Debian Codegraph @

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

raw
1 /*****************************************************************************/
2 // Copyright 2006-2023 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_host.h"
10
11 #include "dng_abort_sniffer.h"
12 #include "dng_area_task.h"
13 #include "dng_bad_pixels.h"
14 #include "dng_exceptions.h"
15 #include "dng_exif.h"
16 #include "dng_gain_map.h"
17 #include "dng_globals.h"
18 #include "dng_ifd.h"
19 #include "dng_jxl.h"
20 #include "dng_lens_correction.h"
21 #include "dng_memory.h"
22 #include "dng_misc_opcodes.h"
23 #include "dng_negative.h"
24 #include "dng_resample.h"
25 #include "dng_shared.h"
26 #include "dng_simple_image.h"
27
28 #if qDNGUseXMP
29 #include "dng_xmp.h"
30 #endif
31
32 /*****************************************************************************/
33
34 dng_host::dng_host (dng_memory_allocator *allocator,
35 dng_abort_sniffer *sniffer)
36
37 : fAllocator (allocator)
38 , fSniffer (sniffer)
39
40 , fNeedsMeta (true)
41 , fNeedsImage (true)
42 , fForPreview (false)
43 , fMinimumSize (0)
44 , fPreferredSize (0)
45 , fMaximumSize (0)
46 , fCropFactor (1.0)
47 , fSaveDNGVersion (dngVersion_None)
48 , fSaveLinearDNG (false)
49 , fKeepOriginalFile (false)
50 , fIgnoreEnhanced (false)
51 , fForFastSaveToDNG (false)
52 , fFastSaveToDNGSize (0)
53 , fPreserveStage2 (false)
54
55 {
56
57 }
58
59 /*****************************************************************************/
60
61 dng_host::~dng_host ()
62 {
63
64 }
65
66 /*****************************************************************************/
67
68 dng_memory_allocator & dng_host::Allocator ()
69 {
70
71 if (fAllocator)
72 {
73
74 return *fAllocator;
75
76 }
77
78 else
79 {
80
81 return gDefaultDNGMemoryAllocator;
82
83 }
84
85 }
86
87 /*****************************************************************************/
88
89 dng_memory_block * dng_host::Allocate (uint32 logicalSize)
90 {
91
92 return Allocator ().Allocate (logicalSize);
93
94 }
95
96 /*****************************************************************************/
97
98 void dng_host::SniffForAbort ()
99 {
100
101 dng_abort_sniffer::SniffForAbort (Sniffer ());
102
103 }
104
105 /*****************************************************************************/
106
107 void dng_host::ValidateSizes ()
108 {
109
110 // The maximum size limits the other two sizes.
111
112 if (MaximumSize ())
113 {
114 SetMinimumSize (Min_uint32 (MinimumSize (), MaximumSize ()));
115 SetPreferredSize (Min_uint32 (PreferredSize (), MaximumSize ()));
116 }
117
118 // If we have a preferred size, it limits the minimum size.
119
120 if (PreferredSize ())
121 {
122 SetMinimumSize (Min_uint32 (MinimumSize (), PreferredSize ()));
123 }
124
125 // Else find default value for preferred size.
126
127 else
128 {
129
130 // If preferred size is zero, then we want the maximim
131 // size image.
132
133 if (MaximumSize ())
134 {
135 SetPreferredSize (MaximumSize ());
136 }
137
138 }
139
140 // If we don't have a minimum size, find default.
141
142 if (!MinimumSize ())
143 {
144
145 // A common size for embedded thumbnails is 120 by 160 pixels,
146 // So allow 120 by 160 pixels to be used for thumbnails when the
147 // preferred size is 256 pixel.
148
149 if (PreferredSize () >= 160 && PreferredSize () <= 256)
150 {
151 SetMinimumSize (160);
152 }
153
154 // Many sensors are near a multiple of 1024 pixels in size, but after
155 // the default crop, they are a just under. We can get an extra factor
156 // of size reduction if we allow a slight undershoot in the final size
157 // when computing large previews.
158
159 else if (PreferredSize () >= 490 && PreferredSize () <= 512)
160 {
161 SetMinimumSize (490);
162 }
163
164 else if (PreferredSize () >= 980 && PreferredSize () <= 1024)
165 {
166 SetMinimumSize (980);
167 }
168
169 else if (PreferredSize () >= 1470 && PreferredSize () <= 1536)
170 {
171 SetMinimumSize (1470);
172 }
173
174 else if (PreferredSize () >= 1960 && PreferredSize () <= 2048)
175 {
176 SetMinimumSize (1960);
177 }
178
179 else if (PreferredSize () >= 2400 && PreferredSize () <= 2560)
180 {
181 SetMinimumSize (2400);
182 }
183
184 // The following resolutions are typically on HiDPI displays where a
185 // greater degree of upsampling remains visually ok for previews. The
186 // following ratios are all based on 20% upsampling in a linear
187 // dimension.
188
189 else if (PreferredSize () >= 2448 && PreferredSize () <= 2880)
190 {
191 SetMinimumSize (2448);
192 }
193
194 // 1st-generation Surface Book.
195
196 else if (PreferredSize () >= 2560 && PreferredSize () <= 3000)
197 {
198 SetMinimumSize (2560);
199 }
200
201 // 4K (actually 3840).
202
203 else if (PreferredSize () >= 3480 && PreferredSize () <= 4096)
204 {
205 SetMinimumSize (3480);
206 }
207
208 // Surface Studio.
209
210 else if (PreferredSize () >= 3824 && PreferredSize () <= 4500)
211 {
212 SetMinimumSize (3824);
213 }
214
215 // 5K.
216
217 else if (PreferredSize () >= 4352 && PreferredSize () <= 5120)
218 {
219 SetMinimumSize (4352);
220 }
221
222 // 8K.
223
224 else if (PreferredSize () >= 6528 && PreferredSize () <= 7680)
225 {
226 SetMinimumSize (6528);
227 }
228
229 // Else minimum size is same as preferred size.
230
231 else
232 {
233 SetMinimumSize (PreferredSize ());
234 }
235
236 }
237
238 }
239
240 /*****************************************************************************/
241
242 uint32 dng_host::SaveDNGVersion () const
243 {
244
245 return fSaveDNGVersion;
246
247 }
248
249 /*****************************************************************************/
250
251 bool dng_host::SaveLinearDNG (const dng_negative & /* negative */) const
252 {
253
254 return fSaveLinearDNG;
255
256 }
257
258 /*****************************************************************************/
259
260 bool dng_host::IsTransientError (dng_error_code code)
261 {
262
263 switch (code)
264 {
265
266 case dng_error_memory:
267 case dng_error_user_canceled:
268 {
269 return true;
270 }
271
272 default:
273 break;
274
275 }
276
277 return false;
278
279 }
280
281 /*****************************************************************************/
282
283 void dng_host::PerformAreaTask (dng_area_task &task,
284 const dng_rect &area,
285 dng_area_task_progress *progress)
286 {
287
288 dng_area_task::Perform (task,
289 area,
290 &Allocator (),
291 Sniffer (),
292 progress);
293
294 }
295
296 /*****************************************************************************/
297
298 uint32 dng_host::PerformAreaTaskThreads ()
299 {
300
301 return 1;
302
303 }
304
305 /*****************************************************************************/
306
307 dng_exif * dng_host::Make_dng_exif ()
308 {
309
310 dng_exif *result = new dng_exif ();
311
312 if (!result)
313 {
314
315 ThrowMemoryFull ();
316
317 }
318
319 return result;
320
321 }
322
323 /*****************************************************************************/
324
325 #if qDNGUseXMP
326
327 /*****************************************************************************/
328
329 dng_xmp * dng_host::Make_dng_xmp ()
330 {
331
332 dng_xmp *result = new dng_xmp (Allocator ());
333
334 if (!result)
335 {
336
337 ThrowMemoryFull ();
338
339 }
340
341 return result;
342
343 }
344
345 /*****************************************************************************/
346
347 #endif // qDNGUseXMP
348
349 /*****************************************************************************/
350
351 dng_shared * dng_host::Make_dng_shared ()
352 {
353
354 dng_shared *result = new dng_shared ();
355
356 if (!result)
357 {
358
359 ThrowMemoryFull ();
360
361 }
362
363 return result;
364
365 }
366
367 /*****************************************************************************/
368
369 dng_ifd * dng_host::Make_dng_ifd ()
370 {
371
372 dng_ifd *result = new dng_ifd ();
373
374 if (!result)
375 {
376
377 ThrowMemoryFull ();
378
379 }
380
381 return result;
382
383 }
384
385 /*****************************************************************************/
386
387 dng_negative * dng_host::Make_dng_negative ()
388 {
389
390 return dng_negative::Make (*this);
391
392 }
393
394 /*****************************************************************************/
395
396 dng_image * dng_host::Make_dng_image (const dng_rect &bounds,
397 uint32 planes,
398 uint32 pixelType)
399 {
400
401 dng_image *result = new dng_simple_image (bounds,
402 planes,
403 pixelType,
404 Allocator ());
405
406 if (!result)
407 {
408
409 ThrowMemoryFull ();
410
411 }
412
413 return result;
414
415 }
416
417 /*****************************************************************************/
418
419 dng_opcode * dng_host::Make_dng_opcode (uint32 opcodeID,
420 dng_stream &stream)
421 {
422
423 dng_opcode *result = NULL;
424
425 switch (opcodeID)
426 {
427
428 case dngOpcode_WarpRectilinear:
429 {
430
431 result = new dng_opcode_WarpRectilinear (stream);
432
433 break;
434
435 }
436
437 case dngOpcode_WarpRectilinear2:
438 {
439
440 result = new dng_opcode_WarpRectilinear2 (stream);
441
442 break;
443
444 }
445
446 case dngOpcode_WarpFisheye:
447 {
448
449 result = new dng_opcode_WarpFisheye (stream);
450
451 break;
452
453 }
454
455 case dngOpcode_FixVignetteRadial:
456 {
457
458 result = new dng_opcode_FixVignetteRadial (stream);
459
460 break;
461
462 }
463
464 case dngOpcode_FixBadPixelsConstant:
465 {
466
467 result = new dng_opcode_FixBadPixelsConstant (stream);
468
469 break;
470
471 }
472
473 case dngOpcode_FixBadPixelsList:
474 {
475
476 result = new dng_opcode_FixBadPixelsList (stream);
477
478 break;
479
480 }
481
482 case dngOpcode_TrimBounds:
483 {
484
485 result = new dng_opcode_TrimBounds (stream);
486
487 break;
488
489 }
490
491 case dngOpcode_MapTable:
492 {
493
494 result = new dng_opcode_MapTable (*this,
495 stream);
496
497 break;
498
499 }
500
501 case dngOpcode_MapPolynomial:
502 {
503
504 result = new dng_opcode_MapPolynomial (stream);
505
506 break;
507
508 }
509
510 case dngOpcode_GainMap:
511 {
512
513 result = new dng_opcode_GainMap (*this,
514 stream);
515
516 break;
517
518 }
519
520 case dngOpcode_DeltaPerRow:
521 {
522
523 result = new dng_opcode_DeltaPerRow (*this,
524 stream);
525
526 break;
527
528 }
529
530 case dngOpcode_DeltaPerColumn:
531 {
532
533 result = new dng_opcode_DeltaPerColumn (*this,
534 stream);
535
536 break;
537
538 }
539
540 case dngOpcode_ScalePerRow:
541 {
542
543 result = new dng_opcode_ScalePerRow (*this,
544 stream);
545
546 break;
547
548 }
549
550 case dngOpcode_ScalePerColumn:
551 {
552
553 result = new dng_opcode_ScalePerColumn (*this,
554 stream);
555
556 break;
557
558 }
559
560 default:
561 {
562
563 result = new dng_opcode_Unknown (*this,
564 opcodeID,
565 stream);
566
567 }
568
569 }
570
571 if (!result)
572 {
573
574 ThrowMemoryFull ();
575
576 }
577
578 return result;
579
580 }
581
582 /*****************************************************************************/
583
584 dng_rgb_to_rgb_table_data *
585 dng_host::Make_dng_rgb_to_rgb_table_data (const dng_rgb_table &table)
586 {
587
588 return new dng_rgb_to_rgb_table_data (*this,
589 table);
590
591 }
592
593 /*****************************************************************************/
594
595 void dng_host::ApplyOpcodeList (dng_opcode_list &list,
596 dng_negative &negative,
597 AutoPtr<dng_image> &image)
598 {
599
600 list.Apply (*this,
601 negative,
602 image);
603
604 }
605
606 /*****************************************************************************/
607
608 void dng_host::ResampleImage (const dng_image &srcImage,
609 dng_image &dstImage)
610 {
611
612 ::ResampleImage (*this,
613 srcImage,
614 dstImage,
615 srcImage.Bounds (),
616 dstImage.Bounds (),
617 dng_resample_bicubic::Get ());
618
619 }
620
621 /*****************************************************************************/
622
623 void dng_host::SetJXLEncodeSettings (const dng_jxl_encode_settings &settings)
624 {
625
626 fJXLEncodeSettings.reset (new dng_jxl_encode_settings (settings));
627
628 }
629
630 /*****************************************************************************/
631
632 dng_jxl_encode_settings *
633 dng_host::MakeJXLEncodeSettings (use_case_enum useCase,
634 const dng_image &image,
635 const dng_negative * /* negative */) const
636 {
637
638 bool isFloat = (image.PixelType () == ttFloat);
639
640 AutoPtr<dng_jxl_encode_settings> settings (new dng_jxl_encode_settings);
641
642 settings->SetEffort (7);
643
644 switch (useCase)
645 {
646
647 case use_case_LossyMosaic:
648 {
649 settings->SetDistance (0.2f);
650 break;
651 }
652
653 case use_case_LosslessMosaic:
654 case use_case_LosslessMainImage:
655 case use_case_LosslessEnhancedImage:
656 case use_case_LosslessGainMap:
657 {
658 settings->SetDistance (0.0f);
659 settings->SetUseOriginalColorEncoding (true);
660 break;
661 }
662
663 case use_case_MainImage:
664 case use_case_EncodedMainImage:
665 case use_case_ProxyImage:
666 {
667
668 // If we have special settings attached to the host, just use them.
669
670 if (JXLEncodeSettings ())
671 {
672
673 *settings = *JXLEncodeSettings ();
674
675 }
676
677 else
678 {
679
680 bool useHigherQuality = (useCase != use_case_ProxyImage) ||
681 ((uint64) image.Width () *
682 (uint64) image.Height () >= 5000000);
683
684 if (isFloat)
685 {
686
687 settings->SetDistance (useHigherQuality ? 1.0f : 2.0f);
688
689 }
690
691 else if (useCase == use_case_MainImage)
692 {
693
694 // For non-encoded integer main images, we need to use very conservative
695 // compression settings.
696
697 settings->SetDistance (0.01f);
698
699 }
700
701 else
702 {
703
704 settings->SetDistance (useHigherQuality ? 0.5f : 1.0f);
705
706 }
707
708 }
709
710 break;
711
712 }
713
714 case use_case_EnhancedImage:
715 {
716 settings->SetDistance (isFloat ? 0.5f : 0.01f);
717 break;
718 }
719
720 case use_case_MergeResults:
721 {
722 settings->SetDistance (isFloat ? 0.5f : 0.1f);
723 break;
724 }
725
726 case use_case_Transparency:
727 {
728
729 if (isFloat)
730 {
731 settings->SetDistance (1.0f);
732 break;
733 }
734
735 // Fall through
736
737 }
738
739 case use_case_LosslessTransparency:
740 {
741
742 // Fast lossless.
743
744 settings->SetDistance (0.0f);
745 settings->SetEffort (1);
746 settings->SetUseOriginalColorEncoding (true);
747
748 break;
749
750 }
751
752 case use_case_Depth:
753 case use_case_SemanticMask:
754 {
755
756 if (isFloat)
757 {
758 settings->SetDistance (1.0f);
759 break;
760 }
761
762 // Fall through
763
764 }
765
766 case use_case_LosslessDepth:
767 case use_case_LosslessSemanticMask:
768 {
769
770 // Medium lossless.
771
772 settings->SetDistance (0.0f);
773 settings->SetEffort (3);
774 settings->SetUseOriginalColorEncoding (true);
775
776 break;
777
778 }
779
780 case use_case_RenderedPreview:
781 {
782 settings->SetDistance (2.0f);
783 break;
784 }
785
786 case use_case_GainMap:
787 {
788 settings->SetDistance (1.0);
789 break;
790 }
791
792 }
793
794 return settings.Release ();
795
796 }
797
798 /*****************************************************************************/