| /*****************************************************************************/ |
| // 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 (); |
| |
| } |
| |
| /*****************************************************************************/ |
