diff options
Diffstat (limited to 'gpr/source/lib/dng_sdk/dng_negative.h')
| -rw-r--r-- | gpr/source/lib/dng_sdk/dng_negative.h | 2397 |
1 files changed, 2397 insertions, 0 deletions
diff --git a/gpr/source/lib/dng_sdk/dng_negative.h b/gpr/source/lib/dng_sdk/dng_negative.h new file mode 100644 index 0000000..1304292 --- /dev/null +++ b/gpr/source/lib/dng_sdk/dng_negative.h @@ -0,0 +1,2397 @@ +/*****************************************************************************/
+// 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_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
+
+/*****************************************************************************/
+
+#if GPR_READING
+ typedef bool (*Vc5DecodeCallback)(dng_stream &stream, dng_image &image );
+#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:
+
+ 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 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.
+
+ AutoPtr<dng_xmp> fXMP;
+
+ // 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:
+
+ 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 );
+
+ // 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);
+ }
+
+/*****************************************************************************/
+
+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);
+ }
+
+/*****************************************************************************/
+
+/// \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.
+
+ 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;
+ }
+
+ bool IsVc5Image(dng_info &info);
+
+ void ReadVc5Image (dng_host &host,
+ dng_stream &stream,
+ dng_info &info,
+ dng_read_image &imageReader );
+
+ /// 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:
+
+ 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 ();
+ }
+
+ // 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
+
+/*****************************************************************************/
|