/src/skia/third_party/externals/dng_sdk/source/dng_negative.h

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_negative.h#4 $ */ 
/* $DateTime: 2012/08/02 06:09:06 $ */
/* $Change: 841096 $ */
/* $Author: erichan $ */

/** \file
 * Functions and classes for working with a digital negative (image data and
 * corresponding metadata).
 */

/*****************************************************************************/

#ifndef __dng_negative__
#define __dng_negative__

/*****************************************************************************/

#include "dng_1d_function.h"
#include "dng_auto_ptr.h"
#include "dng_classes.h"
#include "dng_fingerprint.h"
#include "dng_image.h"
#include "dng_linearization_info.h"
#include "dng_matrix.h"
#include "dng_memory.h"
#include "dng_mosaic_info.h"
#include "dng_opcode_list.h"
#include "dng_orientation.h"
#include "dng_rational.h"
#include "dng_sdk_limits.h"
#include "dng_string.h"
#include "dng_tag_types.h"
#include "dng_tag_values.h"
#include "dng_types.h"
#include "dng_utils.h"
#include "dng_xy_coord.h"

#include <vector>

/*****************************************************************************/

// To prevent using the internal metadata when we meant to use override
// metadata, the following definitions allow us to only allow access to
// the internal metadata on non-const negatives. This allows the old API
// to keep working essentially unchanged provided one does not use const
// negatives, but will prevent access to the embedded data on const
// negatives.

#if 1

#define qMetadataOnConst 0
#define METACONST

#else

#define qMetadataOnConst 1
#define METACONST const

#endif

/*****************************************************************************/

/// \brief Noise model for photon and sensor read noise, assuming that they are
/// independent random variables and spatially invariant.
///
/// The noise model is N (x) = sqrt (scale*x + offset), where x represents a linear
/// signal value in the range [0,1], and N (x) is the standard deviation (i.e.,
/// noise). The parameters scale and offset are both sensor-dependent and
/// ISO-dependent. scale must be positive, and offset must be non-negative.

class dng_noise_function: public dng_1d_function
  {
    
  protected:

    real64 fScale;
    real64 fOffset;

  public:

    /// Create empty and invalid noise function.

    dng_noise_function ()

      : fScale  (0.0)
      , fOffset (0.0)

      {

      }

    /// Create noise function with the specified scale and offset.

    dng_noise_function (real64 scale,
              real64 offset)

      : fScale  (scale)
      , fOffset (offset)

      {

      }

    /// Compute noise (standard deviation) at the specified average signal level
    /// x.

    virtual real64 Evaluate (real64 x) const
      {
      return sqrt (fScale * x + fOffset);
      }

    /// The scale (slope, gain) of the noise function.

    real64 Scale () const 
      { 
      return fScale; 
      }

    /// The offset (square of the noise floor) of the noise function.

    real64 Offset () const 
      { 
      return fOffset; 
      }

    /// Set the scale (slope, gain) of the noise function.

    void SetScale (real64 scale)
      {
      fScale = scale;
      }

    /// Set the offset (square of the noise floor) of the noise function.

    void SetOffset (real64 offset)
      {
      fOffset = offset;
      }

    /// Is the noise function valid?

    bool IsValid () const
      {
      return (fScale > 0.0 && fOffset >= 0.0);
      }
    
  };

/*****************************************************************************/

/// \brief Noise profile for a negative.
///
/// For mosaiced negatives, the noise profile describes the approximate noise
/// characteristics of a mosaic negative after linearization, but prior to
/// demosaicing. For demosaiced negatives (i.e., linear DNGs), the noise profile
/// describes the approximate noise characteristics of the image data immediately
/// following the demosaic step, prior to the processing of opcode list 3.
///
/// A noise profile may contain 1 or N noise functions, where N is the number of
/// color planes for the negative. Otherwise the noise profile is considered to be
/// invalid for that negative. If the noise profile contains 1 noise function, then
/// it is assumed that this single noise function applies to all color planes of the
/// negative. Otherwise, the N noise functions map to the N planes of the negative in
/// order specified in the CFAPlaneColor tag.

class dng_noise_profile
  {
    
  protected:

    dng_std_vector<dng_noise_function> fNoiseFunctions;

  public:

    /// Create empty (invalid) noise profile.

    dng_noise_profile ();

    /// Create noise profile with the specified noise functions (1 per plane).

    explicit dng_noise_profile (const dng_std_vector<dng_noise_function> &functions);

    /// Is the noise profile valid?

    bool IsValid () const;

    /// Is the noise profile valid for the specified negative?

    bool IsValidForNegative (const dng_negative &negative) const;

    /// The noise function for the specified plane.

    const dng_noise_function & NoiseFunction (uint32 plane) const;

    /// The number of noise functions in this profile.

    uint32 NumFunctions () const;
    
  };

/*****************************************************************************/

/// \brief Main class for holding metadata.

class dng_metadata
  {
  
  private:
    
    // Base orientation of both the thumbnail and raw data. This is
    // generally based on the EXIF values.
    
    bool fHasBaseOrientation;
  
    dng_orientation fBaseOrientation;
    
    // Is the maker note safe to copy from file to file? Defaults to false
    // because many maker notes are not safe.
    
    bool fIsMakerNoteSafe;
    
    // MakerNote binary data block.
    
    AutoPtr<dng_memory_block> fMakerNote;
    
    // EXIF data.
    
    AutoPtr<dng_exif> fExif;
    
    // A copy of the EXIF data before is was synchronized with other metadata sources.
    
    AutoPtr<dng_exif> fOriginalExif;
    
    // IPTC binary data block and offset in original file.
    
    AutoPtr<dng_memory_block> fIPTCBlock;
    
    uint64 fIPTCOffset;
    
    // XMP data.
    
    #if qDNGUseXMP
    
    AutoPtr<dng_xmp> fXMP;
    
    #endif
    
    // If there a valid embedded XMP block, has is its digest?  NULL if no valid
    // embedded XMP.
    
    dng_fingerprint fEmbeddedXMPDigest;
    
    // Is the XMP data from a sidecar file?
    
    bool fXMPinSidecar;
    
    // If the XMP data is from a sidecar file, is the sidecar file newer
    // than the raw file?
    
    bool fXMPisNewer;
    
    // Source file mimi-type, if known.
    
    dng_string fSourceMIMI;
    
  public:

    dng_metadata (dng_host &host);
    
    dng_metadata (const dng_metadata &rhs,
            dng_memory_allocator &allocator);
    
    virtual ~dng_metadata ();

    /// Copy this metadata.
    
    virtual dng_metadata * Clone (dng_memory_allocator &allocator) const;
    
    /// Setter for BaseOrientation.
      
    void SetBaseOrientation (const dng_orientation &orientation);
    
    /// Has BaseOrientation been set?

    bool HasBaseOrientation () const
      {
      return fHasBaseOrientation;
      }
    
    /// Getter for BaseOrientation.
      
    const dng_orientation & BaseOrientation () const
      {
      return fBaseOrientation;
      }
      
    /// Logically rotates the image by changing the orientation values.
    /// This will also update the XMP data.
    
    void ApplyOrientation (const dng_orientation &orientation);

    // API for IPTC metadata:
      
    void SetIPTC (AutoPtr<dng_memory_block> &block,
            uint64 offset);
    
    void SetIPTC (AutoPtr<dng_memory_block> &block);
    
    void ClearIPTC ();
    
    const void * IPTCData () const;
    
    uint32 IPTCLength () const;
    
    uint64 IPTCOffset () const;
    
    dng_fingerprint IPTCDigest (bool includePadding = true) const;
    
    void RebuildIPTC (dng_memory_allocator &allocator,
              bool padForTIFF);
    
    // API for MakerNote data:
    
    void SetMakerNoteSafety (bool safe)
      {
      fIsMakerNoteSafe = safe;
      }
    
    bool IsMakerNoteSafe () const
      {
      return fIsMakerNoteSafe;
      }
    
    void SetMakerNote (AutoPtr<dng_memory_block> &block)
      {
      fMakerNote.Reset (block.Release ());
      }
    
    void ClearMakerNote ()
      {
      fIsMakerNoteSafe = false;
      fMakerNote.Reset ();
      }
    
    const void * MakerNoteData () const
      {
      return fMakerNote.Get () ? fMakerNote->Buffer ()
                   : NULL;
      }
    
    uint32 MakerNoteLength () const
      {
      return fMakerNote.Get () ? fMakerNote->LogicalSize ()
                   : 0;
      }
    
    // API for EXIF metadata:
    
    dng_exif * GetExif ()
      {
      return fExif.Get ();
      }
      
    const dng_exif * GetExif () const
      {
      return fExif.Get ();
      }
      
    template< class E >
    E & Exif ();
      
    template< class E >
    const E & Exif () const;
          
    void ResetExif (dng_exif * newExif);
      
    dng_memory_block * BuildExifBlock (dng_memory_allocator &allocator,
                       const dng_resolution *resolution = NULL,
                       bool includeIPTC = false,
                       const dng_jpeg_preview *thumbnail = NULL) const;
                           
    // API for original EXIF metadata.
    
    dng_exif * GetOriginalExif ()
      {
      return fOriginalExif.Get ();
      }
      
    const dng_exif * GetOriginalExif () const
      {
      return fOriginalExif.Get ();
      }
      
    // API for XMP metadata:
    
    #if qDNGUseXMP
    
    bool SetXMP (dng_host &host,
           const void *buffer,
           uint32 count,
           bool xmpInSidecar = false,
           bool xmpIsNewer = false);
           
    void SetEmbeddedXMP (dng_host &host,
               const void *buffer,
               uint32 count);
           
    dng_xmp * GetXMP ()
      {
      return fXMP.Get ();
      }
      
    const dng_xmp * GetXMP () const
      {
      return fXMP.Get ();
      }

    template< class X >
    X & XMP ();

    template< class X >
    const X & XMP () const;

    bool XMPinSidecar () const
      {
      return fXMPinSidecar;
      }
      
    const dng_fingerprint & EmbeddedXMPDigest () const
      {
      return fEmbeddedXMPDigest;
      }
            
    bool HaveValidEmbeddedXMP () const
      {
      return fEmbeddedXMPDigest.IsValid ();
      }
    
    void ResetXMP (dng_xmp * newXMP);
  
    void ResetXMPSidecarNewer (dng_xmp * newXMP, bool inSidecar, bool isNewer );
      
    #endif
    
    // Synchronize metadata sources.
    
    void SynchronizeMetadata ();
    
    // Routines to update the date/time field in the EXIF and XMP
    // metadata.
    
    void UpdateDateTime (const dng_date_time_info &dt);
               
    void UpdateDateTimeToNow ();
    
    void UpdateMetadataDateTimeToNow ();
    
    // Routines to set and get the source file MIMI type.
    
    void SetSourceMIMI (const char *s)
      {
      fSourceMIMI.Set (s);
      }
      
    const dng_string & SourceMIMI () const
      {
      return fSourceMIMI;
      }
      
  };

/*****************************************************************************/

template< class E >
E & dng_metadata::Exif ()
  {
  dng_exif * exif = GetExif ();
  if (!exif) ThrowProgramError ("EXIF object is NULL.");
  return dynamic_cast< E & > (*exif);
  }

/*****************************************************************************/

template< class E >
const E & dng_metadata::Exif () const
  {
  const dng_exif * exif = GetExif ();
  if (!exif) ThrowProgramError ("EXIF object is NULL.");
  return dynamic_cast< const E & > (*exif);
  }

/*****************************************************************************/

#if qDNGUseXMP

template< class X >
X & dng_metadata::XMP ()
  {
  dng_xmp * xmp = GetXMP ();
  if (!xmp) ThrowProgramError ("XMP object is NULL.");
  return dynamic_cast< X & > (*xmp);
  }

/*****************************************************************************/

template< class X >
const X & dng_metadata::XMP () const
  {
  const dng_xmp * xmp = GetXMP ();
  if (!xmp) ThrowProgramError ("XMP object is NULL.");
  return dynamic_cast< const X & > (*xmp);
  }

#endif

/*****************************************************************************/

/// \brief Main class for holding DNG image data and associated metadata.

class dng_negative
  {
  
  public:
  
    enum RawImageStageEnum
      {
      rawImageStagePreOpcode1,
      rawImageStagePostOpcode1,
      rawImageStagePostOpcode2,
      rawImageStagePreOpcode3,
      rawImageStagePostOpcode3,
      rawImageStageNone
      };
      
  protected:
  
    // The negative stores an associated allocator. It does not do
    // anything to keep it alive or to release it when the object destructs.
    // Hence, clients will need to make sure that the allocator's lifespan
    // encompasses that of the dng_factory object which is generally
    // directly bound to the dng_negative object.
  
    dng_memory_allocator &fAllocator;
      
    // Non-localized ASCII model name.
    
    dng_string fModelName;
    
    // Localized UTF-8 model name.
    
    dng_string fLocalName;
    
    // The area of raw image that should be included in the final converted
    // image. This stems from extra pixels around the edges of the sensor
    // including both the black mask and some additional padding.
    
    // The default crop can be smaller than the "active" area which includes
    // the padding but not the black masked pixels.
    
    dng_urational fDefaultCropSizeH;
    dng_urational fDefaultCropSizeV;
    
    dng_urational fDefaultCropOriginH;
    dng_urational fDefaultCropOriginV;

    // Default user crop, in relative coordinates.

    dng_urational fDefaultUserCropT;
    dng_urational fDefaultUserCropL;
    dng_urational fDefaultUserCropB;
    dng_urational fDefaultUserCropR;
    
    // Default scale factors. Generally, 1.0 for square pixel cameras. They
    // can compensate for non-square pixels. The choice of exact values will
    // generally depend on what the camera does. These are particularly
    // interesting for the Nikon D1X and the Fuji diamond mosaic.
    
    dng_urational fDefaultScaleH;
    dng_urational fDefaultScaleV;
    
    // Best quality scale factor. Used for the Nikon D1X and Fuji cameras
    // to force everything to be a scale up rather than scale down. So,
    // generally this is 1.0 / min (fDefaultScaleH, fDefaultScaleV) but
    // this isn't used if the scale factors are only slightly different
    // from 1.0.
    
    dng_urational fBestQualityScale;
    
    // Proxy image support.  Remember certain sizes for the original image
    // this proxy was derived from.
        
    dng_point fOriginalDefaultFinalSize;
    dng_point fOriginalBestQualityFinalSize;
    
    dng_urational fOriginalDefaultCropSizeH;
    dng_urational fOriginalDefaultCropSizeV;
    
    // Scale factors used in demosaic algorithm (calculated).
    // Maps raw image coordinates to full image coordinates -- i.e.,
    // original image coordinates on raw sensor data to coordinates
    // in fStage3Image which is the output of the interpolation step.
    // So, if we downsample when interpolating, these numbers get
    // smaller.
    
    real64 fRawToFullScaleH;
    real64 fRawToFullScaleV;
    
    // Relative amount of noise at ISO 100. This is measured per camera model
    // based on looking at flat areas of color.
    
    dng_urational fBaselineNoise;
    
    // How much noise reduction has already been applied (0.0 to 1.0) to the
    // the raw image data?  0.0 = none, 1.0 = "ideal" amount--i.e. don't apply any
    // more by default.  0/0 for unknown.
    
    dng_urational fNoiseReductionApplied;

    // Amount of noise for this negative (see dng_noise_profile for details).

    dng_noise_profile fNoiseProfile;
    
    // Zero point for the exposure compensation slider. This reflects how
    // the manufacturer sets up the camera and its conversions.
    
    dng_srational fBaselineExposure;
    
    // Relative amount of sharpening required. This is chosen per camera
    // model based on how strong the anti-alias filter is on the camera
    // and the quality of the lenses. This scales the sharpness slider
    // value.
  
    dng_urational fBaselineSharpness;
    
    // Chroma blur radius (or 0/0 for auto). Set to 0/1 to disable
    // chroma blurring.
    
    dng_urational fChromaBlurRadius;
    
    // Anti-alias filter strength (0.0 to 1.0).  Used as a hint
    // to the demosaic algorithms.
    
    dng_urational fAntiAliasStrength;
    
    // Linear response limit. The point at which the sensor goes
    // non-linear and color information becomes unreliable. Used in
    // the highlight-recovery logic.
    
    dng_urational fLinearResponseLimit;
    
    // Scale factor for shadows slider. The Fuji HDR cameras, for example,
    // need a more sensitive shadow slider.
    
    dng_urational fShadowScale;
    
    // Colormetric reference.
    
    uint32 fColorimetricReference;
    
    // Number of color channels for this image (e.g. 1, 3, or 4).
    
    uint32 fColorChannels;
    
    // Amount by which each channel has already been scaled. Some cameras
    // have analog amplifiers on the color channels and these can result
    // in different scalings per channel. This provides some level of
    // analog white balancing. The Nikon D1 also did digital scaling but
    // this caused problems with highlight recovery. 
    
    dng_vector fAnalogBalance;
    
    // The "As Shot" neutral color coordinates in native camera space.
    // This overrides fCameraWhiteXY if both are specified. This
    // specifies the values per channel that would result in a neutral
    // color for the "As Shot" case. This is generally supplied by
    // the camera.
    
    dng_vector fCameraNeutral;
    
    // The "As Shot" white balance xy coordinates. Sometimes this is
    // supplied by the camera. Sometimes the camera just supplies a name
    // for the white balance.
    
    dng_xy_coord fCameraWhiteXY;
    
    // Individual camera calibrations.
    
    // Camera data --> camera calibration --> "inverse" of color matrix
    
    // This will be a 4x4 matrix for a 4-color camera. The defaults are
    // almost always the identity matrix and for the cases where they
    // aren't, they are diagonal matrices.
    
    dng_matrix fCameraCalibration1;
    dng_matrix fCameraCalibration2;
    
    // Signature which allows a profile to announce that it is compatible
    // with these calibration matrices.

    dng_string fCameraCalibrationSignature;
    
    // List of camera profiles.
    
    dng_std_vector<dng_camera_profile *> fCameraProfile;
    
    // "As shot" camera profile name.
    
    dng_string fAsShotProfileName;
    
    // Raw image data digests. These are MD5 fingerprints of the raw image data
    // in the file, computed using a specific algorithms.  They can be used
    // verify the raw data has not been corrupted.  The new version is faster
    // to compute on MP machines, and is used starting with DNG version 1.4. 
    
    mutable dng_fingerprint fRawImageDigest;
    
    mutable dng_fingerprint fNewRawImageDigest;

    // Raw data unique ID.  This is an unique identifer for the actual
    // raw image data in the file.  It can be used to index into caches
    // for this data.
    
    mutable dng_fingerprint fRawDataUniqueID;
    
    // Original raw file name.  Just the file name, not the full path.
    
    dng_string fOriginalRawFileName;
    
    // Is the original raw file data availaible?
    
    bool fHasOriginalRawFileData;
    
    // The compressed original raw file data.
    
    AutoPtr<dng_memory_block> fOriginalRawFileData;
    
    // MD5 digest of original raw file data block.
    
    mutable dng_fingerprint fOriginalRawFileDigest;
    
    // DNG private data block.
    
    AutoPtr<dng_memory_block> fDNGPrivateData;
    
    // Metadata information (XMP, IPTC, EXIF, orientation)
  
    dng_metadata fMetadata;
    
    // Information required to linearize and range map the raw data.
    
    AutoPtr<dng_linearization_info> fLinearizationInfo;
    
    // Information required to demoasic the raw data.
    
    AutoPtr<dng_mosaic_info> fMosaicInfo;
    
    // Opcode list 1. (Applied to stored data)
    
    dng_opcode_list fOpcodeList1;
    
    // Opcode list 2. (Applied to range mapped data)
    
    dng_opcode_list fOpcodeList2;
    
    // Opcode list 3. (Post demosaic)
    
    dng_opcode_list fOpcodeList3;
    
    // Stage 1 image, which is image data stored in a DNG file.
    
    AutoPtr<dng_image> fStage1Image;
    
    // Stage 2 image, which is the stage 1 image after it has been
    // linearized and range mapped.
    
    AutoPtr<dng_image> fStage2Image;
    
    // Stage 3 image, which is the stage 2 image after it has been
    // demosaiced.
    
    AutoPtr<dng_image> fStage3Image;
    
    // Additiona gain applied when building the stage 3 image. 
    
    real64 fStage3Gain;

    // Were any approximations (e.g. downsampling, etc.) applied
    // file reading this image?
    
    bool fIsPreview;
    
    // Does the file appear to be damaged?
    
    bool fIsDamaged;
    
    // At what processing stage did we grab a copy of raw image data?
    
    RawImageStageEnum fRawImageStage;
    
    // The raw image data that we grabbed, if any.
    
    AutoPtr<dng_image> fRawImage;
    
    // The floating point bit depth of the raw file, if any.
    
    uint32 fRawFloatBitDepth;
    
    // The raw image JPEG data that we grabbed, if any.
    
    AutoPtr<dng_jpeg_image> fRawJPEGImage;
    
    // Keep a separate digest for the compressed JPEG data, if any.
    
    mutable dng_fingerprint fRawJPEGImageDigest;
    
    // Transparency mask image, if any.
    
    AutoPtr<dng_image> fTransparencyMask;
    
    // Grabbed transparency mask, if we are not saving the current mask.
    
    AutoPtr<dng_image> fRawTransparencyMask;
    
    // The bit depth for the raw transparancy mask, if known.
    
    uint32 fRawTransparencyMaskBitDepth;
    
    // We sometimes need to keep of copy of the stage3 image before
    // flattening the transparency.
    
    AutoPtr<dng_image> fUnflattenedStage3Image;
    
  public:
  
    virtual ~dng_negative ();
    
    static dng_negative * Make (dng_host &host);
    
    /// Provide access to the memory allocator used for this object.
    
    dng_memory_allocator & Allocator () const
      {
      return fAllocator;
      }
      
    /// Getter for ModelName.
    
    void SetModelName (const char *name)
      {
      fModelName.Set_ASCII (name);
      }
    
    /// Setter for ModelName.

    const dng_string & ModelName () const
      {
      return fModelName;
      }

    /// Setter for LocalName.
      
    void SetLocalName (const char *name)
      {
      fLocalName.Set (name);
      }
  
    /// Getter for LocalName.

    const dng_string & LocalName () const
      {
      return fLocalName;
      }
      
    /// Getter for metadata
      
    dng_metadata &Metadata ()
      {
      return fMetadata;
      }
      
    #if qMetadataOnConst
      
    const dng_metadata &Metadata () const
      {
      return fMetadata;
      }
      
    #endif // qMetadataOnConst

    /// Make a copy of the internal metadata generally as a basis for further
    /// changes.

    dng_metadata * CloneInternalMetadata () const;
    
  protected:

    /// An accessor for the internal metadata that works even when we
    /// have general access turned off. This is needed to provide
    /// access to EXIF ISO information.

    const dng_metadata &InternalMetadata () const
      {
      return fMetadata;
      }
      
  public:
        
    /// Setter for BaseOrientation.
      
    void SetBaseOrientation (const dng_orientation &orientation)
      {
      Metadata ().SetBaseOrientation (orientation);
      }
    
    /// Has BaseOrientation been set?

    bool HasBaseOrientation () METACONST
      {
      return Metadata ().HasBaseOrientation ();
      }
    
    /// Getter for BaseOrientation.
      
    const dng_orientation & BaseOrientation () METACONST
      {
      return Metadata ().BaseOrientation ();
      }
      
    /// Hook to allow SDK host code to add additional rotations.
      
    virtual dng_orientation ComputeOrientation (const dng_metadata &metadata) const;
    
    /// For non-const negatives, we simply default to using the metadata attached to the negative.
    
    dng_orientation Orientation ()
      {
      return ComputeOrientation (Metadata ());
      }
    
    /// Logically rotates the image by changing the orientation values.
    /// This will also update the XMP data.
    
    void ApplyOrientation (const dng_orientation &orientation)
      {
      Metadata ().ApplyOrientation (orientation);
      }
    
    /// Setter for DefaultCropSize.
    
    void SetDefaultCropSize (const dng_urational &sizeH,
                     const dng_urational &sizeV)
      {
      fDefaultCropSizeH = sizeH;
      fDefaultCropSizeV = sizeV;
      }
              
    /// Setter for DefaultCropSize.
    
    void SetDefaultCropSize (uint32 sizeH,
                     uint32 sizeV)
      {
      SetDefaultCropSize (dng_urational (sizeH, 1),
                    dng_urational (sizeV, 1));
      }
              
    /// Getter for DefaultCropSize horizontal.
    
    const dng_urational & DefaultCropSizeH () const
      {
      return fDefaultCropSizeH;
      }
    
    /// Getter for DefaultCropSize vertical.
    
    const dng_urational & DefaultCropSizeV () const
      {
      return fDefaultCropSizeV;
      }

    /// Setter for DefaultCropOrigin.
    
    void SetDefaultCropOrigin (const dng_urational &originH,
                     const dng_urational &originV)
      {
      fDefaultCropOriginH = originH;
      fDefaultCropOriginV = originV;
      }
    
    /// Setter for DefaultCropOrigin.

    void SetDefaultCropOrigin (uint32 originH,
                     uint32 originV)
      {
      SetDefaultCropOrigin (dng_urational (originH, 1),
                    dng_urational (originV, 1));
      }
      
    /// Set default crop around center of image.

    void SetDefaultCropCentered (const dng_point &rawSize)
      {
      
      uint32 sizeH = Round_uint32 (fDefaultCropSizeH.As_real64 ());
      uint32 sizeV = Round_uint32 (fDefaultCropSizeV.As_real64 ());
      
      SetDefaultCropOrigin ((rawSize.h - sizeH) >> 1,
                  (rawSize.v - sizeV) >> 1);
      
      }
                    
    /// Get default crop origin horizontal value.

    const dng_urational & DefaultCropOriginH () const
      {
      return fDefaultCropOriginH;
      }
    
    /// Get default crop origin vertical value.

    const dng_urational & DefaultCropOriginV () const
      {
      return fDefaultCropOriginV;
      }

    /// Getter for top coordinate of default user crop.

    const dng_urational & DefaultUserCropT () const
      {
      return fDefaultUserCropT;
      }
                
    /// Getter for left coordinate of default user crop.

    const dng_urational & DefaultUserCropL () const
      {
      return fDefaultUserCropL;
      }
                
    /// Getter for bottom coordinate of default user crop.

    const dng_urational & DefaultUserCropB () const
      {
      return fDefaultUserCropB;
      }
                
    /// Getter for right coordinate of default user crop.

    const dng_urational & DefaultUserCropR () const
      {
      return fDefaultUserCropR;
      }

    /// Reset default user crop to default crop area.

    void ResetDefaultUserCrop ()
      {
      fDefaultUserCropT = dng_urational (0, 1);
      fDefaultUserCropL = dng_urational (0, 1);
      fDefaultUserCropB = dng_urational (1, 1);
      fDefaultUserCropR = dng_urational (1, 1);
      }

    /// Setter for all 4 coordinates of default user crop.
                
    void SetDefaultUserCrop (const dng_urational &t,
                 const dng_urational &l,
                 const dng_urational &b,
                 const dng_urational &r)
      {
      fDefaultUserCropT = t;
      fDefaultUserCropL = l;
      fDefaultUserCropB = b;
      fDefaultUserCropR = r;
      }

    /// Setter for top coordinate of default user crop.
                
    void SetDefaultUserCropT (const dng_urational &value)
      {
      fDefaultUserCropT = value;
      }

    /// Setter for left coordinate of default user crop.
                
    void SetDefaultUserCropL (const dng_urational &value)
      {
      fDefaultUserCropL = value;
      }

    /// Setter for bottom coordinate of default user crop.
                
    void SetDefaultUserCropB (const dng_urational &value)
      {
      fDefaultUserCropB = value;
      }

    /// Setter for right coordinate of default user crop.
                
    void SetDefaultUserCropR (const dng_urational &value)
      {
      fDefaultUserCropR = value;
      }

    /// Setter for DefaultScale.
    
    void SetDefaultScale (const dng_urational &scaleH,
                const dng_urational &scaleV)
      {
      fDefaultScaleH = scaleH;
      fDefaultScaleV = scaleV;
      }
                
    /// Get default scale horizontal value.

    const dng_urational & DefaultScaleH () const
      {
      return fDefaultScaleH;
      }
    
    /// Get default scale vertical value.

    const dng_urational & DefaultScaleV () const
      {
      return fDefaultScaleV;
      }
    
    /// Setter for BestQualityScale.
    
    void SetBestQualityScale (const dng_urational &scale)
      {
      fBestQualityScale = scale;
      }
                
    /// Getter for BestQualityScale.
    
    const dng_urational & BestQualityScale () const
      {
      return fBestQualityScale;
      }
      
    /// API for raw to full image scaling factors horizontal.
    
    real64 RawToFullScaleH () const
      {
      return fRawToFullScaleH;
      }
      
    /// API for raw to full image scaling factors vertical.
    
    real64 RawToFullScaleV () const
      {
      return fRawToFullScaleV;
      }
      
    /// Setter for raw to full scales.
    
    void SetRawToFullScale (real64 scaleH,
                  real64 scaleV)
      {
      fRawToFullScaleH = scaleH;
      fRawToFullScaleV = scaleV;
      }
      
    /// Get default scale factor.
    /// When specifing a single scale factor, we use the horizontal
    /// scale factor,  and let the vertical scale factor be calculated
    /// based on the pixel aspect ratio.
    
    real64 DefaultScale () const
      {
      return DefaultScaleH ().As_real64 ();
      }
    
    /// Default cropped image size (at scale == 1.0) width.
    
    real64 SquareWidth () const
      {
      return DefaultCropSizeH ().As_real64 ();
      }
    
    /// Default cropped image size (at scale == 1.0) height.
    
    real64 SquareHeight () const
      {
      return DefaultCropSizeV ().As_real64 () *
           DefaultScaleV    ().As_real64 () /
           DefaultScaleH    ().As_real64 ();
      }
    
    /// Default cropped image aspect ratio.
    
    real64 AspectRatio () const
      {
      return SquareWidth  () /
           SquareHeight ();
      }
      
    /// Pixel aspect ratio of stage 3 image.
    
    real64 PixelAspectRatio () const
      {
      return (DefaultScaleH ().As_real64 () / RawToFullScaleH ()) /
           (DefaultScaleV ().As_real64 () / RawToFullScaleV ());
      }
    
    /// Default cropped image size at given scale factor width.
    
    uint32 FinalWidth (real64 scale) const
      {
      return Round_uint32 (SquareWidth () * scale);
      }
    
    /// Default cropped image size at given scale factor height.
    
    uint32 FinalHeight (real64 scale) const
      {
      return Round_uint32 (SquareHeight () * scale);
      }
    
    /// Default cropped image size at default scale factor width.
    
    uint32 DefaultFinalWidth () const
      {
      return FinalWidth (DefaultScale ());
      }
    
    /// Default cropped image size at default scale factor height.
    
    uint32 DefaultFinalHeight () const
      {
      return FinalHeight (DefaultScale ());
      }
    
    /// Get best quality width.
    /// For a naive conversion, one could use either the default size,
    /// or the best quality size.
    
    uint32 BestQualityFinalWidth () const
      {
      return FinalWidth (DefaultScale () * BestQualityScale ().As_real64 ());
      }
    
    /// Get best quality height.
    /// For a naive conversion, one could use either the default size,
    /// or the best quality size.
    
    uint32 BestQualityFinalHeight () const
      {
      return FinalHeight (DefaultScale () * BestQualityScale ().As_real64 ());
      }
      
    /// Default size of original (non-proxy) image.  For non-proxy images, this
    /// is equal to DefaultFinalWidth/DefaultFinalHight.  For proxy images, this
    /// is equal to the DefaultFinalWidth/DefaultFinalHeight of the image this
    /// proxy was derived from.
    
    const dng_point & OriginalDefaultFinalSize () const
      {
      return fOriginalDefaultFinalSize;
      }
      
    /// Setter for OriginalDefaultFinalSize.
    
    void SetOriginalDefaultFinalSize (const dng_point &size)
      {
      fOriginalDefaultFinalSize = size;
      }
    
    /// Best quality size of original (non-proxy) image.  For non-proxy images, this
    /// is equal to BestQualityFinalWidth/BestQualityFinalHeight.  For proxy images, this
    /// is equal to the BestQualityFinalWidth/BestQualityFinalHeight of the image this
    /// proxy was derived from.
    
    const dng_point & OriginalBestQualityFinalSize () const
      {
      return fOriginalBestQualityFinalSize;
      }
      
    /// Setter for OriginalBestQualityFinalSize.
    
    void SetOriginalBestQualityFinalSize (const dng_point &size)
      {
      fOriginalBestQualityFinalSize = size;
      }
      
    /// DefaultCropSize for original (non-proxy) image.  For non-proxy images,
    /// this is equal to the DefaultCropSize.  for proxy images, this is
    /// equal size of the DefaultCropSize of the image this proxy was derived from.
    
    const dng_urational & OriginalDefaultCropSizeH () const
      {
      return fOriginalDefaultCropSizeH;
      }
      
    const dng_urational & OriginalDefaultCropSizeV () const
      {
      return fOriginalDefaultCropSizeV;
      }
      
    /// Setter for OriginalDefaultCropSize.
    
    void SetOriginalDefaultCropSize (const dng_urational &sizeH,
                     const dng_urational &sizeV)
      {
      fOriginalDefaultCropSizeH = sizeH;
      fOriginalDefaultCropSizeV = sizeV;
      }
      
    /// If the original size fields are undefined, set them to the
    /// current sizes.
    
    void SetDefaultOriginalSizes ();

    /// The default crop area in the stage 3 image coordinates.
              
    dng_rect DefaultCropArea () const;
                    
    /// Setter for BaselineNoise.
    
    void SetBaselineNoise (real64 noise)
      {
      fBaselineNoise.Set_real64 (noise, 100);
      }
            
    /// Getter for BaselineNoise as dng_urational.

    const dng_urational & BaselineNoiseR () const
      {
      return fBaselineNoise;
      }
    
    /// Getter for BaselineNoise as real64.

    real64 BaselineNoise () const
      {
      return fBaselineNoise.As_real64 ();
      }
      
    /// Setter for NoiseReductionApplied.
    
    void SetNoiseReductionApplied (const dng_urational &value)
      {
      fNoiseReductionApplied = value;
      }
      
    /// Getter for NoiseReductionApplied.
    
    const dng_urational & NoiseReductionApplied () const
      {
      return fNoiseReductionApplied;
      }

    /// Setter for noise profile.

    void SetNoiseProfile (const dng_noise_profile &noiseProfile)
      {
      fNoiseProfile = noiseProfile;
      }

    /// Does this negative have a valid noise profile?

    bool HasNoiseProfile () const
      {
      return fNoiseProfile.IsValidForNegative (*this);
      }

    /// Getter for noise profile.

    const dng_noise_profile & NoiseProfile () const
      {
      return fNoiseProfile;
      }
      
    /// Setter for BaselineExposure.
    
    void SetBaselineExposure (real64 exposure)
      {
      fBaselineExposure.Set_real64 (exposure, 100);
      }
            
    /// Getter for BaselineExposure as dng_urational.

    const dng_srational & BaselineExposureR () const
      {
      return fBaselineExposure;
      }
    
    /// Getter for BaselineExposure as real64.

    real64 BaselineExposure () const
      {
      return BaselineExposureR ().As_real64 ();
      }

    /// Compute total baseline exposure (sum of negative's BaselineExposure and
    /// profile's BaselineExposureOffset).

    real64 TotalBaselineExposure (const dng_camera_profile_id &profileID) const;

    /// Setter for BaselineSharpness.
    
    void SetBaselineSharpness (real64 sharpness)
      {
      fBaselineSharpness.Set_real64 (sharpness, 100);
      }
    
    /// Getter for BaselineSharpness as dng_urational.

    const dng_urational & BaselineSharpnessR () const
      {
      return fBaselineSharpness;
      }
    
    /// Getter for BaselineSharpness as real64.

    real64 BaselineSharpness () const
      {
      return BaselineSharpnessR ().As_real64 ();
      }
    
    /// Setter for ChromaBlurRadius.
    
    void SetChromaBlurRadius (const dng_urational &radius)
      {
      fChromaBlurRadius = radius;
      }
    
    /// Getter for ChromaBlurRadius as dng_urational.

    const dng_urational & ChromaBlurRadius () const
      {
      return fChromaBlurRadius;
      }
    
    /// Setter for AntiAliasStrength.
    
    void SetAntiAliasStrength (const dng_urational &strength)
      {
      fAntiAliasStrength = strength;
      }
            
    /// Getter for AntiAliasStrength as dng_urational.

    const dng_urational & AntiAliasStrength () const
      {
      return fAntiAliasStrength;
      }
    
    /// Setter for LinearResponseLimit.
    
    void SetLinearResponseLimit (real64 limit)
      {
      fLinearResponseLimit.Set_real64 (limit, 100);
      }
    
    /// Getter for LinearResponseLimit as dng_urational.

    const dng_urational & LinearResponseLimitR () const
      {
      return fLinearResponseLimit;
      }
    
    /// Getter for LinearResponseLimit as real64.

    real64 LinearResponseLimit () const
      {
      return LinearResponseLimitR ().As_real64 ();
      }
    
    /// Setter for ShadowScale.
    
    void SetShadowScale (const dng_urational &scale);
    
    /// Getter for ShadowScale as dng_urational.

    const dng_urational & ShadowScaleR () const
      {
      return fShadowScale;
      }
    
    /// Getter for ShadowScale as real64.

    real64 ShadowScale () const
      {
      return ShadowScaleR ().As_real64 ();
      }
      
    // API for ColorimetricReference.
    
    void SetColorimetricReference (uint32 ref)
      {
      fColorimetricReference = ref;
      }
      
    uint32 ColorimetricReference () const
      {
      return fColorimetricReference;
      }
    
    /// Setter for ColorChannels.
      
    void SetColorChannels (uint32 channels)
      {
      fColorChannels = channels;
      }
    
    /// Getter for ColorChannels.
      
    uint32 ColorChannels () const
      {
      return fColorChannels;
      }
    
    /// Setter for Monochrome.
      
    void SetMonochrome ()
      {
      SetColorChannels (1);
      }

    /// Getter for Monochrome.
      
    bool IsMonochrome () const
      {
      return ColorChannels () == 1;
      }
    
    /// Setter for AnalogBalance.

    void SetAnalogBalance (const dng_vector &b);
    
    /// Getter for AnalogBalance as dng_urational.

    dng_urational AnalogBalanceR (uint32 channel) const;
    
    /// Getter for AnalogBalance as real64.

    real64 AnalogBalance (uint32 channel) const;
    
    /// Setter for CameraNeutral.

    void SetCameraNeutral (const dng_vector &n);
            
    /// Clear CameraNeutral.

    void ClearCameraNeutral ()
      {
      fCameraNeutral.Clear ();
      }
    
    /// Determine if CameraNeutral has been set but not cleared.

    bool HasCameraNeutral () const
      {
      return fCameraNeutral.NotEmpty ();
      }
      
    /// Getter for CameraNeutral.

    const dng_vector & CameraNeutral () const
      {
      return fCameraNeutral;
      }
    
    dng_urational CameraNeutralR (uint32 channel) const;
    
    /// Setter for CameraWhiteXY.

    void SetCameraWhiteXY (const dng_xy_coord &coord);
    
    bool HasCameraWhiteXY () const
      {
      return fCameraWhiteXY.IsValid ();
      }
    
    const dng_xy_coord & CameraWhiteXY () const;
    
    void GetCameraWhiteXY (dng_urational &x,
                 dng_urational &y) const;
                 
    // API for camera calibration:
    
    /// Setter for first of up to two color matrices used for individual camera calibrations.
    /// 
    /// The sequence of matrix transforms is:
    /// Camera data --> camera calibration --> "inverse" of color matrix
    ///
    /// This will be a 4x4 matrix for a four-color camera. The defaults are
    /// almost always the identity matrix, and for the cases where they
    /// aren't, they are diagonal matrices.

    void SetCameraCalibration1 (const dng_matrix &m);

    /// Setter for second of up to two color matrices used for individual camera calibrations.
    /// 
    /// The sequence of matrix transforms is:
    /// Camera data --> camera calibration --> "inverse" of color matrix
    ///
    /// This will be a 4x4 matrix for a four-color camera. The defaults are
    /// almost always the identity matrix, and for the cases where they
    /// aren't, they are diagonal matrices.

    void SetCameraCalibration2 (const dng_matrix &m);
    
    /// Getter for first of up to two color matrices used for individual camera calibrations.

    const dng_matrix & CameraCalibration1 () const
      {
      return fCameraCalibration1;
      }
  
    /// Getter for second of up to two color matrices used for individual camera calibrations.

    const dng_matrix & CameraCalibration2 () const
      {
      return fCameraCalibration2;
      }
    
    void SetCameraCalibrationSignature (const char *signature)
      {
      fCameraCalibrationSignature.Set (signature);
      }

    const dng_string & CameraCalibrationSignature () const
      {
      return fCameraCalibrationSignature;
      }
      
    // Camera Profile API:
    
    void AddProfile (AutoPtr<dng_camera_profile> &profile);
    
    void ClearProfiles ();
      
    void ClearProfiles (bool clearBuiltinMatrixProfiles,
              bool clearReadFromDisk);
      
    uint32 ProfileCount () const;
    
    const dng_camera_profile & ProfileByIndex (uint32 index) const;
    
    virtual const dng_camera_profile * ProfileByID (const dng_camera_profile_id &id,
                            bool useDefaultIfNoMatch = true) const;
    
    bool HasProfileID (const dng_camera_profile_id &id) const
      {
      return ProfileByID (id, false) != NULL;
      }
    
    // Returns the camera profile to embed when saving to DNG: 
    
    virtual const dng_camera_profile * ComputeCameraProfileToEmbed
                          (const dng_metadata &metadata) const;
                          
    // For non-const negatives, we can use the embedded metadata.
    
    const dng_camera_profile * CameraProfileToEmbed ()
      {
      return ComputeCameraProfileToEmbed (Metadata ());
      }
    
    // API for AsShotProfileName.
      
    void SetAsShotProfileName (const char *name)
      {
      fAsShotProfileName.Set (name);
      }

    const dng_string & AsShotProfileName () const
      {
      return fAsShotProfileName;
      }
      
    // Makes a dng_color_spec object for this negative.
    
    virtual dng_color_spec * MakeColorSpec (const dng_camera_profile_id &id) const;
    
    // Compute a MD5 hash on an image, using a fixed algorithm.
    // The results must be stable across different hardware, OSes,
    // and software versions.
      
    dng_fingerprint FindImageDigest (dng_host &host,
                     const dng_image &image) const;
      
    // API for RawImageDigest and NewRawImageDigest:
    
    void SetRawImageDigest (const dng_fingerprint &digest)
      {
      fRawImageDigest = digest;
      }
      
    void SetNewRawImageDigest (const dng_fingerprint &digest)
      {
      fNewRawImageDigest = digest;
      }
      
    void ClearRawImageDigest () const
      {
      fRawImageDigest   .Clear ();
      fNewRawImageDigest.Clear ();
      }
      
    const dng_fingerprint & RawImageDigest () const
      {
      return fRawImageDigest;
      }
      
    const dng_fingerprint & NewRawImageDigest () const
      {
      return fNewRawImageDigest;
      }
      
    void FindRawImageDigest (dng_host &host) const;
    
    void FindNewRawImageDigest (dng_host &host) const;
    
    void ValidateRawImageDigest (dng_host &host);
    
    // API for RawDataUniqueID:

    void SetRawDataUniqueID (const dng_fingerprint &id)
      {
      fRawDataUniqueID = id;
      }
    
    const dng_fingerprint & RawDataUniqueID () const
      {
      return fRawDataUniqueID;
      }
    
    void FindRawDataUniqueID (dng_host &host) const;
    
    void RecomputeRawDataUniqueID (dng_host &host);

    // API for original raw file name:
    
    void SetOriginalRawFileName (const char *name)
      {
      fOriginalRawFileName.Set (name);
      }
      
    bool HasOriginalRawFileName () const
      {
      return fOriginalRawFileName.NotEmpty ();
      }
    
    const dng_string & OriginalRawFileName () const
      {
      return fOriginalRawFileName;
      }
    
    // API for original raw file data:
    
    void SetHasOriginalRawFileData (bool hasData)
      {
      fHasOriginalRawFileData = hasData;
      }
    
    bool CanEmbedOriginalRaw () const
      {
      return fHasOriginalRawFileData && HasOriginalRawFileName ();
      }
    
    void SetOriginalRawFileData (AutoPtr<dng_memory_block> &data)
      {
      fOriginalRawFileData.Reset (data.Release ());
      }
    
    const void * OriginalRawFileData () const
      {
      return fOriginalRawFileData.Get () ? fOriginalRawFileData->Buffer ()
                         : NULL;
      }
    
    uint32 OriginalRawFileDataLength () const
      {
      return fOriginalRawFileData.Get () ? fOriginalRawFileData->LogicalSize ()
                         : 0;
      }
      
    // API for original raw file data digest.
    
    void SetOriginalRawFileDigest (const dng_fingerprint &digest)
      {
      fOriginalRawFileDigest = digest;
      }
      
    const dng_fingerprint & OriginalRawFileDigest () const
      {
      return fOriginalRawFileDigest;
      }
      
    void FindOriginalRawFileDigest () const;
    
    void ValidateOriginalRawFileDigest ();
    
    // API for DNG private data:
    
    void SetPrivateData (AutoPtr<dng_memory_block> &block)
      {
      fDNGPrivateData.Reset (block.Release ());
      }
    
    void ClearPrivateData ()
      {
      fDNGPrivateData.Reset ();
      }
    
    const uint8 * PrivateData () const
      {
      return fDNGPrivateData.Get () ? fDNGPrivateData->Buffer_uint8 ()
                      : NULL;
      }
    
    uint32 PrivateLength () const
      {
      return fDNGPrivateData.Get () ? fDNGPrivateData->LogicalSize ()
                      : 0;
      }
    
    // API for MakerNote data:
    
    void SetMakerNoteSafety (bool safe)
      {
      Metadata ().SetMakerNoteSafety (safe);
      }
    
    bool IsMakerNoteSafe () METACONST
      {
      return Metadata ().IsMakerNoteSafe ();
      }
    
    void SetMakerNote (AutoPtr<dng_memory_block> &block)
      {
      Metadata ().SetMakerNote (block);
      }
    
    void ClearMakerNote ()
      {
      Metadata ().ClearMakerNote ();
      }
    
    const void * MakerNoteData () METACONST
      {
      return Metadata ().MakerNoteData ();
      }
    
    uint32 MakerNoteLength () METACONST
      {
      return Metadata ().MakerNoteLength ();
      }
    
    // API for EXIF metadata:
    
    dng_exif * GetExif ()
      {
      return Metadata ().GetExif ();
      }
      
    #if qMetadataOnConst
      
    const dng_exif * GetExif () const
      {
      return Metadata ().GetExif ();
      }
      
    #endif // qMetadataOnConst
      
    void ResetExif (dng_exif * newExif)
      {
      Metadata ().ResetExif (newExif);
      }
      
    // API for original EXIF metadata.
    
    dng_exif * GetOriginalExif ()
      {
      return Metadata ().GetOriginalExif ();
      }
      
    #if qMetadataOnConst
      
    const dng_exif * GetOriginalExif () const
      {
      return Metadata ().GetOriginalExif ();
      }
      
    #endif // qMetadataOnConst
      
    // API for IPTC metadata:
      
    void SetIPTC (AutoPtr<dng_memory_block> &block,
            uint64 offset)
      {
      Metadata ().SetIPTC (block, offset);
      }
    
    void SetIPTC (AutoPtr<dng_memory_block> &block)
      {
      Metadata ().SetIPTC (block);
      }
    
    void ClearIPTC ()
      {
      Metadata ().ClearIPTC ();
      }
    
    const void * IPTCData () METACONST
      {
      return Metadata ().IPTCData ();
      }
    
    uint32 IPTCLength () METACONST
      {
      return Metadata ().IPTCLength ();
      }
    
    uint64 IPTCOffset () METACONST
      {
      return Metadata ().IPTCOffset ();
      }
    
    dng_fingerprint IPTCDigest (bool includePadding = true) METACONST
      {
      return Metadata ().IPTCDigest (includePadding);
      }
    
    void RebuildIPTC (bool padForTIFF)
      {
      Metadata ().RebuildIPTC (Allocator (), padForTIFF);
      }
    
    // API for XMP metadata:
    
    #if qDNGUseXMP
    
    bool SetXMP (dng_host &host,
           const void *buffer,
           uint32 count,
           bool xmpInSidecar = false,
           bool xmpIsNewer = false)
      {
      return Metadata ().SetXMP (host,
                     buffer,
                     count,
                     xmpInSidecar,
                     xmpIsNewer);
      }
           
    dng_xmp * GetXMP ()
      {
      return Metadata ().GetXMP ();
      }
      
    #if qMetadataOnConst
      
    const dng_xmp * GetXMP () const
      {
      return Metadata ().GetXMP ();
      }
      
    #endif // qMetadataOnConst
      
    bool XMPinSidecar () METACONST
      {
      return Metadata ().XMPinSidecar ();
      }
      
    void ResetXMP (dng_xmp * newXMP)
      {
      Metadata ().ResetXMP (newXMP);
      }
  
    void ResetXMPSidecarNewer (dng_xmp * newXMP, bool inSidecar, bool isNewer )
      {
      Metadata ().ResetXMPSidecarNewer (newXMP, inSidecar, isNewer);
      }
    
    bool HaveValidEmbeddedXMP () METACONST
      {
      return Metadata ().HaveValidEmbeddedXMP ();
      }
      
    #endif
    
    // API for source MIMI type.
    
    void SetSourceMIMI (const char *s)
      {
      Metadata ().SetSourceMIMI (s);
      }
    
    // API for linearization information:
      
    const dng_linearization_info * GetLinearizationInfo () const
      {
      return fLinearizationInfo.Get ();
      }
      
    void ClearLinearizationInfo ()
      {
      fLinearizationInfo.Reset ();
      }
      
    // Linearization curve.  Usually used to increase compression ratios
    // by storing the compressed data in a more visually uniform space.
    // This is a 16-bit LUT that maps the stored data back to linear.
    
    void SetLinearization (AutoPtr<dng_memory_block> &curve);
    
    // Active area (non-black masked pixels).  These pixels are trimmed
    // during linearization step.
    
    void SetActiveArea (const dng_rect &area);
    
    // Areas that are known to contain black masked pixels that can
    // be used to estimate black levels.
    
    void SetMaskedAreas (uint32 count,
               const dng_rect *area);
               
    void SetMaskedArea (const dng_rect &area)
      {
      SetMaskedAreas (1, &area);
      }

    // Sensor black level information.
    
    void SetBlackLevel (real64 black,
              int32 plane = -1);
              
    void SetQuadBlacks (real64 black0,
                real64 black1,
                real64 black2,
                real64 black3,
              int32 plane = -1);
                
    void SetRowBlacks (const real64 *blacks,
               uint32 count);
               
    void SetColumnBlacks (const real64 *blacks,
                uint32 count);
                
    // Sensor white level information.
    
    uint32 WhiteLevel (uint32 plane = 0) const;
      
    void SetWhiteLevel (uint32 white,
              int32 plane = -1);

    // API for mosaic information:
    
    const dng_mosaic_info * GetMosaicInfo () const
      {
      return fMosaicInfo.Get ();
      }
      
    void ClearMosaicInfo ()
      {
      fMosaicInfo.Reset ();
      }
    
    // ColorKeys APIs:
              
    void SetColorKeys (ColorKeyCode color0,
               ColorKeyCode color1,
               ColorKeyCode color2,
               ColorKeyCode color3 = colorKeyMaxEnum);

    void SetRGB ()
      {
      
      SetColorChannels (3);
      
      SetColorKeys (colorKeyRed,
              colorKeyGreen,
              colorKeyBlue);
              
      }
      
    void SetCMY ()
      {
      
      SetColorChannels (3);
      
      SetColorKeys (colorKeyCyan,
              colorKeyMagenta,
              colorKeyYellow);
              
      }
      
    void SetGMCY ()
      {
      
      SetColorChannels (4);
      
      SetColorKeys (colorKeyGreen,
              colorKeyMagenta,
                colorKeyCyan,
              colorKeyYellow);
              
      }
      
    // APIs to set mosaic patterns.
      
    void SetBayerMosaic (uint32 phase);

    void SetFujiMosaic (uint32 phase);

    void SetFujiMosaic6x6 (uint32 phase);

    void SetQuadMosaic (uint32 pattern);
      
    // BayerGreenSplit.
              
    void SetGreenSplit (uint32 split);
    
    // APIs for opcode lists.
    
    const dng_opcode_list & OpcodeList1 () const
      {
      return fOpcodeList1;
      }
      
    dng_opcode_list & OpcodeList1 ()
      {
      return fOpcodeList1;
      }
      
    const dng_opcode_list & OpcodeList2 () const
      {
      return fOpcodeList2;
      }
      
    dng_opcode_list & OpcodeList2 ()
      {
      return fOpcodeList2;
      }
      
    const dng_opcode_list & OpcodeList3 () const
      {
      return fOpcodeList3;
      }
      
    dng_opcode_list & OpcodeList3 ()
      {
      return fOpcodeList3;
      }
    
    // First part of parsing logic.
    
    virtual void Parse (dng_host &host,
              dng_stream &stream,
              dng_info &info);
              
    // Second part of parsing logic.  This is split off from the
    // first part because these operations are useful when extending
    // this sdk to support non-DNG raw formats.
              
    virtual void PostParse (dng_host &host,
                dng_stream &stream,
                dng_info &info);
                
    // Synchronize metadata sources.
    
    void SynchronizeMetadata ()
      {
      Metadata ().SynchronizeMetadata ();
      }
    
    // Routines to update the date/time field in the EXIF and XMP
    // metadata.
    
    void UpdateDateTime (const dng_date_time_info &dt)
      {
      Metadata ().UpdateDateTime (dt);
      }
               
    void UpdateDateTimeToNow ()
      {
      Metadata ().UpdateDateTimeToNow ();
      }
    
    // Developer's utility function to switch to four color Bayer
    // interpolation.  This is useful for evaluating how much green
    // split a Bayer pattern sensor has.
      
    virtual bool SetFourColorBayer ();
    
    // Access routines for the image stages.
              
    const dng_image * Stage1Image () const
      {
      return fStage1Image.Get ();
      }
      
    const dng_image * Stage2Image () const
      {
      return fStage2Image.Get ();
      }
      
    const dng_image * Stage3Image () const
      {
      return fStage3Image.Get ();
      }
      
    // Returns the processing stage of the raw image data.
    
    RawImageStageEnum RawImageStage () const
      {
      return fRawImageStage;
      }
      
    // Returns the raw image data.
    
    const dng_image & RawImage () const;
    
    // API for raw floating point bit depth.
    
    uint32 RawFloatBitDepth () const
      {
      return fRawFloatBitDepth;
      }
      
    void SetRawFloatBitDepth (uint32 bitDepth)
      {
      fRawFloatBitDepth = bitDepth;
      }
    
    // API for raw jpeg image.
    
    const dng_jpeg_image * RawJPEGImage () const;

    void SetRawJPEGImage (AutoPtr<dng_jpeg_image> &jpegImage);
      
    void ClearRawJPEGImage ();
      
    // API for RawJPEGImageDigest:
    
    void SetRawJPEGImageDigest (const dng_fingerprint &digest)
      {
      fRawJPEGImageDigest = digest;
      }
      
    void ClearRawJPEGImageDigest () const
      {
      fRawJPEGImageDigest.Clear ();
      }
      
    const dng_fingerprint & RawJPEGImageDigest () const
      {
      return fRawJPEGImageDigest;
      }
      
    void FindRawJPEGImageDigest (dng_host &host) const;
    
    // Read the stage 1 image.
      
    virtual void ReadStage1Image (dng_host &host,
                    dng_stream &stream,
                    dng_info &info);
                    
    // Assign the stage 1 image.
    
    void SetStage1Image (AutoPtr<dng_image> &image);
    
    // Assign the stage 2 image.
    
    void SetStage2Image (AutoPtr<dng_image> &image);
                    
    // Assign the stage 3 image.
    
    void SetStage3Image (AutoPtr<dng_image> &image);
    
    // Build the stage 2 (linearized and range mapped) image.
    
    void BuildStage2Image (dng_host &host);
                     
    // Build the stage 3 (demosaiced) image.
                     
    void BuildStage3Image (dng_host &host,
                 int32 srcPlane = -1);
                     
    // Additional gain applied when building the stage 3 image.
    
    void SetStage3Gain (real64 gain)
      {
      fStage3Gain = gain;
      }
    
    real64 Stage3Gain () const
      {
      return fStage3Gain;
      }
      
    // Adaptively encode a proxy image down to 8-bits/channel.

    dng_image * EncodeRawProxy (dng_host &host,
                  const dng_image &srcImage,
                  dng_opcode_list &opcodeList) const;

    // Convert to a proxy negative.

    void ConvertToProxy (dng_host &host,
               dng_image_writer &writer,
               uint32 proxySize = 0,
               uint64 proxyCount = 0);
               
    // IsPreview API:
      
    void SetIsPreview (bool preview)
      {
      fIsPreview = preview;
      }
    
    bool IsPreview () const
      {
      return fIsPreview;
      }
      
    // IsDamaged API:
    
    void SetIsDamaged (bool damaged)
      {
      fIsDamaged = damaged;
      }
      
    bool IsDamaged () const
      {
      return fIsDamaged;
      }
      
    // Transparancy Mask API:
    
    void SetTransparencyMask (AutoPtr<dng_image> &image,
                  uint32 bitDepth = 0);
    
    const dng_image * TransparencyMask () const;
    
    const dng_image * RawTransparencyMask () const;
    
    uint32 RawTransparencyMaskBitDepth () const;
    
    void ReadTransparencyMask (dng_host &host,
                   dng_stream &stream,
                   dng_info &info);
                   
    virtual bool NeedFlattenTransparency (dng_host &host);
    
    virtual void FlattenTransparency (dng_host &host);
    
    const dng_image * UnflattenedStage3Image () const;

  protected:
  
    dng_negative (dng_host &host);
    
    virtual void Initialize ();
    
    virtual dng_linearization_info * MakeLinearizationInfo ();
    
    void NeedLinearizationInfo ();
    
    virtual dng_mosaic_info * MakeMosaicInfo ();
    
    void NeedMosaicInfo ();
    
    virtual void DoBuildStage2 (dng_host &host);
    
    virtual void DoPostOpcodeList2 (dng_host &host);
                     
    virtual bool NeedDefloatStage2 (dng_host &host);
    
    virtual void DefloatStage2 (dng_host &host);
    
    virtual void DoInterpolateStage3 (dng_host &host,
                        int32 srcPlane);
                  
    virtual void DoMergeStage3 (dng_host &host);
                     
    virtual void DoBuildStage3 (dng_host &host,
                  int32 srcPlane);
                     
    virtual void AdjustProfileForStage3 ();
                    
    virtual void ResizeTransparencyToMatchStage3 (dng_host &host,
                            bool convertTo8Bit = false);
                            
  };

/*****************************************************************************/

#endif
  
/*****************************************************************************/

Coverage Report

Created: 2021-08-22 09:07