if (!str.isEmpty()) exif->fLensName.Set_ASCII(str.trimmed().toLatin1().constData());
// Canon Markernotes
if (meta.getExifTagLong("Exif.Canon.SerialNumber", val)) exif->fCameraSerialNumber.Set_ASCII((QString::fromUtf8("%1").arg(val)).toLatin1().constData());
/*
if (meta.getExifTagLong("Exif.CanonCs.LensType", val)) exif->fLensID.Set_ASCII((QString::fromUtf8("%1").arg(val)).toLatin1().constData());
if (meta.getExifTagLong("Exif.CanonCs.FlashActivity", val)) exif->fFlash = (uint32)val;
if (meta.getExifTagLong("Exif.CanonFi.FileNumber", val)) exif->fImageNumber = (uint32)val;
if (meta.getExifTagLong("Exif.CanonCs.MaxAperture", val)) exif->fMaxApertureValue = dng_urational(val, 100000);
*/
if (meta.getExifTagLong("Exif.CanonCs.ExposureProgram", val))
{
switch (val)
{
case 1:
exif->fExposureProgram = 2;
break;
case 2:
exif->fExposureProgram = 4;
break;
case 3:
exif->fExposureProgram = 3;
break;
case 4:
exif->fExposureProgram = 1;
break;
default:
break;
}
}
if (meta.getExifTagLong("Exif.CanonCs.MeteringMode", val))
{
switch (val)
{
case 1:
exif->fMeteringMode = 3;
break;
case 2:
exif->fMeteringMode = 1;
break;
case 3:
exif->fMeteringMode = 5;
break;
case 4:
exif->fMeteringMode = 6;
break;
case 5:
exif->fMeteringMode = 2;
break;
default:
break;
}
}
long canonLensUnits = 1;
if (meta.getExifTagRational("Exif.CanonCs.Lens", num, den, 2)) canonLensUnits = num;
if (meta.getExifTagRational("Exif.CanonCs.Lens", num, den, 0)) exif->fLensInfo[1] = dng_urational(num, canonLensUnits);
if (meta.getExifTagRational("Exif.CanonCs.Lens", num, den, 1)) exif->fLensInfo[0] = dng_urational(num, canonLensUnits);
if (meta.getExifTagRational("Exif.Canon.FocalLength", num, den, 1)) exif->fFocalLength = dng_urational(num, canonLensUnits);
long canonLensType = 65535;
if (meta.getExifTagLong("Exif.CanonCs.LensType", canonLensType)) exif->fLensID.Set_ASCII((QString::fromUtf8("%1").arg(canonLensType)).toLatin1().constData());
/// A dng_1d_function that represents the composition (curry) of two other dng_1d_functions.
class dng_1d_concatenate: public dng_1d_function
{
-
+
protected:
-
+
const dng_1d_function &fFunction1;
-
+
const dng_1d_function &fFunction2;
-
+
public:
-
+
/// Create a dng_1d_function which computes y = function2.Evaluate(function1.Evaluate(x)).
/// Compose function1 and function2 to compute y = function2.Evaluate(function1.Evaluate(x)). The range of function1.Evaluate must be a subset of 0.0 to 1.0 inclusive,
/// otherwise the result of function1(x) will be pinned (clipped) to 0.0 if <0.0 and to 1.0 if > 1.0 .
/// \param function1 Inner function of composition.
/// \param function2 Outer function of composition.
/// Be careful using this method with compositions where the inner function does not have a range 0.0 to 1.0 . (Or better yet, do not use such functions.)
/// \param y A value to reverse map. Should be within the range of function2.Evaluate.
/// \retval A value x such that function2.Evaluate(function1.Evaluate(x)) == y (to very close approximation).
-/// \brief Abstract class for rectangular processing operations with support for partitioning across multiple processing resources and observing memory constraints.
- /// Getter for the maximum number of threads (resources) that can be used for processing
+ const char * Name () const
+ {
+ return fName.Get ();
+ }
+
+ /// Getter for the maximum number of threads (resources) that can be
+ /// used for processing
///
/// \retval Number of threads, minimum of 1, that can be used for this task.
virtual uint32 MaxThreads () const
{
return fMaxThreads;
}
/// Getter for minimum area of a partitioned rectangle.
- /// Often it is not profitable to use more resources if it requires partitioning the input into chunks that are too small,
- /// as the overhead increases more than the speedup. This method can be overridden for a specific task to indicate the smallest
- /// area for partitioning. Default is 256x256 pixels.
+ /// Often it is not profitable to use more resources if it requires
+ /// partitioning the input into chunks that are too small, as the
+ /// overhead increases more than the speedup. This method can be
+ /// ovreridden for a specific task to indicate the smallest area for
+ /// partitioning. Default is 256x256 pixels.
///
- /// \retval Minimum area for a partitioned tile in order to give performant operation. (Partitions can be smaller due to small inputs and edge cases.)
+ /// \retval Minimum area for a partitoned tile in order to give performant
+ /// operation. (Partitions can be smaller due to small inputs and edge cases.)
virtual uint32 MinTaskArea () const
{
return fMinTaskArea;
}
/// Getter for dimensions of which partitioned tiles should be a multiple.
- /// Various methods of processing prefer certain alignments. The partitioning attempts to construct tiles such that the
- /// sizes are a multiple of the dimensions of this point.
+ /// Various methods of processing prefer certain alignments. The
+ /// partitioning attempts to construct tiles such that the sizes are a
+ /// multiple of the dimensions of this point.
///
/// \retval a point giving preferred alignment in x and y
virtual dng_point UnitCell () const
{
return fUnitCell;
}
/// Getter for maximum size of a tile for processing.
- /// Often processing will need to allocate temporary buffers or use other resources that are either fixed or in limited supply.
- /// The maximum tile size forces further partitioning if the tile is bigger than this size.
+ /// Often processing will need to allocate temporary buffers or use
+ /// other resources that are either fixed or in limited supply. The
+ /// maximum tile size forces further partitioning if the tile is bigger
+ /// than this size.
///
/// \retval Maximum tile size allowed for this area task.
virtual dng_point MaxTileSize () const
{
return fMaxTileSize;
}
/// Getter for RepeatingTile1.
- /// RepeatingTile1, RepeatingTile2, and RepeatingTile3 are used to establish a set of 0 to 3 tile patterns for which
- /// the resulting partitions that the final Process method is called on will not cross tile boundaries in any of the
- /// tile patterns. This can be used for a processing routine that needs to read from two tiles and write to a third
- /// such that all the tiles are aligned and sized in a certain way. A RepeatingTile value is valid if it is non-empty.
- /// Higher numbered RepeatingTile patterns are only used if all lower ones are non-empty. A RepeatingTile pattern must
- /// be a multiple of UnitCell in size for all constraints of the partitionerr to be met.
+ /// RepeatingTile1, RepeatingTile2, and RepeatingTile3 are used to
+ /// establish a set of 0 to 3 tile patterns for which the resulting
+ /// partitions that the final Process method is called on will not cross
+ /// tile boundaries in any of the tile patterns. This can be used for a
+ /// processing routine that needs to read from two tiles and write to a
+ /// third such that all the tiles are aligned and sized in a certain
+ /// way. A RepeatingTile value is valid if it is non-empty. Higher
+ /// numbered RepeatingTile patterns are only used if all lower ones are
+ /// non-empty. A RepeatingTile pattern must be a multiple of UnitCell in
+ /// size for all constraints of the partitionerr to be met.
virtual dng_rect RepeatingTile1 () const;
-
+
/// Getter for RepeatingTile2.
- /// RepeatingTile1, RepeatingTile2, and RepeatingTile3 are used to establish a set of 0 to 3 tile patterns for which
- /// the resulting partitions that the final Process method is called on will not cross tile boundaries in any of the
- /// tile patterns. This can be used for a processing routine that needs to read from two tiles and write to a third
- /// such that all the tiles are aligned and sized in a certain way. A RepeatingTile value is valid if it is non-empty.
- /// Higher numbered RepeatingTile patterns are only used if all lower ones are non-empty. A RepeatingTile pattern must
- /// be a multiple of UnitCell in size for all constraints of the partitionerr to be met.
+ /// RepeatingTile1, RepeatingTile2, and RepeatingTile3 are used to
+ /// establish a set of 0 to 3 tile patterns for which the resulting
+ /// partitions that the final Process method is called on will not cross
+ /// tile boundaries in any of the tile patterns. This can be used for a
+ /// processing routine that needs to read from two tiles and write to a
+ /// third such that all the tiles are aligned and sized in a certain
+ /// way. A RepeatingTile value is valid if it is non-empty. Higher
+ /// numbered RepeatingTile patterns are only used if all lower ones are
+ /// non-empty. A RepeatingTile pattern must be a multiple of UnitCell in
+ /// size for all constraints of the partitionerr to be met.
virtual dng_rect RepeatingTile2 () const;
/// Getter for RepeatingTile3.
- /// RepeatingTile1, RepeatingTile2, and RepeatingTile3 are used to establish a set of 0 to 3 tile patterns for which
- /// the resulting partitions that the final Process method is called on will not cross tile boundaries in any of the
- /// tile patterns. This can be used for a processing routine that needs to read from two tiles and write to a third
- /// such that all the tiles are aligned and sized in a certain way. A RepeatingTile value is valid if it is non-empty.
- /// Higher numbered RepeatingTile patterns are only used if all lower ones are non-empty. A RepeatingTile pattern must
- /// be a multiple of UnitCell in size for all constraints of the partitionerr to be met.
-
+ /// RepeatingTile1, RepeatingTile2, and RepeatingTile3 are used to
+ /// establish a set of 0 to 3 tile patterns for which the resulting
+ /// partitions that the final Process method is called on will not cross
+ /// tile boundaries in any of the tile patterns. This can be used for a
+ /// processing routine that needs to read from two tiles and write to a
+ /// third such that all the tiles are aligned and sized in a certain
+ /// way. A RepeatingTile value is valid if it is non-empty. Higher
+ /// numbered RepeatingTile patterns are only used if all lower ones are
+ /// non-empty. A RepeatingTile pattern must be a multiple of UnitCell in
+ /// size for all constraints of the partitionerr to be met.
+
virtual dng_rect RepeatingTile3 () const;
/// Task startup method called before any processing is done on partitions.
- /// The Start method is called before any processing is done and can be overridden to allocate temporary buffers, etc.
+ /// The Start method is called before any processing is done and can be
+ /// overridden to allocate temporary buffers, etc.
///
- /// \param threadCount Total number of threads that will be used for processing. Less than or equal to MaxThreads.
- /// \param tileSize Size of source tiles which will be processed. (Not all tiles will be this size due to edge conditions.)
+ /// \param threadCount Total number of threads that will be used for processing.
+ /// Less than or equal to MaxThreads.
+ /// \param dstArea Area to be processed in the current run of the task.
+ /// \param tileSize Size of source tiles which will be processed.
+ /// (Not all tiles will be this size due to edge conditions.)
/// \param allocator dng_memory_allocator to use for allocating temporary buffers, etc.
/// \param sniffer Sniffer to test for user cancellation and to set up progress.
virtual void Start (uint32 threadCount,
+ const dng_rect &dstArea,
const dng_point &tileSize,
dng_memory_allocator *allocator,
dng_abort_sniffer *sniffer);
- /// Process one tile or fully partitioned area.
- /// This method is overridden by derived classes to implement the actual image processing. Note that the sniffer can be ignored if it is certain that a
- /// processing task will complete very quickly.
- /// This method should never be called directly but rather accessed via Process.
- /// There is no allocator parameter as all allocation should be done in Start.
+ /// Process one tile or fully partitioned area. This method is
+ /// overridden by derived classes to implement the actual image
+ /// processing. Note that the sniffer can be ignored if it is certain
+ /// that a processing task will complete very quickly. This method
+ /// should never be called directly but rather accessed via Process.
+ /// There is no allocator parameter as all allocation should be done in
+ /// Start.
///
- /// \param threadIndex 0 to threadCount - 1 index indicating which thread this is. (Can be used to get a thread-specific buffer allocated in the Start method.)
+ /// \param threadIndex 0 to threadCount - 1 index indicating which thread this is.
+ /// (Can be used to get a thread-specific buffer allocated in the Start method.)
/// \param tile Area to process.
- /// \param sniffer dng_abort_sniffer to use to check for user cancellation and progress updates.
+ /// \param sniffer dng_abort_sniffer to use to check for user cancellation
+ /// and progress updates.
virtual void Process (uint32 threadIndex,
const dng_rect &tile,
dng_abort_sniffer *sniffer) = 0;
-
- /// Task computation finalization and teardown method.
- /// Called after all resources have completed processing. Can be overridden to accumulate results and free resources allocated in Start.
+
+ /// Task computation finalization and teardown method. Called after all
+ /// resources have completed processing. Can be overridden to accumulate
+ /// results and free resources allocated in Start.
///
/// \param threadCount Number of threads used for processing. Same as value passed to Start.
virtual void Finish (uint32 threadCount);
/// Find tile size taking into account repeating tiles, unit cell, and maximum tile size.
/// \param area Computation area for which to find tile size.
/// \retval Tile size as height and width in point.
-/// \brief A class intended to be used in stack scope to hold a pointer from new. The held pointer will be deleted automatically if the scope is left without calling Release on the AutoPtr first.
+/// \brief A class intended to be used in stack scope to hold a pointer from new. The
+/// held pointer will be deleted automatically if the scope is left without calling
+/// Release on the AutoPtr first.
template<class T>
-class AutoPtr
+class AutoPtr: private dng_uncopyable
{
-
+
private:
-
+
T *p_;
-
+
public:
/// Construct an AutoPtr with no referent.
AutoPtr () : p_ (0) { }
-
+
/// Construct an AutoPtr which owns the argument pointer.
- /// \param p pointer which constructed AutoPtr takes ownership of. p will be deleted on destruction or Reset unless Release is called first.
+ /// \param p pointer which constructed AutoPtr takes ownership of. p will be
+ /// deleted on destruction or Reset unless Release is called first.
explicit AutoPtr (T *p) : p_( p ) { }
- /// Reset() is called on destruction.
+ /// Reset is called on destruction.
~AutoPtr ();
/// Call Reset with a pointer from new. Uses T's default constructor.
void Alloc ();
- /// Return the owned pointer of this AutoPtr, NULL if none. No change in ownership or other effects occur.
+ /// Return the owned pointer of this AutoPtr, NULL if none. No change in
+ /// ownership or other effects occur.
T *Get () const { return p_; }
- /// Return the owned pointer of this AutoPtr, NULL if none. The AutoPtr gives up ownership and takes NULL as its value.
+ /// Return the owned pointer of this AutoPtr, NULL if none. The AutoPtr gives
+ /// up ownership and takes NULL as its value.
T *Release ();
- /// If a pointer is owned, it is deleted. Ownership is taken of passed in pointer.
+ /// If a pointer is owned, it is deleted. Ownership is taken of passed in
+ /// pointer.
+ /// \param p pointer which constructed AutoPtr takes ownership of. p will be
+ /// deleted on destruction or Reset unless Release is called first.
void Reset (T *p);
- /// If a pointer is owned, it is deleted and the AutoPtr takes NULL as its value.
+ /// If a pointer is owned, it is deleted and the AutoPtr takes NULL as its
+ /// value.
void Reset ();
- /// Allows members of the owned pointer to be accessed directly. It is an error to call this if the AutoPtr has NULL as its value.
+ /// Allows members of the owned pointer to be accessed directly. It is an
+ /// error to call this if the AutoPtr has NULL as its value.
T *operator-> () const { return p_; }
- /// Returns a reference to the object that the owned pointer points to. It is an error to call this if the AutoPtr has NULL as its value.
+ /// Returns a reference to the object that the owned pointer points to. It is
+ /// an error to call this if the AutoPtr has NULL as its value.
T &operator* () const { return *p_; }
-
- private:
-
- // Hidden copy constructor and assignment operator. I don't
- // think the STL "feature" of grabbing ownership of the pointer
- // is a good idea.
-
- AutoPtr (AutoPtr<T> &rhs);
-
- AutoPtr<T> & operator= (AutoPtr<T> &rhs);
-
+
+ /// Swap with another auto ptr.
+
+ friend inline void Swap (AutoPtr< T > &x, AutoPtr< T > &y)
- /// Implements filtering operation from one buffer to another.
- /// Source and destination pixels are set up in member fields of this class.
- /// Ideally, no allocation should be done in this routine.
+ /// Implements filtering operation from one buffer to another. Source and
+ /// destination pixels are set up in member fields of this class. Ideally, no
+ /// allocation should be done in this routine.
+ ///
+ /// \param threadIndex The thread on which this routine is being called,
+ /// between 0 and threadCount - 1 for the threadCount passed to Start method.
///
- /// \param threadIndex The thread on which this routine is being called, between 0 and threadCount - 1 for the threadCount passed to Start method.
/// \param srcBuffer Input area and source pixels.
+ ///
/// \param dstBuffer Output area and destination pixels.
virtual void ProcessArea (uint32 threadIndex,
dng_pixel_buffer &srcBuffer,
dng_pixel_buffer &dstBuffer) = 0;
- /// Called prior to processing on specific threads. Can be used to allocate per-thread memory buffers, etc.
- /// \param threadCount Total number of threads that will be used for processing. Less than or equal to MaxThreads of dng_area_task.
- /// \param tileSize Size of source tiles which will be processed. (Not all tiles will be this size due to edge conditions.)
- /// \param allocator dng_memory_allocator to use for allocating temporary buffers, etc.
- /// \param sniffer Sniffer to test for user cancellation and to set up progress.
+ /// Called prior to processing on specific threads. Can be used to allocate
+ /// per-thread memory buffers, etc.
+ ///
+ /// \param threadCount Total number of threads that will be used for
+ /// processing. Less than or equal to MaxThreads of dng_area_task.
+ ///
+ /// \param tileSize Size of source tiles which will be processed. (Not all
+ /// tiles will be this size due to edge conditions.)
+ ///
+ /// \param allocator dng_memory_allocator to use for allocating temporary
+ /// buffers, etc.
+ ///
+ /// \param sniffer Sniffer to test for user cancellation and to set up
+ /// progress.
virtual void Start (uint32 threadCount,
+ const dng_rect &dstArea,
const dng_point &tileSize,
dng_memory_allocator *allocator,
dng_abort_sniffer *sniffer);
-
- /// Process one tile or partitioned area.
- /// Should not be overridden. Instead, override ProcessArea, which is where to implement filter processing for a specific type of dng_filter_task.
- /// There is no allocator parameter as all allocation should be done in Start.
+
+ /// Process one tile or partitioned area. Should not be overridden. Instead,
+ /// override ProcessArea, which is where to implement filter processing for a
+ /// specific type of dng_filter_task. There is no allocator parameter as all
+ /// allocation should be done in Start.
+ ///
+ /// \param threadIndex 0 to threadCount - 1 index indicating which thread
+ /// this is. (Can be used to get a thread-specific buffer allocated in the
+ /// Start method.)
///
- /// \param threadIndex 0 to threadCount - 1 index indicating which thread this is. (Can be used to get a thread-specific buffer allocated in the Start method.)
- /// \param area Size of tiles to be used for sizing buffers, etc. (Edges of processing can be smaller.)
- /// \param sniffer dng_abort_sniffer to use to check for user cancellation and progress updates.
+ /// \param area Size of tiles to be used for sizing buffers, etc. (Edges of
+ /// processing can be smaller.)
+ ///
+ /// \param sniffer dng_abort_sniffer to use to check for user cancellation
-/// When validation (qValidate) is turned on, this globale enables verbose output about DNG tags and other properties.
+/// When validation (qValidate) is turned on, this global enables verbose
+/// output about DNG tags and other properties.
extern bool gVerbose;
-/// When validation (qValidate) is turned on, and verbose mode (gVerbose) is enabled, limits the number of lines of text that are dumped for each tag.
+/// When validation (qValidate) is turned on, and verbose mode (gVerbose) is
+/// enabled, limits the number of lines of text that are dumped for each tag.
/// \brief Class for managing data values related to DNG linearization.
///
-/// See LinearizationTable, BlackLevel, BlackLevelRepeatDim, BlackLevelDeltaH, BlackLevelDeltaV and WhiteLevel tags in the \ref spec_dng "DNG 1.1.0 specification".
+/// See LinearizationTable, BlackLevel, BlackLevelRepeatDim, BlackLevelDeltaH,
+/// BlackLevelDeltaV and WhiteLevel tags in the \ref spec_dng "DNG 1.1.0 specification".
class dng_linearization_info
{
-
+
public:
/// This rectangle defines the active (non-masked) pixels of the sensor.
/// The order of the rectangle coordinates is: top, left, bottom, right.
dng_rect fActiveArea;
/// Number of rectangles in fMaskedArea
- uint32 fMaskedAreaCount;
+ uint32 fMaskedAreaCount;
/// List of non-overlapping rectangle coordinates of fully masked pixels.
/// Can be optionally used by DNG readers to measure the black encoding level.
/// The order of each rectangle's coordinates is: top, left, bottom, right.
/// If the raw image data has already had its black encoding level subtracted, then this tag should
/// not be used, since the masked pixels are no longer useful.
/// Note that DNG writers are still required to include an estimate and store the black encoding level
/// using the black level DNG tags. Support for the MaskedAreas tag is not required of DNG
/// readers.
dng_rect fMaskedArea [kMaxMaskedAreas];
-
+
/// A lookup table that maps stored values into linear values.
/// This tag is typically used to increase compression ratios by storing the raw data in a non-linear, more
/// visually uniform space with fewer total encoding levels.
/// If SamplesPerPixel is not equal to one, e.g. Fuji S3 type sensor, this single table applies to all the samples for each
/// pixel.
AutoPtr<dng_memory_block> fLinearizationTable;
/// Actual number of rows in fBlackLevel pattern
uint32 fBlackLevelRepeatRows;
/// Actual number of columns in fBlackLevel pattern
uint32 fBlackLevelRepeatCols;
/// Repeating pattern of black level deltas fBlackLevelRepeatRows by fBlackLevelRepeatCols in size.
/// Memory block of double-precision floating point deltas between baseline black level and a given column's black level
AutoPtr<dng_memory_block> fBlackDeltaH;
/// Memory block of double-precision floating point deltas between baseline black level and a given row's black level
AutoPtr<dng_memory_block> fBlackDeltaV;
-
+
/// Single white level (maximum sensor value) for each sample plane.
real64 fWhiteLevel [kMaxSamplesPerPixel];
-
+
protected:
-
+
int32 fBlackDenom;
public:
-
+
dng_linearization_info ();
-
+
virtual ~dng_linearization_info ();
-
+
void RoundBlacks ();
-
+
virtual void Parse (dng_host &host,
dng_stream &stream,
dng_info &info);
-
+
virtual void PostParse (dng_host &host,
dng_negative &negative);
-
- /// Compute the maximum black level for a given sample plane taking into account base black level, repeated black level patter, and row/column delta maps.
+
+ /// Compute the maximum black level for a given sample plane taking into account base
+ /// black level, repeated black level patter, and row/column delta maps.
real64 MaxBlackLevel (uint32 plane) const;
-
+
/// Convert raw data from in-file format to a true linear image using linearization data from DNG.
/// \param host Used to allocate buffers, check for aborts, and post progress updates.
+ /// \param negative Used to remember preserved black point.
/// \param srcImage Input pre-linearization RAW samples.
/// \param dstImage Output linearized image.
virtual void Linearize (dng_host &host,
+ dng_negative &negative,
const dng_image &srcImage,
dng_image &dstImage);
/// Compute black level for one coordinate and sample plane in the image.
/// \param row Row to compute black level for.
/// \param col Column to compute black level for.
/// \param plane Sample plane to compute black level for.
dng_urational BlackLevel (uint32 row,
uint32 col,
uint32 plane) const;
-
+
/// Number of per-row black level deltas in fBlackDeltaV.
uint32 RowBlackCount () const;
/// Lookup black level delta for a given row.
/// \param row Row to get black level for.
/// \retval black level for indicated row.
dng_srational RowBlack (uint32 row) const;
-
+
/// Number of per-column black level deltas in fBlackDeltaV.
+ exif.fLensInfo [j] = dng_urational (n [j], d [j]);
- if (minFL == maxFL)
- sprintf (s, "%.1f mm", minFL);
+ }
- else
- sprintf (s, "%.1f-%.1f mm", minFL, maxFL);
+ }
}
- exif.fLensName.Set (s);
-
- SetString (XMP_NS_AUX,
- "Lens",
- exif.fLensName);
-
}
}
+
+ // Lens name:
+
+ SyncLensName (exif);
// Lens ID:
-
+
SyncString (XMP_NS_AUX,
"LensID",
exif.fLensID,
- options);
+ readOnly);
+
+ // Lens Make:
+
+ if (!SyncString (XMP_NS_EXIF,
+ "LensMake",
+ exif.fLensMake,
+ readOnly + removable))
- // Lens Serial Number:
+ {
+ SyncString (XMP_NS_EXIFEX,
+ "LensMake",
+ exif.fLensMake,
+ readOnly + removable);
+
+ }
+
+ // Lens Serial Number:
+
SyncString (XMP_NS_AUX,
"LensSerialNumber",
exif.fLensSerialNumber,
- options);
-
+ readOnly);
+
// Image Number:
-
- Sync_uint32 (XMP_NS_AUX,
+
+ Sync_uint32 (XMP_NS_AUX,
"ImageNumber",
exif.fImageNumber,
exif.fImageNumber == 0xFFFFFFFF,
- options);
-
+ preferXMP); // CR-4197237: Preserve aux:ImageNumber in XMP when Updating Metadata
+
// User Comment:
-
+
if (exif.fUserComment.NotEmpty ())
{
fSDK->SetAltLangDefault (XMP_NS_EXIF,
"UserComment",
exif.fUserComment);
-
+
}
-
+
else
{
-
+
(void) fSDK->GetAltLangDefault (XMP_NS_EXIF,
"UserComment",
exif.fUserComment);
}
+
+ if (removeFromXMP)
+ {
+ Remove (XMP_NS_EXIF, "UserComment");
+ }
+
+ // Approximate focus distance:
- // Flash Compensation:
+ SyncApproximateFocusDistance (exif,
+ readOnly);
+
+ // LensDistortInfo:
+ {
+
+ dng_string s;
+
+ if (exif.HasLensDistortInfo ())
+ {
+
+ char ss [256];
+
+ sprintf (ss,
+ "%d/%d %d/%d %d/%d %d/%d",
+ (int) exif.fLensDistortInfo [0].n,
+ (int) exif.fLensDistortInfo [0].d,
+ (int) exif.fLensDistortInfo [1].n,
+ (int) exif.fLensDistortInfo [1].d,
+ (int) exif.fLensDistortInfo [2].n,
+ (int) exif.fLensDistortInfo [2].d,
+ (int) exif.fLensDistortInfo [3].n,
+ (int) exif.fLensDistortInfo [3].d);
+
+ s.Set (ss);
+
+ }
+
+ SyncString (XMP_NS_AUX,
+ "LensDistortInfo",
+ s,
+ readOnly);
+
+ if (s.NotEmpty ())
+ {
+
+ int n [4];
+ int d [4];
+
+ if (sscanf (s.Get (),
+ "%d/%d %d/%d %d/%d %d/%d",
+ &n [0],
+ &d [0],
+ &n [1],
+ &d [1],
+ &n [2],
+ &d [2],
+ &n [3],
+ &d [3]) == 8)
+ {
+
+ for (uint32 j = 0; j < 4; j++)
+ {
+
+ exif.fLensDistortInfo [j] = dng_srational (n [j], d [j]);
+
+ }
+
+ }
+
+
+ }
+
+ }
+
+ // Flash Compensation:
+
Sync_srational (XMP_NS_AUX,
"FlashCompensation",
exif.fFlashCompensation,
- options);
-
- // Owner Name:
+ readOnly);
+ // Owner Name: (allow XMP updates)
+
SyncString (XMP_NS_AUX,
"OwnerName",
exif.fOwnerName,
- options);
-
+ preferXMP);
+
// Firmware:
-
+
SyncString (XMP_NS_AUX,
"Firmware",
exif.fFirmware,
- options);
-
+ readOnly);
+
// Image Unique ID:
-
+
{
-
+
dng_string s = EncodeFingerprint (exif.fImageUniqueID);
-
+
SyncString (XMP_NS_EXIF,
"ImageUniqueID",
s,
- options);
-
+ readOnly + removable);
+
exif.fImageUniqueID = DecodeFingerprint (s);
-
+
}
-
+
+ // For the following GPS related fields, we offer an option to prefer XMP to
+ // the EXIF values. This is to allow the host app to modify the XMP for manual
+ // geo-tagging and overwrite the EXIF values during export. It also allows the user
+ // to correct the GPS values via changes in a sidecar XMP file, without modifying
+ // the original GPS data recorded in the raw file by the camera.
+
+ bool preferGPSFromXMP = false;
+
+ uint32 gpsSyncOption = preferNonXMP;
+
+ #if qDNGPreferGPSMetadataFromXMP
+ preferGPSFromXMP = true;
+ #endif
+
+ // Allow EXIF GPS to be updated via updates from XMP.
+
+ if (doingUpdateFromXMP || preferGPSFromXMP)
+ {
+
+ // Require that at least one basic GPS field exist in the
+ // XMP before overrriding the EXIF GPS fields.
+
+ if (Exists (XMP_NS_EXIF, "GPSVersionID" ) ||
+ Exists (XMP_NS_EXIF, "GPSLatitude" ) ||
+ Exists (XMP_NS_EXIF, "GPSLongitude" ) ||
+ Exists (XMP_NS_EXIF, "GPSAltitude" ) ||
+ Exists (XMP_NS_EXIF, "GPSTimeStamp" ) ||
+ Exists (XMP_NS_EXIF, "GPSProcessingMethod"))
+ {
+
+ // Clear out the GPS info from the EXIF so it will
+ // replaced by the GPS info from the XMP.
+
+ dng_exif blankExif;
+
+ exif.CopyGPSFrom (blankExif);
+
+ if (preferGPSFromXMP)
+ {
+
+ gpsSyncOption = preferXMP;
+
+ }
+ }
+
+ }
+
// GPS Version ID:
-
+
{
-
+
dng_string s = EncodeGPSVersion (exif.fGPSVersionID);
-
+
if (SyncString (XMP_NS_EXIF,
"GPSVersionID",
s,
- options))
+ gpsSyncOption + removable))
{
-
+
exif.fGPSVersionID = DecodeGPSVersion (s);
-
+
}
-
+
}
-
+
// GPS Latitude:
-
+
{
-
+
dng_string s = EncodeGPSCoordinate (exif.fGPSLatitudeRef,
exif.fGPSLatitude);
-
+
if (SyncString (XMP_NS_EXIF,
"GPSLatitude",
s,
- options))
+ gpsSyncOption + removable))
{
-
+
DecodeGPSCoordinate (s,
exif.fGPSLatitudeRef,
exif.fGPSLatitude);
-
+
}
-
+
}
-
+
// GPS Longitude:
-
+
{
-
+
dng_string s = EncodeGPSCoordinate (exif.fGPSLongitudeRef,
exif.fGPSLongitude);
-
+
if (SyncString (XMP_NS_EXIF,
"GPSLongitude",
s,
- options))
+ gpsSyncOption + removable))
{
-
+
DecodeGPSCoordinate (s,
exif.fGPSLongitudeRef,
exif.fGPSLongitude);
+
+ }
+
+ }
+
+ // Handle simple case of incorrectly written GPS altitude where someone didn't understand the GPSAltitudeRef and assumed the GPSAltitude RATIONAL is signed.
+ // Only handle this case as we do not want to misinterpret e.g. a fixed point representation of very high GPS altitudes.
+
+ uint32 &altitudeRef = exif.fGPSAltitudeRef;
+ dng_urational &altitude = exif.fGPSAltitude;
+
+ if (altitude.IsValid () &&
+ (altitudeRef == 0 || altitudeRef == 0xFFFFFFFF)) // If the file contains a "below sea level" altitudeRef, assume the writing software is working according to the spec.
+ {
+
+ if ((altitude.n & (1U << 31)) &&
+ altitude.d < 7) // As the denominator increases, large numerator values become possibly valid distances. Pick a limit on the conservative side (approx 33e6m) to prevent misinterpretation.
+ // Noting that the normal case for this mistake has a denominator of 1
+ {
+
+ altitude.n = ~altitude.n + 1;
+ altitudeRef = 1;
}
}
// GPS Altitude Reference:
-
+
Sync_uint32 (XMP_NS_EXIF,
"GPSAltitudeRef",
- exif.fGPSAltitudeRef,
- exif.fGPSAltitudeRef == 0xFFFFFFFF,
- options);
-
+ altitudeRef,
+ altitudeRef == 0xFFFFFFFF,
+ gpsSyncOption + removable);
+
// GPS Altitude:
-
+
Sync_urational (XMP_NS_EXIF,
"GPSAltitude",
- exif.fGPSAltitude,
- options);
-
+ altitude,
+ gpsSyncOption + removable);
+
// GPS Date/Time:
-
+
{
-
+
dng_string s = EncodeGPSDateTime (exif.fGPSDateStamp,
exif.fGPSTimeStamp);
-
+
if (SyncString (XMP_NS_EXIF,
"GPSTimeStamp",
s,
- options))
+ preferNonXMP + removable))
{
-
+
DecodeGPSDateTime (s,
exif.fGPSDateStamp,
exif.fGPSTimeStamp);
-
+
}
-
+
}
-
+
// GPS Satellites:
-
+
SyncString (XMP_NS_EXIF,
"GPSSatellites",
exif.fGPSSatellites,
- options | requireASCII);
-
+ preferNonXMP + removable);
+
// GPS Status:
SyncString (XMP_NS_EXIF,
"GPSStatus",
exif.fGPSStatus,
- options | requireASCII);
-
+ preferNonXMP + removable);
+
// GPS Measure Mode:
-
+
SyncString (XMP_NS_EXIF,
"GPSMeasureMode",
exif.fGPSMeasureMode,
- options | requireASCII);
-
+ preferNonXMP + removable);
+
// GPS DOP:
-
+
Sync_urational (XMP_NS_EXIF,
"GPSDOP",
exif.fGPSDOP,
- options);
-
+ preferNonXMP + removable);
+
// GPS Speed Reference:
-
+
SyncString (XMP_NS_EXIF,
"GPSSpeedRef",
exif.fGPSSpeedRef,
- options | requireASCII);
-
+ preferNonXMP + removable);
+
// GPS Speed:
-
+
Sync_urational (XMP_NS_EXIF,
"GPSSpeed",
exif.fGPSSpeed,
- options);
-
+ preferNonXMP + removable);
+
// GPS Track Reference:
-
+
SyncString (XMP_NS_EXIF,
"GPSTrackRef",
exif.fGPSTrackRef,
- options | requireASCII);
-
+ preferNonXMP + removable);
+
// GPS Track:
-
+
Sync_urational (XMP_NS_EXIF,
"GPSTrack",
exif.fGPSTrack,
- options);
-
+ preferNonXMP + removable);
+
// GPS Image Direction Reference:
-
+
SyncString (XMP_NS_EXIF,
"GPSImgDirectionRef",
exif.fGPSImgDirectionRef,
- options | requireASCII);
-
+ preferNonXMP + removable);
+
// GPS Image Direction:
-
+
Sync_urational (XMP_NS_EXIF,
"GPSImgDirection",
exif.fGPSImgDirection,
- options);
-
+ preferNonXMP + removable);
+
// GPS Map Datum:
-
+
SyncString (XMP_NS_EXIF,
"GPSMapDatum",
exif.fGPSMapDatum,
- options | requireASCII);
-
+ preferNonXMP + removable);
+
// GPS Destination Latitude:
-
+
{
-
+
dng_string s = EncodeGPSCoordinate (exif.fGPSDestLatitudeRef,
exif.fGPSDestLatitude);
-
+
if (SyncString (XMP_NS_EXIF,
"GPSDestLatitude",
s,
- options))
+ preferNonXMP + removable))
{
-
+
DecodeGPSCoordinate (s,
exif.fGPSDestLatitudeRef,
exif.fGPSDestLatitude);
-
+
}
-
+
}
// GPS Destination Longitude:
-
+
{
-
+
dng_string s = EncodeGPSCoordinate (exif.fGPSDestLongitudeRef,
exif.fGPSDestLongitude);
-
+
if (SyncString (XMP_NS_EXIF,
"GPSDestLongitude",
s,
- options))
+ preferNonXMP + removable))
{
-
+
DecodeGPSCoordinate (s,
exif.fGPSDestLongitudeRef,
exif.fGPSDestLongitude);
-
+
}
-
+
}
// GPS Destination Bearing Reference:
-
+
SyncString (XMP_NS_EXIF,
"GPSDestBearingRef",
exif.fGPSDestBearingRef,
- options | requireASCII);
-
+ preferNonXMP + removable);
+
// GPS Destination Bearing:
-
+
Sync_urational (XMP_NS_EXIF,
"GPSDestBearing",
exif.fGPSDestBearing,
- options);
-
+ preferNonXMP + removable);
+
// GPS Destination Distance Reference:
-
+
SyncString (XMP_NS_EXIF,
"GPSDestDistanceRef",
exif.fGPSDestDistanceRef,
- options | requireASCII);
-
+ preferNonXMP + removable);
+
// GPS Destination Distance:
-
+
Sync_urational (XMP_NS_EXIF,
"GPSDestDistance",
exif.fGPSDestDistance,
- options);
-
+ preferNonXMP + removable);
+
// GPS Processing Method:
-
+
SyncString (XMP_NS_EXIF,
"GPSProcessingMethod",
exif.fGPSProcessingMethod,
- options);
-
+ preferNonXMP + removable);
+
// GPS Area Information:
-
+
SyncString (XMP_NS_EXIF,
"GPSAreaInformation",
exif.fGPSAreaInformation,
- options);
-
+ preferNonXMP + removable);
+
// GPS Differential:
-
+
Sync_uint32 (XMP_NS_EXIF,
"GPSDifferential",
exif.fGPSDifferential,
exif.fGPSDifferential == 0xFFFFFFFF,
- options);
-
+ preferNonXMP + removable);
+
+ // GPS Horizontal Positioning Error:
+
+ Sync_urational (XMP_NS_EXIF,
+ "GPSHPositioningError",
+ exif.fGPSHPositioningError,
+ preferNonXMP + removable);
+
+ // Sync date/times.
+
+ UpdateExifDates (exif, removeFromXMP);
+
+ // EXIF 2.3.1 tags.
+
+ Sync_srational (XMP_NS_EXIFEX,
+ "Temperature",
+ exif.fTemperature,
+ readOnly + removable);
+
+ Sync_urational (XMP_NS_EXIFEX,
+ "Humidity",
+ exif.fHumidity,
+ readOnly + removable);
+
+ Sync_urational (XMP_NS_EXIFEX,
+ "Pressure",
+ exif.fPressure,
+ readOnly + removable);
+
+ Sync_srational (XMP_NS_EXIFEX,
+ "WaterDepth",
+ exif.fWaterDepth,
+ readOnly + removable);
+
+ Sync_urational (XMP_NS_EXIFEX,
+ "Acceleration",
+ exif.fAcceleration,
+ readOnly + removable);
+
+ Sync_srational (XMP_NS_EXIFEX,
+ "CameraElevationAngle",
+ exif.fCameraElevationAngle,
+ readOnly + removable);
+
// We are syncing EXIF and XMP, but we are not updating the
// NativeDigest tags. It is better to just delete them than leave
+ // TO DO check in case array node doesn't already exist, and the parent of the array to be created is also an array -currently appending the array at the end of the existing array
+ //! \brief Interface that serves as the base interface for all the externally exposed interfaces which needs to provide client configurable thread safety.
+ //!
+ //! \attention In case client has disabled thread safety at the module level these functions will
+ //! have no use.
+ //! \note By default all the objects created are not thread safe.
+ //!
+ class XMP_PUBLIC IThreadSafe
+ {
+ public:
+
+ //!
+ //! @brief Enables the thread safety on an object.
+ //! @details After calling this function the object can be used across multiple threads.
+ //! | <0 | Either the value of the first character that does not match is lower in the compared string, or all compared characters match but the compared string is shorter. |
+ //! | >0 | Either the value of the first character that does not match is greater in the compared string, or all compared characters match but the compared string is longer. |
+ //! \attention Error is thrown in case
+ //! - pos is greater than the object's length.
+ //!
+ int32 compare( const char * buf ) const {
+ return compare( 0, size(), buf, npos );
+ }
+ //! @brief Compare strings.
+ //! @details Compares the value of the string object (or a substring) to the sequence of characters specified by its
+ //! arguments.
+ //! \param[in] buf pointer to a constant char buffer containing content to be compared. It can be null
+ //! terminated or not. NULL pointer will be treated as empty string.
+ //! \param[in] pos Position of the first character in the compared string. If this is greater than the string
+ //! length, it is treated as empty string.
+ //! \param[in] len Length of compared string (if the string is shorter, as many characters as possible).
+ //! A value of npos indicates all characters until the end of the string.
+ //!
+ //! \return Returns a signed integral indicating the relation between the strings
+ //! | value | relation between compared string and comparing string |
+ //! | <0 | Either the value of the first character that does not match is lower in the compared string, or all compared characters match but the compared string is shorter. |
+ //! | >0 | Either the value of the first character that does not match is greater in the compared string, or all compared characters match but the compared string is longer. |
+ //! | <0 | Either the value of the first character that does not match is lower in the compared string, or all compared characters match but the compared string is shorter. |
+ //! | >0 | Either the value of the first character that does not match is greater in the compared string, or all compared characters match but the compared string is longer. |
+ //! | <0 | Either the value of the first character that does not match is lower in the compared string, or all compared characters match but the compared string is shorter. |
+ //! | >0 | Either the value of the first character that does not match is greater in the compared string, or all compared characters match but the compared string is longer. |
+ //! | <0 | Either the value of the first character that does not match is lower in the compared string, or all compared characters match but the compared string is shorter. |
+ //! | >0 | Either the value of the first character that does not match is greater in the compared string, or all compared characters match but the compared string is longer. |
+ //! @brief Version 1 of the interface that supports parsing by the client supplied parser of the XMP Data Model.
+ //! @details Provides functions to parse the XMP Data Model.
+ //! Thread safety is controllable by the client.
+ //!
+ class XMP_PUBLIC IClientDOMParser_v1
+ {
+ public:
+
+ //!
+ //! @brief Parse the contents present in the buffer taking into account the configuration parameters.
+ //! \param[in] buffer Pointer to a constant char buffer containing serialized XMP Data Model.
+ //! \param[in] bufferLength Number of characters in buffer. In case name is null terminated set it to \#AdobeXMPCommon::npos.
+ //! \param[in] configurationParameters An object of type \#AdobeXMPCommon::IConfigurable containing all the configuration parameters requested by client
+ //! to be taken care of while parsing.
+ //! \param[in] proc A function pointer to be used by the parse operation to report back any encountered errors/warnings.
+ //! \return A shared pointer to \#INode object containing all the parsed XMP Data Model.
+ //! @brief Called by the library when the object is no longer required by it and client can free up the resources or memory associated with the object.
+ //! @brief Version 1 of the interface that supports serializing by the client supplied serializer of the XMP Data Model.
+ //! @details Provides functions to serialize the XMP Data Model.
+ //! Thread safety is controllable by the client.
+ //!
+ class XMP_PUBLIC IClientDOMSerializer_v1
+ {
+ public:
+
+ //!
+ //! @brief Serialize the XMP Data Model taking into account the configuration parameters.
+ //! \param[in] node The node to be serialized.
+ //! \param[in] nameSpacePrefixMap An object of type \#INameSpacePrefixMap which contains preferred prefixes for namespaces.
+ //! \param[in] configurationParameters An object of type #AdobeXMPCommon::IConfigurable containing all the configuration parameters requested by client
+ //! to be taken care of while serializing.
+ //! \param[in] functor A function object to be used by the serializing operation to report back any encountered errors/warnings.
+ //! \param[out] string A shared pointer to an IUTF8String object which should be filled with the serialized form of XMP Data Model.
+ //! @brief Called by the library when the object is no longer required by it and client can free up the resources or memory associated with the object.
+ //! @brief Returns the index of the node in case it is an array item.
+ //! \return The index of the node, in case it is an array item, otherwise returns 0.
+ //!
+ virtual sizet APICALL GetIndex() const = 0;
+
+ //!
+ //! @brief Indicates whether the node has any qualifiers associated with it.
+ //! \return A bool value; true in case the node has any qualifier associated with it, false otherwise.
+ //!
+ virtual bool APICALL HasQualifiers() const = 0;
+
+ //!
+ //! @brief Returns whether the node has any content or not.
+ //! return A bool value indicating the presence of contents in the node apart from qualifiers.
+ //!
+ virtual bool APICALL HasContent() const = 0;
+
+ //!
+ //! @brief Returns whether the node is empty.
+ //! return A bool value indicating whether the contents and qualifiers of a node are empty.
+ //!
+ virtual bool APICALL IsEmpty() const = 0;
+
+ //!
+ //! @brief Returns the status about any change done to the node or its children or qualifiers.
+ //! returns a bool value indicating whether some changes have been performed on the node or its children or qualifiers.
+ //! for a simple node, true will be returned in scenarios like when the node's value or qualifiers are modified.
+ //! for an array node or a structure node, true will be returned in scenarios like when the node's children or the node's qualifiers are modified.
+ //!
+ virtual bool APICALL HasChanged() const = 0;
+
+ //!
+ //! @brief Acknowledges that changes for the node and its children and qualifiers have been taken care of.
+ //! for a simple node, changes that will be acknowledged in scenarios like when the node's value or node's qualifiers were modified.
+ //! for an array node or a structure node, changes will be acknowledged in scenarios like when the node's children were or the node's qualifiers were modified.
+ //! @brief Converts Node to a structure node type, if possible.
+ //! \return Shared pointer to const or non const IStructureNode object. An empty structure node is thrown in case actual node is not a structure node.