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

// Copyright 2006-2007 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_info.cpp#1 $ */ 

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

/* $Change: 832332 $ */

/* $Author: tknoll $ */

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

#include "dng_info.h"

#include "dng_camera_profile.h"

#include "dng_exceptions.h"

#include "dng_globals.h"

#include "dng_host.h"

#include "dng_tag_codes.h"

#include "dng_parse_utils.h"

#include "dng_safe_arithmetic.h"

#include "dng_tag_types.h"

#include "dng_tag_values.h"

#include "dng_utils.h"

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

dng_info::dng_info ()

  : fTIFFBlockOffset         (0)

  , fTIFFBlockOriginalOffset (kDNGStreamInvalidOffset)

  , fBigEndian         (false)

  , fMagic           (0)

  , fExif          ()

  , fShared          ()

  , fMainIndex         (-1)

  , fMaskIndex         (-1)

  , fIFDCount        (0)

  , fChainedIFDCount     (0)

  , fMakerNoteNextIFD    (0)

  {

  }

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

dng_info::~dng_info ()

  {

  }

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

void dng_info::ValidateMagic ()

  {

  switch (fMagic)

    {

    case magicTIFF:

    case magicExtendedProfile:

    case magicRawCache:

    case magicPanasonic:

    case magicOlympusA:

    case magicOlympusB:

      {

      return;

      }

    default:

      {

      #if qDNGValidate

      ReportError ("Invalid TIFF magic number");

      #endif

      ThrowBadFormat ();

      }

    }

  }

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

void dng_info::ParseTag (dng_host &host,

             dng_stream &stream,

             dng_exif *exif,

             dng_shared *shared,

             dng_ifd *ifd,

             uint32 parentCode,

             uint32 tagCode,

             uint32 tagType,

             uint32 tagCount,

             uint64 tagOffset,

             int64 offsetDelta)

  {

  bool isSubIFD = parentCode >= tcFirstSubIFD &&

          parentCode <= tcLastSubIFD;

  bool isMainIFD = (parentCode == 0 || isSubIFD) &&

           ifd &&

           ifd->fUsesNewSubFileType &&

           ifd->fNewSubFileType == sfMainImage;

  // Panasonic RAW format stores private tags using tag codes < 254 in

  // IFD 0.  Redirect the parsing of these tags into a logical

  // "PanasonicRAW" IFD.

  // Panasonic is starting to use some higher numbers also (280..283).

  if (fMagic == 85 && parentCode == 0 && (tagCode < tcNewSubFileType ||

                      (tagCode >= 280 && tagCode <= 283)))

    {

    parentCode = tcPanasonicRAW;

    ifd = NULL;

    }

  stream.SetReadPosition (tagOffset);

  if (ifd && ifd->ParseTag (stream,

                parentCode,

                tagCode,

                tagType,

                tagCount,

                tagOffset))

    {

    return;

    }

  stream.SetReadPosition (tagOffset);

  if (exif && shared && exif->ParseTag (stream,

                      *shared,

                      parentCode,

                      isMainIFD,

                      tagCode,

                      tagType,

                      tagCount,

                      tagOffset))

    {

    return;

    }

  stream.SetReadPosition (tagOffset);

  if (shared && exif && shared->ParseTag (stream,

                      *exif,

                        parentCode,

                        isMainIFD,

                        tagCode,

                        tagType,

                        tagCount,

                        tagOffset,

                        offsetDelta))

    {

    return;

    }

  if (parentCode == tcLeicaMakerNote &&

    tagType == ttUndefined &&

    tagCount >= 14)

    {

    if (ParseMakerNoteIFD (host,

                 stream,

                 tagCount,

                 tagOffset,

                 offsetDelta,

                 tagOffset,

                 stream.Length (),

                 tcLeicaMakerNote))

      {

      return;

      }

    }

  if (parentCode == tcOlympusMakerNote &&

    tagType == ttUndefined &&

    tagCount >= 14)

    {

    uint32 olympusMakerParent = 0;

    switch (tagCode)

      {

      case 8208:

        olympusMakerParent = tcOlympusMakerNote8208;

        break;

      case 8224:

        olympusMakerParent = tcOlympusMakerNote8224;

        break; 

      case 8240:

        olympusMakerParent = tcOlympusMakerNote8240;

        break; 

      case 8256:

        olympusMakerParent = tcOlympusMakerNote8256;

        break; 

      case 8272:

        olympusMakerParent = tcOlympusMakerNote8272;

        break; 

      case 12288:

        olympusMakerParent = tcOlympusMakerNote12288;

        break;

      default:

        break;

      }

    if (olympusMakerParent)

      {

      // Olympus made a mistake in some camera models in computing

      // the size of these sub-tags, so we fudge the count.

      if (ParseMakerNoteIFD (host,

                   stream,

                     stream.Length () - tagOffset,

                         tagOffset,

                         offsetDelta,

                         tagOffset,

                         stream.Length (),

                         olympusMakerParent))

        {

        return;

        }

      }

    }

  if (parentCode == tcRicohMakerNote &&

    tagCode == 0x2001 &&

    tagType == ttUndefined &&

    tagCount > 22)

    {

    char header [20];

    stream.SetReadPosition (tagOffset);

    stream.Get (header, sizeof (header));

    if (memcmp (header, "[Ricoh Camera Info]", 19) == 0)

      {

      ParseMakerNoteIFD (host,

                 stream,

                 tagCount - 20,

                     tagOffset + 20,

                     offsetDelta,

                     tagOffset + 20,

                     tagOffset + tagCount,

                     tcRicohMakerNoteCameraInfo);

      return;

      }

    }

  #if qDNGValidate

    {

    stream.SetReadPosition (tagOffset);

    if (gVerbose)

      {

      printf ("*");

      DumpTagValues (stream,

               LookupTagType (tagType),

               parentCode,

               tagCode,

               tagType,

               tagCount);

      }

    // If type is ASCII, then parse anyway so we report any ASCII

    // NULL termination or character set errors.

    else if (tagType == ttAscii)

      {

      dng_string s;

      ParseStringTag (stream,

              parentCode,

              tagCode,

              tagCount,

              s,

              false);

      }

    }

  #endif

  }

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

bool dng_info::ValidateIFD (dng_stream &stream,

                uint64 ifdOffset,

                int64 offsetDelta)

  {

  // Make sure we have a count.

  if (ifdOffset + 2 > stream.Length ())

    {

    return false;

    }

  // Get entry count.

  stream.SetReadPosition (ifdOffset);

  uint32 ifdEntries = stream.Get_uint16 ();

  if (ifdEntries < 1)

    {

    return false;

    }

  // Make sure we have room for all entries and next IFD link.

  if (ifdOffset + 2 + ifdEntries * 12 + 4 > stream.Length ())

    {

    return false;

    }

  // Check each entry.

  for (uint32 tag_index = 0; tag_index < ifdEntries; tag_index++)

    {

    stream.SetReadPosition (ifdOffset + 2 + tag_index * 12);

    stream.Skip (2);    // Ignore tag code.

    uint32 tagType  = stream.Get_uint16 ();

    uint32 tagCount = stream.Get_uint32 ();

    uint32 tag_type_size = TagTypeSize (tagType);

    if (tag_type_size == 0)

      {

      return false;

      }

    uint32 tag_data_size = SafeUint32Mult(tagCount, tag_type_size);

    if (tag_data_size > 4)

      {

      uint64 tagOffset = stream.Get_uint32 ();

      tagOffset += offsetDelta;

      if (SafeUint64Add(tagOffset, tag_data_size) > stream.Length())

        {

        return false;

        }

      }

    }

  return true;

  }

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

void dng_info::ParseIFD (dng_host &host,

             dng_stream &stream,

             dng_exif *exif,

             dng_shared *shared,

             dng_ifd *ifd,

             uint64 ifdOffset,

             int64 offsetDelta,

             uint32 parentCode)

  {

  #if qDNGValidate

  bool isMakerNote = (parentCode >= tcFirstMakerNoteIFD &&

            parentCode <= tcLastMakerNoteIFD);

  #endif

  stream.SetReadPosition (ifdOffset);

  if (ifd)

    {

    ifd->fThisIFD = ifdOffset;

    }

  uint32 ifdEntries = stream.Get_uint16 ();

  #if qDNGValidate

  if (gVerbose)

    {

    printf ("%s: Offset = %u, Entries = %u\n\n",

        LookupParentCode (parentCode),

          (unsigned) ifdOffset, 

          (unsigned) ifdEntries);

    }

  if ((ifdOffset & 1) && !isMakerNote)

    {

    char message [256];

    sprintf (message,

         "%s has odd offset (%u)",

         LookupParentCode (parentCode),

         (unsigned) ifdOffset);

    ReportWarning (message);

    }

  #endif

  uint32 prev_tag_code = 0;

  for (uint32 tag_index = 0; tag_index < ifdEntries; tag_index++)

    {

    stream.SetReadPosition (ifdOffset + 2 + tag_index * 12);

    uint32 tagCode  = stream.Get_uint16 ();

    uint32 tagType  = stream.Get_uint16 ();

    // Minolta 7D files have a bug in the EXIF block where the count

    // is wrong, and we run off into next IFD link.  So if abort parsing

    // if we get a zero code/type combinations.

    if (tagCode == 0 && tagType == 0)

      {

      #if qDNGValidate

      char message [256];

      sprintf (message,

           "%s had zero/zero tag code/type entry",

           LookupParentCode (parentCode));

      ReportWarning (message);

      #endif

      return;

      }

    uint32 tagCount = stream.Get_uint32 ();

    #if qDNGValidate

      {

      if (tag_index > 0 && tagCode <= prev_tag_code && !isMakerNote)

        {

        char message [256];

        sprintf (message,

             "%s tags are not sorted in ascending numerical order",

             LookupParentCode (parentCode));

        ReportWarning (message);

        }

      }

    #endif

    prev_tag_code = tagCode;

    uint32 tag_type_size = TagTypeSize (tagType);

    if (tag_type_size == 0)

      {

      #if qDNGValidate

        {

        char message [256];

        sprintf (message,

             "%s %s has unknown type (%u)",

             LookupParentCode (parentCode),

             LookupTagCode (parentCode, tagCode),

             (unsigned) tagType);

        ReportWarning (message);

        }

      #endif

      continue;

      }

    uint64 tagOffset = ifdOffset + 2 + tag_index * 12 + 8;

    if (SafeUint32Mult(tagCount, tag_type_size) > 4)

      {

      tagOffset = stream.Get_uint32 ();

      #if qDNGValidate

        {

        if (!(ifdOffset & 1) && 

             (tagOffset & 1) &&

            !isMakerNote     &&

            parentCode != tcKodakDCRPrivateIFD &&

          parentCode != tcKodakKDCPrivateIFD)

          {

          char message [256];

          sprintf (message,

               "%s %s has odd data offset (%u)",

               LookupParentCode (parentCode),

               LookupTagCode (parentCode, tagCode),

               (unsigned) tagOffset);

          ReportWarning (message);

          }

        }

      #endif

      tagOffset += offsetDelta;

      stream.SetReadPosition (tagOffset);

      }

    ParseTag (host,

          stream,

            exif,

          shared,

          ifd,

          parentCode,

          tagCode,

          tagType,

          tagCount,

          tagOffset,

          offsetDelta);

    }

  stream.SetReadPosition (ifdOffset + 2 + ifdEntries * 12);

  uint32 nextIFD = stream.Get_uint32 ();

  #if qDNGValidate

  if (gVerbose)

    {

    printf ("NextIFD = %u\n", (unsigned) nextIFD);

    }

  #endif

  if (ifd)

    {

    ifd->fNextIFD = nextIFD;

    }

  #if qDNGValidate

  if (nextIFD)

    {

    if (parentCode != 0 &&

        (parentCode < tcFirstChainedIFD ||

         parentCode > tcLastChainedIFD  ))

      {

      char message [256];

      sprintf (message,

           "%s has an unexpected non-zero NextIFD (%u)",

           LookupParentCode (parentCode),

           (unsigned) nextIFD);

      ReportWarning (message);

      }

    }

  if (gVerbose)

    {

    printf ("\n");

    }

  #endif

  }

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

bool dng_info::ParseMakerNoteIFD (dng_host &host,

                  dng_stream &stream,

                  uint64 ifdSize,

                  uint64 ifdOffset,

                  int64 offsetDelta,

                  uint64 minOffset,

                  uint64 maxOffset,

                  uint32 parentCode)

  {

  uint32 tagIndex;

  uint32 tagCode;

  uint32 tagType;

  uint32 tagCount;

  // Assume there is no next IFD pointer.

  fMakerNoteNextIFD = 0;

  // If size is too small to hold a single entry IFD, abort.

  if (ifdSize < 14)

    {

    return false;

    }

  // Get entry count.

  stream.SetReadPosition (ifdOffset);

  uint32 ifdEntries = stream.Get_uint16 ();

  // Make the entry count if reasonable for the MakerNote size.

  if (ifdEntries < 1 || 2 + ifdEntries * 12 > ifdSize)

    {

    return false;

    }

  // Scan IFD to verify all the tag types are all valid.

  for (tagIndex = 0; tagIndex < ifdEntries; tagIndex++)

    {

    stream.SetReadPosition (ifdOffset + 2 + tagIndex * 12 + 2);

    tagType = stream.Get_uint16 ();

    // Kludge: Some Canon MakerNotes contain tagType = 0 tags, so we

    // need to ignore them.  This was a "firmware 1.0.4" Canon 40D raw file.

    if (parentCode == tcCanonMakerNote && tagType == 0)

      {

      continue;

      }

    if (TagTypeSize (tagType) == 0)

      {

      return false;

      }

    }

  // OK, the IFD looks reasonable enough to parse.

  #if qDNGValidate

  if (gVerbose)

    {

    printf ("%s: Offset = %u, Entries = %u\n\n",

        LookupParentCode (parentCode),

          (unsigned) ifdOffset, 

          (unsigned) ifdEntries);

    }

  #endif

  for (tagIndex = 0; tagIndex < ifdEntries; tagIndex++)

    {

    stream.SetReadPosition (ifdOffset + 2 + tagIndex * 12);

    tagCode  = stream.Get_uint16 ();

    tagType  = stream.Get_uint16 ();

    tagCount = stream.Get_uint32 ();

    if (tagType == 0)

      {

      continue;

      }

    uint32 tagSize = SafeUint32Mult(tagCount, TagTypeSize (tagType));

    uint64 tagOffset = ifdOffset + 2 + tagIndex * 12 + 8;

    if (tagSize > 4)

      {

      tagOffset = stream.Get_uint32 () + offsetDelta;

      if (tagOffset           < minOffset ||

        SafeUint64Add(tagOffset, tagSize) > maxOffset)

        {

        // Tag data is outside the valid offset range,

        // so ignore this tag.

        continue;

        }

      stream.SetReadPosition (tagOffset);

      }

    // Olympus switched to using IFDs in version 3 makernotes.

    if (parentCode == tcOlympusMakerNote &&

      tagType == ttIFD &&

      tagCount == 1)

      {

      uint32 olympusMakerParent = 0;

      switch (tagCode)

        {

        case 8208:

          olympusMakerParent = tcOlympusMakerNote8208;

          break;

        case 8224:

          olympusMakerParent = tcOlympusMakerNote8224;

          break; 

        case 8240:

          olympusMakerParent = tcOlympusMakerNote8240;

          break; 

        case 8256:

          olympusMakerParent = tcOlympusMakerNote8256;

          break; 

        case 8272:

          olympusMakerParent = tcOlympusMakerNote8272;

          break; 

        case 12288:

          olympusMakerParent = tcOlympusMakerNote12288;

          break;

        default:

          break;

        }

      if (olympusMakerParent)

        {

        stream.SetReadPosition (tagOffset);

        uint64 subMakerNoteOffset = stream.Get_uint32 () + offsetDelta;

        if (subMakerNoteOffset >= minOffset &&

          subMakerNoteOffset <  maxOffset)

          {

          if (ParseMakerNoteIFD (host,

                       stream,

                       maxOffset - subMakerNoteOffset,

                       subMakerNoteOffset,

                       offsetDelta,

                       minOffset,

                       maxOffset,

                       olympusMakerParent))

            {

            continue;

            }

          }

        }

      stream.SetReadPosition (tagOffset);

      }

    ParseTag (host,

          stream,

          fExif.Get (),

          fShared.Get (),

          NULL,

          parentCode,

          tagCode,

          tagType,

          tagCount,

          tagOffset,

          offsetDelta);

    }

  // Grab next IFD pointer, for possible use.

  if (ifdSize >= 2 + ifdEntries * 12 + 4)

    {

    stream.SetReadPosition (ifdOffset + 2 + ifdEntries * 12);

    fMakerNoteNextIFD = stream.Get_uint32 ();

    }

  #if qDNGValidate

  if (gVerbose)

    {

    printf ("\n");

    }

  #endif

  return true;

  }

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

void dng_info::ParseMakerNote (dng_host &host,

                 dng_stream &stream,

                 uint32 makerNoteCount,

                 uint64 makerNoteOffset,

                 int64 offsetDelta,

                 uint64 minOffset,

                 uint64 maxOffset)

  {

  uint8 firstBytes [16];

  memset (firstBytes, 0, sizeof (firstBytes));

  stream.SetReadPosition (makerNoteOffset);

  stream.Get (firstBytes, (uint32) Min_uint64 (sizeof (firstBytes),

                         makerNoteCount));

  // Epson MakerNote with header.

  if (memcmp (firstBytes, "EPSON\000\001\000", 8) == 0)

    {

    if (makerNoteCount > 8)

      {

      ParseMakerNoteIFD (host,

                 stream,

                 makerNoteCount - 8,

                     makerNoteOffset + 8,

                     offsetDelta,

                     minOffset,

                     maxOffset,

                     tcEpsonMakerNote);

      }

    return;

    }

  // Fujifilm MakerNote.

  if (memcmp (firstBytes, "FUJIFILM", 8) == 0)

    {

    stream.SetReadPosition (makerNoteOffset + 8);

    TempLittleEndian tempEndian (stream);

    uint32 ifd_offset = stream.Get_uint32 ();

    if (ifd_offset >= 12 && ifd_offset < makerNoteCount)

      {

      ParseMakerNoteIFD (host,

                 stream,

                 makerNoteCount - ifd_offset,

                 makerNoteOffset + ifd_offset,

                 makerNoteOffset,

                 minOffset,

                 maxOffset,

                 tcFujiMakerNote);

      }

    return;

    }

  // Leica MakerNote for models that store entry offsets relative to the start of

  // the MakerNote (e.g., M9).

  if ((memcmp (firstBytes, "LEICA\000\000\000", 8) == 0) ||

    (memcmp (firstBytes, "LEICA0\003\000",    8) == 0) ||

    (memcmp (firstBytes, "LEICA\000\001\000", 8) == 0) ||

    (memcmp (firstBytes, "LEICA\000\005\000", 8) == 0))

    {

    if (makerNoteCount > 8)

      {

      ParseMakerNoteIFD (host,

                 stream,

                 makerNoteCount - 8,

                 makerNoteOffset + 8,

                 makerNoteOffset,

                 minOffset,

                 maxOffset,

                 tcLeicaMakerNote);

      }

    return;

    }

  // Leica MakerNote for models that store absolute entry offsets (i.e., relative

  // to the start of the file, e.g., S2).

  if (memcmp (firstBytes, "LEICA\000\002\377", 8) == 0)

    {

    if (makerNoteCount > 8)

      {

      ParseMakerNoteIFD (host,

                 stream,

                 makerNoteCount - 8,

                 makerNoteOffset + 8,

                 offsetDelta,

                 minOffset,

                 maxOffset,

                 tcLeicaMakerNote);

      }

    return;

    }

  // Nikon version 2 MakerNote with header.

  if (memcmp (firstBytes, "Nikon\000\002", 7) == 0)

    {

    stream.SetReadPosition (makerNoteOffset + 10);

    bool bigEndian = false;

    uint16 endianMark = stream.Get_uint16 ();

    if (endianMark == byteOrderMM)

      {

      bigEndian = true;

      }

    else if (endianMark != byteOrderII)

      {

      return;

      }

    TempBigEndian temp_endian (stream, bigEndian);

    uint16 magic = stream.Get_uint16 ();

    if (magic != 42)

      {

      return;

      }

    uint32 ifd_offset = stream.Get_uint32 ();

    if (ifd_offset >= 8 && ifd_offset < makerNoteCount - 10)

      {

      ParseMakerNoteIFD (host,

                 stream,

                 makerNoteCount - 10 - ifd_offset,

                 makerNoteOffset + 10 + ifd_offset,

                 makerNoteOffset + 10,

                 minOffset,

                 maxOffset,

                 tcNikonMakerNote);

      }

    return;

    }

  // Newer version of Olympus MakerNote with byte order mark.

  if (memcmp (firstBytes, "OLYMPUS\000", 8) == 0)

    {

    stream.SetReadPosition (makerNoteOffset + 8);

    bool bigEndian = false;

    uint16 endianMark = stream.Get_uint16 ();