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

// 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_shared.cpp#2 $ */ 

/* $DateTime: 2012/06/14 20:24:41 $ */

/* $Change: 835078 $ */

/* $Author: tknoll $ */

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

#include "dng_shared.h"

#include "dng_camera_profile.h"

#include "dng_exceptions.h"

#include "dng_globals.h"

#include "dng_memory.h"

#include "dng_parse_utils.h"

#include "dng_safe_arithmetic.h"

#include "dng_tag_codes.h"

#include "dng_tag_types.h"

#include "dng_tag_values.h"

#include "dng_utils.h"

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

dng_camera_profile_info::dng_camera_profile_info ()

  : fBigEndian (false)

  , fColorPlanes (0)

  , fCalibrationIlluminant1 (lsUnknown)

  , fCalibrationIlluminant2 (lsUnknown)

  , fColorMatrix1 ()

  , fColorMatrix2 ()

  , fForwardMatrix1 ()

  , fForwardMatrix2 ()

  , fReductionMatrix1 ()

  , fReductionMatrix2 ()

  , fProfileCalibrationSignature ()

  , fProfileName ()

  , fProfileCopyright ()

  , fEmbedPolicy (pepAllowCopying)

  , fProfileHues (0)

  , fProfileSats (0)

  , fProfileVals (0)

  , fHueSatDeltas1Offset (0)

  , fHueSatDeltas1Count  (0)

  , fHueSatDeltas2Offset (0)

  , fHueSatDeltas2Count  (0)

  , fHueSatMapEncoding (encoding_Linear)

  , fLookTableHues (0)

  , fLookTableSats (0)

  , fLookTableVals (0)

  , fLookTableOffset (0)

  , fLookTableCount  (0)

  , fLookTableEncoding (encoding_Linear)

  , fBaselineExposureOffset (0, 100)

  , fDefaultBlackRender (defaultBlackRender_Auto)

  , fToneCurveOffset     (0)

  , fToneCurveCount      (0)

  , fUniqueCameraModel ()

  {

  }

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

dng_camera_profile_info::~dng_camera_profile_info ()

  {

  }

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

bool dng_camera_profile_info::ParseTag (dng_stream &stream,

                    uint32 parentCode,

                    uint32 tagCode,

                    uint32 tagType,

                    uint32 tagCount,

                    uint64 tagOffset)

  {

  switch (tagCode)

    {

    case tcCalibrationIlluminant1:

      {

      CheckTagType (parentCode, tagCode, tagType, ttShort);

      CheckTagCount (parentCode, tagCode, tagCount, 1);

      fCalibrationIlluminant1 = stream.TagValue_uint32 (tagType);

      #if qDNGValidate

      if (gVerbose)

        {

        printf ("CalibrationIlluminant1: %s\n",

            LookupLightSource (fCalibrationIlluminant1));

        }

      #endif

      break;

      }

    case tcCalibrationIlluminant2:

      {

      CheckTagType (parentCode, tagCode, tagType, ttShort);

      CheckTagCount (parentCode, tagCode, tagCount, 1);

      fCalibrationIlluminant2 = stream.TagValue_uint32 (tagType);

      #if qDNGValidate

      if (gVerbose)

        {

        printf ("CalibrationIlluminant2: %s\n",

            LookupLightSource (fCalibrationIlluminant2));

        }

      #endif

      break;

      }

    case tcColorMatrix1:

      {

      CheckTagType (parentCode, tagCode, tagType, ttSRational);

      if (fColorPlanes == 0)

        {

        fColorPlanes = Pin_uint32 (0, tagCount / 3, kMaxColorPlanes);

        }

      if (!CheckColorImage (parentCode, tagCode, fColorPlanes))

        return false;

      if (!ParseMatrixTag (stream,

                 parentCode,

                 tagCode,

                 tagType,

                 tagCount,

                 fColorPlanes,

                 3,

                 fColorMatrix1))

        return false;

      #if qDNGValidate

      if (gVerbose)

        {

        printf ("ColorMatrix1:\n");

        DumpMatrix (fColorMatrix1);

        }

      #endif

      break;

      }

    case tcColorMatrix2:

      {

      CheckTagType (parentCode, tagCode, tagType, ttSRational);

      // Kludge - Hasselblad FFF files are very DNG-like, but sometimes

      // only have a ColorMatrix2 tag and no ColorMatrix1 tag.

      bool hasselbladHack = (fColorPlanes == 0);

      if (hasselbladHack)

        {

        fColorPlanes = Pin_uint32 (0, tagCount / 3, kMaxColorPlanes);

        #if qDNGValidate

        ReportWarning ("ColorMatrix2 without ColorMatrix1");

        #endif

        }

      if (!CheckColorImage (parentCode, tagCode, fColorPlanes))

        return false;

      if (!ParseMatrixTag (stream,

                 parentCode,

                 tagCode,

                 tagType,

                 tagCount,

                 fColorPlanes,

                 3,

                 fColorMatrix2))

        return false;

      #if qDNGValidate

      if (gVerbose)

        {

        printf ("ColorMatrix2:\n");

        DumpMatrix (fColorMatrix2);

        }

      #endif

      if (hasselbladHack)

        {

        fColorMatrix1 = fColorMatrix2;

        fColorMatrix2 = dng_matrix ();

        }

      break;

      }

    case tcForwardMatrix1:

      {

      CheckTagType (parentCode, tagCode, tagType, ttSRational);

      if (!CheckColorImage (parentCode, tagCode, fColorPlanes))

        return false;

      if (!ParseMatrixTag (stream,

                 parentCode,

                 tagCode,

                 tagType,

                 tagCount,

                 3,

                 fColorPlanes,

                 fForwardMatrix1))

        return false;

      #if qDNGValidate

      if (gVerbose)

        {

        printf ("ForwardMatrix1:\n");

        DumpMatrix (fForwardMatrix1);

        }

      #endif

      break;

      }

    case tcForwardMatrix2:

      {

      CheckTagType (parentCode, tagCode, tagType, ttSRational);

      if (!CheckColorImage (parentCode, tagCode, fColorPlanes))

        return false;

      if (!ParseMatrixTag (stream,

                 parentCode,

                 tagCode,

                 tagType,

                 tagCount,

                 3,

                 fColorPlanes,

                 fForwardMatrix2))

        return false;

      #if qDNGValidate

      if (gVerbose)

        {

        printf ("ForwardMatrix2:\n");

        DumpMatrix (fForwardMatrix2);

        }

      #endif

      break;

      }

    case tcReductionMatrix1:

      {

      CheckTagType (parentCode, tagCode, tagType, ttSRational);

      if (!CheckColorImage (parentCode, tagCode, fColorPlanes))

        return false;

      if (!ParseMatrixTag (stream,

                 parentCode,

                 tagCode,

                 tagType,

                 tagCount,

                 3,

                 fColorPlanes,

                 fReductionMatrix1))

        return false;

      #if qDNGValidate

      if (gVerbose)

        {

        printf ("ReductionMatrix1:\n");

        DumpMatrix (fReductionMatrix1);

        }

      #endif

      break;

      }

    case tcReductionMatrix2:

      {

      CheckTagType (parentCode, tagCode, tagType, ttSRational);

      if (!CheckColorImage (parentCode, tagCode, fColorPlanes))

        return false;

      if (!ParseMatrixTag (stream,

                 parentCode,

                 tagCode,

                 tagType,

                 tagCount,

                 3,

                 fColorPlanes,

                 fReductionMatrix2))

        return false;

      #if qDNGValidate

      if (gVerbose)

        {

        printf ("ReductionMatrix2:\n");

        DumpMatrix (fReductionMatrix2);

        }

      #endif

      break;

      }

    case tcProfileCalibrationSignature:

      {

      CheckTagType (parentCode, tagCode, tagType, ttAscii, ttByte);

      ParseStringTag (stream,

              parentCode,

              tagCode,

              tagCount,

              fProfileCalibrationSignature,

              false);

      #if qDNGValidate

      if (gVerbose)

        {

        printf ("ProfileCalibrationSignature: ");

        DumpString (fProfileCalibrationSignature);

        printf ("\n");

        }

      #endif

      break;

      }

    case tcProfileName:

      {

      CheckTagType (parentCode, tagCode, tagType, ttAscii, ttByte);

      ParseStringTag (stream,

              parentCode,

              tagCode,

              tagCount,

              fProfileName,

              false);

      #if qDNGValidate

      if (gVerbose)

        {

        printf ("ProfileName: ");

        DumpString (fProfileName);

        printf ("\n");

        }

      #endif

      break;

      }

    case tcProfileCopyright:

      {

      CheckTagType (parentCode, tagCode, tagType, ttAscii, ttByte);

      ParseStringTag (stream,

              parentCode,

              tagCode,

              tagCount,

              fProfileCopyright,

              false);

      #if qDNGValidate

      if (gVerbose)

        {

        printf ("ProfileCopyright: ");

        DumpString (fProfileCopyright);

        printf ("\n");

        }

      #endif

      break;

      }

    case tcProfileEmbedPolicy:

      {

      CheckTagType (parentCode, tagCode, tagType, ttLong);

      CheckTagCount (parentCode, tagCode, tagCount, 1);

      fEmbedPolicy = stream.TagValue_uint32 (tagType);

      #if qDNGValidate

      if (gVerbose)

        {

        const char *policy;

        switch (fEmbedPolicy)

          {

          case pepAllowCopying:

            policy = "Allow copying";

            break;

          case pepEmbedIfUsed:

            policy = "Embed if used";

            break;

          case pepEmbedNever:

            policy = "Embed never";

            break;

          case pepNoRestrictions:

            policy = "No restrictions";

            break;

          default:

            policy = "INVALID VALUE";

          }

        printf ("ProfileEmbedPolicy: %s\n", policy);

        }

      #endif

      break;

      }

    case tcProfileHueSatMapDims:

      {

      CheckTagType (parentCode, tagCode, tagType, ttLong);

      CheckTagCount (parentCode, tagCode, tagCount, 2, 3);

      fProfileHues = stream.TagValue_uint32 (tagType);

      fProfileSats = stream.TagValue_uint32 (tagType);

      if (tagCount > 2)

        fProfileVals = stream.TagValue_uint32 (tagType);

      else

        fProfileVals = 1;

      #if qDNGValidate

      if (gVerbose)

        {

        printf ("ProfileHueSatMapDims: Hues = %u, Sats = %u, Vals = %u\n",

            (unsigned) fProfileHues,

            (unsigned) fProfileSats,

            (unsigned) fProfileVals);

        }

      #endif

      break;

      }

    case tcProfileHueSatMapData1:

      {

      if (!CheckTagType (parentCode, tagCode, tagType, ttFloat))

        return false;

      bool skipSat0 = (tagCount ==

               SafeUint32Mult(fProfileHues,

                      SafeUint32Sub(fProfileSats, 1u),

                      fProfileVals,

                      3u));

      if (!skipSat0)

        {

        if (!CheckTagCount (parentCode, tagCode, tagCount,

                  SafeUint32Mult(fProfileHues, fProfileSats, fProfileVals, 3)))

          return false;

        }

      fBigEndian = stream.BigEndian ();

      fHueSatDeltas1Offset = tagOffset;

      fHueSatDeltas1Count  = tagCount;

      #if qDNGValidate

      if (gVerbose)

        {

        printf ("ProfileHueSatMapData1:\n");

        DumpHueSatMap (stream,

                 fProfileHues,

                 fProfileSats,

                 fProfileVals,

                 skipSat0);

        }

      #endif

      break;

      }

    case tcProfileHueSatMapData2:

      {

      if (!CheckTagType (parentCode, tagCode, tagType, ttFloat))

        return false;

      bool skipSat0 = (tagCount ==

               SafeUint32Mult(fProfileHues,

                      SafeUint32Sub(fProfileSats, 1u),

                      fProfileVals,

                      3u));

      if (!skipSat0)

        {

        if (!CheckTagCount (parentCode, tagCode, tagCount,

                  SafeUint32Mult(fProfileHues, fProfileSats, fProfileVals, 3)))

          return false;

        }

      fBigEndian = stream.BigEndian ();

      fHueSatDeltas2Offset = tagOffset;

      fHueSatDeltas2Count  = tagCount;

      #if qDNGValidate

      if (gVerbose)

        {

        printf ("ProfileHueSatMapData2:\n");

        DumpHueSatMap (stream,

                 fProfileHues,

                 fProfileSats,

                 fProfileVals,

                 skipSat0);

        }

      #endif

      break;

      }

    case tcProfileHueSatMapEncoding:

      {

      CheckTagType (parentCode, tagCode, tagType, ttLong);

      CheckTagCount (parentCode, tagCode, tagCount, 1);

      fHueSatMapEncoding = stream.TagValue_uint32 (tagType);

      #if qDNGValidate

      if (gVerbose)

        {

        const char *encoding = NULL;

        switch (fHueSatMapEncoding)

          {

          case encoding_Linear:

            encoding = "Linear";

            break;

          case encoding_sRGB:

            encoding = "sRGB";

            break;

          default:

            encoding = "INVALID VALUE";

          }

        printf ("ProfileHueSatMapEncoding: %s\n", encoding);

        }

      #endif

      break;

      }

    case tcProfileLookTableDims:

      {

      CheckTagType (parentCode, tagCode, tagType, ttLong);

      CheckTagCount (parentCode, tagCode, tagCount, 2, 3);

      fLookTableHues = stream.TagValue_uint32 (tagType);

      fLookTableSats = stream.TagValue_uint32 (tagType);

      if (tagCount > 2)

        fLookTableVals = stream.TagValue_uint32 (tagType);

      else

        fLookTableVals = 1;

      #if qDNGValidate

      if (gVerbose)

        {

        printf ("ProfileLookTableDims: Hues = %u, Sats = %u, Vals = %u\n",

            (unsigned) fLookTableHues,

            (unsigned) fLookTableSats,

            (unsigned) fLookTableVals);

        }

      #endif

      break;

      }

    case tcProfileLookTableData:

      {

      if (!CheckTagType (parentCode, tagCode, tagType, ttFloat))

        return false;

      bool skipSat0 = (tagCount ==

               SafeUint32Mult(fLookTableHues,

                      SafeUint32Sub(fLookTableSats, 1u),

                      fLookTableVals,

                      3u));

      if (!skipSat0)

        {

        if (!CheckTagCount (parentCode, tagCode, tagCount,

                  SafeUint32Mult(fLookTableHues,

                          fLookTableSats,

                          fLookTableVals, 3)))

          return false;

        }

      fBigEndian = stream.BigEndian ();

      fLookTableOffset = tagOffset;

      fLookTableCount  = tagCount;

      #if qDNGValidate

      if (gVerbose)

        {

        printf ("ProfileLookTableData:\n");

        DumpHueSatMap (stream,

                 fLookTableHues,

                 fLookTableSats,

                 fLookTableVals,

                 skipSat0);

        }

      #endif

      break;

      }

    case tcProfileLookTableEncoding:

      {

      CheckTagType (parentCode, tagCode, tagType, ttLong);

      CheckTagCount (parentCode, tagCode, tagCount, 1);

      fLookTableEncoding = stream.TagValue_uint32 (tagType);

      #if qDNGValidate

      if (gVerbose)

        {

        const char *encoding = NULL;

        switch (fLookTableEncoding)

          {

          case encoding_Linear:

            encoding = "Linear";

            break;

          case encoding_sRGB:

            encoding = "sRGB";

            break;

          default:

            encoding = "INVALID VALUE";

          }

        printf ("ProfileLookTableEncoding: %s\n", encoding);

        }

      #endif

      break;

      }

    case tcBaselineExposureOffset:

      {

      CheckTagType (parentCode, tagCode, tagType, ttSRational);

      CheckTagCount (parentCode, tagCode, tagCount, 1);

      fBaselineExposureOffset = stream.TagValue_srational (tagType);

      #if qDNGValidate

      if (gVerbose)

        {

        printf ("BaselineExposureOffset: %+0.2f\n",

              fBaselineExposureOffset.As_real64 ());

        }

      #endif

      break;

      }

    case tcDefaultBlackRender:

      {

      CheckTagType (parentCode, tagCode, tagType, ttLong);

      CheckTagCount (parentCode, tagCode, tagCount, 1);

      fDefaultBlackRender = stream.TagValue_uint32 (tagType);

      #if qDNGValidate

      if (gVerbose)

        {

        const char *setting = NULL;

        switch (fDefaultBlackRender)

          {

          case defaultBlackRender_Auto:

            setting = "Auto";

            break;

          case defaultBlackRender_None:

            setting = "None";

            break;

          default:

            setting = "INVALID VALUE";

          }

        printf ("DefaultBlackRender: %s\n", 

            setting);

        }

      #endif

      break;

      }

    case tcProfileToneCurve:

      {

      if (!CheckTagType (parentCode, tagCode, tagType, ttFloat))

        return false;

      if (!CheckTagCount (parentCode, tagCode, tagCount, 4, tagCount))

        return false;

      if ((tagCount & 1) != 0)

        {

        #if qDNGValidate

          {

          char message [256];

          sprintf (message,

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

               LookupParentCode (parentCode),

               LookupTagCode (parentCode, tagCode),

               (unsigned) tagCount);

          ReportWarning (message);

          }

        #endif

        return false;

        }

      fBigEndian = stream.BigEndian ();

      fToneCurveOffset = tagOffset;

      fToneCurveCount  = tagCount;

      #if qDNGValidate

      if (gVerbose)

        {

        DumpTagValues (stream,

                 "Coord",

                 parentCode,

                 tagCode,

                 tagType,

                 tagCount);

        }

      #endif

      break;

      }

    case tcUniqueCameraModel:

      {

      // Note: This code is only used when parsing stand-alone

      // profiles.  The embedded profiles are assumed to be restricted

      // to the model they are embedded in.

      CheckTagType (parentCode, tagCode, tagType, ttAscii);

      ParseStringTag (stream,

              parentCode,

              tagCode,

              tagCount,

              fUniqueCameraModel,

              false);

      bool didTrim = fUniqueCameraModel.TrimTrailingBlanks ();

      #if qDNGValidate

      if (didTrim)

        {

        ReportWarning ("UniqueCameraModel string has trailing blanks");

        }

      if (gVerbose)

        {

        printf ("UniqueCameraModel: ");

        DumpString (fUniqueCameraModel);

        printf ("\n");

        }

      #else

      (void) didTrim;   // Unused

      #endif

      break;

      }

    default:

      {

      return false;

      }

    }

  return true;

  }

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

bool dng_camera_profile_info::ParseExtended (dng_stream &stream)

  {

  try

    {

    // Offsets are relative to the start of this structure, not the entire file.

    uint64 startPosition = stream.Position ();

    // Read header. Like a TIFF header, but with different magic number

    // Plus all offsets are relative to the start of the IFD, not to the

    // stream or file.

    uint16 byteOrder = stream.Get_uint16 ();

    if (byteOrder == byteOrderMM)

      fBigEndian = true;

    else if (byteOrder == byteOrderII)

      fBigEndian = false;

    else

      return false;

    TempBigEndian setEndianness (stream, fBigEndian);

    uint16 magicNumber = stream.Get_uint16 ();

    if (magicNumber != magicExtendedProfile)

      {

      return false;

      }

    uint32 offset = stream.Get_uint32 ();

    stream.Skip (SafeUint32Sub(offset, 8u));

    // Start on IFD entries.

    uint32 ifdEntries = stream.Get_uint16 ();

    if (ifdEntries < 1)

      {

      return false;

      }

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

      {

      stream.SetReadPosition (startPosition + 8 + 2 + tag_index * 12);

      uint16 tagCode  = stream.Get_uint16 ();

      uint32 tagType  = stream.Get_uint16 ();