/*****************************************************************************/

// Copyright 2006-2008 Adobe Systems Incorporated

// All Rights Reserved.

//

// NOTICE:  Adobe permits you to use, modify, and distribute this file in

// accordance with the terms of the Adobe license agreement accompanying it.

/*****************************************************************************/

/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_exif.cpp#1 $ */ 

/* $DateTime: 2012/05/30 13:28:51 $ */

/* $Change: 832332 $ */

/* $Author: tknoll $ */

/*****************************************************************************/

#include "dng_exif.h"

#include "dng_tag_codes.h"

#include "dng_tag_types.h"

#include "dng_parse_utils.h"

#include "dng_globals.h"

#include "dng_exceptions.h"

#include "dng_tag_values.h"

#include "dng_utils.h"

/*****************************************************************************/

dng_exif::dng_exif ()

  : fImageDescription ()

  , fMake             ()

  , fModel            ()

  , fSoftware         ()

  , fArtist           ()

  , fCopyright        ()

  , fCopyright2       ()

  , fUserComment      ()

  , fDateTime            ()

  , fDateTimeStorageInfo ()

  , fDateTimeOriginal  ()

  , fDateTimeOriginalStorageInfo ()

  , fDateTimeDigitized ()

  , fDateTimeDigitizedStorageInfo ()

  , fTIFF_EP_StandardID (0)

  , fExifVersion        (0)

  , fFlashPixVersion  (0)

  , fExposureTime      ()

  , fFNumber           ()

  , fShutterSpeedValue ()

  , fApertureValue     ()

  , fBrightnessValue   ()

  , fExposureBiasValue ()

  , fMaxApertureValue  ()

  , fFocalLength       ()

  , fDigitalZoomRatio  ()

  , fExposureIndex     ()

  , fSubjectDistance   ()

  , fGamma             ()

  , fBatteryLevelR ()

  , fBatteryLevelA ()

  , fExposureProgram      (0xFFFFFFFF)

  , fMeteringMode         (0xFFFFFFFF)

  , fLightSource          (0xFFFFFFFF)

  , fFlash            (0xFFFFFFFF)

  , fFlashMask        (0x0000FFFF)

  , fSensingMethod        (0xFFFFFFFF)

  , fColorSpace           (0xFFFFFFFF)

  , fFileSource           (0xFFFFFFFF)

  , fSceneType          (0xFFFFFFFF)

  , fCustomRendered       (0xFFFFFFFF)

  , fExposureMode       (0xFFFFFFFF)

  , fWhiteBalance         (0xFFFFFFFF)

  , fSceneCaptureType     (0xFFFFFFFF)

  , fGainControl      (0xFFFFFFFF)

  , fContrast         (0xFFFFFFFF)

  , fSaturation       (0xFFFFFFFF)

  , fSharpness        (0xFFFFFFFF)

  , fSubjectDistanceRange (0xFFFFFFFF)

  , fSelfTimerMode      (0xFFFFFFFF)

  , fImageNumber      (0xFFFFFFFF)

  , fFocalLengthIn35mmFilm (0)

  , fSensitivityType       (0)

  , fStandardOutputSensitivity (0)

  , fRecommendedExposureIndex  (0)

  , fISOSpeed          (0)

  , fISOSpeedLatitudeyyy     (0)

  , fISOSpeedLatitudezzz     (0)

  , fSubjectAreaCount (0)

  , fComponentsConfiguration (0)

  , fCompresssedBitsPerPixel ()

  , fPixelXDimension (0)

  , fPixelYDimension (0)

  , fFocalPlaneXResolution ()

  , fFocalPlaneYResolution ()

  , fFocalPlaneResolutionUnit (0xFFFFFFFF)

  , fCFARepeatPatternRows (0)

  , fCFARepeatPatternCols (0)

  , fImageUniqueID ()

  , fGPSVersionID     (0)

  , fGPSLatitudeRef     ()

  , fGPSLongitudeRef    ()

  , fGPSAltitudeRef     (0xFFFFFFFF)

  , fGPSAltitude      ()

  , fGPSSatellites      ()

  , fGPSStatus        ()

  , fGPSMeasureMode     ()

  , fGPSDOP         ()

  , fGPSSpeedRef      ()

  , fGPSSpeed       ()

  , fGPSTrackRef      ()

  , fGPSTrack       ()

  , fGPSImgDirectionRef   ()

  , fGPSImgDirection    ()

  , fGPSMapDatum      ()

  , fGPSDestLatitudeRef   ()

  , fGPSDestLongitudeRef  ()

  , fGPSDestBearingRef    ()

  , fGPSDestBearing     ()

  , fGPSDestDistanceRef   ()

  , fGPSDestDistance    ()

  , fGPSProcessingMethod  ()

  , fGPSAreaInformation   ()

  , fGPSDateStamp     ()

  , fGPSDifferential    (0xFFFFFFFF)

  , fGPSHPositioningError ()

  , fInteroperabilityIndex ()

  , fInteroperabilityVersion (0)

  , fRelatedImageFileFormat ()

  , fRelatedImageWidth  (0)

  , fRelatedImageLength (0)

  , fCameraSerialNumber ()

  , fLensID       ()

  , fLensMake     ()

  , fLensName     ()

  , fLensSerialNumber ()

  , fLensNameWasReadFromExif (false)

  , fApproxFocusDistance ()

  , fFlashCompensation ()

  , fOwnerName ()

  , fFirmware  ()

  {

  uint32 j;

  uint32 k;

  fISOSpeedRatings [0] = 0;

  fISOSpeedRatings [1] = 0;

  fISOSpeedRatings [2] = 0;

  for (j = 0; j < kMaxCFAPattern; j++)

    for (k = 0; k < kMaxCFAPattern; k++)

      {

      fCFAPattern [j] [k] = 255;

      }

  }

/*****************************************************************************/

dng_exif::~dng_exif ()

  {

  }

/*****************************************************************************/

dng_exif * dng_exif::Clone () const

  {

  dng_exif *result = new dng_exif (*this);

  if (!result)

    {

    ThrowMemoryFull ();

    }

  return result;

  }

/*****************************************************************************/

void dng_exif::SetEmpty ()

  {

  *this = dng_exif ();

  }

/*****************************************************************************/

void dng_exif::CopyGPSFrom (const dng_exif &exif)

  {

  fGPSVersionID         = exif.fGPSVersionID;

  fGPSLatitudeRef       = exif.fGPSLatitudeRef;

  fGPSLatitude [0]    = exif.fGPSLatitude [0];

  fGPSLatitude [1]    = exif.fGPSLatitude [1];

  fGPSLatitude [2]    = exif.fGPSLatitude [2];

  fGPSLongitudeRef      = exif.fGPSLongitudeRef;

  fGPSLongitude [0]   = exif.fGPSLongitude [0];

  fGPSLongitude [1]   = exif.fGPSLongitude [1];

  fGPSLongitude [2]   = exif.fGPSLongitude [2];

  fGPSAltitudeRef       = exif.fGPSAltitudeRef;

  fGPSAltitude          = exif.fGPSAltitude;

  fGPSTimeStamp [0]     = exif.fGPSTimeStamp [0];

  fGPSTimeStamp [1]     = exif.fGPSTimeStamp [1];

  fGPSTimeStamp [2]     = exif.fGPSTimeStamp [2];

  fGPSSatellites        = exif.fGPSSatellites;

  fGPSStatus            = exif.fGPSStatus;

  fGPSMeasureMode       = exif.fGPSMeasureMode;

  fGPSDOP               = exif.fGPSDOP;

  fGPSSpeedRef          = exif.fGPSSpeedRef;

  fGPSSpeed             = exif.fGPSSpeed;

  fGPSTrackRef          = exif.fGPSTrackRef;

  fGPSTrack             = exif.fGPSTrack;

  fGPSImgDirectionRef   = exif.fGPSImgDirectionRef;

  fGPSImgDirection      = exif.fGPSImgDirection;

  fGPSMapDatum          = exif.fGPSMapDatum;

  fGPSDestLatitudeRef   = exif.fGPSDestLatitudeRef;

  fGPSDestLatitude [0]  = exif.fGPSDestLatitude [0];

  fGPSDestLatitude [1]  = exif.fGPSDestLatitude [1];

  fGPSDestLatitude [2]  = exif.fGPSDestLatitude [2];

  fGPSDestLongitudeRef  = exif.fGPSDestLongitudeRef;

  fGPSDestLongitude [0] = exif.fGPSDestLongitude [0];

  fGPSDestLongitude [1] = exif.fGPSDestLongitude [1];

  fGPSDestLongitude [2] = exif.fGPSDestLongitude [2];

  fGPSDestBearingRef    = exif.fGPSDestBearingRef;

  fGPSDestBearing       = exif.fGPSDestBearing;

  fGPSDestDistanceRef   = exif.fGPSDestDistanceRef;

  fGPSDestDistance      = exif.fGPSDestDistance;

  fGPSProcessingMethod  = exif.fGPSProcessingMethod;

  fGPSAreaInformation   = exif.fGPSAreaInformation;

  fGPSDateStamp         = exif.fGPSDateStamp;

  fGPSDifferential      = exif.fGPSDifferential;

  fGPSHPositioningError = exif.fGPSHPositioningError;

  }

/*****************************************************************************/

// Fix up common errors and rounding issues with EXIF exposure times.

real64 dng_exif::SnapExposureTime (real64 et)

  {

  // Protection against invalid values.

  if (et <= 0.0)

    return 0.0;

  // If near a standard shutter speed, snap to it.

  static const real64 kStandardSpeed [] =

    {

    30.0,

    25.0,

    20.0,

    15.0,

    13.0,

    10.0,

    8.0,

    6.0,

    5.0,

    4.0,

    3.2,

    3.0,

    2.5,

    2.0,

    1.6,

    1.5,

    1.3,

    1.0,

    0.8,

    0.7,

    0.6,

    0.5,

    0.4,

    0.3,

    1.0 / 4.0,

    1.0 / 5.0,

    1.0 / 6.0,

    1.0 / 8.0,

    1.0 / 10.0,

    1.0 / 13.0,

    1.0 / 15.0,

    1.0 / 20.0,

    1.0 / 25.0,

    1.0 / 30.0,

    1.0 / 40.0,

    1.0 / 45.0,

    1.0 / 50.0,

    1.0 / 60.0,

    1.0 / 80.0,

    1.0 / 90.0,

    1.0 / 100.0,

    1.0 / 125.0,

    1.0 / 160.0,

    1.0 / 180.0,

    1.0 / 200.0,

    1.0 / 250.0,

    1.0 / 320.0,

    1.0 / 350.0,

    1.0 / 400.0,

    1.0 / 500.0,

    1.0 / 640.0,

    1.0 / 750.0,

    1.0 / 800.0,

    1.0 / 1000.0,

    1.0 / 1250.0,

    1.0 / 1500.0,

    1.0 / 1600.0,

    1.0 / 2000.0,

    1.0 / 2500.0,

    1.0 / 3000.0,

    1.0 / 3200.0,

    1.0 / 4000.0,

    1.0 / 5000.0,

    1.0 / 6000.0,

    1.0 / 6400.0,

    1.0 / 8000.0,

    1.0 / 10000.0,

    1.0 / 12000.0,

    1.0 / 12800.0,

    1.0 / 16000.0

    };

  uint32 count = sizeof (kStandardSpeed    ) /

           sizeof (kStandardSpeed [0]);

  for (uint32 fudge = 0; fudge <= 1; fudge++)

    {

    real64 testSpeed = et;

    if (fudge == 1)

      {

      // Often APEX values are rounded to a power of two,

      // which results in non-standard shutter speeds.

      if (et >= 0.1)

        {

        // No fudging slower than 1/10 second

        break;

        }

      else if (et >= 0.01)

        {

        // Between 1/10 and 1/100 the commonly misrounded

        // speeds are 1/15, 1/30, 1/60, which are often encoded as

        // 1/16, 1/32, 1/64.  Try fudging and see if we get

        // near a standard speed.

        testSpeed *= 16.0 / 15.0;

        }

      else

        {

        // Faster than 1/100, the commonly misrounded

        // speeds are 1/125, 1/250, 1/500, etc., which

        // are often encoded as 1/128, 1/256, 1/512.

        testSpeed *= 128.0 / 125.0;

        }

      }

    for (uint32 index = 0; index < count; index++)

      {

      if (testSpeed >= kStandardSpeed [index] * 0.98 &&

        testSpeed <= kStandardSpeed [index] * 1.02)

        {

        return kStandardSpeed [index];

        }

      }

    }

  // We are not near any standard speeds.  Round the non-standard value to something

  // that looks reasonable.

  if (et >= 10.0)

    {

    // Round to nearest second.

    et = floor (et + 0.5);

    }

  else if (et >= 0.5)

    {

    // Round to nearest 1/10 second

    et = floor (et * 10.0 + 0.5) * 0.1;

    }

  else if (et >= 1.0 / 20.0)

    {

    // Round to an exact inverse.

    et = 1.0 / floor (1.0 / et + 0.5);

    }

  else if (et >= 1.0 / 130.0)

    {

    // Round inverse to multiple of 5

    et = 0.2 / floor (0.2 / et + 0.5);

    }

  else if (et >= 1.0 / 750.0)

    {

    // Round inverse to multiple of 10

    et = 0.1 / floor (0.1 / et + 0.5);

    }

  else if (et >= 1.0 / 1300.0)

    {

    // Round inverse to multiple of 50

    et = 0.02 / floor (0.02 / et + 0.5);

    }

  else if (et >= 1.0 / 15000.0)

    {

    // Round inverse to multiple of 100

    et = 0.01 / floor (0.01 / et + 0.5);

    }

  else

    {

    // Round inverse to multiple of 1000

    et = 0.001 / floor (0.001 / et + 0.5);

    }

  return et;

  }

/*****************************************************************************/

void dng_exif::SetExposureTime (real64 et, bool snap)

  {

  fExposureTime.Clear ();

  fShutterSpeedValue.Clear ();

  if (snap)

    {

    et = SnapExposureTime (et);

    }

  if (et >= 1.0 / 32768.0 && et <= 32768.0)

    {

    if (et >= 100.0)

      {

      fExposureTime.Set_real64 (et, 1);

      }

    else if (et >= 1.0)

      {

      fExposureTime.Set_real64 (et, 10);

      fExposureTime.ReduceByFactor (10);

      }

    else if (et <= 0.1)

      {

      fExposureTime = dng_urational (1, Round_uint32 (1.0 / et));

      }

    else

      {

      fExposureTime.Set_real64 (et, 100);

      fExposureTime.ReduceByFactor (10);

      for (uint32 f = 2; f <= 9; f++)

        {

        real64 z = 1.0 / (real64) f / et;

        if (z >= 0.99 && z <= 1.01)

          {

          fExposureTime = dng_urational (1, f);

          break;

          }

        }

      }

    // Now mirror this value to the ShutterSpeedValue field.

    et = fExposureTime.As_real64 ();

    fShutterSpeedValue.Set_real64 (-log (et) / log (2.0), 1000000);

    fShutterSpeedValue.ReduceByFactor (10);                 

    fShutterSpeedValue.ReduceByFactor (10);                 

    fShutterSpeedValue.ReduceByFactor (10);                 

    fShutterSpeedValue.ReduceByFactor (10);                 

    fShutterSpeedValue.ReduceByFactor (10);                 

    fShutterSpeedValue.ReduceByFactor (10);                 

    }

  }

/*****************************************************************************/

void dng_exif::SetShutterSpeedValue (real64 ss)

  {

  if (fExposureTime.NotValid ())

    {

    real64 et = pow (2.0, -ss);

    SetExposureTime (et, true);

    }

  }

/******************************************************************************/

dng_urational dng_exif::EncodeFNumber (real64 fs)

  {

  dng_urational y;

  if (fs > 10.0)

    {

    y.Set_real64 (fs, 1);

    }

  else if (fs < 1.0)

    {

    y.Set_real64 (fs, 100);

    y.ReduceByFactor (10);

    y.ReduceByFactor (10);

    }

  else

    {

    y.Set_real64 (fs, 10);

    y.ReduceByFactor (10);

    }

  return y;

  }

/*****************************************************************************/

void dng_exif::SetFNumber (real64 fs)

  {

  fFNumber.Clear ();

  fApertureValue.Clear ();

  // Allow f-number values less than 1.0 (e.g., f/0.95), even though they would

  // correspond to negative APEX values, which the EXIF specification does not

  // support (ApertureValue is a rational, not srational). The ApertureValue tag

  // will be omitted in the case where fs < 1.0.

  if (fs > 0.0 && fs <= 32768.0)

    {

    fFNumber = EncodeFNumber (fs);

    // Now mirror this value to the ApertureValue field.

    real64 av = FNumberToApertureValue (fFNumber);

    if (av >= 0.0 && av <= 99.99)

      {

      fApertureValue.Set_real64 (av, 1000000);

      fApertureValue.ReduceByFactor (10);                 

      fApertureValue.ReduceByFactor (10);                 

      fApertureValue.ReduceByFactor (10);                 

      fApertureValue.ReduceByFactor (10);                 

      fApertureValue.ReduceByFactor (10);                 

      fApertureValue.ReduceByFactor (10);                 

      }

    }

  }

/*****************************************************************************/

void dng_exif::SetApertureValue (real64 av)

  {

  if (fFNumber.NotValid ())

    {

    SetFNumber (ApertureValueToFNumber (av));

    }

  }

/*****************************************************************************/

real64 dng_exif::ApertureValueToFNumber (real64 av)

  {

  return pow (2.0, 0.5 * av);

  }

/*****************************************************************************/

real64 dng_exif::ApertureValueToFNumber (const dng_urational &av)

  {

  return ApertureValueToFNumber (av.As_real64 ());

  }

/*****************************************************************************/

real64 dng_exif::FNumberToApertureValue (real64 fNumber)

  {

  return 2.0 * log (fNumber) / log (2.0);

  }

/*****************************************************************************/

real64 dng_exif::FNumberToApertureValue (const dng_urational &fNumber)

  {

  return FNumberToApertureValue (fNumber.As_real64 ());

  }

/*****************************************************************************/

void dng_exif::UpdateDateTime (const dng_date_time_info &dt)

  {

  fDateTime = dt;

  }

/*****************************************************************************/

bool dng_exif::AtLeastVersion0230 () const

  {

  uint32 b0 = (fExifVersion >> 24) & 0xff;

  uint32 b1 = (fExifVersion >> 16) & 0xff;

  uint32 b2 = (fExifVersion >>  8) & 0xff;

  return (b0 > 0) || (b1 >= 2 && b2 >= 3);

  }

/*****************************************************************************/

bool dng_exif::ParseTag (dng_stream &stream,

             dng_shared &shared,

             uint32 parentCode,

             bool isMainIFD,

             uint32 tagCode,

             uint32 tagType,

             uint32 tagCount,

             uint64 tagOffset)

  {

  if (parentCode == 0)

    {

    if (Parse_ifd0 (stream,

            shared,

            parentCode,

            tagCode,

            tagType,

            tagCount,

            tagOffset))

      {

      return true;

      }

    }

  if (parentCode == 0 || isMainIFD)

    {

    if (Parse_ifd0_main (stream,

                 shared,

               parentCode,

               tagCode,

               tagType,

               tagCount,

               tagOffset))

      {

      return true;

      }

    }

  if (parentCode == 0 ||

    parentCode == tcExifIFD)

    {

    if (Parse_ifd0_exif (stream,

                 shared,

               parentCode,

               tagCode,

               tagType,

               tagCount,

               tagOffset))

      {

      return true;

      }

    }

  if (parentCode == tcGPSInfo)

    {

    if (Parse_gps (stream,

             shared,

             parentCode,

             tagCode,

             tagType,

             tagCount,

             tagOffset))

      {

      return true;

      }

    }

  if (parentCode == tcInteroperabilityIFD)

    {

    if (Parse_interoperability (stream,

                    shared,

                  parentCode,

                  tagCode,

                  tagType,

                  tagCount,

                  tagOffset))

      {

      return true;

      }

    }

  return false;

  }

/*****************************************************************************/

// Parses tags that should only appear in IFD 0.

bool dng_exif::Parse_ifd0 (dng_stream &stream,

                 dng_shared & /* shared */,

               uint32 parentCode,

               uint32 tagCode,

               uint32 tagType,

               uint32 tagCount,

               uint64 /* tagOffset */)

  {

  switch (tagCode)

    {

    case tcImageDescription:

      {

      CheckTagType (parentCode, tagCode, tagType, ttAscii);

      ParseStringTag (stream,

              parentCode,

              tagCode,

              tagCount,

              fImageDescription);

      #if qDNGValidate

      if (gVerbose)

        {

        printf ("ImageDescription: ");

        DumpString (fImageDescription);

        printf ("\n");

        }

      #endif

      break;

      }

    case tcMake:

      {

      CheckTagType (parentCode, tagCode, tagType, ttAscii);

      ParseStringTag (stream,

              parentCode,

              tagCode,

              tagCount,

              fMake);

      #if qDNGValidate

      if (gVerbose)

        {

        printf ("Make: ");

        DumpString (fMake);

        printf ("\n");

        }

      #endif

      break;

      }

    case tcModel:

      {

      CheckTagType (parentCode, tagCode, tagType, ttAscii);

      ParseStringTag (stream,

              parentCode,

              tagCode,

              tagCount,

              fModel);

      #if qDNGValidate

      if (gVerbose)

        {

        printf ("Model: ");

        DumpString (fModel);

        printf ("\n");

        }

      #endif

      break;

      }

    case tcSoftware:

      {

      CheckTagType (parentCode, tagCode, tagType, ttAscii);

      ParseStringTag (stream,

              parentCode,

              tagCode,

              tagCount,

              fSoftware);

      #if qDNGValidate

      if (gVerbose)

        {

        printf ("Software: ");

        DumpString (fSoftware);

        printf ("\n");

        }

      #endif

      break;

      }

    case tcDateTime:

      {

      uint64 tagPosition = stream.PositionInOriginalFile ();

      dng_date_time dt;

      if (!ParseDateTimeTag (stream,

                   parentCode,

                   tagCode,

                   tagType,

                   tagCount,

                   dt))

        {

        return false;

        }

      fDateTime.SetDateTime (dt);

      fDateTimeStorageInfo = dng_date_time_storage_info (tagPosition,

                                 dng_date_time_format_exif);

      #if qDNGValidate

      if (gVerbose)

        {

        printf ("DateTime: ");

        DumpDateTime (fDateTime.DateTime ());

        printf ("\n");

        }

      #endif

      break;

      }

    case tcArtist:

      {

      CheckTagType (parentCode, tagCode, tagType, ttAscii);

      ParseStringTag (stream,

              parentCode,

              tagCode,

              tagCount,

              fArtist);

      #if qDNGValidate

      if (gVerbose)

        {

        printf ("Artist: ");

        DumpString (fArtist);

        printf ("\n");

        }

      #endif

      break;