/*****************************************************************************/
// 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
/*****************************************************************************/