/src/dng_sdk/source/dng_image_writer.cpp

Source (jump to first uncovered line)
/*****************************************************************************/
// 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 ();
  
  }
                 
/*****************************************************************************/

Coverage Report

Created: 2025-01-23 06:29