Debian Codegraph @

core/libs/dngwriter/extra/dng_sdk/dng_preview.cpp

raw
1 /*****************************************************************************/
2 // Copyright 2007-2022 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 #include "dng_preview.h"
10
11 #include "dng_assertions.h"
12 #include "dng_host.h"
13 #include "dng_image.h"
14 #include "dng_image_writer.h"
15 #include "dng_jxl.h"
16 #include "dng_memory.h"
17 #include "dng_stream.h"
18 #include "dng_tag_codes.h"
19 #include "dng_tag_values.h"
20
21 /*****************************************************************************/
22
23 class dng_preview_tag_set: public dng_basic_tag_set
24 {
25
26 private:
27
28 tag_string fApplicationNameTag;
29
30 tag_string fApplicationVersionTag;
31
32 tag_string fSettingsNameTag;
33
34 dng_fingerprint fSettingsDigest;
35
36 tag_uint8_ptr fSettingsDigestTag;
37
38 tag_uint32 fColorSpaceTag;
39
40 tag_string fDateTimeTag;
41
42 tag_real64 fRawToPreviewGainTag;
43
44 tag_uint32 fCacheVersionTag;
45
46 public:
47
48 dng_preview_tag_set (dng_tiff_directory &directory,
49 const dng_preview &preview,
50 const dng_ifd &ifd);
51
52 virtual ~dng_preview_tag_set ();
53
54 };
55
56 /*****************************************************************************/
57
58 dng_preview_tag_set::dng_preview_tag_set (dng_tiff_directory &directory,
59 const dng_preview &preview,
60 const dng_ifd &ifd)
61
62 : dng_basic_tag_set (directory, ifd)
63
64 , fApplicationNameTag (tcPreviewApplicationName,
65 preview.fInfo.fApplicationName,
66 false)
67
68 , fApplicationVersionTag (tcPreviewApplicationVersion,
69 preview.fInfo.fApplicationVersion,
70 false)
71
72 , fSettingsNameTag (tcPreviewSettingsName,
73 preview.fInfo.fSettingsName,
74 false)
75
76 , fSettingsDigest (preview.fInfo.fSettingsDigest)
77
78 , fSettingsDigestTag (tcPreviewSettingsDigest,
79 fSettingsDigest.data,
80 16)
81
82 , fColorSpaceTag (tcPreviewColorSpace,
83 preview.fInfo.fColorSpace)
84
85 , fDateTimeTag (tcPreviewDateTime,
86 preview.fInfo.fDateTime,
87 true)
88
89 , fRawToPreviewGainTag (tcRawToPreviewGain,
90 preview.fInfo.fRawToPreviewGain)
91
92 , fCacheVersionTag (tcCacheVersion,
93 preview.fInfo.fCacheVersion)
94
95 {
96
97 if (preview.fInfo.fApplicationName.NotEmpty ())
98 {
99
100 directory.Add (&fApplicationNameTag);
101
102 }
103
104 if (preview.fInfo.fApplicationVersion.NotEmpty ())
105 {
106
107 directory.Add (&fApplicationVersionTag);
108
109 }
110
111 if (preview.fInfo.fSettingsName.NotEmpty ())
112 {
113
114 directory.Add (&fSettingsNameTag);
115
116 }
117
118 if (preview.fInfo.fSettingsDigest.IsValid ())
119 {
120
121 directory.Add (&fSettingsDigestTag);
122
123 }
124
125 if (preview.fInfo.fColorSpace != previewColorSpace_MaxEnum)
126 {
127
128 directory.Add (&fColorSpaceTag);
129
130 }
131
132 if (preview.fInfo.fDateTime.NotEmpty ())
133 {
134
135 directory.Add (&fDateTimeTag);
136
137 }
138
139 if (preview.fInfo.fRawToPreviewGain != 1.0)
140 {
141
142 directory.Add (&fRawToPreviewGainTag);
143
144 }
145
146 if (preview.fInfo.fCacheVersion != 0)
147 {
148
149 directory.Add (&fCacheVersionTag);
150
151 }
152
153 }
154
155 /*****************************************************************************/
156
157 dng_preview_tag_set::~dng_preview_tag_set ()
158 {
159
160 }
161
162 /*****************************************************************************/
163
164 void dng_preview::SetIFDInfo (dng_host & /* host */,
165 const dng_image &image)
166 {
167
168 fIFD.fNewSubFileType = fInfo.fIsPrimary ? sfPreviewImage
169 : sfAltPreviewImage;
170
171 fIFD.fImageWidth = image.Width ();
172 fIFD.fImageLength = image.Height ();
173
174 fIFD.fSamplesPerPixel = image.Planes ();
175
176 fIFD.fPhotometricInterpretation = fIFD.fSamplesPerPixel == 1 ? piBlackIsZero
177 : piRGB;
178
179 fIFD.fBitsPerSample [0] = TagTypeSize (image.PixelType ()) * 8;
180
181 fIFD.fSampleFormat [0] = image.PixelType () == ttFloat
182 ? sfFloatingPoint
183 : sfUnsignedInteger;
184
185 for (uint32 j = 1; j < fIFD.fSamplesPerPixel; j++)
186 {
187 fIFD.fBitsPerSample [j] = fIFD.fBitsPerSample [0];
188 fIFD.fSampleFormat [j] = fIFD.fSampleFormat [0];
189 }
190
191 fIFD.SetSingleStrip ();
192
193 }
194
195 /*****************************************************************************/
196
197 dng_basic_tag_set * dng_preview::AddTagSet (dng_host & /* host */,
198 dng_tiff_directory &directory) const
199 {
200
201 return new dng_preview_tag_set (directory, *this, fIFD);
202
203 }
204
205 /*****************************************************************************/
206
207 void dng_preview::WriteData (dng_host &host,
208 dng_image_writer &writer,
209 dng_basic_tag_set &basic,
210 dng_stream &stream) const
211 {
212
213 if (fCompressedImage.get ())
214 {
215
216 fCompressedImage->WriteData (stream,
217 basic);
218
219 }
220
221 else
222 {
223
224 writer.WriteImage (host,
225 fIFD,
226 basic,
227 stream,
228 *fImage);
229
230 }
231
232 }
233
234 /*****************************************************************************/
235
236 uint64 dng_preview::MaxImageDataByteCount () const
237 {
238
239 if (fCompressedImage.get ())
240 {
241
242 return fCompressedImage->NonHeaderSize ();
243
244 }
245
246 else
247 {
248
249 return fIFD.MaxImageDataByteCount ();
250
251 }
252
253 }
254
255 /*****************************************************************************/
256
257 void dng_preview::Compress (dng_host &host,
258 dng_image_writer &writer)
259 {
260
261 if (fIFD.fCompression == ccJXL ||
262 fIFD.fCompression == ccLossyJPEG ||
263 fIFD.fCompression == ccDeflate)
264 {
265
266 AutoPtr<dng_compressed_image_tiles> compressedImage
267 (new dng_compressed_image_tiles);
268
269 compressedImage->EncodeTiles (host,
270 writer,
271 *fImage,
272 fIFD);
273
274 fCompressedImage.reset (compressedImage.Release ());
275
276 fImage.reset ();
277
278 }
279
280 }
281
282 /*****************************************************************************/
283
284 class dng_jpeg_preview_tag_set: public dng_preview_tag_set
285 {
286
287 private:
288
289 dng_urational fCoefficientsData [3];
290
291 tag_urational_ptr fCoefficientsTag;
292
293 uint16 fSubSamplingData [2];
294
295 tag_uint16_ptr fSubSamplingTag;
296
297 tag_uint16 fPositioningTag;
298
299 dng_urational fReferenceData [6];
300
301 tag_urational_ptr fReferenceTag;
302
303 public:
304
305 dng_jpeg_preview_tag_set (dng_tiff_directory &directory,
306 const dng_jpeg_preview &preview,
307 const dng_ifd &ifd);
308
309 };
310
311 /******************************************************************************/
312
313 dng_jpeg_preview_tag_set::dng_jpeg_preview_tag_set (dng_tiff_directory &directory,
314 const dng_jpeg_preview &preview,
315 const dng_ifd &ifd)
316
317 : dng_preview_tag_set (directory, preview, ifd)
318
319 , fCoefficientsTag (tcYCbCrCoefficients, fCoefficientsData, 3)
320
321 , fSubSamplingTag (tcYCbCrSubSampling, fSubSamplingData, 2)
322
323 , fPositioningTag (tcYCbCrPositioning, ifd.fYCbCrPositioning)
324
325 , fReferenceTag (tcReferenceBlackWhite, fReferenceData, 6)
326
327 {
328
329 if (ifd.fPhotometricInterpretation == piYCbCr)
330 {
331
332 fCoefficientsData [0] = dng_urational (299, 1000);
333 fCoefficientsData [1] = dng_urational (587, 1000);
334 fCoefficientsData [2] = dng_urational (114, 1000);
335
336 directory.Add (&fCoefficientsTag);
337
338 fSubSamplingData [0] = (uint16) ifd.fYCbCrSubSampleH;
339 fSubSamplingData [1] = (uint16) ifd.fYCbCrSubSampleV;
340
341 directory.Add (&fSubSamplingTag);
342
343 directory.Add (&fPositioningTag);
344
345 fReferenceData [0] = dng_urational ( 0, 1);
346 fReferenceData [1] = dng_urational (255, 1);
347 fReferenceData [2] = dng_urational (128, 1);
348 fReferenceData [3] = dng_urational (255, 1);
349 fReferenceData [4] = dng_urational (128, 1);
350 fReferenceData [5] = dng_urational (255, 1);
351
352 directory.Add (&fReferenceTag);
353
354 }
355
356 }
357
358 /*****************************************************************************/
359
360 void dng_jpeg_preview::SetIFDInfo (dng_host &host,
361 const dng_image &image)
362 {
363
364 dng_preview::SetIFDInfo (host, image);
365
366 fIFD.fCompression = ccJPEG; // Lossy version
367
368 if (image.Planes () == 1)
369 {
370 fIFD.fPhotometricInterpretation = piBlackIsZero;
371 }
372
373 else
374 {
375 SetYCbCr (1, 1);
376 }
377
378 }
379
380 /*****************************************************************************/
381
382 void dng_jpeg_preview::SetCompressedData (AutoPtr<dng_memory_block> &compressedData)
383 {
384
385 fImage.reset ();
386
387 AutoPtr<dng_compressed_image_tiles> compressedTiles (new dng_compressed_image_tiles);
388
389 compressedTiles->fData.resize (1);
390
391 compressedTiles->fData [0].reset (compressedData.Release ());
392
393 fCompressedImage.reset (compressedTiles.Release ());
394
395 }
396
397 /*****************************************************************************/
398
399 const dng_memory_block & dng_jpeg_preview::CompressedData () const
400 {
401
402 DNG_REQUIRE (fCompressedImage.get () &&
403 fCompressedImage->fData.size () == 1,
404 "No compressed data");
405
406 return *(fCompressedImage->fData [0]);
407
408 }
409
410 /*****************************************************************************/
411
412 dng_basic_tag_set * dng_jpeg_preview::AddTagSet (dng_host & /* host */,
413 dng_tiff_directory &directory) const
414 {
415
416 return new dng_jpeg_preview_tag_set (directory, *this, fIFD);
417
418 }
419
420 /*****************************************************************************/
421
422 void dng_jpeg_preview::WriteData (dng_host &host,
423 dng_image_writer &writer,
424 dng_basic_tag_set &basic,
425 dng_stream &stream) const
426 {
427
428 // Force the data to be written using lossy JPEG.
429
430 fIFD.fCompression = ccLossyJPEG;
431
432 dng_preview::WriteData (host,
433 writer,
434 basic,
435 stream);
436
437 // But we still want to use the normal jpeg compression code in the IFD.
438
439 fIFD.fCompression = ccJPEG;
440
441 }
442
443 /*****************************************************************************/
444
445 uint64 dng_jpeg_preview::MaxImageDataByteCount () const
446 {
447
448 fIFD.fCompression = ccLossyJPEG;
449
450 uint64 result = dng_preview::MaxImageDataByteCount ();
451
452 fIFD.fCompression = ccJPEG;
453
454 return result;
455
456 }
457
458 /*****************************************************************************/
459
460 void dng_jpeg_preview::Compress (dng_host &host,
461 dng_image_writer &writer)
462 {
463
464 fIFD.fCompression = ccLossyJPEG;
465
466 dng_preview::Compress (host, writer);
467
468 fIFD.fCompression = ccJPEG;
469
470 }
471
472 /*****************************************************************************/
473
474 void dng_jpeg_preview::SpoolAdobeThumbnail (dng_stream &stream) const
475 {
476
477 DNG_ASSERT (fIFD.fPhotometricInterpretation == piYCbCr,
478 "SpoolAdobeThumbnail: Non-YCbCr");
479
480 uint32 compressedSize = CompressedData ().LogicalSize ();
481
482 stream.Put_uint32 (DNG_CHAR4 ('8','B','I','M'));
483 stream.Put_uint16 (1036);
484 stream.Put_uint16 (0);
485
486 stream.Put_uint32 (compressedSize + 28);
487
488 uint32 widthBytes = (fIFD.fImageWidth * 24 + 31) / 32 * 4;
489
490 stream.Put_uint32 (1);
491 stream.Put_uint32 (fIFD.fImageWidth);
492 stream.Put_uint32 (fIFD.fImageLength);
493 stream.Put_uint32 (widthBytes);
494 stream.Put_uint32 (widthBytes * fIFD.fImageLength);
495 stream.Put_uint32 (compressedSize);
496 stream.Put_uint16 (24);
497 stream.Put_uint16 (1);
498
499 stream.Put (CompressedData ().Buffer (),
500 compressedSize);
501
502 if (compressedSize & 1)
503 {
504 stream.Put_uint8 (0);
505 }
506
507 }
508
509 //*****************************************************************************/
510
511 void dng_jxl_preview::SetIFDInfo (dng_host &host,
512 const dng_image &image)
513 {
514
515 dng_preview::SetIFDInfo (host, image);
516
517 // Store a copy of the preview info so that the writer can get information
518 // about the color space.
519
520 fIFD.fPreviewInfo = this->fInfo;
521
522 fIFD.fCompression = ccJXL;
523 fIFD.fPredictor = cpNullPredictor;
524
525 AutoPtr<dng_jxl_encode_settings> settings (host.MakeJXLEncodeSettings (dng_host::use_case_RenderedPreview,
526 image));
527
528 fIFD.fJXLEncodeSettings.reset (settings.Release ());
529
530 fIFD.fJXLDistance = fIFD.fJXLEncodeSettings->Distance ();
531 fIFD.fJXLEffort = fIFD.fJXLEncodeSettings->Effort ();
532 fIFD.fJXLDecodeSpeed = fIFD.fJXLEncodeSettings->DecodeSpeed ();
533
534 }
535
536 /*****************************************************************************/
537
538 class dng_raw_preview_tag_set: public dng_preview_tag_set
539 {
540
541 private:
542
543 tag_data_ptr fOpcodeList2Tag;
544
545 tag_uint32_ptr fWhiteLevelTag;
546
547 uint32 fWhiteLevelData [kMaxColorPlanes];
548
549 tag_urational_ptr fBlackLevelTag;
550
551 dng_urational fBlackLevelData [kMaxColorPlanes];
552
553 public:
554
555 dng_raw_preview_tag_set (dng_tiff_directory &directory,
556 const dng_raw_preview &preview,
557 const dng_ifd &ifd);
558
559 virtual ~dng_raw_preview_tag_set ();
560
561 };
562
563 /*****************************************************************************/
564
565 dng_raw_preview_tag_set::dng_raw_preview_tag_set (dng_tiff_directory &directory,
566 const dng_raw_preview &preview,
567 const dng_ifd &ifd)
568
569 : dng_preview_tag_set (directory, preview, ifd)
570
571 , fOpcodeList2Tag (tcOpcodeList2,
572 ttUndefined,
573 0,
574 NULL)
575
576 , fWhiteLevelTag (tcWhiteLevel,
577 fWhiteLevelData,
578 preview.SamplesPerPixel ())
579
580 , fBlackLevelTag (tcBlackLevel,
581 fBlackLevelData,
582 preview.SamplesPerPixel ())
583
584 {
585
586 if (preview.fOpcodeList2Data.Get ())
587 {
588
589 fOpcodeList2Tag.SetData (preview.fOpcodeList2Data->Buffer ());
590 fOpcodeList2Tag.SetCount (preview.fOpcodeList2Data->LogicalSize ());
591
592 directory.Add (&fOpcodeList2Tag);
593
594 }
595
596 if (preview.SampleFormat () == sfFloatingPoint)
597 {
598
599 for (uint32 j = 0; j < kMaxColorPlanes; j++)
600 {
601 fWhiteLevelData [j] = 32768;
602 }
603
604 directory.Add (&fWhiteLevelTag);
605
606 }
607
608 else
609 {
610
611 bool nonZeroBlack = false;
612
613 for (uint32 j = 0; j < preview.SamplesPerPixel (); j++)
614 {
615
616 fBlackLevelData [j].Set_real64 (preview.fBlackLevel [j], 1);
617
618 nonZeroBlack = nonZeroBlack || (preview.fBlackLevel [j] != 0.0);
619
620 }
621
622 if (nonZeroBlack)
623 {
624
625 directory.Add (&fBlackLevelTag);
626
627 }
628
629 }
630
631 }
632
633 /*****************************************************************************/
634
635 dng_raw_preview_tag_set::~dng_raw_preview_tag_set ()
636 {
637
638 }
639
640 /*****************************************************************************/
641
642 dng_raw_preview::dng_raw_preview ()
643 {
644
645 for (uint32 n = 0; n < kMaxColorPlanes; n++)
646 {
647 fBlackLevel [n] = 0.0;
648 }
649
650 }
651
652 /*****************************************************************************/
653
654 void dng_raw_preview::SetIFDInfo (dng_host &host,
655 const dng_image &image)
656 {
657
658 dng_preview::SetIFDInfo (host, image);
659
660 fIFD.fNewSubFileType = sfPreviewImage;
661
662 fIFD.fPhotometricInterpretation = piLinearRaw;
663
664 if (image.PixelType () == ttFloat)
665 {
666
667 if (fPreferJXL && SupportsJXL (*fImage))
668 {
669 fIFD.fCompression = ccJXL;
670 fIFD.fPredictor = cpNullPredictor;
671 }
672
673 else
674 {
675 fIFD.fCompression = ccDeflate;
676 fIFD.fCompressionQuality = fCompressionQuality;
677 fIFD.fPredictor = cpFloatingPoint;
678 }
679
680 for (uint32 j = 0; j < fIFD.fSamplesPerPixel; j++)
681 {
682 fIFD.fBitsPerSample [j] = 16;
683 }
684
685 fIFD.FindTileSize (512 * 1024);
686
687 }
688
689 else
690 {
691
692 if (fPreferJXL && SupportsJXL (*fImage))
693 {
694 fIFD.fCompression = ccJXL;
695 fIFD.fPredictor = cpNullPredictor;
696 }
697
698 else
699 {
700 fIFD.fCompression = ccLossyJPEG;
701 fIFD.fCompressionQuality = fCompressionQuality;
702 }
703
704 fIFD.FindTileSize (512 * 512 * fIFD.fSamplesPerPixel);
705
706 }
707
708 if (fIFD.fCompression == ccJXL)
709 {
710
711 // Use default host for the raw preview compression settings so any customizations
712 // targeted for the actual main image are not used.
713
714 dng_host defaultHost;
715
716 // Use same compression quality as if encoding a non-full size proxy image.
717
718 AutoPtr<dng_jxl_encode_settings> settings (defaultHost.MakeJXLEncodeSettings (dng_host::use_case_ProxyImage,
719 image));
720
721 if (fForNegativeCache)
722 {
723 settings->SetEffort (1);
724 }
725
726 fIFD.fJXLEncodeSettings.reset (settings.Release ());
727
728 fIFD.fJXLDistance = fIFD.fJXLEncodeSettings->Distance ();
729 fIFD.fJXLEffort = fIFD.fJXLEncodeSettings->Effort ();
730 fIFD.fJXLDecodeSpeed = fIFD.fJXLEncodeSettings->DecodeSpeed ();
731
732 if (image.PixelType () == ttShort)
733 {
734
735 AutoPtr<JxlColorEncoding> encoding (new JxlColorEncoding);
736
737 memset (encoding.Get (), 0, sizeof (JxlColorEncoding));
738
739 // EncodeImageForCompression leaves the image far from linear gamma,
740 // so let's pretend it is sRGB gamma.
741
742 encoding->color_space = image.Planes () == 1 ? JXL_COLOR_SPACE_GRAY
743 : JXL_COLOR_SPACE_RGB;
744 encoding->white_point = JXL_WHITE_POINT_D65;
745 encoding->primaries = JXL_PRIMARIES_2100;
746 encoding->transfer_function = JXL_TRANSFER_FUNCTION_SRGB;
747
748 fIFD.fJXLColorEncoding.reset (encoding.Release ());
749
750 }
751
752 }
753
754 }
755
756 /*****************************************************************************/
757
758 dng_basic_tag_set * dng_raw_preview::AddTagSet (dng_host & /* host */,
759 dng_tiff_directory &directory) const
760 {
761
762 return new dng_raw_preview_tag_set (directory, *this, fIFD);
763
764 }
765
766 /*****************************************************************************/
767
768 void dng_mask_preview::SetIFDInfo (dng_host &host,
769 const dng_image &image)
770 {
771
772 dng_preview::SetIFDInfo (host, image);
773
774 fIFD.fNewSubFileType = sfPreviewMask;
775
776 fIFD.fPhotometricInterpretation = piTransparencyMask;
777
778 fIFD.FindTileSize (512 * 512 * fIFD.fSamplesPerPixel);
779
780 if (fPreferJXL && SupportsJXL (*fImage))
781 {
782 fIFD.fCompression = ccJXL;
783 fIFD.fPredictor = cpNullPredictor;
784 }
785
786 else
787 {
788
789 fIFD.fCompression = ccDeflate;
790 fIFD.fPredictor = cpHorizontalDifference;
791
792 fIFD.fCompressionQuality = fCompressionQuality;
793
794 }
795
796 if (fIFD.fCompression == ccJXL)
797 {
798
799 AutoPtr<dng_jxl_encode_settings> settings (host.MakeJXLEncodeSettings (dng_host::use_case_Transparency,
800 image));
801
802 if (fForNegativeCache)
803 {
804 settings->SetEffort (1);
805 }
806
807 fIFD.fJXLEncodeSettings.reset (settings.Release ());
808
809 fIFD.fJXLDistance = fIFD.fJXLEncodeSettings->Distance ();
810 fIFD.fJXLEffort = fIFD.fJXLEncodeSettings->Effort ();
811 fIFD.fJXLDecodeSpeed = fIFD.fJXLEncodeSettings->DecodeSpeed ();
812
813 }
814
815 }
816
817 /*****************************************************************************/
818
819 dng_basic_tag_set * dng_mask_preview::AddTagSet (dng_host & /* host */,
820 dng_tiff_directory &directory) const
821 {
822
823 return new dng_basic_tag_set (directory, fIFD);
824
825 }
826
827 /*****************************************************************************/
828
829 void dng_semantic_mask_preview::SetIFDInfo (dng_host &host,
830 const dng_image &image)
831 {
832
833 dng_preview::SetIFDInfo (host, image);
834
835 fIFD.fNewSubFileType = fOriginalSize ? sfSemanticMask
836 : sfPreviewSemanticMask;
837
838 fIFD.fPhotometricInterpretation = piPhotometricMask;
839
840 fIFD.FindTileSize (512 * 512 * fIFD.fSamplesPerPixel);
841
842 if (fPreferJXL && SupportsJXL (*fImage))
843 {
844 fIFD.fCompression = ccJXL;
845 fIFD.fPredictor = cpNullPredictor;
846 }
847
848 else
849 {
850
851 fIFD.fCompression = ccDeflate;
852 fIFD.fPredictor = cpHorizontalDifference;
853
854 fIFD.fCompressionQuality = fCompressionQuality;
855
856 }
857
858 if (fIFD.fCompression == ccJXL)
859 {
860
861 AutoPtr<dng_jxl_encode_settings> settings (host.MakeJXLEncodeSettings (dng_host::use_case_SemanticMask,
862 image));
863
864 if (fForNegativeCache)
865 {
866 settings->SetEffort (1);
867 }
868
869 fIFD.fJXLEncodeSettings.reset (settings.Release ());
870
871 fIFD.fJXLDistance = fIFD.fJXLEncodeSettings->Distance ();
872 fIFD.fJXLEffort = fIFD.fJXLEncodeSettings->Effort ();
873 fIFD.fJXLDecodeSpeed = fIFD.fJXLEncodeSettings->DecodeSpeed ();
874
875 }
876
877 }
878
879 /*****************************************************************************/
880
881 dng_basic_tag_set * dng_semantic_mask_preview::AddTagSet (dng_host & /* host */,
882 dng_tiff_directory &directory) const
883 {
884
885 // Need to write the name and instance ID to the directory, too. Otherwise
886 // we won't have corresponding labels when reading the image back in.
887
888 fTagName.reset (new tag_string (tcSemanticName,
889 fName,
890 false));
891
892 fTagInstanceID.reset (new tag_string (tcSemanticInstanceID,
893 fInstanceID,
894 false));
895
896 directory.Add (fTagName.get ());
897
898 directory.Add (fTagInstanceID.get ());
899
900 // Also need to add the MaskSubArea info.
901
902 fTagMaskSubArea.reset (new tag_uint32_ptr (tcMaskSubArea,
903 & fMaskSubArea [0],
904 4));
905
906 directory.Add (fTagMaskSubArea.get ());
907
908 return new dng_basic_tag_set (directory, fIFD);
909
910 }
911
912 /*****************************************************************************/
913
914 void dng_depth_preview::SetIFDInfo (dng_host &host,
915 const dng_image &image)
916 {
917
918 dng_preview::SetIFDInfo (host, image);
919
920 fIFD.fNewSubFileType = fFullResolution ? sfDepthMap
921 : sfPreviewDepthMap;
922
923 fIFD.fPhotometricInterpretation = piDepth;
924
925 fIFD.FindTileSize (512 * 512 * fIFD.fSamplesPerPixel);
926
927 if (fPreferJXL && SupportsJXL (*fImage))
928 {
929 fIFD.fCompression = ccJXL;
930 fIFD.fPredictor = cpNullPredictor;
931 }
932
933 else
934 {
935
936 fIFD.fCompression = ccDeflate;
937 fIFD.fPredictor = cpHorizontalDifference;
938
939 fIFD.fCompressionQuality = fCompressionQuality;
940
941 }
942
943 if (fIFD.fCompression == ccJXL)
944 {
945
946 AutoPtr<dng_jxl_encode_settings> settings (host.MakeJXLEncodeSettings (dng_host::use_case_Depth,
947 image));
948
949 if (fForNegativeCache)
950 {
951 settings->SetEffort (1);
952 }
953
954 fIFD.fJXLEncodeSettings.reset (settings.Release ());
955
956 fIFD.fJXLDistance = fIFD.fJXLEncodeSettings->Distance ();
957 fIFD.fJXLEffort = fIFD.fJXLEncodeSettings->Effort ();
958 fIFD.fJXLDecodeSpeed = fIFD.fJXLEncodeSettings->DecodeSpeed ();
959
960 }
961
962 }
963
964 /*****************************************************************************/
965
966 dng_basic_tag_set * dng_depth_preview::AddTagSet (dng_host & /* host */,
967 dng_tiff_directory &directory) const
968 {
969
970 return new dng_basic_tag_set (directory, fIFD);
971
972 }
973
974 /*****************************************************************************/
975
976 void dng_preview_list::Append (AutoPtr<dng_preview> &preview)
977 {
978
979 if (preview.Get ())
980 {
981
982 std::shared_ptr<const dng_preview> entry (preview.Release ());
983
984 fPreview.push_back (entry);
985
986 }
987
988 }
989
990 /*****************************************************************************/