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 53 dng_noise_profile::dng_noise_profile () 54 55 : fNoiseFunctions () 56 57 { 58 59 } 60 61 /*****************************************************************************/ 62 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 73 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 97 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 111 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 128 uint32 dng_noise_profile::NumFunctions () const 129 { 130 return (uint32) fNoiseFunctions.size (); 131 } 132 133 /*****************************************************************************/ 134 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 162 dng_metadata::~dng_metadata () 163 { 164 } 165 166 /******************************************************************************/ 167 168 template< class T > 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 > 179 T * CloneAutoPtr (const AutoPtr< T > &ptr, U &u) 180 { 181 182 return ptr.Get () ? ptr->Clone (u) : NULL; 183 184 } 185 186 /******************************************************************************/ 187 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 217 dng_metadata * dng_metadata::Clone (dng_memory_allocator &allocator) const 218 { 219 220 return new dng_metadata (*this, allocator); 221 222 } 223 224 /******************************************************************************/ 225 226 void dng_metadata::SetBaseOrientation (const dng_orientation &orientation) 227 { 228 229 fHasBaseOrientation = true; 230 231 fBaseOrientation = orientation; 232 233 } 234 235 /******************************************************************************/ 236 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 252 void dng_metadata::ResetExif (dng_exif * newExif) 253 { 254 255 fExif.Reset (newExif); 256 257 } 258 259 /******************************************************************************/ 260 261 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 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 415 void dng_metadata::SetIPTC (AutoPtr<dng_memory_block> &block) 416 { 417 418 SetIPTC (block, kDNGStreamInvalidOffset); 419 420 } 421 422 /******************************************************************************/ 423 424 void dng_metadata::ClearIPTC () 425 { 426 427 fIPTCBlock.Reset (); 428 429 fIPTCOffset = kDNGStreamInvalidOffset; 430 431 } 432 433 /*****************************************************************************/ 434 435 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 451 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 467 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 483 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 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 545 void dng_metadata::ResetXMP (dng_xmp * newXMP) 546 { 547 548 fXMP.Reset (newXMP); 549 550 } 551 552 /*****************************************************************************/ 553 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 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 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 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 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 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 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 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 810 dng_negative::~dng_negative () 811 { 812 813 // Delete any camera profiles owned by this negative. 814 815 ClearProfiles (); 816 817 } 818 819 /******************************************************************************/ 820 821 void dng_negative::Initialize () 822 { 823 824 } 825 826 /******************************************************************************/ 827 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 846 dng_metadata * dng_negative::CloneInternalMetadata () const 847 { 848 849 return InternalMetadata ().Clone (Allocator ()); 850 851 } 852 853 /******************************************************************************/ 854 855 dng_orientation dng_negative::ComputeOrientation (const dng_metadata &metadata) const 856 { 857 858 return metadata.BaseOrientation (); 859 860 } 861 862 /******************************************************************************/ 863 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 891 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 909 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 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 949 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 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 984 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 995 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 1008 void dng_negative::SetCameraCalibration1 (const dng_matrix &m) 1009 { 1010 1011 fCameraCalibration1 = m; 1012 1013 fCameraCalibration1.Round (10000); 1014 1015 } 1016 1017 /******************************************************************************/ 1018 1019 void dng_negative::SetCameraCalibration2 (const dng_matrix &m) 1020 { 1021 1022 fCameraCalibration2 = m; 1023 1024 fCameraCalibration2.Round (10000); 1025 1026 } 1027 1028 /******************************************************************************/ 1029 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 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 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 1236 uint32 dng_negative::ProfileCount () const 1237 { 1238 1239 return (uint32) fCameraProfile.size (); 1240 1241 } 1242 1243 /******************************************************************************/ 1244 1245 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 1257 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 1405 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 1461 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 1477 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 1575 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 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 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 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 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 1779 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 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 2033 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 2119 void dng_negative::RecomputeRawDataUniqueID (dng_host &host) 2120 { 2121 2122 fRawDataUniqueID.Clear (); 2123 2124 FindRawDataUniqueID (host); 2125 2126 } 2127 2128 /******************************************************************************/ 2129 2130 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 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 2203 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 2247 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 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 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 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 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 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 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 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 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 2506 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 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 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 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 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 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 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 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 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 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 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 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 3509 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 3536 const dng_jpeg_image * dng_negative::RawJPEGImage () const 3537 { 3538 3539 return fRawJPEGImage.Get (); 3540 3541 } 3542 3543 /*****************************************************************************/ 3544 3545 void dng_negative::SetRawJPEGImage (AutoPtr<dng_jpeg_image> &jpegImage) 3546 { 3547 3548 fRawJPEGImage.Reset (jpegImage.Release ()); 3549 3550 } 3551 3552 /*****************************************************************************/ 3553 3554 void dng_negative::ClearRawJPEGImage () 3555 { 3556 3557 fRawJPEGImage.Reset (); 3558 3559 } 3560 3561 /*****************************************************************************/ 3562 3563 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 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 3732 void dng_negative::SetStage1Image (AutoPtr<dng_image> &image) 3733 { 3734 3735 fStage1Image.Reset (image.Release ()); 3736 3737 } 3738 3739 /*****************************************************************************/ 3740 3741 void dng_negative::SetStage2Image (AutoPtr<dng_image> &image) 3742 { 3743 3744 fStage2Image.Reset (image.Release ()); 3745 3746 } 3747 3748 /*****************************************************************************/ 3749 3750 void dng_negative::SetStage3Image (AutoPtr<dng_image> &image) 3751 { 3752 3753 fStage3Image.Reset (image.Release ()); 3754 3755 } 3756 3757 /*****************************************************************************/ 3758 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 3788 void dng_negative::DoPostOpcodeList2 (dng_host & /* host */) 3789 { 3790 3791 // Nothing by default. 3792 3793 } 3794 3795 /*****************************************************************************/ 3796 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 3820 void dng_negative::DefloatStage2 (dng_host & /* host */) 3821 { 3822 3823 ThrowNotYetImplemented ("dng_negative::DefloatStage2"); 3824 3825 } 3826 3827 /*****************************************************************************/ 3828 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 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 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 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 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 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 4301 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 4358 virtual dng_rect RepeatingTile1 () const 4359 { 4360 return fSrcImage.RepeatingTile (); 4361 } 4362 4363 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 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 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 4470 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 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 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 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 4895 void dng_negative::NeedLinearizationInfo () 4896 { 4897 4898 if (!fLinearizationInfo.Get ()) 4899 { 4900 4901 fLinearizationInfo.Reset (MakeLinearizationInfo ()); 4902 4903 } 4904 4905 } 4906 4907 /*****************************************************************************/ 4908 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 4925 void dng_negative::NeedMosaicInfo () 4926 { 4927 4928 if (!fMosaicInfo.Get ()) 4929 { 4930 4931 fMosaicInfo.Reset (MakeMosaicInfo ()); 4932 4933 } 4934 4935 } 4936 4937 /*****************************************************************************/ 4938 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 4951 const dng_image * dng_negative::TransparencyMask () const 4952 { 4953 4954 return fTransparencyMask.Get (); 4955 4956 } 4957 4958 /*****************************************************************************/ 4959 4960 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 4976 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 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 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 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 5099 void dng_negative::FlattenTransparency (dng_host & /* host */) 5100 { 5101 5102 ThrowNotYetImplemented (); 5103 5104 } 5105 5106 /*****************************************************************************/ 5107 5108 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
