/*****************************************************************************/ // Copyright 2006-2007 Adobe Systems Incorporated // All Rights Reserved. // // NOTICE: Adobe permits you to use, modify, and distribute this file in // accordance with the terms of the Adobe license agreement accompanying it. /*****************************************************************************/ /* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_info.cpp#1 $ */ /* $DateTime: 2012/05/30 13:28:51 $ */ /* $Change: 832332 $ */ /* $Author: tknoll $ */ /*****************************************************************************/ #include "dng_info.h" #include "dng_camera_profile.h" #include "dng_exceptions.h" #include "dng_globals.h" #include "dng_host.h" #include "dng_tag_codes.h" #include "dng_parse_utils.h" #include "dng_safe_arithmetic.h" #include "dng_tag_types.h" #include "dng_tag_values.h" #include "dng_utils.h" /*****************************************************************************/ dng_info::dng_info () : fTIFFBlockOffset (0) , fTIFFBlockOriginalOffset (kDNGStreamInvalidOffset) , fBigEndian (false) , fMagic (0) , fExif () , fShared () , fMainIndex (-1) , fMaskIndex (-1) , fIFDCount (0) , fChainedIFDCount (0) , fMakerNoteNextIFD (0) { } /*****************************************************************************/ dng_info::~dng_info () { } /*****************************************************************************/ void dng_info::ValidateMagic () { switch (fMagic) { case magicTIFF: case magicExtendedProfile: case magicRawCache: case magicPanasonic: case magicOlympusA: case magicOlympusB: { return; } default: { #if qDNGValidate ReportError ("Invalid TIFF magic number"); #endif ThrowBadFormat (); } } } /*****************************************************************************/ void dng_info::ParseTag (dng_host &host, dng_stream &stream, dng_exif *exif, dng_shared *shared, dng_ifd *ifd, uint32 parentCode, uint32 tagCode, uint32 tagType, uint32 tagCount, uint64 tagOffset, int64 offsetDelta) { bool isSubIFD = parentCode >= tcFirstSubIFD && parentCode <= tcLastSubIFD; bool isMainIFD = (parentCode == 0 || isSubIFD) && ifd && ifd->fUsesNewSubFileType && ifd->fNewSubFileType == sfMainImage; // Panasonic RAW format stores private tags using tag codes < 254 in // IFD 0. Redirect the parsing of these tags into a logical // "PanasonicRAW" IFD. // Panasonic is starting to use some higher numbers also (280..283). if (fMagic == 85 && parentCode == 0 && (tagCode < tcNewSubFileType || (tagCode >= 280 && tagCode <= 283))) { parentCode = tcPanasonicRAW; ifd = NULL; } stream.SetReadPosition (tagOffset); if (ifd && ifd->ParseTag (stream, parentCode, tagCode, tagType, tagCount, tagOffset)) { return; } stream.SetReadPosition (tagOffset); if (exif && shared && exif->ParseTag (stream, *shared, parentCode, isMainIFD, tagCode, tagType, tagCount, tagOffset)) { return; } stream.SetReadPosition (tagOffset); if (shared && exif && shared->ParseTag (stream, *exif, parentCode, isMainIFD, tagCode, tagType, tagCount, tagOffset, offsetDelta)) { return; } if (parentCode == tcLeicaMakerNote && tagType == ttUndefined && tagCount >= 14) { if (ParseMakerNoteIFD (host, stream, tagCount, tagOffset, offsetDelta, tagOffset, stream.Length (), tcLeicaMakerNote)) { return; } } if (parentCode == tcOlympusMakerNote && tagType == ttUndefined && tagCount >= 14) { uint32 olympusMakerParent = 0; switch (tagCode) { case 8208: olympusMakerParent = tcOlympusMakerNote8208; break; case 8224: olympusMakerParent = tcOlympusMakerNote8224; break; case 8240: olympusMakerParent = tcOlympusMakerNote8240; break; case 8256: olympusMakerParent = tcOlympusMakerNote8256; break; case 8272: olympusMakerParent = tcOlympusMakerNote8272; break; case 12288: olympusMakerParent = tcOlympusMakerNote12288; break; default: break; } if (olympusMakerParent) { // Olympus made a mistake in some camera models in computing // the size of these sub-tags, so we fudge the count. if (ParseMakerNoteIFD (host, stream, stream.Length () - tagOffset, tagOffset, offsetDelta, tagOffset, stream.Length (), olympusMakerParent)) { return; } } } if (parentCode == tcRicohMakerNote && tagCode == 0x2001 && tagType == ttUndefined && tagCount > 22) { char header [20]; stream.SetReadPosition (tagOffset); stream.Get (header, sizeof (header)); if (memcmp (header, "[Ricoh Camera Info]", 19) == 0) { ParseMakerNoteIFD (host, stream, tagCount - 20, tagOffset + 20, offsetDelta, tagOffset + 20, tagOffset + tagCount, tcRicohMakerNoteCameraInfo); return; } } #if qDNGValidate { stream.SetReadPosition (tagOffset); if (gVerbose) { printf ("*"); DumpTagValues (stream, LookupTagType (tagType), parentCode, tagCode, tagType, tagCount); } // If type is ASCII, then parse anyway so we report any ASCII // NULL termination or character set errors. else if (tagType == ttAscii) { dng_string s; ParseStringTag (stream, parentCode, tagCode, tagCount, s, false); } } #endif } /*****************************************************************************/ bool dng_info::ValidateIFD (dng_stream &stream, uint64 ifdOffset, int64 offsetDelta) { // Make sure we have a count. if (ifdOffset + 2 > stream.Length ()) { return false; } // Get entry count. stream.SetReadPosition (ifdOffset); uint32 ifdEntries = stream.Get_uint16 (); if (ifdEntries < 1) { return false; } // Make sure we have room for all entries and next IFD link. if (ifdOffset + 2 + ifdEntries * 12 + 4 > stream.Length ()) { return false; } // Check each entry. for (uint32 tag_index = 0; tag_index < ifdEntries; tag_index++) { stream.SetReadPosition (ifdOffset + 2 + tag_index * 12); stream.Skip (2); // Ignore tag code. uint32 tagType = stream.Get_uint16 (); uint32 tagCount = stream.Get_uint32 (); uint32 tag_type_size = TagTypeSize (tagType); if (tag_type_size == 0) { return false; } uint32 tag_data_size = SafeUint32Mult(tagCount, tag_type_size); if (tag_data_size > 4) { uint64 tagOffset = stream.Get_uint32 (); tagOffset += offsetDelta; if (SafeUint64Add(tagOffset, tag_data_size) > stream.Length()) { return false; } } } return true; } /*****************************************************************************/ void dng_info::ParseIFD (dng_host &host, dng_stream &stream, dng_exif *exif, dng_shared *shared, dng_ifd *ifd, uint64 ifdOffset, int64 offsetDelta, uint32 parentCode) { #if qDNGValidate bool isMakerNote = (parentCode >= tcFirstMakerNoteIFD && parentCode <= tcLastMakerNoteIFD); #endif stream.SetReadPosition (ifdOffset); if (ifd) { ifd->fThisIFD = ifdOffset; } uint32 ifdEntries = stream.Get_uint16 (); #if qDNGValidate if (gVerbose) { printf ("%s: Offset = %u, Entries = %u\n\n", LookupParentCode (parentCode), (unsigned) ifdOffset, (unsigned) ifdEntries); } if ((ifdOffset & 1) && !isMakerNote) { char message [256]; sprintf (message, "%s has odd offset (%u)", LookupParentCode (parentCode), (unsigned) ifdOffset); ReportWarning (message); } #endif uint32 prev_tag_code = 0; for (uint32 tag_index = 0; tag_index < ifdEntries; tag_index++) { stream.SetReadPosition (ifdOffset + 2 + tag_index * 12); uint32 tagCode = stream.Get_uint16 (); uint32 tagType = stream.Get_uint16 (); // Minolta 7D files have a bug in the EXIF block where the count // is wrong, and we run off into next IFD link. So if abort parsing // if we get a zero code/type combinations. if (tagCode == 0 && tagType == 0) { #if qDNGValidate char message [256]; sprintf (message, "%s had zero/zero tag code/type entry", LookupParentCode (parentCode)); ReportWarning (message); #endif return; } uint32 tagCount = stream.Get_uint32 (); #if qDNGValidate { if (tag_index > 0 && tagCode <= prev_tag_code && !isMakerNote) { char message [256]; sprintf (message, "%s tags are not sorted in ascending numerical order", LookupParentCode (parentCode)); ReportWarning (message); } } #endif prev_tag_code = tagCode; uint32 tag_type_size = TagTypeSize (tagType); if (tag_type_size == 0) { #if qDNGValidate { char message [256]; sprintf (message, "%s %s has unknown type (%u)", LookupParentCode (parentCode), LookupTagCode (parentCode, tagCode), (unsigned) tagType); ReportWarning (message); } #endif continue; } uint64 tagOffset = ifdOffset + 2 + tag_index * 12 + 8; if (SafeUint32Mult(tagCount, tag_type_size) > 4) { tagOffset = stream.Get_uint32 (); #if qDNGValidate { if (!(ifdOffset & 1) && (tagOffset & 1) && !isMakerNote && parentCode != tcKodakDCRPrivateIFD && parentCode != tcKodakKDCPrivateIFD) { char message [256]; sprintf (message, "%s %s has odd data offset (%u)", LookupParentCode (parentCode), LookupTagCode (parentCode, tagCode), (unsigned) tagOffset); ReportWarning (message); } } #endif tagOffset += offsetDelta; stream.SetReadPosition (tagOffset); } ParseTag (host, stream, exif, shared, ifd, parentCode, tagCode, tagType, tagCount, tagOffset, offsetDelta); } stream.SetReadPosition (ifdOffset + 2 + ifdEntries * 12); uint32 nextIFD = stream.Get_uint32 (); #if qDNGValidate if (gVerbose) { printf ("NextIFD = %u\n", (unsigned) nextIFD); } #endif if (ifd) { ifd->fNextIFD = nextIFD; } #if qDNGValidate if (nextIFD) { if (parentCode != 0 && (parentCode < tcFirstChainedIFD || parentCode > tcLastChainedIFD )) { char message [256]; sprintf (message, "%s has an unexpected non-zero NextIFD (%u)", LookupParentCode (parentCode), (unsigned) nextIFD); ReportWarning (message); } } if (gVerbose) { printf ("\n"); } #endif } /*****************************************************************************/ bool dng_info::ParseMakerNoteIFD (dng_host &host, dng_stream &stream, uint64 ifdSize, uint64 ifdOffset, int64 offsetDelta, uint64 minOffset, uint64 maxOffset, uint32 parentCode) { uint32 tagIndex; uint32 tagCode; uint32 tagType; uint32 tagCount; // Assume there is no next IFD pointer. fMakerNoteNextIFD = 0; // If size is too small to hold a single entry IFD, abort. if (ifdSize < 14) { return false; } // Get entry count. stream.SetReadPosition (ifdOffset); uint32 ifdEntries = stream.Get_uint16 (); // Make the entry count if reasonable for the MakerNote size. if (ifdEntries < 1 || 2 + ifdEntries * 12 > ifdSize) { return false; } // Scan IFD to verify all the tag types are all valid. for (tagIndex = 0; tagIndex < ifdEntries; tagIndex++) { stream.SetReadPosition (ifdOffset + 2 + tagIndex * 12 + 2); tagType = stream.Get_uint16 (); // Kludge: Some Canon MakerNotes contain tagType = 0 tags, so we // need to ignore them. This was a "firmware 1.0.4" Canon 40D raw file. if (parentCode == tcCanonMakerNote && tagType == 0) { continue; } if (TagTypeSize (tagType) == 0) { return false; } } // OK, the IFD looks reasonable enough to parse. #if qDNGValidate if (gVerbose) { printf ("%s: Offset = %u, Entries = %u\n\n", LookupParentCode (parentCode), (unsigned) ifdOffset, (unsigned) ifdEntries); } #endif for (tagIndex = 0; tagIndex < ifdEntries; tagIndex++) { stream.SetReadPosition (ifdOffset + 2 + tagIndex * 12); tagCode = stream.Get_uint16 (); tagType = stream.Get_uint16 (); tagCount = stream.Get_uint32 (); if (tagType == 0) { continue; } uint32 tagSize = SafeUint32Mult(tagCount, TagTypeSize (tagType)); uint64 tagOffset = ifdOffset + 2 + tagIndex * 12 + 8; if (tagSize > 4) { tagOffset = stream.Get_uint32 () + offsetDelta; if (tagOffset < minOffset || SafeUint64Add(tagOffset, tagSize) > maxOffset) { // Tag data is outside the valid offset range, // so ignore this tag. continue; } stream.SetReadPosition (tagOffset); } // Olympus switched to using IFDs in version 3 makernotes. if (parentCode == tcOlympusMakerNote && tagType == ttIFD && tagCount == 1) { uint32 olympusMakerParent = 0; switch (tagCode) { case 8208: olympusMakerParent = tcOlympusMakerNote8208; break; case 8224: olympusMakerParent = tcOlympusMakerNote8224; break; case 8240: olympusMakerParent = tcOlympusMakerNote8240; break; case 8256: olympusMakerParent = tcOlympusMakerNote8256; break; case 8272: olympusMakerParent = tcOlympusMakerNote8272; break; case 12288: olympusMakerParent = tcOlympusMakerNote12288; break; default: break; } if (olympusMakerParent) { stream.SetReadPosition (tagOffset); uint64 subMakerNoteOffset = stream.Get_uint32 () + offsetDelta; if (subMakerNoteOffset >= minOffset && subMakerNoteOffset < maxOffset) { if (ParseMakerNoteIFD (host, stream, maxOffset - subMakerNoteOffset, subMakerNoteOffset, offsetDelta, minOffset, maxOffset, olympusMakerParent)) { continue; } } } stream.SetReadPosition (tagOffset); } ParseTag (host, stream, fExif.Get (), fShared.Get (), NULL, parentCode, tagCode, tagType, tagCount, tagOffset, offsetDelta); } // Grab next IFD pointer, for possible use. if (ifdSize >= 2 + ifdEntries * 12 + 4) { stream.SetReadPosition (ifdOffset + 2 + ifdEntries * 12); fMakerNoteNextIFD = stream.Get_uint32 (); } #if qDNGValidate if (gVerbose) { printf ("\n"); } #endif return true; } /*****************************************************************************/ void dng_info::ParseMakerNote (dng_host &host, dng_stream &stream, uint32 makerNoteCount, uint64 makerNoteOffset, int64 offsetDelta, uint64 minOffset, uint64 maxOffset) { uint8 firstBytes [16]; memset (firstBytes, 0, sizeof (firstBytes)); stream.SetReadPosition (makerNoteOffset); stream.Get (firstBytes, (uint32) Min_uint64 (sizeof (firstBytes), makerNoteCount)); // Epson MakerNote with header. if (memcmp (firstBytes, "EPSON\000\001\000", 8) == 0) { if (makerNoteCount > 8) { ParseMakerNoteIFD (host, stream, makerNoteCount - 8, makerNoteOffset + 8, offsetDelta, minOffset, maxOffset, tcEpsonMakerNote); } return; } // Fujifilm MakerNote. if (memcmp (firstBytes, "FUJIFILM", 8) == 0) { stream.SetReadPosition (makerNoteOffset + 8); TempLittleEndian tempEndian (stream); uint32 ifd_offset = stream.Get_uint32 (); if (ifd_offset >= 12 && ifd_offset < makerNoteCount) { ParseMakerNoteIFD (host, stream, makerNoteCount - ifd_offset, makerNoteOffset + ifd_offset, makerNoteOffset, minOffset, maxOffset, tcFujiMakerNote); } return; } // Leica MakerNote for models that store entry offsets relative to the start of // the MakerNote (e.g., M9). if ((memcmp (firstBytes, "LEICA\000\000\000", 8) == 0) || (memcmp (firstBytes, "LEICA0\003\000", 8) == 0) || (memcmp (firstBytes, "LEICA\000\001\000", 8) == 0) || (memcmp (firstBytes, "LEICA\000\005\000", 8) == 0)) { if (makerNoteCount > 8) { ParseMakerNoteIFD (host, stream, makerNoteCount - 8, makerNoteOffset + 8, makerNoteOffset, minOffset, maxOffset, tcLeicaMakerNote); } return; } // Leica MakerNote for models that store absolute entry offsets (i.e., relative // to the start of the file, e.g., S2). if (memcmp (firstBytes, "LEICA\000\002\377", 8) == 0) { if (makerNoteCount > 8) { ParseMakerNoteIFD (host, stream, makerNoteCount - 8, makerNoteOffset + 8, offsetDelta, minOffset, maxOffset, tcLeicaMakerNote); } return; } // Nikon version 2 MakerNote with header. if (memcmp (firstBytes, "Nikon\000\002", 7) == 0) { stream.SetReadPosition (makerNoteOffset + 10); bool bigEndian = false; uint16 endianMark = stream.Get_uint16 (); if (endianMark == byteOrderMM) { bigEndian = true; } else if (endianMark != byteOrderII) { return; } TempBigEndian temp_endian (stream, bigEndian); uint16 magic = stream.Get_uint16 (); if (magic != 42) { return; } uint32 ifd_offset = stream.Get_uint32 (); if (ifd_offset >= 8 && ifd_offset < makerNoteCount - 10) { ParseMakerNoteIFD (host, stream, makerNoteCount - 10 - ifd_offset, makerNoteOffset + 10 + ifd_offset, makerNoteOffset + 10, minOffset, maxOffset, tcNikonMakerNote); } return; } // Newer version of Olympus MakerNote with byte order mark. if (memcmp (firstBytes, "OLYMPUS\000", 8) == 0) { stream.SetReadPosition (makerNoteOffset + 8); bool bigEndian = false; uint16 endianMark = stream.Get_uint16 (); if (endianMark == byteOrderMM) { bigEndian = true; } else if (endianMark != byteOrderII) { return; } TempBigEndian temp_endian (stream, bigEndian); uint16 version = stream.Get_uint16 (); if (version != 3) { return; } if (makerNoteCount > 12) { ParseMakerNoteIFD (host, stream, makerNoteCount - 12, makerNoteOffset + 12, makerNoteOffset, minOffset, maxOffset, tcOlympusMakerNote); } return; } // Olympus MakerNote with header. if (memcmp (firstBytes, "OLYMP", 5) == 0) { if (makerNoteCount > 8) { ParseMakerNoteIFD (host, stream, makerNoteCount - 8, makerNoteOffset + 8, offsetDelta, minOffset, maxOffset, tcOlympusMakerNote); } return; } // Panasonic MakerNote. if (memcmp (firstBytes, "Panasonic\000\000\000", 12) == 0) { if (makerNoteCount > 12) { ParseMakerNoteIFD (host, stream, makerNoteCount - 12, makerNoteOffset + 12, offsetDelta, minOffset, maxOffset, tcPanasonicMakerNote); } return; } // Pentax MakerNote. if (memcmp (firstBytes, "AOC", 4) == 0) { if (makerNoteCount > 6) { stream.SetReadPosition (makerNoteOffset + 4); bool bigEndian = stream.BigEndian (); uint16 endianMark = stream.Get_uint16 (); if (endianMark == byteOrderMM) { bigEndian = true; } else if (endianMark == byteOrderII) { bigEndian = false; } TempBigEndian temp_endian (stream, bigEndian); ParseMakerNoteIFD (host, stream, makerNoteCount - 6, makerNoteOffset + 6, offsetDelta, minOffset, maxOffset, tcPentaxMakerNote); } return; } // Ricoh MakerNote. if (memcmp (firstBytes, "RICOH", 5) == 0 || memcmp (firstBytes, "Ricoh", 5) == 0) { if (makerNoteCount > 8) { TempBigEndian tempEndian (stream); ParseMakerNoteIFD (host, stream, makerNoteCount - 8, makerNoteOffset + 8, offsetDelta, minOffset, maxOffset, tcRicohMakerNote); } return; } // Nikon MakerNote without header. if (fExif->fMake.StartsWith ("NIKON")) { ParseMakerNoteIFD (host, stream, makerNoteCount, makerNoteOffset, offsetDelta, minOffset, maxOffset, tcNikonMakerNote); return; } // Canon MakerNote. if (fExif->fMake.StartsWith ("CANON")) { ParseMakerNoteIFD (host, stream, makerNoteCount, makerNoteOffset, offsetDelta, minOffset, maxOffset, tcCanonMakerNote); return; } // Minolta MakerNote. if (fExif->fMake.StartsWith ("MINOLTA" ) || fExif->fMake.StartsWith ("KONICA MINOLTA")) { ParseMakerNoteIFD (host, stream, makerNoteCount, makerNoteOffset, offsetDelta, minOffset, maxOffset, tcMinoltaMakerNote); return; } // Sony MakerNote. if (fExif->fMake.StartsWith ("SONY")) { ParseMakerNoteIFD (host, stream, makerNoteCount, makerNoteOffset, offsetDelta, minOffset, maxOffset, tcSonyMakerNote); return; } // Kodak MakerNote. if (fExif->fMake.StartsWith ("EASTMAN KODAK")) { ParseMakerNoteIFD (host, stream, makerNoteCount, makerNoteOffset, offsetDelta, minOffset, maxOffset, tcKodakMakerNote); return; } // Mamiya MakerNote. if (fExif->fMake.StartsWith ("Mamiya")) { ParseMakerNoteIFD (host, stream, makerNoteCount, makerNoteOffset, offsetDelta, minOffset, maxOffset, tcMamiyaMakerNote); // Mamiya uses a MakerNote chain. while (fMakerNoteNextIFD) { ParseMakerNoteIFD (host, stream, makerNoteCount, offsetDelta + fMakerNoteNextIFD, offsetDelta, minOffset, maxOffset, tcMamiyaMakerNote); } return; } // Nikon MakerNote without header. if (fExif->fMake.StartsWith ("Hasselblad")) { ParseMakerNoteIFD (host, stream, makerNoteCount, makerNoteOffset, offsetDelta, minOffset, maxOffset, tcHasselbladMakerNote); return; } // Samsung MakerNote. if (fExif->fMake.StartsWith ("Samsung")) { ParseMakerNoteIFD (host, stream, makerNoteCount, makerNoteOffset, makerNoteOffset, minOffset, maxOffset, tcSamsungMakerNote); return; } // Casio MakerNote. if (fExif->fMake.StartsWith ("CASIO COMPUTER") && memcmp (firstBytes, "QVC\000\000\000", 6) == 0) { ParseMakerNoteIFD (host, stream, makerNoteCount - 6, makerNoteOffset + 6, makerNoteOffset, minOffset, maxOffset, tcCasioMakerNote); return; } } /*****************************************************************************/ void dng_info::ParseSonyPrivateData (dng_host & /* host */, dng_stream & /* stream */, uint64 /* count */, uint64 /* oldOffset */, uint64 /* newOffset */) { // Sony private data is encrypted, sorry. } /*****************************************************************************/ void dng_info::ParseDNGPrivateData (dng_host &host, dng_stream &stream) { if (fShared->fDNGPrivateDataCount < 2) { return; } // DNG private data should always start with a null-terminated // company name, to define the format of the private data. dng_string privateName; { char buffer [64]; stream.SetReadPosition (fShared->fDNGPrivateDataOffset); uint32 readLength = Min_uint32 (fShared->fDNGPrivateDataCount, sizeof (buffer) - 1); stream.Get (buffer, readLength); buffer [readLength] = 0; privateName.Set (buffer); } // Pentax is storing their MakerNote in the DNGPrivateData data. if (privateName.StartsWith ("PENTAX" ) || privateName.StartsWith ("SAMSUNG")) { #if qDNGValidate if (gVerbose) { printf ("Parsing Pentax/Samsung DNGPrivateData\n\n"); } #endif stream.SetReadPosition (fShared->fDNGPrivateDataOffset + 8); bool bigEndian = stream.BigEndian (); uint16 endianMark = stream.Get_uint16 (); if (endianMark == byteOrderMM) { bigEndian = true; } else if (endianMark == byteOrderII) { bigEndian = false; } TempBigEndian temp_endian (stream, bigEndian); ParseMakerNoteIFD (host, stream, fShared->fDNGPrivateDataCount - 10, fShared->fDNGPrivateDataOffset + 10, fShared->fDNGPrivateDataOffset, fShared->fDNGPrivateDataOffset, fShared->fDNGPrivateDataOffset + fShared->fDNGPrivateDataCount, tcPentaxMakerNote); return; } // Stop parsing if this is not an Adobe format block. if (!privateName.Matches ("Adobe")) { return; } TempBigEndian temp_order (stream); uint32 section_offset = 6; while (SafeUint32Add(section_offset, 8) < fShared->fDNGPrivateDataCount) { stream.SetReadPosition (SafeUint64Add(fShared->fDNGPrivateDataOffset, section_offset)); uint32 section_key = stream.Get_uint32 (); uint32 section_count = stream.Get_uint32 (); if (section_key == DNG_CHAR4 ('M','a','k','N') && section_count > 6) { #if qDNGValidate if (gVerbose) { printf ("Found MakerNote inside DNGPrivateData\n\n"); } #endif uint16 order_mark = stream.Get_uint16 (); int64 old_offset = stream.Get_uint32 (); uint32 tempSize = SafeUint32Sub(section_count, 6); AutoPtr tempBlock (host.Allocate (tempSize)); uint64 positionInOriginalFile = stream.PositionInOriginalFile(); stream.Get (tempBlock->Buffer (), tempSize); dng_stream tempStream (tempBlock->Buffer (), tempSize, positionInOriginalFile); tempStream.SetBigEndian (order_mark == byteOrderMM); ParseMakerNote (host, tempStream, tempSize, 0, 0 - old_offset, 0, tempSize); } else if (section_key == DNG_CHAR4 ('S','R','2',' ') && section_count > 6) { #if qDNGValidate if (gVerbose) { printf ("Found Sony private data inside DNGPrivateData\n\n"); } #endif uint16 order_mark = stream.Get_uint16 (); uint64 old_offset = stream.Get_uint32 (); uint64 new_offset = fShared->fDNGPrivateDataOffset + section_offset + 14; TempBigEndian sr2_order (stream, order_mark == byteOrderMM); ParseSonyPrivateData (host, stream, section_count - 6, old_offset, new_offset); } else if (section_key == DNG_CHAR4 ('R','A','F',' ') && section_count > 4) { #if qDNGValidate if (gVerbose) { printf ("Found Fuji RAF tags inside DNGPrivateData\n\n"); } #endif uint16 order_mark = stream.Get_uint16 (); uint32 tagCount = stream.Get_uint32 (); uint64 tagOffset = stream.Position (); if (tagCount) { TempBigEndian raf_order (stream, order_mark == byteOrderMM); ParseTag (host, stream, fExif.Get (), fShared.Get (), NULL, tcFujiRAF, tcFujiHeader, ttUndefined, tagCount, tagOffset, 0); stream.SetReadPosition (SafeUint64Add(tagOffset, tagCount)); } tagCount = stream.Get_uint32 (); tagOffset = stream.Position (); if (tagCount) { TempBigEndian raf_order (stream, order_mark == byteOrderMM); ParseTag (host, stream, fExif.Get (), fShared.Get (), NULL, tcFujiRAF, tcFujiRawInfo1, ttUndefined, tagCount, tagOffset, 0); stream.SetReadPosition (SafeUint64Add(tagOffset, tagCount)); } tagCount = stream.Get_uint32 (); tagOffset = stream.Position (); if (tagCount) { TempBigEndian raf_order (stream, order_mark == byteOrderMM); ParseTag (host, stream, fExif.Get (), fShared.Get (), NULL, tcFujiRAF, tcFujiRawInfo2, ttUndefined, tagCount, tagOffset, 0); stream.SetReadPosition (SafeUint64Add(tagOffset, tagCount)); } } else if (section_key == DNG_CHAR4 ('C','n','t','x') && section_count > 4) { #if qDNGValidate if (gVerbose) { printf ("Found Contax Raw header inside DNGPrivateData\n\n"); } #endif uint16 order_mark = stream.Get_uint16 (); uint32 tagCount = stream.Get_uint32 (); uint64 tagOffset = stream.Position (); if (tagCount) { TempBigEndian contax_order (stream, order_mark == byteOrderMM); ParseTag (host, stream, fExif.Get (), fShared.Get (), NULL, tcContaxRAW, tcContaxHeader, ttUndefined, tagCount, tagOffset, 0); } } else if (section_key == DNG_CHAR4 ('C','R','W',' ') && section_count > 4) { #if qDNGValidate if (gVerbose) { printf ("Found Canon CRW tags inside DNGPrivateData\n\n"); } #endif uint16 order_mark = stream.Get_uint16 (); uint32 entries = stream.Get_uint16 (); uint64 crwTagStart = stream.Position (); for (uint32 parsePass = 1; parsePass <= 2; parsePass++) { stream.SetReadPosition (crwTagStart); for (uint32 index = 0; index < entries; index++) { uint32 tagCode = stream.Get_uint16 (); uint32 tagCount = stream.Get_uint32 (); uint64 tagOffset = stream.Position (); // We need to grab the model id tag first, and then all the // other tags. if ((parsePass == 1) == (tagCode == 0x5834)) { TempBigEndian tag_order (stream, order_mark == byteOrderMM); ParseTag (host, stream, fExif.Get (), fShared.Get (), NULL, tcCanonCRW, tagCode, ttUndefined, tagCount, tagOffset, 0); } stream.SetReadPosition (tagOffset + tagCount); } } } else if (section_count > 4) { uint32 parentCode = 0; bool code32 = false; bool hasType = true; switch (section_key) { case DNG_CHAR4 ('M','R','W',' '): { parentCode = tcMinoltaMRW; code32 = true; hasType = false; break; } case DNG_CHAR4 ('P','a','n','o'): { parentCode = tcPanasonicRAW; break; } case DNG_CHAR4 ('L','e','a','f'): { parentCode = tcLeafMOS; break; } case DNG_CHAR4 ('K','o','d','a'): { parentCode = tcKodakDCRPrivateIFD; break; } case DNG_CHAR4 ('K','D','C',' '): { parentCode = tcKodakKDCPrivateIFD; break; } default: break; } if (parentCode) { #if qDNGValidate if (gVerbose) { printf ("Found %s tags inside DNGPrivateData\n\n", LookupParentCode (parentCode)); } #endif uint16 order_mark = stream.Get_uint16 (); uint32 entries = stream.Get_uint16 (); for (uint32 index = 0; index < entries; index++) { uint32 tagCode = code32 ? stream.Get_uint32 () : stream.Get_uint16 (); uint32 tagType = hasType ? stream.Get_uint16 () : ttUndefined; uint32 tagCount = stream.Get_uint32 (); uint32 tagSize = SafeUint32Mult(tagCount, TagTypeSize (tagType)); uint64 tagOffset = stream.Position (); TempBigEndian tag_order (stream, order_mark == byteOrderMM); ParseTag (host, stream, fExif.Get (), fShared.Get (), NULL, parentCode, tagCode, tagType, tagCount, tagOffset, 0); stream.SetReadPosition (SafeUint64Add(tagOffset, tagSize)); } } } section_offset = SafeUint32Add(section_offset, 8); section_offset = SafeUint32Add(section_offset, section_count); if (section_offset & 1) { section_offset = SafeUint32Add(section_offset, 1); } } } /*****************************************************************************/ void dng_info::Parse (dng_host &host, dng_stream &stream) { fTIFFBlockOffset = stream.Position (); fTIFFBlockOriginalOffset = stream.PositionInOriginalFile (); // Check byte order indicator. uint16 byteOrder = stream.Get_uint16 (); if (byteOrder == byteOrderII) { fBigEndian = false; #if qDNGValidate if (gVerbose) { printf ("\nUses little-endian byte order\n"); } #endif stream.SetLittleEndian (); } else if (byteOrder == byteOrderMM) { fBigEndian = true; #if qDNGValidate if (gVerbose) { printf ("\nUses big-endian byte order\n"); } #endif stream.SetBigEndian (); } else { #if qDNGValidate ReportError ("Unknown byte order"); #endif ThrowBadFormat (); } // Check "magic number" indicator. fMagic = stream.Get_uint16 (); #if qDNGValidate if (gVerbose) { printf ("Magic number = %u\n\n", (unsigned) fMagic); } #endif ValidateMagic (); // Parse IFD 0. uint64 next_offset = stream.Get_uint32 (); fExif.Reset (host.Make_dng_exif ()); fShared.Reset (host.Make_dng_shared ()); fIFD [0].Reset (host.Make_dng_ifd ()); ParseIFD (host, stream, fExif.Get (), fShared.Get (), fIFD [0].Get (), fTIFFBlockOffset + next_offset, fTIFFBlockOffset, 0); next_offset = fIFD [0]->fNextIFD; fIFDCount = 1; // Parse chained IFDs. while (next_offset) { if (next_offset >= stream.Length ()) { #if qDNGValidate { ReportWarning ("Chained IFD offset past end of stream"); } #endif break; } // Some TIFF file writers forget about the next IFD offset, so // validate the IFD at that offset before parsing it. if (!ValidateIFD (stream, fTIFFBlockOffset + next_offset, fTIFFBlockOffset)) { #if qDNGValidate { ReportWarning ("Chained IFD is not valid"); } #endif break; } if (fChainedIFDCount == kMaxChainedIFDs) { #if qDNGValidate { ReportWarning ("Chained IFD count exceeds DNG SDK parsing limit"); } #endif break; } fChainedIFD [fChainedIFDCount].Reset (host.Make_dng_ifd ()); ParseIFD (host, stream, NULL, NULL, fChainedIFD [fChainedIFDCount].Get (), fTIFFBlockOffset + next_offset, fTIFFBlockOffset, tcFirstChainedIFD + fChainedIFDCount); next_offset = fChainedIFD [fChainedIFDCount]->fNextIFD; fChainedIFDCount++; } // Parse SubIFDs. uint32 searchedIFDs = 0; bool tooManySubIFDs = false; while (searchedIFDs < fIFDCount && !tooManySubIFDs) { uint32 searchLimit = fIFDCount; for (uint32 searchIndex = searchedIFDs; searchIndex < searchLimit && !tooManySubIFDs; searchIndex++) { for (uint32 subIndex = 0; subIndex < fIFD [searchIndex]->fSubIFDsCount; subIndex++) { if (fIFDCount == kMaxSubIFDs + 1) { tooManySubIFDs = true; break; } stream.SetReadPosition (fIFD [searchIndex]->fSubIFDsOffset + subIndex * 4); uint32 sub_ifd_offset = stream.Get_uint32 (); fIFD [fIFDCount].Reset (host.Make_dng_ifd ()); ParseIFD (host, stream, fExif.Get (), fShared.Get (), fIFD [fIFDCount].Get (), fTIFFBlockOffset + sub_ifd_offset, fTIFFBlockOffset, tcFirstSubIFD + fIFDCount - 1); fIFDCount++; } searchedIFDs = searchLimit; } } #if qDNGValidate { if (tooManySubIFDs) { ReportWarning ("SubIFD count exceeds DNG SDK parsing limit"); } } #endif // Parse EXIF IFD. if (fShared->fExifIFD) { ParseIFD (host, stream, fExif.Get (), fShared.Get (), NULL, fTIFFBlockOffset + fShared->fExifIFD, fTIFFBlockOffset, tcExifIFD); } // Parse GPS IFD. if (fShared->fGPSInfo) { ParseIFD (host, stream, fExif.Get (), fShared.Get (), NULL, fTIFFBlockOffset + fShared->fGPSInfo, fTIFFBlockOffset, tcGPSInfo); } // Parse Interoperability IFD. if (fShared->fInteroperabilityIFD) { // Some Kodak KDC files have bogus Interoperability IFDs, so // validate the IFD before trying to parse it. if (ValidateIFD (stream, fTIFFBlockOffset + fShared->fInteroperabilityIFD, fTIFFBlockOffset)) { ParseIFD (host, stream, fExif.Get (), fShared.Get (), NULL, fTIFFBlockOffset + fShared->fInteroperabilityIFD, fTIFFBlockOffset, tcInteroperabilityIFD); } #if qDNGValidate else { ReportWarning ("The Interoperability IFD is not a valid IFD"); } #endif } // Parse Kodak DCR Private IFD. if (fShared->fKodakDCRPrivateIFD) { ParseIFD (host, stream, fExif.Get (), fShared.Get (), NULL, fTIFFBlockOffset + fShared->fKodakDCRPrivateIFD, fTIFFBlockOffset, tcKodakDCRPrivateIFD); } // Parse Kodak KDC Private IFD. if (fShared->fKodakKDCPrivateIFD) { ParseIFD (host, stream, fExif.Get (), fShared.Get (), NULL, fTIFFBlockOffset + fShared->fKodakKDCPrivateIFD, fTIFFBlockOffset, tcKodakKDCPrivateIFD); } // Parse MakerNote tag. if (fShared->fMakerNoteCount) { ParseMakerNote (host, stream, (uint32) (fTIFFBlockOffset + fShared->fMakerNoteCount), fShared->fMakerNoteOffset, fTIFFBlockOffset, 0, stream.Length ()); } // Parse DNGPrivateData tag. if (fShared->fDNGPrivateDataCount && fShared->fDNGVersion) { ParseDNGPrivateData (host, stream); } #if qDNGValidate // If we are running dng_validate on stand-alone camera profile file, // complete the validation of the profile. if (fMagic == magicExtendedProfile) { dng_camera_profile_info &profileInfo = fShared->fCameraProfile; dng_camera_profile profile; profile.Parse (stream, profileInfo); if (profileInfo.fColorPlanes < 3 || !profile.IsValid (profileInfo.fColorPlanes)) { ReportError ("Invalid camera profile file"); } } #endif } /*****************************************************************************/ void dng_info::PostParse (dng_host &host) { uint32 index; fExif->PostParse (host, *fShared.Get ()); fShared->PostParse (host, *fExif.Get ()); for (index = 0; index < fIFDCount; index++) { fIFD [index]->PostParse (); } for (index = 0; index < fChainedIFDCount; index++) { fChainedIFD [index]->PostParse (); } if (fShared->fDNGVersion != 0) { // Find main IFD. fMainIndex = -1; for (index = 0; index < fIFDCount; index++) { if (fIFD [index]->fUsesNewSubFileType && fIFD [index]->fNewSubFileType == sfMainImage) { if (fMainIndex == -1) { fMainIndex = index; } #if qDNGValidate else { ReportError ("Multiple IFDs marked as main image"); } #endif } else if (fIFD [index]->fNewSubFileType == sfPreviewImage || fIFD [index]->fNewSubFileType == sfAltPreviewImage) { // Fill in default color space for DNG previews if not included. if (fIFD [index]->fPreviewInfo.fColorSpace == previewColorSpace_MaxEnum) { if (fIFD [index]->fSamplesPerPixel == 1) { fIFD [index]->fPreviewInfo.fColorSpace = previewColorSpace_GrayGamma22; } else { fIFD [index]->fPreviewInfo.fColorSpace = previewColorSpace_sRGB; } } } } // Deal with lossless JPEG bug in early DNG versions. if (fShared->fDNGVersion < dngVersion_1_1_0_0) { if (fMainIndex != -1) { fIFD [fMainIndex]->fLosslessJPEGBug16 = true; } } // Find mask index. for (index = 0; index < fIFDCount; index++) { if (fIFD [index]->fNewSubFileType == sfTransparencyMask) { if (fMaskIndex == -1) { fMaskIndex = index; } #if qDNGValidate else { ReportError ("Multiple IFDs marked as transparency mask image"); } #endif } } // Warn about Chained IFDs. #if qDNGValidate if (fChainedIFDCount > 0) { ReportWarning ("This file has Chained IFDs, which will be ignored by DNG readers"); } #endif } } /*****************************************************************************/ bool dng_info::IsValidDNG () { // Check shared info. if (!fShared->IsValidDNG ()) { return false; } // Check TIFF magic number. if (fMagic != 42) { #if qDNGValidate ReportError ("Invalid TIFF magic number"); #endif return false; } // Make sure we have a main image IFD. if (fMainIndex == -1) { #if qDNGValidate ReportError ("Unable to find main image IFD"); #endif return false; } // Make sure is each IFD is valid. for (uint32 index = 0; index < fIFDCount; index++) { uint32 parentCode = (index == 0 ? 0 : tcFirstSubIFD + index - 1); if (!fIFD [index]->IsValidDNG (*fShared.Get (), parentCode)) { // Only errors in the main and transparency mask IFDs are fatal to parsing. if (index == (uint32) fMainIndex || index == (uint32) fMaskIndex) { return false; } } } return true; } /*****************************************************************************/