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.
879 lines
23 KiB
879 lines
23 KiB
/******************************************************************************/
|
|
// Copyright 2006-2007 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_camera_profile.h#2 $ */
|
|
/* $DateTime: 2012/07/11 10:36:56 $ */
|
|
/* $Change: 838485 $ */
|
|
/* $Author: tknoll $ */
|
|
|
|
/** \file
|
|
* Support for DNG camera color profile information.
|
|
* Per the \ref spec_dng "DNG 1.1.0 specification", a DNG file can store up to
|
|
* two sets of color profile information for a camera in the DNG file from that
|
|
* camera. The second set is optional and when there are two sets, they represent
|
|
* profiles made under different illumination.
|
|
*
|
|
* Profiling information is optionally separated into two parts. One part represents
|
|
* a profile for a reference camera. (ColorMatrix1 and ColorMatrix2 here.) The
|
|
* second is a per-camera calibration that takes into account unit-to-unit variation.
|
|
* This is designed to allow replacing the reference color matrix with one of one's
|
|
* own construction while maintaining any unit-specific calibration the camera
|
|
* manufacturer may have provided.
|
|
*
|
|
* See Appendix 6 of the \ref spec_dng "DNG 1.1.0 specification" for more information.
|
|
*/
|
|
|
|
#ifndef __dng_camera_profile__
|
|
#define __dng_camera_profile__
|
|
|
|
/******************************************************************************/
|
|
|
|
#include "dng_auto_ptr.h"
|
|
#include "dng_assertions.h"
|
|
#include "dng_classes.h"
|
|
#include "dng_fingerprint.h"
|
|
#include "dng_hue_sat_map.h"
|
|
#include "dng_matrix.h"
|
|
#include "dng_string.h"
|
|
#include "dng_tag_values.h"
|
|
#include "dng_tone_curve.h"
|
|
|
|
/******************************************************************************/
|
|
|
|
extern const char * kProfileName_Embedded;
|
|
|
|
extern const char * kAdobeCalibrationSignature;
|
|
|
|
/******************************************************************************/
|
|
|
|
/// \brief An ID for a camera profile consisting of a name and optional fingerprint.
|
|
|
|
class dng_camera_profile_id
|
|
{
|
|
|
|
private:
|
|
|
|
dng_string fName;
|
|
|
|
dng_fingerprint fFingerprint;
|
|
|
|
public:
|
|
|
|
/// Construct an invalid camera profile ID (empty name and fingerprint).
|
|
|
|
dng_camera_profile_id ()
|
|
|
|
: fName ()
|
|
, fFingerprint ()
|
|
|
|
{
|
|
}
|
|
|
|
/// Construct a camera profile ID with the specified name and no fingerprint.
|
|
/// \param name The name of the camera profile ID.
|
|
|
|
dng_camera_profile_id (const char *name)
|
|
|
|
: fName ()
|
|
, fFingerprint ()
|
|
|
|
{
|
|
fName.Set (name);
|
|
}
|
|
|
|
/// Construct a camera profile ID with the specified name and no fingerprint.
|
|
/// \param name The name of the camera profile ID.
|
|
|
|
dng_camera_profile_id (const dng_string &name)
|
|
|
|
: fName (name)
|
|
, fFingerprint ()
|
|
|
|
{
|
|
}
|
|
|
|
/// Construct a camera profile ID with the specified name and fingerprint.
|
|
/// \param name The name of the camera profile ID.
|
|
/// \param fingerprint The fingerprint of the camera profile ID.
|
|
|
|
dng_camera_profile_id (const char *name,
|
|
const dng_fingerprint &fingerprint)
|
|
|
|
: fName ()
|
|
, fFingerprint (fingerprint)
|
|
|
|
{
|
|
fName.Set (name);
|
|
DNG_ASSERT (!fFingerprint.IsValid () || fName.NotEmpty (),
|
|
"Cannot have profile fingerprint without name");
|
|
}
|
|
|
|
/// Construct a camera profile ID with the specified name and fingerprint.
|
|
/// \param name The name of the camera profile ID.
|
|
/// \param fingerprint The fingerprint of the camera profile ID.
|
|
|
|
dng_camera_profile_id (const dng_string &name,
|
|
const dng_fingerprint &fingerprint)
|
|
|
|
: fName (name)
|
|
, fFingerprint (fingerprint)
|
|
|
|
{
|
|
DNG_ASSERT (!fFingerprint.IsValid () || fName.NotEmpty (),
|
|
"Cannot have profile fingerprint without name");
|
|
}
|
|
|
|
/// Getter for the name of the camera profile ID.
|
|
/// \retval The name of the camera profile ID.
|
|
|
|
const dng_string & Name () const
|
|
{
|
|
return fName;
|
|
}
|
|
|
|
/// Getter for the fingerprint of the camera profile ID.
|
|
/// \retval The fingerprint of the camera profile ID.
|
|
|
|
const dng_fingerprint & Fingerprint () const
|
|
{
|
|
return fFingerprint;
|
|
}
|
|
|
|
/// Test for equality of two camera profile IDs.
|
|
/// \param The id of the camera profile ID to compare.
|
|
|
|
bool operator== (const dng_camera_profile_id &id) const
|
|
{
|
|
return fName == id.fName &&
|
|
fFingerprint == id.fFingerprint;
|
|
}
|
|
|
|
/// Test for inequality of two camera profile IDs.
|
|
/// \param The id of the camera profile ID to compare.
|
|
|
|
bool operator!= (const dng_camera_profile_id &id) const
|
|
{
|
|
return !(*this == id);
|
|
}
|
|
|
|
/// Returns true iff the camera profile ID is valid.
|
|
|
|
bool IsValid () const
|
|
{
|
|
return fName.NotEmpty (); // Fingerprint is optional.
|
|
}
|
|
|
|
/// Resets the name and fingerprint, thereby making this camera profile ID
|
|
/// invalid.
|
|
|
|
void Clear ()
|
|
{
|
|
*this = dng_camera_profile_id ();
|
|
}
|
|
|
|
};
|
|
|
|
/******************************************************************************/
|
|
|
|
/// \brief Container for DNG camera color profile and calibration data.
|
|
|
|
class dng_camera_profile
|
|
{
|
|
|
|
protected:
|
|
|
|
// Name of this camera profile.
|
|
|
|
dng_string fName;
|
|
|
|
// Light sources for up to two calibrations. These use the EXIF
|
|
// encodings for illuminant and are used to distinguish which
|
|
// matrix to use.
|
|
|
|
uint32 fCalibrationIlluminant1;
|
|
uint32 fCalibrationIlluminant2;
|
|
|
|
// Color matrices for up to two calibrations.
|
|
|
|
// These matrices map XYZ values to non-white balanced camera values.
|
|
// Adobe needs to go that direction in order to determine the clipping
|
|
// points for highlight recovery logic based on the white point. If
|
|
// cameras were all 3-color, the matrix could be stored as a forward matrix,
|
|
// but we need the backwards matrix to deal with 4-color cameras.
|
|
|
|
dng_matrix fColorMatrix1;
|
|
dng_matrix fColorMatrix2;
|
|
|
|
// These matrices map white balanced camera values to XYZ chromatically
|
|
// adapted to D50 (the ICC profile PCS white point). If the matrices
|
|
// exist, then this implies that white balancing should be done by scaling
|
|
// camera values with a diagonal matrix.
|
|
|
|
dng_matrix fForwardMatrix1;
|
|
dng_matrix fForwardMatrix2;
|
|
|
|
// Dimensionality reduction hints for more than three color cameras.
|
|
// This is an optional matrix that maps the camera's color components
|
|
// to 3 components. These are only used if the forward matrices don't
|
|
// exist, and are used invert the color matrices.
|
|
|
|
dng_matrix fReductionMatrix1;
|
|
dng_matrix fReductionMatrix2;
|
|
|
|
// MD5 hash for all data bits of the profile.
|
|
|
|
mutable dng_fingerprint fFingerprint;
|
|
|
|
// Copyright notice from creator of profile.
|
|
|
|
dng_string fCopyright;
|
|
|
|
// Rules for how this profile can be embedded and/or copied.
|
|
|
|
uint32 fEmbedPolicy;
|
|
|
|
// 2-D (or 3-D) hue/sat tables to modify colors.
|
|
|
|
dng_hue_sat_map fHueSatDeltas1;
|
|
dng_hue_sat_map fHueSatDeltas2;
|
|
|
|
// Value (V of HSV) encoding for hue/sat tables.
|
|
|
|
uint32 fHueSatMapEncoding;
|
|
|
|
// 3-D hue/sat table to apply a "look".
|
|
|
|
dng_hue_sat_map fLookTable;
|
|
|
|
// Value (V of HSV) encoding for look table.
|
|
|
|
uint32 fLookTableEncoding;
|
|
|
|
// Baseline exposure offset. When using this profile, this offset value is
|
|
// added to the BaselineExposure value for the negative to determine the
|
|
// overall baseline exposure to apply.
|
|
|
|
dng_srational fBaselineExposureOffset;
|
|
|
|
// Default black rendering.
|
|
|
|
uint32 fDefaultBlackRender;
|
|
|
|
// The "as shot" tone curve for this profile. Check IsValid method
|
|
// to tell if one exists in profile.
|
|
|
|
dng_tone_curve fToneCurve;
|
|
|
|
// If this string matches the fCameraCalibrationSignature of the
|
|
// negative, then use the calibration matrix values from the negative.
|
|
|
|
dng_string fProfileCalibrationSignature;
|
|
|
|
// If non-empty, only allow use of this profile with camera having
|
|
// same unique model name.
|
|
|
|
dng_string fUniqueCameraModelRestriction;
|
|
|
|
// Was this profile read from inside a DNG file? (If so, we wnat
|
|
// to be sure to include it again when writing out an updated
|
|
// DNG file)
|
|
|
|
bool fWasReadFromDNG;
|
|
|
|
// Was this profile read from disk (i.e., an external profile)? (If so, we
|
|
// may need to refresh when changes are made externally to the profile
|
|
// directory.)
|
|
|
|
bool fWasReadFromDisk;
|
|
|
|
// Was this profile a built-in "Matrix" profile? (If so, we may need to
|
|
// refresh -- i.e., remove it from the list of available profiles -- when
|
|
// changes are made externally to the profile directory.)
|
|
|
|
bool fWasBuiltinMatrix;
|
|
|
|
// Was this profile stubbed to save memory (and no longer valid
|
|
// for building color conversion tables)?
|
|
|
|
bool fWasStubbed;
|
|
|
|
public:
|
|
|
|
dng_camera_profile ();
|
|
|
|
virtual ~dng_camera_profile ();
|
|
|
|
// API for profile name:
|
|
|
|
/// Setter for camera profile name.
|
|
/// \param name Name to use for this camera profile.
|
|
|
|
void SetName (const char *name)
|
|
{
|
|
fName.Set (name);
|
|
ClearFingerprint ();
|
|
}
|
|
|
|
/// Getter for camera profile name.
|
|
/// \retval Name of profile.
|
|
|
|
const dng_string & Name () const
|
|
{
|
|
return fName;
|
|
}
|
|
|
|
/// Test if this name is embedded.
|
|
/// \retval true if the name matches the name of the embedded camera profile.
|
|
|
|
bool NameIsEmbedded () const
|
|
{
|
|
return fName.Matches (kProfileName_Embedded, true);
|
|
}
|
|
|
|
// API for calibration illuminants:
|
|
|
|
/// Setter for first of up to two light sources used for calibration.
|
|
/// Uses the EXIF encodings for illuminant and is used to distinguish which
|
|
/// matrix to use.
|
|
/// Corresponds to the DNG CalibrationIlluminant1 tag.
|
|
|
|
void SetCalibrationIlluminant1 (uint32 light)
|
|
{
|
|
fCalibrationIlluminant1 = light;
|
|
ClearFingerprint ();
|
|
}
|
|
|
|
/// Setter for second of up to two light sources used for calibration.
|
|
/// Uses the EXIF encodings for illuminant and is used to distinguish which
|
|
/// matrix to use.
|
|
/// Corresponds to the DNG CalibrationIlluminant2 tag.
|
|
|
|
void SetCalibrationIlluminant2 (uint32 light)
|
|
{
|
|
fCalibrationIlluminant2 = light;
|
|
ClearFingerprint ();
|
|
}
|
|
|
|
/// Getter for first of up to two light sources used for calibration.
|
|
/// Uses the EXIF encodings for illuminant and is used to distinguish which
|
|
/// matrix to use.
|
|
/// Corresponds to the DNG CalibrationIlluminant1 tag.
|
|
|
|
uint32 CalibrationIlluminant1 () const
|
|
{
|
|
return fCalibrationIlluminant1;
|
|
}
|
|
|
|
/// Getter for second of up to two light sources used for calibration.
|
|
/// Uses the EXIF encodings for illuminant and is used to distinguish which
|
|
/// matrix to use.
|
|
/// Corresponds to the DNG CalibrationIlluminant2 tag.
|
|
|
|
uint32 CalibrationIlluminant2 () const
|
|
{
|
|
return fCalibrationIlluminant2;
|
|
}
|
|
|
|
/// Getter for first of up to two light sources used for calibration, returning
|
|
/// result as color temperature.
|
|
|
|
real64 CalibrationTemperature1 () const
|
|
{
|
|
return IlluminantToTemperature (CalibrationIlluminant1 ());
|
|
}
|
|
|
|
/// Getter for second of up to two light sources used for calibration, returning
|
|
/// result as color temperature.
|
|
|
|
real64 CalibrationTemperature2 () const
|
|
{
|
|
return IlluminantToTemperature (CalibrationIlluminant2 ());
|
|
}
|
|
|
|
// API for color matrices:
|
|
|
|
/// Utility function to normalize the scale of the color matrix.
|
|
|
|
static void NormalizeColorMatrix (dng_matrix &m);
|
|
|
|
/// Setter for first of up to two color matrices used for reference camera calibrations.
|
|
/// These matrices map XYZ values to camera values. The DNG SDK needs to map colors
|
|
/// that direction in order to determine the clipping points for
|
|
/// highlight recovery logic based on the white point. If cameras
|
|
/// were all three-color, the matrix could be stored as a forward matrix.
|
|
/// The inverse matrix is requried to support four-color cameras.
|
|
|
|
void SetColorMatrix1 (const dng_matrix &m);
|
|
|
|
/// Setter for second of up to two color matrices used for reference camera calibrations.
|
|
/// These matrices map XYZ values to camera values. The DNG SDK needs to map colors
|
|
/// that direction in order to determine the clipping points for
|
|
/// highlight recovery logic based on the white point. If cameras
|
|
/// were all three-color, the matrix could be stored as a forward matrix.
|
|
/// The inverse matrix is requried to support four-color cameras.
|
|
|
|
void SetColorMatrix2 (const dng_matrix &m);
|
|
|
|
/// Predicate to test if first camera matrix is set
|
|
|
|
bool HasColorMatrix1 () const;
|
|
|
|
/// Predicate to test if second camera matrix is set
|
|
|
|
bool HasColorMatrix2 () const;
|
|
|
|
/// Getter for first of up to two color matrices used for calibrations.
|
|
|
|
const dng_matrix & ColorMatrix1 () const
|
|
{
|
|
return fColorMatrix1;
|
|
}
|
|
|
|
/// Getter for second of up to two color matrices used for calibrations.
|
|
|
|
const dng_matrix & ColorMatrix2 () const
|
|
{
|
|
return fColorMatrix2;
|
|
}
|
|
|
|
// API for forward matrices:
|
|
|
|
/// Utility function to normalize the scale of the forward matrix.
|
|
|
|
static void NormalizeForwardMatrix (dng_matrix &m);
|
|
|
|
/// Setter for first of up to two forward matrices used for calibrations.
|
|
|
|
void SetForwardMatrix1 (const dng_matrix &m);
|
|
|
|
/// Setter for second of up to two forward matrices used for calibrations.
|
|
|
|
void SetForwardMatrix2 (const dng_matrix &m);
|
|
|
|
/// Getter for first of up to two forward matrices used for calibrations.
|
|
|
|
const dng_matrix & ForwardMatrix1 () const
|
|
{
|
|
return fForwardMatrix1;
|
|
}
|
|
|
|
/// Getter for second of up to two forward matrices used for calibrations.
|
|
|
|
const dng_matrix & ForwardMatrix2 () const
|
|
{
|
|
return fForwardMatrix2;
|
|
}
|
|
|
|
// API for reduction matrices:
|
|
|
|
/// Setter for first of up to two dimensionality reduction hints for four-color cameras.
|
|
/// This is an optional matrix that maps four components to three.
|
|
/// See Appendix 6 of the \ref spec_dng "DNG 1.1.0 specification."
|
|
|
|
void SetReductionMatrix1 (const dng_matrix &m);
|
|
|
|
/// Setter for second of up to two dimensionality reduction hints for four-color cameras.
|
|
/// This is an optional matrix that maps four components to three.
|
|
/// See Appendix 6 of the \ref spec_dng "DNG 1.1.0 specification."
|
|
|
|
void SetReductionMatrix2 (const dng_matrix &m);
|
|
|
|
/// Getter for first of up to two dimensionality reduction hints for four color cameras.
|
|
|
|
const dng_matrix & ReductionMatrix1 () const
|
|
{
|
|
return fReductionMatrix1;
|
|
}
|
|
|
|
/// Getter for second of up to two dimensionality reduction hints for four color cameras.
|
|
|
|
const dng_matrix & ReductionMatrix2 () const
|
|
{
|
|
return fReductionMatrix2;
|
|
}
|
|
|
|
/// Getter function from profile fingerprint.
|
|
|
|
const dng_fingerprint &Fingerprint () const
|
|
{
|
|
|
|
if (!fFingerprint.IsValid ())
|
|
CalculateFingerprint ();
|
|
|
|
return fFingerprint;
|
|
|
|
}
|
|
|
|
/// Getter for camera profile id.
|
|
/// \retval ID of profile.
|
|
|
|
dng_camera_profile_id ProfileID () const
|
|
{
|
|
return dng_camera_profile_id (Name (), Fingerprint ());
|
|
}
|
|
|
|
/// Setter for camera profile copyright.
|
|
/// \param copyright Copyright string to use for this camera profile.
|
|
|
|
void SetCopyright (const char *copyright)
|
|
{
|
|
fCopyright.Set (copyright);
|
|
ClearFingerprint ();
|
|
}
|
|
|
|
/// Getter for camera profile copyright.
|
|
/// \retval Copyright string for profile.
|
|
|
|
const dng_string & Copyright () const
|
|
{
|
|
return fCopyright;
|
|
}
|
|
|
|
// Accessors for embed policy.
|
|
|
|
/// Setter for camera profile embed policy.
|
|
/// \param policy Policy to use for this camera profile.
|
|
|
|
void SetEmbedPolicy (uint32 policy)
|
|
{
|
|
fEmbedPolicy = policy;
|
|
ClearFingerprint ();
|
|
}
|
|
|
|
/// Getter for camera profile embed policy.
|
|
/// \param Policy for profile.
|
|
|
|
uint32 EmbedPolicy () const
|
|
{
|
|
return fEmbedPolicy;
|
|
}
|
|
|
|
/// Returns true iff the profile is legal to embed in a DNG, per the
|
|
/// profile's embed policy.
|
|
|
|
bool IsLegalToEmbed () const
|
|
{
|
|
return WasReadFromDNG () ||
|
|
EmbedPolicy () == pepAllowCopying ||
|
|
EmbedPolicy () == pepEmbedIfUsed ||
|
|
EmbedPolicy () == pepNoRestrictions;
|
|
}
|
|
|
|
// Accessors for hue sat maps.
|
|
|
|
/// Returns true iff the profile has a valid HueSatMap color table.
|
|
|
|
bool HasHueSatDeltas () const
|
|
{
|
|
return fHueSatDeltas1.IsValid ();
|
|
}
|
|
|
|
/// Getter for first HueSatMap color table (for calibration illuminant 1).
|
|
|
|
const dng_hue_sat_map & HueSatDeltas1 () const
|
|
{
|
|
return fHueSatDeltas1;
|
|
}
|
|
|
|
/// Setter for first HueSatMap color table (for calibration illuminant 1).
|
|
|
|
void SetHueSatDeltas1 (const dng_hue_sat_map &deltas1);
|
|
|
|
/// Getter for second HueSatMap color table (for calibration illuminant 2).
|
|
|
|
const dng_hue_sat_map & HueSatDeltas2 () const
|
|
{
|
|
return fHueSatDeltas2;
|
|
}
|
|
|
|
/// Setter for second HueSatMap color table (for calibration illuminant 2).
|
|
|
|
void SetHueSatDeltas2 (const dng_hue_sat_map &deltas2);
|
|
|
|
// Accessors for hue sat map encoding.
|
|
|
|
/// Returns the hue sat map encoding (see ProfileHueSatMapEncoding tag).
|
|
|
|
uint32 HueSatMapEncoding () const
|
|
{
|
|
return fHueSatMapEncoding;
|
|
}
|
|
|
|
/// Sets the hue sat map encoding (see ProfileHueSatMapEncoding tag) to the
|
|
/// specified encoding.
|
|
|
|
void SetHueSatMapEncoding (uint32 encoding)
|
|
{
|
|
fHueSatMapEncoding = encoding;
|
|
ClearFingerprint ();
|
|
}
|
|
|
|
// Accessors for look table.
|
|
|
|
/// Returns true if the profile has a LookTable.
|
|
|
|
bool HasLookTable () const
|
|
{
|
|
return fLookTable.IsValid ();
|
|
}
|
|
|
|
/// Getter for LookTable.
|
|
|
|
const dng_hue_sat_map & LookTable () const
|
|
{
|
|
return fLookTable;
|
|
}
|
|
|
|
/// Setter for LookTable.
|
|
|
|
void SetLookTable (const dng_hue_sat_map &table);
|
|
|
|
// Accessors for look table encoding.
|
|
|
|
/// Returns the LookTable encoding (see ProfileLookTableEncoding tag).
|
|
|
|
uint32 LookTableEncoding () const
|
|
{
|
|
return fLookTableEncoding;
|
|
}
|
|
|
|
/// Sets the LookTable encoding (see ProfileLookTableEncoding tag) to the
|
|
/// specified encoding.
|
|
|
|
void SetLookTableEncoding (uint32 encoding)
|
|
{
|
|
fLookTableEncoding = encoding;
|
|
ClearFingerprint ();
|
|
}
|
|
|
|
// Accessors for baseline exposure offset.
|
|
|
|
/// Sets the baseline exposure offset of the profile (see
|
|
/// BaselineExposureOffset tag) to the specified value.
|
|
|
|
void SetBaselineExposureOffset (real64 exposureOffset)
|
|
{
|
|
fBaselineExposureOffset.Set_real64 (exposureOffset, 100);
|
|
ClearFingerprint ();
|
|
}
|
|
|
|
/// Returns the baseline exposure offset of the profile (see
|
|
/// BaselineExposureOffset tag).
|
|
|
|
const dng_srational & BaselineExposureOffset () const
|
|
{
|
|
return fBaselineExposureOffset;
|
|
}
|
|
|
|
// Accessors for default black render.
|
|
|
|
/// Sets the default black render of the profile (see DefaultBlackRender tag)
|
|
/// to the specified option.
|
|
|
|
void SetDefaultBlackRender (uint32 defaultBlackRender)
|
|
{
|
|
fDefaultBlackRender = defaultBlackRender;
|
|
ClearFingerprint ();
|
|
}
|
|
|
|
/// Returns the default black render of the profile (see DefaultBlackRender
|
|
/// tag).
|
|
|
|
uint32 DefaultBlackRender () const
|
|
{
|
|
return fDefaultBlackRender;
|
|
}
|
|
|
|
// Accessors for tone curve.
|
|
|
|
/// Returns the tone curve of the profile.
|
|
|
|
const dng_tone_curve & ToneCurve () const
|
|
{
|
|
return fToneCurve;
|
|
}
|
|
|
|
/// Sets the tone curve of the profile to the specified curve.
|
|
|
|
void SetToneCurve (const dng_tone_curve &curve)
|
|
{
|
|
fToneCurve = curve;
|
|
ClearFingerprint ();
|
|
}
|
|
|
|
// Accessors for profile calibration signature.
|
|
|
|
/// Sets the profile calibration signature (see ProfileCalibrationSignature
|
|
/// tag) to the specified string.
|
|
|
|
void SetProfileCalibrationSignature (const char *signature)
|
|
{
|
|
fProfileCalibrationSignature.Set (signature);
|
|
}
|
|
|
|
/// Returns the profile calibration signature (see ProfileCalibrationSignature
|
|
/// tag) of the profile.
|
|
|
|
const dng_string & ProfileCalibrationSignature () const
|
|
{
|
|
return fProfileCalibrationSignature;
|
|
}
|
|
|
|
/// Setter for camera unique model name to restrict use of this profile.
|
|
/// \param camera Camera unique model name designating only camera this
|
|
/// profile can be used with. (Empty string for no restriction.)
|
|
|
|
void SetUniqueCameraModelRestriction (const char *camera)
|
|
{
|
|
fUniqueCameraModelRestriction.Set (camera);
|
|
// Not included in fingerprint, so don't need ClearFingerprint ().
|
|
}
|
|
|
|
/// Getter for camera unique model name to restrict use of this profile.
|
|
/// \retval Unique model name of only camera this profile can be used with
|
|
/// or empty if no restriction.
|
|
|
|
const dng_string & UniqueCameraModelRestriction () const
|
|
{
|
|
return fUniqueCameraModelRestriction;
|
|
}
|
|
|
|
// Accessors for was read from DNG flag.
|
|
|
|
/// Sets internal flag to indicate this profile was originally read from a
|
|
/// DNG file.
|
|
|
|
void SetWasReadFromDNG (bool state = true)
|
|
{
|
|
fWasReadFromDNG = state;
|
|
}
|
|
|
|
/// Was this profile read from a DNG?
|
|
|
|
bool WasReadFromDNG () const
|
|
{
|
|
return fWasReadFromDNG;
|
|
}
|
|
|
|
// Accessors for was read from disk flag.
|
|
|
|
/// Sets internal flag to indicate this profile was originally read from
|
|
/// disk.
|
|
|
|
void SetWasReadFromDisk (bool state = true)
|
|
{
|
|
fWasReadFromDisk = state;
|
|
}
|
|
|
|
/// Was this profile read from disk?
|
|
|
|
bool WasReadFromDisk () const
|
|
{
|
|
return fWasReadFromDisk;
|
|
}
|
|
|
|
// Accessors for was built-in matrix flag.
|
|
|
|
/// Sets internal flag to indicate this profile was originally a built-in
|
|
/// matrix profile.
|
|
|
|
void SetWasBuiltinMatrix (bool state = true)
|
|
{
|
|
fWasBuiltinMatrix = state;
|
|
}
|
|
|
|
/// Was this profile a built-in matrix profile?
|
|
|
|
bool WasBuiltinMatrix () const
|
|
{
|
|
return fWasBuiltinMatrix;
|
|
}
|
|
|
|
/// Determines if this a valid profile for this number of color channels?
|
|
/// \retval true if the profile is valid.
|
|
|
|
bool IsValid (uint32 channels) const;
|
|
|
|
/// Predicate to check if two camera profiles are colorwise equal, thus ignores
|
|
/// the profile name.
|
|
/// \param profile Camera profile to compare to.
|
|
|
|
bool EqualData (const dng_camera_profile &profile) const;
|
|
|
|
/// Parse profile from dng_camera_profile_info data.
|
|
|
|
void Parse (dng_stream &stream,
|
|
dng_camera_profile_info &profileInfo);
|
|
|
|
/// Parse from an extended profile stream, which is similar to stand alone
|
|
/// TIFF file.
|
|
|
|
bool ParseExtended (dng_stream &stream);
|
|
|
|
/// Convert from a three-color to a four-color Bayer profile.
|
|
|
|
virtual void SetFourColorBayer ();
|
|
|
|
/// Find the hue/sat table to use for a given white point, if any.
|
|
/// The calling routine owns the resulting table.
|
|
|
|
dng_hue_sat_map * HueSatMapForWhite (const dng_xy_coord &white) const;
|
|
|
|
/// Stub out the profile (free memory used by large tables).
|
|
|
|
void Stub ();
|
|
|
|
/// Was this profile stubbed?
|
|
|
|
bool WasStubbed () const
|
|
{
|
|
return fWasStubbed;
|
|
}
|
|
|
|
protected:
|
|
|
|
static real64 IlluminantToTemperature (uint32 light);
|
|
|
|
void ClearFingerprint ()
|
|
{
|
|
fFingerprint.Clear ();
|
|
}
|
|
|
|
void CalculateFingerprint () const;
|
|
|
|
static bool ValidForwardMatrix (const dng_matrix &m);
|
|
|
|
static void ReadHueSatMap (dng_stream &stream,
|
|
dng_hue_sat_map &hueSatMap,
|
|
uint32 hues,
|
|
uint32 sats,
|
|
uint32 vals,
|
|
bool skipSat0);
|
|
|
|
};
|
|
|
|
/******************************************************************************/
|
|
|
|
void SplitCameraProfileName (const dng_string &name,
|
|
dng_string &baseName,
|
|
int32 &version);
|
|
|
|
/*****************************************************************************/
|
|
|
|
void BuildHueSatMapEncodingTable (dng_memory_allocator &allocator,
|
|
uint32 encoding,
|
|
AutoPtr<dng_1d_table> &encodeTable,
|
|
AutoPtr<dng_1d_table> &decodeTable,
|
|
bool subSample);
|
|
|
|
/******************************************************************************/
|
|
|
|
#endif
|
|
|
|
/******************************************************************************/
|