void dng_iptc::ParseString (dng_stream &stream,
dng_string &s,
CharSet charSet)
{
uint32 length = stream.Get_uint16 ();
dng_memory_data buffer (length + 1);
char *c = buffer.Buffer_char ();
stream.Get (c, length);
c [length] = 0;
switch (charSet)
{
case kCharSetUTF8:
{
s.Set_UTF8 (c);
break;
}
default:
{
s.Set_SystemEncoding (c);
}
}
s.SetLineEndingsToNewLines ();
s.StripLowASCII ();
s.TrimTrailingBlanks ();
}
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 == 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
}
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.
if (memcmp (firstBytes, "LEICA\000\000\000", 8) == 0)
{
if (makerNoteCount > 8)
{
ParseMakerNoteIFD (host,
stream,
makerNoteCount - 8,
makerNoteOffset + 8,
makerNoteOffset,
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;
}
}
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 (section_offset + 8 < fShared->fDNGPrivateDataCount)
{
stream.SetReadPosition (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 ();
uint64 old_offset = stream.Get_uint32 ();
uint32 tempSize = section_count - 6;
AutoPtr<dng_memory_block> 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 (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 (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 (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 = 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 (tagOffset + tagSize);
}
}
}
section_offset += 8 + section_count;
if (section_offset & 1)
{
section_offset++;
}
}
}
bool dng_shared::Parse_ifd0 (dng_stream &stream,
dng_exif & /* exif */,
uint32 parentCode,
uint32 tagCode,
uint32 tagType,
uint32 tagCount,
uint64 tagOffset)
{
switch (tagCode)
{
case tcXMP:
{
CheckTagType (parentCode, tagCode, tagType, ttByte);
fXMPCount = tagCount;
fXMPOffset = fXMPCount ? tagOffset : 0;
#if qDNGValidate
if (gVerbose)
{
printf ("XMP: Count = %u, Offset = %u\n",
(unsigned) fXMPCount,
(unsigned) fXMPOffset);
if (fXMPCount)
{
DumpXMP (stream, fXMPCount);
}
}
#endif
break;
}
case tcIPTC_NAA:
{
CheckTagType (parentCode, tagCode, tagType, ttLong, ttAscii);
fIPTC_NAA_Count = tagCount * TagTypeSize (tagType);
fIPTC_NAA_Offset = fIPTC_NAA_Count ? tagOffset : 0;
#if qDNGValidate
if (gVerbose)
{
printf ("IPTC/NAA: Count = %u, Offset = %u\n",
(unsigned) fIPTC_NAA_Count,
(unsigned) fIPTC_NAA_Offset);
if (fIPTC_NAA_Count)
{
DumpHexAscii (stream, fIPTC_NAA_Count);
}
// Compute and output the digest.
dng_memory_data buffer (fIPTC_NAA_Count);
stream.SetReadPosition (fIPTC_NAA_Offset);
stream.Get (buffer.Buffer (), fIPTC_NAA_Count);
const uint8 *data = buffer.Buffer_uint8 ();
uint32 count = fIPTC_NAA_Count;
// Method 1: Counting all bytes (this is correct).
{
dng_md5_printer printer;
printer.Process (data, count);
printf ("IPTCDigest: ");
DumpFingerprint (printer.Result ());
printf ("\n");
}
// Method 2: Ignoring zero padding.
{
uint32 removed = 0;
while ((removed < 3) && (count > 0) && (data [count - 1] == 0))
{
removed++;
count--;
}
if (removed != 0)
{
dng_md5_printer printer;
printer.Process (data, count);
printf ("IPTCDigest (ignoring zero padding): ");
DumpFingerprint (printer.Result ());
printf ("\n");
}
}
}
#endif
break;
}
case tcExifIFD:
{
CheckTagType (parentCode, tagCode, tagType, ttLong, ttIFD);
CheckTagCount (parentCode, tagCode, tagCount, 1);
fExifIFD = stream.TagValue_uint32 (tagType);
#if qDNGValidate
if (gVerbose)
{
printf ("ExifIFD: %u\n", (unsigned) fExifIFD);
}
#endif
break;
}
case tcGPSInfo:
{
CheckTagType (parentCode, tagCode, tagType, ttLong, ttIFD);
CheckTagCount (parentCode, tagCode, tagCount, 1);
fGPSInfo = stream.TagValue_uint32 (tagType);
#if qDNGValidate
if (gVerbose)
{
printf ("GPSInfo: %u\n", (unsigned) fGPSInfo);
}
#endif
break;
}
case tcKodakDCRPrivateIFD:
{
CheckTagType (parentCode, tagCode, tagType, ttLong, ttIFD);
CheckTagCount (parentCode, tagCode, tagCount, 1);
fKodakDCRPrivateIFD = stream.TagValue_uint32 (tagType);
#if qDNGValidate
if (gVerbose)
{
printf ("KodakDCRPrivateIFD: %u\n", (unsigned) fKodakDCRPrivateIFD);
}
#endif
break;
}
case tcKodakKDCPrivateIFD:
{
CheckTagType (parentCode, tagCode, tagType, ttLong, ttIFD);
CheckTagCount (parentCode, tagCode, tagCount, 1);
fKodakKDCPrivateIFD = stream.TagValue_uint32 (tagType);
#if qDNGValidate
if (gVerbose)
{
printf ("KodakKDCPrivateIFD: %u\n", (unsigned) fKodakKDCPrivateIFD);
}
#endif
break;
}
case tcDNGVersion:
{
CheckTagType (parentCode, tagCode, tagType, ttByte);
CheckTagCount (parentCode, tagCode, tagCount, 4);
uint32 b0 = stream.Get_uint8 ();
uint32 b1 = stream.Get_uint8 ();
uint32 b2 = stream.Get_uint8 ();
uint32 b3 = stream.Get_uint8 ();
fDNGVersion = (b0 << 24) | (b1 << 16) | (b2 << 8) | b3;
#if qDNGValidate
if (gVerbose)
{
printf ("DNGVersion: %u.%u.%u.%u\n",
(unsigned) b0,
(unsigned) b1,
(unsigned) b2,
(unsigned) b3);
}
#endif
break;
}
case tcDNGBackwardVersion:
{
CheckTagType (parentCode, tagCode, tagType, ttByte);
CheckTagCount (parentCode, tagCode, tagCount, 4);
uint32 b0 = stream.Get_uint8 ();
uint32 b1 = stream.Get_uint8 ();
uint32 b2 = stream.Get_uint8 ();
uint32 b3 = stream.Get_uint8 ();
fDNGBackwardVersion = (b0 << 24) | (b1 << 16) | (b2 << 8) | b3;
#if qDNGValidate
if (gVerbose)
{
printf ("DNGBackwardVersion: %u.%u.%u.%u\n",
(unsigned) b0,
(unsigned) b1,
(unsigned) b2,
(unsigned) b3);
}
#endif
break;
}
case tcUniqueCameraModel:
{
CheckTagType (parentCode, tagCode, tagType, ttAscii);
ParseStringTag (stream,
parentCode,
tagCode,
tagCount,
fUniqueCameraModel,
false);
bool didTrim = fUniqueCameraModel.TrimTrailingBlanks ();
#if qDNGValidate
if (didTrim)
{
ReportWarning ("UniqueCameraModel string has trailing blanks");
}
if (gVerbose)
{
printf ("UniqueCameraModel: ");
DumpString (fUniqueCameraModel);
printf ("\n");
}
#else
(void) didTrim; // Unused
#endif
break;
}
case tcLocalizedCameraModel:
{
CheckTagType (parentCode, tagCode, tagType, ttAscii, ttByte);
ParseStringTag (stream,
parentCode,
tagCode,
tagCount,
fLocalizedCameraModel,
false,
false);
bool didTrim = fLocalizedCameraModel.TrimTrailingBlanks ();
#if qDNGValidate
if (didTrim)
{
ReportWarning ("LocalizedCameraModel string has trailing blanks");
}
if (gVerbose)
{
printf ("LocalizedCameraModel: ");
DumpString (fLocalizedCameraModel);
printf ("\n");
}
#else
(void) didTrim; // Unused
#endif
break;
}
case tcCameraCalibration1:
{
CheckTagType (parentCode, tagCode, tagType, ttSRational);
if (!CheckColorImage (parentCode, tagCode, fCameraProfile.fColorPlanes))
return false;
if (!ParseMatrixTag (stream,
parentCode,
tagCode,
tagType,
tagCount,
fCameraProfile.fColorPlanes,
fCameraProfile.fColorPlanes,
fCameraCalibration1))
return false;
#if qDNGValidate
if (gVerbose)
{
printf ("CameraCalibration1:\n");
DumpMatrix (fCameraCalibration1);
}
#endif
break;
}
case tcCameraCalibration2:
{
CheckTagType (parentCode, tagCode, tagType, ttSRational);
if (!CheckColorImage (parentCode, tagCode, fCameraProfile.fColorPlanes))
return false;
if (!ParseMatrixTag (stream,
parentCode,
tagCode,
tagType,
tagCount,
fCameraProfile.fColorPlanes,
fCameraProfile.fColorPlanes,
fCameraCalibration2))
return false;
#if qDNGValidate
if (gVerbose)
{
printf ("CameraCalibration2:\n");
DumpMatrix (fCameraCalibration2);
}
#endif
break;
}
case tcCameraCalibrationSignature:
{
CheckTagType (parentCode, tagCode, tagType, ttAscii, ttByte);
ParseStringTag (stream,
parentCode,
tagCode,
tagCount,
fCameraCalibrationSignature,
false,
false);
#if qDNGValidate
if (gVerbose)
{
printf ("CameraCalibrationSignature: ");
DumpString (fCameraCalibrationSignature);
printf ("\n");
}
#endif
break;
}
case tcAnalogBalance:
{
CheckTagType (parentCode, tagCode, tagType, ttRational);
if (!CheckColorImage (parentCode, tagCode, fCameraProfile.fColorPlanes))
return false;
if (!ParseVectorTag (stream,
parentCode,
tagCode,
tagType,
tagCount,
fCameraProfile.fColorPlanes,
fAnalogBalance))
return false;
#if qDNGValidate
if (gVerbose)
{
printf ("AnalogBalance:");
DumpVector (fAnalogBalance);
}
#endif
break;
}
case tcAsShotNeutral:
{
CheckTagType (parentCode, tagCode, tagType, ttRational);
if (!CheckColorImage (parentCode, tagCode, fCameraProfile.fColorPlanes))
return false;
if (!ParseVectorTag (stream,
parentCode,
tagCode,
tagType,
tagCount,
fCameraProfile.fColorPlanes,
fAsShotNeutral))
return false;
#if qDNGValidate
if (gVerbose)
{
printf ("AsShotNeutral:");
DumpVector (fAsShotNeutral);
}
#endif
break;
}
case tcAsShotWhiteXY:
{
CheckTagType (parentCode, tagCode, tagType, ttRational);
if (!CheckColorImage (parentCode, tagCode, fCameraProfile.fColorPlanes))
return false;
if (!CheckTagCount (parentCode, tagCode, tagCount, 2))
return false;
fAsShotWhiteXY.x = stream.TagValue_real64 (tagType);
fAsShotWhiteXY.y = stream.TagValue_real64 (tagType);
#if qDNGValidate
if (gVerbose)
{
printf ("AsShotWhiteXY: %0.4f %0.4f\n",
fAsShotWhiteXY.x,
fAsShotWhiteXY.y);
}
#endif
break;
}
case tcBaselineExposure:
{
CheckTagType (parentCode, tagCode, tagType, ttSRational);
CheckTagCount (parentCode, tagCode, tagCount, 1);
fBaselineExposure = stream.TagValue_srational (tagType);
#if qDNGValidate
if (gVerbose)
{
printf ("BaselineExposure: %+0.2f\n",
fBaselineExposure.As_real64 ());
}
#endif
break;
}
case tcBaselineNoise:
{
CheckTagType (parentCode, tagCode, tagType, ttRational);
CheckTagCount (parentCode, tagCode, tagCount, 1);
fBaselineNoise = stream.TagValue_urational (tagType);
#if qDNGValidate
if (gVerbose)
{
printf ("BaselineNoise: %0.2f\n",
fBaselineNoise.As_real64 ());
}
#endif
break;
}
case tcNoiseReductionApplied:
{
if (!CheckTagType (parentCode, tagCode, tagType, ttRational))
return false;
if (!CheckTagCount (parentCode, tagCode, tagCount, 1))
return false;
fNoiseReductionApplied = stream.TagValue_urational (tagType);
#if qDNGValidate
if (gVerbose)
{
printf ("NoiseReductionApplied: %u/%u\n",
(unsigned) fNoiseReductionApplied.n,
(unsigned) fNoiseReductionApplied.d);
}
#endif
break;
}
case tcNoiseProfile:
{
if (!CheckTagType (parentCode, tagCode, tagType, ttDouble))
return false;
// Must be an even, positive number of doubles in a noise profile.
if (!tagCount || (tagCount & 1))
return false;
// Determine number of planes (i.e., half the number of doubles).
const uint32 numPlanes = Pin_uint32 (0,
tagCount >> 1,
kMaxColorPlanes);
// Parse the noise function parameters.
std::vector<dng_noise_function> noiseFunctions;
for (uint32 i = 0; i < numPlanes; i++)
{
const real64 scale = stream.TagValue_real64 (tagType);
const real64 offset = stream.TagValue_real64 (tagType);
noiseFunctions.push_back (dng_noise_function (scale, offset));
}
// Store the noise profile.
fNoiseProfile = dng_noise_profile (noiseFunctions);
// Debug.
#if qDNGValidate
if (gVerbose)
{
printf ("NoiseProfile:\n");
printf (" Planes: %u\n", numPlanes);
for (uint32 plane = 0; plane < numPlanes; plane++)
{
printf (" Noise function for plane %u: scale = %.8lf, offset = %.8lf\n",
plane,
noiseFunctions [plane].Scale (),
noiseFunctions [plane].Offset ());
}
}
#endif
break;
}
case tcBaselineSharpness:
{
CheckTagType (parentCode, tagCode, tagType, ttRational);
CheckTagCount (parentCode, tagCode, tagCount, 1);
fBaselineSharpness = stream.TagValue_urational (tagType);
#if qDNGValidate
if (gVerbose)
{
printf ("BaselineSharpness: %0.2f\n",
fBaselineSharpness.As_real64 ());
}
#endif
break;
}
case tcLinearResponseLimit:
{
CheckTagType (parentCode, tagCode, tagType, ttRational);
CheckTagCount (parentCode, tagCode, tagCount, 1);
fLinearResponseLimit = stream.TagValue_urational (tagType);
#if qDNGValidate
if (gVerbose)
{
printf ("LinearResponseLimit: %0.2f\n",
fLinearResponseLimit.As_real64 ());
}
#endif
break;
}
case tcShadowScale:
{
CheckTagType (parentCode, tagCode, tagType, ttRational);
CheckTagCount (parentCode, tagCode, tagCount, 1);
fShadowScale = stream.TagValue_urational (tagType);
#if qDNGValidate
if (gVerbose)
{
printf ("ShadowScale: %0.4f\n",
fShadowScale.As_real64 ());
}
#endif
break;
}
case tcDNGPrivateData:
{
CheckTagType (parentCode, tagCode, tagType, ttByte);
fDNGPrivateDataCount = tagCount;
fDNGPrivateDataOffset = tagOffset;
#if qDNGValidate
if (gVerbose)
{
printf ("DNGPrivateData: Count = %u, Offset = %u\n",
(unsigned) fDNGPrivateDataCount,
(unsigned) fDNGPrivateDataOffset);
DumpHexAscii (stream, tagCount);
}
#endif
break;
}
case tcMakerNoteSafety:
{
CheckTagType (parentCode, tagCode, tagType, ttShort);
CheckTagCount (parentCode, tagCode, tagCount, 1);
fMakerNoteSafety = stream.TagValue_uint32 (tagType);
#if qDNGValidate
if (gVerbose)
{
printf ("MakerNoteSafety: %s\n",
LookupMakerNoteSafety (fMakerNoteSafety));
}
#endif
break;
}
case tcRawImageDigest:
{
if (!CheckTagType (parentCode, tagCode, tagType, ttByte))
return false;
if (!CheckTagCount (parentCode, tagCode, tagCount, 16))
return false;
stream.Get (fRawImageDigest.data, 16);
#if qDNGValidate
if (gVerbose)
{
printf ("RawImageDigest: ");
DumpFingerprint (fRawImageDigest);
printf ("\n");
}
#endif
break;
}
case tcRawDataUniqueID:
{
if (!CheckTagType (parentCode, tagCode, tagType, ttByte))
return false;
if (!CheckTagCount (parentCode, tagCode, tagCount, 16))
return false;
stream.Get (fRawDataUniqueID.data, 16);
#if qDNGValidate
if (gVerbose)
{
printf ("RawDataUniqueID: ");
DumpFingerprint (fRawDataUniqueID);
printf ("\n");
}
#endif
break;
}
case tcOriginalRawFileName:
{
CheckTagType (parentCode, tagCode, tagType, ttAscii, ttByte);
ParseStringTag (stream,
parentCode,
tagCode,
tagCount,
fOriginalRawFileName,
false,
false);
#if qDNGValidate
if (gVerbose)
{
printf ("OriginalRawFileName: ");
DumpString (fOriginalRawFileName);
printf ("\n");
}
#endif
break;
}
case tcOriginalRawFileData:
{
CheckTagType (parentCode, tagCode, tagType, ttUndefined);
fOriginalRawFileDataCount = tagCount;
fOriginalRawFileDataOffset = tagOffset;
#if qDNGValidate
if (gVerbose)
{
printf ("OriginalRawFileData: Count = %u, Offset = %u\n",
(unsigned) fOriginalRawFileDataCount,
(unsigned) fOriginalRawFileDataOffset);
DumpHexAscii (stream, tagCount);
}
#endif
break;
}
case tcOriginalRawFileDigest:
{
if (!CheckTagType (parentCode, tagCode, tagType, ttByte))
return false;
if (!CheckTagCount (parentCode, tagCode, tagCount, 16))
return false;
stream.Get (fOriginalRawFileDigest.data, 16);
#if qDNGValidate
if (gVerbose)
{
printf ("OriginalRawFileDigest: ");
DumpFingerprint (fOriginalRawFileDigest);
printf ("\n");
}
#endif
break;
}
case tcAsShotICCProfile:
{
CheckTagType (parentCode, tagCode, tagType, ttUndefined);
fAsShotICCProfileCount = tagCount;
fAsShotICCProfileOffset = tagOffset;
#if qDNGValidate
if (gVerbose)
{
printf ("AsShotICCProfile: Count = %u, Offset = %u\n",
(unsigned) fAsShotICCProfileCount,
(unsigned) fAsShotICCProfileOffset);
DumpHexAscii (stream, tagCount);
}
#endif
break;
}
case tcAsShotPreProfileMatrix:
{
CheckTagType (parentCode, tagCode, tagType, ttSRational);
if (!CheckColorImage (parentCode, tagCode, fCameraProfile.fColorPlanes))
return false;
uint32 rows = fCameraProfile.fColorPlanes;
if (tagCount == fCameraProfile.fColorPlanes * 3)
{
rows = 3;
}
if (!ParseMatrixTag (stream,
parentCode,
tagCode,
tagType,
tagCount,
rows,
fCameraProfile.fColorPlanes,
fAsShotPreProfileMatrix))
return false;
#if qDNGValidate
if (gVerbose)
{
printf ("AsShotPreProfileMatrix:\n");
DumpMatrix (fAsShotPreProfileMatrix);
}
#endif
break;
}
case tcCurrentICCProfile:
{
CheckTagType (parentCode, tagCode, tagType, ttUndefined);
fCurrentICCProfileCount = tagCount;
fCurrentICCProfileOffset = tagOffset;
#if qDNGValidate
if (gVerbose)
{
printf ("CurrentICCProfile: Count = %u, Offset = %u\n",
(unsigned) fCurrentICCProfileCount,
(unsigned) fCurrentICCProfileOffset);
DumpHexAscii (stream, tagCount);
}
#endif
break;
}
case tcCurrentPreProfileMatrix:
{
CheckTagType (parentCode, tagCode, tagType, ttSRational);
if (!CheckColorImage (parentCode, tagCode, fCameraProfile.fColorPlanes))
return false;
uint32 rows = fCameraProfile.fColorPlanes;
if (tagCount == fCameraProfile.fColorPlanes * 3)
{
rows = 3;
}
if (!ParseMatrixTag (stream,
parentCode,
tagCode,
tagType,
tagCount,
rows,
fCameraProfile.fColorPlanes,
fCurrentPreProfileMatrix))
return false;
#if qDNGValidate
if (gVerbose)
{
printf ("CurrentPreProfileMatrix:\n");
DumpMatrix (fCurrentPreProfileMatrix);
}
#endif
break;
}
case tcColorimetricReference:
{
CheckTagType (parentCode, tagCode, tagType, ttShort);
CheckTagCount (parentCode, tagCode, tagCount, 1);
fColorimetricReference = stream.TagValue_uint32 (tagType);
#if qDNGValidate
if (gVerbose)
{
printf ("ColorimetricReference: %s\n",
LookupColorimetricReference (fColorimetricReference));
}
#endif
break;
}
case tcExtraCameraProfiles:
{
CheckTagType (parentCode, tagCode, tagType, ttLong);
CheckTagCount (parentCode, tagCode, tagCount, 1, tagCount);
#if qDNGValidate
if (gVerbose)
{
printf ("ExtraCameraProfiles: %u\n", (unsigned) tagCount);
}
#endif
fExtraCameraProfiles.reserve (tagCount);
for (uint32 index = 0; index < tagCount; index++)
{
#if qDNGValidate
if (gVerbose)
{
printf ("\nExtraCameraProfile [%u]:\n\n", (unsigned) index);
}
#endif
stream.SetReadPosition (tagOffset + index * 4);
uint32 profileOffset = stream.TagValue_uint32 (tagType);
dng_camera_profile_info profileInfo;
stream.SetReadPosition (profileOffset);
if (profileInfo.ParseExtended (stream))
{
fExtraCameraProfiles.push_back (profileInfo);
}
else
{
#if qDNGValidate
ReportWarning ("Unable to parse extra camera profile");
#endif
}
}
#if qDNGValidate
if (gVerbose)
{
printf ("\nDone with ExtraCameraProfiles\n\n");
}
#endif
break;
}
case tcAsShotProfileName:
{
CheckTagType (parentCode, tagCode, tagType, ttAscii, ttByte);
ParseStringTag (stream,
parentCode,
tagCode,
tagCount,
fAsShotProfileName,
false,
false);
#if qDNGValidate
if (gVerbose)
{
printf ("AsShotProfileName: ");
DumpString (fAsShotProfileName);
printf ("\n");
}
#endif
break;
}
default:
{
// The main camera profile tags also appear in IFD 0
return fCameraProfile.ParseTag (stream,
parentCode,
tagCode,
tagType,
tagCount,
tagOffset);
}
}
return true;
}
