| /*****************************************************************************/ |
| // 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"); |
| |
| #endif |
| |
| ThrowBadFormat (); |
| |
| } |
| |
| break; |
| |
| } |
| |
| case tcJPEGTables: |
| { |
| |
| CheckTagType (parentCode, tagCode, tagType, ttUndefined); |
| |
| fJPEGTablesCount = tagCount; |
| fJPEGTablesOffset = tagOffset; |
| |
| #if qDNGValidate |
| |
| if (gVerbose) |
| { |
| |
| printf ("JPEGTables: count = %u, offset = %u\n", |
| (unsigned) fJPEGTablesCount, |
| (unsigned) fJPEGTablesOffset); |
| |
| } |
| |
| #endif |
| |
| break; |
| |
| } |
| |
| case tcJPEGInterchangeFormat: |
| { |
| |
| CheckTagType (parentCode, tagCode, tagType, ttLong); |
| |
| CheckTagCount (parentCode, tagCode, tagCount, 1); |
| |
| fJPEGInterchangeFormat = stream.TagValue_uint32 (tagType); |
| |
| #if qDNGValidate |
| |
| if (gVerbose) |
| { |
| printf ("JPEGInterchangeFormat: %u\n", |
| (unsigned) fJPEGInterchangeFormat); |
| } |
| |
| #endif |
| |
| break; |
| |
| } |
| |
| case tcJPEGInterchangeFormatLength: |
| { |
| |
| CheckTagType (parentCode, tagCode, tagType, ttLong); |
| |
| CheckTagCount (parentCode, tagCode, tagCount, 1); |
| |
| fJPEGInterchangeFormatLength = stream.TagValue_uint32 (tagType); |
| |
| #if qDNGValidate |
| |
| if (gVerbose) |
| { |
| printf ("JPEGInterchangeFormatLength: %u\n", |
| (unsigned) fJPEGInterchangeFormatLength); |
| } |
| |
| #endif |
| |
| break; |
| |
| } |
| |
| case tcYCbCrCoefficients: |
| { |
| |
| CheckTagType (parentCode, tagCode, tagType, ttRational); |
| |
| if (!CheckTagCount (parentCode, tagCode, tagCount, 3)) |
| { |
| return false; |
| } |
| |
| fYCbCrCoefficientR = stream.TagValue_real64 (tagType); |
| fYCbCrCoefficientG = stream.TagValue_real64 (tagType); |
| fYCbCrCoefficientB = stream.TagValue_real64 (tagType); |
| |
| #if qDNGValidate |
| |
| if (gVerbose) |
| { |
| |
| printf ("YCbCrCoefficients: R = %0.3f, G = %0.3f, B = %0.3f\n", |
| fYCbCrCoefficientR, |
| fYCbCrCoefficientG, |
| fYCbCrCoefficientB); |
| |
| } |
| |
| #endif |
| |
| break; |
| |
| } |
| |
| case tcYCbCrSubSampling: |
| { |
| |
| CheckTagType (parentCode, tagCode, tagType, ttShort); |
| |
| if (!CheckTagCount (parentCode, tagCode, tagCount, 2)) |
| { |
| return false; |
| } |
| |
| fYCbCrSubSampleH = stream.TagValue_uint32 (tagType); |
| fYCbCrSubSampleV = stream.TagValue_uint32 (tagType); |
| |
| #if qDNGValidate |
| |
| if (gVerbose) |
| { |
| |
| printf ("YCbCrSubSampling: H = %u, V = %u\n", |
| (unsigned) fYCbCrSubSampleH, |
| (unsigned) fYCbCrSubSampleV); |
| |
| } |
| |
| #endif |
| |
| break; |
| |
| } |
| |
| case tcYCbCrPositioning: |
| { |
| |
| CheckTagType (parentCode, tagCode, tagType, ttShort); |
| |
| CheckTagCount (parentCode, tagCode, tagCount, 1); |
| |
| fYCbCrPositioning = stream.TagValue_uint32 (tagType); |
| |
| #if qDNGValidate |
| |
| if (gVerbose) |
| { |
| |
| printf ("YCbCrPositioning: %u\n", |
| (unsigned) fYCbCrPositioning); |
| |
| } |
| |
| #endif |
| |
| break; |
| |
| } |
| |
| case tcReferenceBlackWhite: |
| { |
| |
| CheckTagType (parentCode, tagCode, tagType, ttRational); |
| |
| if (!CheckTagCount (parentCode, tagCode, tagCount, 6)) |
| { |
| return false; |
| } |
| |
| for (j = 0; j < 6; j++) |
| { |
| fReferenceBlackWhite [j] = stream.TagValue_real64 (tagType); |
| } |
| |
| #if qDNGValidate |
| |
| if (gVerbose) |
| { |
| |
| printf ("ReferenceBlackWhite: %0.1f %0.1f %0.1f %0.1f %0.1f %0.1f\n", |
| fReferenceBlackWhite [0], |
| fReferenceBlackWhite [1], |
| fReferenceBlackWhite [2], |
| fReferenceBlackWhite [3], |
| fReferenceBlackWhite [4], |
| fReferenceBlackWhite [5]); |
| |
| } |
| |
| #endif |
| |
| break; |
| |
| } |
| |
| case tcCFARepeatPatternDim: |
| { |
| |
| CheckCFA (parentCode, tagCode, fPhotometricInterpretation); |
| |
| CheckTagType (parentCode, tagCode, tagType, ttShort); |
| |
| if (!CheckTagCount (parentCode, tagCode, tagCount, 2)) |
| { |
| return false; |
| } |
| |
| fCFARepeatPatternRows = stream.TagValue_uint32 (tagType); |
| fCFARepeatPatternCols = stream.TagValue_uint32 (tagType); |
| |
| #if qDNGValidate |
| |
| if (gVerbose) |
| { |
| |
| printf ("CFARepeatPatternDim: Rows = %u, Cols = %u\n", |
| (unsigned) fCFARepeatPatternRows, |
| (unsigned) fCFARepeatPatternCols); |
| |
| } |
| |
| #endif |
| |
| break; |
| |
| } |
| |
| case tcCFAPattern: |
| { |
| |
| CheckCFA (parentCode, tagCode, fPhotometricInterpretation); |
| |
| if (!CheckTagType (parentCode, tagCode, tagType, ttByte)) |
| { |
| return false; |
| } |
| |
| if (!CheckTagCount (parentCode, tagCode, tagCount, |
| SafeUint32Mult(fCFARepeatPatternRows, fCFARepeatPatternCols))) |
| { |
| return false; |
| } |
| |
| if (fCFARepeatPatternRows < 1 || fCFARepeatPatternRows > kMaxCFAPattern || |
| fCFARepeatPatternCols < 1 || fCFARepeatPatternCols > kMaxCFAPattern) |
| { |
| return false; |
| } |
| |
| // Note that the Exif spec stores this array in a different |
| // scan order than the TIFF-EP spec. |
| |
| for (j = 0; j < fCFARepeatPatternRows; j++) |
| for (k = 0; k < fCFARepeatPatternCols; k++) |
| { |
| |
| fCFAPattern [j] [k] = stream.Get_uint8 (); |
| |
| } |
| |
| #if qDNGValidate |
| |
| if (gVerbose) |
| { |
| |
| printf ("CFAPattern:\n"); |
| |
| for (j = 0; j < fCFARepeatPatternRows; j++) |
| { |
| |
| int32 spaces = 4; |
| |
| for (k = 0; k < fCFARepeatPatternCols; k++) |
| { |
| |
| while (spaces-- > 0) |
| { |
| printf (" "); |
| } |
| |
| const char *name = LookupCFAColor (fCFAPattern [j] [k]); |
| |
| spaces = 9 - (int32) strlen (name); |
| |
| printf ("%s", name); |
| |
| } |
| |
| printf ("\n"); |
| |
| } |
| |
| } |
| |
| #endif |
| |
| break; |
| |
| } |
| |
| case tcCFAPlaneColor: |
| { |
| |
| CheckCFA (parentCode, tagCode, fPhotometricInterpretation); |
| |
| if (!CheckTagType (parentCode, tagCode, tagType, ttByte)) |
| { |
| return false; |
| } |
| |
| if (!CheckTagCount (parentCode, tagCode, tagCount, 3, kMaxColorPlanes)) |
| { |
| return false; |
| } |
| |
| for (j = 0; j < kMaxColorPlanes; j++) |
| { |
| |
| if (j < tagCount) |
| fCFAPlaneColor [j] = stream.Get_uint8 (); |
| |
| else |
| fCFAPlaneColor [j] = 255; |
| |
| } |
| |
| #if qDNGValidate |
| |
| if (gVerbose) |
| { |
| |
| printf ("CFAPlaneColor:"); |
| |
| for (j = 0; j < tagCount; j++) |
| { |
| |
| printf (" %s", LookupCFAColor (fCFAPlaneColor [j])); |
| |
| } |
| |
| printf ("\n"); |
| |
| } |
| |
| #endif |
| |
| break; |
| |
| } |
| |
| case tcCFALayout: |
| { |
| |
| CheckCFA (parentCode, tagCode, fPhotometricInterpretation); |
| |
| CheckTagType (parentCode, tagCode, tagType, ttShort); |
| |
| CheckTagCount (parentCode, tagCode, tagCount, 1); |
| |
| fCFALayout = stream.TagValue_uint32 (tagType); |
| |
| #if qDNGValidate |
| |
| if (gVerbose) |
| { |
| |
| printf ("CFALayout: %s\n", |
| LookupCFALayout (fCFALayout)); |
| |
| } |
| |
| #endif |
| |
| break; |
| |
| } |
| |
| case tcLinearizationTable: |
| { |
| |
| CheckRawIFD (parentCode, tagCode, fPhotometricInterpretation); |
| |
| CheckTagType (parentCode, tagCode, tagType, ttShort); |
| |
| fLinearizationTableType = tagType; |
| fLinearizationTableCount = tagCount; |
| fLinearizationTableOffset = tagOffset; |
| |
| #if qDNGValidate |
| |
| if (gVerbose) |
| { |
| |
| DumpTagValues (stream, |
| "Table", |
| parentCode, |
| tagCode, |
| tagType, |
| tagCount); |
| |
| } |
| |
| #endif |
| |
| break; |
| |
| } |
| |
| case tcBlackLevelRepeatDim: |
| { |
| |
| CheckRawIFD (parentCode, tagCode, fPhotometricInterpretation); |
| |
| CheckTagType (parentCode, tagCode, tagType, ttShort); |
| |
| if (!CheckTagCount (parentCode, tagCode, tagCount, 2)) |
| { |
| return false; |
| } |
| |
| fBlackLevelRepeatRows = stream.TagValue_uint32 (tagType); |
| fBlackLevelRepeatCols = stream.TagValue_uint32 (tagType); |
| |
| #if qDNGValidate |
| |
| if (gVerbose) |
| { |
| |
| printf ("BlackLevelRepeatDim: Rows = %u, Cols = %u\n", |
| (unsigned) fBlackLevelRepeatRows, |
| (unsigned) fBlackLevelRepeatCols); |
| |
| } |
| |
| #endif |
| |
| break; |
| |
| } |
| |
| case tcBlackLevel: |
| { |
| |
| CheckRawIFD (parentCode, tagCode, fPhotometricInterpretation); |
| |
| CheckTagType (parentCode, tagCode, tagType, ttShort, ttLong, ttRational); |
| |
| if (!CheckTagCount (parentCode, tagCode, tagCount, SafeUint32Mult(fBlackLevelRepeatRows, |
| fBlackLevelRepeatCols, |
| fSamplesPerPixel))) |
| { |
| return false; |
| } |
| |
| if (fBlackLevelRepeatRows < 1 || fBlackLevelRepeatRows > kMaxBlackPattern || |
| fBlackLevelRepeatCols < 1 || fBlackLevelRepeatCols > kMaxBlackPattern || |
| fSamplesPerPixel < 1 || fSamplesPerPixel > kMaxSamplesPerPixel) |
| { |
| return false; |
| } |
| |
| for (j = 0; j < fBlackLevelRepeatRows; j++) |
| for (k = 0; k < fBlackLevelRepeatCols; k++) |
| for (n = 0; n < fSamplesPerPixel; n++) |
| { |
| |
| fBlackLevel [j] [k] [n] = stream.TagValue_real64 (tagType); |
| |
| } |
| |
| #if qDNGValidate |
| |
| if (gVerbose) |
| { |
| |
| printf ("BlackLevel:"); |
| |
| if (fBlackLevelRepeatRows == 1 && |
| fBlackLevelRepeatCols == 1) |
| { |
| |
| for (n = 0; n < fSamplesPerPixel; n++) |
| { |
| printf (" %0.2f", fBlackLevel [0] [0] [n]); |
| } |
| |
| printf ("\n"); |
| |
| } |
| |
| else |
| { |
| |
| printf ("\n"); |
| |
| for (n = 0; n < fSamplesPerPixel; n++) |
| { |
| |
| if (fSamplesPerPixel > 1) |
| { |
| printf (" Sample: %u\n", (unsigned) n); |
| } |
| |
| for (j = 0; j < fBlackLevelRepeatRows; j++) |
| { |
| |
| printf (" "); |
| |
| for (k = 0; k < fBlackLevelRepeatCols; k++) |
| { |
| |
| printf (" %8.2f", fBlackLevel [j] [k] [n]); |
| |
| } |
| |
| printf ("\n"); |
| |
| } |
| |
| } |
| |
| } |
| |
| } |
| |
| #endif |
| |
| break; |
| |
| } |
| |
| case tcBlackLevelDeltaH: |
| { |
| |
| CheckRawIFD (parentCode, tagCode, fPhotometricInterpretation); |
| |
| CheckTagType (parentCode, tagCode, tagType, ttSRational); |
| |
| fBlackLevelDeltaHType = tagType; |
| fBlackLevelDeltaHCount = tagCount; |
| fBlackLevelDeltaHOffset = tagOffset; |
| |
| #if qDNGValidate |
| |
| if (gVerbose) |
| { |
| |
| DumpTagValues (stream, |
| "Delta", |
| parentCode, |
| tagCode, |
| tagType, |
| tagCount); |
| |
| } |
| |
| #endif |
| |
| break; |
| |
| } |
| |
| case tcBlackLevelDeltaV: |
| { |
| |
| CheckRawIFD (parentCode, tagCode, fPhotometricInterpretation); |
| |
| CheckTagType (parentCode, tagCode, tagType, ttSRational); |
| |
| fBlackLevelDeltaVType = tagType; |
| fBlackLevelDeltaVCount = tagCount; |
| fBlackLevelDeltaVOffset = tagOffset; |
| |
| #if qDNGValidate |
| |
| if (gVerbose) |
| { |
| |
| DumpTagValues (stream, |
| "Delta", |
| parentCode, |
| tagCode, |
| tagType, |
| tagCount); |
| |
| } |
| |
| #endif |
| |
| break; |
| |
| } |
| |
| case tcWhiteLevel: |
| { |
| |
| CheckRawIFD (parentCode, tagCode, fPhotometricInterpretation); |
| |
| CheckTagType (parentCode, tagCode, tagType, ttShort, ttLong); |
| |
| if (!CheckTagCount (parentCode, tagCode, tagCount, fSamplesPerPixel)) |
| return false; |
| |
| for (j = 0; j < tagCount && j < kMaxSamplesPerPixel; j++) |
| { |
| |
| fWhiteLevel [j] = stream.TagValue_real64 (tagType); |
| |
| } |
| |
| #if qDNGValidate |
| |
| if (gVerbose) |
| { |
| |
| printf ("WhiteLevel:"); |
| |
| for (j = 0; j < tagCount && j < kMaxSamplesPerPixel; j++) |
| { |
| |
| printf (" %0.0f", fWhiteLevel [j]); |
| |
| } |
| |
| printf ("\n"); |
| |
| } |
| |
| #endif |
| |
| break; |
| |
| } |
| |
| case tcDefaultScale: |
| { |
| |
| CheckMainIFD (parentCode, tagCode, fNewSubFileType); |
| |
| CheckTagType (parentCode, tagCode, tagType, ttRational); |
| |
| if (!CheckTagCount (parentCode, tagCode, tagCount, 2)) |
| return false; |
| |
| fDefaultScaleH = stream.TagValue_urational (tagType); |
| fDefaultScaleV = stream.TagValue_urational (tagType); |
| |
| #if qDNGValidate |
| |
| if (gVerbose) |
| { |
| |
| printf ("DefaultScale: H = %0.4f V = %0.4f\n", |
| fDefaultScaleH.As_real64 (), |
| fDefaultScaleV.As_real64 ()); |
| |
| } |
| |
| #endif |
| |
| break; |
| |
| } |
| |
| case tcDefaultCropOrigin: |
| { |
| |
| CheckMainIFD (parentCode, tagCode, fNewSubFileType); |
| |
| CheckTagType (parentCode, tagCode, tagType, ttShort, ttLong, ttRational); |
| |
| if (!CheckTagCount (parentCode, tagCode, tagCount, 2)) |
| return false; |
| |
| fDefaultCropOriginH = stream.TagValue_urational (tagType); |
| fDefaultCropOriginV = stream.TagValue_urational (tagType); |
| |
| #if qDNGValidate |
| |
| if (gVerbose) |
| { |
| |
| printf ("DefaultCropOrigin: H = %0.2f V = %0.2f\n", |
| fDefaultCropOriginH.As_real64 (), |
| fDefaultCropOriginV.As_real64 ()); |
| |
| } |
| |
| #endif |
| |
| break; |
| |
| } |
| |
| case tcDefaultCropSize: |
| { |
| |
| CheckMainIFD (parentCode, tagCode, fNewSubFileType); |
| |
| CheckTagType (parentCode, tagCode, tagType, ttShort, ttLong, ttRational); |
| |
| if (!CheckTagCount (parentCode, tagCode, tagCount, 2)) |
| return false; |
| |
| fDefaultCropSizeH = stream.TagValue_urational (tagType); |
| fDefaultCropSizeV = stream.TagValue_urational (tagType); |
| |
| #if qDNGValidate |
| |
| if (gVerbose) |
| { |
| |
| printf ("DefaultCropSize: H = %0.2f V = %0.2f\n", |
| fDefaultCropSizeH.As_real64 (), |
| fDefaultCropSizeV.As_real64 ()); |
| |
| } |
| |
| #endif |
| |
| break; |
| |
| } |
| |
| case tcDefaultUserCrop: |
| { |
| |
| CheckMainIFD (parentCode, tagCode, fNewSubFileType); |
| |
| CheckTagType (parentCode, tagCode, tagType, ttRational); |
| |
| if (!CheckTagCount (parentCode, tagCode, tagCount, 4)) |
| return false; |
| |
| fDefaultUserCropT = stream.TagValue_urational (tagType); |
| fDefaultUserCropL = stream.TagValue_urational (tagType); |
| fDefaultUserCropB = stream.TagValue_urational (tagType); |
| fDefaultUserCropR = stream.TagValue_urational (tagType); |
| |
| #if qDNGValidate |
| |
| if (gVerbose) |
| { |
| |
| printf ("DefaultUserCrop: T = %0.2lf L = %0.2lf B = %0.2lf R = %0.2lf\n", |
| (double) fDefaultUserCropT.As_real64 (), |
| (double) fDefaultUserCropL.As_real64 (), |
| (double) fDefaultUserCropB.As_real64 (), |
| (double) fDefaultUserCropR.As_real64 ()); |
| |
| |
| } |
| |
| #endif // qDNGValidate |
| |
| break; |
| |
| } |
| |
| case tcBayerGreenSplit: |
| { |
| |
| CheckCFA (parentCode, tagCode, fPhotometricInterpretation); |
| |
| CheckTagType (parentCode, tagCode, tagType, ttLong); |
| |
| CheckTagCount (parentCode, tagCode, tagCount, 1); |
| |
| fBayerGreenSplit = stream.TagValue_uint32 (tagType); |
| |
| #if qDNGValidate |
| |
| if (gVerbose) |
| { |
| printf ("BayerGreenSplit: %u\n", (unsigned) fBayerGreenSplit); |
| } |
| |
| #endif |
| |
| break; |
| |
| } |
| |
| case tcChromaBlurRadius: |
| { |
| |
| CheckMainIFD (parentCode, tagCode, fNewSubFileType); |
| |
| CheckTagType (parentCode, tagCode, tagType, ttRational); |
| |
| CheckTagCount (parentCode, tagCode, tagCount, 1); |
| |
| fChromaBlurRadius = stream.TagValue_urational (tagType); |
| |
| #if qDNGValidate |
| |
| if (gVerbose) |
| { |
| |
| printf ("ChromaBlurRadius: %0.2f\n", |
| fChromaBlurRadius.As_real64 ()); |
| |
| } |
| |
| #endif |
| |
| break; |
| |
| } |
| |
| case tcAntiAliasStrength: |
| { |
| |
| CheckMainIFD (parentCode, tagCode, fNewSubFileType); |
| |
| CheckTagType (parentCode, tagCode, tagType, ttRational); |
| |
| CheckTagCount (parentCode, tagCode, tagCount, 1); |
| |
| fAntiAliasStrength = stream.TagValue_urational (tagType); |
| |
| #if qDNGValidate |
| |
| if (gVerbose) |
| { |
| |
| printf ("AntiAliasStrength: %0.2f\n", |
| fAntiAliasStrength.As_real64 ()); |
| |
| } |
| |
| #endif |
| |
| break; |
| |
| } |
| |
| case tcBestQualityScale: |
| { |
| |
| CheckMainIFD (parentCode, tagCode, fNewSubFileType); |
| |
| CheckTagType (parentCode, tagCode, tagType, ttRational); |
| |
| CheckTagCount (parentCode, tagCode, tagCount, 1); |
| |
| fBestQualityScale = stream.TagValue_urational (tagType); |
| |
| #if qDNGValidate |
| |
| if (gVerbose) |
| { |
| |
| printf ("BestQualityScale: %0.4f\n", |
| fBestQualityScale.As_real64 ()); |
| |
| } |
| |
| #endif |
| |
| break; |
| |
| } |
| |
| case tcActiveArea: |
| { |
| |
| CheckMainIFD (parentCode, tagCode, fNewSubFileType); |
| |
| CheckTagType (parentCode, tagCode, tagType, ttShort, ttLong); |
| |
| if (!CheckTagCount (parentCode, tagCode, tagCount, 4)) |
| return false; |
| |
| fActiveArea.t = stream.TagValue_int32 (tagType); |
| fActiveArea.l = stream.TagValue_int32 (tagType); |
| fActiveArea.b = stream.TagValue_int32 (tagType); |
| fActiveArea.r = stream.TagValue_int32 (tagType); |
| |
| #if qDNGValidate |
| |
| if (gVerbose) |
| { |
| |
| printf ("ActiveArea: T = %d L = %d B = %d R = %d\n", |
| (int) fActiveArea.t, |
| (int) fActiveArea.l, |
| (int) fActiveArea.b, |
| (int) fActiveArea.r); |
| |
| } |
| |
| #endif |
| |
| break; |
| |
| } |
| |
| case tcMaskedAreas: |
| { |
| |
| CheckMainIFD (parentCode, tagCode, fNewSubFileType); |
| |
| CheckTagType (parentCode, tagCode, tagType, ttShort, ttLong); |
| |
| uint32 rect_count = tagCount / 4; |
| |
| if (!CheckTagCount (parentCode, tagCode, tagCount, rect_count * 4)) |
| return false; |
| |
| fMaskedAreaCount = rect_count; |
| |
| if (fMaskedAreaCount > kMaxMaskedAreas) |
| fMaskedAreaCount = kMaxMaskedAreas; |
| |
| for (j = 0; j < fMaskedAreaCount; j++) |
| { |
| |
| fMaskedArea [j].t = stream.TagValue_int32 (tagType); |
| fMaskedArea [j].l = stream.TagValue_int32 (tagType); |
| fMaskedArea [j].b = stream.TagValue_int32 (tagType); |
| fMaskedArea [j].r = stream.TagValue_int32 (tagType); |
| |
| } |
| |
| #if qDNGValidate |
| |
| if (gVerbose) |
| { |
| |
| printf ("MaskedAreas: %u\n", (unsigned) fMaskedAreaCount); |
| |
| for (j = 0; j < fMaskedAreaCount; j++) |
| { |
| |
| printf (" Area [%u]: T = %d L = %d B = %d R = %d\n", |
| (unsigned) j, |
| (int) fMaskedArea [j].t, |
| (int) fMaskedArea [j].l, |
| (int) fMaskedArea [j].b, |
| (int) fMaskedArea [j].r); |
| |
| } |
| |
| } |
| |
| #endif |
| |
| break; |
| |
| } |
| |
| case tcPreviewApplicationName: |
| { |
| |
| CheckTagType (parentCode, tagCode, tagType, ttAscii, ttByte); |
| |
| ParseStringTag (stream, |
| parentCode, |
| tagCode, |
| tagCount, |
| fPreviewInfo.fApplicationName, |
| false); |
| |
| #if qDNGValidate |
| |
| if (gVerbose) |
| { |
| |
| printf ("PreviewApplicationName: "); |
| |
| DumpString (fPreviewInfo.fApplicationName); |
| |
| printf ("\n"); |
| |
| } |
| |
| #endif |
| |
| break; |
| |
| } |
| |
| case tcPreviewApplicationVersion: |
| { |
| |
| CheckTagType (parentCode, tagCode, tagType, ttAscii, ttByte); |
| |
| ParseStringTag (stream, |
| parentCode, |
| tagCode, |
| tagCount, |
| fPreviewInfo.fApplicationVersion, |
| false); |
| |
| #if qDNGValidate |
| |
| if (gVerbose) |
| { |
| |
| printf ("PreviewApplicationVersion: "); |
| |
| DumpString (fPreviewInfo.fApplicationVersion); |
| |
| printf ("\n"); |
| |
| } |
| |
| #endif |
| |
| break; |
| |
| } |
| |
| case tcPreviewSettingsName: |
| { |
| |
| CheckTagType (parentCode, tagCode, tagType, ttAscii, ttByte); |
| |
| ParseStringTag (stream, |
| parentCode, |
| tagCode, |
| tagCount, |
| fPreviewInfo.fSettingsName, |
| false); |
| |
| #if qDNGValidate |
| |
| if (gVerbose) |
| { |
| |
| printf ("PreviewSettingsName: "); |
| |
| DumpString (fPreviewInfo.fSettingsName); |
| |
| printf ("\n"); |
| |
| } |
| |
| #endif |
| |
| break; |
| |
| } |
| |
| case tcPreviewSettingsDigest: |
| { |
| |
| if (!CheckTagType (parentCode, tagCode, tagType, ttByte)) |
| return false; |
| |
| if (!CheckTagCount (parentCode, tagCode, tagCount, 16)) |
| return false; |
| |
| stream.Get (fPreviewInfo.fSettingsDigest.data, 16); |
| |
| #if qDNGValidate |
| |
| if (gVerbose) |
| { |
| |
| printf ("PreviewSettingsDigest: "); |
| |
| DumpFingerprint (fPreviewInfo.fSettingsDigest); |
| |
| printf ("\n"); |
| |
| } |
| |
| #endif |
| |
| break; |
| |
| } |
| |
| case tcPreviewColorSpace: |
| { |
| |
| CheckTagType (parentCode, tagCode, tagType, ttLong); |
| |
| CheckTagCount (parentCode, tagCode, tagCount, 1); |
| |
| fPreviewInfo.fColorSpace = (PreviewColorSpaceEnum) |
| stream.TagValue_uint32 (tagType); |
| |
| #if qDNGValidate |
| |
| if (gVerbose) |
| { |
| |
| printf ("PreviewColorSpace: %s\n", |
| LookupPreviewColorSpace ((uint32) fPreviewInfo.fColorSpace)); |
| |
| } |
| |
| #endif |
| |
| break; |
| |
| } |
| |
| case tcPreviewDateTime: |
| { |
| |
| CheckTagType (parentCode, tagCode, tagType, ttAscii); |
| |
| ParseStringTag (stream, |
| parentCode, |
| tagCode, |
| tagCount, |
| fPreviewInfo.fDateTime, |
| false); |
| |
| #if qDNGValidate |
| |
| if (gVerbose) |
| { |
| |
| printf ("PreviewDateTime: "); |
| |
| DumpString (fPreviewInfo.fDateTime); |
| |
| printf ("\n"); |
| |
| } |
| |
| #endif |
| |
| break; |
| |
| } |
| |
| case tcRowInterleaveFactor: |
| { |
| |
| CheckTagType (parentCode, tagCode, tagType, ttShort, ttLong); |
| |
| if (!CheckTagCount (parentCode, tagCode, tagCount, 1)) |
| return false; |
| |
| fRowInterleaveFactor = stream.TagValue_uint32 (tagType); |
| |
| #if qDNGValidate |
| |
| if (gVerbose) |
| { |
| |
| printf ("RowInterleaveFactor: %u\n", |
| (unsigned) fRowInterleaveFactor); |
| |
| } |
| |
| #endif |
| |
| break; |
| |
| } |
| |
| case tcSubTileBlockSize: |
| { |
| |
| CheckTagType (parentCode, tagCode, tagType, ttShort, ttLong); |
| |
| if (!CheckTagCount (parentCode, tagCode, tagCount, 2)) |
| return false; |
| |
| fSubTileBlockRows = stream.TagValue_uint32 (tagType); |
| fSubTileBlockCols = stream.TagValue_uint32 (tagType); |
| |
| #if qDNGValidate |
| |
| if (gVerbose) |
| { |
| |
| printf ("SubTileBlockSize: rows = %u, cols = %u\n", |
| (unsigned) fSubTileBlockRows, |
| (unsigned) fSubTileBlockCols); |
| |
| } |
| |
| #endif |
| |
| break; |
| |
| } |
| |
| case tcOpcodeList1: |
| { |
| |
| CheckRawIFD (parentCode, tagCode, fPhotometricInterpretation); |
| |
| CheckTagType (parentCode, tagCode, tagType, ttUndefined); |
| |
| fOpcodeList1Count = tagCount; |
| fOpcodeList1Offset = tagOffset; |
| |
| #if qDNGValidate |
| |
| if (gVerbose) |
| { |
| |
| printf ("OpcodeList1: count = %u, offset = %u\n", |
| (unsigned) fOpcodeList1Count, |
| (unsigned) fOpcodeList1Offset); |
| |
| } |
| |
| #endif |
| |
| break; |
| |
| } |
| |
| case tcOpcodeList2: |
| { |
| |
| CheckRawIFD (parentCode, tagCode, fPhotometricInterpretation); |
| |
| CheckTagType (parentCode, tagCode, tagType, ttUndefined); |
| |
| fOpcodeList2Count = tagCount; |
| fOpcodeList2Offset = tagOffset; |
| |
| #if qDNGValidate |
| |
| if (gVerbose) |
| { |
| |
| printf ("OpcodeList2: count = %u, offset = %u\n", |
| (unsigned) fOpcodeList2Count, |
| (unsigned) fOpcodeList2Offset); |
| |
| } |
| |
| #endif |
| |
| break; |
| |
| } |
| |
| case tcOpcodeList3: |
| { |
| |
| CheckRawIFD (parentCode, tagCode, fPhotometricInterpretation); |
| |
| CheckTagType (parentCode, tagCode, tagType, ttUndefined); |
| |
| fOpcodeList3Count = tagCount; |
| fOpcodeList3Offset = tagOffset; |
| |
| #if qDNGValidate |
| |
| if (gVerbose) |
| { |
| |
| printf ("OpcodeList3: count = %u, offset = %u\n", |
| (unsigned) fOpcodeList3Count, |
| (unsigned) fOpcodeList3Offset); |
| |
| } |
| |
| #endif |
| |
| break; |
| |
| } |
| |
| case tcRawToPreviewGain: |
| { |
| |
| #if qDNGValidate |
| |
| if (fNewSubFileType != sfPreviewImage) |
| { |
| |
| char message [256]; |
| |
| sprintf (message, |
| "%s %s is not allowed IFDs with NewSubFileType != PreviewImage", |
| LookupParentCode (parentCode), |
| LookupTagCode (parentCode, tagCode)); |
| |
| ReportWarning (message); |
| |
| } |
| |
| #endif |
| |
| CheckRawIFD (parentCode, tagCode, fPhotometricInterpretation); |
| |
| CheckTagType (parentCode, tagCode, tagType, ttDouble); |
| |
| if (!CheckTagCount (parentCode, tagCode, tagCount, 1)) |
| return false; |
| |
| fPreviewInfo.fRawToPreviewGain = stream.TagValue_real64 (tagType); |
| |
| #if qDNGValidate |
| |
| if (gVerbose) |
| { |
| |
| printf ("RawToPreviewGain = %f\n", |
| fPreviewInfo.fRawToPreviewGain); |
| |
| } |
| |
| #endif |
| |
| break; |
| |
| } |
| |
| case tcCacheVersion: |
| { |
| |
| #if qDNGValidate |
| |
| if (fNewSubFileType != sfPreviewImage) |
| { |
| |
| char message [256]; |
| |
| sprintf (message, |
| "%s %s is not allowed IFDs with NewSubFileType != PreviewImage", |
| LookupParentCode (parentCode), |
| LookupTagCode (parentCode, tagCode)); |
| |
| ReportWarning (message); |
| |
| } |
| |
| #endif |
| |
| CheckRawIFD (parentCode, tagCode, fPhotometricInterpretation); |
| |
| CheckTagType (parentCode, tagCode, tagType, ttLong); |
| |
| if (!CheckTagCount (parentCode, tagCode, tagCount, 1)) |
| return false; |
| |
| fPreviewInfo.fCacheVersion = stream.TagValue_uint32 (tagType); |
| |
| #if qDNGValidate |
| |
| if (gVerbose) |
| { |
| |
| printf ("CacheVersion = 0x%x\n", |
| (unsigned) fPreviewInfo.fCacheVersion); |
| |
| } |
| |
| #endif |
| |
| break; |
| |
| } |
| |
| default: |
| { |
| |
| return false; |
| |
| } |
| |
| } |
| |
| return true; |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| void dng_ifd::PostParse () |
| { |
| |
| uint32 j; |
| uint32 k; |
| |
| // There is only one PlanarConfiguration for single sample imaages. |
| |
| if (fSamplesPerPixel == 1) |
| { |
| fPlanarConfiguration = pcInterleaved; |
| } |
| |
| // Default tile size. |
| |
| if (fTileWidth == 0) |
| { |
| fTileWidth = fImageWidth; |
| } |
| |
| if (fTileLength == 0) |
| { |
| fTileLength = fImageLength; |
| } |
| |
| // Default ActiveArea. |
| |
| dng_rect imageArea (0, 0, fImageLength, fImageWidth); |
| |
| if (fActiveArea.IsZero ()) |
| { |
| fActiveArea = imageArea; |
| } |
| |
| // Default crop size. |
| |
| if (fDefaultCropSizeH.d == 0) |
| { |
| fDefaultCropSizeH = dng_urational (fActiveArea.W (), 1); |
| } |
| |
| if (fDefaultCropSizeV.d == 0) |
| { |
| fDefaultCropSizeV = dng_urational (fActiveArea.H (), 1); |
| } |
| |
| // Default white level. |
| |
| uint32 defaultWhite = (fSampleFormat [0] == sfFloatingPoint) ? |
| 1 : |
| (uint32) ((((uint64) 1) << fBitsPerSample [0]) - 1); |
| |
| for (j = 0; j < kMaxSamplesPerPixel; j++) |
| { |
| |
| if (fWhiteLevel [j] < 0.0) |
| { |
| fWhiteLevel [j] = (real64) defaultWhite; |
| } |
| |
| } |
| |
| // Check AntiAliasStrength. |
| |
| if (fAntiAliasStrength.As_real64 () < 0.0 || |
| fAntiAliasStrength.As_real64 () > 1.0) |
| { |
| |
| #if qDNGValidate |
| |
| ReportWarning ("Invalid AntiAliasStrength"); |
| |
| #endif |
| |
| fAntiAliasStrength = dng_urational (1, 1); |
| |
| } |
| |
| // Check MaskedAreas. |
| |
| for (j = 0; j < fMaskedAreaCount; j++) |
| { |
| |
| const dng_rect &r = fMaskedArea [j]; |
| |
| if (r.IsEmpty () || ((r & imageArea) != r)) |
| { |
| |
| #if qDNGValidate |
| |
| ReportWarning ("Invalid MaskedArea"); |
| |
| #endif |
| |
| fMaskedAreaCount = 0; |
| |
| break; |
| |
| } |
| |
| if ((r & fActiveArea).NotEmpty ()) |
| { |
| |
| #if qDNGValidate |
| |
| ReportWarning ("MaskedArea overlaps ActiveArea"); |
| |
| #endif |
| |
| fMaskedAreaCount = 0; |
| |
| break; |
| |
| } |
| |
| for (k = 0; k < j; k++) |
| { |
| |
| if ((r & fMaskedArea [k]).NotEmpty ()) |
| { |
| |
| #if qDNGValidate |
| |
| ReportWarning ("MaskedAreas overlap each other"); |
| |
| #endif |
| |
| fMaskedAreaCount = 0; |
| |
| break; |
| |
| } |
| |
| } |
| |
| } |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| bool dng_ifd::IsValidCFA (dng_shared &shared, |
| uint32 parentCode) |
| { |
| |
| uint32 j; |
| uint32 k; |
| uint32 n; |
| |
| #if !qDNGValidate |
| |
| (void) parentCode; // Unused |
| |
| #endif |
| |
| if (fCFARepeatPatternRows < 1 || fCFARepeatPatternRows > kMaxCFAPattern || |
| fCFARepeatPatternCols < 1 || fCFARepeatPatternCols > kMaxCFAPattern) |
| { |
| |
| #if qDNGValidate |
| |
| ReportError ("Missing or invalid CFAPatternRepeatDim", |
| LookupParentCode (parentCode)); |
| |
| #endif |
| |
| return false; |
| |
| } |
| |
| uint32 count [kMaxColorPlanes]; |
| |
| for (n = 0; n < shared.fCameraProfile.fColorPlanes; n++) |
| { |
| count [n] = 0; |
| } |
| |
| for (j = 0; j < fCFARepeatPatternRows; j++) |
| { |
| |
| for (k = 0; k < fCFARepeatPatternCols; k++) |
| { |
| |
| bool found = false; |
| |
| for (n = 0; n < shared.fCameraProfile.fColorPlanes; n++) |
| { |
| |
| if (fCFAPattern [j] [k] == fCFAPlaneColor [n]) |
| { |
| found = true; |
| count [n] ++; |
| break; |
| } |
| |
| } |
| |
| if (!found) |
| { |
| |
| #if qDNGValidate |
| |
| ReportError ("CFAPattern contains colors not included in the CFAPlaneColor tag", |
| LookupParentCode (parentCode)); |
| |
| #endif |
| |
| return false; |
| |
| } |
| |
| } |
| |
| } |
| |
| for (n = 0; n < shared.fCameraProfile.fColorPlanes; n++) |
| { |
| |
| if (count [n] == 0) |
| { |
| |
| #if qDNGValidate |
| |
| ReportError ("CFAPattern does not contain all the colors in the CFAPlaneColor tag", |
| LookupParentCode (parentCode)); |
| |
| #endif |
| |
| return false; |
| |
| } |
| |
| } |
| |
| if (fCFALayout < 1 || fCFALayout > 9) |
| { |
| |
| #if qDNGValidate |
| |
| ReportError ("Invalid CFALayout", |
| LookupParentCode (parentCode)); |
| |
| #endif |
| |
| return false; |
| |
| } |
| |
| return true; |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| bool dng_ifd::IsValidDNG (dng_shared &shared, |
| uint32 parentCode) |
| { |
| |
| uint32 j; |
| |
| bool isFloatingPoint = (fSampleFormat [0] == sfFloatingPoint); |
| |
| dng_rect imageArea (0, 0, fImageLength, fImageWidth); |
| |
| uint32 defaultWhite = isFloatingPoint ? |
| 1 : |
| (uint32) ((((uint64) 1) << fBitsPerSample [0]) - 1); |
| |
| bool isMonochrome = (shared.fCameraProfile.fColorPlanes == 1); |
| bool isColor = !isMonochrome; |
| |
| bool isMainIFD = (fNewSubFileType == sfMainImage); |
| |
| // Check NewSubFileType. |
| |
| if (!fUsesNewSubFileType) |
| { |
| |
| #if qDNGValidate |
| |
| ReportError ("Missing NewSubFileType", |
| LookupParentCode (parentCode)); |
| |
| #endif |
| |
| return false; |
| |
| } |
| |
| if (fNewSubFileType != sfMainImage && |
| fNewSubFileType != sfPreviewImage && |
| fNewSubFileType != sfTransparencyMask && |
| fNewSubFileType != sfPreviewMask && |
| fNewSubFileType != sfAltPreviewImage) |
| { |
| |
| #if qDNGValidate |
| |
| ReportError ("Unexpected NewSubFileType", |
| LookupParentCode (parentCode)); |
| |
| #endif |
| |
| return false; |
| |
| } |
| |
| // Check ImageWidth and ImageLength. |
| |
| if (fImageWidth < 1) |
| { |
| |
| #if qDNGValidate |
| |
| ReportError ("Missing or invalid ImageWidth", |
| LookupParentCode (parentCode)); |
| |
| #endif |
| |
| return false; |
| |
| } |
| |
| if (fImageLength < 1) |
| { |
| |
| #if qDNGValidate |
| |
| ReportError ("Missing or invalid ImageLength", |
| LookupParentCode (parentCode)); |
| |
| #endif |
| |
| return false; |
| |
| } |
| |
| if (fImageWidth > kMaxImageSide || |
| fImageLength > kMaxImageSide) |
| { |
| |
| #if qDNGValidate |
| |
| ReportWarning ("Image size is larger than supported"); |
| |
| #endif |
| |
| return false; |
| |
| } |
| |
| // Check PhotometricInterpretation. |
| |
| if (fNewSubFileType == sfTransparencyMask || |
| fNewSubFileType == sfPreviewMask) |
| { |
| |
| if (fPhotometricInterpretation != piTransparencyMask) |
| { |
| |
| #if qDNGValidate |
| |
| ReportError ("NewSubFileType requires PhotometricInterpretation = TransparencyMask", |
| LookupParentCode (parentCode)); |
| |
| #endif |
| |
| return false; |
| |
| } |
| |
| } |
| |
| else |
| { |
| |
| switch (fPhotometricInterpretation) |
| { |
| |
| case piBlackIsZero: |
| case piRGB: |
| case piYCbCr: |
| { |
| |
| if (isMainIFD) |
| { |
| |
| #if qDNGValidate |
| |
| ReportError ("PhotometricInterpretation requires NewSubFileType = 1", |
| LookupParentCode (parentCode)); |
| |
| #endif |
| |
| return false; |
| |
| } |
| |
| break; |
| |
| } |
| |
| case piCFA: |
| { |
| |
| if (!isMainIFD) |
| { |
| |
| #if qDNGValidate |
| |
| ReportError ("PhotometricInterpretation requires NewSubFileType = 0", |
| LookupParentCode (parentCode)); |
| |
| #endif |
| |
| return false; |
| |
| } |
| |
| break; |
| |
| } |
| |
| case piLinearRaw: |
| break; |
| |
| default: |
| { |
| |
| #if qDNGValidate |
| |
| ReportError ("Missing or invalid PhotometricInterpretation", |
| LookupParentCode (parentCode)); |
| |
| #endif |
| |
| return false; |
| |
| } |
| |
| } |
| |
| } |
| |
| switch (fPhotometricInterpretation) |
| { |
| |
| case piBlackIsZero: |
| { |
| |
| // Allow black in white previews even in color images since the |
| // raw processing software may be converting to grayscale. |
| |
| if (isColor && isMainIFD) |
| { |
| |
| #if qDNGValidate |
| |
| ReportError ("PhotometricInterpretation forbids use of ColorMatrix1 tag", |
| LookupParentCode (parentCode)); |
| |
| #endif |
| |
| return false; |
| |
| } |
| |
| break; |
| |
| } |
| |
| case piRGB: |
| case piYCbCr: |
| { |
| |
| // Allow color previews even in monochrome DNG files, since the |
| // raw procesing software may be adding color effects. |
| |
| break; |
| |
| } |
| |
| case piCFA: |
| { |
| |
| if (isMonochrome) |
| { |
| |
| #if qDNGValidate |
| |
| ReportError ("PhotometricInterpretation requires use of ColorMatrix1 tag", |
| LookupParentCode (parentCode)); |
| |
| #endif |
| |
| return false; |
| |
| } |
| |
| break; |
| |
| } |
| |
| } |
| |
| if (isFloatingPoint) |
| { |
| |
| if (fPhotometricInterpretation != piCFA && |
| fPhotometricInterpretation != piLinearRaw && |
| fPhotometricInterpretation != piTransparencyMask) |
| { |
| |
| #if qDNGValidate |
| |
| ReportError ("Floating point data requires PhotometricInterpretation CFA or LinearRaw or TransparencyMask", |
| LookupParentCode (parentCode)); |
| |
| #endif |
| |
| return false; |
| |
| } |
| |
| } |
| |
| // Check SamplesPerPixel and BitsPerSample. |
| |
| uint32 minSamplesPerPixel = 1; |
| uint32 maxSamplesPerPixel = 1; |
| |
| uint32 minBitsPerSample = 8; |
| uint32 maxBitsPerSample = 16; |
| |
| switch (fPhotometricInterpretation) |
| { |
| |
| case piBlackIsZero: |
| break; |
| |
| case piRGB: |
| case piYCbCr: |
| { |
| minSamplesPerPixel = 3; |
| maxSamplesPerPixel = 3; |
| break; |
| } |
| |
| case piCFA: |
| { |
| maxSamplesPerPixel = kMaxSamplesPerPixel; |
| maxBitsPerSample = 32; |
| break; |
| } |
| |
| case piLinearRaw: |
| { |
| minSamplesPerPixel = shared.fCameraProfile.fColorPlanes; |
| maxSamplesPerPixel = shared.fCameraProfile.fColorPlanes; |
| maxBitsPerSample = 32; |
| break; |
| } |
| |
| case piTransparencyMask: |
| { |
| minBitsPerSample = 8; |
| maxBitsPerSample = 16; |
| break; |
| } |
| |
| } |
| |
| if (isFloatingPoint) |
| { |
| minBitsPerSample = 16; |
| maxBitsPerSample = 32; |
| } |
| |
| if (fSamplesPerPixel < minSamplesPerPixel || |
| fSamplesPerPixel > maxSamplesPerPixel) |
| { |
| |
| #if qDNGValidate |
| |
| ReportError ("Missing or invalid SamplesPerPixel", |
| LookupParentCode (parentCode)); |
| |
| #endif |
| |
| return false; |
| |
| } |
| |
| for (j = 0; j < kMaxSamplesPerPixel; j++) |
| { |
| |
| if (j < fSamplesPerPixel) |
| { |
| |
| if (fBitsPerSample [j] < minBitsPerSample || |
| fBitsPerSample [j] > maxBitsPerSample) |
| { |
| |
| #if qDNGValidate |
| |
| ReportError ("Missing or invalid BitsPerSample", |
| LookupParentCode (parentCode)); |
| |
| #endif |
| |
| return false; |
| |
| } |
| |
| if (isFloatingPoint && |
| fBitsPerSample [j] != 16 && |
| fBitsPerSample [j] != 24 && |
| fBitsPerSample [j] != 32) |
| { |
| |
| #if qDNGValidate |
| |
| ReportError ("Invalid BitsPerSample for floating point", |
| LookupParentCode (parentCode)); |
| |
| #endif |
| |
| return false; |
| |
| } |
| |
| if (minBitsPerSample == 8 && |
| maxBitsPerSample == 16 && |
| fBitsPerSample [j] != 8 && |
| fBitsPerSample [j] != 16) |
| { |
| |
| #if qDNGValidate |
| |
| ReportError ("Rendered previews and integer masks require 8 or 16 bits per sample", |
| LookupParentCode (parentCode)); |
| |
| #endif |
| |
| return false; |
| |
| } |
| |
| if (j > 0 && fBitsPerSample [j] != fBitsPerSample [0]) |
| { |
| |
| #if qDNGValidate |
| |
| ReportError ("BitsPerSample not equal for all samples", |
| LookupParentCode (parentCode)); |
| |
| #endif |
| |
| return false; |
| |
| } |
| |
| } |
| |
| else |
| { |
| |
| if (fBitsPerSample [j] != 0) |
| { |
| |
| #if qDNGValidate |
| |
| ReportError ("Too many values specified in BitsPerSample", |
| LookupParentCode (parentCode)); |
| |
| #endif |
| |
| return false; |
| |
| } |
| |
| } |
| |
| } |
| |
| // Check Compression. |
| |
| switch (fCompression) |
| { |
| |
| case ccUncompressed: |
| break; |
| |
| case ccJPEG: |
| { |
| |
| if (fPhotometricInterpretation == piRGB) |
| { |
| |
| #if qDNGValidate |
| |
| ReportError ("JPEG previews should use PhotometricInterpretation = YCbYb", |
| LookupParentCode (parentCode)); |
| |
| #endif |
| |
| return false; |
| |
| } |
| |
| if (fBitsPerSample [0] > 16) |
| { |
| |
| #if qDNGValidate |
| |
| ReportError ("JPEG compression is limited to 16 bits/sample", |
| LookupParentCode (parentCode)); |
| |
| #endif |
| |
| return false; |
| |
| } |
| |
| break; |
| |
| } |
| |
| case ccLossyJPEG: |
| { |
| |
| if (fPhotometricInterpretation != piLinearRaw) |
| { |
| |
| #if qDNGValidate |
| |
| ReportError ("Lossy JPEG compression code requires PhotometricInterpretation = LinearRaw", |
| LookupParentCode (parentCode)); |
| |
| #endif |
| |
| return false; |
| |
| } |
| |
| if (fBitsPerSample [0] != 8) |
| { |
| |
| #if qDNGValidate |
| |
| ReportError ("Lossy JPEG compression is limited to 8 bits/sample", |
| LookupParentCode (parentCode)); |
| |
| #endif |
| |
| return false; |
| |
| } |
| |
| break; |
| |
| } |
| |
| case ccDeflate: |
| { |
| |
| if (!isFloatingPoint && |
| fBitsPerSample [0] != 32 && |
| fPhotometricInterpretation != piTransparencyMask) |
| { |
| |
| #if qDNGValidate |
| |
| ReportError ("ZIP compression is limited to floating point and 32-bit integer and transparency masks", |
| LookupParentCode (parentCode)); |
| |
| #endif |
| |
| } |
| |
| break; |
| |
| } |
| |
| default: |
| { |
| |
| #if qDNGValidate |
| |
| ReportError ("Unsupported Compression", |
| LookupParentCode (parentCode)); |
| |
| #endif |
| |
| return false; |
| |
| } |
| |
| } |
| |
| // Check Predictor. |
| |
| if (isFloatingPoint && fCompression == ccDeflate && |
| (fPredictor == cpFloatingPoint || |
| fPredictor == cpFloatingPointX2 || |
| fPredictor == cpFloatingPointX4)) |
| { |
| |
| // These combinations are supported. |
| |
| } |
| |
| else if (!isFloatingPoint && fCompression == ccDeflate && |
| (fPredictor == cpHorizontalDifference || |
| fPredictor == cpHorizontalDifferenceX2 || |
| fPredictor == cpHorizontalDifferenceX4)) |
| { |
| |
| // These combinations are supported. |
| |
| } |
| |
| else if (fPredictor != cpNullPredictor) |
| { |
| |
| #if qDNGValidate |
| |
| ReportError ("Unsupported Predictor", |
| LookupParentCode (parentCode)); |
| |
| #endif |
| |
| return false; |
| |
| } |
| |
| // Check FillOrder. |
| |
| if (fFillOrder != 1) |
| { |
| |
| #if qDNGValidate |
| |
| ReportError ("Unsupported FillOrder", |
| LookupParentCode (parentCode)); |
| |
| #endif |
| |
| return false; |
| |
| } |
| |
| // Check PlanarConfiguration. |
| |
| if (fPlanarConfiguration != pcInterleaved) |
| { |
| |
| #if qDNGValidate |
| |
| ReportError ("Unsupported PlanarConfiguration", |
| LookupParentCode (parentCode)); |
| |
| #endif |
| |
| return false; |
| |
| } |
| |
| // Check ExtraSamples. |
| |
| if (fExtraSamplesCount != 0) |
| { |
| |
| #if qDNGValidate |
| |
| ReportError ("Unsupported ExtraSamples", |
| LookupParentCode (parentCode)); |
| |
| #endif |
| |
| return false; |
| |
| } |
| |
| // Check SampleFormat. |
| |
| for (j = 0; j < fSamplesPerPixel; j++) |
| { |
| |
| if (fSampleFormat [j] != (isFloatingPoint ? sfFloatingPoint : sfUnsignedInteger)) |
| { |
| |
| #if qDNGValidate |
| |
| ReportError ("Unsupported SampleFormat", |
| LookupParentCode (parentCode)); |
| |
| #endif |
| |
| return false; |
| |
| } |
| |
| } |
| |
| // Check Orientation. |
| |
| if (fOrientation > 9) |
| { |
| |
| #if qDNGValidate |
| |
| ReportError ("Unknown Orientation", |
| LookupParentCode (parentCode)); |
| |
| #endif |
| |
| return false; |
| |
| } |
| |
| #if qDNGValidate |
| |
| if (fOrientation != 0 && parentCode != 0) |
| { |
| |
| ReportWarning ("Unexpected Orientation tag", |
| LookupParentCode (parentCode)); |
| |
| } |
| |
| if (fOrientation == 0 && parentCode == 0) |
| { |
| |
| ReportWarning ("Missing Orientation tag", |
| LookupParentCode (parentCode)); |
| |
| } |
| |
| #endif |
| |
| // Check Strips vs. Tiles. |
| |
| if (!fUsesStrips && !fUsesTiles) |
| { |
| |
| #if qDNGValidate |
| |
| ReportError ("IFD uses neither strips nor tiles", |
| LookupParentCode (parentCode)); |
| |
| #endif |
| |
| return false; |
| |
| } |
| |
| if (fUsesStrips && fUsesTiles) |
| { |
| |
| #if qDNGValidate |
| |
| ReportError ("IFD uses both strips and tiles", |
| LookupParentCode (parentCode)); |
| |
| #endif |
| |
| return false; |
| |
| } |
| |
| // Check tile info. |
| |
| uint32 tilesWide = SafeUint32DivideUp(fImageWidth, fTileWidth); |
| uint32 tilesHigh = SafeUint32DivideUp(fImageLength, fTileLength); |
| |
| uint32 tileCount = tilesWide * tilesHigh; |
| |
| if (fTileOffsetsCount != tileCount) |
| { |
| |
| #if qDNGValidate |
| |
| ReportError ("Missing or invalid Strip/TileOffsets", |
| LookupParentCode (parentCode)); |
| |
| #endif |
| |
| return false; |
| |
| } |
| |
| if (fTileByteCountsCount != tileCount) |
| { |
| |
| #if qDNGValidate |
| |
| ReportError ("Missing or invalid Strip/TileByteCounts", |
| LookupParentCode (parentCode)); |
| |
| #endif |
| |
| return false; |
| |
| } |
| |
| // Check CFA pattern. |
| |
| if (fPhotometricInterpretation == piCFA) |
| { |
| |
| if (!IsValidCFA (shared, parentCode)) |
| { |
| |
| return false; |
| |
| } |
| |
| } |
| |
| // Check ActiveArea. |
| |
| if (((fActiveArea & imageArea) != fActiveArea) || fActiveArea.IsEmpty ()) |
| { |
| |
| #if qDNGValidate |
| |
| ReportError ("Invalid ActiveArea", |
| LookupParentCode (parentCode)); |
| |
| #endif |
| |
| return false; |
| |
| } |
| |
| if (fActiveArea != imageArea) |
| { |
| |
| if (shared.fDNGBackwardVersion < dngVersion_1_1_0_0) |
| { |
| |
| #if qDNGValidate |
| |
| ReportError ("Non-default ActiveArea tag not allowed in this DNG version", |
| LookupParentCode (parentCode)); |
| |
| #endif |
| |
| return false; |
| |
| } |
| |
| } |
| |
| // Check LinearizationTable. |
| |
| if (fLinearizationTableCount) |
| { |
| |
| if (fLinearizationTableType != ttShort) |
| { |
| |
| #if qDNGValidate |
| |
| ReportError ("Invalidate LinearizationTable type", |
| LookupParentCode (parentCode)); |
| |
| #endif |
| |
| return false; |
| |
| } |
| |
| if (fLinearizationTableCount < 2 || |
| fLinearizationTableCount > 65536) |
| { |
| |
| #if qDNGValidate |
| |
| ReportError ("Invalidate LinearizationTable count", |
| LookupParentCode (parentCode)); |
| |
| #endif |
| |
| return false; |
| |
| } |
| |
| if (isFloatingPoint || fBitsPerSample [0] > 16) |
| { |
| |
| #if qDNGValidate |
| |
| ReportError ("Linearization table not allowed for this data type", |
| LookupParentCode (parentCode)); |
| |
| #endif |
| |
| return false; |
| |
| } |
| |
| } |
| |
| // Check BlackLevelRepeatDim. |
| |
| if (fBlackLevelRepeatRows < 1 || fBlackLevelRepeatRows > kMaxBlackPattern || |
| fBlackLevelRepeatCols < 1 || fBlackLevelRepeatCols > kMaxBlackPattern) |
| { |
| |
| #if qDNGValidate |
| |
| ReportError ("Invalid BlackLevelRepeatDim", |
| LookupParentCode (parentCode)); |
| |
| #endif |
| |
| return false; |
| |
| } |
| |
| // Check BlackLevelDeltaH. |
| |
| if (fBlackLevelDeltaHCount != 0 && |
| fBlackLevelDeltaHCount != fActiveArea.W ()) |
| { |
| |
| #if qDNGValidate |
| |
| ReportError ("Invalid BlackLevelDeltaH count", |
| LookupParentCode (parentCode)); |
| |
| #endif |
| |
| return false; |
| |
| } |
| |
| // Check BlackLevelDeltaV. |
| |
| if (fBlackLevelDeltaVCount != 0 && |
| fBlackLevelDeltaVCount != fActiveArea.H ()) |
| { |
| |
| #if qDNGValidate |
| |
| ReportError ("Invalid BlackLevelDeltaV count", |
| LookupParentCode (parentCode)); |
| |
| #endif |
| |
| return false; |
| |
| } |
| |
| // Check WhiteLevel. |
| |
| real64 maxWhite = fLinearizationTableCount ? 65535.0 |
| : (real64) defaultWhite; |
| |
| for (j = 0; j < fSamplesPerPixel; j++) |
| { |
| |
| if (fWhiteLevel [j] < 1.0 || (fWhiteLevel [j] > maxWhite && !isFloatingPoint)) |
| { |
| |
| #if qDNGValidate |
| |
| ReportError ("Invalid WhiteLevel", |
| LookupParentCode (parentCode)); |
| |
| #endif |
| |
| return false; |
| |
| } |
| |
| } |
| |
| // Check BlackLevel. |
| |
| for (j = 0; j < kMaxBlackPattern; j++) |
| { |
| |
| for (uint32 k = 0; k < kMaxBlackPattern; k++) |
| { |
| |
| for (uint32 s = 0; s < kMaxSamplesPerPixel; s++) |
| { |
| |
| const real64 black = fBlackLevel [j][k][s]; |
| |
| if (black >= fWhiteLevel [s]) |
| { |
| |
| #if qDNGValidate |
| |
| ReportError ("Invalid BlackLevel", |
| LookupParentCode (parentCode)); |
| |
| #endif |
| |
| return false; |
| |
| } |
| |
| } |
| |
| } |
| |
| } |
| |
| // Check DefaultScale. |
| |
| if (fDefaultScaleH.As_real64 () <= 0.0 || |
| fDefaultScaleV.As_real64 () <= 0.0) |
| { |
| |
| #if qDNGValidate |
| |
| ReportError ("Invalid DefaultScale"); |
| |
| #endif |
| |
| return false; |
| |
| } |
| |
| // Check BestQualityScale. |
| |
| if (fBestQualityScale.As_real64 () < 1.0) |
| { |
| |
| #if qDNGValidate |
| |
| ReportError ("Invalid BestQualityScale"); |
| |
| #endif |
| |
| return false; |
| |
| } |
| |
| // Check DefaultCropOrigin. |
| |
| if (fDefaultCropOriginH.As_real64 () < 0.0 || |
| fDefaultCropOriginV.As_real64 () < 0.0 || |
| fDefaultCropOriginH.As_real64 () >= (real64) fActiveArea.W () || |
| fDefaultCropOriginV.As_real64 () >= (real64) fActiveArea.H ()) |
| { |
| |
| #if qDNGValidate |
| |
| ReportError ("Invalid DefaultCropOrigin"); |
| |
| #endif |
| |
| return false; |
| |
| } |
| |
| // Check DefaultCropSize. |
| |
| if (fDefaultCropSizeH.As_real64 () <= 0.0 || |
| fDefaultCropSizeV.As_real64 () <= 0.0 || |
| fDefaultCropSizeH.As_real64 () > (real64) fActiveArea.W () || |
| fDefaultCropSizeV.As_real64 () > (real64) fActiveArea.H ()) |
| { |
| |
| #if qDNGValidate |
| |
| ReportError ("Invalid DefaultCropSize"); |
| |
| #endif |
| |
| return false; |
| |
| } |
| |
| // Check DefaultCrop area. |
| |
| if (fDefaultCropOriginH.As_real64 () + |
| fDefaultCropSizeH .As_real64 () > (real64) fActiveArea.W () || |
| fDefaultCropOriginV.As_real64 () + |
| fDefaultCropSizeV .As_real64 () > (real64) fActiveArea.H ()) |
| { |
| |
| #if qDNGValidate |
| |
| ReportError ("Default crop extends outside ActiveArea"); |
| |
| #endif |
| |
| return false; |
| |
| } |
| |
| // Check DefaultUserCrop. |
| |
| if (fDefaultUserCropT.As_real64 () < 0.0 || |
| fDefaultUserCropL.As_real64 () < 0.0 || |
| fDefaultUserCropB.As_real64 () > 1.0 || |
| fDefaultUserCropR.As_real64 () > 1.0 || |
| fDefaultUserCropT.As_real64 () >= fDefaultUserCropB.As_real64 () || |
| fDefaultUserCropL.As_real64 () >= fDefaultUserCropR.As_real64 ()) |
| { |
| |
| #if qDNGValidate |
| |
| ReportError ("Invalid DefaultUserCrop"); |
| |
| #endif // qDNGValidate |
| |
| return false; |
| |
| } |
| |
| // The default crop and default user crop tags are not allowed for the |
| // non-main image. If they are there, at least require that they be NOPs. |
| |
| if (!isMainIFD) |
| { |
| |
| if (Round_int32 (fDefaultCropOriginH.As_real64 ()) != 0 || |
| Round_int32 (fDefaultCropOriginV.As_real64 ()) != 0) |
| { |
| |
| #if qDNGValidate |
| |
| ReportError ("non-default DefaultCropOrigin on non-main image"); |
| |
| #endif |
| |
| return false; |
| |
| } |
| |
| if (Round_int32 (fDefaultCropSizeH.As_real64 ()) != (int32) fImageWidth || |
| Round_int32 (fDefaultCropSizeV.As_real64 ()) != (int32) fImageLength) |
| { |
| |
| #if qDNGValidate |
| |
| ReportError ("non-default DefaultCropSize on non-main image"); |
| |
| #endif |
| |
| return false; |
| |
| } |
| |
| if (fDefaultUserCropT.As_real64 () != 0.0 || |
| fDefaultUserCropL.As_real64 () != 0.0 || |
| fDefaultUserCropB.As_real64 () != 1.0 || |
| fDefaultUserCropR.As_real64 () != 1.0) |
| { |
| |
| #if qDNGValidate |
| |
| ReportError ("non-default DefaultCUserCrop on non-main image"); |
| |
| #endif // qDNGValidate |
| |
| return false; |
| |
| } |
| |
| } |
| |
| // Warning if too little padding on CFA image. |
| |
| #if qDNGValidate |
| |
| if (fPhotometricInterpretation == piCFA) |
| { |
| |
| const real64 kMinPad = 1.9; |
| |
| if (fDefaultCropOriginH.As_real64 () < kMinPad) |
| { |
| |
| ReportWarning ("Too little padding on left edge of CFA image", |
| "possible interpolation artifacts"); |
| |
| } |
| |
| if (fDefaultCropOriginV.As_real64 () < kMinPad) |
| { |
| |
| ReportWarning ("Too little padding on top edge of CFA image", |
| "possible interpolation artifacts"); |
| |
| } |
| |
| if (fDefaultCropOriginH.As_real64 () + |
| fDefaultCropSizeH .As_real64 () > (real64) fActiveArea.W () - kMinPad) |
| { |
| |
| ReportWarning ("Too little padding on right edge of CFA image", |
| "possible interpolation artifacts"); |
| |
| } |
| |
| if (fDefaultCropOriginV.As_real64 () + |
| fDefaultCropSizeV .As_real64 () > (real64) fActiveArea.H () - kMinPad) |
| { |
| |
| ReportWarning ("Too little padding on bottom edge of CFA image", |
| "possible interpolation artifacts"); |
| |
| } |
| |
| } |
| |
| #endif |
| |
| // Check RowInterleaveFactor |
| |
| if (fRowInterleaveFactor != 1) |
| { |
| |
| if (fRowInterleaveFactor < 1 || |
| fRowInterleaveFactor > fImageLength) |
| { |
| |
| #if qDNGValidate |
| |
| ReportError ("RowInterleaveFactor out of valid range", |
| LookupParentCode (parentCode)); |
| |
| #endif |
| |
| return false; |
| |
| } |
| |
| if (shared.fDNGBackwardVersion < dngVersion_1_2_0_0) |
| { |
| |
| #if qDNGValidate |
| |
| ReportError ("Non-default RowInterleaveFactor tag not allowed in this DNG version", |
| LookupParentCode (parentCode)); |
| |
| #endif |
| |
| return false; |
| |
| } |
| |
| } |
| |
| // Check SubTileBlockSize |
| |
| if (fSubTileBlockRows != 1 || fSubTileBlockCols != 1) |
| { |
| |
| if (fSubTileBlockRows < 2 || fSubTileBlockRows > fTileLength || |
| fSubTileBlockCols < 1 || fSubTileBlockCols > fTileWidth) |
| { |
| |
| #if qDNGValidate |
| |
| ReportError ("SubTileBlockSize out of valid range", |
| LookupParentCode (parentCode)); |
| |
| #endif |
| |
| return false; |
| |
| } |
| |
| if ((fTileLength % fSubTileBlockRows) != 0 || |
| (fTileWidth % fSubTileBlockCols) != 0) |
| { |
| |
| #if qDNGValidate |
| |
| ReportError ("TileSize not exact multiple of SubTileBlockSize", |
| LookupParentCode (parentCode)); |
| |
| #endif |
| |
| return false; |
| |
| } |
| |
| if (shared.fDNGBackwardVersion < dngVersion_1_2_0_0) |
| { |
| |
| #if qDNGValidate |
| |
| ReportError ("Non-default SubTileBlockSize tag not allowed in this DNG version", |
| LookupParentCode (parentCode)); |
| |
| #endif |
| |
| return false; |
| |
| } |
| |
| } |
| |
| return true; |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| uint32 dng_ifd::TilesAcross () const |
| { |
| |
| if (fTileWidth) |
| { |
| |
| return (SafeUint32Sub(SafeUint32Add(fImageWidth, fTileWidth), 1)) / fTileWidth; |
| |
| } |
| |
| return 0; |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| uint32 dng_ifd::TilesDown () const |
| { |
| |
| if (fTileLength) |
| { |
| |
| return (SafeUint32Sub(SafeUint32Add(fImageLength, fTileLength), 1)) / fTileLength; |
| |
| } |
| |
| return 0; |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| uint32 dng_ifd::TilesPerImage () const |
| { |
| |
| uint32 total = TilesAcross () * TilesDown (); |
| |
| if (fPlanarConfiguration == pcPlanar) |
| { |
| |
| total *= fSamplesPerPixel; |
| |
| } |
| |
| return total; |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| dng_rect dng_ifd::TileArea (uint32 rowIndex, |
| uint32 colIndex) const |
| { |
| |
| dng_rect r; |
| |
| r.t = rowIndex * fTileLength; |
| r.b = r.t + fTileLength; |
| |
| r.l = colIndex * fTileWidth; |
| r.r = r.l + fTileWidth; |
| |
| // If this IFD is using strips rather than tiles, the last strip |
| // is trimmed so it does not extend beyond the end of the image. |
| |
| if (fUsesStrips) |
| { |
| |
| r.b = Min_uint32 (r.b, fImageLength); |
| |
| } |
| |
| return r; |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| uint32 dng_ifd::TileByteCount (const dng_rect &tile) const |
| { |
| |
| if (fCompression == ccUncompressed) |
| { |
| |
| uint32 bitsPerRow = SafeUint32Mult(tile.W (), fBitsPerSample [0]); |
| |
| if (fPlanarConfiguration == pcInterleaved) |
| { |
| |
| bitsPerRow = SafeUint32Mult(bitsPerRow, fSamplesPerPixel); |
| |
| } |
| |
| uint32 bytesPerRow = SafeUint32DivideUp(bitsPerRow, 8); |
| |
| if (fPlanarConfiguration == pcRowInterleaved) |
| { |
| |
| bytesPerRow = SafeUint32Mult(bytesPerRow, fSamplesPerPixel); |
| |
| } |
| |
| return SafeUint32Mult(bytesPerRow, tile.H ()); |
| |
| } |
| |
| return 0; |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| void dng_ifd::SetSingleStrip () |
| { |
| |
| fTileWidth = fImageWidth; |
| fTileLength = fImageLength; |
| |
| fUsesTiles = false; |
| fUsesStrips = true; |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| void dng_ifd::FindTileSize (uint32 bytesPerTile, |
| uint32 cellH, |
| uint32 cellV) |
| { |
| |
| uint32 bytesPerSample = fSamplesPerPixel * |
| ((fBitsPerSample [0] + 7) >> 3); |
| |
| uint32 samplesPerTile = bytesPerTile / bytesPerSample; |
| |
| uint32 tileSide = Round_uint32 (sqrt ((real64) samplesPerTile)); |
| |
| fTileWidth = Min_uint32 (fImageWidth, tileSide); |
| |
| uint32 across = TilesAcross (); |
| |
| fTileWidth = (fImageWidth + across - 1) / across; |
| |
| fTileWidth = ((fTileWidth + cellH - 1) / cellH) * cellH; |
| |
| fTileLength = Pin_uint32 (1, |
| samplesPerTile / fTileWidth, |
| fImageLength); |
| |
| uint32 down = TilesDown (); |
| |
| fTileLength = (fImageLength + down - 1) / down; |
| |
| fTileLength = ((fTileLength + cellV - 1) / cellV) * cellV; |
| |
| fUsesTiles = true; |
| fUsesStrips = false; |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| void dng_ifd::FindStripSize (uint32 bytesPerStrip, |
| uint32 cellV) |
| { |
| |
| uint32 bytesPerSample = fSamplesPerPixel * |
| ((fBitsPerSample [0] + 7) >> 3); |
| |
| uint32 samplesPerStrip = bytesPerStrip / bytesPerSample; |
| |
| fTileWidth = fImageWidth; |
| |
| fTileLength = Pin_uint32 (1, |
| samplesPerStrip / fTileWidth, |
| fImageLength); |
| |
| uint32 down = TilesDown (); |
| |
| fTileLength = (fImageLength + down - 1) / down; |
| |
| fTileLength = ((fTileLength + cellV - 1) / cellV) * cellV; |
| |
| fUsesTiles = false; |
| fUsesStrips = true; |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| uint32 dng_ifd::PixelType () const |
| { |
| |
| if (fSampleFormat [0] == sfFloatingPoint) |
| { |
| return ttFloat; |
| } |
| |
| if (fBitsPerSample [0] <= 8) |
| { |
| return ttByte; |
| } |
| |
| else if (fBitsPerSample [0] <= 16) |
| { |
| return ttShort; |
| } |
| |
| return ttLong; |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| bool dng_ifd::IsBaselineJPEG () const |
| { |
| |
| if (fBitsPerSample [0] != 8) |
| { |
| return false; |
| } |
| |
| if (fSampleFormat [0] != sfUnsignedInteger) |
| { |
| return false; |
| } |
| |
| if (fCompression == ccLossyJPEG) |
| { |
| return true; |
| } |
| |
| if (fCompression != ccJPEG) |
| { |
| return false; |
| } |
| |
| switch (fPhotometricInterpretation) |
| { |
| |
| case piBlackIsZero: |
| { |
| return (fSamplesPerPixel == 1); |
| } |
| |
| case piYCbCr: |
| { |
| return (fSamplesPerPixel == 3 ) && |
| (fPlanarConfiguration == pcInterleaved); |
| } |
| |
| default: |
| break; |
| |
| } |
| |
| return false; |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| bool dng_ifd::CanRead () const |
| { |
| |
| dng_read_image reader; |
| |
| return reader.CanRead (*this); |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| void dng_ifd::ReadImage (dng_host &host, |
| dng_stream &stream, |
| dng_image &image, |
| dng_jpeg_image *jpegImage, |
| dng_fingerprint *jpegDigest) const |
| { |
| |
| dng_read_image reader; |
| |
| reader.Read (host, |
| *this, |
| stream, |
| image, |
| jpegImage, |
| jpegDigest); |
| |
| } |
| |
| /*****************************************************************************/ |
