dng_opcode_GainMap::dng_opcode_GainMap (dng_host &host,
dng_stream &stream)
: dng_inplace_opcode (dngOpcode_GainMap,
stream,
"GainMap")
, fAreaSpec ()
, fGainMap ()
{
uint32 byteCount = stream.Get_uint32 ();
uint64 startPosition = stream.Position ();
fAreaSpec.GetData (stream);
fGainMap.Reset (dng_gain_map::GetStream (host, stream));
if (stream.Position () != startPosition + byteCount)
{
ThrowBadFormat ();
}
}
void dng_jpeg_preview::WriteData (dng_host & /* host */,
dng_image_writer & /* writer */,
dng_basic_tag_set &basic,
dng_stream &stream) const
{
basic.SetTileOffset (0, (uint32) stream.Position ());
basic.SetTileByteCount (0, fCompressedData->LogicalSize ());
stream.Put (fCompressedData->Buffer (),
fCompressedData->LogicalSize ());
if (fCompressedData->LogicalSize () & 1)
{
stream.Put_uint8 (0);
}
}
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::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_camera_profile_info::ParseExtended (dng_stream &stream)
{
try
{
// Offsets are relative to the start of this structure, not the entire file.
uint64 startPosition = stream.Position ();
// Read header. Like a TIFF header, but with different magic number
// Plus all offsets are relative to the start of the IFD, not to the
// stream or file.
uint16 byteOrder = stream.Get_uint16 ();
if (byteOrder == byteOrderMM)
fBigEndian = true;
else if (byteOrder == byteOrderII)
fBigEndian = false;
else
return false;
TempBigEndian setEndianness (stream, fBigEndian);
uint16 magicNumber = stream.Get_uint16 ();
if (magicNumber != magicExtendedProfile)
{
return false;
}
uint32 offset = stream.Get_uint32 ();
stream.Skip (offset - 8);
// Start on IFD entries.
uint32 ifdEntries = stream.Get_uint16 ();
if (ifdEntries < 1)
{
return false;
}
for (uint32 tag_index = 0; tag_index < ifdEntries; tag_index++)
{
stream.SetReadPosition (startPosition + 8 + 2 + tag_index * 12);
uint16 tagCode = stream.Get_uint16 ();
uint32 tagType = stream.Get_uint16 ();
uint32 tagCount = stream.Get_uint32 ();
uint64 tagOffset = stream.Position ();
if (TagTypeSize (tagType) * tagCount > 4)
{
tagOffset = startPosition + stream.Get_uint32 ();
stream.SetReadPosition (tagOffset);
}
if (!ParseTag (stream,
0,
tagCode,
tagType,
tagCount,
tagOffset))
{
#if qDNGValidate
if (gVerbose)
{
stream.SetReadPosition (tagOffset);
printf ("*");
DumpTagValues (stream,
LookupTagType (tagType),
0,
tagCode,
tagType,
tagCount);
}
#endif
}
}
return true;
}
catch (...)
{
// Eat parsing errors.
}
return false;
}