You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2404 lines
55 KiB
2404 lines
55 KiB
/*****************************************************************************/
|
|
// 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
|
|
|
|
/*****************************************************************************/
|