C++程序
|
6978行
|
138.72 KB
/*****************************************************************************/
// 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_image_writer.cpp#4 $ */
/* $DateTime: 2012/06/14 20:24:41 $ */
/* $Change: 835078 $ */
/* $Author: tknoll $ */
/*****************************************************************************/
#include "dng_image_writer.h"
#include "dng_abort_sniffer.h"
#include "dng_area_task.h"
#include "dng_bottlenecks.h"
#include "dng_camera_profile.h"
#include "dng_color_space.h"
#include "dng_exif.h"
#include "dng_flags.h"
#include "dng_exceptions.h"
#include "dng_host.h"
#include "dng_ifd.h"
#include "dng_image.h"
#include "dng_jpeg_image.h"
#include "dng_lossless_jpeg.h"
#include "dng_memory.h"
#include "dng_memory_stream.h"
#include "dng_negative.h"
#include "dng_pixel_buffer.h"
#include "dng_preview.h"
#include "dng_read_image.h"
#include "dng_safe_arithmetic.h"
#include "dng_stream.h"
#include "dng_string_list.h"
#include "dng_tag_codes.h"
#include "dng_tag_values.h"
#include "dng_utils.h"
#if qDNGUseXMP
#include "dng_xmp.h"
#endif
#include "zlib.h"
#if qDNGUseLibJPEG
#include "dng_jpeglib.h"
#endif
/*****************************************************************************/
// Defines for testing DNG 1.2 features.
//#define qTestRowInterleave 2
//#define qTestSubTileBlockRows 2
//#define qTestSubTileBlockCols 2
/*****************************************************************************/
dng_resolution::dng_resolution ()
: fXResolution ()
, fYResolution ()
, fResolutionUnit (0)
{
}
/******************************************************************************/
static void SpoolAdobeData (dng_stream &stream,
const dng_metadata *metadata,
const dng_jpeg_preview *preview,
const dng_memory_block *imageResources)
{
TempBigEndian tempEndian (stream);
#if qDNGUseXMP
if (metadata && metadata->GetXMP ())
{
bool marked = false;
if (metadata->GetXMP ()->GetBoolean (XMP_NS_XAP_RIGHTS,
"Marked",
marked))
{
stream.Put_uint32 (DNG_CHAR4 ('8','B','I','M'));
stream.Put_uint16 (1034);
stream.Put_uint16 (0);
stream.Put_uint32 (1);
stream.Put_uint8 (marked ? 1 : 0);
stream.Put_uint8 (0);
}
dng_string webStatement;
if (metadata->GetXMP ()->GetString (XMP_NS_XAP_RIGHTS,
"WebStatement",
webStatement))
{
dng_memory_data buffer;
uint32 size = webStatement.Get_SystemEncoding (buffer);
if (size > 0)
{
stream.Put_uint32 (DNG_CHAR4 ('8','B','I','M'));
stream.Put_uint16 (1035);
stream.Put_uint16 (0);
stream.Put_uint32 (size);
stream.Put (buffer.Buffer (), size);
if (size & 1)
stream.Put_uint8 (0);
}
}
}
#endif
if (preview)
{
preview->SpoolAdobeThumbnail (stream);
}
if (metadata && metadata->IPTCLength ())
{
dng_fingerprint iptcDigest = metadata->IPTCDigest ();
if (iptcDigest.IsValid ())
{
stream.Put_uint32 (DNG_CHAR4 ('8','B','I','M'));
stream.Put_uint16 (1061);
stream.Put_uint16 (0);
stream.Put_uint32 (16);
stream.Put (iptcDigest.data, 16);
}
}
if (imageResources)
{
uint32 size = imageResources->LogicalSize ();
stream.Put (imageResources->Buffer (), size);
if (size & 1)
stream.Put_uint8 (0);
}
}
/******************************************************************************/
static dng_memory_block * BuildAdobeData (dng_host &host,
const dng_metadata *metadata,
const dng_jpeg_preview *preview,
const dng_memory_block *imageResources)
{
dng_memory_stream stream (host.Allocator ());
SpoolAdobeData (stream,
metadata,
preview,
imageResources);
return stream.AsMemoryBlock (host.Allocator ());
}
/*****************************************************************************/
tag_string::tag_string (uint16 code,
const dng_string &s,
bool forceASCII)
: tiff_tag (code, ttAscii, 0)
, fString (s)
{
if (forceASCII)
{
// Metadata working group recommendation - go ahead
// write UTF-8 into ASCII tag strings, rather than
// actually force the strings to ASCII. There is a matching
// change on the reading side to assume UTF-8 if the string
// contains a valid UTF-8 string.
//
// fString.ForceASCII ();
}
else if (!fString.IsASCII ())
{
fType = ttByte;
}
fCount = fString.Length () + 1;
}
/*****************************************************************************/
void tag_string::Put (dng_stream &stream) const
{
stream.Put (fString.Get (), Size ());
}
/*****************************************************************************/
tag_encoded_text::tag_encoded_text (uint16 code,
const dng_string &text)
: tiff_tag (code, ttUndefined, 0)
, fText (text)
, fUTF16 ()
{
if (fText.IsASCII ())
{
fCount = 8 + fText.Length ();
}
else
{
fCount = 8 + fText.Get_UTF16 (fUTF16) * 2;
}
}
/*****************************************************************************/
void tag_encoded_text::Put (dng_stream &stream) const
{
if (fUTF16.Buffer ())
{
stream.Put ("UNICODE\000", 8);
uint32 chars = (fCount - 8) >> 1;
const uint16 *buf = fUTF16.Buffer_uint16 ();
for (uint32 j = 0; j < chars; j++)
{
stream.Put_uint16 (buf [j]);
}
}
else
{
stream.Put ("ASCII\000\000\000", 8);
stream.Put (fText.Get (), fCount - 8);
}
}
/*****************************************************************************/
void tag_data_ptr::Put (dng_stream &stream) const
{
// If we are swapping bytes, we need to swap with the right size
// entries.
if (stream.SwapBytes ())
{
switch (Type ())
{
// Two byte entries.
case ttShort:
case ttSShort:
case ttUnicode:
{
const uint16 *p = (const uint16 *) fData;
uint32 entries = (Size () >> 1);
for (uint32 j = 0; j < entries; j++)
{
stream.Put_uint16 (p [j]);
}
return;
}
// Four byte entries.
case ttLong:
case ttSLong:
case ttRational:
case ttSRational:
case ttIFD:
case ttFloat:
case ttComplex:
{
const uint32 *p = (const uint32 *) fData;
uint32 entries = (Size () >> 2);
for (uint32 j = 0; j < entries; j++)
{
stream.Put_uint32 (p [j]);
}
return;
}
// Eight byte entries.
case ttDouble:
{
const real64 *p = (const real64 *) fData;
uint32 entries = (Size () >> 3);
for (uint32 j = 0; j < entries; j++)
{
stream.Put_real64 (p [j]);
}
return;
}
// Entries don't need to be byte swapped. Fall through
// to non-byte swapped case.
default:
{
break;
}
}
}
// Non-byte swapped case.
stream.Put (fData, Size ());
}
/******************************************************************************/
tag_matrix::tag_matrix (uint16 code,
const dng_matrix &m)
: tag_srational_ptr (code, fEntry, m.Rows () * m.Cols ())
{
uint32 index = 0;
for (uint32 r = 0; r < m.Rows (); r++)
for (uint32 c = 0; c < m.Cols (); c++)
{
fEntry [index].Set_real64 (m [r] [c], 10000);
index++;
}
}
/******************************************************************************/
tag_icc_profile::tag_icc_profile (const void *profileData,
uint32 profileSize)
: tag_data_ptr (tcICCProfile,
ttUndefined,
0,
NULL)
{
if (profileData && profileSize)
{
SetCount (profileSize);
SetData (profileData);
}
}
/******************************************************************************/
void tag_cfa_pattern::Put (dng_stream &stream) const
{
stream.Put_uint16 ((uint16) fCols);
stream.Put_uint16 ((uint16) fRows);
for (uint32 col = 0; col < fCols; col++)
for (uint32 row = 0; row < fRows; row++)
{
stream.Put_uint8 (fPattern [row * kMaxCFAPattern + col]);
}
}
/******************************************************************************/
tag_exif_date_time::tag_exif_date_time (uint16 code,
const dng_date_time &dt)
: tag_data_ptr (code, ttAscii, 20, fData)
{
if (dt.IsValid ())
{
sprintf (fData,
"%04d:%02d:%02d %02d:%02d:%02d",
(int) dt.fYear,
(int) dt.fMonth,
(int) dt.fDay,
(int) dt.fHour,
(int) dt.fMinute,
(int) dt.fSecond);
}
}
/******************************************************************************/
tag_iptc::tag_iptc (const void *data,
uint32 length)
: tiff_tag (tcIPTC_NAA, ttLong, (length + 3) >> 2)
, fData (data )
, fLength (length)
{
}
/******************************************************************************/
void tag_iptc::Put (dng_stream &stream) const
{
// Note: For historical compatiblity reasons, the standard TIFF data
// type for IPTC data is ttLong, but without byte swapping. This really
// should be ttUndefined, but doing the right thing would break some
// existing readers.
stream.Put (fData, fLength);
// Pad with zeros to get to long word boundary.
uint32 extra = fCount * 4 - fLength;
while (extra--)
{
stream.Put_uint8 (0);
}
}
/******************************************************************************/
tag_xmp::tag_xmp (const dng_xmp *xmp)
: tag_uint8_ptr (tcXMP, NULL, 0)
, fBuffer ()
{
#if qDNGUseXMP
if (xmp)
{
fBuffer.Reset (xmp->Serialize (true));
if (fBuffer.Get ())
{
SetData (fBuffer->Buffer_uint8 ());
SetCount (fBuffer->LogicalSize ());
}
}
#endif
}
/******************************************************************************/
void dng_tiff_directory::Add (const tiff_tag *tag)
{
if (fEntries >= kMaxEntries)
{
ThrowProgramError ();
}
// Tags must be sorted in increasing order of tag code.
uint32 index = fEntries;
for (uint32 j = 0; j < fEntries; j++)
{
if (tag->Code () < fTag [j]->Code ())
{
index = j;
break;
}
}
for (uint32 k = fEntries; k > index; k--)
{
fTag [k] = fTag [k - 1];
}
fTag [index] = tag;
fEntries++;
}
/******************************************************************************/
uint32 dng_tiff_directory::Size () const
{
if (!fEntries) return 0;
uint32 size = fEntries * 12 + 6;
for (uint32 index = 0; index < fEntries; index++)
{
uint32 tagSize = fTag [index]->Size ();
if (tagSize > 4)
{
size += (tagSize + 1) & ~1;
}
}
return size;
}
/******************************************************************************/
void dng_tiff_directory::Put (dng_stream &stream,
OffsetsBase offsetsBase,
uint32 explicitBase) const
{
if (!fEntries) return;
uint32 index;
uint32 bigData = fEntries * 12 + 6;
if (offsetsBase == offsetsRelativeToStream)
bigData += (uint32) stream.Position ();
else if (offsetsBase == offsetsRelativeToExplicitBase)
bigData += explicitBase;
stream.Put_uint16 ((uint16) fEntries);
for (index = 0; index < fEntries; index++)
{
const tiff_tag &tag = *fTag [index];
stream.Put_uint16 (tag.Code ());
stream.Put_uint16 (tag.Type ());
stream.Put_uint32 (tag.Count ());
uint32 size = tag.Size ();
if (size <= 4)
{
tag.Put (stream);
while (size < 4)
{
stream.Put_uint8 (0);
size++;
}
}
else
{
stream.Put_uint32 (bigData);
bigData += (size + 1) & ~1;
}
}
stream.Put_uint32 (fChained); // Next IFD offset
for (index = 0; index < fEntries; index++)
{
const tiff_tag &tag = *fTag [index];
uint32 size = tag.Size ();
if (size > 4)
{
tag.Put (stream);
if (size & 1)
stream.Put_uint8 (0);
}
}
}
/******************************************************************************/
dng_basic_tag_set::dng_basic_tag_set (dng_tiff_directory &directory,
const dng_ifd &info)
: fNewSubFileType (tcNewSubFileType, info.fNewSubFileType)
, fImageWidth (tcImageWidth , info.fImageWidth )
, fImageLength (tcImageLength, info.fImageLength)
, fPhotoInterpretation (tcPhotometricInterpretation,
(uint16) info.fPhotometricInterpretation)
, fFillOrder (tcFillOrder, 1)
, fSamplesPerPixel (tcSamplesPerPixel, (uint16) info.fSamplesPerPixel)
, fBitsPerSample (tcBitsPerSample,
fBitsPerSampleData,
info.fSamplesPerPixel)
, fStrips (info.fUsesStrips)
, fTileWidth (tcTileWidth, info.fTileWidth)
, fTileLength (fStrips ? tcRowsPerStrip : tcTileLength,
info.fTileLength)
, fTileInfoBuffer (info.TilesPerImage (), 8)
, fTileOffsetData (fTileInfoBuffer.Buffer_uint32 ())
, fTileOffsets (fStrips ? tcStripOffsets : tcTileOffsets,
fTileOffsetData,
info.TilesPerImage ())
, fTileByteCountData (fTileOffsetData + info.TilesPerImage ())
, fTileByteCounts (fStrips ? tcStripByteCounts : tcTileByteCounts,
fTileByteCountData,
info.TilesPerImage ())
, fPlanarConfiguration (tcPlanarConfiguration, pcInterleaved)
, fCompression (tcCompression, (uint16) info.fCompression)
, fPredictor (tcPredictor , (uint16) info.fPredictor )
, fExtraSamples (tcExtraSamples,
fExtraSamplesData,
info.fExtraSamplesCount)
, fSampleFormat (tcSampleFormat,
fSampleFormatData,
info.fSamplesPerPixel)
, fRowInterleaveFactor (tcRowInterleaveFactor,
(uint16) info.fRowInterleaveFactor)
, fSubTileBlockSize (tcSubTileBlockSize,
fSubTileBlockSizeData,
2)
{
uint32 j;
for (j = 0; j < info.fSamplesPerPixel; j++)
{
fBitsPerSampleData [j] = (uint16) info.fBitsPerSample [0];
}
directory.Add (&fNewSubFileType);
directory.Add (&fImageWidth);
directory.Add (&fImageLength);
directory.Add (&fPhotoInterpretation);
directory.Add (&fSamplesPerPixel);
directory.Add (&fBitsPerSample);
if (info.fBitsPerSample [0] != 8 &&
info.fBitsPerSample [0] != 16 &&
info.fBitsPerSample [0] != 32)
{
directory.Add (&fFillOrder);
}
if (!fStrips)
{
directory.Add (&fTileWidth);
}
directory.Add (&fTileLength);
directory.Add (&fTileOffsets);
directory.Add (&fTileByteCounts);
directory.Add (&fPlanarConfiguration);
directory.Add (&fCompression);
if (info.fPredictor != cpNullPredictor)
{
directory.Add (&fPredictor);
}
if (info.fExtraSamplesCount != 0)
{
for (j = 0; j < info.fExtraSamplesCount; j++)
{
fExtraSamplesData [j] = (uint16) info.fExtraSamples [j];
}
directory.Add (&fExtraSamples);
}
if (info.fSampleFormat [0] != sfUnsignedInteger)
{
for (j = 0; j < info.fSamplesPerPixel; j++)
{
fSampleFormatData [j] = (uint16) info.fSampleFormat [j];
}
directory.Add (&fSampleFormat);
}
if (info.fRowInterleaveFactor != 1)
{
directory.Add (&fRowInterleaveFactor);
}
if (info.fSubTileBlockRows != 1 ||
info.fSubTileBlockCols != 1)
{
fSubTileBlockSizeData [0] = (uint16) info.fSubTileBlockRows;
fSubTileBlockSizeData [1] = (uint16) info.fSubTileBlockCols;
directory.Add (&fSubTileBlockSize);
}
}
/******************************************************************************/
exif_tag_set::exif_tag_set (dng_tiff_directory &directory,
const dng_exif &exif,
bool makerNoteSafe,
const void *makerNoteData,
uint32 makerNoteLength,
bool insideDNG)
: fExifIFD ()
, fGPSIFD ()
, fExifLink (tcExifIFD, 0)
, fGPSLink (tcGPSInfo, 0)
, fAddedExifLink (false)
, fAddedGPSLink (false)
, fExifVersion (tcExifVersion, ttUndefined, 4, fExifVersionData)
, fExposureTime (tcExposureTime , exif.fExposureTime )
, fShutterSpeedValue (tcShutterSpeedValue, exif.fShutterSpeedValue)
, fFNumber (tcFNumber , exif.fFNumber )
, fApertureValue (tcApertureValue, exif.fApertureValue)
, fBrightnessValue (tcBrightnessValue, exif.fBrightnessValue)
, fExposureBiasValue (tcExposureBiasValue, exif.fExposureBiasValue)
, fMaxApertureValue (tcMaxApertureValue , exif.fMaxApertureValue)
, fSubjectDistance (tcSubjectDistance, exif.fSubjectDistance)
, fFocalLength (tcFocalLength, exif.fFocalLength)
// Special case: the EXIF 2.2 standard represents ISO speed ratings with 2 bytes,
// which cannot hold ISO speed ratings above 65535 (e.g., 102400). In these
// cases, we write the maximum representable ISO speed rating value in the EXIF
// tag, i.e., 65535.
, fISOSpeedRatings (tcISOSpeedRatings,
(uint16) Min_uint32 (65535,
exif.fISOSpeedRatings [0]))
, fSensitivityType (tcSensitivityType, (uint16) exif.fSensitivityType)
, fStandardOutputSensitivity (tcStandardOutputSensitivity, exif.fStandardOutputSensitivity)
, fRecommendedExposureIndex (tcRecommendedExposureIndex, exif.fRecommendedExposureIndex)
, fISOSpeed (tcISOSpeed, exif.fISOSpeed)
, fISOSpeedLatitudeyyy (tcISOSpeedLatitudeyyy, exif.fISOSpeedLatitudeyyy)
, fISOSpeedLatitudezzz (tcISOSpeedLatitudezzz, exif.fISOSpeedLatitudezzz)
, fFlash (tcFlash, (uint16) exif.fFlash)
, fExposureProgram (tcExposureProgram, (uint16) exif.fExposureProgram)
, fMeteringMode (tcMeteringMode, (uint16) exif.fMeteringMode)
, fLightSource (tcLightSource, (uint16) exif.fLightSource)
, fSensingMethod (tcSensingMethodExif, (uint16) exif.fSensingMethod)
, fFocalLength35mm (tcFocalLengthIn35mmFilm, (uint16) exif.fFocalLengthIn35mmFilm)
, fFileSourceData ((uint8) exif.fFileSource)
, fFileSource (tcFileSource, ttUndefined, 1, &fFileSourceData)
, fSceneTypeData ((uint8) exif.fSceneType)
, fSceneType (tcSceneType, ttUndefined, 1, &fSceneTypeData)
, fCFAPattern (tcCFAPatternExif,
exif.fCFARepeatPatternRows,
exif.fCFARepeatPatternCols,
&exif.fCFAPattern [0] [0])
, fCustomRendered (tcCustomRendered , (uint16) exif.fCustomRendered )
, fExposureMode (tcExposureMode , (uint16) exif.fExposureMode )
, fWhiteBalance (tcWhiteBalance , (uint16) exif.fWhiteBalance )
, fSceneCaptureType (tcSceneCaptureType , (uint16) exif.fSceneCaptureType )
, fGainControl (tcGainControl , (uint16) exif.fGainControl )
, fContrast (tcContrast , (uint16) exif.fContrast )
, fSaturation (tcSaturation , (uint16) exif.fSaturation )
, fSharpness (tcSharpness , (uint16) exif.fSharpness )
, fSubjectDistanceRange (tcSubjectDistanceRange, (uint16) exif.fSubjectDistanceRange)
, fDigitalZoomRatio (tcDigitalZoomRatio, exif.fDigitalZoomRatio)
, fExposureIndex (tcExposureIndexExif, exif.fExposureIndex)
, fImageNumber (tcImageNumber, exif.fImageNumber)
, fSelfTimerMode (tcSelfTimerMode, (uint16) exif.fSelfTimerMode)
, fBatteryLevelA (tcBatteryLevel, exif.fBatteryLevelA)
, fBatteryLevelR (tcBatteryLevel, exif.fBatteryLevelR)
, fFocalPlaneXResolution (tcFocalPlaneXResolutionExif, exif.fFocalPlaneXResolution)
, fFocalPlaneYResolution (tcFocalPlaneYResolutionExif, exif.fFocalPlaneYResolution)
, fFocalPlaneResolutionUnit (tcFocalPlaneResolutionUnitExif, (uint16) exif.fFocalPlaneResolutionUnit)
, fSubjectArea (tcSubjectArea, fSubjectAreaData, exif.fSubjectAreaCount)
, fLensInfo (tcLensInfo, fLensInfoData, 4)
, fDateTime (tcDateTime , exif.fDateTime .DateTime ())
, fDateTimeOriginal (tcDateTimeOriginal , exif.fDateTimeOriginal .DateTime ())
, fDateTimeDigitized (tcDateTimeDigitized, exif.fDateTimeDigitized.DateTime ())
, fSubsecTime (tcSubsecTime, exif.fDateTime .Subseconds ())
, fSubsecTimeOriginal (tcSubsecTimeOriginal, exif.fDateTimeOriginal .Subseconds ())
, fSubsecTimeDigitized (tcSubsecTimeDigitized, exif.fDateTimeDigitized.Subseconds ())
, fMake (tcMake, exif.fMake)
, fModel (tcModel, exif.fModel)
, fArtist (tcArtist, exif.fArtist)
, fSoftware (tcSoftware, exif.fSoftware)
, fCopyright (tcCopyright, exif.fCopyright)
, fMakerNoteSafety (tcMakerNoteSafety, makerNoteSafe ? 1 : 0)
, fMakerNote (tcMakerNote, ttUndefined, makerNoteLength, makerNoteData)
, fImageDescription (tcImageDescription, exif.fImageDescription)
, fSerialNumber (tcCameraSerialNumber, exif.fCameraSerialNumber)
, fUserComment (tcUserComment, exif.fUserComment)
, fImageUniqueID (tcImageUniqueID, ttAscii, 33, fImageUniqueIDData)
// EXIF 2.3 tags.
, fCameraOwnerName (tcCameraOwnerNameExif, exif.fOwnerName )
, fBodySerialNumber (tcCameraSerialNumberExif, exif.fCameraSerialNumber)
, fLensSpecification (tcLensSpecificationExif, fLensInfoData, 4 )
, fLensMake (tcLensMakeExif, exif.fLensMake )
, fLensModel (tcLensModelExif, exif.fLensName )
, fLensSerialNumber (tcLensSerialNumberExif, exif.fLensSerialNumber )
, fGPSVersionID (tcGPSVersionID, fGPSVersionData, 4)
, fGPSLatitudeRef (tcGPSLatitudeRef, exif.fGPSLatitudeRef)
, fGPSLatitude (tcGPSLatitude, exif.fGPSLatitude, 3)
, fGPSLongitudeRef (tcGPSLongitudeRef, exif.fGPSLongitudeRef)
, fGPSLongitude (tcGPSLongitude, exif.fGPSLongitude, 3)
, fGPSAltitudeRef (tcGPSAltitudeRef, (uint8) exif.fGPSAltitudeRef)
, fGPSAltitude (tcGPSAltitude, exif.fGPSAltitude )
, fGPSTimeStamp (tcGPSTimeStamp, exif.fGPSTimeStamp, 3)
, fGPSSatellites (tcGPSSatellites , exif.fGPSSatellites )
, fGPSStatus (tcGPSStatus , exif.fGPSStatus )
, fGPSMeasureMode (tcGPSMeasureMode, exif.fGPSMeasureMode)
, fGPSDOP (tcGPSDOP, exif.fGPSDOP)
, fGPSSpeedRef (tcGPSSpeedRef, exif.fGPSSpeedRef)
, fGPSSpeed (tcGPSSpeed , exif.fGPSSpeed )
, fGPSTrackRef (tcGPSTrackRef, exif.fGPSTrackRef)
, fGPSTrack (tcGPSTrack , exif.fGPSTrack )
, fGPSImgDirectionRef (tcGPSImgDirectionRef, exif.fGPSImgDirectionRef)
, fGPSImgDirection (tcGPSImgDirection , exif.fGPSImgDirection )
, fGPSMapDatum (tcGPSMapDatum, exif.fGPSMapDatum)
, fGPSDestLatitudeRef (tcGPSDestLatitudeRef, exif.fGPSDestLatitudeRef)
, fGPSDestLatitude (tcGPSDestLatitude, exif.fGPSDestLatitude, 3)
, fGPSDestLongitudeRef (tcGPSDestLongitudeRef, exif.fGPSDestLongitudeRef)
, fGPSDestLongitude (tcGPSDestLongitude, exif.fGPSDestLongitude, 3)
, fGPSDestBearingRef (tcGPSDestBearingRef, exif.fGPSDestBearingRef)
, fGPSDestBearing (tcGPSDestBearing , exif.fGPSDestBearing )
, fGPSDestDistanceRef (tcGPSDestDistanceRef, exif.fGPSDestDistanceRef)
, fGPSDestDistance (tcGPSDestDistance , exif.fGPSDestDistance )
, fGPSProcessingMethod (tcGPSProcessingMethod, exif.fGPSProcessingMethod)
, fGPSAreaInformation (tcGPSAreaInformation , exif.fGPSAreaInformation )
, fGPSDateStamp (tcGPSDateStamp, exif.fGPSDateStamp)
, fGPSDifferential (tcGPSDifferential, (uint16) exif.fGPSDifferential)
, fGPSHPositioningError (tcGPSHPositioningError, exif.fGPSHPositioningError)
{
if (exif.fExifVersion)
{
fExifVersionData [0] = (uint8) (exif.fExifVersion >> 24);
fExifVersionData [1] = (uint8) (exif.fExifVersion >> 16);
fExifVersionData [2] = (uint8) (exif.fExifVersion >> 8);
fExifVersionData [3] = (uint8) (exif.fExifVersion );
fExifIFD.Add (&fExifVersion);
}
if (exif.fExposureTime.IsValid ())
{
fExifIFD.Add (&fExposureTime);
}
if (exif.fShutterSpeedValue.IsValid ())
{
fExifIFD.Add (&fShutterSpeedValue);
}
if (exif.fFNumber.IsValid ())
{
fExifIFD.Add (&fFNumber);
}
if (exif.fApertureValue.IsValid ())
{
fExifIFD.Add (&fApertureValue);
}
if (exif.fBrightnessValue.IsValid ())
{
fExifIFD.Add (&fBrightnessValue);
}
if (exif.fExposureBiasValue.IsValid ())
{
fExifIFD.Add (&fExposureBiasValue);
}
if (exif.fMaxApertureValue.IsValid ())
{
fExifIFD.Add (&fMaxApertureValue);
}
if (exif.fSubjectDistance.IsValid ())
{
fExifIFD.Add (&fSubjectDistance);
}
if (exif.fFocalLength.IsValid ())
{
fExifIFD.Add (&fFocalLength);
}
if (exif.fISOSpeedRatings [0] != 0)
{
fExifIFD.Add (&fISOSpeedRatings);
}
if (exif.fFlash <= 0x0FFFF)
{
fExifIFD.Add (&fFlash);
}
if (exif.fExposureProgram <= 0x0FFFF)
{
fExifIFD.Add (&fExposureProgram);
}
if (exif.fMeteringMode <= 0x0FFFF)
{
fExifIFD.Add (&fMeteringMode);
}
if (exif.fLightSource <= 0x0FFFF)
{
fExifIFD.Add (&fLightSource);
}
if (exif.fSensingMethod <= 0x0FFFF)
{
fExifIFD.Add (&fSensingMethod);
}
if (exif.fFocalLengthIn35mmFilm != 0)
{
fExifIFD.Add (&fFocalLength35mm);
}
if (exif.fFileSource <= 0x0FF)
{
fExifIFD.Add (&fFileSource);
}
if (exif.fSceneType <= 0x0FF)
{
fExifIFD.Add (&fSceneType);
}
if (exif.fCFARepeatPatternRows &&
exif.fCFARepeatPatternCols)
{
fExifIFD.Add (&fCFAPattern);
}
if (exif.fCustomRendered <= 0x0FFFF)
{
fExifIFD.Add (&fCustomRendered);
}
if (exif.fExposureMode <= 0x0FFFF)
{
fExifIFD.Add (&fExposureMode);
}
if (exif.fWhiteBalance <= 0x0FFFF)
{
fExifIFD.Add (&fWhiteBalance);
}
if (exif.fSceneCaptureType <= 0x0FFFF)
{
fExifIFD.Add (&fSceneCaptureType);
}
if (exif.fGainControl <= 0x0FFFF)
{
fExifIFD.Add (&fGainControl);
}
if (exif.fContrast <= 0x0FFFF)
{
fExifIFD.Add (&fContrast);
}
if (exif.fSaturation <= 0x0FFFF)
{
fExifIFD.Add (&fSaturation);
}
if (exif.fSharpness <= 0x0FFFF)
{
fExifIFD.Add (&fSharpness);
}
if (exif.fSubjectDistanceRange <= 0x0FFFF)
{
fExifIFD.Add (&fSubjectDistanceRange);
}
if (exif.fDigitalZoomRatio.IsValid ())
{
fExifIFD.Add (&fDigitalZoomRatio);
}
if (exif.fExposureIndex.IsValid ())
{
fExifIFD.Add (&fExposureIndex);
}
if (insideDNG) // TIFF-EP only tags
{
if (exif.fImageNumber != 0xFFFFFFFF)
{
directory.Add (&fImageNumber);
}
if (exif.fSelfTimerMode <= 0x0FFFF)
{
directory.Add (&fSelfTimerMode);
}
if (exif.fBatteryLevelA.NotEmpty ())
{
directory.Add (&fBatteryLevelA);
}
else if (exif.fBatteryLevelR.IsValid ())
{
directory.Add (&fBatteryLevelR);
}
}
if (exif.fFocalPlaneXResolution.IsValid ())
{
fExifIFD.Add (&fFocalPlaneXResolution);
}
if (exif.fFocalPlaneYResolution.IsValid ())
{
fExifIFD.Add (&fFocalPlaneYResolution);
}
if (exif.fFocalPlaneResolutionUnit <= 0x0FFFF)
{
fExifIFD.Add (&fFocalPlaneResolutionUnit);
}
if (exif.fSubjectAreaCount)
{
fSubjectAreaData [0] = (uint16) exif.fSubjectArea [0];
fSubjectAreaData [1] = (uint16) exif.fSubjectArea [1];
fSubjectAreaData [2] = (uint16) exif.fSubjectArea [2];
fSubjectAreaData [3] = (uint16) exif.fSubjectArea [3];
fExifIFD.Add (&fSubjectArea);
}
if (exif.fLensInfo [0].IsValid () &&
exif.fLensInfo [1].IsValid ())
{
fLensInfoData [0] = exif.fLensInfo [0];
fLensInfoData [1] = exif.fLensInfo [1];
fLensInfoData [2] = exif.fLensInfo [2];
fLensInfoData [3] = exif.fLensInfo [3];
if (insideDNG)
{
directory.Add (&fLensInfo);
}
}
if (exif.fDateTime.IsValid ())
{
directory.Add (&fDateTime);
if (exif.fDateTime.Subseconds ().NotEmpty ())
{
fExifIFD.Add (&fSubsecTime);
}
}
if (exif.fDateTimeOriginal.IsValid ())
{
fExifIFD.Add (&fDateTimeOriginal);
if (exif.fDateTimeOriginal.Subseconds ().NotEmpty ())
{
fExifIFD.Add (&fSubsecTimeOriginal);
}
}
if (exif.fDateTimeDigitized.IsValid ())
{
fExifIFD.Add (&fDateTimeDigitized);
if (exif.fDateTimeDigitized.Subseconds ().NotEmpty ())
{
fExifIFD.Add (&fSubsecTimeDigitized);
}
}
if (exif.fMake.NotEmpty ())
{
directory.Add (&fMake);
}
if (exif.fModel.NotEmpty ())
{
directory.Add (&fModel);
}
if (exif.fArtist.NotEmpty ())
{
directory.Add (&fArtist);
}
if (exif.fSoftware.NotEmpty ())
{
directory.Add (&fSoftware);
}
if (exif.fCopyright.NotEmpty ())
{
directory.Add (&fCopyright);
}
if (exif.fImageDescription.NotEmpty ())
{
directory.Add (&fImageDescription);
}
if (exif.fCameraSerialNumber.NotEmpty () && insideDNG)
{
directory.Add (&fSerialNumber);
}
if (makerNoteSafe && makerNoteData)
{
directory.Add (&fMakerNoteSafety);
fExifIFD.Add (&fMakerNote);
}
if (exif.fUserComment.NotEmpty ())
{
fExifIFD.Add (&fUserComment);
}
if (exif.fImageUniqueID.IsValid ())
{
for (uint32 j = 0; j < 16; j++)
{
sprintf (fImageUniqueIDData + j * 2,
"%02X",
(unsigned) exif.fImageUniqueID.data [j]);
}
fExifIFD.Add (&fImageUniqueID);
}
if (exif.AtLeastVersion0230 ())
{
if (exif.fSensitivityType != 0)
{
fExifIFD.Add (&fSensitivityType);
}
// Sensitivity tags. Do not write these extra tags unless the SensitivityType
// and PhotographicSensitivity (i.e., ISOSpeedRatings) values are valid.
if (exif.fSensitivityType != 0 &&
exif.fISOSpeedRatings [0] != 0)
{
// Standard Output Sensitivity (SOS).
if (exif.fStandardOutputSensitivity != 0)
{
fExifIFD.Add (&fStandardOutputSensitivity);
}
// Recommended Exposure Index (REI).
if (exif.fRecommendedExposureIndex != 0)
{
fExifIFD.Add (&fRecommendedExposureIndex);
}
// ISO Speed.
if (exif.fISOSpeed != 0)
{
fExifIFD.Add (&fISOSpeed);
if (exif.fISOSpeedLatitudeyyy != 0 &&
exif.fISOSpeedLatitudezzz != 0)
{
fExifIFD.Add (&fISOSpeedLatitudeyyy);
fExifIFD.Add (&fISOSpeedLatitudezzz);
}
}
}
if (exif.fOwnerName.NotEmpty ())
{
fExifIFD.Add (&fCameraOwnerName);
}
if (exif.fCameraSerialNumber.NotEmpty ())
{
fExifIFD.Add (&fBodySerialNumber);
}
if (exif.fLensInfo [0].IsValid () &&
exif.fLensInfo [1].IsValid ())
{
fExifIFD.Add (&fLensSpecification);
}
if (exif.fLensMake.NotEmpty ())
{
fExifIFD.Add (&fLensMake);
}
if (exif.fLensName.NotEmpty ())
{
fExifIFD.Add (&fLensModel);
}
if (exif.fLensSerialNumber.NotEmpty ())
{
fExifIFD.Add (&fLensSerialNumber);
}
}
if (exif.fGPSVersionID)
{
fGPSVersionData [0] = (uint8) (exif.fGPSVersionID >> 24);
fGPSVersionData [1] = (uint8) (exif.fGPSVersionID >> 16);
fGPSVersionData [2] = (uint8) (exif.fGPSVersionID >> 8);
fGPSVersionData [3] = (uint8) (exif.fGPSVersionID );
fGPSIFD.Add (&fGPSVersionID);
}
if (exif.fGPSLatitudeRef.NotEmpty () &&
exif.fGPSLatitude [0].IsValid ())
{
fGPSIFD.Add (&fGPSLatitudeRef);
fGPSIFD.Add (&fGPSLatitude );
}
if (exif.fGPSLongitudeRef.NotEmpty () &&
exif.fGPSLongitude [0].IsValid ())
{
fGPSIFD.Add (&fGPSLongitudeRef);
fGPSIFD.Add (&fGPSLongitude );
}
if (exif.fGPSAltitudeRef <= 0x0FF)
{
fGPSIFD.Add (&fGPSAltitudeRef);
}
if (exif.fGPSAltitude.IsValid ())
{
fGPSIFD.Add (&fGPSAltitude);
}
if (exif.fGPSTimeStamp [0].IsValid ())
{
fGPSIFD.Add (&fGPSTimeStamp);
}
if (exif.fGPSSatellites.NotEmpty ())
{
fGPSIFD.Add (&fGPSSatellites);
}
if (exif.fGPSStatus.NotEmpty ())
{
fGPSIFD.Add (&fGPSStatus);
}
if (exif.fGPSMeasureMode.NotEmpty ())
{
fGPSIFD.Add (&fGPSMeasureMode);
}
if (exif.fGPSDOP.IsValid ())
{
fGPSIFD.Add (&fGPSDOP);
}
if (exif.fGPSSpeedRef.NotEmpty ())
{
fGPSIFD.Add (&fGPSSpeedRef);
}
if (exif.fGPSSpeed.IsValid ())
{
fGPSIFD.Add (&fGPSSpeed);
}
if (exif.fGPSTrackRef.NotEmpty ())
{
fGPSIFD.Add (&fGPSTrackRef);
}
if (exif.fGPSTrack.IsValid ())
{
fGPSIFD.Add (&fGPSTrack);
}
if (exif.fGPSImgDirectionRef.NotEmpty ())
{
fGPSIFD.Add (&fGPSImgDirectionRef);
}
if (exif.fGPSImgDirection.IsValid ())
{
fGPSIFD.Add (&fGPSImgDirection);
}
if (exif.fGPSMapDatum.NotEmpty ())
{
fGPSIFD.Add (&fGPSMapDatum);
}
if (exif.fGPSDestLatitudeRef.NotEmpty () &&
exif.fGPSDestLatitude [0].IsValid ())
{
fGPSIFD.Add (&fGPSDestLatitudeRef);
fGPSIFD.Add (&fGPSDestLatitude );
}
if (exif.fGPSDestLongitudeRef.NotEmpty () &&
exif.fGPSDestLongitude [0].IsValid ())
{
fGPSIFD.Add (&fGPSDestLongitudeRef);
fGPSIFD.Add (&fGPSDestLongitude );
}
if (exif.fGPSDestBearingRef.NotEmpty ())
{
fGPSIFD.Add (&fGPSDestBearingRef);
}
if (exif.fGPSDestBearing.IsValid ())
{
fGPSIFD.Add (&fGPSDestBearing);
}
if (exif.fGPSDestDistanceRef.NotEmpty ())
{
fGPSIFD.Add (&fGPSDestDistanceRef);
}
if (exif.fGPSDestDistance.IsValid ())
{
fGPSIFD.Add (&fGPSDestDistance);
}
if (exif.fGPSProcessingMethod.NotEmpty ())
{
fGPSIFD.Add (&fGPSProcessingMethod);
}
if (exif.fGPSAreaInformation.NotEmpty ())
{
fGPSIFD.Add (&fGPSAreaInformation);
}
if (exif.fGPSDateStamp.NotEmpty ())
{
fGPSIFD.Add (&fGPSDateStamp);
}
if (exif.fGPSDifferential <= 0x0FFFF)
{
fGPSIFD.Add (&fGPSDifferential);
}
if (exif.AtLeastVersion0230 ())
{
if (exif.fGPSHPositioningError.IsValid ())
{
fGPSIFD.Add (&fGPSHPositioningError);
}
}
AddLinks (directory);
}
/******************************************************************************/
void exif_tag_set::AddLinks (dng_tiff_directory &directory)
{
if (fExifIFD.Size () != 0 && !fAddedExifLink)
{
directory.Add (&fExifLink);
fAddedExifLink = true;
}
if (fGPSIFD.Size () != 0 && !fAddedGPSLink)
{
directory.Add (&fGPSLink);
fAddedGPSLink = true;
}
}
/******************************************************************************/
class range_tag_set
{
private:
uint32 fActiveAreaData [4];
tag_uint32_ptr fActiveArea;
uint32 fMaskedAreaData [kMaxMaskedAreas * 4];
tag_uint32_ptr fMaskedAreas;
tag_uint16_ptr fLinearizationTable;
uint16 fBlackLevelRepeatDimData [2];
tag_uint16_ptr fBlackLevelRepeatDim;
dng_urational fBlackLevelData [kMaxBlackPattern *
kMaxBlackPattern *
kMaxSamplesPerPixel];
tag_urational_ptr fBlackLevel;
dng_memory_data fBlackLevelDeltaHData;
dng_memory_data fBlackLevelDeltaVData;
tag_srational_ptr fBlackLevelDeltaH;
tag_srational_ptr fBlackLevelDeltaV;
uint16 fWhiteLevelData16 [kMaxSamplesPerPixel];
uint32 fWhiteLevelData32 [kMaxSamplesPerPixel];
tag_uint16_ptr fWhiteLevel16;
tag_uint32_ptr fWhiteLevel32;
public:
range_tag_set (dng_tiff_directory &directory,
const dng_negative &negative);
};
/******************************************************************************/
range_tag_set::range_tag_set (dng_tiff_directory &directory,
const dng_negative &negative)
: fActiveArea (tcActiveArea,
fActiveAreaData,
4)
, fMaskedAreas (tcMaskedAreas,
fMaskedAreaData,
0)
, fLinearizationTable (tcLinearizationTable,
NULL,
0)
, fBlackLevelRepeatDim (tcBlackLevelRepeatDim,
fBlackLevelRepeatDimData,
2)
, fBlackLevel (tcBlackLevel,
fBlackLevelData)
, fBlackLevelDeltaHData ()
, fBlackLevelDeltaVData ()
, fBlackLevelDeltaH (tcBlackLevelDeltaH)
, fBlackLevelDeltaV (tcBlackLevelDeltaV)
, fWhiteLevel16 (tcWhiteLevel,
fWhiteLevelData16)
, fWhiteLevel32 (tcWhiteLevel,
fWhiteLevelData32)
{
const dng_image &rawImage (negative.RawImage ());
const dng_linearization_info *rangeInfo = negative.GetLinearizationInfo ();
if (rangeInfo)
{
// ActiveArea:
{
const dng_rect &r = rangeInfo->fActiveArea;
if (r.NotEmpty ())
{
fActiveAreaData [0] = r.t;
fActiveAreaData [1] = r.l;
fActiveAreaData [2] = r.b;
fActiveAreaData [3] = r.r;
directory.Add (&fActiveArea);
}
}
// MaskedAreas:
if (rangeInfo->fMaskedAreaCount)
{
fMaskedAreas.SetCount (rangeInfo->fMaskedAreaCount * 4);
for (uint32 index = 0; index < rangeInfo->fMaskedAreaCount; index++)
{
const dng_rect &r = rangeInfo->fMaskedArea [index];
fMaskedAreaData [index * 4 + 0] = r.t;
fMaskedAreaData [index * 4 + 1] = r.l;
fMaskedAreaData [index * 4 + 2] = r.b;
fMaskedAreaData [index * 4 + 3] = r.r;
}
directory.Add (&fMaskedAreas);
}
// LinearizationTable:
if (rangeInfo->fLinearizationTable.Get ())
{
fLinearizationTable.SetData (rangeInfo->fLinearizationTable->Buffer_uint16 () );
fLinearizationTable.SetCount (rangeInfo->fLinearizationTable->LogicalSize () >> 1);
directory.Add (&fLinearizationTable);
}
// BlackLevelRepeatDim:
{
fBlackLevelRepeatDimData [0] = (uint16) rangeInfo->fBlackLevelRepeatRows;
fBlackLevelRepeatDimData [1] = (uint16) rangeInfo->fBlackLevelRepeatCols;
directory.Add (&fBlackLevelRepeatDim);
}
// BlackLevel:
{
uint32 index = 0;
for (uint16 v = 0; v < rangeInfo->fBlackLevelRepeatRows; v++)
{
for (uint32 h = 0; h < rangeInfo->fBlackLevelRepeatCols; h++)
{
for (uint32 c = 0; c < rawImage.Planes (); c++)
{
fBlackLevelData [index++] = rangeInfo->BlackLevel (v, h, c);
}
}
}
fBlackLevel.SetCount (rangeInfo->fBlackLevelRepeatRows *
rangeInfo->fBlackLevelRepeatCols * rawImage.Planes ());
directory.Add (&fBlackLevel);
}
// BlackLevelDeltaH:
if (rangeInfo->ColumnBlackCount ())
{
uint32 count = rangeInfo->ColumnBlackCount ();
fBlackLevelDeltaHData.Allocate (count, sizeof (dng_srational));
dng_srational *blacks = (dng_srational *) fBlackLevelDeltaHData.Buffer ();
for (uint32 col = 0; col < count; col++)
{
blacks [col] = rangeInfo->ColumnBlack (col);
}
fBlackLevelDeltaH.SetData (blacks);
fBlackLevelDeltaH.SetCount (count );
directory.Add (&fBlackLevelDeltaH);
}
// BlackLevelDeltaV:
if (rangeInfo->RowBlackCount ())
{
uint32 count = rangeInfo->RowBlackCount ();
fBlackLevelDeltaVData.Allocate (count, sizeof (dng_srational));
dng_srational *blacks = (dng_srational *) fBlackLevelDeltaVData.Buffer ();
for (uint32 row = 0; row < count; row++)
{
blacks [row] = rangeInfo->RowBlack (row);
}
fBlackLevelDeltaV.SetData (blacks);
fBlackLevelDeltaV.SetCount (count );
directory.Add (&fBlackLevelDeltaV);
}
}
// WhiteLevel:
// Only use the 32-bit data type if we must use it since there
// are some lazy (non-Adobe) DNG readers out there.
bool needs32 = false;
fWhiteLevel16.SetCount (rawImage.Planes ());
fWhiteLevel32.SetCount (rawImage.Planes ());
for (uint32 c = 0; c < fWhiteLevel16.Count (); c++)
{
fWhiteLevelData32 [c] = negative.WhiteLevel (c);
if (fWhiteLevelData32 [c] > 0x0FFFF)
{
needs32 = true;
}
fWhiteLevelData16 [c] = (uint16) fWhiteLevelData32 [c];
}
if (needs32)
{
directory.Add (&fWhiteLevel32);
}
else
{
directory.Add (&fWhiteLevel16);
}
}
/******************************************************************************/
class mosaic_tag_set
{
private:
uint16 fCFARepeatPatternDimData [2];
tag_uint16_ptr fCFARepeatPatternDim;
uint8 fCFAPatternData [kMaxCFAPattern *
kMaxCFAPattern];
tag_uint8_ptr fCFAPattern;
uint8 fCFAPlaneColorData [kMaxColorPlanes];
tag_uint8_ptr fCFAPlaneColor;
tag_uint16 fCFALayout;
tag_uint32 fGreenSplit;
public:
mosaic_tag_set (dng_tiff_directory &directory,
const dng_mosaic_info &info);
};
/******************************************************************************/
mosaic_tag_set::mosaic_tag_set (dng_tiff_directory &directory,
const dng_mosaic_info &info)
: fCFARepeatPatternDim (tcCFARepeatPatternDim,
fCFARepeatPatternDimData,
2)
, fCFAPattern (tcCFAPattern,
fCFAPatternData)
, fCFAPlaneColor (tcCFAPlaneColor,
fCFAPlaneColorData)
, fCFALayout (tcCFALayout,
(uint16) info.fCFALayout)
, fGreenSplit (tcBayerGreenSplit,
info.fBayerGreenSplit)
{
if (info.IsColorFilterArray ())
{
// CFARepeatPatternDim:
fCFARepeatPatternDimData [0] = (uint16) info.fCFAPatternSize.v;
fCFARepeatPatternDimData [1] = (uint16) info.fCFAPatternSize.h;
directory.Add (&fCFARepeatPatternDim);
// CFAPattern:
fCFAPattern.SetCount (info.fCFAPatternSize.v *
info.fCFAPatternSize.h);
for (int32 r = 0; r < info.fCFAPatternSize.v; r++)
{
for (int32 c = 0; c < info.fCFAPatternSize.h; c++)
{
fCFAPatternData [r * info.fCFAPatternSize.h + c] = info.fCFAPattern [r] [c];
}
}
directory.Add (&fCFAPattern);
// CFAPlaneColor:
fCFAPlaneColor.SetCount (info.fColorPlanes);
for (uint32 j = 0; j < info.fColorPlanes; j++)
{
fCFAPlaneColorData [j] = info.fCFAPlaneColor [j];
}
directory.Add (&fCFAPlaneColor);
// CFALayout:
fCFALayout.Set ((uint16) info.fCFALayout);
directory.Add (&fCFALayout);
// BayerGreenSplit: (only include if the pattern is a Bayer pattern)
if (info.fCFAPatternSize == dng_point (2, 2) &&
info.fColorPlanes == 3)
{
directory.Add (&fGreenSplit);
}
}
}
/******************************************************************************/
class color_tag_set
{
private:
uint32 fColorChannels;
tag_matrix fCameraCalibration1;
tag_matrix fCameraCalibration2;
tag_string fCameraCalibrationSignature;
tag_string fAsShotProfileName;
dng_urational fAnalogBalanceData [4];
tag_urational_ptr fAnalogBalance;
dng_urational fAsShotNeutralData [4];
tag_urational_ptr fAsShotNeutral;
dng_urational fAsShotWhiteXYData [2];
tag_urational_ptr fAsShotWhiteXY;
tag_urational fLinearResponseLimit;
public:
color_tag_set (dng_tiff_directory &directory,
const dng_negative &negative);
};
/******************************************************************************/
color_tag_set::color_tag_set (dng_tiff_directory &directory,
const dng_negative &negative)
: fColorChannels (negative.ColorChannels ())
, fCameraCalibration1 (tcCameraCalibration1,
negative.CameraCalibration1 ())
, fCameraCalibration2 (tcCameraCalibration2,
negative.CameraCalibration2 ())
, fCameraCalibrationSignature (tcCameraCalibrationSignature,
negative.CameraCalibrationSignature ())
, fAsShotProfileName (tcAsShotProfileName,
negative.AsShotProfileName ())
, fAnalogBalance (tcAnalogBalance,
fAnalogBalanceData,
fColorChannels)
, fAsShotNeutral (tcAsShotNeutral,
fAsShotNeutralData,
fColorChannels)
, fAsShotWhiteXY (tcAsShotWhiteXY,
fAsShotWhiteXYData,
2)
, fLinearResponseLimit (tcLinearResponseLimit,
negative.LinearResponseLimitR ())
{
if (fColorChannels > 1)
{
uint32 channels2 = fColorChannels * fColorChannels;
if (fCameraCalibration1.Count () == channels2)
{
directory.Add (&fCameraCalibration1);
}
if (fCameraCalibration2.Count () == channels2)
{
directory.Add (&fCameraCalibration2);
}
if (fCameraCalibration1.Count () == channels2 ||
fCameraCalibration2.Count () == channels2)
{
if (negative.CameraCalibrationSignature ().NotEmpty ())
{
directory.Add (&fCameraCalibrationSignature);
}
}
if (negative.AsShotProfileName ().NotEmpty ())
{
directory.Add (&fAsShotProfileName);
}
for (uint32 j = 0; j < fColorChannels; j++)
{
fAnalogBalanceData [j] = negative.AnalogBalanceR (j);
}
directory.Add (&fAnalogBalance);
if (negative.HasCameraNeutral ())
{
for (uint32 k = 0; k < fColorChannels; k++)
{
fAsShotNeutralData [k] = negative.CameraNeutralR (k);
}
directory.Add (&fAsShotNeutral);
}
else if (negative.HasCameraWhiteXY ())
{
negative.GetCameraWhiteXY (fAsShotWhiteXYData [0],
fAsShotWhiteXYData [1]);
directory.Add (&fAsShotWhiteXY);
}
directory.Add (&fLinearResponseLimit);
}
}
/******************************************************************************/
class profile_tag_set
{
private:
tag_uint16 fCalibrationIlluminant1;
tag_uint16 fCalibrationIlluminant2;
tag_matrix fColorMatrix1;
tag_matrix fColorMatrix2;
tag_matrix fForwardMatrix1;
tag_matrix fForwardMatrix2;
tag_matrix fReductionMatrix1;
tag_matrix fReductionMatrix2;
tag_string fProfileName;
tag_string fProfileCalibrationSignature;
tag_uint32 fEmbedPolicyTag;
tag_string fCopyrightTag;
uint32 fHueSatMapDimData [3];
tag_uint32_ptr fHueSatMapDims;
tag_data_ptr fHueSatData1;
tag_data_ptr fHueSatData2;
tag_uint32 fHueSatMapEncodingTag;
uint32 fLookTableDimData [3];
tag_uint32_ptr fLookTableDims;
tag_data_ptr fLookTableData;
tag_uint32 fLookTableEncodingTag;
tag_srational fBaselineExposureOffsetTag;
tag_uint32 fDefaultBlackRenderTag;
dng_memory_data fToneCurveBuffer;
tag_data_ptr fToneCurveTag;
public:
profile_tag_set (dng_tiff_directory &directory,
const dng_camera_profile &profile);
};
/******************************************************************************/
profile_tag_set::profile_tag_set (dng_tiff_directory &directory,
const dng_camera_profile &profile)
: fCalibrationIlluminant1 (tcCalibrationIlluminant1,
(uint16) profile.CalibrationIlluminant1 ())
, fCalibrationIlluminant2 (tcCalibrationIlluminant2,
(uint16) profile.CalibrationIlluminant2 ())
, fColorMatrix1 (tcColorMatrix1,
profile.ColorMatrix1 ())
, fColorMatrix2 (tcColorMatrix2,
profile.ColorMatrix2 ())
, fForwardMatrix1 (tcForwardMatrix1,
profile.ForwardMatrix1 ())
, fForwardMatrix2 (tcForwardMatrix2,
profile.ForwardMatrix2 ())
, fReductionMatrix1 (tcReductionMatrix1,
profile.ReductionMatrix1 ())
, fReductionMatrix2 (tcReductionMatrix2,
profile.ReductionMatrix2 ())
, fProfileName (tcProfileName,
profile.Name (),
false)
, fProfileCalibrationSignature (tcProfileCalibrationSignature,
profile.ProfileCalibrationSignature (),
false)
, fEmbedPolicyTag (tcProfileEmbedPolicy,
profile.EmbedPolicy ())
, fCopyrightTag (tcProfileCopyright,
profile.Copyright (),
false)
, fHueSatMapDims (tcProfileHueSatMapDims,
fHueSatMapDimData,
3)
, fHueSatData1 (tcProfileHueSatMapData1,
ttFloat,
profile.HueSatDeltas1 ().DeltasCount () * 3,
profile.HueSatDeltas1 ().GetConstDeltas ())
, fHueSatData2 (tcProfileHueSatMapData2,
ttFloat,
profile.HueSatDeltas2 ().DeltasCount () * 3,
profile.HueSatDeltas2 ().GetConstDeltas ())
, fHueSatMapEncodingTag (tcProfileHueSatMapEncoding,
profile.HueSatMapEncoding ())
, fLookTableDims (tcProfileLookTableDims,
fLookTableDimData,
3)
, fLookTableData (tcProfileLookTableData,
ttFloat,
profile.LookTable ().DeltasCount () * 3,
profile.LookTable ().GetConstDeltas ())
, fLookTableEncodingTag (tcProfileLookTableEncoding,
profile.LookTableEncoding ())
, fBaselineExposureOffsetTag (tcBaselineExposureOffset,
profile.BaselineExposureOffset ())
, fDefaultBlackRenderTag (tcDefaultBlackRender,
profile.DefaultBlackRender ())
, fToneCurveBuffer ()
, fToneCurveTag (tcProfileToneCurve,
ttFloat,
0,
NULL)
{
if (profile.HasColorMatrix1 ())
{
uint32 colorChannels = profile.ColorMatrix1 ().Rows ();
directory.Add (&fCalibrationIlluminant1);
directory.Add (&fColorMatrix1);
if (fForwardMatrix1.Count () == colorChannels * 3)
{
directory.Add (&fForwardMatrix1);
}
if (colorChannels > 3 && fReductionMatrix1.Count () == colorChannels * 3)
{
directory.Add (&fReductionMatrix1);
}
if (profile.HasColorMatrix2 ())
{
directory.Add (&fCalibrationIlluminant2);
directory.Add (&fColorMatrix2);
if (fForwardMatrix2.Count () == colorChannels * 3)
{
directory.Add (&fForwardMatrix2);
}
if (colorChannels > 3 && fReductionMatrix2.Count () == colorChannels * 3)
{
directory.Add (&fReductionMatrix2);
}
}
if (profile.Name ().NotEmpty ())
{
directory.Add (&fProfileName);
}
if (profile.ProfileCalibrationSignature ().NotEmpty ())
{
directory.Add (&fProfileCalibrationSignature);
}
directory.Add (&fEmbedPolicyTag);
if (profile.Copyright ().NotEmpty ())
{
directory.Add (&fCopyrightTag);
}
bool haveHueSat1 = profile.HueSatDeltas1 ().IsValid ();
bool haveHueSat2 = profile.HueSatDeltas2 ().IsValid () &&
profile.HasColorMatrix2 ();
if (haveHueSat1 || haveHueSat2)
{
uint32 hueDivs = 0;
uint32 satDivs = 0;
uint32 valDivs = 0;
if (haveHueSat1)
{
profile.HueSatDeltas1 ().GetDivisions (hueDivs,
satDivs,
valDivs);
}
else
{
profile.HueSatDeltas2 ().GetDivisions (hueDivs,
satDivs,
valDivs);
}
fHueSatMapDimData [0] = hueDivs;
fHueSatMapDimData [1] = satDivs;
fHueSatMapDimData [2] = valDivs;
directory.Add (&fHueSatMapDims);
// Don't bother including the ProfileHueSatMapEncoding tag unless it's
// non-linear.
if (profile.HueSatMapEncoding () != encoding_Linear)
{
directory.Add (&fHueSatMapEncodingTag);
}
}
if (haveHueSat1)
{
directory.Add (&fHueSatData1);
}
if (haveHueSat2)
{
directory.Add (&fHueSatData2);
}
if (profile.HasLookTable ())
{
uint32 hueDivs = 0;
uint32 satDivs = 0;
uint32 valDivs = 0;
profile.LookTable ().GetDivisions (hueDivs,
satDivs,
valDivs);
fLookTableDimData [0] = hueDivs;
fLookTableDimData [1] = satDivs;
fLookTableDimData [2] = valDivs;
directory.Add (&fLookTableDims);
directory.Add (&fLookTableData);
// Don't bother including the ProfileLookTableEncoding tag unless it's
// non-linear.
if (profile.LookTableEncoding () != encoding_Linear)
{
directory.Add (&fLookTableEncodingTag);
}
}
// Don't bother including the BaselineExposureOffset tag unless it's both
// valid and non-zero.
if (profile.BaselineExposureOffset ().IsValid ())
{
if (profile.BaselineExposureOffset ().As_real64 () != 0.0)
{
directory.Add (&fBaselineExposureOffsetTag);
}
}
if (profile.DefaultBlackRender () != defaultBlackRender_Auto)
{
directory.Add (&fDefaultBlackRenderTag);
}
if (profile.ToneCurve ().IsValid ())
{
// Tone curve stored as pairs of 32-bit coordinates. Probably could do with
// 16-bits here, but should be small number of points so...
uint32 toneCurvePoints = (uint32) (profile.ToneCurve ().fCoord.size ());
fToneCurveBuffer.Allocate (SafeUint32Mult(toneCurvePoints, 2),
sizeof (real32));
real32 *points = fToneCurveBuffer.Buffer_real32 ();
fToneCurveTag.SetCount (toneCurvePoints * 2);
fToneCurveTag.SetData (points);
for (uint32 i = 0; i < toneCurvePoints; i++)
{
// Transpose coordinates so they are in a more expected
// order (domain -> range).
points [i * 2 ] = (real32) profile.ToneCurve ().fCoord [i].h;
points [i * 2 + 1] = (real32) profile.ToneCurve ().fCoord [i].v;
}
directory.Add (&fToneCurveTag);
}
}
}
/******************************************************************************/
tiff_dng_extended_color_profile::tiff_dng_extended_color_profile
(const dng_camera_profile &profile)
: fProfile (profile)
{
}
/******************************************************************************/
void tiff_dng_extended_color_profile::Put (dng_stream &stream,
bool includeModelRestriction)
{
// Profile header.
stream.Put_uint16 (stream.BigEndian () ? byteOrderMM : byteOrderII);
stream.Put_uint16 (magicExtendedProfile);
stream.Put_uint32 (8);
// Profile tags.
profile_tag_set tagSet (*this, fProfile);
// Camera this profile is for.
tag_string cameraModelTag (tcUniqueCameraModel,
fProfile.UniqueCameraModelRestriction ());
if (includeModelRestriction)
{
if (fProfile.UniqueCameraModelRestriction ().NotEmpty ())
{
Add (&cameraModelTag);
}
}
// Write it all out.
dng_tiff_directory::Put (stream, offsetsRelativeToExplicitBase, 8);
}
/*****************************************************************************/
tag_dng_noise_profile::tag_dng_noise_profile (const dng_noise_profile &profile)
: tag_data_ptr (tcNoiseProfile,
ttDouble,
2 * profile.NumFunctions (),
fValues)
{
DNG_REQUIRE (profile.NumFunctions () <= kMaxColorPlanes,
"Too many noise functions in tag_dng_noise_profile.");
for (uint32 i = 0; i < profile.NumFunctions (); i++)
{
fValues [(2 * i) ] = profile.NoiseFunction (i).Scale ();
fValues [(2 * i) + 1] = profile.NoiseFunction (i).Offset ();
}
}
/*****************************************************************************/
dng_image_writer::dng_image_writer ()
{
}
/*****************************************************************************/
dng_image_writer::~dng_image_writer ()
{
}
/*****************************************************************************/
uint32 dng_image_writer::CompressedBufferSize (const dng_ifd &ifd,
uint32 uncompressedSize)
{
switch (ifd.fCompression)
{
case ccLZW:
{
// Add lots of slop for LZW to expand data.
return SafeUint32Add (SafeUint32Mult (uncompressedSize, 2), 1024);
}
case ccDeflate:
{
// ZLib says maximum is source size + 0.1% + 12 bytes.
return SafeUint32Add (SafeUint32Add (uncompressedSize,
uncompressedSize >> 8), 64);
}
case ccJPEG:
{
// If we are saving lossless JPEG from an 8-bit image, reserve
// space to pad the data out to 16-bits.
if (ifd.fBitsPerSample [0] <= 8)
{
return SafeUint32Mult (uncompressedSize, 2);
}
break;
}
default:
break;
}
return 0;
}
/******************************************************************************/
static void EncodeDelta8 (uint8 *dPtr,
uint32 rows,
uint32 cols,
uint32 channels)
{
const uint32 dRowStep = cols * channels;
for (uint32 row = 0; row < rows; row++)
{
for (uint32 col = cols - 1; col > 0; col--)
{
for (uint32 channel = 0; channel < channels; channel++)
{
dPtr [col * channels + channel] -= dPtr [(col - 1) * channels + channel];
}
}
dPtr += dRowStep;
}
}
/******************************************************************************/
static void EncodeDelta16 (uint16 *dPtr,
uint32 rows,
uint32 cols,
uint32 channels)
{
const uint32 dRowStep = cols * channels;
for (uint32 row = 0; row < rows; row++)
{
for (uint32 col = cols - 1; col > 0; col--)
{
for (uint32 channel = 0; channel < channels; channel++)
{
dPtr [col * channels + channel] -= dPtr [(col - 1) * channels + channel];
}
}
dPtr += dRowStep;
}
}
/******************************************************************************/
static void EncodeDelta32 (uint32 *dPtr,
uint32 rows,
uint32 cols,
uint32 channels)
{
const uint32 dRowStep = cols * channels;
for (uint32 row = 0; row < rows; row++)
{
for (uint32 col = cols - 1; col > 0; col--)
{
for (uint32 channel = 0; channel < channels; channel++)
{
dPtr [col * channels + channel] -= dPtr [(col - 1) * channels + channel];
}
}
dPtr += dRowStep;
}
}
/*****************************************************************************/
inline void EncodeDeltaBytes (uint8 *bytePtr, int32 cols, int32 channels)
{
if (channels == 1)
{
bytePtr += (cols - 1);
uint8 this0 = bytePtr [0];
for (int32 col = 1; col < cols; col++)
{
uint8 prev0 = bytePtr [-1];
this0 -= prev0;
bytePtr [0] = this0;
this0 = prev0;
bytePtr -= 1;
}
}
else if (channels == 3)
{
bytePtr += (cols - 1) * 3;
uint8 this0 = bytePtr [0];
uint8 this1 = bytePtr [1];
uint8 this2 = bytePtr [2];
for (int32 col = 1; col < cols; col++)
{
uint8 prev0 = bytePtr [-3];
uint8 prev1 = bytePtr [-2];
uint8 prev2 = bytePtr [-1];
this0 -= prev0;
this1 -= prev1;
this2 -= prev2;
bytePtr [0] = this0;
bytePtr [1] = this1;
bytePtr [2] = this2;
this0 = prev0;
this1 = prev1;
this2 = prev2;
bytePtr -= 3;
}
}
else
{
uint32 rowBytes = cols * channels;
bytePtr += rowBytes - 1;
for (uint32 col = channels; col < rowBytes; col++)
{
bytePtr [0] -= bytePtr [-channels];
bytePtr--;
}
}
}
/*****************************************************************************/
static void EncodeFPDelta (uint8 *buffer,
uint8 *temp,
int32 cols,
int32 channels,
int32 bytesPerSample)
{
int32 rowIncrement = cols * channels;
if (bytesPerSample == 2)
{
const uint8 *src = buffer;
#if qDNGBigEndian
uint8 *dst0 = temp;
uint8 *dst1 = temp + rowIncrement;
#else
uint8 *dst1 = temp;
uint8 *dst0 = temp + rowIncrement;
#endif
for (int32 col = 0; col < rowIncrement; ++col)
{
dst0 [col] = src [0];
dst1 [col] = src [1];
src += 2;
}
}
else if (bytesPerSample == 3)
{
const uint8 *src = buffer;
uint8 *dst0 = temp;
uint8 *dst1 = temp + rowIncrement;
uint8 *dst2 = temp + rowIncrement * 2;
for (int32 col = 0; col < rowIncrement; ++col)
{
dst0 [col] = src [0];
dst1 [col] = src [1];
dst2 [col] = src [2];
src += 3;
}
}
else
{
const uint8 *src = buffer;
#if qDNGBigEndian
uint8 *dst0 = temp;
uint8 *dst1 = temp + rowIncrement;
uint8 *dst2 = temp + rowIncrement * 2;
uint8 *dst3 = temp + rowIncrement * 3;
#else
uint8 *dst3 = temp;
uint8 *dst2 = temp + rowIncrement;
uint8 *dst1 = temp + rowIncrement * 2;
uint8 *dst0 = temp + rowIncrement * 3;
#endif
for (int32 col = 0; col < rowIncrement; ++col)
{
dst0 [col] = src [0];
dst1 [col] = src [1];
dst2 [col] = src [2];
dst3 [col] = src [3];
src += 4;
}
}
EncodeDeltaBytes (temp, cols*bytesPerSample, channels);
memcpy (buffer, temp, cols*bytesPerSample*channels);
}
/*****************************************************************************/
void dng_image_writer::EncodePredictor (dng_host &host,
const dng_ifd &ifd,
dng_pixel_buffer &buffer,
AutoPtr<dng_memory_block> &tempBuffer)
{
switch (ifd.fPredictor)
{
case cpHorizontalDifference:
case cpHorizontalDifferenceX2:
case cpHorizontalDifferenceX4:
{
int32 xFactor = 1;
if (ifd.fPredictor == cpHorizontalDifferenceX2)
{
xFactor = 2;
}
else if (ifd.fPredictor == cpHorizontalDifferenceX4)
{
xFactor = 4;
}
switch (buffer.fPixelType)
{
case ttByte:
{
EncodeDelta8 ((uint8 *) buffer.fData,
buffer.fArea.H (),
buffer.fArea.W () / xFactor,
buffer.fPlanes * xFactor);
return;
}
case ttShort:
{
EncodeDelta16 ((uint16 *) buffer.fData,
buffer.fArea.H (),
buffer.fArea.W () / xFactor,
buffer.fPlanes * xFactor);
return;
}
case ttLong:
{
EncodeDelta32 ((uint32 *) buffer.fData,
buffer.fArea.H (),
buffer.fArea.W () / xFactor,
buffer.fPlanes * xFactor);
return;
}
default:
break;
}
break;
}
case cpFloatingPoint:
case cpFloatingPointX2:
case cpFloatingPointX4:
{
int32 xFactor = 1;
if (ifd.fPredictor == cpFloatingPointX2)
{
xFactor = 2;
}
else if (ifd.fPredictor == cpFloatingPointX4)
{
xFactor = 4;
}
if (buffer.fRowStep < 0)
{
ThrowProgramError ("Row step may not be negative");
}
uint32 tempBufferSize = SafeUint32Mult (
static_cast<uint32>(buffer.fRowStep),
buffer.fPixelSize);
if (!tempBuffer.Get () || tempBuffer->LogicalSize () < tempBufferSize)
{
tempBuffer.Reset (host.Allocate (tempBufferSize));
}
for (int32 row = buffer.fArea.t; row < buffer.fArea.b; row++)
{
EncodeFPDelta ((uint8 *) buffer.DirtyPixel (row, buffer.fArea.l, buffer.fPlane),
tempBuffer->Buffer_uint8 (),
buffer.fArea.W () / xFactor,
buffer.fPlanes * xFactor,
buffer.fPixelSize);
}
return;
}
default:
break;
}
if (ifd.fPredictor != cpNullPredictor)
{
ThrowProgramError ();
}
}
/*****************************************************************************/
void dng_image_writer::ByteSwapBuffer (dng_host & /* host */,
dng_pixel_buffer &buffer)
{
uint32 pixels = buffer.fRowStep * buffer.fArea.H ();
switch (buffer.fPixelSize)
{
case 2:
{
DoSwapBytes16 ((uint16 *) buffer.fData,
pixels);
break;
}
case 4:
{
DoSwapBytes32 ((uint32 *) buffer.fData,
pixels);
break;
}
default:
break;
}
}
/*****************************************************************************/
void dng_image_writer::ReorderSubTileBlocks (const dng_ifd &ifd,
dng_pixel_buffer &buffer,
AutoPtr<dng_memory_block> &uncompressedBuffer,
AutoPtr<dng_memory_block> &subTileBlockBuffer)
{
uint32 blockRows = ifd.fSubTileBlockRows;
uint32 blockCols = ifd.fSubTileBlockCols;
uint32 rowBlocks = buffer.fArea.H () / blockRows;
uint32 colBlocks = buffer.fArea.W () / blockCols;
int32 rowStep = buffer.fRowStep * buffer.fPixelSize;
int32 colStep = buffer.fColStep * buffer.fPixelSize;
int32 rowBlockStep = rowStep * blockRows;
int32 colBlockStep = colStep * blockCols;
uint32 blockColBytes = blockCols * buffer.fPlanes * buffer.fPixelSize;
const uint8 *s0 = uncompressedBuffer->Buffer_uint8 ();
uint8 *d0 = subTileBlockBuffer->Buffer_uint8 ();
for (uint32 rowBlock = 0; rowBlock < rowBlocks; rowBlock++)
{
const uint8 *s1 = s0;
for (uint32 colBlock = 0; colBlock < colBlocks; colBlock++)
{
const uint8 *s2 = s1;
for (uint32 blockRow = 0; blockRow < blockRows; blockRow++)
{
for (uint32 j = 0; j < blockColBytes; j++)
{
d0 [j] = s2 [j];
}
d0 += blockColBytes;
s2 += rowStep;
}
s1 += colBlockStep;
}
s0 += rowBlockStep;
}
// Copy back reordered pixels.
DoCopyBytes (subTileBlockBuffer->Buffer (),
uncompressedBuffer->Buffer (),
uncompressedBuffer->LogicalSize ());
}
/******************************************************************************/
class dng_lzw_compressor
{
private:
enum
{
kResetCode = 256,
kEndCode = 257,
kTableSize = 4096
};
// Compressor nodes have two son pointers. The low order bit of
// the next code determines which pointer is used. This cuts the
// number of nodes searched for the next code by two on average.
struct LZWCompressorNode
{
int16 final;
int16 son0;
int16 son1;
int16 brother;
};
dng_memory_data fBuffer;
LZWCompressorNode *fTable;
uint8 *fDstPtr;
int32 fDstCount;
int32 fBitOffset;
int32 fNextCode;
int32 fCodeSize;
public:
dng_lzw_compressor ();
void Compress (const uint8 *sPtr,
uint8 *dPtr,
uint32 sCount,
uint32 &dCount);
private:
void InitTable ();
int32 SearchTable (int32 w, int32 k) const
{
DNG_ASSERT ((w >= 0) && (w <= kTableSize),
"Bad w value in dng_lzw_compressor::SearchTable");
int32 son0 = fTable [w] . son0;
int32 son1 = fTable [w] . son1;
// Branchless version of:
// int32 code = (k & 1) ? son1 : son0;
int32 code = son0 + ((-((int32) (k & 1))) & (son1 - son0));
while (code > 0 && fTable [code].final != k)
{
code = fTable [code].brother;
}
return code;
}
void AddTable (int32 w, int32 k);
void PutCodeWord (int32 code);
// Hidden copy constructor and assignment operator.
dng_lzw_compressor (const dng_lzw_compressor &compressor);
dng_lzw_compressor & operator= (const dng_lzw_compressor &compressor);
};
/******************************************************************************/
dng_lzw_compressor::dng_lzw_compressor ()
: fBuffer ()
, fTable (NULL)
, fDstPtr (NULL)
, fDstCount (0)
, fBitOffset (0)
, fNextCode (0)
, fCodeSize (0)
{
fBuffer.Allocate (kTableSize, sizeof (LZWCompressorNode));
fTable = (LZWCompressorNode *) fBuffer.Buffer ();
}
/******************************************************************************/
void dng_lzw_compressor::InitTable ()
{
fCodeSize = 9;
fNextCode = 258;
LZWCompressorNode *node = &fTable [0];
for (int32 code = 0; code < 256; ++code)
{
node->final = (int16) code;
node->son0 = -1;
node->son1 = -1;
node->brother = -1;
node++;
}
}
/******************************************************************************/
void dng_lzw_compressor::AddTable (int32 w, int32 k)
{
DNG_ASSERT ((w >= 0) && (w <= kTableSize),
"Bad w value in dng_lzw_compressor::AddTable");
LZWCompressorNode *node = &fTable [w];
int32 nextCode = fNextCode;
DNG_ASSERT ((nextCode >= 0) && (nextCode <= kTableSize),
"Bad fNextCode value in dng_lzw_compressor::AddTable");
LZWCompressorNode *node2 = &fTable [nextCode];
fNextCode++;
int32 oldSon;
if( k&1 )
{
oldSon = node->son1;
node->son1 = (int16) nextCode;
}
else
{
oldSon = node->son0;
node->son0 = (int16) nextCode;
}
node2->final = (int16) k;
node2->son0 = -1;
node2->son1 = -1;
node2->brother = (int16) oldSon;
if (nextCode == (1 << fCodeSize) - 1)
{
if (fCodeSize != 12)
fCodeSize++;
}
}
/******************************************************************************/
void dng_lzw_compressor::PutCodeWord (int32 code)
{
int32 bit = (int32) (fBitOffset & 7);
int32 offset1 = fBitOffset >> 3;
int32 offset2 = (fBitOffset + fCodeSize - 1) >> 3;
int32 shift1 = (fCodeSize + bit) - 8;
int32 shift2 = (fCodeSize + bit) - 16;
uint8 byte1 = (uint8) (code >> shift1);
uint8 *dstPtr1 = fDstPtr + offset1;
uint8 *dstPtr3 = fDstPtr + offset2;
if (offset1 + 1 == offset2)
{
uint8 byte2 = (uint8) (code << (-shift2));
if (bit)
*dstPtr1 |= byte1;
else
*dstPtr1 = byte1;
*dstPtr3 = byte2;
}
else
{
int32 shift3 = (fCodeSize + bit) - 24;
uint8 byte2 = (uint8) (code >> shift2);
uint8 byte3 = (uint8) (code << (-shift3));
uint8 *dstPtr2 = fDstPtr + (offset1 + 1);
if (bit)
*dstPtr1 |= byte1;
else
*dstPtr1 = byte1;
*dstPtr2 = byte2;
*dstPtr3 = byte3;
}
fBitOffset += fCodeSize;
}
/******************************************************************************/
void dng_lzw_compressor::Compress (const uint8 *sPtr,
uint8 *dPtr,
uint32 sCount,
uint32 &dCount)
{
fDstPtr = dPtr;
fBitOffset = 0;
InitTable ();
PutCodeWord (kResetCode);
int32 code = -1;
int32 pixel;
if (sCount > 0)
{
pixel = *sPtr;
sPtr = sPtr + 1;
code = pixel;
sCount--;
while (sCount--)
{
pixel = *sPtr;
sPtr = sPtr + 1;
int32 newCode = SearchTable (code, pixel);
if (newCode == -1)
{
PutCodeWord (code);
if (fNextCode < 4093)
{
AddTable (code, pixel);
}
else
{
PutCodeWord (kResetCode);
InitTable ();
}
code = pixel;
}
else
code = newCode;
}
}
if (code != -1)
{
PutCodeWord (code);
AddTable (code, 0);
}
PutCodeWord (kEndCode);
dCount = (fBitOffset + 7) >> 3;
}
/*****************************************************************************/
#if qDNGUseLibJPEG
/*****************************************************************************/
static void dng_error_exit (j_common_ptr cinfo)
{
// Output message.
(*cinfo->err->output_message) (cinfo);
// Convert to a dng_exception.
switch (cinfo->err->msg_code)
{
case JERR_OUT_OF_MEMORY:
{
ThrowMemoryFull ();
break;
}
default:
{
ThrowBadFormat ();
}
}
}
/*****************************************************************************/
static void dng_output_message (j_common_ptr cinfo)
{
// Format message to string.
char buffer [JMSG_LENGTH_MAX];
(*cinfo->err->format_message) (cinfo, buffer);
// Report the libjpeg message as a warning.
ReportWarning ("libjpeg", buffer);
}
/*****************************************************************************/
struct dng_jpeg_stream_dest
{
struct jpeg_destination_mgr pub;
dng_stream *fStream;
uint8 fBuffer [4096];
};
/*****************************************************************************/
static void dng_init_destination (j_compress_ptr cinfo)
{
dng_jpeg_stream_dest *dest = (dng_jpeg_stream_dest *) cinfo->dest;
dest->pub.next_output_byte = dest->fBuffer;
dest->pub.free_in_buffer = sizeof (dest->fBuffer);
}
/*****************************************************************************/
static boolean dng_empty_output_buffer (j_compress_ptr cinfo)
{
dng_jpeg_stream_dest *dest = (dng_jpeg_stream_dest *) cinfo->dest;
dest->fStream->Put (dest->fBuffer, sizeof (dest->fBuffer));
dest->pub.next_output_byte = dest->fBuffer;
dest->pub.free_in_buffer = sizeof (dest->fBuffer);
return TRUE;
}
/*****************************************************************************/
static void dng_term_destination (j_compress_ptr cinfo)
{
dng_jpeg_stream_dest *dest = (dng_jpeg_stream_dest *) cinfo->dest;
uint32 datacount = sizeof (dest->fBuffer) -
(uint32) dest->pub.free_in_buffer;
if (datacount)
{
dest->fStream->Put (dest->fBuffer, datacount);
}
}
/*****************************************************************************/
static void jpeg_set_adobe_quality (struct jpeg_compress_struct *cinfo,
int32 quality)
{
// If out of range, map to default.
if (quality < 0 || quality > 12)
{
quality = 10;
}
// Adobe turns off chroma downsampling at high quality levels.
bool useChromaDownsampling = (quality <= 6);
// Approximate mapping from Adobe quality levels to LibJPEG levels.
const int kLibJPEGQuality [13] =
{
5, 11, 23, 34, 46, 63, 76, 77, 86, 90, 94, 97, 99
};
quality = kLibJPEGQuality [quality];
jpeg_set_quality (cinfo, quality, TRUE);
// LibJPEG defaults to always using chroma downsampling. Turn if off
// if we need it off to match Adobe.
if (!useChromaDownsampling)
{
cinfo->comp_info [0].h_samp_factor = 1;
cinfo->comp_info [0].h_samp_factor = 1;
}
}
/*****************************************************************************/
#endif
/*****************************************************************************/
void dng_image_writer::WriteData (dng_host &host,
const dng_ifd &ifd,
dng_stream &stream,
dng_pixel_buffer &buffer,
AutoPtr<dng_memory_block> &compressedBuffer)
{
switch (ifd.fCompression)
{
case ccUncompressed:
{
// Special case support for when we save to 8-bits from
// 16-bit data.
if (ifd.fBitsPerSample [0] == 8 && buffer.fPixelType == ttShort)
{
uint32 count = buffer.fRowStep *
buffer.fArea.H ();
const uint16 *sPtr = (const uint16 *) buffer.fData;
for (uint32 j = 0; j < count; j++)
{
stream.Put_uint8 ((uint8) sPtr [j]);
}
}
else
{
// Swap bytes if required.
if (stream.SwapBytes ())
{
ByteSwapBuffer (host, buffer);
}
// Write the bytes.
stream.Put (buffer.fData, buffer.fRowStep *
buffer.fArea.H () *
buffer.fPixelSize);
}
break;
}
case ccLZW:
case ccDeflate:
{
// Both these compression algorithms are byte based. The floating
// point predictor already does byte ordering, so don't ever swap
// when using it.
if (stream.SwapBytes () && ifd.fPredictor != cpFloatingPoint)
{
ByteSwapBuffer (host,
buffer);
}
// Run the compression algorithm.
uint32 sBytes = buffer.fRowStep *
buffer.fArea.H () *
buffer.fPixelSize;
uint8 *sBuffer = (uint8 *) buffer.fData;
uint32 dBytes = 0;
uint8 *dBuffer = compressedBuffer->Buffer_uint8 ();
if (ifd.fCompression == ccLZW)
{
dng_lzw_compressor lzwCompressor;
lzwCompressor.Compress (sBuffer,
dBuffer,
sBytes,
dBytes);
}
else
{
uLongf dCount = compressedBuffer->LogicalSize ();
int32 level = Z_DEFAULT_COMPRESSION;
if (ifd.fCompressionQuality >= Z_BEST_SPEED &&
ifd.fCompressionQuality <= Z_BEST_COMPRESSION)
{
level = ifd.fCompressionQuality;
}
int zResult = ::compress2 (dBuffer,
&dCount,
sBuffer,
sBytes,
level);
if (zResult != Z_OK)
{
ThrowMemoryFull ();
}
dBytes = (uint32) dCount;
}
if (dBytes > compressedBuffer->LogicalSize ())
{
DNG_REPORT ("Compression output buffer overflow");
ThrowProgramError ();
}
stream.Put (dBuffer, dBytes);
return;
}
case ccJPEG:
{
dng_pixel_buffer temp (buffer);
if (buffer.fPixelType == ttByte)
{
// The lossless JPEG encoder needs 16-bit data, so if we are
// are saving 8 bit data, we need to pad it out to 16-bits.
temp.fData = compressedBuffer->Buffer ();
temp.fPixelType = ttShort;
temp.fPixelSize = 2;
temp.CopyArea (buffer,
buffer.fArea,
buffer.fPlane,
buffer.fPlanes);
}
EncodeLosslessJPEG ((const uint16 *) temp.fData,
temp.fArea.H (),
temp.fArea.W (),
temp.fPlanes,
ifd.fBitsPerSample [0],
temp.fRowStep,
temp.fColStep,
stream);
break;
}
#if qDNGUseLibJPEG
case ccLossyJPEG:
{
struct jpeg_compress_struct cinfo;
// Setup the error manager.
struct jpeg_error_mgr jerr;
cinfo.err = jpeg_std_error (&jerr);
jerr.error_exit = dng_error_exit;
jerr.output_message = dng_output_message;
try
{
// Create the compression context.
jpeg_create_compress (&cinfo);
// Setup the destination manager to write to stream.
dng_jpeg_stream_dest dest;
dest.fStream = &stream;
dest.pub.init_destination = dng_init_destination;
dest.pub.empty_output_buffer = dng_empty_output_buffer;
dest.pub.term_destination = dng_term_destination;
cinfo.dest = &dest.pub;
// Setup basic image info.
cinfo.image_width = buffer.fArea.W ();
cinfo.image_height = buffer.fArea.H ();
cinfo.input_components = buffer.fPlanes;
switch (buffer.fPlanes)
{
case 1:
cinfo.in_color_space = JCS_GRAYSCALE;
break;
case 3:
cinfo.in_color_space = JCS_RGB;
break;
case 4:
cinfo.in_color_space = JCS_CMYK;
break;
default:
ThrowProgramError ();
}
// Setup the compression parameters.
jpeg_set_defaults (&cinfo);
jpeg_set_adobe_quality (&cinfo, ifd.fCompressionQuality);
// Write the JPEG header.
jpeg_start_compress (&cinfo, TRUE);
// Write the scanlines.
for (int32 row = buffer.fArea.t; row < buffer.fArea.b; row++)
{
uint8 *sampArray [1];
sampArray [0] = buffer.DirtyPixel_uint8 (row,
buffer.fArea.l,
0);
jpeg_write_scanlines (&cinfo, sampArray, 1);
}
// Cleanup.
jpeg_finish_compress (&cinfo);
jpeg_destroy_compress (&cinfo);
}
catch (...)
{
jpeg_destroy_compress (&cinfo);
throw;
}
return;
}
#endif
default:
{
ThrowProgramError ();
}
}
}
/******************************************************************************/
void dng_image_writer::EncodeJPEGPreview (dng_host &host,
const dng_image &image,
dng_jpeg_preview &preview,
int32 quality)
{
#if qDNGUseLibJPEG
dng_memory_stream stream (host.Allocator ());
struct jpeg_compress_struct cinfo;
// Setup the error manager.
struct jpeg_error_mgr jerr;
cinfo.err = jpeg_std_error (&jerr);
jerr.error_exit = dng_error_exit;
jerr.output_message = dng_output_message;
try
{
// Create the compression context.
jpeg_create_compress (&cinfo);
// Setup the destination manager to write to stream.
dng_jpeg_stream_dest dest;
dest.fStream = &stream;
dest.pub.init_destination = dng_init_destination;
dest.pub.empty_output_buffer = dng_empty_output_buffer;
dest.pub.term_destination = dng_term_destination;
cinfo.dest = &dest.pub;
// Setup basic image info.
cinfo.image_width = image.Bounds ().W ();
cinfo.image_height = image.Bounds ().H ();
cinfo.input_components = image.Planes ();
switch (image.Planes ())
{
case 1:
cinfo.in_color_space = JCS_GRAYSCALE;
break;
case 3:
cinfo.in_color_space = JCS_RGB;
break;
default:
ThrowProgramError ();
}
// Setup the compression parameters.
jpeg_set_defaults (&cinfo);
jpeg_set_adobe_quality (&cinfo, quality);
// Find some preview information based on the compression settings.
preview.fPreviewSize = image.Size ();
if (image.Planes () == 1)
{
preview.fPhotometricInterpretation = piBlackIsZero;
}
else
{
preview.fPhotometricInterpretation = piYCbCr;
preview.fYCbCrSubSampling.h = cinfo.comp_info [0].h_samp_factor;
preview.fYCbCrSubSampling.v = cinfo.comp_info [0].v_samp_factor;
}
// Write the JPEG header.
jpeg_start_compress (&cinfo, TRUE);
// Write the scanlines.
dng_pixel_buffer buffer (image.Bounds (), 0, image.Planes (), ttByte,
pcInterleaved, NULL);
AutoPtr<dng_memory_block> bufferData (host.Allocate (buffer.fRowStep));
buffer.fData = bufferData->Buffer ();
for (uint32 row = 0; row < cinfo.image_height; row++)
{
buffer.fArea.t = row;
buffer.fArea.b = row + 1;
image.Get (buffer);
uint8 *sampArray [1];
sampArray [0] = buffer.DirtyPixel_uint8 (row,
buffer.fArea.l,
0);
jpeg_write_scanlines (&cinfo, sampArray, 1);
}
// Cleanup.
jpeg_finish_compress (&cinfo);
jpeg_destroy_compress (&cinfo);
}
catch (...)
{
jpeg_destroy_compress (&cinfo);
throw;
}
preview.fCompressedData.Reset (stream.AsMemoryBlock (host.Allocator ()));
#else
(void) host;
(void) image;
(void) preview;
(void) quality;
ThrowProgramError ("No JPEG encoder");
#endif
}
/*****************************************************************************/
void dng_image_writer::WriteTile (dng_host &host,
const dng_ifd &ifd,
dng_stream &stream,
const dng_image &image,
const dng_rect &tileArea,
uint32 fakeChannels,
AutoPtr<dng_memory_block> &compressedBuffer,
AutoPtr<dng_memory_block> &uncompressedBuffer,
AutoPtr<dng_memory_block> &subTileBlockBuffer,
AutoPtr<dng_memory_block> &tempBuffer)
{
// Create pixel buffer to hold uncompressed tile.
dng_pixel_buffer buffer (tileArea, 0, ifd.fSamplesPerPixel,
image.PixelType(), pcInterleaved, uncompressedBuffer->Buffer());
// Get the uncompressed data.
image.Get (buffer, dng_image::edge_zero);
// Deal with sub-tile blocks.
if (ifd.fSubTileBlockRows > 1)
{
ReorderSubTileBlocks (ifd,
buffer,
uncompressedBuffer,
subTileBlockBuffer);
}
// Floating point depth conversion.
if (ifd.fSampleFormat [0] == sfFloatingPoint)
{
if (ifd.fBitsPerSample [0] == 16)
{
uint32 *srcPtr = (uint32 *) buffer.fData;
uint16 *dstPtr = (uint16 *) buffer.fData;
uint32 pixels = tileArea.W () * tileArea.H () * buffer.fPlanes;
for (uint32 j = 0; j < pixels; j++)
{
dstPtr [j] = DNG_FloatToHalf (srcPtr [j]);
}
buffer.fPixelSize = 2;
}
if (ifd.fBitsPerSample [0] == 24)
{
uint32 *srcPtr = (uint32 *) buffer.fData;
uint8 *dstPtr = (uint8 *) buffer.fData;
uint32 pixels = tileArea.W () * tileArea.H () * buffer.fPlanes;
if (stream.BigEndian () || ifd.fPredictor == cpFloatingPoint ||
ifd.fPredictor == cpFloatingPointX2 ||
ifd.fPredictor == cpFloatingPointX4)
{
for (uint32 j = 0; j < pixels; j++)
{
DNG_FloatToFP24 (srcPtr [j], dstPtr);
dstPtr += 3;
}
}
else
{
for (uint32 j = 0; j < pixels; j++)
{
uint8 output [3];
DNG_FloatToFP24 (srcPtr [j], output);
dstPtr [0] = output [2];
dstPtr [1] = output [1];
dstPtr [2] = output [0];
dstPtr += 3;
}
}
buffer.fPixelSize = 3;
}
}
// Run predictor.
EncodePredictor (host,
ifd,
buffer,
tempBuffer);
// Adjust pixel buffer for fake channels.
if (fakeChannels > 1)
{
buffer.fPlanes *= fakeChannels;
buffer.fColStep *= fakeChannels;
buffer.fArea.r = buffer.fArea.l + (buffer.fArea.W () / fakeChannels);
}
// Compress (if required) and write out the data.
WriteData (host,
ifd,
stream,
buffer,
compressedBuffer);
}
/*****************************************************************************/
class dng_write_tiles_task : public dng_area_task
{
private:
dng_image_writer &fImageWriter;
dng_host &fHost;
const dng_ifd &fIFD;
dng_basic_tag_set &fBasic;
dng_stream &fStream;
const dng_image &fImage;
uint32 fFakeChannels;
uint32 fTilesDown;
uint32 fTilesAcross;
uint32 fCompressedSize;
uint32 fUncompressedSize;
dng_mutex fMutex1;
uint32 fNextTileIndex;
dng_mutex fMutex2;
dng_condition fCondition;
bool fTaskFailed;
uint32 fWriteTileIndex;
public:
dng_write_tiles_task (dng_image_writer &imageWriter,
dng_host &host,
const dng_ifd &ifd,
dng_basic_tag_set &basic,
dng_stream &stream,
const dng_image &image,
uint32 fakeChannels,
uint32 tilesDown,
uint32 tilesAcross,
uint32 compressedSize,
uint32 uncompressedSize)
: fImageWriter (imageWriter)
, fHost (host)
, fIFD (ifd)
, fBasic (basic)
, fStream (stream)
, fImage (image)
, fFakeChannels (fakeChannels)
, fTilesDown (tilesDown)
, fTilesAcross (tilesAcross)
, fCompressedSize (compressedSize)
, fUncompressedSize (uncompressedSize)
, fMutex1 ("dng_write_tiles_task_1")
, fNextTileIndex (0)
, fMutex2 ("dng_write_tiles_task_2")
, fCondition ()
, fTaskFailed (false)
, fWriteTileIndex (0)
{
fMinTaskArea = 16 * 16;
fUnitCell = dng_point (16, 16);
fMaxTileSize = dng_point (16, 16);
}
void Process (uint32 /* threadIndex */,
const dng_rect & /* tile */,
dng_abort_sniffer *sniffer)
{
try
{
AutoPtr<dng_memory_block> compressedBuffer;
AutoPtr<dng_memory_block> uncompressedBuffer;
AutoPtr<dng_memory_block> subTileBlockBuffer;
AutoPtr<dng_memory_block> tempBuffer;
if (fCompressedSize)
{
compressedBuffer.Reset (fHost.Allocate (fCompressedSize));
}
if (fUncompressedSize)
{
uncompressedBuffer.Reset (fHost.Allocate (fUncompressedSize));
}
if (fIFD.fSubTileBlockRows > 1 && fUncompressedSize)
{
subTileBlockBuffer.Reset (fHost.Allocate (fUncompressedSize));
}
while (true)
{
// Find tile index to compress.
uint32 tileIndex;
{
dng_lock_mutex lock (&fMutex1);
if (fNextTileIndex == fTilesDown * fTilesAcross)
{
return;
}
tileIndex = fNextTileIndex++;
}
dng_abort_sniffer::SniffForAbort (sniffer);
// Compress tile.
uint32 rowIndex = tileIndex / fTilesAcross;
uint32 colIndex = tileIndex - rowIndex * fTilesAcross;
dng_rect tileArea = fIFD.TileArea (rowIndex, colIndex);
dng_memory_stream tileStream (fHost.Allocator ());
tileStream.SetLittleEndian (fStream.LittleEndian ());
dng_host host (&fHost.Allocator (),
sniffer);
fImageWriter.WriteTile (host,
fIFD,
tileStream,
fImage,
tileArea,
fFakeChannels,
compressedBuffer,
uncompressedBuffer,
subTileBlockBuffer,
tempBuffer);
tileStream.Flush ();
uint32 tileByteCount = (uint32) tileStream.Length ();
tileStream.SetReadPosition (0);
// Wait until it is our turn to write tile.
{
dng_lock_mutex lock (&fMutex2);
while (!fTaskFailed &&
fWriteTileIndex != tileIndex)
{
fCondition.Wait (fMutex2);
}
// If the task failed in another thread, that thread already threw an exception.
if (fTaskFailed)
return;
}
dng_abort_sniffer::SniffForAbort (sniffer);
// Remember this offset.
uint32 tileOffset = (uint32) fStream.Position ();
fBasic.SetTileOffset (tileIndex, tileOffset);
// Copy tile stream for tile into main stream.
tileStream.CopyToStream (fStream, tileByteCount);
// Update tile count.
fBasic.SetTileByteCount (tileIndex, tileByteCount);
// Keep the tiles on even byte offsets.
if (tileByteCount & 1)
{
fStream.Put_uint8 (0);
}
// Let other threads know it is safe to write to stream.
{
dng_lock_mutex lock (&fMutex2);
// If the task failed in another thread, that thread already threw an exception.
if (fTaskFailed)
return;
fWriteTileIndex++;
fCondition.Broadcast ();
}
}
}
catch (...)
{
// If first to fail, wake up any threads waiting on condition.
bool needBroadcast = false;
{
dng_lock_mutex lock (&fMutex2);
needBroadcast = !fTaskFailed;
fTaskFailed = true;
}
if (needBroadcast)
fCondition.Broadcast ();
throw;
}
}
private:
// Hidden copy constructor and assignment operator.
dng_write_tiles_task (const dng_write_tiles_task &);
dng_write_tiles_task & operator= (const dng_write_tiles_task &);
};
/*****************************************************************************/
void dng_image_writer::WriteImage (dng_host &host,
const dng_ifd &ifd,
dng_basic_tag_set &basic,
dng_stream &stream,
const dng_image &image,
uint32 fakeChannels)
{
// Deal with row interleaved images.
if (ifd.fRowInterleaveFactor > 1 &&
ifd.fRowInterleaveFactor < ifd.fImageLength)
{
dng_ifd tempIFD (ifd);
tempIFD.fRowInterleaveFactor = 1;
dng_row_interleaved_image tempImage (*((dng_image *) &image),
ifd.fRowInterleaveFactor);
WriteImage (host,
tempIFD,
basic,
stream,
tempImage,
fakeChannels);
return;
}
// Compute basic information.
uint32 bytesPerSample = TagTypeSize (image.PixelType ());
uint32 bytesPerPixel = SafeUint32Mult (ifd.fSamplesPerPixel,
bytesPerSample);
uint32 tileRowBytes = SafeUint32Mult (ifd.fTileWidth, bytesPerPixel);
// If we can compute the number of bytes needed to store the
// data, we can split the write for each tile into sub-tiles.
uint32 subTileLength = ifd.fTileLength;
if (ifd.TileByteCount (ifd.TileArea (0, 0)) != 0)
{
subTileLength = Pin_uint32 (ifd.fSubTileBlockRows,
kImageBufferSize / tileRowBytes,
ifd.fTileLength);
// Don't split sub-tiles across subTileBlocks.
subTileLength = subTileLength / ifd.fSubTileBlockRows
* ifd.fSubTileBlockRows;
}
// Find size of uncompressed buffer.
uint32 uncompressedSize = SafeUint32Mult(subTileLength, tileRowBytes);
// Find size of compressed buffer, if required.
uint32 compressedSize = CompressedBufferSize (ifd, uncompressedSize);
// See if we can do this write using multiple threads.
uint32 tilesAcross = ifd.TilesAcross ();
uint32 tilesDown = ifd.TilesDown ();
bool useMultipleThreads = (tilesDown * tilesAcross >= 2) &&
(host.PerformAreaTaskThreads () > 1) &&
(subTileLength == ifd.fTileLength) &&
(ifd.fCompression != ccUncompressed);
#if qImagecore
useMultipleThreads = false;
#endif
if (useMultipleThreads)
{
uint32 threadCount = Min_uint32 (tilesDown * tilesAcross,
host.PerformAreaTaskThreads ());
dng_write_tiles_task task (*this,
host,
ifd,
basic,
stream,
image,
fakeChannels,
tilesDown,
tilesAcross,
compressedSize,
uncompressedSize);
host.PerformAreaTask (task,
dng_rect (0, 0, 16, 16 * threadCount));
}
else
{
AutoPtr<dng_memory_block> compressedBuffer;
AutoPtr<dng_memory_block> uncompressedBuffer;
AutoPtr<dng_memory_block> subTileBlockBuffer;
AutoPtr<dng_memory_block> tempBuffer;
if (compressedSize)
{
compressedBuffer.Reset (host.Allocate (compressedSize));
}
if (uncompressedSize)
{
uncompressedBuffer.Reset (host.Allocate (uncompressedSize));
}
if (ifd.fSubTileBlockRows > 1 && uncompressedSize)
{
subTileBlockBuffer.Reset (host.Allocate (uncompressedSize));
}
// Write out each tile.
uint32 tileIndex = 0;
for (uint32 rowIndex = 0; rowIndex < tilesDown; rowIndex++)
{
for (uint32 colIndex = 0; colIndex < tilesAcross; colIndex++)
{
// Remember this offset.
uint32 tileOffset = (uint32) stream.Position ();
basic.SetTileOffset (tileIndex, tileOffset);
// Split tile into sub-tiles if possible.
dng_rect tileArea = ifd.TileArea (rowIndex, colIndex);
uint32 subTileCount = (tileArea.H () + subTileLength - 1) /
subTileLength;
for (uint32 subIndex = 0; subIndex < subTileCount; subIndex++)
{
host.SniffForAbort ();
dng_rect subArea (tileArea);
subArea.t = tileArea.t + subIndex * subTileLength;
subArea.b = Min_int32 (subArea.t + subTileLength,
tileArea.b);
// Write the sub-tile.
WriteTile (host,
ifd,
stream,
image,
subArea,
fakeChannels,
compressedBuffer,
uncompressedBuffer,
subTileBlockBuffer,
tempBuffer);
}
// Update tile count.
uint32 tileByteCount = (uint32) stream.Position () - tileOffset;
basic.SetTileByteCount (tileIndex, tileByteCount);
tileIndex++;
// Keep the tiles on even byte offsets.
if (tileByteCount & 1)
{
stream.Put_uint8 (0);
}
}
}
}
}
/*****************************************************************************/
#if qDNGUseXMP
static void CopyString (const dng_xmp &oldXMP,
dng_xmp &newXMP,
const char *ns,
const char *path,
dng_string *exif = NULL)
{
dng_string s;
if (oldXMP.GetString (ns, path, s))
{
if (s.NotEmpty ())
{
newXMP.SetString (ns, path, s);
if (exif)
{
*exif = s;
}
}
}
}
/*****************************************************************************/
static void CopyStringList (const dng_xmp &oldXMP,
dng_xmp &newXMP,
const char *ns,
const char *path,
bool isBag)
{
dng_string_list list;
if (oldXMP.GetStringList (ns, path, list))
{
if (list.Count ())
{
newXMP.SetStringList (ns, path, list, isBag);
}
}
}
/*****************************************************************************/
static void CopyAltLangDefault (const dng_xmp &oldXMP,
dng_xmp &newXMP,
const char *ns,
const char *path,
dng_string *exif = NULL)
{
dng_string s;
if (oldXMP.GetAltLangDefault (ns, path, s))
{
if (s.NotEmpty ())
{
newXMP.SetAltLangDefault (ns, path, s);
if (exif)
{
*exif = s;
}
}
}
}
/*****************************************************************************/
static void CopyStructField (const dng_xmp &oldXMP,
dng_xmp &newXMP,
const char *ns,
const char *path,
const char *field)
{
dng_string s;
if (oldXMP.GetStructField (ns, path, ns, field, s))
{
if (s.NotEmpty ())
{
newXMP.SetStructField (ns, path, ns, field, s);
}
}
}
/*****************************************************************************/
static void CopyBoolean (const dng_xmp &oldXMP,
dng_xmp &newXMP,
const char *ns,
const char *path)
{
bool b;
if (oldXMP.GetBoolean (ns, path, b))
{
newXMP.SetBoolean (ns, path, b);
}
}
#endif
/*****************************************************************************/
void dng_image_writer::CleanUpMetadata (dng_host &host,
dng_metadata &metadata,
dng_metadata_subset metadataSubset,
const char *dstMIMI,
const char *software)
{
#if qDNGUseXMP
if (metadata.GetXMP () && metadata.GetExif ())
{
dng_xmp &newXMP (*metadata.GetXMP ());
dng_exif &newEXIF (*metadata.GetExif ());
// Update software tag.
if (software)
{
newEXIF.fSoftware.Set (software);
newXMP.Set (XMP_NS_XAP,
"CreatorTool",
software);
}
#if qDNGXMPDocOps
newXMP.DocOpsPrepareForSave (metadata.SourceMIMI ().Get (),
dstMIMI);
#else
metadata.UpdateDateTimeToNow ();
#endif
// Update EXIF version to at least 2.3 so all the exif tags
// can be written.
if (newEXIF.fExifVersion < DNG_CHAR4 ('0','2','3','0'))
{
newEXIF.fExifVersion = DNG_CHAR4 ('0','2','3','0');
newXMP.Set (XMP_NS_EXIF, "ExifVersion", "0230");
}
// Resync EXIF, remove EXIF tags from XMP.
newXMP.SyncExif (newEXIF,
metadata.GetOriginalExif (),
false,
true);
// Deal with ImageIngesterPro bug. This program is adding lots of
// empty metadata strings into the XMP, which is screwing up Adobe CS4.
// We are saving a new file, so this is a chance to clean up this mess.
newXMP.RemoveEmptyStringsAndArrays (XMP_NS_DC);
newXMP.RemoveEmptyStringsAndArrays (XMP_NS_XAP);
newXMP.RemoveEmptyStringsAndArrays (XMP_NS_PHOTOSHOP);
newXMP.RemoveEmptyStringsAndArrays (XMP_NS_IPTC);
newXMP.RemoveEmptyStringsAndArrays (XMP_NS_XAP_RIGHTS);
newXMP.RemoveEmptyStringsAndArrays ("http://ns.iview-multimedia.com/mediapro/1.0/");
// Process metadata subset.
if (metadataSubset == kMetadataSubset_CopyrightOnly ||
metadataSubset == kMetadataSubset_CopyrightAndContact)
{
dng_xmp oldXMP (newXMP );
dng_exif oldEXIF (newEXIF);
// For these options, we start from nothing, and only fill in the
// fields that we absolutely need.
newXMP.RemoveProperties (NULL);
newEXIF.SetEmpty ();
metadata.ClearMakerNote ();
// Move copyright related fields over.
CopyAltLangDefault (oldXMP,
newXMP,
XMP_NS_DC,
"rights",
&newEXIF.fCopyright);
CopyAltLangDefault (oldXMP,
newXMP,
XMP_NS_XAP_RIGHTS,
"UsageTerms");
CopyString (oldXMP,
newXMP,
XMP_NS_XAP_RIGHTS,
"WebStatement");
CopyBoolean (oldXMP,
newXMP,
XMP_NS_XAP_RIGHTS,
"Marked");
#if qDNGXMPDocOps
// Include basic DocOps fields, but not the full history.
CopyString (oldXMP,
newXMP,
XMP_NS_MM,
"OriginalDocumentID");
CopyString (oldXMP,
newXMP,
XMP_NS_MM,
"DocumentID");
CopyString (oldXMP,
newXMP,
XMP_NS_MM,
"InstanceID");
CopyString (oldXMP,
newXMP,
XMP_NS_XAP,
"MetadataDate");
#endif
// Copyright and Contact adds the contact info fields.
if (metadataSubset == kMetadataSubset_CopyrightAndContact)
{
// Note: Save for Web is not including the dc:creator list, but it
// is part of the IPTC contract info metadata panel, so I
// think it should be copied as part of the contact info.
CopyStringList (oldXMP,
newXMP,
XMP_NS_DC,
"creator",
false);
// The first string dc:creator list is mirrored to the
// the exif artist tag, so copy that also.
newEXIF.fArtist = oldEXIF.fArtist;
// Copy other contact fields.
CopyString (oldXMP,
newXMP,
XMP_NS_PHOTOSHOP,
"AuthorsPosition");
CopyStructField (oldXMP,
newXMP,
XMP_NS_IPTC,
"CreatorContactInfo",
"CiEmailWork");
CopyStructField (oldXMP,
newXMP,
XMP_NS_IPTC,
"CreatorContactInfo",
"CiAdrExtadr");
CopyStructField (oldXMP,
newXMP,
XMP_NS_IPTC,
"CreatorContactInfo",
"CiAdrCity");
CopyStructField (oldXMP,
newXMP,
XMP_NS_IPTC,
"CreatorContactInfo",
"CiAdrRegion");
CopyStructField (oldXMP,
newXMP,
XMP_NS_IPTC,
"CreatorContactInfo",
"CiAdrPcode");
CopyStructField (oldXMP,
newXMP,
XMP_NS_IPTC,
"CreatorContactInfo",
"CiAdrCtry");
CopyStructField (oldXMP,
newXMP,
XMP_NS_IPTC,
"CreatorContactInfo",
"CiTelWork");
CopyStructField (oldXMP,
newXMP,
XMP_NS_IPTC,
"CreatorContactInfo",
"CiUrlWork");
CopyAltLangDefault (oldXMP,
newXMP,
XMP_NS_DC,
"title");
}
}
else if (metadataSubset == kMetadataSubset_AllExceptCameraInfo ||
metadataSubset == kMetadataSubset_AllExceptCameraAndLocation ||
metadataSubset == kMetadataSubset_AllExceptLocationInfo)
{
dng_xmp oldXMP (newXMP );
dng_exif oldEXIF (newEXIF);
if (metadataSubset == kMetadataSubset_AllExceptCameraInfo ||
metadataSubset == kMetadataSubset_AllExceptCameraAndLocation)
{
// This removes most of the EXIF info, so just copy the fields
// we are not deleting.
newEXIF.SetEmpty ();
newEXIF.fImageDescription = oldEXIF.fImageDescription; // Note: Differs from SFW
newEXIF.fSoftware = oldEXIF.fSoftware;
newEXIF.fArtist = oldEXIF.fArtist;
newEXIF.fCopyright = oldEXIF.fCopyright;
newEXIF.fCopyright2 = oldEXIF.fCopyright2;
newEXIF.fDateTime = oldEXIF.fDateTime;
newEXIF.fDateTimeOriginal = oldEXIF.fDateTimeOriginal;
newEXIF.fDateTimeDigitized = oldEXIF.fDateTimeDigitized;
newEXIF.fExifVersion = oldEXIF.fExifVersion;
newEXIF.fImageUniqueID = oldEXIF.fImageUniqueID;
newEXIF.CopyGPSFrom (oldEXIF);
// Remove exif info from XMP.
newXMP.RemoveProperties (XMP_NS_EXIF);
newXMP.RemoveProperties (XMP_NS_AUX);
// Remove Camera Raw info
newXMP.RemoveProperties (XMP_NS_CRS);
newXMP.RemoveProperties (XMP_NS_CRSS);
newXMP.RemoveProperties (XMP_NS_CRX);
// Remove DocOps history, since it contains the original
// camera format.
newXMP.Remove (XMP_NS_MM, "History");
// MakerNote contains camera info.
metadata.ClearMakerNote ();
}
if (metadataSubset == kMetadataSubset_AllExceptLocationInfo ||
metadataSubset == kMetadataSubset_AllExceptCameraAndLocation)
{
// Remove GPS fields.
dng_exif blankExif;
newEXIF.CopyGPSFrom (blankExif);
// Remove MakerNote just in case, because we don't know
// all of what is in it.
metadata.ClearMakerNote ();
// Remove XMP & IPTC location fields.
newXMP.Remove (XMP_NS_PHOTOSHOP, "City");
newXMP.Remove (XMP_NS_PHOTOSHOP, "State");
newXMP.Remove (XMP_NS_PHOTOSHOP, "Country");
newXMP.Remove (XMP_NS_IPTC, "Location");
newXMP.Remove (XMP_NS_IPTC, "CountryCode");
newXMP.Remove (XMP_NS_IPTC_EXT, "LocationCreated");
newXMP.Remove (XMP_NS_IPTC_EXT, "LocationShown");
}
}
// Rebuild the legacy IPTC block, if needed.
bool isTIFF = (strcmp (dstMIMI, "image/tiff") == 0);
bool isDNG = (strcmp (dstMIMI, "image/dng" ) == 0);
if (!isDNG)
{
metadata.RebuildIPTC (host.Allocator (),
isTIFF);
}
else
{
metadata.ClearIPTC ();
}
// Clear format related XMP.
newXMP.ClearOrientation ();
newXMP.ClearImageInfo ();
newXMP.RemoveProperties (XMP_NS_DNG);
// All the formats we care about already keep the IPTC digest
// elsewhere, do we don't need to write it to the XMP.
newXMP.ClearIPTCDigest ();
// Make sure that sidecar specific tags never get written to files.
newXMP.Remove (XMP_NS_PHOTOSHOP, "SidecarForExtension");
newXMP.Remove (XMP_NS_PHOTOSHOP, "EmbeddedXMPDigest");
}
#endif
}
/*****************************************************************************/
void dng_image_writer::WriteTIFF (dng_host &host,
dng_stream &stream,
const dng_image &image,
uint32 photometricInterpretation,
uint32 compression,
dng_negative *negative,
const dng_color_space *space,
const dng_resolution *resolution,
const dng_jpeg_preview *thumbnail,
const dng_memory_block *imageResources,
dng_metadata_subset metadataSubset)
{
WriteTIFF (host,
stream,
image,
photometricInterpretation,
compression,
negative ? &(negative->Metadata ()) : NULL,
space,
resolution,
thumbnail,
imageResources,
metadataSubset);
}
/*****************************************************************************/
void dng_image_writer::WriteTIFF (dng_host &host,
dng_stream &stream,
const dng_image &image,
uint32 photometricInterpretation,
uint32 compression,
const dng_metadata *metadata,
const dng_color_space *space,
const dng_resolution *resolution,
const dng_jpeg_preview *thumbnail,
const dng_memory_block *imageResources,
dng_metadata_subset metadataSubset)
{
const void *profileData = NULL;
uint32 profileSize = 0;
const uint8 *data = NULL;
uint32 size = 0;
if (space && space->ICCProfile (size, data))
{
profileData = data;
profileSize = size;
}
WriteTIFFWithProfile (host,
stream,
image,
photometricInterpretation,
compression,
metadata,
profileData,
profileSize,
resolution,
thumbnail,
imageResources,
metadataSubset);
}
/*****************************************************************************/
void dng_image_writer::WriteTIFFWithProfile (dng_host &host,
dng_stream &stream,
const dng_image &image,
uint32 photometricInterpretation,
uint32 compression,
dng_negative *negative,
const void *profileData,
uint32 profileSize,
const dng_resolution *resolution,
const dng_jpeg_preview *thumbnail,
const dng_memory_block *imageResources,
dng_metadata_subset metadataSubset)
{
WriteTIFFWithProfile (host,
stream,
image,
photometricInterpretation,
compression,
negative ? &(negative->Metadata ()) : NULL,
profileData,
profileSize,
resolution,
thumbnail,
imageResources,
metadataSubset);
}
/*****************************************************************************/
void dng_image_writer::WriteTIFFWithProfile (dng_host &host,
dng_stream &stream,
const dng_image &image,
uint32 photometricInterpretation,
uint32 compression,
const dng_metadata *constMetadata,
const void *profileData,
uint32 profileSize,
const dng_resolution *resolution,
const dng_jpeg_preview *thumbnail,
const dng_memory_block *imageResources,
dng_metadata_subset metadataSubset)
{
uint32 j;
AutoPtr<dng_metadata> metadata;
if (constMetadata)
{
metadata.Reset (constMetadata->Clone (host.Allocator ()));
CleanUpMetadata (host,
*metadata,
metadataSubset,
"image/tiff");
}
dng_ifd ifd;
ifd.fNewSubFileType = sfMainImage;
ifd.fImageWidth = image.Bounds ().W ();
ifd.fImageLength = image.Bounds ().H ();
ifd.fSamplesPerPixel = image.Planes ();
ifd.fBitsPerSample [0] = TagTypeSize (image.PixelType ()) * 8;
for (j = 1; j < ifd.fSamplesPerPixel; j++)
{
ifd.fBitsPerSample [j] = ifd.fBitsPerSample [0];
}
ifd.fPhotometricInterpretation = photometricInterpretation;
ifd.fCompression = compression;
if (ifd.fCompression == ccUncompressed)
{
ifd.SetSingleStrip ();
}
else
{
ifd.FindStripSize (128 * 1024);
ifd.fPredictor = cpHorizontalDifference;
}
uint32 extraSamples = 0;
switch (photometricInterpretation)
{
case piBlackIsZero:
{
extraSamples = image.Planes () - 1;
break;
}
case piRGB:
{
extraSamples = image.Planes () - 3;
break;
}
default:
break;
}
ifd.fExtraSamplesCount = extraSamples;
if (image.PixelType () == ttFloat)
{
for (j = 0; j < ifd.fSamplesPerPixel; j++)
{
ifd.fSampleFormat [j] = sfFloatingPoint;
}
}
dng_tiff_directory mainIFD;
dng_basic_tag_set basic (mainIFD, ifd);
// Resolution.
dng_resolution res;
if (resolution)
{
res = *resolution;
}
tag_urational tagXResolution (tcXResolution, res.fXResolution);
tag_urational tagYResolution (tcYResolution, res.fYResolution);
tag_uint16 tagResolutionUnit (tcResolutionUnit, res.fResolutionUnit);
if (resolution)
{
mainIFD.Add (&tagXResolution );
mainIFD.Add (&tagYResolution );
mainIFD.Add (&tagResolutionUnit);
}
// ICC Profile.
tag_icc_profile iccProfileTag (profileData, profileSize);
if (iccProfileTag.Count ())
{
mainIFD.Add (&iccProfileTag);
}
// XMP metadata.
#if qDNGUseXMP
tag_xmp tagXMP (metadata.Get () ? metadata->GetXMP () : NULL);
if (tagXMP.Count ())
{
mainIFD.Add (&tagXMP);
}
#endif
// IPTC metadata.
tag_iptc tagIPTC (metadata.Get () ? metadata->IPTCData () : NULL,
metadata.Get () ? metadata->IPTCLength () : 0);
if (tagIPTC.Count ())
{
mainIFD.Add (&tagIPTC);
}
// Adobe data (thumbnail and IPTC digest)
AutoPtr<dng_memory_block> adobeData (BuildAdobeData (host,
metadata.Get (),
thumbnail,
imageResources));
tag_uint8_ptr tagAdobe (tcAdobeData,
adobeData->Buffer_uint8 (),
adobeData->LogicalSize ());
if (tagAdobe.Count ())
{
mainIFD.Add (&tagAdobe);
}
// Exif metadata.
exif_tag_set exifSet (mainIFD,
metadata.Get () && metadata->GetExif () ? *metadata->GetExif ()
: dng_exif (),
metadata.Get () ? metadata->IsMakerNoteSafe () : false,
metadata.Get () ? metadata->MakerNoteData () : NULL,
metadata.Get () ? metadata->MakerNoteLength () : 0,
false);
// Find offset to main image data.
uint32 offsetMainIFD = 8;
uint32 offsetExifData = offsetMainIFD + mainIFD.Size ();
exifSet.Locate (offsetExifData);
uint32 offsetMainData = offsetExifData + exifSet.Size ();
stream.SetWritePosition (offsetMainData);
// Write the main image data.
WriteImage (host,
ifd,
basic,
stream,
image);
// Trim the file to this length.
stream.SetLength (stream.Position ());
// TIFF has a 4G size limit.
if (stream.Length () > 0x0FFFFFFFFL)
{
ThrowImageTooBigTIFF ();
}
// Write TIFF Header.
stream.SetWritePosition (0);
stream.Put_uint16 (stream.BigEndian () ? byteOrderMM : byteOrderII);
stream.Put_uint16 (42);
stream.Put_uint32 (offsetMainIFD);
// Write the IFDs.
mainIFD.Put (stream);
exifSet.Put (stream);
stream.Flush ();
}
/*****************************************************************************/
void dng_image_writer::WriteDNG (dng_host &host,
dng_stream &stream,
dng_negative &negative,
const dng_preview_list *previewList,
uint32 maxBackwardVersion,
bool uncompressed)
{
WriteDNG (host,
stream,
negative,
negative.Metadata (),
previewList,
maxBackwardVersion,
uncompressed);
}
/*****************************************************************************/
void dng_image_writer::WriteDNG (dng_host &host,
dng_stream &stream,
const dng_negative &negative,
const dng_metadata &constMetadata,
const dng_preview_list *previewList,
uint32 maxBackwardVersion,
bool uncompressed)
{
uint32 j;
// Clean up metadata per MWG recommendations.
AutoPtr<dng_metadata> metadata (constMetadata.Clone (host.Allocator ()));
CleanUpMetadata (host,
*metadata,
kMetadataSubset_All,
"image/dng");
// Figure out the compression to use. Most of the time this is lossless
// JPEG.
uint32 compression = uncompressed ? ccUncompressed : ccJPEG;
// Was the the original file lossy JPEG compressed?
const dng_jpeg_image *rawJPEGImage = negative.RawJPEGImage ();
// If so, can we save it using the requested compression and DNG version?
if (uncompressed || maxBackwardVersion < dngVersion_1_4_0_0)
{
if (rawJPEGImage || negative.RawJPEGImageDigest ().IsValid ())
{
rawJPEGImage = NULL;
negative.ClearRawJPEGImageDigest ();
negative.ClearRawImageDigest ();
}
}
else if (rawJPEGImage)
{
compression = ccLossyJPEG;
}
// Are we saving the original size tags?
bool saveOriginalDefaultFinalSize = false;
bool saveOriginalBestQualityFinalSize = false;
bool saveOriginalDefaultCropSize = false;
{
// See if we are saving a proxy image.
dng_point defaultFinalSize (negative.DefaultFinalHeight (),
negative.DefaultFinalWidth ());
saveOriginalDefaultFinalSize = (negative.OriginalDefaultFinalSize () !=
defaultFinalSize);
if (saveOriginalDefaultFinalSize)
{
// If the save OriginalDefaultFinalSize tag, this changes the defaults
// for the OriginalBestQualityFinalSize and OriginalDefaultCropSize tags.
saveOriginalBestQualityFinalSize = (negative.OriginalBestQualityFinalSize () !=
defaultFinalSize);
saveOriginalDefaultCropSize = (negative.OriginalDefaultCropSizeV () !=
dng_urational (defaultFinalSize.v, 1)) ||
(negative.OriginalDefaultCropSizeH () !=
dng_urational (defaultFinalSize.h, 1));
}
else
{
// Else these two tags default to the normal non-proxy size image values.
dng_point bestQualityFinalSize (negative.BestQualityFinalHeight (),
negative.BestQualityFinalWidth ());
saveOriginalBestQualityFinalSize = (negative.OriginalBestQualityFinalSize () !=
bestQualityFinalSize);
saveOriginalDefaultCropSize = (negative.OriginalDefaultCropSizeV () !=
negative.DefaultCropSizeV ()) ||
(negative.OriginalDefaultCropSizeH () !=
negative.DefaultCropSizeH ());
}
}
// Is this a floating point image that we are saving?
bool isFloatingPoint = (negative.RawImage ().PixelType () == ttFloat);
// Does this image have a transparency mask?
bool hasTransparencyMask = (negative.RawTransparencyMask () != NULL);
// Should we save a compressed 32-bit integer file?
bool isCompressed32BitInteger = (negative.RawImage ().PixelType () == ttLong) &&
(maxBackwardVersion >= dngVersion_1_4_0_0) &&
(!uncompressed);
// Figure out what main version to use.
uint32 dngVersion = dngVersion_Current;
// Don't write version 1.4 files unless we actually use some feature of the 1.4 spec.
if (dngVersion == dngVersion_1_4_0_0)
{
if (!rawJPEGImage &&
!isFloatingPoint &&
!hasTransparencyMask &&
!isCompressed32BitInteger &&
!saveOriginalDefaultFinalSize &&
!saveOriginalBestQualityFinalSize &&
!saveOriginalDefaultCropSize )
{
dngVersion = dngVersion_1_3_0_0;
}
}
// Figure out what backward version to use.
uint32 dngBackwardVersion = dngVersion_1_1_0_0;
#if defined(qTestRowInterleave) || defined(qTestSubTileBlockRows) || defined(qTestSubTileBlockCols)
dngBackwardVersion = Max_uint32 (dngBackwardVersion, dngVersion_1_2_0_0);
#endif
dngBackwardVersion = Max_uint32 (dngBackwardVersion,
negative.OpcodeList1 ().MinVersion (false));
dngBackwardVersion = Max_uint32 (dngBackwardVersion,
negative.OpcodeList2 ().MinVersion (false));
dngBackwardVersion = Max_uint32 (dngBackwardVersion,
negative.OpcodeList3 ().MinVersion (false));
if (negative.GetMosaicInfo () &&
negative.GetMosaicInfo ()->fCFALayout >= 6)
{
dngBackwardVersion = Max_uint32 (dngBackwardVersion, dngVersion_1_3_0_0);
}
if (rawJPEGImage || isFloatingPoint || hasTransparencyMask || isCompressed32BitInteger)
{
dngBackwardVersion = Max_uint32 (dngBackwardVersion, dngVersion_1_4_0_0);
}
if (dngBackwardVersion > dngVersion)
{
ThrowProgramError ();
}
// Find best thumbnail from preview list, if any.
const dng_preview *thumbnail = NULL;
if (previewList)
{
uint32 thumbArea = 0;
for (j = 0; j < previewList->Count (); j++)
{
const dng_image_preview *imagePreview = dynamic_cast<const dng_image_preview *>(&previewList->Preview (j));
if (imagePreview)
{
uint32 thisArea = imagePreview->fImage->Bounds ().W () *
imagePreview->fImage->Bounds ().H ();
if (!thumbnail || thisArea < thumbArea)
{
thumbnail = &previewList->Preview (j);
thumbArea = thisArea;
}
}
const dng_jpeg_preview *jpegPreview = dynamic_cast<const dng_jpeg_preview *>(&previewList->Preview (j));
if (jpegPreview)
{
uint32 thisArea = jpegPreview->fPreviewSize.h *
jpegPreview->fPreviewSize.v;
if (!thumbnail || thisArea < thumbArea)
{
thumbnail = &previewList->Preview (j);
thumbArea = thisArea;
}
}
}
}
// Create the main IFD
dng_tiff_directory mainIFD;
// Create the IFD for the raw data. If there is no thumnail, this is
// just a reference the main IFD. Otherwise allocate a new one.
AutoPtr<dng_tiff_directory> rawIFD_IfNotMain;
if (thumbnail)
{
rawIFD_IfNotMain.Reset (new dng_tiff_directory);
}
dng_tiff_directory &rawIFD (thumbnail ? *rawIFD_IfNotMain : mainIFD);
// Include DNG version tags.
uint8 dngVersionData [4];
dngVersionData [0] = (uint8) (dngVersion >> 24);
dngVersionData [1] = (uint8) (dngVersion >> 16);
dngVersionData [2] = (uint8) (dngVersion >> 8);
dngVersionData [3] = (uint8) (dngVersion );
tag_uint8_ptr tagDNGVersion (tcDNGVersion, dngVersionData, 4);
mainIFD.Add (&tagDNGVersion);
uint8 dngBackwardVersionData [4];
dngBackwardVersionData [0] = (uint8) (dngBackwardVersion >> 24);
dngBackwardVersionData [1] = (uint8) (dngBackwardVersion >> 16);
dngBackwardVersionData [2] = (uint8) (dngBackwardVersion >> 8);
dngBackwardVersionData [3] = (uint8) (dngBackwardVersion );
tag_uint8_ptr tagDNGBackwardVersion (tcDNGBackwardVersion, dngBackwardVersionData, 4);
mainIFD.Add (&tagDNGBackwardVersion);
// The main IFD contains the thumbnail, if there is a thumbnail.
AutoPtr<dng_basic_tag_set> thmBasic;
if (thumbnail)
{
thmBasic.Reset (thumbnail->AddTagSet (mainIFD));
}
// Get the raw image we are writing.
const dng_image &rawImage (negative.RawImage ());
// For floating point, we only support ZIP compression.
if (isFloatingPoint && !uncompressed)
{
compression = ccDeflate;
}
// For 32-bit integer images, we only support ZIP and uncompressed.
if (rawImage.PixelType () == ttLong)
{
if (isCompressed32BitInteger)
{
compression = ccDeflate;
}
else
{
compression = ccUncompressed;
}
}
// Get a copy of the mosaic info.
dng_mosaic_info mosaicInfo;
if (negative.GetMosaicInfo ())
{
mosaicInfo = *(negative.GetMosaicInfo ());
}
// Create a dng_ifd record for the raw image.
dng_ifd info;
info.fImageWidth = rawImage.Width ();
info.fImageLength = rawImage.Height ();
info.fSamplesPerPixel = rawImage.Planes ();
info.fPhotometricInterpretation = mosaicInfo.IsColorFilterArray () ? piCFA
: piLinearRaw;
info.fCompression = compression;
if (isFloatingPoint && compression == ccDeflate)
{
info.fPredictor = cpFloatingPoint;
if (mosaicInfo.IsColorFilterArray ())
{
if (mosaicInfo.fCFAPatternSize.h == 2)
{
info.fPredictor = cpFloatingPointX2;
}
else if (mosaicInfo.fCFAPatternSize.h == 4)
{
info.fPredictor = cpFloatingPointX4;
}
}
}
if (isCompressed32BitInteger)
{
info.fPredictor = cpHorizontalDifference;
if (mosaicInfo.IsColorFilterArray ())
{
if (mosaicInfo.fCFAPatternSize.h == 2)
{
info.fPredictor = cpHorizontalDifferenceX2;
}
else if (mosaicInfo.fCFAPatternSize.h == 4)
{
info.fPredictor = cpHorizontalDifferenceX4;
}
}
}
uint32 rawPixelType = rawImage.PixelType ();
if (rawPixelType == ttShort)
{
// See if we are using a linearization table with <= 256 entries, in which
// case the useful data will all fit within 8-bits.
const dng_linearization_info *rangeInfo = negative.GetLinearizationInfo ();
if (rangeInfo)
{
if (rangeInfo->fLinearizationTable.Get ())
{
uint32 entries = rangeInfo->fLinearizationTable->LogicalSize () >> 1;
if (entries <= 256)
{
rawPixelType = ttByte;
}
}
}
}
switch (rawPixelType)
{
case ttByte:
{
info.fBitsPerSample [0] = 8;
break;
}
case ttShort:
{
info.fBitsPerSample [0] = 16;
break;
}
case ttLong:
{
info.fBitsPerSample [0] = 32;
break;
}
case ttFloat:
{
if (negative.RawFloatBitDepth () == 16)
{
info.fBitsPerSample [0] = 16;
}
else if (negative.RawFloatBitDepth () == 24)
{
info.fBitsPerSample [0] = 24;
}
else
{
info.fBitsPerSample [0] = 32;
}
for (j = 0; j < info.fSamplesPerPixel; j++)
{
info.fSampleFormat [j] = sfFloatingPoint;
}
break;
}
default:
{
ThrowProgramError ();
}
}
// For lossless JPEG compression, we often lie about the
// actual channel count to get the predictors to work across
// same color mosaic pixels.
uint32 fakeChannels = 1;
if (info.fCompression == ccJPEG)
{
if (mosaicInfo.IsColorFilterArray ())
{
if (mosaicInfo.fCFAPatternSize.h == 4)
{
fakeChannels = 4;
}
else if (mosaicInfo.fCFAPatternSize.h == 2)
{
fakeChannels = 2;
}
// However, lossless JEPG is limited to four channels,
// so compromise might be required.
while (fakeChannels * info.fSamplesPerPixel > 4 &&
fakeChannels > 1)
{
fakeChannels >>= 1;
}
}
}
// Figure out tile sizes.
if (rawJPEGImage)
{
DNG_ASSERT (rawPixelType == ttByte,
"Unexpected jpeg pixel type");
DNG_ASSERT (info.fImageWidth == (uint32) rawJPEGImage->fImageSize.h &&
info.fImageLength == (uint32) rawJPEGImage->fImageSize.v,
"Unexpected jpeg image size");
info.fTileWidth = rawJPEGImage->fTileSize.h;
info.fTileLength = rawJPEGImage->fTileSize.v;
info.fUsesStrips = rawJPEGImage->fUsesStrips;
info.fUsesTiles = !info.fUsesStrips;
}
else if (info.fCompression == ccJPEG)
{
info.FindTileSize (128 * 1024);
}
else if (info.fCompression == ccDeflate)
{
info.FindTileSize (512 * 1024);
}
else if (info.fCompression == ccLossyJPEG)
{
ThrowProgramError ("No JPEG compressed image");
}
// Don't use tiles for uncompressed images.
else
{
info.SetSingleStrip ();
}
#ifdef qTestRowInterleave
info.fRowInterleaveFactor = qTestRowInterleave;
#endif
#if defined(qTestSubTileBlockRows) && defined(qTestSubTileBlockCols)
info.fSubTileBlockRows = qTestSubTileBlockRows;
info.fSubTileBlockCols = qTestSubTileBlockCols;
if (fakeChannels == 2)
fakeChannels = 4;
#endif
// Basic information.
dng_basic_tag_set rawBasic (rawIFD, info);
// JPEG tables, if any.
tag_data_ptr tagJPEGTables (tcJPEGTables,
ttUndefined,
0,
NULL);
if (rawJPEGImage && rawJPEGImage->fJPEGTables.Get ())
{
tagJPEGTables.SetData (rawJPEGImage->fJPEGTables->Buffer ());
tagJPEGTables.SetCount (rawJPEGImage->fJPEGTables->LogicalSize ());
rawIFD.Add (&tagJPEGTables);
}
// DefaultScale tag.
dng_urational defaultScaleData [2];
defaultScaleData [0] = negative.DefaultScaleH ();
defaultScaleData [1] = negative.DefaultScaleV ();
tag_urational_ptr tagDefaultScale (tcDefaultScale,
defaultScaleData,
2);
rawIFD.Add (&tagDefaultScale);
// Best quality scale tag.
tag_urational tagBestQualityScale (tcBestQualityScale,
negative.BestQualityScale ());
rawIFD.Add (&tagBestQualityScale);
// DefaultCropOrigin tag.
dng_urational defaultCropOriginData [2];
defaultCropOriginData [0] = negative.DefaultCropOriginH ();
defaultCropOriginData [1] = negative.DefaultCropOriginV ();
tag_urational_ptr tagDefaultCropOrigin (tcDefaultCropOrigin,
defaultCropOriginData,
2);
rawIFD.Add (&tagDefaultCropOrigin);
// DefaultCropSize tag.
dng_urational defaultCropSizeData [2];
defaultCropSizeData [0] = negative.DefaultCropSizeH ();
defaultCropSizeData [1] = negative.DefaultCropSizeV ();
tag_urational_ptr tagDefaultCropSize (tcDefaultCropSize,
defaultCropSizeData,
2);
rawIFD.Add (&tagDefaultCropSize);
// DefaultUserCrop tag.
dng_urational defaultUserCropData [4];
defaultUserCropData [0] = negative.DefaultUserCropT ();
defaultUserCropData [1] = negative.DefaultUserCropL ();
defaultUserCropData [2] = negative.DefaultUserCropB ();
defaultUserCropData [3] = negative.DefaultUserCropR ();
tag_urational_ptr tagDefaultUserCrop (tcDefaultUserCrop,
defaultUserCropData,
4);
rawIFD.Add (&tagDefaultUserCrop);
// Range mapping tag set.
range_tag_set rangeSet (rawIFD, negative);
// Mosaic pattern information.
mosaic_tag_set mosaicSet (rawIFD, mosaicInfo);
// Chroma blur radius.
tag_urational tagChromaBlurRadius (tcChromaBlurRadius,
negative.ChromaBlurRadius ());
if (negative.ChromaBlurRadius ().IsValid ())
{
rawIFD.Add (&tagChromaBlurRadius);
}
// Anti-alias filter strength.
tag_urational tagAntiAliasStrength (tcAntiAliasStrength,
negative.AntiAliasStrength ());
if (negative.AntiAliasStrength ().IsValid ())
{
rawIFD.Add (&tagAntiAliasStrength);
}
// Profile and other color related tags.
AutoPtr<profile_tag_set> profileSet;
AutoPtr<color_tag_set> colorSet;
dng_std_vector<uint32> extraProfileIndex;
if (!negative.IsMonochrome ())
{
const dng_camera_profile &mainProfile (*negative.ComputeCameraProfileToEmbed (constMetadata));
profileSet.Reset (new profile_tag_set (mainIFD,
mainProfile));
colorSet.Reset (new color_tag_set (mainIFD,
negative));
// Build list of profile indices to include in extra profiles tag.
uint32 profileCount = negative.ProfileCount ();
for (uint32 index = 0; index < profileCount; index++)
{
const dng_camera_profile &profile (negative.ProfileByIndex (index));
if (&profile != &mainProfile)
{
if (profile.WasReadFromDNG ())
{
extraProfileIndex.push_back (index);
}
}
}
}
// Extra camera profiles tag.
uint32 extraProfileCount = (uint32) extraProfileIndex.size ();
dng_memory_data extraProfileOffsets (extraProfileCount, sizeof (uint32));
tag_uint32_ptr extraProfileTag (tcExtraCameraProfiles,
extraProfileOffsets.Buffer_uint32 (),
extraProfileCount);
if (extraProfileCount)
{
mainIFD.Add (&extraProfileTag);
}
// Other tags.
tag_uint16 tagOrientation (tcOrientation,
(uint16) negative.ComputeOrientation (constMetadata).GetTIFF ());
mainIFD.Add (&tagOrientation);
tag_srational tagBaselineExposure (tcBaselineExposure,
negative.BaselineExposureR ());
mainIFD.Add (&tagBaselineExposure);
tag_urational tagBaselineNoise (tcBaselineNoise,
negative.BaselineNoiseR ());
mainIFD.Add (&tagBaselineNoise);
tag_urational tagNoiseReductionApplied (tcNoiseReductionApplied,
negative.NoiseReductionApplied ());
if (negative.NoiseReductionApplied ().IsValid ())
{
mainIFD.Add (&tagNoiseReductionApplied);
}
tag_dng_noise_profile tagNoiseProfile (negative.NoiseProfile ());
if (negative.NoiseProfile ().IsValidForNegative (negative))
{
mainIFD.Add (&tagNoiseProfile);
}
tag_urational tagBaselineSharpness (tcBaselineSharpness,
negative.BaselineSharpnessR ());
mainIFD.Add (&tagBaselineSharpness);
tag_string tagUniqueName (tcUniqueCameraModel,
negative.ModelName (),
true);
mainIFD.Add (&tagUniqueName);
tag_string tagLocalName (tcLocalizedCameraModel,
negative.LocalName (),
false);
if (negative.LocalName ().NotEmpty ())
{
mainIFD.Add (&tagLocalName);
}
tag_urational tagShadowScale (tcShadowScale,
negative.ShadowScaleR ());
mainIFD.Add (&tagShadowScale);
tag_uint16 tagColorimetricReference (tcColorimetricReference,
(uint16) negative.ColorimetricReference ());
if (negative.ColorimetricReference () != crSceneReferred)
{
mainIFD.Add (&tagColorimetricReference);
}
bool useNewDigest = (maxBackwardVersion >= dngVersion_1_4_0_0);
if (compression == ccLossyJPEG)
{
negative.FindRawJPEGImageDigest (host);
}
else
{
if (useNewDigest)
{
negative.FindNewRawImageDigest (host);
}
else
{
negative.FindRawImageDigest (host);
}
}
tag_uint8_ptr tagRawImageDigest (useNewDigest ? tcNewRawImageDigest : tcRawImageDigest,
compression == ccLossyJPEG ?
negative.RawJPEGImageDigest ().data :
(useNewDigest ? negative.NewRawImageDigest ().data
: negative.RawImageDigest ().data),
16);
mainIFD.Add (&tagRawImageDigest);
negative.FindRawDataUniqueID (host);
tag_uint8_ptr tagRawDataUniqueID (tcRawDataUniqueID,
negative.RawDataUniqueID ().data,
16);
if (negative.RawDataUniqueID ().IsValid ())
{
mainIFD.Add (&tagRawDataUniqueID);
}
tag_string tagOriginalRawFileName (tcOriginalRawFileName,
negative.OriginalRawFileName (),
false);
if (negative.HasOriginalRawFileName ())
{
mainIFD.Add (&tagOriginalRawFileName);
}
negative.FindOriginalRawFileDigest ();
tag_data_ptr tagOriginalRawFileData (tcOriginalRawFileData,
ttUndefined,
negative.OriginalRawFileDataLength (),
negative.OriginalRawFileData ());
tag_uint8_ptr tagOriginalRawFileDigest (tcOriginalRawFileDigest,
negative.OriginalRawFileDigest ().data,
16);
if (negative.OriginalRawFileData ())
{
mainIFD.Add (&tagOriginalRawFileData);
mainIFD.Add (&tagOriginalRawFileDigest);
}
// XMP metadata.
#if qDNGUseXMP
tag_xmp tagXMP (metadata->GetXMP ());
if (tagXMP.Count ())
{
mainIFD.Add (&tagXMP);
}
#endif
// Exif tags.
exif_tag_set exifSet (mainIFD,
*metadata->GetExif (),
metadata->IsMakerNoteSafe (),
metadata->MakerNoteData (),
metadata->MakerNoteLength (),
true);
// Private data.
tag_uint8_ptr tagPrivateData (tcDNGPrivateData,
negative.PrivateData (),
negative.PrivateLength ());
if (negative.PrivateLength ())
{
mainIFD.Add (&tagPrivateData);
}
// Proxy size tags.
uint32 originalDefaultFinalSizeData [2];
originalDefaultFinalSizeData [0] = negative.OriginalDefaultFinalSize ().h;
originalDefaultFinalSizeData [1] = negative.OriginalDefaultFinalSize ().v;
tag_uint32_ptr tagOriginalDefaultFinalSize (tcOriginalDefaultFinalSize,
originalDefaultFinalSizeData,
2);
if (saveOriginalDefaultFinalSize)
{
mainIFD.Add (&tagOriginalDefaultFinalSize);
}
uint32 originalBestQualityFinalSizeData [2];
originalBestQualityFinalSizeData [0] = negative.OriginalBestQualityFinalSize ().h;
originalBestQualityFinalSizeData [1] = negative.OriginalBestQualityFinalSize ().v;
tag_uint32_ptr tagOriginalBestQualityFinalSize (tcOriginalBestQualityFinalSize,
originalBestQualityFinalSizeData,
2);
if (saveOriginalBestQualityFinalSize)
{
mainIFD.Add (&tagOriginalBestQualityFinalSize);
}
dng_urational originalDefaultCropSizeData [2];
originalDefaultCropSizeData [0] = negative.OriginalDefaultCropSizeH ();
originalDefaultCropSizeData [1] = negative.OriginalDefaultCropSizeV ();
tag_urational_ptr tagOriginalDefaultCropSize (tcOriginalDefaultCropSize,
originalDefaultCropSizeData,
2);
if (saveOriginalDefaultCropSize)
{
mainIFD.Add (&tagOriginalDefaultCropSize);
}
// Opcode list 1.
AutoPtr<dng_memory_block> opcodeList1Data (negative.OpcodeList1 ().Spool (host));
tag_data_ptr tagOpcodeList1 (tcOpcodeList1,
ttUndefined,
opcodeList1Data.Get () ? opcodeList1Data->LogicalSize () : 0,
opcodeList1Data.Get () ? opcodeList1Data->Buffer () : NULL);
if (opcodeList1Data.Get ())
{
rawIFD.Add (&tagOpcodeList1);
}
// Opcode list 2.
AutoPtr<dng_memory_block> opcodeList2Data (negative.OpcodeList2 ().Spool (host));
tag_data_ptr tagOpcodeList2 (tcOpcodeList2,
ttUndefined,
opcodeList2Data.Get () ? opcodeList2Data->LogicalSize () : 0,
opcodeList2Data.Get () ? opcodeList2Data->Buffer () : NULL);
if (opcodeList2Data.Get ())
{
rawIFD.Add (&tagOpcodeList2);
}
// Opcode list 3.
AutoPtr<dng_memory_block> opcodeList3Data (negative.OpcodeList3 ().Spool (host));
tag_data_ptr tagOpcodeList3 (tcOpcodeList3,
ttUndefined,
opcodeList3Data.Get () ? opcodeList3Data->LogicalSize () : 0,
opcodeList3Data.Get () ? opcodeList3Data->Buffer () : NULL);
if (opcodeList3Data.Get ())
{
rawIFD.Add (&tagOpcodeList3);
}
// Transparency mask, if any.
AutoPtr<dng_ifd> maskInfo;
AutoPtr<dng_tiff_directory> maskIFD;
AutoPtr<dng_basic_tag_set> maskBasic;
if (hasTransparencyMask)
{
// Create mask IFD.
maskInfo.Reset (new dng_ifd);
maskInfo->fNewSubFileType = sfTransparencyMask;
maskInfo->fImageWidth = negative.RawTransparencyMask ()->Bounds ().W ();
maskInfo->fImageLength = negative.RawTransparencyMask ()->Bounds ().H ();
maskInfo->fSamplesPerPixel = 1;
maskInfo->fBitsPerSample [0] = negative.RawTransparencyMaskBitDepth ();
maskInfo->fPhotometricInterpretation = piTransparencyMask;
maskInfo->fCompression = uncompressed ? ccUncompressed : ccDeflate;
maskInfo->fPredictor = uncompressed ? cpNullPredictor : cpHorizontalDifference;
if (negative.RawTransparencyMask ()->PixelType () == ttFloat)
{
maskInfo->fSampleFormat [0] = sfFloatingPoint;
if (maskInfo->fCompression == ccDeflate)
{
maskInfo->fPredictor = cpFloatingPoint;
}
}
if (maskInfo->fCompression == ccDeflate)
{
maskInfo->FindTileSize (512 * 1024);
}
else
{
maskInfo->SetSingleStrip ();
}
// Create mask tiff directory.
maskIFD.Reset (new dng_tiff_directory);
// Add mask basic tag set.
maskBasic.Reset (new dng_basic_tag_set (*maskIFD, *maskInfo));
}
// Add other subfiles.
uint32 subFileCount = thumbnail ? 1 : 0;
if (hasTransparencyMask)
{
subFileCount++;
}
// Add previews.
uint32 previewCount = previewList ? previewList->Count () : 0;
AutoPtr<dng_tiff_directory> previewIFD [kMaxDNGPreviews];
AutoPtr<dng_basic_tag_set> previewBasic [kMaxDNGPreviews];
for (j = 0; j < previewCount; j++)
{
if (thumbnail != &previewList->Preview (j))
{
previewIFD [j] . Reset (new dng_tiff_directory);
previewBasic [j] . Reset (previewList->Preview (j).AddTagSet (*previewIFD [j]));
subFileCount++;
}
}
// And a link to the raw and JPEG image IFDs.
uint32 subFileData [kMaxDNGPreviews + 2];
tag_uint32_ptr tagSubFile (tcSubIFDs,
subFileData,
subFileCount);
if (subFileCount)
{
mainIFD.Add (&tagSubFile);
}
// Skip past the header and IFDs for now.
uint32 currentOffset = 8;
currentOffset += mainIFD.Size ();
uint32 subFileIndex = 0;
if (thumbnail)
{
subFileData [subFileIndex++] = currentOffset;
currentOffset += rawIFD.Size ();
}
if (hasTransparencyMask)
{
subFileData [subFileIndex++] = currentOffset;
currentOffset += maskIFD->Size ();
}
for (j = 0; j < previewCount; j++)
{
if (thumbnail != &previewList->Preview (j))
{
subFileData [subFileIndex++] = currentOffset;
currentOffset += previewIFD [j]->Size ();
}
}
exifSet.Locate (currentOffset);
currentOffset += exifSet.Size ();
stream.SetWritePosition (currentOffset);
// Write the extra profiles.
if (extraProfileCount)
{
for (j = 0; j < extraProfileCount; j++)
{
extraProfileOffsets.Buffer_uint32 () [j] = (uint32) stream.Position ();
uint32 index = extraProfileIndex [j];
const dng_camera_profile &profile (negative.ProfileByIndex (index));
tiff_dng_extended_color_profile extraWriter (profile);
extraWriter.Put (stream, false);
}
}
// Write the thumbnail data.
if (thumbnail)
{
thumbnail->WriteData (host,
*this,
*thmBasic,
stream);
}
// Write the preview data.
for (j = 0; j < previewCount; j++)
{
if (thumbnail != &previewList->Preview (j))
{
previewList->Preview (j).WriteData (host,
*this,
*previewBasic [j],
stream);
}
}
// Write the raw data.
if (rawJPEGImage)
{
uint32 tileCount = info.TilesAcross () *
info.TilesDown ();
for (uint32 tileIndex = 0; tileIndex < tileCount; tileIndex++)
{
// Remember this offset.
uint32 tileOffset = (uint32) stream.Position ();
rawBasic.SetTileOffset (tileIndex, tileOffset);
// Write JPEG data.
stream.Put (rawJPEGImage->fJPEGData [tileIndex]->Buffer (),
rawJPEGImage->fJPEGData [tileIndex]->LogicalSize ());
// Update tile count.
uint32 tileByteCount = (uint32) stream.Position () - tileOffset;
rawBasic.SetTileByteCount (tileIndex, tileByteCount);
// Keep the tiles on even byte offsets.
if (tileByteCount & 1)
{
stream.Put_uint8 (0);
}
}
}
else
{
#if qDNGValidate
dng_timer timer ("Write raw image time");
#endif
WriteImage (host,
info,
rawBasic,
stream,
rawImage,
fakeChannels);
}
// Write transparency mask image.
if (hasTransparencyMask)
{
#if qDNGValidate
dng_timer timer ("Write transparency mask time");
#endif
WriteImage (host,
*maskInfo,
*maskBasic,
stream,
*negative.RawTransparencyMask ());
}
// Trim the file to this length.
stream.SetLength (stream.Position ());
// DNG has a 4G size limit.
if (stream.Length () > 0x0FFFFFFFFL)
{
ThrowImageTooBigDNG ();
}
// Write TIFF Header.
stream.SetWritePosition (0);
stream.Put_uint16 (stream.BigEndian () ? byteOrderMM : byteOrderII);
stream.Put_uint16 (42);
stream.Put_uint32 (8);
// Write the IFDs.
mainIFD.Put (stream);
if (thumbnail)
{
rawIFD.Put (stream);
}
if (hasTransparencyMask)
{
maskIFD->Put (stream);
}
for (j = 0; j < previewCount; j++)
{
if (thumbnail != &previewList->Preview (j))
{
previewIFD [j]->Put (stream);
}
}
exifSet.Put (stream);
stream.Flush ();
}
/*****************************************************************************/