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

// Copyright 2006-2012 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_ifd.cpp#3 $ */ 

/* $DateTime: 2012/06/05 11:05:39 $ */

/* $Change: 833352 $ */

/* $Author: tknoll $ */

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

#include "dng_ifd.h"

#include "dng_exceptions.h"

#include "dng_flags.h"

#include "dng_globals.h"

#include "dng_ifd.h"

#include "dng_types.h"

#include "dng_parse_utils.h"

#include "dng_read_image.h"

#include "dng_stream.h"

#include "dng_tag_codes.h"

#include "dng_tag_types.h"

#include "dng_tag_values.h"

#include "dng_utils.h"

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

dng_preview_info::dng_preview_info ()

  : fIsPrimary          (true)

  , fApplicationName    ()

  , fApplicationVersion ()

  , fSettingsName       ()

  , fSettingsDigest     ()

  , fColorSpace     (previewColorSpace_MaxEnum)

  , fDateTime     ()

  , fRawToPreviewGain   (1.0)

  , fCacheVersion   (0)

  {

  }

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

dng_preview_info::~dng_preview_info ()

  {

  }

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

dng_ifd::dng_ifd ()

  : fUsesNewSubFileType (false)

  , fNewSubFileType     (0)

  , fImageWidth  (0)

  , fImageLength (0)

  , fCompression (ccUncompressed)

  , fPredictor   (cpNullPredictor)

  , fPhotometricInterpretation (0xFFFFFFFF)

  , fFillOrder (1)

  , fOrientation          (0)

  , fOrientationType      (0)

  , fOrientationOffset    (kDNGStreamInvalidOffset)

  , fOrientationBigEndian (false)

  , fSamplesPerPixel (1)

  , fPlanarConfiguration (pcInterleaved)

  , fXResolution    (0.0)

  , fYResolution    (0.0)

  , fResolutionUnit (0)

  , fUsesStrips (false)

  , fUsesTiles  (false)

  , fTileWidth  (0)

  , fTileLength (0)

  , fTileOffsetsType   (0)

  , fTileOffsetsCount  (0)

  , fTileOffsetsOffset (0)

  , fTileByteCountsType   (0)

  , fTileByteCountsCount  (0)

  , fTileByteCountsOffset (0)

  , fSubIFDsCount  (0)

  , fSubIFDsOffset (0)

  , fExtraSamplesCount (0)

  , fJPEGTablesCount  (0)

  , fJPEGTablesOffset (0)

  , fJPEGInterchangeFormat     (0)

  , fJPEGInterchangeFormatLength (0)

  , fYCbCrCoefficientR (0.0)

  , fYCbCrCoefficientG (0.0)

  , fYCbCrCoefficientB (0.0)

  , fYCbCrSubSampleH (0)

  , fYCbCrSubSampleV (0)

  , fYCbCrPositioning (0)

  , fCFARepeatPatternRows (0)

  , fCFARepeatPatternCols (0)

  , fCFALayout (1)

  , fLinearizationTableType   (0)

  , fLinearizationTableCount  (0)

  , fLinearizationTableOffset (0)

  , fBlackLevelRepeatRows (1)

  , fBlackLevelRepeatCols (1)

  , fBlackLevelDeltaHType   (0)

  , fBlackLevelDeltaHCount  (0)

  , fBlackLevelDeltaHOffset (0)

  , fBlackLevelDeltaVType   (0)

  , fBlackLevelDeltaVCount  (0)

  , fBlackLevelDeltaVOffset (0)

  , fDefaultScaleH (1, 1)

  , fDefaultScaleV (1, 1)

  , fBestQualityScale (1, 1)

  , fDefaultCropOriginH (0, 1)

  , fDefaultCropOriginV (0, 1)

  , fDefaultCropSizeH ()

  , fDefaultCropSizeV ()

  , fDefaultUserCropT (0, 1)

  , fDefaultUserCropL (0, 1)

  , fDefaultUserCropB (1, 1)

  , fDefaultUserCropR (1, 1)

  , fBayerGreenSplit (0)

  , fChromaBlurRadius ()

  , fAntiAliasStrength (1, 1)

  , fActiveArea ()

  , fMaskedAreaCount (0)

  , fRowInterleaveFactor (1)

  , fSubTileBlockRows (1)

  , fSubTileBlockCols (1)

  , fPreviewInfo ()

  , fOpcodeList1Count  (0)

  , fOpcodeList1Offset (0)

  , fOpcodeList2Count  (0)

  , fOpcodeList2Offset (0)

  , fOpcodeList3Count  (0)

  , fOpcodeList3Offset (0)

  , fLosslessJPEGBug16 (false)

  , fSampleBitShift (0)

  , fThisIFD (0)

  , fNextIFD (0)

  , fCompressionQuality (-1)

  , fPatchFirstJPEGByte (false)

  {

  uint32 j;

  uint32 k;

  uint32 n;

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

    {

    fBitsPerSample [j] = 0;

    }

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

    {

    fTileOffset    [j] = 0;

    fTileByteCount [j] = 0;

    }

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

    {

    fExtraSamples [j] = esUnspecified;

    }

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

    {

    fSampleFormat [j] = sfUnsignedInteger;

    }

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

    {

    fReferenceBlackWhite [j] = 0.0;

    }

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

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

      {

      fCFAPattern [j] [k] = 255;

      }

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

    {

    fCFAPlaneColor [j] = (uint8) (j < 3 ? j : 255);

    }

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

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

      for (n = 0; n < kMaxSamplesPerPixel; n++)

        {

        fBlackLevel [j] [k] [n] = 0.0;

        }

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

    {

    fWhiteLevel [j] = -1.0;   // Don't know real default yet.

    }

  }

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

dng_ifd::~dng_ifd ()

  {

  }

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

// Parses tags that should only appear in IFDs that contain images.

bool dng_ifd::ParseTag (dng_stream &stream,

            uint32 parentCode,

            uint32 tagCode,

            uint32 tagType,

            uint32 tagCount,

            uint64 tagOffset)

  {

  uint32 j;

  uint32 k;

  uint32 n;

  switch (tagCode)

    {

    case tcNewSubFileType:

      {

      CheckTagType (parentCode, tagCode, tagType, ttLong);

      CheckTagCount (parentCode, tagCode, tagCount, 1);

      fUsesNewSubFileType = true;

      fNewSubFileType = stream.TagValue_uint32 (tagType);

      fPreviewInfo.fIsPrimary = (fNewSubFileType == sfPreviewImage);

      #if qDNGValidate

      if (gVerbose)

        {

        printf ("NewSubFileType: %s\n",

            LookupNewSubFileType (fNewSubFileType));

        }

      #endif

      break;

      }

    case tcImageWidth:

      {

      CheckTagType (parentCode, tagCode, tagType, ttShort, ttLong);

      CheckTagCount (parentCode, tagCode, tagCount, 1);

      fImageWidth = stream.TagValue_uint32 (tagType);

      #if qDNGValidate

      if (gVerbose)

        {

        printf ("ImageWidth: %u\n", (unsigned) fImageWidth);

        }

      #endif

      break;

      }

    case tcImageLength:

      {

      CheckTagType (parentCode, tagCode, tagType, ttShort, ttLong);

      CheckTagCount (parentCode, tagCode, tagCount, 1);

      fImageLength = stream.TagValue_uint32 (tagType);

      #if qDNGValidate

      if (gVerbose)

        {

        printf ("ImageLength: %u\n", (unsigned) fImageLength);

        }

      #endif

      break;

      }

    case tcBitsPerSample:

      {

      CheckTagType (parentCode, tagCode, tagType, ttShort);

      CheckTagCount (parentCode, tagCode, tagCount, 1, 0x0FFFF);

      #if qDNGValidate

      if (gVerbose)

        {

        printf ("BitsPerSample:");

        }

      #endif

      bool extrasMatch = true;

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

        {

        uint32 x = stream.TagValue_uint32 (tagType);

        const uint32 maxBitsPerSample = 32;

        if (j < kMaxSamplesPerPixel)

          {

          if (x > maxBitsPerSample)

            {

            ThrowBadFormat ("BitsPerSample out of bounds.");

            }

          fBitsPerSample [j] = x;

          }

        else if (x != fBitsPerSample [kMaxSamplesPerPixel - 1])

          {

          extrasMatch = false;

          }

        #if qDNGValidate

        if (gVerbose)

          {

          printf (" %u", (unsigned) x);

          }

        #endif

        }

      #if qDNGValidate

      if (gVerbose)

        {

        printf ("\n");

        }

      #endif

      if (!extrasMatch)

        {

        #if qDNGValidate

        ReportError ("BitsPerSample not constant");

        #endif

        ThrowBadFormat ();

        }

      break;

      }

    case tcCompression:

      {

      CheckTagType (parentCode, tagCode, tagType, ttShort);

      CheckTagCount (parentCode, tagCode, tagCount, 1);

      fCompression = stream.TagValue_uint32 (tagType);

      #if qDNGValidate

      if (gVerbose)

        {

        printf ("Compression: %s\n",

              LookupCompression (fCompression));

        }

      #endif

      // Correct a common TIFF writer mistake.

      if (fCompression == 0)

        {

        #if qDNGValidate

          {

          char message [256];

          sprintf (message,

               "%s has invalid zero compression code",

               LookupParentCode (parentCode));

          ReportWarning (message);

          }

        #endif

        fCompression = ccUncompressed;

        }

      break;

      }

    case tcPhotometricInterpretation:

      {

      CheckTagType (parentCode, tagCode, tagType, ttShort);

      CheckTagCount (parentCode, tagCode, tagCount, 1);

      fPhotometricInterpretation = stream.TagValue_uint32 (tagType);

      #if qDNGValidate

      if (gVerbose)

        {

        printf ("PhotometricInterpretation: %s\n",

            LookupPhotometricInterpretation (fPhotometricInterpretation));

        }

      #endif

      break;

      }

    case tcFillOrder:

      {

      CheckTagType (parentCode, tagCode, tagType, ttShort);

      CheckTagCount (parentCode, tagCode, tagCount, 1);

      fFillOrder = stream.TagValue_uint32 (tagType);

      #if qDNGValidate

      if (gVerbose)

        {

        printf ("FillOrder: %u\n", (unsigned) fFillOrder);

        }

      #endif

      break;

      }

    case tcStripOffsets:

      {

      CheckTagType (parentCode, tagCode, tagType, ttShort, ttLong);

      fUsesStrips = true;

      fTileOffsetsType   = tagType;

      fTileOffsetsCount  = tagCount;

      fTileOffsetsOffset = tagOffset;

      if (tagCount <= kMaxTileInfo)

        {

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

          {

          fTileOffset [j] = stream.TagValue_uint32 (tagType);

          }

        }

      #if qDNGValidate

      if (gVerbose)

        {

        stream.SetReadPosition (tagOffset);

        DumpTagValues (stream,

                 "Offset",

                 parentCode,

                 tagCode,

                 tagType,

                 tagCount);

        }

      #endif

      break;

      }

    case tcOrientation:

      {

      CheckTagType (parentCode, tagCode, tagType, ttShort);

      CheckTagCount (parentCode, tagCode, tagCount, 1);

      fOrientationType      = tagType;

      fOrientationOffset    = stream.PositionInOriginalFile ();

      fOrientationBigEndian = stream.BigEndian ();

      fOrientation = stream.TagValue_uint32 (tagType);

      #if qDNGValidate

      if (gVerbose)

        {

        printf ("Orientation: %s\n",

              LookupOrientation (fOrientation));

        }

      #endif

      break;

      }

    case tcSamplesPerPixel:

      {

      CheckTagType (parentCode, tagCode, tagType, ttShort);

      CheckTagCount (parentCode, tagCode, tagCount, 1);

      fSamplesPerPixel = stream.TagValue_uint32 (tagType);

      #if qDNGValidate

      if (gVerbose)

        {

        printf ("SamplesPerPixel: %u\n", (unsigned) fSamplesPerPixel);

        }

      #endif

      break;

      }

    case tcRowsPerStrip:

      {

      CheckTagType (parentCode, tagCode, tagType, ttShort, ttLong);

      CheckTagCount (parentCode, tagCode, tagCount, 1);

      fUsesStrips = true;

      fTileLength = stream.TagValue_uint32 (tagType);

      #if qDNGValidate

      if (gVerbose)

        {

        printf ("RowsPerStrip: %u\n", (unsigned) fTileLength);

        }

      #endif

      break;

      }

    case tcStripByteCounts:

      {

      CheckTagType (parentCode, tagCode, tagType, ttShort, ttLong);

      fUsesStrips = true;

      fTileByteCountsType   = tagType;

      fTileByteCountsCount  = tagCount;

      fTileByteCountsOffset = tagOffset;

      if (tagCount <= kMaxTileInfo)

        {

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

          {

          fTileByteCount [j] = stream.TagValue_uint32 (tagType);

          }

        }

      #if qDNGValidate

      if (gVerbose)

        {

        stream.SetReadPosition (tagOffset);

        DumpTagValues (stream,

                 "Count",

                 parentCode,

                 tagCode,

                 tagType,

                 tagCount);

        }

      #endif

      break;

      }

    case tcXResolution:

      {

      CheckTagType (parentCode, tagCode, tagType, ttRational);

      CheckTagCount (parentCode, tagCode, tagCount, 1);

      fXResolution = stream.TagValue_real64 (tagType);

      #if qDNGValidate

      if (gVerbose)

        {

        printf ("XResolution: %0.2f\n", fXResolution);

        }

      #endif

      break;

      }

    case tcYResolution:

      {

      CheckTagType (parentCode, tagCode, tagType, ttRational);

      CheckTagCount (parentCode, tagCode, tagCount, 1);

      fYResolution = stream.TagValue_real64 (tagType);

      #if qDNGValidate

      if (gVerbose)

        {

        printf ("YResolution: %0.2f\n", fYResolution);

        }

      #endif

      break;

      }

    case tcPlanarConfiguration:

      {

      CheckTagType (parentCode, tagCode, tagType, ttShort);

      CheckTagCount (parentCode, tagCode, tagCount, 1);

      fPlanarConfiguration = stream.TagValue_uint32 (tagType);

      #if qDNGValidate

      if (gVerbose)

        {

        printf ("PlanarConfiguration: %u\n", (unsigned) fPlanarConfiguration);

        }

      #endif

      break;

      }

    case tcResolutionUnit:

      {

      CheckTagType (parentCode, tagCode, tagType, ttShort);

      CheckTagCount (parentCode, tagCode, tagCount, 1);

      fResolutionUnit = stream.TagValue_uint32 (tagType);

      #if qDNGValidate

      if (gVerbose)

        {

        printf ("ResolutionUnit: %s\n",

              LookupResolutionUnit (fResolutionUnit));

        }

      #endif

      break;

      }

    case tcPredictor:

      {

      CheckTagType (parentCode, tagCode, tagType, ttShort);

      CheckTagCount (parentCode, tagCode, tagCount, 1);

      fPredictor = stream.TagValue_uint32 (tagType);

      #if qDNGValidate

      if (gVerbose)

        {

        printf ("Predictor: %s\n",

            LookupPredictor (fPredictor));

        }

      #endif

      break;

      }

    case tcTileWidth:

      {

      CheckTagType (parentCode, tagCode, tagType, ttShort, ttLong);

      CheckTagCount (parentCode, tagCode, tagCount, 1);

      fUsesTiles = true;

      fTileWidth = stream.TagValue_uint32 (tagType);

      #if qDNGValidate

      if (gVerbose)

        {

        printf ("TileWidth: %u\n", (unsigned) fTileWidth);

        }

      #endif

      break;

      }

    case tcTileLength:

      {

      CheckTagType (parentCode, tagCode, tagType, ttShort, ttLong);

      CheckTagCount (parentCode, tagCode, tagCount, 1);

      fUsesTiles = true;

      fTileLength = stream.TagValue_uint32 (tagType);

      #if qDNGValidate

      if (gVerbose)

        {

        printf ("TileLength: %u\n", (unsigned) fTileLength);

        }

      #endif

      break;

      }

    case tcTileOffsets:

      {

      CheckTagType (parentCode, tagCode, tagType, ttLong);

      fUsesTiles = true;

      fTileOffsetsType   = tagType;

      fTileOffsetsCount  = tagCount;

      fTileOffsetsOffset = tagOffset;

      if (tagCount <= kMaxTileInfo)

        {

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

          {

          fTileOffset [j] = stream.TagValue_uint32 (tagType);

          }

        }

      #if qDNGValidate

      if (gVerbose)

        {

        stream.SetReadPosition (tagOffset);

        DumpTagValues (stream,

                 "Offset",

                 parentCode,

                 tagCode,

                 tagType,

                 tagCount);

        }

      #endif

      break;

      }

    case tcTileByteCounts:

      {

      CheckTagType (parentCode, tagCode, tagType, ttShort, ttLong);

      fUsesTiles = true;

      fTileByteCountsType   = tagType;

      fTileByteCountsCount  = tagCount;

      fTileByteCountsOffset = tagOffset;

      if (tagCount <= kMaxTileInfo)

        {

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

          {

          fTileByteCount [j] = stream.TagValue_uint32 (tagType);

          }

        }

      #if qDNGValidate

      if (gVerbose)

        {

        stream.SetReadPosition (tagOffset);

        DumpTagValues (stream,

                 "Count",

                 parentCode,

                 tagCode,

                 tagType,

                 tagCount);

        }

      #endif

      break;

      }

    case tcSubIFDs:

      {

      CheckTagType (parentCode, tagCode, tagType, ttLong, ttIFD);

      fSubIFDsCount  = tagCount;

      fSubIFDsOffset = tagOffset;

      #if qDNGValidate

      if (gVerbose)

        {

        DumpTagValues (stream,

                 "IFD",

                 parentCode,

                 tagCode,

                 ttLong,

                 tagCount);

        }

      #endif

      break;

      }

    case tcExtraSamples:

      {

      CheckTagType (parentCode, tagCode, tagType, ttShort);

      CheckTagCount (parentCode, tagCode, tagCount, 1, fSamplesPerPixel);

      #if qDNGValidate

      if (gVerbose)

        {

        printf ("ExtraSamples:");

        }

      #endif

      fExtraSamplesCount = tagCount;

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

        {

        uint32 x = stream.TagValue_uint32 (tagType);

        if (j < kMaxSamplesPerPixel)

          {

          fExtraSamples [j] = x;

          }

        #if qDNGValidate

        if (gVerbose)

          {

          printf (" %u", (unsigned) x);

          }

        #endif

        }

      #if qDNGValidate

      if (gVerbose)

        {

        printf ("\n");

        }

      #endif

      break;

      }

    case tcSampleFormat:

      {

      CheckTagType (parentCode, tagCode, tagType, ttShort);

      CheckTagCount (parentCode, tagCode, tagCount, fSamplesPerPixel);

      #if qDNGValidate

      if (gVerbose)

        {

        printf ("SampleFormat:");

        }

      #endif

      bool extrasMatch = true;

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

        {

        uint32 x = stream.TagValue_uint32 (tagType);

        if (j < kMaxSamplesPerPixel)

          {

          fSampleFormat [j] = x;

          }

        else if (x != fSampleFormat [kMaxSamplesPerPixel - 1])

          {

          extrasMatch = false;

          }

        #if qDNGValidate

        if (gVerbose)

          {

          printf (" %s", LookupSampleFormat (x));

          }

        #endif

        }

      #if qDNGValidate

      if (gVerbose)

        {

        printf ("\n");

        }

      #endif

      if (!extrasMatch)

        {

        #if qDNGValidate

        ReportError ("SampleFormat not constant");