• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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.cpp#3 $ */
10 /* $DateTime: 2012/06/14 20:24:41 $ */
11 /* $Change: 835078 $ */
12 /* $Author: tknoll $ */
13 
14 /*****************************************************************************/
15 
16 #include "dng_negative.h"
17 
18 #include "dng_1d_table.h"
19 #include "dng_abort_sniffer.h"
20 #include "dng_area_task.h"
21 #include "dng_assertions.h"
22 #include "dng_bottlenecks.h"
23 #include "dng_camera_profile.h"
24 #include "dng_color_space.h"
25 #include "dng_color_spec.h"
26 #include "dng_exceptions.h"
27 #include "dng_globals.h"
28 #include "dng_host.h"
29 #include "dng_image.h"
30 #include "dng_image_writer.h"
31 #include "dng_info.h"
32 #include "dng_jpeg_image.h"
33 #include "dng_linearization_info.h"
34 #include "dng_memory.h"
35 #include "dng_memory_stream.h"
36 #include "dng_misc_opcodes.h"
37 #include "dng_mosaic_info.h"
38 #include "dng_preview.h"
39 #include "dng_resample.h"
40 #include "dng_safe_arithmetic.h"
41 #include "dng_simple_image.h"
42 #include "dng_tag_codes.h"
43 #include "dng_tag_values.h"
44 #include "dng_tile_iterator.h"
45 #include "dng_utils.h"
46 
47 #if qDNGUseXMP
48 #include "dng_xmp.h"
49 #endif
50 
51 /*****************************************************************************/
52 
dng_noise_profile()53 dng_noise_profile::dng_noise_profile ()
54 
55 	:	fNoiseFunctions ()
56 
57 	{
58 
59 	}
60 
61 /*****************************************************************************/
62 
dng_noise_profile(const dng_std_vector<dng_noise_function> & functions)63 dng_noise_profile::dng_noise_profile (const dng_std_vector<dng_noise_function> &functions)
64 
65 	:	fNoiseFunctions (functions)
66 
67 	{
68 
69 	}
70 
71 /*****************************************************************************/
72 
IsValid() const73 bool dng_noise_profile::IsValid () const
74 	{
75 
76 	if (NumFunctions () == 0 || NumFunctions () > kMaxColorPlanes)
77 		{
78 		return false;
79 		}
80 
81 	for (uint32 plane = 0; plane < NumFunctions (); plane++)
82 		{
83 
84 		if (!NoiseFunction (plane).IsValid ())
85 			{
86 			return false;
87 			}
88 
89 		}
90 
91 	return true;
92 
93 	}
94 
95 /*****************************************************************************/
96 
IsValidForNegative(const dng_negative & negative) const97 bool dng_noise_profile::IsValidForNegative (const dng_negative &negative) const
98 	{
99 
100 	if (!(NumFunctions () == 1 || NumFunctions () == negative.ColorChannels ()))
101 		{
102 		return false;
103 		}
104 
105 	return IsValid ();
106 
107 	}
108 
109 /*****************************************************************************/
110 
NoiseFunction(uint32 plane) const111 const dng_noise_function & dng_noise_profile::NoiseFunction (uint32 plane) const
112 	{
113 
114 	if (NumFunctions () == 1)
115 		{
116 		return fNoiseFunctions.front ();
117 		}
118 
119 	DNG_REQUIRE (plane < NumFunctions (),
120 				 "Bad plane index argument for NoiseFunction ().");
121 
122 	return fNoiseFunctions [plane];
123 
124 	}
125 
126 /*****************************************************************************/
127 
NumFunctions() const128 uint32 dng_noise_profile::NumFunctions () const
129 	{
130 	return (uint32) fNoiseFunctions.size ();
131 	}
132 
133 /*****************************************************************************/
134 
dng_metadata(dng_host & host)135 dng_metadata::dng_metadata (dng_host &host)
136 
137 	:	fHasBaseOrientation 		(false)
138 	,	fBaseOrientation    		()
139 	,	fIsMakerNoteSafe			(false)
140 	,	fMakerNote					()
141 	,	fExif			    		(host.Make_dng_exif ())
142 	,	fOriginalExif				()
143 	,	fIPTCBlock          		()
144 	,	fIPTCOffset					(kDNGStreamInvalidOffset)
145 
146 	#if qDNGUseXMP
147 
148 	,	fXMP			    		(host.Make_dng_xmp ())
149 
150 	#endif
151 
152 	,	fEmbeddedXMPDigest       	()
153 	,	fXMPinSidecar	    		(false)
154 	,	fXMPisNewer		    		(false)
155 	,	fSourceMIMI					()
156 
157 	{
158 	}
159 
160 /*****************************************************************************/
161 
~dng_metadata()162 dng_metadata::~dng_metadata ()
163 	{
164 	}
165 
166 /******************************************************************************/
167 
168 template< class T >
CloneAutoPtr(const AutoPtr<T> & ptr)169 T * CloneAutoPtr (const AutoPtr< T > &ptr)
170 	{
171 
172 	return ptr.Get () ? ptr->Clone () : NULL;
173 
174 	}
175 
176 /******************************************************************************/
177 
178 template< class T, typename U >
CloneAutoPtr(const AutoPtr<T> & ptr,U & u)179 T * CloneAutoPtr (const AutoPtr< T > &ptr, U &u)
180 	{
181 
182 	return ptr.Get () ? ptr->Clone (u) : NULL;
183 
184 	}
185 
186 /******************************************************************************/
187 
dng_metadata(const dng_metadata & rhs,dng_memory_allocator & allocator)188 dng_metadata::dng_metadata (const dng_metadata &rhs,
189 							dng_memory_allocator &allocator)
190 
191 	:	fHasBaseOrientation 		(rhs.fHasBaseOrientation)
192 	,	fBaseOrientation    		(rhs.fBaseOrientation)
193 	,	fIsMakerNoteSafe			(rhs.fIsMakerNoteSafe)
194 	,	fMakerNote					(CloneAutoPtr (rhs.fMakerNote, allocator))
195 	,	fExif			    		(CloneAutoPtr (rhs.fExif))
196 	,	fOriginalExif				(CloneAutoPtr (rhs.fOriginalExif))
197 	,	fIPTCBlock          		(CloneAutoPtr (rhs.fIPTCBlock, allocator))
198 	,	fIPTCOffset					(rhs.fIPTCOffset)
199 
200 	#if qDNGUseXMP
201 
202 	,	fXMP			    		(CloneAutoPtr (rhs.fXMP))
203 
204 	#endif
205 
206 	,	fEmbeddedXMPDigest       	(rhs.fEmbeddedXMPDigest)
207 	,	fXMPinSidecar	    		(rhs.fXMPinSidecar)
208 	,	fXMPisNewer		    		(rhs.fXMPisNewer)
209 	,	fSourceMIMI					(rhs.fSourceMIMI)
210 
211 	{
212 
213 	}
214 
215 /******************************************************************************/
216 
Clone(dng_memory_allocator & allocator) const217 dng_metadata * dng_metadata::Clone (dng_memory_allocator &allocator) const
218 	{
219 
220 	return new dng_metadata (*this, allocator);
221 
222 	}
223 
224 /******************************************************************************/
225 
SetBaseOrientation(const dng_orientation & orientation)226 void dng_metadata::SetBaseOrientation (const dng_orientation &orientation)
227 	{
228 
229 	fHasBaseOrientation = true;
230 
231 	fBaseOrientation = orientation;
232 
233 	}
234 
235 /******************************************************************************/
236 
ApplyOrientation(const dng_orientation & orientation)237 void dng_metadata::ApplyOrientation (const dng_orientation &orientation)
238 	{
239 
240 	fBaseOrientation += orientation;
241 
242 	#if qDNGUseXMP
243 
244 	fXMP->SetOrientation (fBaseOrientation);
245 
246 	#endif
247 
248 	}
249 
250 /*****************************************************************************/
251 
ResetExif(dng_exif * newExif)252 void dng_metadata::ResetExif (dng_exif * newExif)
253 	{
254 
255 	fExif.Reset (newExif);
256 
257 	}
258 
259 /******************************************************************************/
260 
BuildExifBlock(dng_memory_allocator & allocator,const dng_resolution * resolution,bool includeIPTC,const dng_jpeg_preview * thumbnail) const261 dng_memory_block * dng_metadata::BuildExifBlock (dng_memory_allocator &allocator,
262 												 const dng_resolution *resolution,
263 												 bool includeIPTC,
264 												 const dng_jpeg_preview *thumbnail) const
265 	{
266 
267 	dng_memory_stream stream (allocator);
268 
269 		{
270 
271 		// Create the main IFD
272 
273 		dng_tiff_directory mainIFD;
274 
275 		// Optionally include the resolution tags.
276 
277 		dng_resolution res;
278 
279 		if (resolution)
280 			{
281 			res = *resolution;
282 			}
283 
284 		tag_urational tagXResolution (tcXResolution, res.fXResolution);
285 		tag_urational tagYResolution (tcYResolution, res.fYResolution);
286 
287 		tag_uint16 tagResolutionUnit (tcResolutionUnit, res.fResolutionUnit);
288 
289 		if (resolution)
290 			{
291 			mainIFD.Add (&tagXResolution   );
292 			mainIFD.Add (&tagYResolution   );
293 			mainIFD.Add (&tagResolutionUnit);
294 			}
295 
296 		// Optionally include IPTC block.
297 
298 		tag_iptc tagIPTC (IPTCData   (),
299 						  IPTCLength ());
300 
301 		if (includeIPTC && tagIPTC.Count ())
302 			{
303 			mainIFD.Add (&tagIPTC);
304 			}
305 
306 		// Exif tags.
307 
308 		exif_tag_set exifSet (mainIFD,
309 							  *GetExif (),
310 							  IsMakerNoteSafe (),
311 							  MakerNoteData   (),
312 							  MakerNoteLength (),
313 							  false);
314 
315 		// Figure out the Exif IFD offset.
316 
317 		uint32 exifOffset = 8 + mainIFD.Size ();
318 
319 		exifSet.Locate (exifOffset);
320 
321 		// Thumbnail IFD (if any).
322 
323 		dng_tiff_directory thumbIFD;
324 
325 		tag_uint16 thumbCompression (tcCompression, ccOldJPEG);
326 
327 		tag_urational thumbXResolution (tcXResolution, dng_urational (72, 1));
328 		tag_urational thumbYResolution (tcYResolution, dng_urational (72, 1));
329 
330 		tag_uint16 thumbResolutionUnit (tcResolutionUnit, ruInch);
331 
332 		tag_uint32 thumbDataOffset (tcJPEGInterchangeFormat      , 0);
333 		tag_uint32 thumbDataLength (tcJPEGInterchangeFormatLength, 0);
334 
335 		if (thumbnail)
336 			{
337 
338 			thumbIFD.Add (&thumbCompression);
339 
340 			thumbIFD.Add (&thumbXResolution);
341 			thumbIFD.Add (&thumbYResolution);
342 			thumbIFD.Add (&thumbResolutionUnit);
343 
344 			thumbIFD.Add (&thumbDataOffset);
345 			thumbIFD.Add (&thumbDataLength);
346 
347 			thumbDataLength.Set (thumbnail->fCompressedData->LogicalSize ());
348 
349 			uint32 thumbOffset = exifOffset + exifSet.Size ();
350 
351 			mainIFD.SetChained (thumbOffset);
352 
353 			thumbDataOffset.Set (thumbOffset + thumbIFD.Size ());
354 
355 			}
356 
357 		// Don't write anything unless the main IFD has some tags.
358 
359 		if (mainIFD.Size () != 0)
360 			{
361 
362 			// Write TIFF Header.
363 
364 			stream.SetWritePosition (0);
365 
366 			stream.Put_uint16 (stream.BigEndian () ? byteOrderMM : byteOrderII);
367 
368 			stream.Put_uint16 (42);
369 
370 			stream.Put_uint32 (8);
371 
372 			// Write the IFDs.
373 
374 			mainIFD.Put (stream);
375 
376 			exifSet.Put (stream);
377 
378 			if (thumbnail)
379 				{
380 
381 				thumbIFD.Put (stream);
382 
383 				stream.Put (thumbnail->fCompressedData->Buffer      (),
384 							thumbnail->fCompressedData->LogicalSize ());
385 
386 				}
387 
388 			// Trim the file to this length.
389 
390 			stream.Flush ();
391 
392 			stream.SetLength (stream.Position ());
393 
394 			}
395 
396 		}
397 
398 	return stream.AsMemoryBlock (allocator);
399 
400 	}
401 
402 /******************************************************************************/
403 
SetIPTC(AutoPtr<dng_memory_block> & block,uint64 offset)404 void dng_metadata::SetIPTC (AutoPtr<dng_memory_block> &block, uint64 offset)
405 	{
406 
407 	fIPTCBlock.Reset (block.Release ());
408 
409 	fIPTCOffset = offset;
410 
411 	}
412 
413 /******************************************************************************/
414 
SetIPTC(AutoPtr<dng_memory_block> & block)415 void dng_metadata::SetIPTC (AutoPtr<dng_memory_block> &block)
416 	{
417 
418 	SetIPTC (block, kDNGStreamInvalidOffset);
419 
420 	}
421 
422 /******************************************************************************/
423 
ClearIPTC()424 void dng_metadata::ClearIPTC ()
425 	{
426 
427 	fIPTCBlock.Reset ();
428 
429 	fIPTCOffset = kDNGStreamInvalidOffset;
430 
431 	}
432 
433 /*****************************************************************************/
434 
IPTCData() const435 const void * dng_metadata::IPTCData () const
436 	{
437 
438 	if (fIPTCBlock.Get ())
439 		{
440 
441 		return fIPTCBlock->Buffer ();
442 
443 		}
444 
445 	return NULL;
446 
447 	}
448 
449 /*****************************************************************************/
450 
IPTCLength() const451 uint32 dng_metadata::IPTCLength () const
452 	{
453 
454 	if (fIPTCBlock.Get ())
455 		{
456 
457 		return fIPTCBlock->LogicalSize ();
458 
459 		}
460 
461 	return 0;
462 
463 	}
464 
465 /*****************************************************************************/
466 
IPTCOffset() const467 uint64 dng_metadata::IPTCOffset () const
468 	{
469 
470 	if (fIPTCBlock.Get ())
471 		{
472 
473 		return fIPTCOffset;
474 
475 		}
476 
477 	return kDNGStreamInvalidOffset;
478 
479 	}
480 
481 /*****************************************************************************/
482 
IPTCDigest(bool includePadding) const483 dng_fingerprint dng_metadata::IPTCDigest (bool includePadding) const
484 	{
485 
486 	if (IPTCLength ())
487 		{
488 
489 		dng_md5_printer printer;
490 
491 		const uint8 *data = (const uint8 *) IPTCData ();
492 
493 		uint32 count = IPTCLength ();
494 
495 		// Because of some stupid ways of storing the IPTC data, the IPTC
496 		// data might be padded with up to three zeros.  The official Adobe
497 		// logic is to include these zeros in the digest.  However, older
498 		// versions of the Camera Raw code did not include the padding zeros
499 		// in the digest, so we support both methods and allow either to
500 		// match.
501 
502 		if (!includePadding)
503 			{
504 
505 			uint32 removed = 0;
506 
507 			while ((removed < 3) && (count > 0) && (data [count - 1] == 0))
508 				{
509 				removed++;
510 				count--;
511 				}
512 
513 			}
514 
515 		printer.Process (data, count);
516 
517 		return printer.Result ();
518 
519 		}
520 
521 	return dng_fingerprint ();
522 
523 	}
524 
525 /******************************************************************************/
526 
527 #if qDNGUseXMP
528 
RebuildIPTC(dng_memory_allocator & allocator,bool padForTIFF)529 void dng_metadata::RebuildIPTC (dng_memory_allocator &allocator,
530 								bool padForTIFF)
531 	{
532 
533 	ClearIPTC ();
534 
535 	fXMP->RebuildIPTC (*this, allocator, padForTIFF);
536 
537 	dng_fingerprint digest = IPTCDigest ();
538 
539 	fXMP->SetIPTCDigest (digest);
540 
541 	}
542 
543 /*****************************************************************************/
544 
ResetXMP(dng_xmp * newXMP)545 void dng_metadata::ResetXMP (dng_xmp * newXMP)
546 	{
547 
548 	fXMP.Reset (newXMP);
549 
550 	}
551 
552 /*****************************************************************************/
553 
ResetXMPSidecarNewer(dng_xmp * newXMP,bool inSidecar,bool isNewer)554 void dng_metadata::ResetXMPSidecarNewer (dng_xmp * newXMP,
555 										 bool inSidecar,
556 										 bool isNewer )
557 	{
558 
559 	fXMP.Reset (newXMP);
560 
561 	fXMPinSidecar = inSidecar;
562 
563 	fXMPisNewer = isNewer;
564 
565 	}
566 
567 /*****************************************************************************/
568 
SetXMP(dng_host & host,const void * buffer,uint32 count,bool xmpInSidecar,bool xmpIsNewer)569 bool dng_metadata::SetXMP (dng_host &host,
570 						   const void *buffer,
571 					 	   uint32 count,
572 					 	   bool xmpInSidecar,
573 					 	   bool xmpIsNewer)
574 	{
575 
576 	bool result = false;
577 
578 	try
579 		{
580 
581 		AutoPtr<dng_xmp> tempXMP (host.Make_dng_xmp ());
582 
583 		tempXMP->Parse (host, buffer, count);
584 
585 		ResetXMPSidecarNewer (tempXMP.Release (), xmpInSidecar, xmpIsNewer);
586 
587 		result = true;
588 
589 		}
590 
591 	catch (dng_exception &except)
592 		{
593 
594 		// Don't ignore transient errors.
595 
596 		if (host.IsTransientError (except.ErrorCode ()))
597 			{
598 
599 			throw;
600 
601 			}
602 
603 		// Eat other parsing errors.
604 
605 		}
606 
607 	catch (...)
608 		{
609 
610 		// Eat unknown parsing exceptions.
611 
612 		}
613 
614 	return result;
615 
616 	}
617 
618 /*****************************************************************************/
619 
SetEmbeddedXMP(dng_host & host,const void * buffer,uint32 count)620 void dng_metadata::SetEmbeddedXMP (dng_host &host,
621 								   const void *buffer,
622 								   uint32 count)
623 	{
624 
625 	if (SetXMP (host, buffer, count))
626 		{
627 
628 		dng_md5_printer printer;
629 
630 		printer.Process (buffer, count);
631 
632 		fEmbeddedXMPDigest = printer.Result ();
633 
634 		// Remove any sidecar specific tags from embedded XMP.
635 
636 		if (fXMP.Get ())
637 			{
638 
639 			fXMP->Remove (XMP_NS_PHOTOSHOP, "SidecarForExtension");
640 			fXMP->Remove (XMP_NS_PHOTOSHOP, "EmbeddedXMPDigest");
641 
642 			}
643 
644 		}
645 
646 	else
647 		{
648 
649 		fEmbeddedXMPDigest.Clear ();
650 
651 		}
652 
653 	}
654 
655 #endif
656 
657 /*****************************************************************************/
658 
SynchronizeMetadata()659 void dng_metadata::SynchronizeMetadata ()
660 	{
661 
662 	if (!fOriginalExif.Get ())
663 		{
664 
665 		fOriginalExif.Reset (fExif->Clone ());
666 
667 		}
668 
669 	#if qDNGUseXMP
670 
671 	fXMP->ValidateMetadata ();
672 
673 	fXMP->IngestIPTC (*this, fXMPisNewer);
674 
675 	fXMP->SyncExif (*fExif.Get ());
676 
677 	fXMP->SyncOrientation (*this, fXMPinSidecar);
678 
679 	#endif
680 
681 	}
682 
683 /*****************************************************************************/
684 
UpdateDateTime(const dng_date_time_info & dt)685 void dng_metadata::UpdateDateTime (const dng_date_time_info &dt)
686 	{
687 
688 	fExif->UpdateDateTime (dt);
689 
690 #if qDNGUseXMP
691 	fXMP->UpdateDateTime (dt);
692 #endif
693 
694 	}
695 
696 /*****************************************************************************/
697 
UpdateDateTimeToNow()698 void dng_metadata::UpdateDateTimeToNow ()
699 	{
700 
701 	dng_date_time_info dt;
702 
703 	CurrentDateTimeAndZone (dt);
704 
705 	UpdateDateTime (dt);
706 
707 	#if qDNGUseXMP
708 
709 	fXMP->UpdateMetadataDate (dt);
710 
711 	#endif
712 
713 	}
714 
715 /*****************************************************************************/
716 
UpdateMetadataDateTimeToNow()717 void dng_metadata::UpdateMetadataDateTimeToNow ()
718 	{
719 
720 	dng_date_time_info dt;
721 
722 	CurrentDateTimeAndZone (dt);
723 
724 #if qDNGUseXMP
725 	fXMP->UpdateMetadataDate (dt);
726 #endif
727 
728 	}
729 
730 /*****************************************************************************/
731 
dng_negative(dng_host & host)732 dng_negative::dng_negative (dng_host &host)
733 
734 	:	fAllocator						(host.Allocator ())
735 
736 	,	fModelName						()
737 	,	fLocalName						()
738 	,	fDefaultCropSizeH				()
739 	,	fDefaultCropSizeV				()
740 	,	fDefaultCropOriginH				(0, 1)
741 	,	fDefaultCropOriginV				(0, 1)
742 	,	fDefaultUserCropT				(0, 1)
743 	,	fDefaultUserCropL				(0, 1)
744 	,	fDefaultUserCropB				(1, 1)
745 	,	fDefaultUserCropR				(1, 1)
746 	,	fDefaultScaleH					(1, 1)
747 	,	fDefaultScaleV					(1, 1)
748 	,	fBestQualityScale				(1, 1)
749 	,	fOriginalDefaultFinalSize		()
750 	,	fOriginalBestQualityFinalSize	()
751 	,	fOriginalDefaultCropSizeH	    ()
752 	,	fOriginalDefaultCropSizeV	    ()
753 	,	fRawToFullScaleH				(1.0)
754 	,	fRawToFullScaleV				(1.0)
755 	,	fBaselineNoise					(100, 100)
756 	,	fNoiseReductionApplied			(0, 0)
757 	,	fNoiseProfile					()
758 	,	fBaselineExposure				(  0, 100)
759 	,	fBaselineSharpness				(100, 100)
760 	,	fChromaBlurRadius				()
761 	,	fAntiAliasStrength				(100, 100)
762 	,	fLinearResponseLimit			(100, 100)
763 	,	fShadowScale					(1, 1)
764 	,	fColorimetricReference			(crSceneReferred)
765 	,	fColorChannels					(0)
766 	,	fAnalogBalance					()
767 	,	fCameraNeutral					()
768 	,	fCameraWhiteXY					()
769 	,	fCameraCalibration1				()
770 	,	fCameraCalibration2				()
771 	,	fCameraCalibrationSignature		()
772 	,	fCameraProfile					()
773 	,	fAsShotProfileName				()
774 	,	fRawImageDigest					()
775 	,	fNewRawImageDigest				()
776 	,	fRawDataUniqueID				()
777 	,	fOriginalRawFileName			()
778 	,	fHasOriginalRawFileData			(false)
779 	,	fOriginalRawFileData			()
780 	,	fOriginalRawFileDigest			()
781 	,	fDNGPrivateData					()
782 	,	fMetadata						(host)
783 	,	fLinearizationInfo				()
784 	,	fMosaicInfo						()
785 	,	fOpcodeList1					(1)
786 	,	fOpcodeList2					(2)
787 	,	fOpcodeList3					(3)
788 	,	fStage1Image					()
789 	,	fStage2Image					()
790 	,	fStage3Image					()
791 	,	fStage3Gain						(1.0)
792 	,	fIsPreview						(false)
793 	,	fIsDamaged						(false)
794 	,	fRawImageStage					(rawImageStageNone)
795 	,	fRawImage						()
796 	,	fRawFloatBitDepth				(0)
797 	,	fRawJPEGImage					()
798 	,	fRawJPEGImageDigest				()
799 	,	fTransparencyMask				()
800 	,	fRawTransparencyMask			()
801 	,	fRawTransparencyMaskBitDepth	(0)
802 	,	fUnflattenedStage3Image			()
803 
804 	{
805 
806 	}
807 
808 /*****************************************************************************/
809 
~dng_negative()810 dng_negative::~dng_negative ()
811 	{
812 
813 	// Delete any camera profiles owned by this negative.
814 
815 	ClearProfiles ();
816 
817 	}
818 
819 /******************************************************************************/
820 
Initialize()821 void dng_negative::Initialize ()
822 	{
823 
824 	}
825 
826 /******************************************************************************/
827 
Make(dng_host & host)828 dng_negative * dng_negative::Make (dng_host &host)
829 	{
830 
831 	AutoPtr<dng_negative> result (new dng_negative (host));
832 
833 	if (!result.Get ())
834 		{
835 		ThrowMemoryFull ();
836 		}
837 
838 	result->Initialize ();
839 
840 	return result.Release ();
841 
842 	}
843 
844 /******************************************************************************/
845 
CloneInternalMetadata() const846 dng_metadata * dng_negative::CloneInternalMetadata () const
847 	{
848 
849 	return InternalMetadata ().Clone (Allocator ());
850 
851 	}
852 
853 /******************************************************************************/
854 
ComputeOrientation(const dng_metadata & metadata) const855 dng_orientation dng_negative::ComputeOrientation (const dng_metadata &metadata) const
856 	{
857 
858 	return metadata.BaseOrientation ();
859 
860 	}
861 
862 /******************************************************************************/
863 
SetAnalogBalance(const dng_vector & b)864 void dng_negative::SetAnalogBalance (const dng_vector &b)
865 	{
866 
867 	real64 minEntry = b.MinEntry ();
868 
869 	if (b.NotEmpty () && minEntry > 0.0)
870 		{
871 
872 		fAnalogBalance = b;
873 
874 		fAnalogBalance.Scale (1.0 / minEntry);
875 
876 		fAnalogBalance.Round (1000000.0);
877 
878 		}
879 
880 	else
881 		{
882 
883 		fAnalogBalance.Clear ();
884 
885 		}
886 
887 	}
888 
889 /*****************************************************************************/
890 
AnalogBalance(uint32 channel) const891 real64 dng_negative::AnalogBalance (uint32 channel) const
892 	{
893 
894 	DNG_ASSERT (channel < ColorChannels (), "Channel out of bounds");
895 
896 	if (channel < fAnalogBalance.Count ())
897 		{
898 
899 		return fAnalogBalance [channel];
900 
901 		}
902 
903 	return 1.0;
904 
905 	}
906 
907 /*****************************************************************************/
908 
AnalogBalanceR(uint32 channel) const909 dng_urational dng_negative::AnalogBalanceR (uint32 channel) const
910 	{
911 
912 	dng_urational result;
913 
914 	result.Set_real64 (AnalogBalance (channel), 1000000);
915 
916 	return result;
917 
918 	}
919 
920 /******************************************************************************/
921 
SetCameraNeutral(const dng_vector & n)922 void dng_negative::SetCameraNeutral (const dng_vector &n)
923 	{
924 
925 	real64 maxEntry = n.MaxEntry ();
926 
927 	if (n.NotEmpty () && maxEntry > 0.0)
928 		{
929 
930 		fCameraNeutral = n;
931 
932 		fCameraNeutral.Scale (1.0 / maxEntry);
933 
934 		fCameraNeutral.Round (1000000.0);
935 
936 		}
937 
938 	else
939 		{
940 
941 		fCameraNeutral.Clear ();
942 
943 		}
944 
945 	}
946 
947 /*****************************************************************************/
948 
CameraNeutralR(uint32 channel) const949 dng_urational dng_negative::CameraNeutralR (uint32 channel) const
950 	{
951 
952 	dng_urational result;
953 
954 	result.Set_real64 (CameraNeutral () [channel], 1000000);
955 
956 	return result;
957 
958 	}
959 
960 /******************************************************************************/
961 
SetCameraWhiteXY(const dng_xy_coord & coord)962 void dng_negative::SetCameraWhiteXY (const dng_xy_coord &coord)
963 	{
964 
965 	if (coord.IsValid ())
966 		{
967 
968 		fCameraWhiteXY.x = Round_int32 (coord.x * 1000000.0) / 1000000.0;
969 		fCameraWhiteXY.y = Round_int32 (coord.y * 1000000.0) / 1000000.0;
970 
971 		}
972 
973 	else
974 		{
975 
976 		fCameraWhiteXY.Clear ();
977 
978 		}
979 
980 	}
981 
982 /*****************************************************************************/
983 
CameraWhiteXY() const984 const dng_xy_coord & dng_negative::CameraWhiteXY () const
985 	{
986 
987 	DNG_ASSERT (HasCameraWhiteXY (), "Using undefined CameraWhiteXY");
988 
989 	return fCameraWhiteXY;
990 
991 	}
992 
993 /*****************************************************************************/
994 
GetCameraWhiteXY(dng_urational & x,dng_urational & y) const995 void dng_negative::GetCameraWhiteXY (dng_urational &x,
996 							   		 dng_urational &y) const
997 	{
998 
999 	dng_xy_coord coord = CameraWhiteXY ();
1000 
1001 	x.Set_real64 (coord.x, 1000000);
1002 	y.Set_real64 (coord.y, 1000000);
1003 
1004 	}
1005 
1006 /*****************************************************************************/
1007 
SetCameraCalibration1(const dng_matrix & m)1008 void dng_negative::SetCameraCalibration1 (const dng_matrix &m)
1009 	{
1010 
1011 	fCameraCalibration1 = m;
1012 
1013 	fCameraCalibration1.Round (10000);
1014 
1015 	}
1016 
1017 /******************************************************************************/
1018 
SetCameraCalibration2(const dng_matrix & m)1019 void dng_negative::SetCameraCalibration2 (const dng_matrix &m)
1020 	{
1021 
1022 	fCameraCalibration2 = m;
1023 
1024 	fCameraCalibration2.Round (10000);
1025 
1026 	}
1027 
1028 /******************************************************************************/
1029 
AddProfile(AutoPtr<dng_camera_profile> & profile)1030 void dng_negative::AddProfile (AutoPtr<dng_camera_profile> &profile)
1031 	{
1032 
1033 	// Make sure we have a profile to add.
1034 
1035 	if (!profile.Get ())
1036 		{
1037 
1038 		return;
1039 
1040 		}
1041 
1042 	// We must have some profile name.  Use "embedded" if nothing else.
1043 
1044 	if (profile->Name ().IsEmpty ())
1045 		{
1046 
1047 		profile->SetName (kProfileName_Embedded);
1048 
1049 		}
1050 
1051 	// Special case support for reading older DNG files which did not store
1052 	// the profile name in the main IFD profile.
1053 
1054 	if (fCameraProfile.size ())
1055 		{
1056 
1057 		// See the first profile has a default "embedded" name, and has
1058 		// the same data as the profile we are adding.
1059 
1060 		if (fCameraProfile [0]->NameIsEmbedded () &&
1061 			fCameraProfile [0]->EqualData (*profile.Get ()))
1062 			{
1063 
1064 			// If the profile we are deleting was read from DNG
1065 			// then the new profile should be marked as such also.
1066 
1067 			if (fCameraProfile [0]->WasReadFromDNG ())
1068 				{
1069 
1070 				profile->SetWasReadFromDNG ();
1071 
1072 				}
1073 
1074 			// If the profile we are deleting wasn't read from disk then the new
1075 			// profile should be marked as such also.
1076 
1077 			if (!fCameraProfile [0]->WasReadFromDisk ())
1078 				{
1079 
1080 				profile->SetWasReadFromDisk (false);
1081 
1082 				}
1083 
1084 			// Delete the profile with default name.
1085 
1086 			delete fCameraProfile [0];
1087 
1088 			fCameraProfile [0] = NULL;
1089 
1090 			fCameraProfile.erase (fCameraProfile.begin ());
1091 
1092 			}
1093 
1094 		}
1095 
1096 	// Duplicate detection logic.  We give a preference to last added profile
1097 	// so the profiles end up in a more consistent order no matter what profiles
1098 	// happen to be embedded in the DNG.
1099 
1100 	for (uint32 index = 0; index < (uint32) fCameraProfile.size (); index++)
1101 		{
1102 
1103 		// Instead of checking for matching fingerprints, we check that the two
1104 		// profiles have the same color and have the same name. This allows two
1105 		// profiles that are identical except for copyright string and embed policy
1106 		// to be considered duplicates.
1107 
1108 		const bool equalColorAndSameName = (fCameraProfile [index]->EqualData (*profile.Get ()) &&
1109 											fCameraProfile [index]->Name () == profile->Name ());
1110 
1111 		if (equalColorAndSameName)
1112 			{
1113 
1114 			// If the profile we are deleting was read from DNG
1115 			// then the new profile should be marked as such also.
1116 
1117 			if (fCameraProfile [index]->WasReadFromDNG ())
1118 				{
1119 
1120 				profile->SetWasReadFromDNG ();
1121 
1122 				}
1123 
1124 			// If the profile we are deleting wasn't read from disk then the new
1125 			// profile should be marked as such also.
1126 
1127 			if (!fCameraProfile [index]->WasReadFromDisk ())
1128 				{
1129 
1130 				profile->SetWasReadFromDisk (false);
1131 
1132 				}
1133 
1134 			// Delete the duplicate profile.
1135 
1136 			delete fCameraProfile [index];
1137 
1138 			fCameraProfile [index] = NULL;
1139 
1140 			fCameraProfile.erase (fCameraProfile.begin () + index);
1141 
1142 			break;
1143 
1144 			}
1145 
1146 		}
1147 
1148 	// Now add to profile list.
1149 
1150 	fCameraProfile.push_back (NULL);
1151 
1152 	fCameraProfile [fCameraProfile.size () - 1] = profile.Release ();
1153 
1154 	}
1155 
1156 /******************************************************************************/
1157 
ClearProfiles()1158 void dng_negative::ClearProfiles ()
1159 	{
1160 
1161 	// Delete any camera profiles owned by this negative.
1162 
1163 	for (uint32 index = 0; index < (uint32) fCameraProfile.size (); index++)
1164 		{
1165 
1166 		if (fCameraProfile [index])
1167 			{
1168 
1169 			delete fCameraProfile [index];
1170 
1171 			fCameraProfile [index] = NULL;
1172 
1173 			}
1174 
1175 		}
1176 
1177 	// Now empty list.
1178 
1179 	fCameraProfile.clear ();
1180 
1181 	}
1182 
1183 /*****************************************************************************/
1184 
ClearProfiles(bool clearBuiltinMatrixProfiles,bool clearReadFromDisk)1185 void dng_negative::ClearProfiles (bool clearBuiltinMatrixProfiles,
1186 								  bool clearReadFromDisk)
1187 	{
1188 
1189 	// If neither flag is set, then there's nothing to do.
1190 
1191 	if (!clearBuiltinMatrixProfiles &&
1192 		!clearReadFromDisk)
1193 		{
1194 		return;
1195 		}
1196 
1197 	// Delete any camera profiles in this negative that match the specified criteria.
1198 
1199 	dng_std_vector<dng_camera_profile *>::iterator iter = fCameraProfile.begin ();
1200 	dng_std_vector<dng_camera_profile *>::iterator next;
1201 
1202 	for (; iter != fCameraProfile.end (); iter = next)
1203 		{
1204 
1205 		dng_camera_profile *profile = *iter;
1206 
1207 		// If the profile is invalid (i.e., NULL pointer), or meets one of the
1208 		// specified criteria, then axe it.
1209 
1210 		if (!profile ||
1211 			(clearBuiltinMatrixProfiles && profile->WasBuiltinMatrix ()) ||
1212 			(clearReadFromDisk			&& profile->WasReadFromDisk	 ()))
1213 			{
1214 
1215 			delete profile;
1216 
1217 			next = fCameraProfile.erase (iter);
1218 
1219 			}
1220 
1221 		// Otherwise, just advance to the next element.
1222 
1223 		else
1224 			{
1225 
1226 			next = iter + 1;
1227 
1228 			}
1229 
1230 		}
1231 
1232 	}
1233 
1234 /******************************************************************************/
1235 
ProfileCount() const1236 uint32 dng_negative::ProfileCount () const
1237 	{
1238 
1239 	return (uint32) fCameraProfile.size ();
1240 
1241 	}
1242 
1243 /******************************************************************************/
1244 
ProfileByIndex(uint32 index) const1245 const dng_camera_profile & dng_negative::ProfileByIndex (uint32 index) const
1246 	{
1247 
1248 	DNG_ASSERT (index < ProfileCount (),
1249 				"Invalid index for ProfileByIndex");
1250 
1251 	return *fCameraProfile [index];
1252 
1253 	}
1254 
1255 /*****************************************************************************/
1256 
ProfileByID(const dng_camera_profile_id & id,bool useDefaultIfNoMatch) const1257 const dng_camera_profile * dng_negative::ProfileByID (const dng_camera_profile_id &id,
1258 													  bool useDefaultIfNoMatch) const
1259 	{
1260 
1261 	uint32 index;
1262 
1263 	// If this negative does not have any profiles, we are not going to
1264 	// find a match.
1265 
1266 	uint32 profileCount = ProfileCount ();
1267 
1268 	if (profileCount == 0)
1269 		{
1270 		return NULL;
1271 		}
1272 
1273 	// If we have both a profile name and fingerprint, try matching both.
1274 
1275 	if (id.Name ().NotEmpty () && id.Fingerprint ().IsValid ())
1276 		{
1277 
1278 		for (index = 0; index < profileCount; index++)
1279 			{
1280 
1281 			const dng_camera_profile &profile = ProfileByIndex (index);
1282 
1283 			if (id.Name        () == profile.Name        () &&
1284 				id.Fingerprint () == profile.Fingerprint ())
1285 				{
1286 
1287 				return &profile;
1288 
1289 				}
1290 
1291 			}
1292 
1293 		}
1294 
1295 	// If we have a name, try matching that.
1296 
1297 	if (id.Name ().NotEmpty ())
1298 		{
1299 
1300 		for (index = 0; index < profileCount; index++)
1301 			{
1302 
1303 			const dng_camera_profile &profile = ProfileByIndex (index);
1304 
1305 			if (id.Name () == profile.Name ())
1306 				{
1307 
1308 				return &profile;
1309 
1310 				}
1311 
1312 			}
1313 
1314 		}
1315 
1316 	// If we have a valid fingerprint, try matching that.
1317 
1318 	if (id.Fingerprint ().IsValid ())
1319 		{
1320 
1321 		for (index = 0; index < profileCount; index++)
1322 			{
1323 
1324 			const dng_camera_profile &profile = ProfileByIndex (index);
1325 
1326 			if (id.Fingerprint () == profile.Fingerprint ())
1327 				{
1328 
1329 				return &profile;
1330 
1331 				}
1332 
1333 			}
1334 
1335 		}
1336 
1337 	// Try "upgrading" profile name versions.
1338 
1339 	if (id.Name ().NotEmpty ())
1340 		{
1341 
1342 		dng_string baseName;
1343 		int32      version;
1344 
1345 		SplitCameraProfileName (id.Name (),
1346 								baseName,
1347 								version);
1348 
1349 		int32 bestIndex   = -1;
1350 		int32 bestVersion = 0;
1351 
1352 		for (index = 0; index < profileCount; index++)
1353 			{
1354 
1355 			const dng_camera_profile &profile = ProfileByIndex (index);
1356 
1357 			if (profile.Name ().StartsWith (baseName.Get ()))
1358 				{
1359 
1360 				dng_string testBaseName;
1361 				int32      testVersion;
1362 
1363 				SplitCameraProfileName (profile.Name (),
1364 										testBaseName,
1365 										testVersion);
1366 
1367 				if (bestIndex == -1 || testVersion > bestVersion)
1368 					{
1369 
1370 					bestIndex   = index;
1371 					bestVersion = testVersion;
1372 
1373 					}
1374 
1375 				}
1376 
1377 			}
1378 
1379 		if (bestIndex != -1)
1380 			{
1381 
1382 			return &ProfileByIndex (bestIndex);
1383 
1384 			}
1385 
1386 		}
1387 
1388 	// Did not find a match any way.  See if we should return a default value.
1389 
1390 	if (useDefaultIfNoMatch)
1391 		{
1392 
1393 		return &ProfileByIndex (0);
1394 
1395 		}
1396 
1397 	// Found nothing.
1398 
1399 	return NULL;
1400 
1401 	}
1402 
1403 /*****************************************************************************/
1404 
ComputeCameraProfileToEmbed(const dng_metadata &) const1405 const dng_camera_profile * dng_negative::ComputeCameraProfileToEmbed
1406 										(const dng_metadata & /* metadata */) const
1407 	{
1408 
1409 	uint32 index;
1410 
1411 	uint32 count = ProfileCount ();
1412 
1413 	if (count == 0)
1414 		{
1415 
1416 		return NULL;
1417 
1418 		}
1419 
1420 	// First try to look for the first profile that was already in the DNG
1421 	// when we read it.
1422 
1423 	for (index = 0; index < count; index++)
1424 		{
1425 
1426 		const dng_camera_profile &profile (ProfileByIndex (index));
1427 
1428 		if (profile.WasReadFromDNG ())
1429 			{
1430 
1431 			return &profile;
1432 
1433 			}
1434 
1435 		}
1436 
1437 	// Next we look for the first profile that is legal to embed.
1438 
1439 	for (index = 0; index < count; index++)
1440 		{
1441 
1442 		const dng_camera_profile &profile (ProfileByIndex (index));
1443 
1444 		if (profile.IsLegalToEmbed ())
1445 			{
1446 
1447 			return &profile;
1448 
1449 			}
1450 
1451 		}
1452 
1453 	// Else just return the first profile.
1454 
1455 	return fCameraProfile [0];
1456 
1457 	}
1458 
1459 /*****************************************************************************/
1460 
MakeColorSpec(const dng_camera_profile_id & id) const1461 dng_color_spec * dng_negative::MakeColorSpec (const dng_camera_profile_id &id) const
1462 	{
1463 
1464 	dng_color_spec *spec = new dng_color_spec (*this, ProfileByID (id));
1465 
1466 	if (!spec)
1467 		{
1468 		ThrowMemoryFull ();
1469 		}
1470 
1471 	return spec;
1472 
1473 	}
1474 
1475 /*****************************************************************************/
1476 
FindImageDigest(dng_host & host,const dng_image & image) const1477 dng_fingerprint dng_negative::FindImageDigest (dng_host &host,
1478 											   const dng_image &image) const
1479 	{
1480 
1481 	dng_md5_printer printer;
1482 
1483 	dng_pixel_buffer buffer (image.Bounds (), 0, image.Planes (),
1484 		 image.PixelType (), pcInterleaved, NULL);
1485 
1486 	// Sometimes we expand 8-bit data to 16-bit data while reading or
1487 	// writing, so always compute the digest of 8-bit data as 16-bits.
1488 
1489 	if (buffer.fPixelType == ttByte)
1490 		{
1491 		buffer.fPixelType = ttShort;
1492 		buffer.fPixelSize = 2;
1493 		}
1494 
1495 	const uint32 kBufferRows = 16;
1496 
1497 	uint32 bufferBytes = 0;
1498 
1499 	if (!SafeUint32Mult (kBufferRows, buffer.fRowStep, &bufferBytes) ||
1500 		 !SafeUint32Mult (bufferBytes, buffer.fPixelSize, &bufferBytes))
1501 		{
1502 
1503 		ThrowMemoryFull("Arithmetic overflow computing buffer size.");
1504 
1505 		}
1506 
1507 	AutoPtr<dng_memory_block> bufferData (host.Allocate (bufferBytes));
1508 
1509 	buffer.fData = bufferData->Buffer ();
1510 
1511 	dng_rect area;
1512 
1513 	dng_tile_iterator iter (dng_point (kBufferRows,
1514 									   image.Width ()),
1515 							image.Bounds ());
1516 
1517 	while (iter.GetOneTile (area))
1518 		{
1519 
1520 		host.SniffForAbort ();
1521 
1522 		buffer.fArea = area;
1523 
1524 		image.Get (buffer);
1525 
1526 		uint32 count = buffer.fArea.H () *
1527 					   buffer.fRowStep *
1528 					   buffer.fPixelSize;
1529 
1530 		#if qDNGBigEndian
1531 
1532 		// We need to use the same byte order to compute
1533 		// the digest, no matter the native order.  Little-endian
1534 		// is more common now, so use that.
1535 
1536 		switch (buffer.fPixelSize)
1537 			{
1538 
1539 			case 1:
1540 				break;
1541 
1542 			case 2:
1543 				{
1544 				DoSwapBytes16 ((uint16 *) buffer.fData, count >> 1);
1545 				break;
1546 				}
1547 
1548 			case 4:
1549 				{
1550 				DoSwapBytes32 ((uint32 *) buffer.fData, count >> 2);
1551 				break;
1552 				}
1553 
1554 			default:
1555 				{
1556 				DNG_REPORT ("Unexpected pixel size");
1557 				break;
1558 				}
1559 
1560 			}
1561 
1562 		#endif
1563 
1564 		printer.Process (buffer.fData,
1565 						 count);
1566 
1567 		}
1568 
1569 	return printer.Result ();
1570 
1571 	}
1572 
1573 /*****************************************************************************/
1574 
FindRawImageDigest(dng_host & host) const1575 void dng_negative::FindRawImageDigest (dng_host &host) const
1576 	{
1577 
1578 	if (fRawImageDigest.IsNull ())
1579 		{
1580 
1581 		// Since we are adding the floating point and transparency support
1582 		// in DNG 1.4, and there are no legacy floating point or transparent
1583 		// DNGs, switch to using the more MP friendly algorithm to compute
1584 		// the digest for these images.
1585 
1586 		if (RawImage ().PixelType () == ttFloat || RawTransparencyMask ())
1587 			{
1588 
1589 			FindNewRawImageDigest (host);
1590 
1591 			fRawImageDigest = fNewRawImageDigest;
1592 
1593 			}
1594 
1595 		else
1596 			{
1597 
1598 			#if qDNGValidate
1599 
1600 			dng_timer timeScope ("FindRawImageDigest time");
1601 
1602 			#endif
1603 
1604 			fRawImageDigest = FindImageDigest (host, RawImage ());
1605 
1606 			}
1607 
1608 		}
1609 
1610 	}
1611 
1612 /*****************************************************************************/
1613 
1614 class dng_find_new_raw_image_digest_task : public dng_area_task
1615 	{
1616 
1617 	private:
1618 
1619 		enum
1620 			{
1621 			kTileSize = 256
1622 			};
1623 
1624 		const dng_image &fImage;
1625 
1626 		uint32 fPixelType;
1627 		uint32 fPixelSize;
1628 
1629 		uint32 fTilesAcross;
1630 		uint32 fTilesDown;
1631 
1632 		uint32 fTileCount;
1633 
1634 		AutoArray<dng_fingerprint> fTileHash;
1635 
1636 		AutoPtr<dng_memory_block> fBufferData [kMaxMPThreads];
1637 
1638 	public:
1639 
dng_find_new_raw_image_digest_task(const dng_image & image,uint32 pixelType)1640 		dng_find_new_raw_image_digest_task (const dng_image &image,
1641 											uint32 pixelType)
1642 
1643 			:	fImage       (image)
1644 			,	fPixelType   (pixelType)
1645 			,	fPixelSize	 (TagTypeSize (pixelType))
1646 			,	fTilesAcross (0)
1647 			,	fTilesDown   (0)
1648 			,	fTileCount   (0)
1649 			,	fTileHash    ()
1650 
1651 			{
1652 
1653 			fMinTaskArea = 1;
1654 
1655 			fUnitCell = dng_point (Min_int32 (kTileSize, fImage.Bounds ().H ()),
1656 								   Min_int32 (kTileSize, fImage.Bounds ().W ()));
1657 
1658 			fMaxTileSize = fUnitCell;
1659 
1660 			}
1661 
Start(uint32 threadCount,const dng_point & tileSize,dng_memory_allocator * allocator,dng_abort_sniffer *)1662 		virtual void Start (uint32 threadCount,
1663 							const dng_point &tileSize,
1664 							dng_memory_allocator *allocator,
1665 							dng_abort_sniffer * /* sniffer */)
1666 			{
1667 
1668 			if (tileSize != fUnitCell)
1669 				{
1670 				ThrowProgramError ();
1671 				}
1672 
1673 			fTilesAcross = (fImage.Bounds ().W () + fUnitCell.h - 1) / fUnitCell.h;
1674 			fTilesDown   = (fImage.Bounds ().H () + fUnitCell.v - 1) / fUnitCell.v;
1675 
1676 			fTileCount = fTilesAcross * fTilesDown;
1677 
1678 			fTileHash.Reset (fTileCount);
1679 
1680 			const uint32 bufferSize =
1681 				ComputeBufferSize(fPixelType, tileSize, fImage.Planes(),
1682 								  padNone);
1683 
1684 			for (uint32 index = 0; index < threadCount; index++)
1685 				{
1686 
1687 				fBufferData [index].Reset (allocator->Allocate (bufferSize));
1688 
1689 				}
1690 
1691 			}
1692 
Process(uint32 threadIndex,const dng_rect & tile,dng_abort_sniffer *)1693 		virtual void Process (uint32 threadIndex,
1694 							  const dng_rect &tile,
1695 							  dng_abort_sniffer * /* sniffer */)
1696 			{
1697 
1698 			int32 colIndex = (tile.l - fImage.Bounds ().l) / fUnitCell.h;
1699 			int32 rowIndex = (tile.t - fImage.Bounds ().t) / fUnitCell.v;
1700 
1701 			DNG_ASSERT (tile.l == fImage.Bounds ().l + colIndex * fUnitCell.h &&
1702 						tile.t == fImage.Bounds ().t + rowIndex * fUnitCell.v,
1703 						"Bad tile origin");
1704 
1705 			uint32 tileIndex = rowIndex * fTilesAcross + colIndex;
1706 
1707 			dng_pixel_buffer buffer (tile, 0, fImage.Planes (),
1708 				 fPixelType, pcPlanar,
1709 				 fBufferData [threadIndex]->Buffer ());
1710 
1711 			fImage.Get (buffer);
1712 
1713 			uint32 count = buffer.fPlaneStep *
1714 						   buffer.fPlanes *
1715 						   buffer.fPixelSize;
1716 
1717 			#if qDNGBigEndian
1718 
1719 			// We need to use the same byte order to compute
1720 			// the digest, no matter the native order.  Little-endian
1721 			// is more common now, so use that.
1722 
1723 			switch (buffer.fPixelSize)
1724 				{
1725 
1726 				case 1:
1727 					break;
1728 
1729 				case 2:
1730 					{
1731 					DoSwapBytes16 ((uint16 *) buffer.fData, count >> 1);
1732 					break;
1733 					}
1734 
1735 				case 4:
1736 					{
1737 					DoSwapBytes32 ((uint32 *) buffer.fData, count >> 2);
1738 					break;
1739 					}
1740 
1741 				default:
1742 					{
1743 					DNG_REPORT ("Unexpected pixel size");
1744 					break;
1745 					}
1746 
1747 				}
1748 
1749 			#endif
1750 
1751 			dng_md5_printer printer;
1752 
1753 			printer.Process (buffer.fData, count);
1754 
1755 			fTileHash [tileIndex] = printer.Result ();
1756 
1757 			}
1758 
Result()1759 		dng_fingerprint Result ()
1760 			{
1761 
1762 			dng_md5_printer printer;
1763 
1764 			for (uint32 tileIndex = 0; tileIndex < fTileCount; tileIndex++)
1765 				{
1766 
1767 				printer.Process (fTileHash [tileIndex] . data, 16);
1768 
1769 				}
1770 
1771 			return printer.Result ();
1772 
1773 			}
1774 
1775 	};
1776 
1777 /*****************************************************************************/
1778 
FindNewRawImageDigest(dng_host & host) const1779 void dng_negative::FindNewRawImageDigest (dng_host &host) const
1780 	{
1781 
1782 	if (fNewRawImageDigest.IsNull ())
1783 		{
1784 
1785 		#if qDNGValidate
1786 
1787 		dng_timer timeScope ("FindNewRawImageDigest time");
1788 
1789 		#endif
1790 
1791 		// Find fast digest of the raw image.
1792 
1793 			{
1794 
1795 			const dng_image &rawImage = RawImage ();
1796 
1797 			// Find pixel type that will be saved in the file.  When saving DNGs, we convert
1798 			// some 16-bit data to 8-bit data, so we need to do the matching logic here.
1799 
1800 			uint32 rawPixelType = rawImage.PixelType ();
1801 
1802 			if (rawPixelType == ttShort)
1803 				{
1804 
1805 				// See if we are using a linearization table with <= 256 entries, in which
1806 				// case the useful data will all fit within 8-bits.
1807 
1808 				const dng_linearization_info *rangeInfo = GetLinearizationInfo ();
1809 
1810 				if (rangeInfo)
1811 					{
1812 
1813 					if (rangeInfo->fLinearizationTable.Get ())
1814 						{
1815 
1816 						uint32 entries = rangeInfo->fLinearizationTable->LogicalSize () >> 1;
1817 
1818 						if (entries <= 256)
1819 							{
1820 
1821 							rawPixelType = ttByte;
1822 
1823 							}
1824 
1825 						}
1826 
1827 					}
1828 
1829 				}
1830 
1831 			// Find the fast digest on the raw image.
1832 
1833 			dng_find_new_raw_image_digest_task task (rawImage, rawPixelType);
1834 
1835 			host.PerformAreaTask (task, rawImage.Bounds ());
1836 
1837 			fNewRawImageDigest = task.Result ();
1838 
1839 			}
1840 
1841 		// If there is a transparancy mask, we need to include that in the
1842 		// digest also.
1843 
1844 		if (RawTransparencyMask () != NULL)
1845 			{
1846 
1847 			// Find the fast digest on the raw mask.
1848 
1849 			dng_fingerprint maskDigest;
1850 
1851 				{
1852 
1853 				dng_find_new_raw_image_digest_task task (*RawTransparencyMask (),
1854 														 RawTransparencyMask ()->PixelType ());
1855 
1856 				host.PerformAreaTask (task, RawTransparencyMask ()->Bounds ());
1857 
1858 				maskDigest = task.Result ();
1859 
1860 				}
1861 
1862 			// Combine the two digests into a single digest.
1863 
1864 			dng_md5_printer printer;
1865 
1866 			printer.Process (fNewRawImageDigest.data, 16);
1867 
1868 			printer.Process (maskDigest.data, 16);
1869 
1870 			fNewRawImageDigest = printer.Result ();
1871 
1872 			}
1873 
1874 		}
1875 
1876 	}
1877 
1878 /*****************************************************************************/
1879 
ValidateRawImageDigest(dng_host & host)1880 void dng_negative::ValidateRawImageDigest (dng_host &host)
1881 	{
1882 
1883 	if (Stage1Image () && !IsPreview () && (fRawImageDigest   .IsValid () ||
1884 										    fNewRawImageDigest.IsValid ()))
1885 		{
1886 
1887 		bool isNewDigest = fNewRawImageDigest.IsValid ();
1888 
1889 		dng_fingerprint &rawDigest = isNewDigest ? fNewRawImageDigest
1890 												 : fRawImageDigest;
1891 
1892 		// For lossy compressed JPEG images, we need to compare the stored
1893 		// digest to the digest computed from the compressed data, since
1894 		// decompressing lossy JPEG data is itself a lossy process.
1895 
1896 		if (RawJPEGImageDigest ().IsValid () || RawJPEGImage ())
1897 			{
1898 
1899 			// Compute the raw JPEG image digest if we have not done so
1900 			// already.
1901 
1902 			FindRawJPEGImageDigest (host);
1903 
1904 			if (rawDigest != RawJPEGImageDigest ())
1905 				{
1906 
1907 				#if qDNGValidate
1908 
1909 				ReportError ("RawImageDigest does not match raw jpeg image");
1910 
1911 				#else
1912 
1913 				SetIsDamaged (true);
1914 
1915 				#endif
1916 
1917 				}
1918 
1919 			}
1920 
1921 		// Else we can compare the stored digest to the image in memory.
1922 
1923 		else
1924 			{
1925 
1926 			dng_fingerprint oldDigest = rawDigest;
1927 
1928 			try
1929 				{
1930 
1931 				rawDigest.Clear ();
1932 
1933 				if (isNewDigest)
1934 					{
1935 
1936 					FindNewRawImageDigest (host);
1937 
1938 					}
1939 
1940 				else
1941 					{
1942 
1943 					FindRawImageDigest (host);
1944 
1945 					}
1946 
1947 				}
1948 
1949 			catch (...)
1950 				{
1951 
1952 				rawDigest = oldDigest;
1953 
1954 				throw;
1955 
1956 				}
1957 
1958 			if (oldDigest != rawDigest)
1959 				{
1960 
1961 				#if qDNGValidate
1962 
1963 				if (isNewDigest)
1964 					{
1965 					ReportError ("NewRawImageDigest does not match raw image");
1966 					}
1967 				else
1968 					{
1969 					ReportError ("RawImageDigest does not match raw image");
1970 					}
1971 
1972 				SetIsDamaged (true);
1973 
1974 				#else
1975 
1976 				if (!isNewDigest)
1977 					{
1978 
1979 					// Note that Lightroom 1.4 Windows had a bug that corrupts the
1980 					// first four bytes of the RawImageDigest tag.  So if the last
1981 					// twelve bytes match, this is very likely the result of the
1982 					// bug, and not an actual corrupt file.  So don't report this
1983 					// to the user--just fix it.
1984 
1985 						{
1986 
1987 						bool matchLast12 = true;
1988 
1989 						for (uint32 j = 4; j < 16; j++)
1990 							{
1991 							matchLast12 = matchLast12 && (oldDigest.data [j] == fRawImageDigest.data [j]);
1992 							}
1993 
1994 						if (matchLast12)
1995 							{
1996 							return;
1997 							}
1998 
1999 						}
2000 
2001 					// Sometimes Lightroom 1.4 would corrupt more than the first four
2002 					// bytes, but for all those files that I have seen so far the
2003 					// resulting first four bytes are 0x08 0x00 0x00 0x00.
2004 
2005 					if (oldDigest.data [0] == 0x08 &&
2006 						oldDigest.data [1] == 0x00 &&
2007 						oldDigest.data [2] == 0x00 &&
2008 						oldDigest.data [3] == 0x00)
2009 						{
2010 						return;
2011 						}
2012 
2013 					}
2014 
2015 				SetIsDamaged (true);
2016 
2017 				#endif
2018 
2019 				}
2020 
2021 			}
2022 
2023 		}
2024 
2025 	}
2026 
2027 /*****************************************************************************/
2028 
2029 // If the raw data unique ID is missing, compute one based on a MD5 hash of
2030 // the raw image hash and the model name, plus other commonly changed
2031 // data that can affect rendering.
2032 
FindRawDataUniqueID(dng_host & host) const2033 void dng_negative::FindRawDataUniqueID (dng_host &host) const
2034 	{
2035 
2036 	if (fRawDataUniqueID.IsNull ())
2037 		{
2038 
2039 		dng_md5_printer_stream printer;
2040 
2041 		// If we have a raw jpeg image, it is much faster to
2042 		// use its digest as part of the unique ID since
2043 		// the data size is much smaller.  We cannot use it
2044 		// if there a transparency mask, since that is not
2045 		// included in the RawJPEGImageDigest.
2046 
2047 		if (RawJPEGImage () && !RawTransparencyMask ())
2048 			{
2049 
2050 			FindRawJPEGImageDigest (host);
2051 
2052 			printer.Put (fRawJPEGImageDigest.data, 16);
2053 
2054 			}
2055 
2056 		// Include the new raw image digest in the unique ID.
2057 
2058 		else
2059 			{
2060 
2061 			FindNewRawImageDigest (host);
2062 
2063 			printer.Put (fNewRawImageDigest.data, 16);
2064 
2065 			}
2066 
2067 		// Include model name.
2068 
2069 		printer.Put (ModelName ().Get    (),
2070 					 ModelName ().Length ());
2071 
2072 		// Include default crop area, since DNG Recover Edges can modify
2073 		// these values and they affect rendering.
2074 
2075 		printer.Put_uint32 (fDefaultCropSizeH.n);
2076 		printer.Put_uint32 (fDefaultCropSizeH.d);
2077 
2078 		printer.Put_uint32 (fDefaultCropSizeV.n);
2079 		printer.Put_uint32 (fDefaultCropSizeV.d);
2080 
2081 		printer.Put_uint32 (fDefaultCropOriginH.n);
2082 		printer.Put_uint32 (fDefaultCropOriginH.d);
2083 
2084 		printer.Put_uint32 (fDefaultCropOriginV.n);
2085 		printer.Put_uint32 (fDefaultCropOriginV.d);
2086 
2087 		// Include default user crop.
2088 
2089 		printer.Put_uint32 (fDefaultUserCropT.n);
2090 		printer.Put_uint32 (fDefaultUserCropT.d);
2091 
2092 		printer.Put_uint32 (fDefaultUserCropL.n);
2093 		printer.Put_uint32 (fDefaultUserCropL.d);
2094 
2095 		printer.Put_uint32 (fDefaultUserCropB.n);
2096 		printer.Put_uint32 (fDefaultUserCropB.d);
2097 
2098 		printer.Put_uint32 (fDefaultUserCropR.n);
2099 		printer.Put_uint32 (fDefaultUserCropR.d);
2100 
2101 		// Include opcode lists, since lens correction utilities can modify
2102 		// these values and they affect rendering.
2103 
2104 		fOpcodeList1.FingerprintToStream (printer);
2105 		fOpcodeList2.FingerprintToStream (printer);
2106 		fOpcodeList3.FingerprintToStream (printer);
2107 
2108 		fRawDataUniqueID = printer.Result ();
2109 
2110 		}
2111 
2112 	}
2113 
2114 /******************************************************************************/
2115 
2116 // Forces recomputation of RawDataUniqueID, useful to call
2117 // after modifying the opcode lists, etc.
2118 
RecomputeRawDataUniqueID(dng_host & host)2119 void dng_negative::RecomputeRawDataUniqueID (dng_host &host)
2120 	{
2121 
2122 	fRawDataUniqueID.Clear ();
2123 
2124 	FindRawDataUniqueID (host);
2125 
2126 	}
2127 
2128 /******************************************************************************/
2129 
FindOriginalRawFileDigest() const2130 void dng_negative::FindOriginalRawFileDigest () const
2131 	{
2132 
2133 	if (fOriginalRawFileDigest.IsNull () && fOriginalRawFileData.Get ())
2134 		{
2135 
2136 		dng_md5_printer printer;
2137 
2138 		printer.Process (fOriginalRawFileData->Buffer      (),
2139 						 fOriginalRawFileData->LogicalSize ());
2140 
2141 		fOriginalRawFileDigest = printer.Result ();
2142 
2143 		}
2144 
2145 	}
2146 
2147 /*****************************************************************************/
2148 
ValidateOriginalRawFileDigest()2149 void dng_negative::ValidateOriginalRawFileDigest ()
2150 	{
2151 
2152 	if (fOriginalRawFileDigest.IsValid () && fOriginalRawFileData.Get ())
2153 		{
2154 
2155 		dng_fingerprint oldDigest = fOriginalRawFileDigest;
2156 
2157 		try
2158 			{
2159 
2160 			fOriginalRawFileDigest.Clear ();
2161 
2162 			FindOriginalRawFileDigest ();
2163 
2164 			}
2165 
2166 		catch (...)
2167 			{
2168 
2169 			fOriginalRawFileDigest = oldDigest;
2170 
2171 			throw;
2172 
2173 			}
2174 
2175 		if (oldDigest != fOriginalRawFileDigest)
2176 			{
2177 
2178 			#if qDNGValidate
2179 
2180 			ReportError ("OriginalRawFileDigest does not match OriginalRawFileData");
2181 
2182 			#else
2183 
2184 			SetIsDamaged (true);
2185 
2186 			#endif
2187 
2188 			// Don't "repair" the original image data digest.  Once it is
2189 			// bad, it stays bad.  The user cannot tell by looking at the image
2190 			// whether the damage is acceptable and can be ignored in the
2191 			// future.
2192 
2193 			fOriginalRawFileDigest = oldDigest;
2194 
2195 			}
2196 
2197 		}
2198 
2199 	}
2200 
2201 /******************************************************************************/
2202 
DefaultCropArea() const2203 dng_rect dng_negative::DefaultCropArea () const
2204 	{
2205 
2206 	// First compute the area using simple rounding.
2207 
2208 	dng_rect result;
2209 
2210 	result.l = Round_int32 (fDefaultCropOriginH.As_real64 () * fRawToFullScaleH);
2211 	result.t = Round_int32 (fDefaultCropOriginV.As_real64 () * fRawToFullScaleV);
2212 
2213 	result.r = result.l + Round_int32 (fDefaultCropSizeH.As_real64 () * fRawToFullScaleH);
2214 	result.b = result.t + Round_int32 (fDefaultCropSizeV.As_real64 () * fRawToFullScaleV);
2215 
2216 	// Sometimes the simple rounding causes the resulting default crop
2217 	// area to slide off the scaled image area.  So we force this not
2218 	// to happen.  We only do this if the image is not stubbed.
2219 
2220 	const dng_image *image = Stage3Image ();
2221 
2222 	if (image)
2223 		{
2224 
2225 		dng_point imageSize = image->Size ();
2226 
2227 		if (result.r > imageSize.h)
2228 			{
2229 			result.l -= result.r - imageSize.h;
2230 			result.r  = imageSize.h;
2231 			}
2232 
2233 		if (result.b > imageSize.v)
2234 			{
2235 			result.t -= result.b - imageSize.v;
2236 			result.b  = imageSize.v;
2237 			}
2238 
2239 		}
2240 
2241 	return result;
2242 
2243 	}
2244 
2245 /*****************************************************************************/
2246 
TotalBaselineExposure(const dng_camera_profile_id & profileID) const2247 real64 dng_negative::TotalBaselineExposure (const dng_camera_profile_id &profileID) const
2248 	{
2249 
2250 	real64 total = BaselineExposure ();
2251 
2252 	const dng_camera_profile *profile = ProfileByID (profileID);
2253 
2254 	if (profile)
2255 		{
2256 
2257 		real64 offset = profile->BaselineExposureOffset ().As_real64 ();
2258 
2259 		total += offset;
2260 
2261 		}
2262 
2263 	return total;
2264 
2265 	}
2266 
2267 /******************************************************************************/
2268 
SetShadowScale(const dng_urational & scale)2269 void dng_negative::SetShadowScale (const dng_urational &scale)
2270 	{
2271 
2272 	if (scale.d > 0)
2273 		{
2274 
2275 		real64 s = scale.As_real64 ();
2276 
2277 		if (s > 0.0 && s <= 1.0)
2278 			{
2279 
2280 			fShadowScale = scale;
2281 
2282 			}
2283 
2284 		}
2285 
2286 	}
2287 
2288 /******************************************************************************/
2289 
SetActiveArea(const dng_rect & area)2290 void dng_negative::SetActiveArea (const dng_rect &area)
2291 	{
2292 
2293 	NeedLinearizationInfo ();
2294 
2295 	dng_linearization_info &info = *fLinearizationInfo.Get ();
2296 
2297 	info.fActiveArea = area;
2298 
2299 	}
2300 
2301 /******************************************************************************/
2302 
SetMaskedAreas(uint32 count,const dng_rect * area)2303 void dng_negative::SetMaskedAreas (uint32 count,
2304 							 	   const dng_rect *area)
2305 	{
2306 
2307 	DNG_ASSERT (count <= kMaxMaskedAreas, "Too many masked areas");
2308 
2309 	NeedLinearizationInfo ();
2310 
2311 	dng_linearization_info &info = *fLinearizationInfo.Get ();
2312 
2313 	info.fMaskedAreaCount = Min_uint32 (count, kMaxMaskedAreas);
2314 
2315 	for (uint32 index = 0; index < info.fMaskedAreaCount; index++)
2316 		{
2317 
2318 		info.fMaskedArea [index] = area [index];
2319 
2320 		}
2321 
2322 	}
2323 
2324 /*****************************************************************************/
2325 
SetLinearization(AutoPtr<dng_memory_block> & curve)2326 void dng_negative::SetLinearization (AutoPtr<dng_memory_block> &curve)
2327 	{
2328 
2329 	NeedLinearizationInfo ();
2330 
2331 	dng_linearization_info &info = *fLinearizationInfo.Get ();
2332 
2333 	info.fLinearizationTable.Reset (curve.Release ());
2334 
2335 	}
2336 
2337 /*****************************************************************************/
2338 
SetBlackLevel(real64 black,int32 plane)2339 void dng_negative::SetBlackLevel (real64 black,
2340 								  int32 plane)
2341 	{
2342 
2343 	NeedLinearizationInfo ();
2344 
2345 	dng_linearization_info &info = *fLinearizationInfo.Get ();
2346 
2347 	info.fBlackLevelRepeatRows = 1;
2348 	info.fBlackLevelRepeatCols = 1;
2349 
2350 	if (plane < 0)
2351 		{
2352 
2353 		for (uint32 j = 0; j < kMaxSamplesPerPixel; j++)
2354 			{
2355 
2356 			info.fBlackLevel [0] [0] [j] = black;
2357 
2358 			}
2359 
2360 		}
2361 
2362 	else
2363 		{
2364 
2365 		info.fBlackLevel [0] [0] [plane] = black;
2366 
2367 		}
2368 
2369 	info.RoundBlacks ();
2370 
2371 	}
2372 
2373 /*****************************************************************************/
2374 
SetQuadBlacks(real64 black0,real64 black1,real64 black2,real64 black3,int32 plane)2375 void dng_negative::SetQuadBlacks (real64 black0,
2376 						    	  real64 black1,
2377 						    	  real64 black2,
2378 						    	  real64 black3,
2379 								  int32 plane)
2380 	{
2381 
2382 	NeedLinearizationInfo ();
2383 
2384 	dng_linearization_info &info = *fLinearizationInfo.Get ();
2385 
2386 	info.fBlackLevelRepeatRows = 2;
2387 	info.fBlackLevelRepeatCols = 2;
2388 
2389 	if (plane < 0)
2390 		{
2391 
2392 		for (uint32 j = 0; j < kMaxSamplesPerPixel; j++)
2393 			{
2394 
2395 			info.fBlackLevel [0] [0] [j] = black0;
2396 			info.fBlackLevel [0] [1] [j] = black1;
2397 			info.fBlackLevel [1] [0] [j] = black2;
2398 			info.fBlackLevel [1] [1] [j] = black3;
2399 
2400 			}
2401 
2402 		}
2403 
2404 	else
2405 		{
2406 
2407 		info.fBlackLevel [0] [0] [plane] = black0;
2408 		info.fBlackLevel [0] [1] [plane] = black1;
2409 		info.fBlackLevel [1] [0] [plane] = black2;
2410 		info.fBlackLevel [1] [1] [plane] = black3;
2411 
2412 		}
2413 
2414 	info.RoundBlacks ();
2415 
2416 	}
2417 
2418 /*****************************************************************************/
2419 
SetRowBlacks(const real64 * blacks,uint32 count)2420 void dng_negative::SetRowBlacks (const real64 *blacks,
2421 				   		   		 uint32 count)
2422 	{
2423 
2424 	if (count)
2425 		{
2426 
2427 		NeedLinearizationInfo ();
2428 
2429 		dng_linearization_info &info = *fLinearizationInfo.Get ();
2430 
2431 		uint32 byteCount = 0;
2432 
2433 		if (!SafeUint32Mult (count, (uint32) sizeof (real64), &byteCount))
2434 			{
2435 
2436 			ThrowMemoryFull("Arithmetic overflow computing byte count.");
2437 
2438 			}
2439 
2440 		info.fBlackDeltaV.Reset (Allocator ().Allocate (byteCount));
2441 
2442 		DoCopyBytes (blacks,
2443 					 info.fBlackDeltaV->Buffer (),
2444 					 byteCount);
2445 
2446 		info.RoundBlacks ();
2447 
2448 		}
2449 
2450 	else if (fLinearizationInfo.Get ())
2451 		{
2452 
2453 		dng_linearization_info &info = *fLinearizationInfo.Get ();
2454 
2455 		info.fBlackDeltaV.Reset ();
2456 
2457 		}
2458 
2459 	}
2460 
2461 /*****************************************************************************/
2462 
SetColumnBlacks(const real64 * blacks,uint32 count)2463 void dng_negative::SetColumnBlacks (const real64 *blacks,
2464 					  		  	    uint32 count)
2465 	{
2466 
2467 	if (count)
2468 		{
2469 
2470 		NeedLinearizationInfo ();
2471 
2472 		dng_linearization_info &info = *fLinearizationInfo.Get ();
2473 
2474 		uint32 byteCount = 0;
2475 
2476 		if (!SafeUint32Mult (count, (uint32) sizeof (real64), &byteCount))
2477 			{
2478 
2479 			ThrowMemoryFull("Arithmetic overflow computing byte count.");
2480 
2481 			}
2482 
2483 		info.fBlackDeltaH.Reset (Allocator ().Allocate (byteCount));
2484 
2485 		DoCopyBytes (blacks,
2486 					 info.fBlackDeltaH->Buffer (),
2487 					 byteCount);
2488 
2489 		info.RoundBlacks ();
2490 
2491 		}
2492 
2493 	else if (fLinearizationInfo.Get ())
2494 		{
2495 
2496 		dng_linearization_info &info = *fLinearizationInfo.Get ();
2497 
2498 		info.fBlackDeltaH.Reset ();
2499 
2500 		}
2501 
2502 	}
2503 
2504 /*****************************************************************************/
2505 
WhiteLevel(uint32 plane) const2506 uint32 dng_negative::WhiteLevel (uint32 plane) const
2507 	{
2508 
2509 	if (fLinearizationInfo.Get ())
2510 		{
2511 
2512 		const dng_linearization_info &info = *fLinearizationInfo.Get ();
2513 
2514 		return Round_uint32 (info.fWhiteLevel [plane]);
2515 
2516 		}
2517 
2518 	if (RawImage ().PixelType () == ttFloat)
2519 		{
2520 
2521 		return 1;
2522 
2523 		}
2524 
2525 	return 0x0FFFF;
2526 
2527 	}
2528 
2529 /*****************************************************************************/
2530 
SetWhiteLevel(uint32 white,int32 plane)2531 void dng_negative::SetWhiteLevel (uint32 white,
2532 							      int32 plane)
2533 	{
2534 
2535 	NeedLinearizationInfo ();
2536 
2537 	dng_linearization_info &info = *fLinearizationInfo.Get ();
2538 
2539 	if (plane < 0)
2540 		{
2541 
2542 		for (uint32 j = 0; j < kMaxSamplesPerPixel; j++)
2543 			{
2544 
2545 			info.fWhiteLevel [j] = (real64) white;
2546 
2547 			}
2548 
2549 		}
2550 
2551 	else
2552 		{
2553 
2554 		info.fWhiteLevel [plane] = (real64) white;
2555 
2556 		}
2557 
2558 	}
2559 
2560 /******************************************************************************/
2561 
SetColorKeys(ColorKeyCode color0,ColorKeyCode color1,ColorKeyCode color2,ColorKeyCode color3)2562 void dng_negative::SetColorKeys (ColorKeyCode color0,
2563 						   		 ColorKeyCode color1,
2564 						   		 ColorKeyCode color2,
2565 						   		 ColorKeyCode color3)
2566 	{
2567 
2568 	NeedMosaicInfo ();
2569 
2570 	dng_mosaic_info &info = *fMosaicInfo.Get ();
2571 
2572 	info.fCFAPlaneColor [0] = color0;
2573 	info.fCFAPlaneColor [1] = color1;
2574 	info.fCFAPlaneColor [2] = color2;
2575 	info.fCFAPlaneColor [3] = color3;
2576 
2577 	}
2578 
2579 /******************************************************************************/
2580 
SetBayerMosaic(uint32 phase)2581 void dng_negative::SetBayerMosaic (uint32 phase)
2582 	{
2583 
2584 	NeedMosaicInfo ();
2585 
2586 	dng_mosaic_info &info = *fMosaicInfo.Get ();
2587 
2588 	ColorKeyCode color0 = (ColorKeyCode) info.fCFAPlaneColor [0];
2589 	ColorKeyCode color1 = (ColorKeyCode) info.fCFAPlaneColor [1];
2590 	ColorKeyCode color2 = (ColorKeyCode) info.fCFAPlaneColor [2];
2591 
2592 	info.fCFAPatternSize = dng_point (2, 2);
2593 
2594 	switch (phase)
2595 		{
2596 
2597 		case 0:
2598 			{
2599 			info.fCFAPattern [0] [0] = color1;
2600 			info.fCFAPattern [0] [1] = color0;
2601 			info.fCFAPattern [1] [0] = color2;
2602 			info.fCFAPattern [1] [1] = color1;
2603 			break;
2604 			}
2605 
2606 		case 1:
2607 			{
2608 			info.fCFAPattern [0] [0] = color0;
2609 			info.fCFAPattern [0] [1] = color1;
2610 			info.fCFAPattern [1] [0] = color1;
2611 			info.fCFAPattern [1] [1] = color2;
2612 			break;
2613 			}
2614 
2615 		case 2:
2616 			{
2617 			info.fCFAPattern [0] [0] = color2;
2618 			info.fCFAPattern [0] [1] = color1;
2619 			info.fCFAPattern [1] [0] = color1;
2620 			info.fCFAPattern [1] [1] = color0;
2621 			break;
2622 			}
2623 
2624 		case 3:
2625 			{
2626 			info.fCFAPattern [0] [0] = color1;
2627 			info.fCFAPattern [0] [1] = color2;
2628 			info.fCFAPattern [1] [0] = color0;
2629 			info.fCFAPattern [1] [1] = color1;
2630 			break;
2631 			}
2632 
2633 		}
2634 
2635 	info.fColorPlanes = 3;
2636 
2637 	info.fCFALayout = 1;
2638 
2639 	}
2640 
2641 /******************************************************************************/
2642 
SetFujiMosaic(uint32 phase)2643 void dng_negative::SetFujiMosaic (uint32 phase)
2644 	{
2645 
2646 	NeedMosaicInfo ();
2647 
2648 	dng_mosaic_info &info = *fMosaicInfo.Get ();
2649 
2650 	ColorKeyCode color0 = (ColorKeyCode) info.fCFAPlaneColor [0];
2651 	ColorKeyCode color1 = (ColorKeyCode) info.fCFAPlaneColor [1];
2652 	ColorKeyCode color2 = (ColorKeyCode) info.fCFAPlaneColor [2];
2653 
2654 	info.fCFAPatternSize = dng_point (2, 4);
2655 
2656 	switch (phase)
2657 		{
2658 
2659 		case 0:
2660 			{
2661 			info.fCFAPattern [0] [0] = color0;
2662 			info.fCFAPattern [0] [1] = color1;
2663 			info.fCFAPattern [0] [2] = color2;
2664 			info.fCFAPattern [0] [3] = color1;
2665 			info.fCFAPattern [1] [0] = color2;
2666 			info.fCFAPattern [1] [1] = color1;
2667 			info.fCFAPattern [1] [2] = color0;
2668 			info.fCFAPattern [1] [3] = color1;
2669 			break;
2670 			}
2671 
2672 		case 1:
2673 			{
2674 			info.fCFAPattern [0] [0] = color2;
2675 			info.fCFAPattern [0] [1] = color1;
2676 			info.fCFAPattern [0] [2] = color0;
2677 			info.fCFAPattern [0] [3] = color1;
2678 			info.fCFAPattern [1] [0] = color0;
2679 			info.fCFAPattern [1] [1] = color1;
2680 			info.fCFAPattern [1] [2] = color2;
2681 			info.fCFAPattern [1] [3] = color1;
2682 			break;
2683 			}
2684 
2685 		}
2686 
2687 	info.fColorPlanes = 3;
2688 
2689 	info.fCFALayout = 2;
2690 
2691 	}
2692 
2693 /*****************************************************************************/
2694 
SetFujiMosaic6x6(uint32 phase)2695 void dng_negative::SetFujiMosaic6x6 (uint32 phase)
2696 	{
2697 
2698 	NeedMosaicInfo ();
2699 
2700 	dng_mosaic_info &info = *fMosaicInfo.Get ();
2701 
2702 	ColorKeyCode color0 = (ColorKeyCode) info.fCFAPlaneColor [0];
2703 	ColorKeyCode color1 = (ColorKeyCode) info.fCFAPlaneColor [1];
2704 	ColorKeyCode color2 = (ColorKeyCode) info.fCFAPlaneColor [2];
2705 
2706 	const uint32 patSize = 6;
2707 
2708 	info.fCFAPatternSize = dng_point (patSize, patSize);
2709 
2710 	info.fCFAPattern [0] [0] = color1;
2711 	info.fCFAPattern [0] [1] = color2;
2712 	info.fCFAPattern [0] [2] = color1;
2713 	info.fCFAPattern [0] [3] = color1;
2714 	info.fCFAPattern [0] [4] = color0;
2715 	info.fCFAPattern [0] [5] = color1;
2716 
2717 	info.fCFAPattern [1] [0] = color0;
2718 	info.fCFAPattern [1] [1] = color1;
2719 	info.fCFAPattern [1] [2] = color0;
2720 	info.fCFAPattern [1] [3] = color2;
2721 	info.fCFAPattern [1] [4] = color1;
2722 	info.fCFAPattern [1] [5] = color2;
2723 
2724 	info.fCFAPattern [2] [0] = color1;
2725 	info.fCFAPattern [2] [1] = color2;
2726 	info.fCFAPattern [2] [2] = color1;
2727 	info.fCFAPattern [2] [3] = color1;
2728 	info.fCFAPattern [2] [4] = color0;
2729 	info.fCFAPattern [2] [5] = color1;
2730 
2731 	info.fCFAPattern [3] [0] = color1;
2732 	info.fCFAPattern [3] [1] = color0;
2733 	info.fCFAPattern [3] [2] = color1;
2734 	info.fCFAPattern [3] [3] = color1;
2735 	info.fCFAPattern [3] [4] = color2;
2736 	info.fCFAPattern [3] [5] = color1;
2737 
2738 	info.fCFAPattern [4] [0] = color2;
2739 	info.fCFAPattern [4] [1] = color1;
2740 	info.fCFAPattern [4] [2] = color2;
2741 	info.fCFAPattern [4] [3] = color0;
2742 	info.fCFAPattern [4] [4] = color1;
2743 	info.fCFAPattern [4] [5] = color0;
2744 
2745 	info.fCFAPattern [5] [0] = color1;
2746 	info.fCFAPattern [5] [1] = color0;
2747 	info.fCFAPattern [5] [2] = color1;
2748 	info.fCFAPattern [5] [3] = color1;
2749 	info.fCFAPattern [5] [4] = color2;
2750 	info.fCFAPattern [5] [5] = color1;
2751 
2752 	DNG_REQUIRE (phase >= 0 && phase < patSize * patSize,
2753 				 "Bad phase in SetFujiMosaic6x6.");
2754 
2755 	if (phase > 0)
2756 		{
2757 
2758 		dng_mosaic_info temp = info;
2759 
2760 		uint32 phaseRow = phase / patSize;
2761 
2762 		uint32 phaseCol = phase - (phaseRow * patSize);
2763 
2764 		for (uint32 dstRow = 0; dstRow < patSize; dstRow++)
2765 			{
2766 
2767 			uint32 srcRow = (dstRow + phaseRow) % patSize;
2768 
2769 			for (uint32 dstCol = 0; dstCol < patSize; dstCol++)
2770 				{
2771 
2772 				uint32 srcCol = (dstCol + phaseCol) % patSize;
2773 
2774 				temp.fCFAPattern [dstRow] [dstCol] = info.fCFAPattern [srcRow] [srcCol];
2775 
2776 				}
2777 
2778 			}
2779 
2780 		info = temp;
2781 
2782 		}
2783 
2784 	info.fColorPlanes = 3;
2785 
2786 	info.fCFALayout = 1;
2787 
2788 	}
2789 
2790 /******************************************************************************/
2791 
SetQuadMosaic(uint32 pattern)2792 void dng_negative::SetQuadMosaic (uint32 pattern)
2793 	{
2794 
2795 	// The pattern of the four colors is assumed to be repeat at least every two
2796 	// columns and eight rows.  The pattern is encoded as a 32-bit integer,
2797 	// with every two bits encoding a color, in scan order for two columns and
2798 	// eight rows (lsb is first).  The usual color coding is:
2799 	//
2800 	// 0 = Green
2801 	// 1 = Magenta
2802 	// 2 = Cyan
2803 	// 3 = Yellow
2804 	//
2805 	// Examples:
2806 	//
2807 	//	PowerShot 600 uses 0xe1e4e1e4:
2808 	//
2809 	//	  0 1 2 3 4 5
2810 	//	0 G M G M G M
2811 	//	1 C Y C Y C Y
2812 	//	2 M G M G M G
2813 	//	3 C Y C Y C Y
2814 	//
2815 	//	PowerShot A5 uses 0x1e4e1e4e:
2816 	//
2817 	//	  0 1 2 3 4 5
2818 	//	0 C Y C Y C Y
2819 	//	1 G M G M G M
2820 	//	2 C Y C Y C Y
2821 	//	3 M G M G M G
2822 	//
2823 	//	PowerShot A50 uses 0x1b4e4b1e:
2824 	//
2825 	//	  0 1 2 3 4 5
2826 	//	0 C Y C Y C Y
2827 	//	1 M G M G M G
2828 	//	2 Y C Y C Y C
2829 	//	3 G M G M G M
2830 	//	4 C Y C Y C Y
2831 	//	5 G M G M G M
2832 	//	6 Y C Y C Y C
2833 	//	7 M G M G M G
2834 	//
2835 	//	PowerShot Pro70 uses 0x1e4b4e1b:
2836 	//
2837 	//	  0 1 2 3 4 5
2838 	//	0 Y C Y C Y C
2839 	//	1 M G M G M G
2840 	//	2 C Y C Y C Y
2841 	//	3 G M G M G M
2842 	//	4 Y C Y C Y C
2843 	//	5 G M G M G M
2844 	//	6 C Y C Y C Y
2845 	//	7 M G M G M G
2846 	//
2847 	//	PowerShots Pro90 and G1 use 0xb4b4b4b4:
2848 	//
2849 	//	  0 1 2 3 4 5
2850 	//	0 G M G M G M
2851 	//	1 Y C Y C Y C
2852 
2853 	NeedMosaicInfo ();
2854 
2855 	dng_mosaic_info &info = *fMosaicInfo.Get ();
2856 
2857 	if (((pattern >> 16) & 0x0FFFF) != (pattern & 0x0FFFF))
2858 		{
2859 		info.fCFAPatternSize = dng_point (8, 2);
2860 		}
2861 
2862 	else if (((pattern >> 8) & 0x0FF) != (pattern & 0x0FF))
2863 		{
2864 		info.fCFAPatternSize = dng_point (4, 2);
2865 		}
2866 
2867 	else
2868 		{
2869 		info.fCFAPatternSize = dng_point (2, 2);
2870 		}
2871 
2872 	for (int32 row = 0; row < info.fCFAPatternSize.v; row++)
2873 		{
2874 
2875 		for (int32 col = 0; col < info.fCFAPatternSize.h; col++)
2876 			{
2877 
2878 			uint32 index = (pattern >> ((((row << 1) & 14) + (col & 1)) << 1)) & 3;
2879 
2880 			info.fCFAPattern [row] [col] = info.fCFAPlaneColor [index];
2881 
2882 			}
2883 
2884 		}
2885 
2886 	info.fColorPlanes = 4;
2887 
2888 	info.fCFALayout = 1;
2889 
2890 	}
2891 
2892 /******************************************************************************/
2893 
SetGreenSplit(uint32 split)2894 void dng_negative::SetGreenSplit (uint32 split)
2895 	{
2896 
2897 	NeedMosaicInfo ();
2898 
2899 	dng_mosaic_info &info = *fMosaicInfo.Get ();
2900 
2901 	info.fBayerGreenSplit = split;
2902 
2903 	}
2904 
2905 /*****************************************************************************/
2906 
Parse(dng_host & host,dng_stream & stream,dng_info & info)2907 void dng_negative::Parse (dng_host &host,
2908 						  dng_stream &stream,
2909 						  dng_info &info)
2910 	{
2911 
2912 	// Shared info.
2913 
2914 	dng_shared &shared = *(info.fShared.Get ());
2915 
2916 	// Find IFD holding the main raw information.
2917 
2918 	dng_ifd &rawIFD = *info.fIFD [info.fMainIndex].Get ();
2919 
2920 	// Model name.
2921 
2922 	SetModelName (shared.fUniqueCameraModel.Get ());
2923 
2924 	// Localized model name.
2925 
2926 	SetLocalName (shared.fLocalizedCameraModel.Get ());
2927 
2928 	// Base orientation.
2929 
2930 		{
2931 
2932 		uint32 orientation = info.fIFD [0]->fOrientation;
2933 
2934 		if (orientation >= 1 && orientation <= 8)
2935 			{
2936 
2937 			SetBaseOrientation (dng_orientation::TIFFtoDNG (orientation));
2938 
2939 			}
2940 
2941 		}
2942 
2943 	// Default crop rectangle.
2944 
2945 	SetDefaultCropSize (rawIFD.fDefaultCropSizeH,
2946 					    rawIFD.fDefaultCropSizeV);
2947 
2948 	SetDefaultCropOrigin (rawIFD.fDefaultCropOriginH,
2949 						  rawIFD.fDefaultCropOriginV);
2950 
2951 	// Default user crop rectangle.
2952 
2953 	SetDefaultUserCrop (rawIFD.fDefaultUserCropT,
2954 						rawIFD.fDefaultUserCropL,
2955 						rawIFD.fDefaultUserCropB,
2956 						rawIFD.fDefaultUserCropR);
2957 
2958 	// Default scale.
2959 
2960 	SetDefaultScale (rawIFD.fDefaultScaleH,
2961 					 rawIFD.fDefaultScaleV);
2962 
2963 	// Best quality scale.
2964 
2965 	SetBestQualityScale (rawIFD.fBestQualityScale);
2966 
2967 	// Baseline noise.
2968 
2969 	SetBaselineNoise (shared.fBaselineNoise.As_real64 ());
2970 
2971 	// NoiseReductionApplied.
2972 
2973 	SetNoiseReductionApplied (shared.fNoiseReductionApplied);
2974 
2975 	// NoiseProfile.
2976 
2977 	SetNoiseProfile (shared.fNoiseProfile);
2978 
2979 	// Baseline exposure.
2980 
2981 	SetBaselineExposure (shared.fBaselineExposure.As_real64 ());
2982 
2983 	// Baseline sharpness.
2984 
2985 	SetBaselineSharpness (shared.fBaselineSharpness.As_real64 ());
2986 
2987 	// Chroma blur radius.
2988 
2989 	SetChromaBlurRadius (rawIFD.fChromaBlurRadius);
2990 
2991 	// Anti-alias filter strength.
2992 
2993 	SetAntiAliasStrength (rawIFD.fAntiAliasStrength);
2994 
2995 	// Linear response limit.
2996 
2997 	SetLinearResponseLimit (shared.fLinearResponseLimit.As_real64 ());
2998 
2999 	// Shadow scale.
3000 
3001 	SetShadowScale (shared.fShadowScale);
3002 
3003 	// Colorimetric reference.
3004 
3005 	SetColorimetricReference (shared.fColorimetricReference);
3006 
3007 	// Color channels.
3008 
3009 	SetColorChannels (shared.fCameraProfile.fColorPlanes);
3010 
3011 	// Analog balance.
3012 
3013 	if (shared.fAnalogBalance.NotEmpty ())
3014 		{
3015 
3016 		SetAnalogBalance (shared.fAnalogBalance);
3017 
3018 		}
3019 
3020 	// Camera calibration matrices
3021 
3022 	if (shared.fCameraCalibration1.NotEmpty ())
3023 		{
3024 
3025 		SetCameraCalibration1 (shared.fCameraCalibration1);
3026 
3027 		}
3028 
3029 	if (shared.fCameraCalibration2.NotEmpty ())
3030 		{
3031 
3032 		SetCameraCalibration2 (shared.fCameraCalibration2);
3033 
3034 		}
3035 
3036 	if (shared.fCameraCalibration1.NotEmpty () ||
3037 		shared.fCameraCalibration2.NotEmpty ())
3038 		{
3039 
3040 		SetCameraCalibrationSignature (shared.fCameraCalibrationSignature.Get ());
3041 
3042 		}
3043 
3044 	// Embedded camera profiles.
3045 
3046 	if (shared.fCameraProfile.fColorPlanes > 1)
3047 		{
3048 
3049 		if (qDNGValidate || host.NeedsMeta () || host.NeedsImage ())
3050 			{
3051 
3052 			// Add profile from main IFD.
3053 
3054 				{
3055 
3056 				AutoPtr<dng_camera_profile> profile (new dng_camera_profile ());
3057 
3058 				dng_camera_profile_info &profileInfo = shared.fCameraProfile;
3059 
3060 				profile->Parse (stream, profileInfo);
3061 
3062 				// The main embedded profile must be valid.
3063 
3064 				if (!profile->IsValid (shared.fCameraProfile.fColorPlanes))
3065 					{
3066 
3067 					ThrowBadFormat ();
3068 
3069 					}
3070 
3071 				profile->SetWasReadFromDNG ();
3072 
3073 				AddProfile (profile);
3074 
3075 				}
3076 
3077 			// Extra profiles.
3078 
3079 			for (uint32 index = 0; index < (uint32) shared.fExtraCameraProfiles.size (); index++)
3080 				{
3081 
3082 				try
3083 					{
3084 
3085 					AutoPtr<dng_camera_profile> profile (new dng_camera_profile ());
3086 
3087 					dng_camera_profile_info &profileInfo = shared.fExtraCameraProfiles [index];
3088 
3089 					profile->Parse (stream, profileInfo);
3090 
3091 					if (!profile->IsValid (shared.fCameraProfile.fColorPlanes))
3092 						{
3093 
3094 						ThrowBadFormat ();
3095 
3096 						}
3097 
3098 					profile->SetWasReadFromDNG ();
3099 
3100 					AddProfile (profile);
3101 
3102 					}
3103 
3104 				catch (dng_exception &except)
3105 					{
3106 
3107 					// Don't ignore transient errors.
3108 
3109 					if (host.IsTransientError (except.ErrorCode ()))
3110 						{
3111 
3112 						throw;
3113 
3114 						}
3115 
3116 					// Eat other parsing errors.
3117 
3118 					#if qDNGValidate
3119 
3120 					ReportWarning ("Unable to parse extra profile");
3121 
3122 					#endif
3123 
3124 					}
3125 
3126 				}
3127 
3128 			}
3129 
3130 		// As shot profile name.
3131 
3132 		if (shared.fAsShotProfileName.NotEmpty ())
3133 			{
3134 
3135 			SetAsShotProfileName (shared.fAsShotProfileName.Get ());
3136 
3137 			}
3138 
3139 		}
3140 
3141 	// Raw image data digest.
3142 
3143 	if (shared.fRawImageDigest.IsValid ())
3144 		{
3145 
3146 		SetRawImageDigest (shared.fRawImageDigest);
3147 
3148 		}
3149 
3150 	// New raw image data digest.
3151 
3152 	if (shared.fNewRawImageDigest.IsValid ())
3153 		{
3154 
3155 		SetNewRawImageDigest (shared.fNewRawImageDigest);
3156 
3157 		}
3158 
3159 	// Raw data unique ID.
3160 
3161 	if (shared.fRawDataUniqueID.IsValid ())
3162 		{
3163 
3164 		SetRawDataUniqueID (shared.fRawDataUniqueID);
3165 
3166 		}
3167 
3168 	// Original raw file name.
3169 
3170 	if (shared.fOriginalRawFileName.NotEmpty ())
3171 		{
3172 
3173 		SetOriginalRawFileName (shared.fOriginalRawFileName.Get ());
3174 
3175 		}
3176 
3177 	// Original raw file data.
3178 
3179 	if (shared.fOriginalRawFileDataCount)
3180 		{
3181 
3182 		SetHasOriginalRawFileData (true);
3183 
3184 		if (host.KeepOriginalFile ())
3185 			{
3186 
3187 			uint32 count = shared.fOriginalRawFileDataCount;
3188 
3189 			AutoPtr<dng_memory_block> block (host.Allocate (count));
3190 
3191 			stream.SetReadPosition (shared.fOriginalRawFileDataOffset);
3192 
3193 			stream.Get (block->Buffer (), count);
3194 
3195 			SetOriginalRawFileData (block);
3196 
3197 			SetOriginalRawFileDigest (shared.fOriginalRawFileDigest);
3198 
3199 			ValidateOriginalRawFileDigest ();
3200 
3201 			}
3202 
3203 		}
3204 
3205 	// DNG private data.
3206 
3207 	if (shared.fDNGPrivateDataCount && (host.SaveDNGVersion () != dngVersion_None))
3208 		{
3209 
3210 		uint32 length = shared.fDNGPrivateDataCount;
3211 
3212 		AutoPtr<dng_memory_block> block (host.Allocate (length));
3213 
3214 		stream.SetReadPosition (shared.fDNGPrivateDataOffset);
3215 
3216 		stream.Get (block->Buffer (), length);
3217 
3218 		SetPrivateData (block);
3219 
3220 		}
3221 
3222 	// Hand off EXIF metadata to negative.
3223 
3224 	ResetExif (info.fExif.Release ());
3225 
3226 	// Parse linearization info.
3227 
3228 	NeedLinearizationInfo ();
3229 
3230 	fLinearizationInfo.Get ()->Parse (host,
3231 								      stream,
3232 								      info);
3233 
3234 	// Parse mosaic info.
3235 
3236 	if (rawIFD.fPhotometricInterpretation == piCFA)
3237 		{
3238 
3239 		NeedMosaicInfo ();
3240 
3241 		fMosaicInfo.Get ()->Parse (host,
3242 							       stream,
3243 							       info);
3244 
3245 		}
3246 
3247 	// Fill in original sizes.
3248 
3249 	if (shared.fOriginalDefaultFinalSize.h > 0 &&
3250 		shared.fOriginalDefaultFinalSize.v > 0)
3251 		{
3252 
3253 		SetOriginalDefaultFinalSize (shared.fOriginalDefaultFinalSize);
3254 
3255 		SetOriginalBestQualityFinalSize (shared.fOriginalDefaultFinalSize);
3256 
3257 		SetOriginalDefaultCropSize (dng_urational (shared.fOriginalDefaultFinalSize.h, 1),
3258 									dng_urational (shared.fOriginalDefaultFinalSize.v, 1));
3259 
3260 		}
3261 
3262 	if (shared.fOriginalBestQualityFinalSize.h > 0 &&
3263 		shared.fOriginalBestQualityFinalSize.v > 0)
3264 		{
3265 
3266 		SetOriginalBestQualityFinalSize (shared.fOriginalBestQualityFinalSize);
3267 
3268 		}
3269 
3270 	if (shared.fOriginalDefaultCropSizeH.As_real64 () >= 1.0 &&
3271 		shared.fOriginalDefaultCropSizeV.As_real64 () >= 1.0)
3272 		{
3273 
3274 		SetOriginalDefaultCropSize (shared.fOriginalDefaultCropSizeH,
3275 									shared.fOriginalDefaultCropSizeV);
3276 
3277 		}
3278 
3279 	}
3280 
3281 /*****************************************************************************/
3282 
SetDefaultOriginalSizes()3283 void dng_negative::SetDefaultOriginalSizes ()
3284 	{
3285 
3286 	// Fill in original sizes if we don't have them already.
3287 
3288 	if (OriginalDefaultFinalSize () == dng_point ())
3289 		{
3290 
3291 		SetOriginalDefaultFinalSize (dng_point (DefaultFinalHeight (),
3292 												DefaultFinalWidth  ()));
3293 
3294 		}
3295 
3296 	if (OriginalBestQualityFinalSize () == dng_point ())
3297 		{
3298 
3299 		SetOriginalBestQualityFinalSize (dng_point (BestQualityFinalHeight (),
3300 													BestQualityFinalWidth  ()));
3301 
3302 		}
3303 
3304 	if (OriginalDefaultCropSizeH ().NotValid () ||
3305 		OriginalDefaultCropSizeV ().NotValid ())
3306 		{
3307 
3308 		SetOriginalDefaultCropSize (DefaultCropSizeH (),
3309 									DefaultCropSizeV ());
3310 
3311 		}
3312 
3313 	}
3314 
3315 /*****************************************************************************/
3316 
PostParse(dng_host & host,dng_stream & stream,dng_info & info)3317 void dng_negative::PostParse (dng_host &host,
3318 						  	  dng_stream &stream,
3319 						  	  dng_info &info)
3320 	{
3321 
3322 	// Shared info.
3323 
3324 	dng_shared &shared = *(info.fShared.Get ());
3325 
3326 	if (host.NeedsMeta ())
3327 		{
3328 
3329 		// Fill in original sizes if we don't have them already.
3330 
3331 		SetDefaultOriginalSizes ();
3332 
3333 		// MakerNote.
3334 
3335 		if (shared.fMakerNoteCount)
3336 			{
3337 
3338 			// See if we know if the MakerNote is safe or not.
3339 
3340 			SetMakerNoteSafety (shared.fMakerNoteSafety == 1);
3341 
3342 			// If the MakerNote is safe, preserve it as a MakerNote.
3343 
3344 			if (IsMakerNoteSafe ())
3345 				{
3346 
3347 				AutoPtr<dng_memory_block> block (host.Allocate (shared.fMakerNoteCount));
3348 
3349 				stream.SetReadPosition (shared.fMakerNoteOffset);
3350 
3351 				stream.Get (block->Buffer (), shared.fMakerNoteCount);
3352 
3353 				SetMakerNote (block);
3354 
3355 				}
3356 
3357 			}
3358 
3359 		// IPTC metadata.
3360 
3361 		if (shared.fIPTC_NAA_Count)
3362 			{
3363 
3364 			AutoPtr<dng_memory_block> block (host.Allocate (shared.fIPTC_NAA_Count));
3365 
3366 			stream.SetReadPosition (shared.fIPTC_NAA_Offset);
3367 
3368 			uint64 iptcOffset = stream.PositionInOriginalFile();
3369 
3370 			stream.Get (block->Buffer      (),
3371 						block->LogicalSize ());
3372 
3373 			SetIPTC (block, iptcOffset);
3374 
3375 			}
3376 
3377 		// XMP metadata.
3378 
3379 		#if qDNGUseXMP
3380 
3381 		if (shared.fXMPCount)
3382 			{
3383 
3384 			AutoPtr<dng_memory_block> block (host.Allocate (shared.fXMPCount));
3385 
3386 			stream.SetReadPosition (shared.fXMPOffset);
3387 
3388 			stream.Get (block->Buffer      (),
3389 						block->LogicalSize ());
3390 
3391 			Metadata ().SetEmbeddedXMP (host,
3392 									    block->Buffer      (),
3393 									    block->LogicalSize ());
3394 
3395 			#if qDNGValidate
3396 
3397 			if (!Metadata ().HaveValidEmbeddedXMP ())
3398 				{
3399 				ReportError ("The embedded XMP is invalid");
3400 				}
3401 
3402 			#endif
3403 
3404 			}
3405 
3406 		#endif
3407 
3408 		// Color info.
3409 
3410 		if (!IsMonochrome ())
3411 			{
3412 
3413 			// If the ColorimetricReference is the ICC profile PCS,
3414 			// then the data must be already be white balanced to the
3415 			// ICC profile PCS white point.
3416 
3417 			if (ColorimetricReference () == crICCProfilePCS)
3418 				{
3419 
3420 				ClearCameraNeutral ();
3421 
3422 				SetCameraWhiteXY (PCStoXY ());
3423 
3424 				}
3425 
3426 			else
3427 				{
3428 
3429 				// AsShotNeutral.
3430 
3431 				if (shared.fAsShotNeutral.Count () == ColorChannels ())
3432 					{
3433 
3434 					SetCameraNeutral (shared.fAsShotNeutral);
3435 
3436 					}
3437 
3438 				// AsShotWhiteXY.
3439 
3440 				if (shared.fAsShotWhiteXY.IsValid () && !HasCameraNeutral ())
3441 					{
3442 
3443 					SetCameraWhiteXY (shared.fAsShotWhiteXY);
3444 
3445 					}
3446 
3447 				}
3448 
3449 			}
3450 
3451 		}
3452 
3453 	}
3454 
3455 /*****************************************************************************/
3456 
SetFourColorBayer()3457 bool dng_negative::SetFourColorBayer ()
3458 	{
3459 
3460 	if (ColorChannels () != 3)
3461 		{
3462 		return false;
3463 		}
3464 
3465 	if (!fMosaicInfo.Get ())
3466 		{
3467 		return false;
3468 		}
3469 
3470 	if (!fMosaicInfo.Get ()->SetFourColorBayer ())
3471 		{
3472 		return false;
3473 		}
3474 
3475 	SetColorChannels (4);
3476 
3477 	if (fCameraNeutral.Count () == 3)
3478 		{
3479 
3480 		dng_vector n (4);
3481 
3482 		n [0] = fCameraNeutral [0];
3483 		n [1] = fCameraNeutral [1];
3484 		n [2] = fCameraNeutral [2];
3485 		n [3] = fCameraNeutral [1];
3486 
3487 		fCameraNeutral = n;
3488 
3489 		}
3490 
3491 	fCameraCalibration1.Clear ();
3492 	fCameraCalibration2.Clear ();
3493 
3494 	fCameraCalibrationSignature.Clear ();
3495 
3496 	for (uint32 index = 0; index < (uint32) fCameraProfile.size (); index++)
3497 		{
3498 
3499 		fCameraProfile [index]->SetFourColorBayer ();
3500 
3501 		}
3502 
3503 	return true;
3504 
3505 	}
3506 
3507 /*****************************************************************************/
3508 
RawImage() const3509 const dng_image & dng_negative::RawImage () const
3510 	{
3511 
3512 	if (fRawImage.Get ())
3513 		{
3514 		return *fRawImage.Get ();
3515 		}
3516 
3517 	if (fStage1Image.Get ())
3518 		{
3519 		return *fStage1Image.Get ();
3520 		}
3521 
3522 	if (fUnflattenedStage3Image.Get ())
3523 		{
3524 		return *fUnflattenedStage3Image.Get ();
3525 		}
3526 
3527 	DNG_ASSERT (fStage3Image.Get (),
3528 				"dng_negative::RawImage with no raw image");
3529 
3530 	return *fStage3Image.Get ();
3531 
3532 	}
3533 
3534 /*****************************************************************************/
3535 
RawJPEGImage() const3536 const dng_jpeg_image * dng_negative::RawJPEGImage () const
3537 	{
3538 
3539 	return fRawJPEGImage.Get ();
3540 
3541 	}
3542 
3543 /*****************************************************************************/
3544 
SetRawJPEGImage(AutoPtr<dng_jpeg_image> & jpegImage)3545 void dng_negative::SetRawJPEGImage (AutoPtr<dng_jpeg_image> &jpegImage)
3546 	{
3547 
3548 	fRawJPEGImage.Reset (jpegImage.Release ());
3549 
3550 	}
3551 
3552 /*****************************************************************************/
3553 
ClearRawJPEGImage()3554 void dng_negative::ClearRawJPEGImage ()
3555 	{
3556 
3557 	fRawJPEGImage.Reset ();
3558 
3559 	}
3560 
3561 /*****************************************************************************/
3562 
FindRawJPEGImageDigest(dng_host & host) const3563 void dng_negative::FindRawJPEGImageDigest (dng_host &host) const
3564 	{
3565 
3566 	if (fRawJPEGImageDigest.IsNull ())
3567 		{
3568 
3569 		if (fRawJPEGImage.Get ())
3570 			{
3571 
3572 			#if qDNGValidate
3573 
3574 			dng_timer timer ("FindRawJPEGImageDigest time");
3575 
3576 			#endif
3577 
3578 			fRawJPEGImageDigest = fRawJPEGImage->FindDigest (host);
3579 
3580 			}
3581 
3582 		else
3583 			{
3584 
3585 			ThrowProgramError ("No raw JPEG image");
3586 
3587 			}
3588 
3589 		}
3590 
3591 	}
3592 
3593 /*****************************************************************************/
3594 
ReadStage1Image(dng_host & host,dng_stream & stream,dng_info & info)3595 void dng_negative::ReadStage1Image (dng_host &host,
3596 									dng_stream &stream,
3597 									dng_info &info)
3598 	{
3599 
3600 	// Allocate image we are reading.
3601 
3602 	dng_ifd &rawIFD = *info.fIFD [info.fMainIndex].Get ();
3603 
3604 	fStage1Image.Reset (host.Make_dng_image (rawIFD.Bounds (),
3605 											 rawIFD.fSamplesPerPixel,
3606 											 rawIFD.PixelType ()));
3607 
3608 	// See if we should grab the compressed JPEG data.
3609 
3610 	AutoPtr<dng_jpeg_image> jpegImage;
3611 
3612 	if (host.SaveDNGVersion () >= dngVersion_1_4_0_0 &&
3613 		!host.PreferredSize () &&
3614 		!host.ForPreview () &&
3615 		rawIFD.fCompression == ccLossyJPEG)
3616 		{
3617 
3618 		jpegImage.Reset (new dng_jpeg_image);
3619 
3620 		}
3621 
3622 	// See if we need to compute the digest of the compressed JPEG data
3623 	// while reading.
3624 
3625 	bool needJPEGDigest = (RawImageDigest    ().IsValid () ||
3626 						   NewRawImageDigest ().IsValid ()) &&
3627 						  rawIFD.fCompression == ccLossyJPEG &&
3628 						  jpegImage.Get () == NULL;
3629 
3630 	dng_fingerprint jpegDigest;
3631 
3632 	// Read the image.
3633 
3634 	rawIFD.ReadImage (host,
3635 					  stream,
3636 					  *fStage1Image.Get (),
3637 					  jpegImage.Get (),
3638 					  needJPEGDigest ? &jpegDigest : NULL);
3639 
3640 	// Remember the raw floating point bit depth, if reading from
3641 	// a floating point image.
3642 
3643 	if (fStage1Image->PixelType () == ttFloat)
3644 		{
3645 
3646 		SetRawFloatBitDepth (rawIFD.fBitsPerSample [0]);
3647 
3648 		}
3649 
3650 	// Remember the compressed JPEG data if we read it.
3651 
3652 	if (jpegImage.Get ())
3653 		{
3654 
3655 		SetRawJPEGImage (jpegImage);
3656 
3657 		}
3658 
3659 	// Remember the compressed JPEG digest if we computed it.
3660 
3661 	if (jpegDigest.IsValid ())
3662 		{
3663 
3664 		SetRawJPEGImageDigest (jpegDigest);
3665 
3666 		}
3667 
3668 	// We are are reading the main image, we should read the opcode lists
3669 	// also.
3670 
3671 	if (rawIFD.fOpcodeList1Count)
3672 		{
3673 
3674 		#if qDNGValidate
3675 
3676 		if (gVerbose)
3677 			{
3678 			printf ("\nParsing OpcodeList1: ");
3679 			}
3680 
3681 		#endif
3682 
3683 		fOpcodeList1.Parse (host,
3684 							stream,
3685 							rawIFD.fOpcodeList1Count,
3686 							rawIFD.fOpcodeList1Offset);
3687 
3688 		}
3689 
3690 	if (rawIFD.fOpcodeList2Count)
3691 		{
3692 
3693 		#if qDNGValidate
3694 
3695 		if (gVerbose)
3696 			{
3697 			printf ("\nParsing OpcodeList2: ");
3698 			}
3699 
3700 		#endif
3701 
3702 		fOpcodeList2.Parse (host,
3703 							stream,
3704 							rawIFD.fOpcodeList2Count,
3705 							rawIFD.fOpcodeList2Offset);
3706 
3707 		}
3708 
3709 	if (rawIFD.fOpcodeList3Count)
3710 		{
3711 
3712 		#if qDNGValidate
3713 
3714 		if (gVerbose)
3715 			{
3716 			printf ("\nParsing OpcodeList3: ");
3717 			}
3718 
3719 		#endif
3720 
3721 		fOpcodeList3.Parse (host,
3722 							stream,
3723 							rawIFD.fOpcodeList3Count,
3724 							rawIFD.fOpcodeList3Offset);
3725 
3726 		}
3727 
3728 	}
3729 
3730 /*****************************************************************************/
3731 
SetStage1Image(AutoPtr<dng_image> & image)3732 void dng_negative::SetStage1Image (AutoPtr<dng_image> &image)
3733 	{
3734 
3735 	fStage1Image.Reset (image.Release ());
3736 
3737 	}
3738 
3739 /*****************************************************************************/
3740 
SetStage2Image(AutoPtr<dng_image> & image)3741 void dng_negative::SetStage2Image (AutoPtr<dng_image> &image)
3742 	{
3743 
3744 	fStage2Image.Reset (image.Release ());
3745 
3746 	}
3747 
3748 /*****************************************************************************/
3749 
SetStage3Image(AutoPtr<dng_image> & image)3750 void dng_negative::SetStage3Image (AutoPtr<dng_image> &image)
3751 	{
3752 
3753 	fStage3Image.Reset (image.Release ());
3754 
3755 	}
3756 
3757 /*****************************************************************************/
3758 
DoBuildStage2(dng_host & host)3759 void dng_negative::DoBuildStage2 (dng_host &host)
3760 	{
3761 
3762 	dng_image &stage1 = *fStage1Image.Get ();
3763 
3764 	dng_linearization_info &info = *fLinearizationInfo.Get ();
3765 
3766 	uint32 pixelType = ttShort;
3767 
3768 	if (stage1.PixelType () == ttLong ||
3769 		stage1.PixelType () == ttFloat)
3770 		{
3771 
3772 		pixelType = ttFloat;
3773 
3774 		}
3775 
3776 	fStage2Image.Reset (host.Make_dng_image (info.fActiveArea.Size (),
3777 											 stage1.Planes (),
3778 											 pixelType));
3779 
3780 	info.Linearize (host,
3781 					stage1,
3782 					*fStage2Image.Get ());
3783 
3784 	}
3785 
3786 /*****************************************************************************/
3787 
DoPostOpcodeList2(dng_host &)3788 void dng_negative::DoPostOpcodeList2 (dng_host & /* host */)
3789 	{
3790 
3791 	// Nothing by default.
3792 
3793 	}
3794 
3795 /*****************************************************************************/
3796 
NeedDefloatStage2(dng_host & host)3797 bool dng_negative::NeedDefloatStage2 (dng_host &host)
3798 	{
3799 
3800 	if (fStage2Image->PixelType () == ttFloat)
3801 		{
3802 
3803 		if (fRawImageStage >= rawImageStagePostOpcode2 &&
3804 			host.SaveDNGVersion () != dngVersion_None  &&
3805 			host.SaveDNGVersion () <  dngVersion_1_4_0_0)
3806 			{
3807 
3808 			return true;
3809 
3810 			}
3811 
3812 		}
3813 
3814 	return false;
3815 
3816 	}
3817 
3818 /*****************************************************************************/
3819 
DefloatStage2(dng_host &)3820 void dng_negative::DefloatStage2 (dng_host & /* host */)
3821 	{
3822 
3823 	ThrowNotYetImplemented ("dng_negative::DefloatStage2");
3824 
3825 	}
3826 
3827 /*****************************************************************************/
3828 
BuildStage2Image(dng_host & host)3829 void dng_negative::BuildStage2Image (dng_host &host)
3830 	{
3831 
3832 	// If reading the negative to save in DNG format, figure out
3833 	// when to grab a copy of the raw data.
3834 
3835 	if (host.SaveDNGVersion () != dngVersion_None)
3836 		{
3837 
3838 		// Transparency masks are only supported in DNG version 1.4 and
3839 		// later.  In this case, the flattening of the transparency mask happens
3840 		// on the the stage3 image.
3841 
3842 		if (TransparencyMask () && host.SaveDNGVersion () < dngVersion_1_4_0_0)
3843 			{
3844 			fRawImageStage = rawImageStagePostOpcode3;
3845 			}
3846 
3847 		else if (fOpcodeList3.MinVersion (false) > host.SaveDNGVersion () ||
3848 			     fOpcodeList3.AlwaysApply ())
3849 			{
3850 			fRawImageStage = rawImageStagePostOpcode3;
3851 			}
3852 
3853 		else if (host.SaveLinearDNG (*this))
3854 			{
3855 
3856 			// If the opcode list 3 has optional tags that are beyond the
3857 			// the minimum version, and we are saving a linear DNG anyway,
3858 			// then go ahead and apply them.
3859 
3860 			if (fOpcodeList3.MinVersion (true) > host.SaveDNGVersion ())
3861 				{
3862 				fRawImageStage = rawImageStagePostOpcode3;
3863 				}
3864 
3865 			else
3866 				{
3867 				fRawImageStage = rawImageStagePreOpcode3;
3868 				}
3869 
3870 			}
3871 
3872 		else if (fOpcodeList2.MinVersion (false) > host.SaveDNGVersion () ||
3873 				 fOpcodeList2.AlwaysApply ())
3874 			{
3875 			fRawImageStage = rawImageStagePostOpcode2;
3876 			}
3877 
3878 		else if (fOpcodeList1.MinVersion (false) > host.SaveDNGVersion () ||
3879 				 fOpcodeList1.AlwaysApply ())
3880 			{
3881 			fRawImageStage = rawImageStagePostOpcode1;
3882 			}
3883 
3884 		else
3885 			{
3886 			fRawImageStage = rawImageStagePreOpcode1;
3887 			}
3888 
3889 		// We should not save floating point stage1 images unless the target
3890 		// DNG version is high enough to understand floating point images.
3891 		// We handle this by converting from floating point to integer if
3892 		// required after building stage2 image.
3893 
3894 		if (fStage1Image->PixelType () == ttFloat)
3895 			{
3896 
3897 			if (fRawImageStage < rawImageStagePostOpcode2)
3898 				{
3899 
3900 				if (host.SaveDNGVersion () < dngVersion_1_4_0_0)
3901 					{
3902 
3903 					fRawImageStage = rawImageStagePostOpcode2;
3904 
3905 					}
3906 
3907 				}
3908 
3909 			}
3910 
3911 		}
3912 
3913 	// Grab clone of raw image if required.
3914 
3915 	if (fRawImageStage == rawImageStagePreOpcode1)
3916 		{
3917 
3918 		fRawImage.Reset (fStage1Image->Clone ());
3919 
3920 		if (fTransparencyMask.Get ())
3921 			{
3922 			fRawTransparencyMask.Reset (fTransparencyMask->Clone ());
3923 			}
3924 
3925 		}
3926 
3927 	else
3928 		{
3929 
3930 		// If we are not keeping the most raw image, we need
3931 		// to recompute the raw image digest.
3932 
3933 		ClearRawImageDigest ();
3934 
3935 		// If we don't grab the unprocessed stage 1 image, then
3936 		// the raw JPEG image is no longer valid.
3937 
3938 		ClearRawJPEGImage ();
3939 
3940 		// Nor is the digest of the raw JPEG data.
3941 
3942 		ClearRawJPEGImageDigest ();
3943 
3944 		// We also don't know the raw floating point bit depth.
3945 
3946 		SetRawFloatBitDepth (0);
3947 
3948 		}
3949 
3950 	// Process opcode list 1.
3951 
3952 	host.ApplyOpcodeList (fOpcodeList1, *this, fStage1Image);
3953 
3954 	// See if we are done with the opcode list 1.
3955 
3956 	if (fRawImageStage > rawImageStagePreOpcode1)
3957 		{
3958 
3959 		fOpcodeList1.Clear ();
3960 
3961 		}
3962 
3963 	// Grab clone of raw image if required.
3964 
3965 	if (fRawImageStage == rawImageStagePostOpcode1)
3966 		{
3967 
3968 		fRawImage.Reset (fStage1Image->Clone ());
3969 
3970 		if (fTransparencyMask.Get ())
3971 			{
3972 			fRawTransparencyMask.Reset (fTransparencyMask->Clone ());
3973 			}
3974 
3975 		}
3976 
3977 	// Finalize linearization info.
3978 
3979 		{
3980 
3981 		NeedLinearizationInfo ();
3982 
3983 		dng_linearization_info &info = *fLinearizationInfo.Get ();
3984 
3985 		info.PostParse (host, *this);
3986 
3987 		}
3988 
3989 	// Perform the linearization.
3990 
3991 	DoBuildStage2 (host);
3992 
3993 	// Delete the stage1 image now that we have computed the stage 2 image.
3994 
3995 	fStage1Image.Reset ();
3996 
3997 	// Are we done with the linearization info.
3998 
3999 	if (fRawImageStage > rawImageStagePostOpcode1)
4000 		{
4001 
4002 		ClearLinearizationInfo ();
4003 
4004 		}
4005 
4006 	// Process opcode list 2.
4007 
4008 	host.ApplyOpcodeList (fOpcodeList2, *this, fStage2Image);
4009 
4010 	// See if we are done with the opcode list 2.
4011 
4012 	if (fRawImageStage > rawImageStagePostOpcode1)
4013 		{
4014 
4015 		fOpcodeList2.Clear ();
4016 
4017 		}
4018 
4019 	// Hook for any required processing just after opcode list 2.
4020 
4021 	DoPostOpcodeList2 (host);
4022 
4023 	// Convert from floating point to integer if required.
4024 
4025 	if (NeedDefloatStage2 (host))
4026 		{
4027 
4028 		DefloatStage2 (host);
4029 
4030 		}
4031 
4032 	// Grab clone of raw image if required.
4033 
4034 	if (fRawImageStage == rawImageStagePostOpcode2)
4035 		{
4036 
4037 		fRawImage.Reset (fStage2Image->Clone ());
4038 
4039 		if (fTransparencyMask.Get ())
4040 			{
4041 			fRawTransparencyMask.Reset (fTransparencyMask->Clone ());
4042 			}
4043 
4044 		}
4045 
4046 	}
4047 
4048 /*****************************************************************************/
4049 
DoInterpolateStage3(dng_host & host,int32 srcPlane)4050 void dng_negative::DoInterpolateStage3 (dng_host &host,
4051 								        int32 srcPlane)
4052 	{
4053 
4054 	dng_image &stage2 = *fStage2Image.Get ();
4055 
4056 	dng_mosaic_info &info = *fMosaicInfo.Get ();
4057 
4058 	dng_point downScale = info.DownScale (host.MinimumSize   (),
4059 										  host.PreferredSize (),
4060 										  host.CropFactor    ());
4061 
4062 	if (downScale != dng_point (1, 1))
4063 		{
4064 		SetIsPreview (true);
4065 		}
4066 
4067 	dng_point dstSize = info.DstSize (downScale);
4068 
4069 	fStage3Image.Reset (host.Make_dng_image (dng_rect (dstSize),
4070 											 info.fColorPlanes,
4071 											 stage2.PixelType ()));
4072 
4073 	if (srcPlane < 0 || srcPlane >= (int32) stage2.Planes ())
4074 		{
4075 		srcPlane = 0;
4076 		}
4077 
4078 	info.Interpolate (host,
4079 					  *this,
4080 					  stage2,
4081 					  *fStage3Image.Get (),
4082 					  downScale,
4083 					  srcPlane);
4084 
4085 	}
4086 
4087 /*****************************************************************************/
4088 
4089 // Interpolate and merge a multi-channel CFA image.
4090 
DoMergeStage3(dng_host & host)4091 void dng_negative::DoMergeStage3 (dng_host &host)
4092 	{
4093 
4094 	// The DNG SDK does not provide multi-channel CFA image merging code.
4095 	// It just grabs the first channel and uses that.
4096 
4097 	DoInterpolateStage3 (host, 0);
4098 
4099 	// Just grabbing the first channel would often result in the very
4100 	// bright image using the baseline exposure value.
4101 
4102 	fStage3Gain = pow (2.0, BaselineExposure ());
4103 
4104 	}
4105 
4106 /*****************************************************************************/
4107 
DoBuildStage3(dng_host & host,int32 srcPlane)4108 void dng_negative::DoBuildStage3 (dng_host &host,
4109 								  int32 srcPlane)
4110 	{
4111 
4112 	// If we don't have a mosaic pattern, then just move the stage 2
4113 	// image on to stage 3.
4114 
4115 	dng_mosaic_info *info = fMosaicInfo.Get ();
4116 
4117 	if (!info || !info->IsColorFilterArray ())
4118 		{
4119 
4120 		fStage3Image.Reset (fStage2Image.Release ());
4121 
4122 		}
4123 
4124 	else
4125 		{
4126 
4127 		// Remember the size of the stage 2 image.
4128 
4129 		dng_point stage2_size = fStage2Image->Size ();
4130 
4131 		// Special case multi-channel CFA interpolation.
4132 
4133 		if ((fStage2Image->Planes () > 1) && (srcPlane < 0))
4134 			{
4135 
4136 			DoMergeStage3 (host);
4137 
4138 			}
4139 
4140 		// Else do a single channel interpolation.
4141 
4142 		else
4143 			{
4144 
4145 			DoInterpolateStage3 (host, srcPlane);
4146 
4147 			}
4148 
4149 		// Calculate the ratio of the stage 3 image size to stage 2 image size.
4150 
4151 		dng_point stage3_size = fStage3Image->Size ();
4152 
4153 		fRawToFullScaleH = (real64) stage3_size.h / (real64) stage2_size.h;
4154 		fRawToFullScaleV = (real64) stage3_size.v / (real64) stage2_size.v;
4155 
4156 		}
4157 
4158 	}
4159 
4160 /*****************************************************************************/
4161 
BuildStage3Image(dng_host & host,int32 srcPlane)4162 void dng_negative::BuildStage3Image (dng_host &host,
4163 									 int32 srcPlane)
4164 	{
4165 
4166 	// Finalize the mosaic information.
4167 
4168 	dng_mosaic_info *info = fMosaicInfo.Get ();
4169 
4170 	if (info)
4171 		{
4172 
4173 		info->PostParse (host, *this);
4174 
4175 		}
4176 
4177 	// Do the interpolation as required.
4178 
4179 	DoBuildStage3 (host, srcPlane);
4180 
4181 	// Delete the stage2 image now that we have computed the stage 3 image.
4182 
4183 	fStage2Image.Reset ();
4184 
4185 	// Are we done with the mosaic info?
4186 
4187 	if (fRawImageStage >= rawImageStagePreOpcode3)
4188 		{
4189 
4190 		ClearMosaicInfo ();
4191 
4192 		// To support saving linear DNG files, to need to account for
4193 		// and upscaling during interpolation.
4194 
4195 		if (fRawToFullScaleH > 1.0)
4196 			{
4197 
4198 			uint32 adjust = Round_uint32 (fRawToFullScaleH);
4199 
4200 			fDefaultCropSizeH  .n =
4201 				SafeUint32Mult (fDefaultCropSizeH.n, adjust);
4202 			fDefaultCropOriginH.n =
4203 				SafeUint32Mult (fDefaultCropOriginH.n, adjust);
4204 			fDefaultScaleH     .d = SafeUint32Mult (fDefaultScaleH.d, adjust);
4205 
4206 			fRawToFullScaleH /= (real64) adjust;
4207 
4208 			}
4209 
4210 		if (fRawToFullScaleV > 1.0)
4211 			{
4212 
4213 			uint32 adjust = Round_uint32 (fRawToFullScaleV);
4214 
4215 			fDefaultCropSizeV  .n =
4216 				SafeUint32Mult (fDefaultCropSizeV.n, adjust);
4217 			fDefaultCropOriginV.n =
4218 				SafeUint32Mult (fDefaultCropOriginV.n, adjust);
4219 			fDefaultScaleV     .d =
4220 				SafeUint32Mult (fDefaultScaleV.d, adjust);
4221 
4222 			fRawToFullScaleV /= (real64) adjust;
4223 
4224 			}
4225 
4226 		}
4227 
4228 	// Resample the transparency mask if required.
4229 
4230 	ResizeTransparencyToMatchStage3 (host);
4231 
4232 	// Grab clone of raw image if required.
4233 
4234 	if (fRawImageStage == rawImageStagePreOpcode3)
4235 		{
4236 
4237 		fRawImage.Reset (fStage3Image->Clone ());
4238 
4239 		if (fTransparencyMask.Get ())
4240 			{
4241 			fRawTransparencyMask.Reset (fTransparencyMask->Clone ());
4242 			}
4243 
4244 		}
4245 
4246 	// Process opcode list 3.
4247 
4248 	host.ApplyOpcodeList (fOpcodeList3, *this, fStage3Image);
4249 
4250 	// See if we are done with the opcode list 3.
4251 
4252 	if (fRawImageStage > rawImageStagePreOpcode3)
4253 		{
4254 
4255 		fOpcodeList3.Clear ();
4256 
4257 		}
4258 
4259 	// Just in case the opcode list 3 changed the image size, resample the
4260 	// transparency mask again if required.  This is nearly always going
4261 	// to be a fast NOP operation.
4262 
4263 	ResizeTransparencyToMatchStage3 (host);
4264 
4265 	// Don't need to grab a copy of raw data at this stage since
4266 	// it is kept around as the stage 3 image.
4267 
4268 	}
4269 
4270 /******************************************************************************/
4271 
4272 class dng_gamma_encode_proxy : public dng_1d_function
4273 	{
4274 
4275 	private:
4276 
4277 		real64 fBlack;
4278 		real64 fWhite;
4279 
4280 		bool fIsSceneReferred;
4281 
4282 		real64 scale;
4283 		real64 t1;
4284 
4285 	public:
4286 
dng_gamma_encode_proxy(real64 black,real64 white,bool isSceneReferred)4287 		dng_gamma_encode_proxy (real64 black,
4288 							    real64 white,
4289 							    bool isSceneReferred)
4290 
4291 			:	fBlack (black)
4292 			,	fWhite (white)
4293 			,	fIsSceneReferred (isSceneReferred)
4294 
4295 			,	scale (1.0 / (fWhite - fBlack))
4296 			,	t1 (1.0 / (27.0 * pow (5.0, 3.0 / 2.0)))
4297 
4298 			{
4299 			}
4300 
Evaluate(real64 x) const4301 		virtual real64 Evaluate (real64 x) const
4302 			{
4303 
4304 			x = Pin_real64 (0.0, (x - fBlack) * scale, 1.0);
4305 
4306 			real64 y;
4307 
4308 			if (fIsSceneReferred)
4309 				{
4310 
4311 				real64 t = pow (sqrt (25920.0 * x * x + 1.0) * t1 + x * (8.0 / 15.0), 1.0 / 3.0);
4312 
4313 				y = t - 1.0 / (45.0 * t);
4314 
4315 				DNG_ASSERT (Abs_real64 (x - (y / 16.0 + y * y * y * 15.0 / 16.0)) < 0.0000001,
4316 							"Round trip error");
4317 
4318 				}
4319 
4320 			else
4321 				{
4322 
4323 				y = (sqrt (960.0 * x + 1.0) - 1.0) / 30.0;
4324 
4325 				DNG_ASSERT (Abs_real64 (x - (y / 16.0 + y * y * (15.0 / 16.0))) < 0.0000001,
4326 							"Round trip error");
4327 
4328 				}
4329 
4330 			return y;
4331 
4332 			}
4333 
4334 	};
4335 
4336 /*****************************************************************************/
4337 
4338 class dng_encode_proxy_task: public dng_area_task
4339 	{
4340 
4341 	private:
4342 
4343 		const dng_image &fSrcImage;
4344 
4345 		dng_image &fDstImage;
4346 
4347 		AutoPtr<dng_memory_block> fTable16 [kMaxColorPlanes];
4348 
4349 	public:
4350 
4351 		dng_encode_proxy_task (dng_host &host,
4352 							   const dng_image &srcImage,
4353 							   dng_image &dstImage,
4354 							   const real64 *black,
4355 							   const real64 *white,
4356 							   bool isSceneReferred);
4357 
RepeatingTile1() const4358 		virtual dng_rect RepeatingTile1 () const
4359 			{
4360 			return fSrcImage.RepeatingTile ();
4361 			}
4362 
RepeatingTile2() const4363 		virtual dng_rect RepeatingTile2 () const
4364 			{
4365 			return fDstImage.RepeatingTile ();
4366 			}
4367 
4368 		virtual void Process (uint32 threadIndex,
4369 							  const dng_rect &tile,
4370 							  dng_abort_sniffer *sniffer);
4371 
4372 	private:
4373 
4374 		// Hidden copy constructor and assignment operator.
4375 
4376 		dng_encode_proxy_task (const dng_encode_proxy_task &task);
4377 
4378 		dng_encode_proxy_task & operator= (const dng_encode_proxy_task &task);
4379 
4380 	};
4381 
4382 /*****************************************************************************/
4383 
dng_encode_proxy_task(dng_host & host,const dng_image & srcImage,dng_image & dstImage,const real64 * black,const real64 * white,bool isSceneReferred)4384 dng_encode_proxy_task::dng_encode_proxy_task (dng_host &host,
4385 											  const dng_image &srcImage,
4386 										      dng_image &dstImage,
4387 										      const real64 *black,
4388 										      const real64 *white,
4389 										      bool isSceneReferred)
4390 
4391 	:	fSrcImage (srcImage)
4392 	,	fDstImage (dstImage)
4393 
4394 	{
4395 
4396 	for (uint32 plane = 0; plane < fSrcImage.Planes (); plane++)
4397 		{
4398 
4399 		dng_gamma_encode_proxy gamma (black [plane],
4400 									  white [plane],
4401 									  isSceneReferred);
4402 
4403 		dng_1d_table table32;
4404 
4405 		table32.Initialize (host.Allocator (), gamma);
4406 
4407 		fTable16 [plane] . Reset (host.Allocate (0x10000 * sizeof (uint16)));
4408 
4409 		table32.Expand16 (fTable16 [plane]->Buffer_uint16 ());
4410 
4411 		}
4412 
4413 	}
4414 
4415 /*****************************************************************************/
4416 
Process(uint32,const dng_rect & tile,dng_abort_sniffer *)4417 void dng_encode_proxy_task::Process (uint32 /* threadIndex */,
4418 								     const dng_rect &tile,
4419 							  	     dng_abort_sniffer * /* sniffer */)
4420 	{
4421 
4422 	dng_const_tile_buffer srcBuffer (fSrcImage, tile);
4423 	dng_dirty_tile_buffer dstBuffer (fDstImage, tile);
4424 
4425 	int32 sColStep = srcBuffer.fColStep;
4426 	int32 dColStep = dstBuffer.fColStep;
4427 
4428 	const uint16 *noise = dng_dither::Get ().NoiseBuffer16 ();
4429 
4430 	for (uint32 plane = 0; plane < fSrcImage.Planes (); plane++)
4431 		{
4432 
4433 		const uint16 *map = fTable16 [plane]->Buffer_uint16 ();
4434 
4435 		for (int32 row = tile.t; row < tile.b; row++)
4436 			{
4437 
4438 			const uint16 *sPtr = srcBuffer.ConstPixel_uint16 (row, tile.l, plane);
4439 
4440 			uint8 *dPtr = dstBuffer.DirtyPixel_uint8 (row, tile.l, plane);
4441 
4442 			const uint16 *rPtr = &noise [(row & dng_dither::kRNGMask) * dng_dither::kRNGSize];
4443 
4444 			for (int32 col = tile.l; col < tile.r; col++)
4445 				{
4446 
4447 				uint32 x = *sPtr;
4448 
4449 				uint32 r = rPtr [col & dng_dither::kRNGMask];
4450 
4451 				x = map [x];
4452 
4453 				x = (((x << 8) - x) + r) >> 16;
4454 
4455 				*dPtr = (uint8) x;
4456 
4457 				sPtr += sColStep;
4458 				dPtr += dColStep;
4459 
4460 				}
4461 
4462 			}
4463 
4464 		}
4465 
4466 	}
4467 
4468 /******************************************************************************/
4469 
EncodeRawProxy(dng_host & host,const dng_image & srcImage,dng_opcode_list & opcodeList) const4470 dng_image * dng_negative::EncodeRawProxy (dng_host &host,
4471 										  const dng_image &srcImage,
4472 										  dng_opcode_list &opcodeList) const
4473 	{
4474 
4475 	if (srcImage.PixelType () != ttShort)
4476 		{
4477 		return NULL;
4478 		}
4479 
4480 	real64 black [kMaxColorPlanes];
4481 	real64 white [kMaxColorPlanes];
4482 
4483 	bool isSceneReferred = (ColorimetricReference () == crSceneReferred);
4484 
4485 		{
4486 
4487 		const real64 kClipFraction = 0.00001;
4488 
4489 		uint64 pixels = (uint64) srcImage.Bounds ().H () *
4490 						(uint64) srcImage.Bounds ().W ();
4491 
4492 		uint32 limit = Round_int32 ((real64) pixels * kClipFraction);
4493 
4494 		AutoPtr<dng_memory_block> histData (host.Allocate (65536 * sizeof (uint32)));
4495 
4496 		uint32 *hist = histData->Buffer_uint32 ();
4497 
4498 		for (uint32 plane = 0; plane < srcImage.Planes (); plane++)
4499 			{
4500 
4501 			HistogramArea (host,
4502 						   srcImage,
4503 						   srcImage.Bounds (),
4504 						   hist,
4505 						   65535,
4506 						   plane);
4507 
4508 			uint32 total = 0;
4509 
4510 			uint32 upper = 65535;
4511 
4512 			while (total + hist [upper] <= limit && upper > 255)
4513 				{
4514 
4515 				total += hist [upper];
4516 
4517 				upper--;
4518 
4519 				}
4520 
4521 			total = 0;
4522 
4523 			uint32 lower = 0;
4524 
4525 			while (total + hist [lower] <= limit && lower < upper - 255)
4526 				{
4527 
4528 				total += hist [lower];
4529 
4530 				lower++;
4531 
4532 				}
4533 
4534 			black [plane] = lower / 65535.0;
4535 			white [plane] = upper / 65535.0;
4536 
4537 			}
4538 
4539 		}
4540 
4541 	// Apply the gamma encoding, using dither when downsampling to 8-bit.
4542 
4543 	AutoPtr<dng_image> dstImage (host.Make_dng_image (srcImage.Bounds (),
4544 													  srcImage.Planes (),
4545 													  ttByte));
4546 
4547 		{
4548 
4549 		dng_encode_proxy_task task (host,
4550 							        srcImage,
4551 									*dstImage,
4552 									black,
4553 									white,
4554 									isSceneReferred);
4555 
4556 		host.PerformAreaTask (task,
4557 							  srcImage.Bounds ());
4558 
4559 		}
4560 
4561 	// Add opcodes to undo the gamma encoding.
4562 
4563 		{
4564 
4565 		for (uint32 plane = 0; plane < srcImage.Planes (); plane++)
4566 			{
4567 
4568 			dng_area_spec areaSpec (srcImage.Bounds (),
4569 									plane);
4570 
4571 			real64 coefficient [4];
4572 
4573 			coefficient [0] = 0.0;
4574 			coefficient [1] = 1.0 / 16.0;
4575 
4576 			if (isSceneReferred)
4577 				{
4578 				coefficient [2] = 0.0;
4579 				coefficient [3] = 15.0 / 16.0;
4580 				}
4581 			else
4582 				{
4583 				coefficient [2] = 15.0 / 16.0;
4584 				coefficient [3] = 0.0;
4585 				}
4586 
4587 			coefficient [0] *= white [plane] - black [plane];
4588 			coefficient [1] *= white [plane] - black [plane];
4589 			coefficient [2] *= white [plane] - black [plane];
4590 			coefficient [3] *= white [plane] - black [plane];
4591 
4592 			coefficient [0] += black [plane];
4593 
4594 			AutoPtr<dng_opcode> opcode (new dng_opcode_MapPolynomial (areaSpec,
4595 																	  isSceneReferred ? 3 : 2,
4596 																	  coefficient));
4597 
4598 			opcodeList.Append (opcode);
4599 
4600 			}
4601 
4602 		}
4603 
4604 	return dstImage.Release ();
4605 
4606 	}
4607 
4608 /******************************************************************************/
4609 
AdjustProfileForStage3()4610 void dng_negative::AdjustProfileForStage3 ()
4611 	{
4612 
4613 	// For dng_sdk, the stage3 image's color space is always the same as the
4614 	// raw image's color space.
4615 
4616 	}
4617 
4618 /******************************************************************************/
4619 
ConvertToProxy(dng_host & host,dng_image_writer & writer,uint32 proxySize,uint64 proxyCount)4620 void dng_negative::ConvertToProxy (dng_host &host,
4621 								   dng_image_writer &writer,
4622 								   uint32 proxySize,
4623 								   uint64 proxyCount)
4624 	{
4625 
4626 	if (!proxySize)
4627 		{
4628 		proxySize = kMaxImageSide;
4629 		}
4630 
4631 	if (!proxyCount)
4632 		{
4633 		proxyCount = (uint64) proxySize * proxySize;
4634 		}
4635 
4636 	// Don't need to private data around in non-full size proxies.
4637 
4638 	if (proxySize  < kMaxImageSide ||
4639 		proxyCount < kMaxImageSide * kMaxImageSide)
4640 		{
4641 
4642 		ClearMakerNote ();
4643 
4644 		ClearPrivateData ();
4645 
4646 		}
4647 
4648 	// See if we already have an acceptable proxy image.
4649 
4650 	if (fRawImage.Get () &&
4651 		fRawImage->PixelType () == ttByte &&
4652 		fRawImage->Bounds () == DefaultCropArea () &&
4653 		fRawImage->Bounds ().H () <= proxySize &&
4654 		fRawImage->Bounds ().W () <= proxySize &&
4655 		(uint64) fRawImage->Bounds ().H () *
4656 		(uint64) fRawImage->Bounds ().W () <= proxyCount &&
4657 		(!GetMosaicInfo () || !GetMosaicInfo ()->IsColorFilterArray ()) &&
4658 		fRawJPEGImage.Get () &&
4659 		(!RawTransparencyMask () || RawTransparencyMask ()->PixelType () == ttByte))
4660 		{
4661 
4662 		return;
4663 
4664 		}
4665 
4666 	if (fRawImage.Get () &&
4667 		fRawImage->PixelType () == ttFloat &&
4668 		fRawImage->Bounds ().H () <= proxySize &&
4669 		fRawImage->Bounds ().W () <= proxySize &&
4670 		(uint64) fRawImage->Bounds ().H () *
4671 		(uint64) fRawImage->Bounds ().W () <= proxyCount &&
4672 		RawFloatBitDepth () == 16 &&
4673 		(!RawTransparencyMask () || RawTransparencyMask ()->PixelType () == ttByte))
4674 		{
4675 
4676 		return;
4677 
4678 		}
4679 
4680 	// Clear any grabbed raw image, since we are going to start
4681 	// building the proxy with the stage3 image.
4682 
4683 	fRawImage.Reset ();
4684 
4685 	ClearRawJPEGImage ();
4686 
4687 	SetRawFloatBitDepth (0);
4688 
4689 	ClearLinearizationInfo ();
4690 
4691 	ClearMosaicInfo ();
4692 
4693 	fOpcodeList1.Clear ();
4694 	fOpcodeList2.Clear ();
4695 	fOpcodeList3.Clear ();
4696 
4697 	// Adjust the profile to match the stage 3 image, if required.
4698 
4699 	AdjustProfileForStage3 ();
4700 
4701 	// Not saving the raw-most image, do the old raw digest is no
4702 	// longer valid.
4703 
4704 	ClearRawImageDigest ();
4705 
4706 	ClearRawJPEGImageDigest ();
4707 
4708 	// Trim off extra pixels outside the default crop area.
4709 
4710 	dng_rect defaultCropArea = DefaultCropArea ();
4711 
4712 	if (Stage3Image ()->Bounds () != defaultCropArea)
4713 		{
4714 
4715 		fStage3Image->Trim (defaultCropArea);
4716 
4717 		if (fTransparencyMask.Get ())
4718 			{
4719 			fTransparencyMask->Trim (defaultCropArea);
4720 			}
4721 
4722 		fDefaultCropOriginH = dng_urational (0, 1);
4723 		fDefaultCropOriginV = dng_urational (0, 1);
4724 
4725 		}
4726 
4727 	// Figure out the requested proxy pixel size.
4728 
4729 	real64 aspectRatio = AspectRatio ();
4730 
4731 	dng_point newSize (proxySize, proxySize);
4732 
4733 	if (aspectRatio >= 1.0)
4734 		{
4735 		newSize.v = Max_int32 (1, Round_int32 (proxySize / aspectRatio));
4736 		}
4737 	else
4738 		{
4739 		newSize.h = Max_int32 (1, Round_int32 (proxySize * aspectRatio));
4740 		}
4741 
4742 	newSize.v = Min_int32 (newSize.v, DefaultFinalHeight ());
4743 	newSize.h = Min_int32 (newSize.h, DefaultFinalWidth  ());
4744 
4745 	if ((uint64) newSize.v *
4746 	    (uint64) newSize.h > proxyCount)
4747 		{
4748 
4749 		if (aspectRatio >= 1.0)
4750 			{
4751 
4752 			newSize.h = (uint32) sqrt (proxyCount * aspectRatio);
4753 
4754 			newSize.v = Max_int32 (1, Round_int32 (newSize.h / aspectRatio));
4755 
4756 			}
4757 
4758 		else
4759 			{
4760 
4761 			newSize.v = (uint32) sqrt (proxyCount / aspectRatio);
4762 
4763 			newSize.h = Max_int32 (1, Round_int32 (newSize.v * aspectRatio));
4764 
4765 			}
4766 
4767 		}
4768 
4769 	// If this is fewer pixels, downsample the stage 3 image to that size.
4770 
4771 	dng_point oldSize = defaultCropArea.Size ();
4772 
4773 	if ((uint64) newSize.v * (uint64) newSize.h <
4774 		(uint64) oldSize.v * (uint64) oldSize.h)
4775 		{
4776 
4777 		const dng_image &srcImage (*Stage3Image ());
4778 
4779 		AutoPtr<dng_image> dstImage (host.Make_dng_image (newSize,
4780 														  srcImage.Planes (),
4781 														  srcImage.PixelType ()));
4782 
4783 		host.ResampleImage (srcImage,
4784 							*dstImage);
4785 
4786 		fStage3Image.Reset (dstImage.Release ());
4787 
4788 		fDefaultCropSizeH = dng_urational (newSize.h, 1);
4789 		fDefaultCropSizeV = dng_urational (newSize.v, 1);
4790 
4791 		fDefaultScaleH = dng_urational (1, 1);
4792 		fDefaultScaleV = dng_urational (1, 1);
4793 
4794 		fBestQualityScale = dng_urational (1, 1);
4795 
4796 		fRawToFullScaleH = 1.0;
4797 		fRawToFullScaleV = 1.0;
4798 
4799 		}
4800 
4801 	// Convert 32-bit floating point images to 16-bit floating point to
4802 	// save space.
4803 
4804 	if (Stage3Image ()->PixelType () == ttFloat)
4805 		{
4806 
4807 		fRawImage.Reset (host.Make_dng_image (Stage3Image ()->Bounds (),
4808 											  Stage3Image ()->Planes (),
4809 											  ttFloat));
4810 
4811 		LimitFloatBitDepth (host,
4812 							*Stage3Image (),
4813 							*fRawImage,
4814 							16,
4815 							32768.0f);
4816 
4817 		SetRawFloatBitDepth (16);
4818 
4819 		SetWhiteLevel (32768);
4820 
4821 		}
4822 
4823 	else
4824 		{
4825 
4826 		// Convert 16-bit deep images to 8-bit deep image for saving.
4827 
4828 		fRawImage.Reset (EncodeRawProxy (host,
4829 										 *Stage3Image (),
4830 										 fOpcodeList2));
4831 
4832 		if (fRawImage.Get ())
4833 			{
4834 
4835 			SetWhiteLevel (255);
4836 
4837 			// Compute JPEG compressed version.
4838 
4839 			if (fRawImage->PixelType () == ttByte &&
4840 				host.SaveDNGVersion () >= dngVersion_1_4_0_0)
4841 				{
4842 
4843 				AutoPtr<dng_jpeg_image> jpegImage (new dng_jpeg_image);
4844 
4845 				jpegImage->Encode (host,
4846 								   *this,
4847 								   writer,
4848 								   *fRawImage);
4849 
4850 				SetRawJPEGImage (jpegImage);
4851 
4852 				}
4853 
4854 			}
4855 
4856 		}
4857 
4858 	// Deal with transparency mask.
4859 
4860 	if (TransparencyMask ())
4861 		{
4862 
4863 		const bool convertTo8Bit = true;
4864 
4865 		ResizeTransparencyToMatchStage3 (host, convertTo8Bit);
4866 
4867 		fRawTransparencyMask.Reset (fTransparencyMask->Clone ());
4868 
4869 		}
4870 
4871 	// Recompute the raw data unique ID, since we changed the image data.
4872 
4873 	RecomputeRawDataUniqueID (host);
4874 
4875 	}
4876 
4877 /*****************************************************************************/
4878 
MakeLinearizationInfo()4879 dng_linearization_info * dng_negative::MakeLinearizationInfo ()
4880 	{
4881 
4882 	dng_linearization_info *info = new dng_linearization_info ();
4883 
4884 	if (!info)
4885 		{
4886 		ThrowMemoryFull ();
4887 		}
4888 
4889 	return info;
4890 
4891 	}
4892 
4893 /*****************************************************************************/
4894 
NeedLinearizationInfo()4895 void dng_negative::NeedLinearizationInfo ()
4896 	{
4897 
4898 	if (!fLinearizationInfo.Get ())
4899 		{
4900 
4901 		fLinearizationInfo.Reset (MakeLinearizationInfo ());
4902 
4903 		}
4904 
4905 	}
4906 
4907 /*****************************************************************************/
4908 
MakeMosaicInfo()4909 dng_mosaic_info * dng_negative::MakeMosaicInfo ()
4910 	{
4911 
4912 	dng_mosaic_info *info = new dng_mosaic_info ();
4913 
4914 	if (!info)
4915 		{
4916 		ThrowMemoryFull ();
4917 		}
4918 
4919 	return info;
4920 
4921 	}
4922 
4923 /*****************************************************************************/
4924 
NeedMosaicInfo()4925 void dng_negative::NeedMosaicInfo ()
4926 	{
4927 
4928 	if (!fMosaicInfo.Get ())
4929 		{
4930 
4931 		fMosaicInfo.Reset (MakeMosaicInfo ());
4932 
4933 		}
4934 
4935 	}
4936 
4937 /*****************************************************************************/
4938 
SetTransparencyMask(AutoPtr<dng_image> & image,uint32 bitDepth)4939 void dng_negative::SetTransparencyMask (AutoPtr<dng_image> &image,
4940 										uint32 bitDepth)
4941 	{
4942 
4943 	fTransparencyMask.Reset (image.Release ());
4944 
4945 	fRawTransparencyMaskBitDepth = bitDepth;
4946 
4947 	}
4948 
4949 /*****************************************************************************/
4950 
TransparencyMask() const4951 const dng_image * dng_negative::TransparencyMask () const
4952 	{
4953 
4954 	return fTransparencyMask.Get ();
4955 
4956 	}
4957 
4958 /*****************************************************************************/
4959 
RawTransparencyMask() const4960 const dng_image * dng_negative::RawTransparencyMask () const
4961 	{
4962 
4963 	if (fRawTransparencyMask.Get ())
4964 		{
4965 
4966 		return fRawTransparencyMask.Get ();
4967 
4968 		}
4969 
4970 	return TransparencyMask ();
4971 
4972 	}
4973 
4974 /*****************************************************************************/
4975 
RawTransparencyMaskBitDepth() const4976 uint32 dng_negative::RawTransparencyMaskBitDepth () const
4977 	{
4978 
4979 	if (fRawTransparencyMaskBitDepth)
4980 		{
4981 
4982 		return fRawTransparencyMaskBitDepth;
4983 
4984 		}
4985 
4986 	const dng_image *mask = RawTransparencyMask ();
4987 
4988 	if (mask)
4989 		{
4990 
4991 		switch (mask->PixelType ())
4992 			{
4993 
4994 			case ttByte:
4995 				return 8;
4996 
4997 			case ttShort:
4998 				return 16;
4999 
5000 			case ttFloat:
5001 				return 32;
5002 
5003 			default:
5004 				ThrowProgramError ();
5005 
5006 			}
5007 
5008 		}
5009 
5010 	return 0;
5011 
5012 	}
5013 
5014 /*****************************************************************************/
5015 
ReadTransparencyMask(dng_host & host,dng_stream & stream,dng_info & info)5016 void dng_negative::ReadTransparencyMask (dng_host &host,
5017 									     dng_stream &stream,
5018 									     dng_info &info)
5019 	{
5020 
5021 	if (info.fMaskIndex != -1)
5022 		{
5023 
5024 		// Allocate image we are reading.
5025 
5026 		dng_ifd &maskIFD = *info.fIFD [info.fMaskIndex].Get ();
5027 
5028 		fTransparencyMask.Reset (host.Make_dng_image (maskIFD.Bounds (),
5029 													  1,
5030 													  maskIFD.PixelType ()));
5031 
5032 		// Read the image.
5033 
5034 		maskIFD.ReadImage (host,
5035 						   stream,
5036 						   *fTransparencyMask.Get ());
5037 
5038 		// Remember the pixel depth.
5039 
5040 		fRawTransparencyMaskBitDepth = maskIFD.fBitsPerSample [0];
5041 
5042 		}
5043 
5044 	}
5045 
5046 /*****************************************************************************/
5047 
ResizeTransparencyToMatchStage3(dng_host & host,bool convertTo8Bit)5048 void dng_negative::ResizeTransparencyToMatchStage3 (dng_host &host,
5049 													bool convertTo8Bit)
5050 	{
5051 
5052 	if (TransparencyMask ())
5053 		{
5054 
5055 		if ((TransparencyMask ()->Bounds () != fStage3Image->Bounds ()) ||
5056 			(TransparencyMask ()->PixelType () != ttByte && convertTo8Bit))
5057 			{
5058 
5059 			AutoPtr<dng_image> newMask (host.Make_dng_image (fStage3Image->Bounds (),
5060 															 1,
5061 															 convertTo8Bit ?
5062 															 ttByte :
5063 															 TransparencyMask ()->PixelType ()));
5064 
5065 			host.ResampleImage (*TransparencyMask (),
5066 								*newMask);
5067 
5068 			fTransparencyMask.Reset (newMask.Release ());
5069 
5070 			if (!fRawTransparencyMask.Get ())
5071 				{
5072 				fRawTransparencyMaskBitDepth = 0;
5073 				}
5074 
5075 			}
5076 
5077 		}
5078 
5079 	}
5080 
5081 /*****************************************************************************/
5082 
NeedFlattenTransparency(dng_host &)5083 bool dng_negative::NeedFlattenTransparency (dng_host & /* host */)
5084 	{
5085 
5086 	if (TransparencyMask ())
5087 		{
5088 
5089 		return true;
5090 
5091 		}
5092 
5093 	return false;
5094 
5095 	}
5096 
5097 /*****************************************************************************/
5098 
FlattenTransparency(dng_host &)5099 void dng_negative::FlattenTransparency (dng_host & /* host */)
5100 	{
5101 
5102 	ThrowNotYetImplemented ();
5103 
5104 	}
5105 
5106 /*****************************************************************************/
5107 
UnflattenedStage3Image() const5108 const dng_image * dng_negative::UnflattenedStage3Image () const
5109 	{
5110 
5111 	if (fUnflattenedStage3Image.Get ())
5112 		{
5113 
5114 		return fUnflattenedStage3Image.Get ();
5115 
5116 		}
5117 
5118 	return fStage3Image.Get ();
5119 
5120 	}
5121 
5122 /*****************************************************************************/
5123