1/*****************************************************************************/
2// Copyright 2006-2012 Adobe Systems Incorporated
3// All Rights Reserved.
4//
5// NOTICE: Adobe permits you to use, modify, and distribute this file in
6// accordance with the terms of the Adobe license agreement accompanying it.
7/*****************************************************************************/
8
9/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_negative.h#4 $ */
10/* $DateTime: 2012/08/02 06:09:06 $ */
11/* $Change: 841096 $ */
12/* $Author: erichan $ */
13
14/** \file
15 * Functions and classes for working with a digital negative (image data and
16 * corresponding metadata).
17 */
18
19/*****************************************************************************/
20
21#ifndef __dng_negative__
22#define __dng_negative__
23
24/*****************************************************************************/
25
26#include "dng_1d_function.h"
27#include "dng_auto_ptr.h"
28#include "dng_classes.h"
29#include "dng_fingerprint.h"
30#include "dng_image.h"
31#include "dng_linearization_info.h"
32#include "dng_matrix.h"
33#include "dng_memory.h"
34#include "dng_mosaic_info.h"
35#include "dng_opcode_list.h"
36#include "dng_orientation.h"
37#include "dng_rational.h"
38#include "dng_sdk_limits.h"
39#include "dng_string.h"
40#include "dng_tag_types.h"
41#include "dng_tag_values.h"
42#include "dng_types.h"
43#include "dng_utils.h"
44#include "dng_xy_coord.h"
45
46#include <vector>
47
48/*****************************************************************************/
49
50// To prevent using the internal metadata when we meant to use override
51// metadata, the following definitions allow us to only allow access to
52// the internal metadata on non-const negatives. This allows the old API
53// to keep working essentially unchanged provided one does not use const
54// negatives, but will prevent access to the embedded data on const
55// negatives.
56
57#if 1
58
59#define qMetadataOnConst 0
60#define METACONST
61
62#else
63
64#define qMetadataOnConst 1
65#define METACONST const
66
67#endif
68
69/*****************************************************************************/
70
71/// \brief Noise model for photon and sensor read noise, assuming that they are
72/// independent random variables and spatially invariant.
73///
74/// The noise model is N (x) = sqrt (scale*x + offset), where x represents a linear
75/// signal value in the range [0,1], and N (x) is the standard deviation (i.e.,
76/// noise). The parameters scale and offset are both sensor-dependent and
77/// ISO-dependent. scale must be positive, and offset must be non-negative.
78
79class dng_noise_function: public dng_1d_function
80 {
81
82 protected:
83
84 real64 fScale;
85 real64 fOffset;
86
87 public:
88
89 /// Create empty and invalid noise function.
90
91 dng_noise_function ()
92
93 : fScale (0.0)
94 , fOffset (0.0)
95
96 {
97
98 }
99
100 /// Create noise function with the specified scale and offset.
101
102 dng_noise_function (real64 scale,
103 real64 offset)
104
105 : fScale (scale)
106 , fOffset (offset)
107
108 {
109
110 }
111
112 /// Compute noise (standard deviation) at the specified average signal level
113 /// x.
114
115 virtual real64 Evaluate (real64 x) const
116 {
117 return sqrt (fScale * x + fOffset);
118 }
119
120 /// The scale (slope, gain) of the noise function.
121
122 real64 Scale () const
123 {
124 return fScale;
125 }
126
127 /// The offset (square of the noise floor) of the noise function.
128
129 real64 Offset () const
130 {
131 return fOffset;
132 }
133
134 /// Set the scale (slope, gain) of the noise function.
135
136 void SetScale (real64 scale)
137 {
138 fScale = scale;
139 }
140
141 /// Set the offset (square of the noise floor) of the noise function.
142
143 void SetOffset (real64 offset)
144 {
145 fOffset = offset;
146 }
147
148 /// Is the noise function valid?
149
150 bool IsValid () const
151 {
152 return (fScale > 0.0 && fOffset >= 0.0);
153 }
154
155 };
156
157/*****************************************************************************/
158
159/// \brief Noise profile for a negative.
160///
161/// For mosaiced negatives, the noise profile describes the approximate noise
162/// characteristics of a mosaic negative after linearization, but prior to
163/// demosaicing. For demosaiced negatives (i.e., linear DNGs), the noise profile
164/// describes the approximate noise characteristics of the image data immediately
165/// following the demosaic step, prior to the processing of opcode list 3.
166///
167/// A noise profile may contain 1 or N noise functions, where N is the number of
168/// color planes for the negative. Otherwise the noise profile is considered to be
169/// invalid for that negative. If the noise profile contains 1 noise function, then
170/// it is assumed that this single noise function applies to all color planes of the
171/// negative. Otherwise, the N noise functions map to the N planes of the negative in
172/// order specified in the CFAPlaneColor tag.
173
174class dng_noise_profile
175 {
176
177 protected:
178
179 dng_std_vector<dng_noise_function> fNoiseFunctions;
180
181 public:
182
183 /// Create empty (invalid) noise profile.
184
185 dng_noise_profile ();
186
187 /// Create noise profile with the specified noise functions (1 per plane).
188
189 explicit dng_noise_profile (const dng_std_vector<dng_noise_function> &functions);
190
191 /// Is the noise profile valid?
192
193 bool IsValid () const;
194
195 /// Is the noise profile valid for the specified negative?
196
197 bool IsValidForNegative (const dng_negative &negative) const;
198
199 /// The noise function for the specified plane.
200
201 const dng_noise_function & NoiseFunction (uint32 plane) const;
202
203 /// The number of noise functions in this profile.
204
205 uint32 NumFunctions () const;
206
207 };
208
209/*****************************************************************************/
210
211/// \brief Main class for holding metadata.
212
213class dng_metadata
214 {
215
216 private:
217
218 // Base orientation of both the thumbnail and raw data. This is
219 // generally based on the EXIF values.
220
221 bool fHasBaseOrientation;
222
223 dng_orientation fBaseOrientation;
224
225 // Is the maker note safe to copy from file to file? Defaults to false
226 // because many maker notes are not safe.
227
228 bool fIsMakerNoteSafe;
229
230 // MakerNote binary data block.
231
232 AutoPtr<dng_memory_block> fMakerNote;
233
234 // EXIF data.
235
236 AutoPtr<dng_exif> fExif;
237
238 // A copy of the EXIF data before is was synchronized with other metadata sources.
239
240 AutoPtr<dng_exif> fOriginalExif;
241
242 // IPTC binary data block and offset in original file.
243
244 AutoPtr<dng_memory_block> fIPTCBlock;
245
246 uint64 fIPTCOffset;
247
248 // XMP data.
249
250 #if qDNGUseXMP
251
252 AutoPtr<dng_xmp> fXMP;
253
254 #endif
255
256 // If there a valid embedded XMP block, has is its digest? NULL if no valid
257 // embedded XMP.
258
259 dng_fingerprint fEmbeddedXMPDigest;
260
261 // Is the XMP data from a sidecar file?
262
263 bool fXMPinSidecar;
264
265 // If the XMP data is from a sidecar file, is the sidecar file newer
266 // than the raw file?
267
268 bool fXMPisNewer;
269
270 // Source file mimi-type, if known.
271
272 dng_string fSourceMIMI;
273
274 public:
275
276 dng_metadata (dng_host &host);
277
278 dng_metadata (const dng_metadata &rhs,
279 dng_memory_allocator &allocator);
280
281 virtual ~dng_metadata ();
282
283 /// Copy this metadata.
284
285 virtual dng_metadata * Clone (dng_memory_allocator &allocator) const;
286
287 /// Setter for BaseOrientation.
288
289 void SetBaseOrientation (const dng_orientation &orientation);
290
291 /// Has BaseOrientation been set?
292
293 bool HasBaseOrientation () const
294 {
295 return fHasBaseOrientation;
296 }
297
298 /// Getter for BaseOrientation.
299
300 const dng_orientation & BaseOrientation () const
301 {
302 return fBaseOrientation;
303 }
304
305 /// Logically rotates the image by changing the orientation values.
306 /// This will also update the XMP data.
307
308 void ApplyOrientation (const dng_orientation &orientation);
309
310 // API for IPTC metadata:
311
312 void SetIPTC (AutoPtr<dng_memory_block> &block,
313 uint64 offset);
314
315 void SetIPTC (AutoPtr<dng_memory_block> &block);
316
317 void ClearIPTC ();
318
319 const void * IPTCData () const;
320
321 uint32 IPTCLength () const;
322
323 uint64 IPTCOffset () const;
324
325 dng_fingerprint IPTCDigest (bool includePadding = true) const;
326
327 void RebuildIPTC (dng_memory_allocator &allocator,
328 bool padForTIFF);
329
330 // API for MakerNote data:
331
332 void SetMakerNoteSafety (bool safe)
333 {
334 fIsMakerNoteSafe = safe;
335 }
336
337 bool IsMakerNoteSafe () const
338 {
339 return fIsMakerNoteSafe;
340 }
341
342 void SetMakerNote (AutoPtr<dng_memory_block> &block)
343 {
344 fMakerNote.Reset (block.Release ());
345 }
346
347 void ClearMakerNote ()
348 {
349 fIsMakerNoteSafe = false;
350 fMakerNote.Reset ();
351 }
352
353 const void * MakerNoteData () const
354 {
355 return fMakerNote.Get () ? fMakerNote->Buffer ()
356 : NULL;
357 }
358
359 uint32 MakerNoteLength () const
360 {
361 return fMakerNote.Get () ? fMakerNote->LogicalSize ()
362 : 0;
363 }
364
365 // API for EXIF metadata:
366
367 dng_exif * GetExif ()
368 {
369 return fExif.Get ();
370 }
371
372 const dng_exif * GetExif () const
373 {
374 return fExif.Get ();
375 }
376
377 template< class E >
378 E & Exif ();
379
380 template< class E >
381 const E & Exif () const;
382
383 void ResetExif (dng_exif * newExif);
384
385 dng_memory_block * BuildExifBlock (dng_memory_allocator &allocator,
386 const dng_resolution *resolution = NULL,
387 bool includeIPTC = false,
388 const dng_jpeg_preview *thumbnail = NULL) const;
389
390 // API for original EXIF metadata.
391
392 dng_exif * GetOriginalExif ()
393 {
394 return fOriginalExif.Get ();
395 }
396
397 const dng_exif * GetOriginalExif () const
398 {
399 return fOriginalExif.Get ();
400 }
401
402 // API for XMP metadata:
403
404 #if qDNGUseXMP
405
406 bool SetXMP (dng_host &host,
407 const void *buffer,
408 uint32 count,
409 bool xmpInSidecar = false,
410 bool xmpIsNewer = false);
411
412 void SetEmbeddedXMP (dng_host &host,
413 const void *buffer,
414 uint32 count);
415
416 dng_xmp * GetXMP ()
417 {
418 return fXMP.Get ();
419 }
420
421 const dng_xmp * GetXMP () const
422 {
423 return fXMP.Get ();
424 }
425
426 template< class X >
427 X & XMP ();
428
429 template< class X >
430 const X & XMP () const;
431
432 bool XMPinSidecar () const
433 {
434 return fXMPinSidecar;
435 }
436
437 const dng_fingerprint & EmbeddedXMPDigest () const
438 {
439 return fEmbeddedXMPDigest;
440 }
441
442 bool HaveValidEmbeddedXMP () const
443 {
444 return fEmbeddedXMPDigest.IsValid ();
445 }
446
447 void ResetXMP (dng_xmp * newXMP);
448
449 void ResetXMPSidecarNewer (dng_xmp * newXMP, bool inSidecar, bool isNewer );
450
451 #endif
452
453 // Synchronize metadata sources.
454
455 void SynchronizeMetadata ();
456
457 // Routines to update the date/time field in the EXIF and XMP
458 // metadata.
459
460 void UpdateDateTime (const dng_date_time_info &dt);
461
462 void UpdateDateTimeToNow ();
463
464 void UpdateMetadataDateTimeToNow ();
465
466 // Routines to set and get the source file MIMI type.
467
468 void SetSourceMIMI (const char *s)
469 {
470 fSourceMIMI.Set (s);
471 }
472
473 const dng_string & SourceMIMI () const
474 {
475 return fSourceMIMI;
476 }
477
478 };
479
480/*****************************************************************************/
481
482template< class E >
483E & dng_metadata::Exif ()
484 {
485 dng_exif * exif = GetExif ();
486 if (!exif) ThrowProgramError ("EXIF object is NULL.");
487 return dynamic_cast< E & > (*exif);
488 }
489
490/*****************************************************************************/
491
492template< class E >
493const E & dng_metadata::Exif () const
494 {
495 const dng_exif * exif = GetExif ();
496 if (!exif) ThrowProgramError ("EXIF object is NULL.");
497 return dynamic_cast< const E & > (*exif);
498 }
499
500/*****************************************************************************/
501
502#if qDNGUseXMP
503
504template< class X >
505X & dng_metadata::XMP ()
506 {
507 dng_xmp * xmp = GetXMP ();
508 if (!xmp) ThrowProgramError ("XMP object is NULL.");
509 return dynamic_cast< X & > (*xmp);
510 }
511
512/*****************************************************************************/
513
514template< class X >
515const X & dng_metadata::XMP () const
516 {
517 const dng_xmp * xmp = GetXMP ();
518 if (!xmp) ThrowProgramError ("XMP object is NULL.");
519 return dynamic_cast< const X & > (*xmp);
520 }
521
522#endif
523
524/*****************************************************************************/
525
526/// \brief Main class for holding DNG image data and associated metadata.
527
528class dng_negative
529 {
530
531 public:
532
533 enum RawImageStageEnum
534 {
535 rawImageStagePreOpcode1,
536 rawImageStagePostOpcode1,
537 rawImageStagePostOpcode2,
538 rawImageStagePreOpcode3,
539 rawImageStagePostOpcode3,
540 rawImageStageNone
541 };
542
543 protected:
544
545 // The negative stores an associated allocator. It does not do
546 // anything to keep it alive or to release it when the object destructs.
547 // Hence, clients will need to make sure that the allocator's lifespan
548 // encompasses that of the dng_factory object which is generally
549 // directly bound to the dng_negative object.
550
551 dng_memory_allocator &fAllocator;
552
553 // Non-localized ASCII model name.
554
555 dng_string fModelName;
556
557 // Localized UTF-8 model name.
558
559 dng_string fLocalName;
560
561 // The area of raw image that should be included in the final converted
562 // image. This stems from extra pixels around the edges of the sensor
563 // including both the black mask and some additional padding.
564
565 // The default crop can be smaller than the "active" area which includes
566 // the padding but not the black masked pixels.
567
568 dng_urational fDefaultCropSizeH;
569 dng_urational fDefaultCropSizeV;
570
571 dng_urational fDefaultCropOriginH;
572 dng_urational fDefaultCropOriginV;
573
574 // Default user crop, in relative coordinates.
575
576 dng_urational fDefaultUserCropT;
577 dng_urational fDefaultUserCropL;
578 dng_urational fDefaultUserCropB;
579 dng_urational fDefaultUserCropR;
580
581 // Default scale factors. Generally, 1.0 for square pixel cameras. They
582 // can compensate for non-square pixels. The choice of exact values will
583 // generally depend on what the camera does. These are particularly
584 // interesting for the Nikon D1X and the Fuji diamond mosaic.
585
586 dng_urational fDefaultScaleH;
587 dng_urational fDefaultScaleV;
588
589 // Best quality scale factor. Used for the Nikon D1X and Fuji cameras
590 // to force everything to be a scale up rather than scale down. So,
591 // generally this is 1.0 / min (fDefaultScaleH, fDefaultScaleV) but
592 // this isn't used if the scale factors are only slightly different
593 // from 1.0.
594
595 dng_urational fBestQualityScale;
596
597 // Proxy image support. Remember certain sizes for the original image
598 // this proxy was derived from.
599
600 dng_point fOriginalDefaultFinalSize;
601 dng_point fOriginalBestQualityFinalSize;
602
603 dng_urational fOriginalDefaultCropSizeH;
604 dng_urational fOriginalDefaultCropSizeV;
605
606 // Scale factors used in demosaic algorithm (calculated).
607 // Maps raw image coordinates to full image coordinates -- i.e.,
608 // original image coordinates on raw sensor data to coordinates
609 // in fStage3Image which is the output of the interpolation step.
610 // So, if we downsample when interpolating, these numbers get
611 // smaller.
612
613 real64 fRawToFullScaleH;
614 real64 fRawToFullScaleV;
615
616 // Relative amount of noise at ISO 100. This is measured per camera model
617 // based on looking at flat areas of color.
618
619 dng_urational fBaselineNoise;
620
621 // How much noise reduction has already been applied (0.0 to 1.0) to the
622 // the raw image data? 0.0 = none, 1.0 = "ideal" amount--i.e. don't apply any
623 // more by default. 0/0 for unknown.
624
625 dng_urational fNoiseReductionApplied;
626
627 // Amount of noise for this negative (see dng_noise_profile for details).
628
629 dng_noise_profile fNoiseProfile;
630
631 // Zero point for the exposure compensation slider. This reflects how
632 // the manufacturer sets up the camera and its conversions.
633
634 dng_srational fBaselineExposure;
635
636 // Relative amount of sharpening required. This is chosen per camera
637 // model based on how strong the anti-alias filter is on the camera
638 // and the quality of the lenses. This scales the sharpness slider
639 // value.
640
641 dng_urational fBaselineSharpness;
642
643 // Chroma blur radius (or 0/0 for auto). Set to 0/1 to disable
644 // chroma blurring.
645
646 dng_urational fChromaBlurRadius;
647
648 // Anti-alias filter strength (0.0 to 1.0). Used as a hint
649 // to the demosaic algorithms.
650
651 dng_urational fAntiAliasStrength;
652
653 // Linear response limit. The point at which the sensor goes
654 // non-linear and color information becomes unreliable. Used in
655 // the highlight-recovery logic.
656
657 dng_urational fLinearResponseLimit;
658
659 // Scale factor for shadows slider. The Fuji HDR cameras, for example,
660 // need a more sensitive shadow slider.
661
662 dng_urational fShadowScale;
663
664 // Colormetric reference.
665
666 uint32 fColorimetricReference;
667
668 // Number of color channels for this image (e.g. 1, 3, or 4).
669
670 uint32 fColorChannels;
671
672 // Amount by which each channel has already been scaled. Some cameras
673 // have analog amplifiers on the color channels and these can result
674 // in different scalings per channel. This provides some level of
675 // analog white balancing. The Nikon D1 also did digital scaling but
676 // this caused problems with highlight recovery.
677
678 dng_vector fAnalogBalance;
679
680 // The "As Shot" neutral color coordinates in native camera space.
681 // This overrides fCameraWhiteXY if both are specified. This
682 // specifies the values per channel that would result in a neutral
683 // color for the "As Shot" case. This is generally supplied by
684 // the camera.
685
686 dng_vector fCameraNeutral;
687
688 // The "As Shot" white balance xy coordinates. Sometimes this is
689 // supplied by the camera. Sometimes the camera just supplies a name
690 // for the white balance.
691
692 dng_xy_coord fCameraWhiteXY;
693
694 // Individual camera calibrations.
695
696 // Camera data --> camera calibration --> "inverse" of color matrix
697
698 // This will be a 4x4 matrix for a 4-color camera. The defaults are
699 // almost always the identity matrix and for the cases where they
700 // aren't, they are diagonal matrices.
701
702 dng_matrix fCameraCalibration1;
703 dng_matrix fCameraCalibration2;
704
705 // Signature which allows a profile to announce that it is compatible
706 // with these calibration matrices.
707
708 dng_string fCameraCalibrationSignature;
709
710 // List of camera profiles.
711
712 dng_std_vector<dng_camera_profile *> fCameraProfile;
713
714 // "As shot" camera profile name.
715
716 dng_string fAsShotProfileName;
717
718 // Raw image data digests. These are MD5 fingerprints of the raw image data
719 // in the file, computed using a specific algorithms. They can be used
720 // verify the raw data has not been corrupted. The new version is faster
721 // to compute on MP machines, and is used starting with DNG version 1.4.
722
723 mutable dng_fingerprint fRawImageDigest;
724
725 mutable dng_fingerprint fNewRawImageDigest;
726
727 // Raw data unique ID. This is an unique identifer for the actual
728 // raw image data in the file. It can be used to index into caches
729 // for this data.
730
731 mutable dng_fingerprint fRawDataUniqueID;
732
733 // Original raw file name. Just the file name, not the full path.
734
735 dng_string fOriginalRawFileName;
736
737 // Is the original raw file data availaible?
738
739 bool fHasOriginalRawFileData;
740
741 // The compressed original raw file data.
742
743 AutoPtr<dng_memory_block> fOriginalRawFileData;
744
745 // MD5 digest of original raw file data block.
746
747 mutable dng_fingerprint fOriginalRawFileDigest;
748
749 // DNG private data block.
750
751 AutoPtr<dng_memory_block> fDNGPrivateData;
752
753 // Metadata information (XMP, IPTC, EXIF, orientation)
754
755 dng_metadata fMetadata;
756
757 // Information required to linearize and range map the raw data.
758
759 AutoPtr<dng_linearization_info> fLinearizationInfo;
760
761 // Information required to demoasic the raw data.
762
763 AutoPtr<dng_mosaic_info> fMosaicInfo;
764
765 // Opcode list 1. (Applied to stored data)
766
767 dng_opcode_list fOpcodeList1;
768
769 // Opcode list 2. (Applied to range mapped data)
770
771 dng_opcode_list fOpcodeList2;
772
773 // Opcode list 3. (Post demosaic)
774
775 dng_opcode_list fOpcodeList3;
776
777 // Stage 1 image, which is image data stored in a DNG file.
778
779 AutoPtr<dng_image> fStage1Image;
780
781 // Stage 2 image, which is the stage 1 image after it has been
782 // linearized and range mapped.
783
784 AutoPtr<dng_image> fStage2Image;
785
786 // Stage 3 image, which is the stage 2 image after it has been
787 // demosaiced.
788
789 AutoPtr<dng_image> fStage3Image;
790
791 // Additiona gain applied when building the stage 3 image.
792
793 real64 fStage3Gain;
794
795 // Were any approximations (e.g. downsampling, etc.) applied
796 // file reading this image?
797
798 bool fIsPreview;
799
800 // Does the file appear to be damaged?
801
802 bool fIsDamaged;
803
804 // At what processing stage did we grab a copy of raw image data?
805
806 RawImageStageEnum fRawImageStage;
807
808 // The raw image data that we grabbed, if any.
809
810 AutoPtr<dng_image> fRawImage;
811
812 // The floating point bit depth of the raw file, if any.
813
814 uint32 fRawFloatBitDepth;
815
816 // The raw image JPEG data that we grabbed, if any.
817
818 AutoPtr<dng_jpeg_image> fRawJPEGImage;
819
820 // Keep a separate digest for the compressed JPEG data, if any.
821
822 mutable dng_fingerprint fRawJPEGImageDigest;
823
824 // Transparency mask image, if any.
825
826 AutoPtr<dng_image> fTransparencyMask;
827
828 // Grabbed transparency mask, if we are not saving the current mask.
829
830 AutoPtr<dng_image> fRawTransparencyMask;
831
832 // The bit depth for the raw transparancy mask, if known.
833
834 uint32 fRawTransparencyMaskBitDepth;
835
836 // We sometimes need to keep of copy of the stage3 image before
837 // flattening the transparency.
838
839 AutoPtr<dng_image> fUnflattenedStage3Image;
840
841 public:
842
843 virtual ~dng_negative ();
844
845 static dng_negative * Make (dng_host &host);
846
847 /// Provide access to the memory allocator used for this object.
848
849 dng_memory_allocator & Allocator () const
850 {
851 return fAllocator;
852 }
853
854 /// Getter for ModelName.
855
856 void SetModelName (const char *name)
857 {
858 fModelName.Set_ASCII (name);
859 }
860
861 /// Setter for ModelName.
862
863 const dng_string & ModelName () const
864 {
865 return fModelName;
866 }
867
868 /// Setter for LocalName.
869
870 void SetLocalName (const char *name)
871 {
872 fLocalName.Set (name);
873 }
874
875 /// Getter for LocalName.
876
877 const dng_string & LocalName () const
878 {
879 return fLocalName;
880 }
881
882 /// Getter for metadata
883
884 dng_metadata &Metadata ()
885 {
886 return fMetadata;
887 }
888
889 #if qMetadataOnConst
890
891 const dng_metadata &Metadata () const
892 {
893 return fMetadata;
894 }
895
896 #endif // qMetadataOnConst
897
898 /// Make a copy of the internal metadata generally as a basis for further
899 /// changes.
900
901 dng_metadata * CloneInternalMetadata () const;
902
903 protected:
904
905 /// An accessor for the internal metadata that works even when we
906 /// have general access turned off. This is needed to provide
907 /// access to EXIF ISO information.
908
909 const dng_metadata &InternalMetadata () const
910 {
911 return fMetadata;
912 }
913
914 public:
915
916 /// Setter for BaseOrientation.
917
918 void SetBaseOrientation (const dng_orientation &orientation)
919 {
920 Metadata ().SetBaseOrientation (orientation);
921 }
922
923 /// Has BaseOrientation been set?
924
925 bool HasBaseOrientation () METACONST
926 {
927 return Metadata ().HasBaseOrientation ();
928 }
929
930 /// Getter for BaseOrientation.
931
932 const dng_orientation & BaseOrientation () METACONST
933 {
934 return Metadata ().BaseOrientation ();
935 }
936
937 /// Hook to allow SDK host code to add additional rotations.
938
939 virtual dng_orientation ComputeOrientation (const dng_metadata &metadata) const;
940
941 /// For non-const negatives, we simply default to using the metadata attached to the negative.
942
943 dng_orientation Orientation ()
944 {
945 return ComputeOrientation (Metadata ());
946 }
947
948 /// Logically rotates the image by changing the orientation values.
949 /// This will also update the XMP data.
950
951 void ApplyOrientation (const dng_orientation &orientation)
952 {
953 Metadata ().ApplyOrientation (orientation);
954 }
955
956 /// Setter for DefaultCropSize.
957
958 void SetDefaultCropSize (const dng_urational &sizeH,
959 const dng_urational &sizeV)
960 {
961 fDefaultCropSizeH = sizeH;
962 fDefaultCropSizeV = sizeV;
963 }
964
965 /// Setter for DefaultCropSize.
966
967 void SetDefaultCropSize (uint32 sizeH,
968 uint32 sizeV)
969 {
970 SetDefaultCropSize (dng_urational (sizeH, 1),
971 dng_urational (sizeV, 1));
972 }
973
974 /// Getter for DefaultCropSize horizontal.
975
976 const dng_urational & DefaultCropSizeH () const
977 {
978 return fDefaultCropSizeH;
979 }
980
981 /// Getter for DefaultCropSize vertical.
982
983 const dng_urational & DefaultCropSizeV () const
984 {
985 return fDefaultCropSizeV;
986 }
987
988 /// Setter for DefaultCropOrigin.
989
990 void SetDefaultCropOrigin (const dng_urational &originH,
991 const dng_urational &originV)
992 {
993 fDefaultCropOriginH = originH;
994 fDefaultCropOriginV = originV;
995 }
996
997 /// Setter for DefaultCropOrigin.
998
999 void SetDefaultCropOrigin (uint32 originH,
1000 uint32 originV)
1001 {
1002 SetDefaultCropOrigin (dng_urational (originH, 1),
1003 dng_urational (originV, 1));
1004 }
1005
1006 /// Set default crop around center of image.
1007
1008 void SetDefaultCropCentered (const dng_point &rawSize)
1009 {
1010
1011 uint32 sizeH = Round_uint32 (fDefaultCropSizeH.As_real64 ());
1012 uint32 sizeV = Round_uint32 (fDefaultCropSizeV.As_real64 ());
1013
1014 SetDefaultCropOrigin ((rawSize.h - sizeH) >> 1,
1015 (rawSize.v - sizeV) >> 1);
1016
1017 }
1018
1019 /// Get default crop origin horizontal value.
1020
1021 const dng_urational & DefaultCropOriginH () const
1022 {
1023 return fDefaultCropOriginH;
1024 }
1025
1026 /// Get default crop origin vertical value.
1027
1028 const dng_urational & DefaultCropOriginV () const
1029 {
1030 return fDefaultCropOriginV;
1031 }
1032
1033 /// Getter for top coordinate of default user crop.
1034
1035 const dng_urational & DefaultUserCropT () const
1036 {
1037 return fDefaultUserCropT;
1038 }
1039
1040 /// Getter for left coordinate of default user crop.
1041
1042 const dng_urational & DefaultUserCropL () const
1043 {
1044 return fDefaultUserCropL;
1045 }
1046
1047 /// Getter for bottom coordinate of default user crop.
1048
1049 const dng_urational & DefaultUserCropB () const
1050 {
1051 return fDefaultUserCropB;
1052 }
1053
1054 /// Getter for right coordinate of default user crop.
1055
1056 const dng_urational & DefaultUserCropR () const
1057 {
1058 return fDefaultUserCropR;
1059 }
1060
1061 /// Reset default user crop to default crop area.
1062
1063 void ResetDefaultUserCrop ()
1064 {
1065 fDefaultUserCropT = dng_urational (0, 1);
1066 fDefaultUserCropL = dng_urational (0, 1);
1067 fDefaultUserCropB = dng_urational (1, 1);
1068 fDefaultUserCropR = dng_urational (1, 1);
1069 }
1070
1071 /// Setter for all 4 coordinates of default user crop.
1072
1073 void SetDefaultUserCrop (const dng_urational &t,
1074 const dng_urational &l,
1075 const dng_urational &b,
1076 const dng_urational &r)
1077 {
1078 fDefaultUserCropT = t;
1079 fDefaultUserCropL = l;
1080 fDefaultUserCropB = b;
1081 fDefaultUserCropR = r;
1082 }
1083
1084 /// Setter for top coordinate of default user crop.
1085
1086 void SetDefaultUserCropT (const dng_urational &value)
1087 {
1088 fDefaultUserCropT = value;
1089 }
1090
1091 /// Setter for left coordinate of default user crop.
1092
1093 void SetDefaultUserCropL (const dng_urational &value)
1094 {
1095 fDefaultUserCropL = value;
1096 }
1097
1098 /// Setter for bottom coordinate of default user crop.
1099
1100 void SetDefaultUserCropB (const dng_urational &value)
1101 {
1102 fDefaultUserCropB = value;
1103 }
1104
1105 /// Setter for right coordinate of default user crop.
1106
1107 void SetDefaultUserCropR (const dng_urational &value)
1108 {
1109 fDefaultUserCropR = value;
1110 }
1111
1112 /// Setter for DefaultScale.
1113
1114 void SetDefaultScale (const dng_urational &scaleH,
1115 const dng_urational &scaleV)
1116 {
1117 fDefaultScaleH = scaleH;
1118 fDefaultScaleV = scaleV;
1119 }
1120
1121 /// Get default scale horizontal value.
1122
1123 const dng_urational & DefaultScaleH () const
1124 {
1125 return fDefaultScaleH;
1126 }
1127
1128 /// Get default scale vertical value.
1129
1130 const dng_urational & DefaultScaleV () const
1131 {
1132 return fDefaultScaleV;
1133 }
1134
1135 /// Setter for BestQualityScale.
1136
1137 void SetBestQualityScale (const dng_urational &scale)
1138 {
1139 fBestQualityScale = scale;
1140 }
1141
1142 /// Getter for BestQualityScale.
1143
1144 const dng_urational & BestQualityScale () const
1145 {
1146 return fBestQualityScale;
1147 }
1148
1149 /// API for raw to full image scaling factors horizontal.
1150
1151 real64 RawToFullScaleH () const
1152 {
1153 return fRawToFullScaleH;
1154 }
1155
1156 /// API for raw to full image scaling factors vertical.
1157
1158 real64 RawToFullScaleV () const
1159 {
1160 return fRawToFullScaleV;
1161 }
1162
1163 /// Setter for raw to full scales.
1164
1165 void SetRawToFullScale (real64 scaleH,
1166 real64 scaleV)
1167 {
1168 fRawToFullScaleH = scaleH;
1169 fRawToFullScaleV = scaleV;
1170 }
1171
1172 /// Get default scale factor.
1173 /// When specifing a single scale factor, we use the horizontal
1174 /// scale factor, and let the vertical scale factor be calculated
1175 /// based on the pixel aspect ratio.
1176
1177 real64 DefaultScale () const
1178 {
1179 return DefaultScaleH ().As_real64 ();
1180 }
1181
1182 /// Default cropped image size (at scale == 1.0) width.
1183
1184 real64 SquareWidth () const
1185 {
1186 return DefaultCropSizeH ().As_real64 ();
1187 }
1188
1189 /// Default cropped image size (at scale == 1.0) height.
1190
1191 real64 SquareHeight () const
1192 {
1193 return DefaultCropSizeV ().As_real64 () *
1194 DefaultScaleV ().As_real64 () /
1195 DefaultScaleH ().As_real64 ();
1196 }
1197
1198 /// Default cropped image aspect ratio.
1199
1200 real64 AspectRatio () const
1201 {
1202 return SquareWidth () /
1203 SquareHeight ();
1204 }
1205
1206 /// Pixel aspect ratio of stage 3 image.
1207
1208 real64 PixelAspectRatio () const
1209 {
1210 return (DefaultScaleH ().As_real64 () / RawToFullScaleH ()) /
1211 (DefaultScaleV ().As_real64 () / RawToFullScaleV ());
1212 }
1213
1214 /// Default cropped image size at given scale factor width.
1215
1216 uint32 FinalWidth (real64 scale) const
1217 {
1218 return Round_uint32 (SquareWidth () * scale);
1219 }
1220
1221 /// Default cropped image size at given scale factor height.
1222
1223 uint32 FinalHeight (real64 scale) const
1224 {
1225 return Round_uint32 (SquareHeight () * scale);
1226 }
1227
1228 /// Default cropped image size at default scale factor width.
1229
1230 uint32 DefaultFinalWidth () const
1231 {
1232 return FinalWidth (DefaultScale ());
1233 }
1234
1235 /// Default cropped image size at default scale factor height.
1236
1237 uint32 DefaultFinalHeight () const
1238 {
1239 return FinalHeight (DefaultScale ());
1240 }
1241
1242 /// Get best quality width.
1243 /// For a naive conversion, one could use either the default size,
1244 /// or the best quality size.
1245
1246 uint32 BestQualityFinalWidth () const
1247 {
1248 return FinalWidth (DefaultScale () * BestQualityScale ().As_real64 ());
1249 }
1250
1251 /// Get best quality height.
1252 /// For a naive conversion, one could use either the default size,
1253 /// or the best quality size.
1254
1255 uint32 BestQualityFinalHeight () const
1256 {
1257 return FinalHeight (DefaultScale () * BestQualityScale ().As_real64 ());
1258 }
1259
1260 /// Default size of original (non-proxy) image. For non-proxy images, this
1261 /// is equal to DefaultFinalWidth/DefaultFinalHight. For proxy images, this
1262 /// is equal to the DefaultFinalWidth/DefaultFinalHeight of the image this
1263 /// proxy was derived from.
1264
1265 const dng_point & OriginalDefaultFinalSize () const
1266 {
1267 return fOriginalDefaultFinalSize;
1268 }
1269
1270 /// Setter for OriginalDefaultFinalSize.
1271
1272 void SetOriginalDefaultFinalSize (const dng_point &size)
1273 {
1274 fOriginalDefaultFinalSize = size;
1275 }
1276
1277 /// Best quality size of original (non-proxy) image. For non-proxy images, this
1278 /// is equal to BestQualityFinalWidth/BestQualityFinalHeight. For proxy images, this
1279 /// is equal to the BestQualityFinalWidth/BestQualityFinalHeight of the image this
1280 /// proxy was derived from.
1281
1282 const dng_point & OriginalBestQualityFinalSize () const
1283 {
1284 return fOriginalBestQualityFinalSize;
1285 }
1286
1287 /// Setter for OriginalBestQualityFinalSize.
1288
1289 void SetOriginalBestQualityFinalSize (const dng_point &size)
1290 {
1291 fOriginalBestQualityFinalSize = size;
1292 }
1293
1294 /// DefaultCropSize for original (non-proxy) image. For non-proxy images,
1295 /// this is equal to the DefaultCropSize. for proxy images, this is
1296 /// equal size of the DefaultCropSize of the image this proxy was derived from.
1297
1298 const dng_urational & OriginalDefaultCropSizeH () const
1299 {
1300 return fOriginalDefaultCropSizeH;
1301 }
1302
1303 const dng_urational & OriginalDefaultCropSizeV () const
1304 {
1305 return fOriginalDefaultCropSizeV;
1306 }
1307
1308 /// Setter for OriginalDefaultCropSize.
1309
1310 void SetOriginalDefaultCropSize (const dng_urational &sizeH,
1311 const dng_urational &sizeV)
1312 {
1313 fOriginalDefaultCropSizeH = sizeH;
1314 fOriginalDefaultCropSizeV = sizeV;
1315 }
1316
1317 /// If the original size fields are undefined, set them to the
1318 /// current sizes.
1319
1320 void SetDefaultOriginalSizes ();
1321
1322 /// The default crop area in the stage 3 image coordinates.
1323
1324 dng_rect DefaultCropArea () const;
1325
1326 /// Setter for BaselineNoise.
1327
1328 void SetBaselineNoise (real64 noise)
1329 {
1330 fBaselineNoise.Set_real64 (noise, 100);
1331 }
1332
1333 /// Getter for BaselineNoise as dng_urational.
1334
1335 const dng_urational & BaselineNoiseR () const
1336 {
1337 return fBaselineNoise;
1338 }
1339
1340 /// Getter for BaselineNoise as real64.
1341
1342 real64 BaselineNoise () const
1343 {
1344 return fBaselineNoise.As_real64 ();
1345 }
1346
1347 /// Setter for NoiseReductionApplied.
1348
1349 void SetNoiseReductionApplied (const dng_urational &value)
1350 {
1351 fNoiseReductionApplied = value;
1352 }
1353
1354 /// Getter for NoiseReductionApplied.
1355
1356 const dng_urational & NoiseReductionApplied () const
1357 {
1358 return fNoiseReductionApplied;
1359 }
1360
1361 /// Setter for noise profile.
1362
1363 void SetNoiseProfile (const dng_noise_profile &noiseProfile)
1364 {
1365 fNoiseProfile = noiseProfile;
1366 }
1367
1368 /// Does this negative have a valid noise profile?
1369
1370 bool HasNoiseProfile () const
1371 {
1372 return fNoiseProfile.IsValidForNegative (*this);
1373 }
1374
1375 /// Getter for noise profile.
1376
1377 const dng_noise_profile & NoiseProfile () const
1378 {
1379 return fNoiseProfile;
1380 }
1381
1382 /// Setter for BaselineExposure.
1383
1384 void SetBaselineExposure (real64 exposure)
1385 {
1386 fBaselineExposure.Set_real64 (exposure, 100);
1387 }
1388
1389 /// Getter for BaselineExposure as dng_urational.
1390
1391 const dng_srational & BaselineExposureR () const
1392 {
1393 return fBaselineExposure;
1394 }
1395
1396 /// Getter for BaselineExposure as real64.
1397
1398 real64 BaselineExposure () const
1399 {
1400 return BaselineExposureR ().As_real64 ();
1401 }
1402
1403 /// Compute total baseline exposure (sum of negative's BaselineExposure and
1404 /// profile's BaselineExposureOffset).
1405
1406 real64 TotalBaselineExposure (const dng_camera_profile_id &profileID) const;
1407
1408 /// Setter for BaselineSharpness.
1409
1410 void SetBaselineSharpness (real64 sharpness)
1411 {
1412 fBaselineSharpness.Set_real64 (sharpness, 100);
1413 }
1414
1415 /// Getter for BaselineSharpness as dng_urational.
1416
1417 const dng_urational & BaselineSharpnessR () const
1418 {
1419 return fBaselineSharpness;
1420 }
1421
1422 /// Getter for BaselineSharpness as real64.
1423
1424 real64 BaselineSharpness () const
1425 {
1426 return BaselineSharpnessR ().As_real64 ();
1427 }
1428
1429 /// Setter for ChromaBlurRadius.
1430
1431 void SetChromaBlurRadius (const dng_urational &radius)
1432 {
1433 fChromaBlurRadius = radius;
1434 }
1435
1436 /// Getter for ChromaBlurRadius as dng_urational.
1437
1438 const dng_urational & ChromaBlurRadius () const
1439 {
1440 return fChromaBlurRadius;
1441 }
1442
1443 /// Setter for AntiAliasStrength.
1444
1445 void SetAntiAliasStrength (const dng_urational &strength)
1446 {
1447 fAntiAliasStrength = strength;
1448 }
1449
1450 /// Getter for AntiAliasStrength as dng_urational.
1451
1452 const dng_urational & AntiAliasStrength () const
1453 {
1454 return fAntiAliasStrength;
1455 }
1456
1457 /// Setter for LinearResponseLimit.
1458
1459 void SetLinearResponseLimit (real64 limit)
1460 {
1461 fLinearResponseLimit.Set_real64 (limit, 100);
1462 }
1463
1464 /// Getter for LinearResponseLimit as dng_urational.
1465
1466 const dng_urational & LinearResponseLimitR () const
1467 {
1468 return fLinearResponseLimit;
1469 }
1470
1471 /// Getter for LinearResponseLimit as real64.
1472
1473 real64 LinearResponseLimit () const
1474 {
1475 return LinearResponseLimitR ().As_real64 ();
1476 }
1477
1478 /// Setter for ShadowScale.
1479
1480 void SetShadowScale (const dng_urational &scale);
1481
1482 /// Getter for ShadowScale as dng_urational.
1483
1484 const dng_urational & ShadowScaleR () const
1485 {
1486 return fShadowScale;
1487 }
1488
1489 /// Getter for ShadowScale as real64.
1490
1491 real64 ShadowScale () const
1492 {
1493 return ShadowScaleR ().As_real64 ();
1494 }
1495
1496 // API for ColorimetricReference.
1497
1498 void SetColorimetricReference (uint32 ref)
1499 {
1500 fColorimetricReference = ref;
1501 }
1502
1503 uint32 ColorimetricReference () const
1504 {
1505 return fColorimetricReference;
1506 }
1507
1508 /// Setter for ColorChannels.
1509
1510 void SetColorChannels (uint32 channels)
1511 {
1512 fColorChannels = channels;
1513 }
1514
1515 /// Getter for ColorChannels.
1516
1517 uint32 ColorChannels () const
1518 {
1519 return fColorChannels;
1520 }
1521
1522 /// Setter for Monochrome.
1523
1524 void SetMonochrome ()
1525 {
1526 SetColorChannels (1);
1527 }
1528
1529 /// Getter for Monochrome.
1530
1531 bool IsMonochrome () const
1532 {
1533 return ColorChannels () == 1;
1534 }
1535
1536 /// Setter for AnalogBalance.
1537
1538 void SetAnalogBalance (const dng_vector &b);
1539
1540 /// Getter for AnalogBalance as dng_urational.
1541
1542 dng_urational AnalogBalanceR (uint32 channel) const;
1543
1544 /// Getter for AnalogBalance as real64.
1545
1546 real64 AnalogBalance (uint32 channel) const;
1547
1548 /// Setter for CameraNeutral.
1549
1550 void SetCameraNeutral (const dng_vector &n);
1551
1552 /// Clear CameraNeutral.
1553
1554 void ClearCameraNeutral ()
1555 {
1556 fCameraNeutral.Clear ();
1557 }
1558
1559 /// Determine if CameraNeutral has been set but not cleared.
1560
1561 bool HasCameraNeutral () const
1562 {
1563 return fCameraNeutral.NotEmpty ();
1564 }
1565
1566 /// Getter for CameraNeutral.
1567
1568 const dng_vector & CameraNeutral () const
1569 {
1570 return fCameraNeutral;
1571 }
1572
1573 dng_urational CameraNeutralR (uint32 channel) const;
1574
1575 /// Setter for CameraWhiteXY.
1576
1577 void SetCameraWhiteXY (const dng_xy_coord &coord);
1578
1579 bool HasCameraWhiteXY () const
1580 {
1581 return fCameraWhiteXY.IsValid ();
1582 }
1583
1584 const dng_xy_coord & CameraWhiteXY () const;
1585
1586 void GetCameraWhiteXY (dng_urational &x,
1587 dng_urational &y) const;
1588
1589 // API for camera calibration:
1590
1591 /// Setter for first of up to two color matrices used for individual camera calibrations.
1592 ///
1593 /// The sequence of matrix transforms is:
1594 /// Camera data --> camera calibration --> "inverse" of color matrix
1595 ///
1596 /// This will be a 4x4 matrix for a four-color camera. The defaults are
1597 /// almost always the identity matrix, and for the cases where they
1598 /// aren't, they are diagonal matrices.
1599
1600 void SetCameraCalibration1 (const dng_matrix &m);
1601
1602 /// Setter for second of up to two color matrices used for individual camera calibrations.
1603 ///
1604 /// The sequence of matrix transforms is:
1605 /// Camera data --> camera calibration --> "inverse" of color matrix
1606 ///
1607 /// This will be a 4x4 matrix for a four-color camera. The defaults are
1608 /// almost always the identity matrix, and for the cases where they
1609 /// aren't, they are diagonal matrices.
1610
1611 void SetCameraCalibration2 (const dng_matrix &m);
1612
1613 /// Getter for first of up to two color matrices used for individual camera calibrations.
1614
1615 const dng_matrix & CameraCalibration1 () const
1616 {
1617 return fCameraCalibration1;
1618 }
1619
1620 /// Getter for second of up to two color matrices used for individual camera calibrations.
1621
1622 const dng_matrix & CameraCalibration2 () const
1623 {
1624 return fCameraCalibration2;
1625 }
1626
1627 void SetCameraCalibrationSignature (const char *signature)
1628 {
1629 fCameraCalibrationSignature.Set (signature);
1630 }
1631
1632 const dng_string & CameraCalibrationSignature () const
1633 {
1634 return fCameraCalibrationSignature;
1635 }
1636
1637 // Camera Profile API:
1638
1639 void AddProfile (AutoPtr<dng_camera_profile> &profile);
1640
1641 void ClearProfiles ();
1642
1643 void ClearProfiles (bool clearBuiltinMatrixProfiles,
1644 bool clearReadFromDisk);
1645
1646 uint32 ProfileCount () const;
1647
1648 const dng_camera_profile & ProfileByIndex (uint32 index) const;
1649
1650 virtual const dng_camera_profile * ProfileByID (const dng_camera_profile_id &id,
1651 bool useDefaultIfNoMatch = true) const;
1652
1653 bool HasProfileID (const dng_camera_profile_id &id) const
1654 {
1655 return ProfileByID (id, false) != NULL;
1656 }
1657
1658 // Returns the camera profile to embed when saving to DNG:
1659
1660 virtual const dng_camera_profile * ComputeCameraProfileToEmbed
1661 (const dng_metadata &metadata) const;
1662
1663 // For non-const negatives, we can use the embedded metadata.
1664
1665 const dng_camera_profile * CameraProfileToEmbed ()
1666 {
1667 return ComputeCameraProfileToEmbed (Metadata ());
1668 }
1669
1670 // API for AsShotProfileName.
1671
1672 void SetAsShotProfileName (const char *name)
1673 {
1674 fAsShotProfileName.Set (name);
1675 }
1676
1677 const dng_string & AsShotProfileName () const
1678 {
1679 return fAsShotProfileName;
1680 }
1681
1682 // Makes a dng_color_spec object for this negative.
1683
1684 virtual dng_color_spec * MakeColorSpec (const dng_camera_profile_id &id) const;
1685
1686 // Compute a MD5 hash on an image, using a fixed algorithm.
1687 // The results must be stable across different hardware, OSes,
1688 // and software versions.
1689
1690 dng_fingerprint FindImageDigest (dng_host &host,
1691 const dng_image &image) const;
1692
1693 // API for RawImageDigest and NewRawImageDigest:
1694
1695 void SetRawImageDigest (const dng_fingerprint &digest)
1696 {
1697 fRawImageDigest = digest;
1698 }
1699
1700 void SetNewRawImageDigest (const dng_fingerprint &digest)
1701 {
1702 fNewRawImageDigest = digest;
1703 }
1704
1705 void ClearRawImageDigest () const
1706 {
1707 fRawImageDigest .Clear ();
1708 fNewRawImageDigest.Clear ();
1709 }
1710
1711 const dng_fingerprint & RawImageDigest () const
1712 {
1713 return fRawImageDigest;
1714 }
1715
1716 const dng_fingerprint & NewRawImageDigest () const
1717 {
1718 return fNewRawImageDigest;
1719 }
1720
1721 void FindRawImageDigest (dng_host &host) const;
1722
1723 void FindNewRawImageDigest (dng_host &host) const;
1724
1725 void ValidateRawImageDigest (dng_host &host);
1726
1727 // API for RawDataUniqueID:
1728
1729 void SetRawDataUniqueID (const dng_fingerprint &id)
1730 {
1731 fRawDataUniqueID = id;
1732 }
1733
1734 const dng_fingerprint & RawDataUniqueID () const
1735 {
1736 return fRawDataUniqueID;
1737 }
1738
1739 void FindRawDataUniqueID (dng_host &host) const;
1740
1741 void RecomputeRawDataUniqueID (dng_host &host);
1742
1743 // API for original raw file name:
1744
1745 void SetOriginalRawFileName (const char *name)
1746 {
1747 fOriginalRawFileName.Set (name);
1748 }
1749
1750 bool HasOriginalRawFileName () const
1751 {
1752 return fOriginalRawFileName.NotEmpty ();
1753 }
1754
1755 const dng_string & OriginalRawFileName () const
1756 {
1757 return fOriginalRawFileName;
1758 }
1759
1760 // API for original raw file data:
1761
1762 void SetHasOriginalRawFileData (bool hasData)
1763 {
1764 fHasOriginalRawFileData = hasData;
1765 }
1766
1767 bool CanEmbedOriginalRaw () const
1768 {
1769 return fHasOriginalRawFileData && HasOriginalRawFileName ();
1770 }
1771
1772 void SetOriginalRawFileData (AutoPtr<dng_memory_block> &data)
1773 {
1774 fOriginalRawFileData.Reset (data.Release ());
1775 }
1776
1777 const void * OriginalRawFileData () const
1778 {
1779 return fOriginalRawFileData.Get () ? fOriginalRawFileData->Buffer ()
1780 : NULL;
1781 }
1782
1783 uint32 OriginalRawFileDataLength () const
1784 {
1785 return fOriginalRawFileData.Get () ? fOriginalRawFileData->LogicalSize ()
1786 : 0;
1787 }
1788
1789 // API for original raw file data digest.
1790
1791 void SetOriginalRawFileDigest (const dng_fingerprint &digest)
1792 {
1793 fOriginalRawFileDigest = digest;
1794 }
1795
1796 const dng_fingerprint & OriginalRawFileDigest () const
1797 {
1798 return fOriginalRawFileDigest;
1799 }
1800
1801 void FindOriginalRawFileDigest () const;
1802
1803 void ValidateOriginalRawFileDigest ();
1804
1805 // API for DNG private data:
1806
1807 void SetPrivateData (AutoPtr<dng_memory_block> &block)
1808 {
1809 fDNGPrivateData.Reset (block.Release ());
1810 }
1811
1812 void ClearPrivateData ()
1813 {
1814 fDNGPrivateData.Reset ();
1815 }
1816
1817 const uint8 * PrivateData () const
1818 {
1819 return fDNGPrivateData.Get () ? fDNGPrivateData->Buffer_uint8 ()
1820 : NULL;
1821 }
1822
1823 uint32 PrivateLength () const
1824 {
1825 return fDNGPrivateData.Get () ? fDNGPrivateData->LogicalSize ()
1826 : 0;
1827 }
1828
1829 // API for MakerNote data:
1830
1831 void SetMakerNoteSafety (bool safe)
1832 {
1833 Metadata ().SetMakerNoteSafety (safe);
1834 }
1835
1836 bool IsMakerNoteSafe () METACONST
1837 {
1838 return Metadata ().IsMakerNoteSafe ();
1839 }
1840
1841 void SetMakerNote (AutoPtr<dng_memory_block> &block)
1842 {
1843 Metadata ().SetMakerNote (block);
1844 }
1845
1846 void ClearMakerNote ()
1847 {
1848 Metadata ().ClearMakerNote ();
1849 }
1850
1851 const void * MakerNoteData () METACONST
1852 {
1853 return Metadata ().MakerNoteData ();
1854 }
1855
1856 uint32 MakerNoteLength () METACONST
1857 {
1858 return Metadata ().MakerNoteLength ();
1859 }
1860
1861 // API for EXIF metadata:
1862
1863 dng_exif * GetExif ()
1864 {
1865 return Metadata ().GetExif ();
1866 }
1867
1868 #if qMetadataOnConst
1869
1870 const dng_exif * GetExif () const
1871 {
1872 return Metadata ().GetExif ();
1873 }
1874
1875 #endif // qMetadataOnConst
1876
1877 void ResetExif (dng_exif * newExif)
1878 {
1879 Metadata ().ResetExif (newExif);
1880 }
1881
1882 // API for original EXIF metadata.
1883
1884 dng_exif * GetOriginalExif ()
1885 {
1886 return Metadata ().GetOriginalExif ();
1887 }
1888
1889 #if qMetadataOnConst
1890
1891 const dng_exif * GetOriginalExif () const
1892 {
1893 return Metadata ().GetOriginalExif ();
1894 }
1895
1896 #endif // qMetadataOnConst
1897
1898 // API for IPTC metadata:
1899
1900 void SetIPTC (AutoPtr<dng_memory_block> &block,
1901 uint64 offset)
1902 {
1903 Metadata ().SetIPTC (block, offset);
1904 }
1905
1906 void SetIPTC (AutoPtr<dng_memory_block> &block)
1907 {
1908 Metadata ().SetIPTC (block);
1909 }
1910
1911 void ClearIPTC ()
1912 {
1913 Metadata ().ClearIPTC ();
1914 }
1915
1916 const void * IPTCData () METACONST
1917 {
1918 return Metadata ().IPTCData ();
1919 }
1920
1921 uint32 IPTCLength () METACONST
1922 {
1923 return Metadata ().IPTCLength ();
1924 }
1925
1926 uint64 IPTCOffset () METACONST
1927 {
1928 return Metadata ().IPTCOffset ();
1929 }
1930
1931 dng_fingerprint IPTCDigest (bool includePadding = true) METACONST
1932 {
1933 return Metadata ().IPTCDigest (includePadding);
1934 }
1935
1936 void RebuildIPTC (bool padForTIFF)
1937 {
1938 Metadata ().RebuildIPTC (Allocator (), padForTIFF);
1939 }
1940
1941 // API for XMP metadata:
1942
1943 #if qDNGUseXMP
1944
1945 bool SetXMP (dng_host &host,
1946 const void *buffer,
1947 uint32 count,
1948 bool xmpInSidecar = false,
1949 bool xmpIsNewer = false)
1950 {
1951 return Metadata ().SetXMP (host,
1952 buffer,
1953 count,
1954 xmpInSidecar,
1955 xmpIsNewer);
1956 }
1957
1958 dng_xmp * GetXMP ()
1959 {
1960 return Metadata ().GetXMP ();
1961 }
1962
1963 #if qMetadataOnConst
1964
1965 const dng_xmp * GetXMP () const
1966 {
1967 return Metadata ().GetXMP ();
1968 }
1969
1970 #endif // qMetadataOnConst
1971
1972 bool XMPinSidecar () METACONST
1973 {
1974 return Metadata ().XMPinSidecar ();
1975 }
1976
1977 void ResetXMP (dng_xmp * newXMP)
1978 {
1979 Metadata ().ResetXMP (newXMP);
1980 }
1981
1982 void ResetXMPSidecarNewer (dng_xmp * newXMP, bool inSidecar, bool isNewer )
1983 {
1984 Metadata ().ResetXMPSidecarNewer (newXMP, inSidecar, isNewer);
1985 }
1986
1987 bool HaveValidEmbeddedXMP () METACONST
1988 {
1989 return Metadata ().HaveValidEmbeddedXMP ();
1990 }
1991
1992 #endif
1993
1994 // API for source MIMI type.
1995
1996 void SetSourceMIMI (const char *s)
1997 {
1998 Metadata ().SetSourceMIMI (s);
1999 }
2000
2001 // API for linearization information:
2002
2003 const dng_linearization_info * GetLinearizationInfo () const
2004 {
2005 return fLinearizationInfo.Get ();
2006 }
2007
2008 void ClearLinearizationInfo ()
2009 {
2010 fLinearizationInfo.Reset ();
2011 }
2012
2013 // Linearization curve. Usually used to increase compression ratios
2014 // by storing the compressed data in a more visually uniform space.
2015 // This is a 16-bit LUT that maps the stored data back to linear.
2016
2017 void SetLinearization (AutoPtr<dng_memory_block> &curve);
2018
2019 // Active area (non-black masked pixels). These pixels are trimmed
2020 // during linearization step.
2021
2022 void SetActiveArea (const dng_rect &area);
2023
2024 // Areas that are known to contain black masked pixels that can
2025 // be used to estimate black levels.
2026
2027 void SetMaskedAreas (uint32 count,
2028 const dng_rect *area);
2029
2030 void SetMaskedArea (const dng_rect &area)
2031 {
2032 SetMaskedAreas (1, &area);
2033 }
2034
2035 // Sensor black level information.
2036
2037 void SetBlackLevel (real64 black,
2038 int32 plane = -1);
2039
2040 void SetQuadBlacks (real64 black0,
2041 real64 black1,
2042 real64 black2,
2043 real64 black3,
2044 int32 plane = -1);
2045
2046 void SetRowBlacks (const real64 *blacks,
2047 uint32 count);
2048
2049 void SetColumnBlacks (const real64 *blacks,
2050 uint32 count);
2051
2052 // Sensor white level information.
2053
2054 uint32 WhiteLevel (uint32 plane = 0) const;
2055
2056 void SetWhiteLevel (uint32 white,
2057 int32 plane = -1);
2058
2059 // API for mosaic information:
2060
2061 const dng_mosaic_info * GetMosaicInfo () const
2062 {
2063 return fMosaicInfo.Get ();
2064 }
2065
2066 void ClearMosaicInfo ()
2067 {
2068 fMosaicInfo.Reset ();
2069 }
2070
2071 // ColorKeys APIs:
2072
2073 void SetColorKeys (ColorKeyCode color0,
2074 ColorKeyCode color1,
2075 ColorKeyCode color2,
2076 ColorKeyCode color3 = colorKeyMaxEnum);
2077
2078 void SetRGB ()
2079 {
2080
2081 SetColorChannels (3);
2082
2083 SetColorKeys (colorKeyRed,
2084 colorKeyGreen,
2085 colorKeyBlue);
2086
2087 }
2088
2089 void SetCMY ()
2090 {
2091
2092 SetColorChannels (3);
2093
2094 SetColorKeys (colorKeyCyan,
2095 colorKeyMagenta,
2096 colorKeyYellow);
2097
2098 }
2099
2100 void SetGMCY ()
2101 {
2102
2103 SetColorChannels (4);
2104
2105 SetColorKeys (colorKeyGreen,
2106 colorKeyMagenta,
2107 colorKeyCyan,
2108 colorKeyYellow);
2109
2110 }
2111
2112 // APIs to set mosaic patterns.
2113
2114 void SetBayerMosaic (uint32 phase);
2115
2116 void SetFujiMosaic (uint32 phase);
2117
2118 void SetFujiMosaic6x6 (uint32 phase);
2119
2120 void SetQuadMosaic (uint32 pattern);
2121
2122 // BayerGreenSplit.
2123
2124 void SetGreenSplit (uint32 split);
2125
2126 // APIs for opcode lists.
2127
2128 const dng_opcode_list & OpcodeList1 () const
2129 {
2130 return fOpcodeList1;
2131 }
2132
2133 dng_opcode_list & OpcodeList1 ()
2134 {
2135 return fOpcodeList1;
2136 }
2137
2138 const dng_opcode_list & OpcodeList2 () const
2139 {
2140 return fOpcodeList2;
2141 }
2142
2143 dng_opcode_list & OpcodeList2 ()
2144 {
2145 return fOpcodeList2;
2146 }
2147
2148 const dng_opcode_list & OpcodeList3 () const
2149 {
2150 return fOpcodeList3;
2151 }
2152
2153 dng_opcode_list & OpcodeList3 ()
2154 {
2155 return fOpcodeList3;
2156 }
2157
2158 // First part of parsing logic.
2159
2160 virtual void Parse (dng_host &host,
2161 dng_stream &stream,
2162 dng_info &info);
2163
2164 // Second part of parsing logic. This is split off from the
2165 // first part because these operations are useful when extending
2166 // this sdk to support non-DNG raw formats.
2167
2168 virtual void PostParse (dng_host &host,
2169 dng_stream &stream,
2170 dng_info &info);
2171
2172 // Synchronize metadata sources.
2173
2174 void SynchronizeMetadata ()
2175 {
2176 Metadata ().SynchronizeMetadata ();
2177 }
2178
2179 // Routines to update the date/time field in the EXIF and XMP
2180 // metadata.
2181
2182 void UpdateDateTime (const dng_date_time_info &dt)
2183 {
2184 Metadata ().UpdateDateTime (dt);
2185 }
2186
2187 void UpdateDateTimeToNow ()
2188 {
2189 Metadata ().UpdateDateTimeToNow ();
2190 }
2191
2192 // Developer's utility function to switch to four color Bayer
2193 // interpolation. This is useful for evaluating how much green
2194 // split a Bayer pattern sensor has.
2195
2196 virtual bool SetFourColorBayer ();
2197
2198 // Access routines for the image stages.
2199
2200 const dng_image * Stage1Image () const
2201 {
2202 return fStage1Image.Get ();
2203 }
2204
2205 const dng_image * Stage2Image () const
2206 {
2207 return fStage2Image.Get ();
2208 }
2209
2210 const dng_image * Stage3Image () const
2211 {
2212 return fStage3Image.Get ();
2213 }
2214
2215 // Returns the processing stage of the raw image data.
2216
2217 RawImageStageEnum RawImageStage () const
2218 {
2219 return fRawImageStage;
2220 }
2221
2222 // Returns the raw image data.
2223
2224 const dng_image & RawImage () const;
2225
2226 // API for raw floating point bit depth.
2227
2228 uint32 RawFloatBitDepth () const
2229 {
2230 return fRawFloatBitDepth;
2231 }
2232
2233 void SetRawFloatBitDepth (uint32 bitDepth)
2234 {
2235 fRawFloatBitDepth = bitDepth;
2236 }
2237
2238 // API for raw jpeg image.
2239
2240 const dng_jpeg_image * RawJPEGImage () const;
2241
2242 void SetRawJPEGImage (AutoPtr<dng_jpeg_image> &jpegImage);
2243
2244 void ClearRawJPEGImage ();
2245
2246 // API for RawJPEGImageDigest:
2247
2248 void SetRawJPEGImageDigest (const dng_fingerprint &digest)
2249 {
2250 fRawJPEGImageDigest = digest;
2251 }
2252
2253 void ClearRawJPEGImageDigest () const
2254 {
2255 fRawJPEGImageDigest.Clear ();
2256 }
2257
2258 const dng_fingerprint & RawJPEGImageDigest () const
2259 {
2260 return fRawJPEGImageDigest;
2261 }
2262
2263 void FindRawJPEGImageDigest (dng_host &host) const;
2264
2265 // Read the stage 1 image.
2266
2267 virtual void ReadStage1Image (dng_host &host,
2268 dng_stream &stream,
2269 dng_info &info);
2270
2271 // Assign the stage 1 image.
2272
2273 void SetStage1Image (AutoPtr<dng_image> &image);
2274
2275 // Assign the stage 2 image.
2276
2277 void SetStage2Image (AutoPtr<dng_image> &image);
2278
2279 // Assign the stage 3 image.
2280
2281 void SetStage3Image (AutoPtr<dng_image> &image);
2282
2283 // Build the stage 2 (linearized and range mapped) image.
2284
2285 void BuildStage2Image (dng_host &host);
2286
2287 // Build the stage 3 (demosaiced) image.
2288
2289 void BuildStage3Image (dng_host &host,
2290 int32 srcPlane = -1);
2291
2292 // Additional gain applied when building the stage 3 image.
2293
2294 void SetStage3Gain (real64 gain)
2295 {
2296 fStage3Gain = gain;
2297 }
2298
2299 real64 Stage3Gain () const
2300 {
2301 return fStage3Gain;
2302 }
2303
2304 // Adaptively encode a proxy image down to 8-bits/channel.
2305
2306 dng_image * EncodeRawProxy (dng_host &host,
2307 const dng_image &srcImage,
2308 dng_opcode_list &opcodeList) const;
2309
2310 // Convert to a proxy negative.
2311
2312 void ConvertToProxy (dng_host &host,
2313 dng_image_writer &writer,
2314 uint32 proxySize = 0,
2315 uint64 proxyCount = 0);
2316
2317 // IsPreview API:
2318
2319 void SetIsPreview (bool preview)
2320 {
2321 fIsPreview = preview;
2322 }
2323
2324 bool IsPreview () const
2325 {
2326 return fIsPreview;
2327 }
2328
2329 // IsDamaged API:
2330
2331 void SetIsDamaged (bool damaged)
2332 {
2333 fIsDamaged = damaged;
2334 }
2335
2336 bool IsDamaged () const
2337 {
2338 return fIsDamaged;
2339 }
2340
2341 // Transparancy Mask API:
2342
2343 void SetTransparencyMask (AutoPtr<dng_image> &image,
2344 uint32 bitDepth = 0);
2345
2346 const dng_image * TransparencyMask () const;
2347
2348 const dng_image * RawTransparencyMask () const;
2349
2350 uint32 RawTransparencyMaskBitDepth () const;
2351
2352 void ReadTransparencyMask (dng_host &host,
2353 dng_stream &stream,
2354 dng_info &info);
2355
2356 virtual bool NeedFlattenTransparency (dng_host &host);
2357
2358 virtual void FlattenTransparency (dng_host &host);
2359
2360 const dng_image * UnflattenedStage3Image () const;
2361
2362 protected:
2363
2364 dng_negative (dng_host &host);
2365
2366 virtual void Initialize ();
2367
2368 virtual dng_linearization_info * MakeLinearizationInfo ();
2369
2370 void NeedLinearizationInfo ();
2371
2372 virtual dng_mosaic_info * MakeMosaicInfo ();
2373
2374 void NeedMosaicInfo ();
2375
2376 virtual void DoBuildStage2 (dng_host &host);
2377
2378 virtual void DoPostOpcodeList2 (dng_host &host);
2379
2380 virtual bool NeedDefloatStage2 (dng_host &host);
2381
2382 virtual void DefloatStage2 (dng_host &host);
2383
2384 virtual void DoInterpolateStage3 (dng_host &host,
2385 int32 srcPlane);
2386
2387 virtual void DoMergeStage3 (dng_host &host);
2388
2389 virtual void DoBuildStage3 (dng_host &host,
2390 int32 srcPlane);
2391
2392 virtual void AdjustProfileForStage3 ();
2393
2394 virtual void ResizeTransparencyToMatchStage3 (dng_host &host,
2395 bool convertTo8Bit = false);
2396
2397 };
2398
2399/*****************************************************************************/
2400
2401#endif
2402
2403/*****************************************************************************/
2404