Debian Codegraph @

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

raw
1 /*****************************************************************************/
2 // Copyright 2006-2019 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_pixel_buffer.h"
10
11 #include "dng_bottlenecks.h"
12 #include "dng_exceptions.h"
13 #include "dng_flags.h"
14 #include "dng_tag_types.h"
15 #include "dng_tag_values.h"
16 #include "dng_utils.h"
17
18 /*****************************************************************************/
19
20 static bool SafeUint32ToInt32Mult (uint32 arg1,
21 uint32 arg2,
22 int32 *result)
23 {
24
25 uint32 uint32_result;
26
27 return (SafeUint32Mult (arg1,
28 arg2,
29 &uint32_result) &&
30
31 ConvertUint32ToInt32 (uint32_result,
32 result));
33
34 }
35
36 /*****************************************************************************/
37
38 void OptimizeOrder (const void *&sPtr,
39 void *&dPtr,
40 uint32 sPixelSize,
41 uint32 dPixelSize,
42 uint32 &count0,
43 uint32 &count1,
44 uint32 &count2,
45 int32 &sStep0,
46 int32 &sStep1,
47 int32 &sStep2,
48 int32 &dStep0,
49 int32 &dStep1,
50 int32 &dStep2)
51 {
52
53 uint32 step0;
54 uint32 step1;
55 uint32 step2;
56
57 // Optimize the order for the data that is most spread out.
58
59 uint32 sRange = Abs_int32 (sStep0) * (count0 - 1) +
60 Abs_int32 (sStep1) * (count1 - 1) +
61 Abs_int32 (sStep2) * (count2 - 1);
62
63 uint32 dRange = Abs_int32 (dStep0) * (count0 - 1) +
64 Abs_int32 (dStep1) * (count1 - 1) +
65 Abs_int32 (dStep2) * (count2 - 1);
66
67 if (dRange >= sRange)
68 {
69
70 if (dStep0 < 0)
71 {
72
73 sPtr = (const void *)
74 (((const uint8 *) sPtr) + (int32)(count0 - 1) * sStep0 * (int32)sPixelSize);
75
76 dPtr = (void *)
77 (((uint8 *) dPtr) + (int32)(count0 - 1) * dStep0 * (int32)dPixelSize);
78
79 sStep0 = -sStep0;
80 dStep0 = -dStep0;
81
82 }
83
84 if (dStep1 < 0)
85 {
86
87 sPtr = (const void *)
88 (((const uint8 *) sPtr) + (int32)(count1 - 1) * sStep1 * (int32)sPixelSize);
89
90 dPtr = (void *)
91 (((uint8 *) dPtr) + (int32)(count1 - 1) * dStep1 * (int32)dPixelSize);
92
93 sStep1 = -sStep1;
94 dStep1 = -dStep1;
95
96 }
97
98 if (dStep2 < 0)
99 {
100
101 sPtr = (const void *)
102 (((const uint8 *) sPtr) + (int32)(count2 - 1) * sStep2 * (int32)sPixelSize);
103
104 dPtr = (void *)
105 (((uint8 *) dPtr) + (int32)(count2 - 1) * dStep2 * (int32)dPixelSize);
106
107 sStep2 = -sStep2;
108 dStep2 = -dStep2;
109
110 }
111
112 step0 = (uint32) dStep0;
113 step1 = (uint32) dStep1;
114 step2 = (uint32) dStep2;
115
116 }
117
118 else
119 {
120
121 if (sStep0 < 0)
122 {
123
124 sPtr = (const void *)
125 (((const uint8 *) sPtr) + (int32)(count0 - 1) * sStep0 * (int32)sPixelSize);
126
127 dPtr = (void *)
128 (((uint8 *) dPtr) + (int32)(count0 - 1) * dStep0 * (int32)dPixelSize);
129
130 sStep0 = -sStep0;
131 dStep0 = -dStep0;
132
133 }
134
135 if (sStep1 < 0)
136 {
137
138 sPtr = (const void *)
139 (((const uint8 *) sPtr) + (int32)(count1 - 1) * sStep1 * (int32)sPixelSize);
140
141 dPtr = (void *)
142 (((uint8 *) dPtr) + (int32)(count1 - 1) * dStep1 * (int32)dPixelSize);
143
144 sStep1 = -sStep1;
145 dStep1 = -dStep1;
146
147 }
148
149 if (sStep2 < 0)
150 {
151
152 sPtr = (const void *)
153 (((const uint8 *) sPtr) + (int32)(count2 - 1) * sStep2 * (int32)sPixelSize);
154
155 dPtr = (void *)
156 (((uint8 *) dPtr) + (int32)(count2 - 1) * dStep2 * (int32)dPixelSize);
157
158 sStep2 = -sStep2;
159 dStep2 = -dStep2;
160
161 }
162
163 step0 = (uint32) sStep0;
164 step1 = (uint32) sStep1;
165 step2 = (uint32) sStep2;
166
167 }
168
169 if (count0 == 1) step0 = 0xFFFFFFFF;
170 if (count1 == 1) step1 = 0xFFFFFFFF;
171 if (count2 == 1) step2 = 0xFFFFFFFF;
172
173 uint32 index0;
174 uint32 index1;
175 uint32 index2;
176
177 if (step0 >= step1)
178 {
179
180 if (step1 >= step2)
181 {
182 index0 = 0;
183 index1 = 1;
184 index2 = 2;
185 }
186
187 else if (step2 >= step0)
188 {
189 index0 = 2;
190 index1 = 0;
191 index2 = 1;
192 }
193
194 else
195 {
196 index0 = 0;
197 index1 = 2;
198 index2 = 1;
199 }
200
201 }
202
203 else
204 {
205
206 if (step0 >= step2)
207 {
208 index0 = 1;
209 index1 = 0;
210 index2 = 2;
211 }
212
213 else if (step2 >= step1)
214 {
215 index0 = 2;
216 index1 = 1;
217 index2 = 0;
218 }
219
220 else
221 {
222 index0 = 1;
223 index1 = 2;
224 index2 = 0;
225 }
226
227 }
228
229 uint32 count [3];
230
231 count [0] = count0;
232 count [1] = count1;
233 count [2] = count2;
234
235 count0 = count [index0];
236 count1 = count [index1];
237 count2 = count [index2];
238
239 int32 step [3];
240
241 step [0] = sStep0;
242 step [1] = sStep1;
243 step [2] = sStep2;
244
245 sStep0 = step [index0];
246 sStep1 = step [index1];
247 sStep2 = step [index2];
248
249 step [0] = dStep0;
250 step [1] = dStep1;
251 step [2] = dStep2;
252
253 dStep0 = step [index0];
254 dStep1 = step [index1];
255 dStep2 = step [index2];
256
257 if (sStep0 == ((int32) count1) * sStep1 &&
258 dStep0 == ((int32) count1) * dStep1)
259 {
260 count1 *= count0;
261 count0 = 1;
262 }
263
264 if (sStep1 == ((int32) count2) * sStep2 &&
265 dStep1 == ((int32) count2) * dStep2)
266 {
267 count2 *= count1;
268 count1 = 1;
269 }
270
271 }
272
273 /*****************************************************************************/
274
275 void OptimizeOrder (const void *&sPtr,
276 uint32 sPixelSize,
277 uint32 &count0,
278 uint32 &count1,
279 uint32 &count2,
280 int32 &sStep0,
281 int32 &sStep1,
282 int32 &sStep2)
283 {
284
285 void *dPtr = NULL;
286
287 int32 dStep0 = sStep0;
288 int32 dStep1 = sStep1;
289 int32 dStep2 = sStep2;
290
291 OptimizeOrder (sPtr,
292 dPtr,
293 sPixelSize,
294 sPixelSize,
295 count0,
296 count1,
297 count2,
298 sStep0,
299 sStep1,
300 sStep2,
301 dStep0,
302 dStep1,
303 dStep2);
304
305 }
306
307 /*****************************************************************************/
308
309 void OptimizeOrder (void *&dPtr,
310 uint32 dPixelSize,
311 uint32 &count0,
312 uint32 &count1,
313 uint32 &count2,
314 int32 &dStep0,
315 int32 &dStep1,
316 int32 &dStep2)
317 {
318
319 const void *sPtr = NULL;
320
321 int32 sStep0 = dStep0;
322 int32 sStep1 = dStep1;
323 int32 sStep2 = dStep2;
324
325 OptimizeOrder (sPtr,
326 dPtr,
327 dPixelSize,
328 dPixelSize,
329 count0,
330 count1,
331 count2,
332 sStep0,
333 sStep1,
334 sStep2,
335 dStep0,
336 dStep1,
337 dStep2);
338
339 }
340
341 /*****************************************************************************/
342
343 dng_pixel_buffer::dng_pixel_buffer ()
344
345 : fArea ()
346 , fPlane (0)
347 , fPlanes (1)
348 , fRowStep (1)
349 , fColStep (1)
350 , fPlaneStep (1)
351 , fPixelType (ttUndefined)
352 , fPixelSize (0)
353 , fData (NULL)
354 , fDirty (true)
355
356 {
357
358 }
359
360 /*****************************************************************************/
361
362 dng_pixel_buffer::dng_pixel_buffer (const dng_rect &area,
363 uint32 plane,
364 uint32 planes,
365 uint32 pixelType,
366 uint32 planarConfiguration,
367 void *data)
368
369 : fArea (area)
370 , fPlane (plane)
371 , fPlanes (planes)
372 , fRowStep (0)
373 , fColStep (0)
374 , fPlaneStep (0)
375 , fPixelType (pixelType)
376 , fPixelSize (TagTypeSize (pixelType))
377 , fData (data)
378 , fDirty (true)
379
380 {
381
382 const char *overflowMessage = "Arithmetic overflow in pixel buffer setup";
383
384 // Initialize fRowStep, fColStep and fPlaneStep according to the desired
385 // pixel layout.
386
387 switch (planarConfiguration)
388 {
389
390 case pcInterleaved:
391 {
392
393 fPlaneStep = 1;
394
395 if (!ConvertUint32ToInt32 (fPlanes, &fColStep) ||
396 !SafeUint32ToInt32Mult (fArea.W (), fPlanes, &fRowStep))
397 {
398 ThrowOverflow (overflowMessage);
399 }
400
401 break;
402
403 }
404
405 case pcPlanar:
406 {
407
408 fColStep = 1;
409
410 // Even though we've hardened dng_rect::W() to guarantee that it
411 // will never return a result that's out of range for an int32, we
412 // still protect the conversion for defense in depth.
413
414 if (!ConvertUint32ToInt32 (fArea.W (), &fRowStep) ||
415 !SafeUint32ToInt32Mult (fArea.H (), fArea.W (), &fPlaneStep))
416 {
417 ThrowOverflow (overflowMessage);
418 }
419
420 break;
421
422 }
423
424 case pcRowInterleaved:
425 case pcRowInterleavedAlignSIMD:
426 {
427
428 fColStep = 1;
429
430 uint32 planeStepUint32;
431
432 if (planarConfiguration == pcRowInterleaved)
433 {
434 planeStepUint32 = fArea.W ();
435 }
436
437 else
438 {
439
440 if (!RoundUpForPixelSize (fArea.W (),
441 fPixelSize,
442 &planeStepUint32))
443 {
444 ThrowOverflow (overflowMessage);
445 }
446
447 }
448
449 if (!ConvertUint32ToInt32 (planeStepUint32, &fPlaneStep) ||
450 !SafeUint32ToInt32Mult (planeStepUint32, fPlanes, &fRowStep))
451 {
452 ThrowOverflow (overflowMessage);
453 }
454
455 break;
456
457 }
458
459 default:
460 {
461 ThrowProgramError ("Invalid value for 'planarConfiguration'");
462 break;
463 }
464
465 }
466
467 }
468
469 /*****************************************************************************/
470
471 dng_pixel_buffer::dng_pixel_buffer (const dng_pixel_buffer &buffer)
472
473 : fArea (buffer.fArea)
474 , fPlane (buffer.fPlane)
475 , fPlanes (buffer.fPlanes)
476 , fRowStep (buffer.fRowStep)
477 , fColStep (buffer.fColStep)
478 , fPlaneStep (buffer.fPlaneStep)
479 , fPixelType (buffer.fPixelType)
480 , fPixelSize (buffer.fPixelSize)
481 , fData (buffer.fData)
482 , fDirty (buffer.fDirty)
483
484 {
485
486 }
487
488 /*****************************************************************************/
489
490 dng_pixel_buffer & dng_pixel_buffer::operator= (const dng_pixel_buffer &buffer)
491 {
492
493 fArea = buffer.fArea;
494 fPlane = buffer.fPlane;
495 fPlanes = buffer.fPlanes;
496 fRowStep = buffer.fRowStep;
497 fColStep = buffer.fColStep;
498 fPlaneStep = buffer.fPlaneStep;
499 fPixelType = buffer.fPixelType;
500 fPixelSize = buffer.fPixelSize;
501 fPixelType = buffer.fPixelType;
502 fData = buffer.fData;
503 fDirty = buffer.fDirty;
504
505 return *this;
506
507 }
508
509 /*****************************************************************************/
510
511 dng_pixel_buffer::~dng_pixel_buffer ()
512 {
513
514 }
515
516 /*****************************************************************************/
517
518 #if qDebugPixelType
519
520 void dng_pixel_buffer::CheckPixelType (uint32 pixelType) const
521 {
522
523 if (fPixelType != pixelType)
524 {
525
526 DNG_REPORT ("Pixel type access mismatch");
527
528 }
529
530 }
531
532 #endif
533
534 /*****************************************************************************/
535
536 uint32 dng_pixel_buffer::PixelRange () const
537 {
538
539 switch (fPixelType)
540 {
541
542 case ttByte:
543 case ttSByte:
544 {
545 return 0x0FF;
546 }
547
548 case ttShort:
549 case ttSShort:
550 {
551 return 0x0FFFF;
552 }
553
554 case ttLong:
555 case ttSLong:
556 {
557 return 0xFFFFFFFF;
558 }
559
560 default:
561 break;
562
563 }
564
565 return 0;
566
567 }
568
569 /*****************************************************************************/
570
571 void dng_pixel_buffer::SetConstant (const dng_rect &area,
572 uint32 plane,
573 uint32 planes,
574 uint32 value)
575 {
576
577 uint32 rows = area.H ();
578 uint32 cols = area.W ();
579
580 void *dPtr = DirtyPixel (area.t,
581 area.l,
582 plane);
583
584 int32 dRowStep = fRowStep;
585 int32 dColStep = fColStep;
586 int32 dPlaneStep = fPlaneStep;
587
588 OptimizeOrder (dPtr,
589 fPixelSize,
590 rows,
591 cols,
592 planes,
593 dRowStep,
594 dColStep,
595 dPlaneStep);
596
597 switch (fPixelSize)
598 {
599
600 case 1:
601 {
602
603 if (rows == 1 && cols == 1 && dPlaneStep == 1 && value == 0)
604 {
605
606 DoZeroBytes (dPtr, planes);
607
608 }
609
610 else
611 {
612
613 DoSetArea8 ((uint8 *) dPtr,
614 (uint8) value,
615 rows,
616 cols,
617 planes,
618 dRowStep,
619 dColStep,
620 dPlaneStep);
621
622 }
623
624 break;
625
626 }
627
628 case 2:
629 {
630
631 if (rows == 1 && cols == 1 && dPlaneStep == 1 && value == 0)
632 {
633
634 DoZeroBytes (dPtr, planes << 1);
635
636 }
637
638 else
639 {
640
641 DoSetArea16 ((uint16 *) dPtr,
642 (uint16) value,
643 rows,
644 cols,
645 planes,
646 dRowStep,
647 dColStep,
648 dPlaneStep);
649
650 }
651
652 break;
653
654 }
655
656 case 4:
657 {
658
659 if (rows == 1 && cols == 1 && dPlaneStep == 1 && value == 0)
660 {
661
662 DoZeroBytes (dPtr, planes << 2);
663
664 }
665
666 else
667 {
668
669 DoSetArea32 ((uint32 *) dPtr,
670 value,
671 rows,
672 cols,
673 planes,
674 dRowStep,
675 dColStep,
676 dPlaneStep);
677
678 }
679
680 break;
681
682 }
683
684 default:
685 {
686
687 ThrowNotYetImplemented ();
688
689 }
690
691 }
692
693 }
694
695 /*****************************************************************************/
696
697 void dng_pixel_buffer::SetZero (const dng_rect &area,
698 uint32 plane,
699 uint32 planes)
700 {
701
702 uint32 value = 0;
703
704 switch (fPixelType)
705 {
706
707 case ttByte:
708 case ttShort:
709 case ttLong:
710 case ttFloat:
711 {
712 break;
713 }
714
715 case ttSShort:
716 {
717 value = 0x8000;
718 break;
719 }
720
721 default:
722 {
723
724 ThrowNotYetImplemented ();
725
726 }
727
728 }
729
730 SetConstant (area,
731 plane,
732 planes,
733 value);
734
735 }
736
737 /*****************************************************************************/
738
739 void dng_pixel_buffer::CopyArea (const dng_pixel_buffer &src,
740 const dng_rect &area,
741 uint32 srcPlane,
742 uint32 dstPlane,
743 uint32 planes)
744 {
745
746 uint32 rows = area.H ();
747 uint32 cols = area.W ();
748
749 const void *sPtr = src.ConstPixel (area.t,
750 area.l,
751 srcPlane);
752
753 void *dPtr = DirtyPixel (area.t,
754 area.l,
755 dstPlane);
756
757 int32 sRowStep = src.fRowStep;
758 int32 sColStep = src.fColStep;
759 int32 sPlaneStep = src.fPlaneStep;
760
761 int32 dRowStep = fRowStep;
762 int32 dColStep = fColStep;
763 int32 dPlaneStep = fPlaneStep;
764
765 OptimizeOrder (sPtr,
766 dPtr,
767 src.fPixelSize,
768 fPixelSize,
769 rows,
770 cols,
771 planes,
772 sRowStep,
773 sColStep,
774 sPlaneStep,
775 dRowStep,
776 dColStep,
777 dPlaneStep);
778
779 if (fPixelType == src.fPixelType)
780 {
781
782 if (rows == 1 && cols == 1 && sPlaneStep == 1 && dPlaneStep == 1)
783 {
784
785 DoCopyBytes (sPtr,
786 dPtr,
787 planes * fPixelSize);
788
789 }
790
791 else switch (fPixelSize)
792 {
793
794 case 1:
795 {
796
797 DoCopyArea8 ((const uint8 *) sPtr,
798 (uint8 *) dPtr,
799 rows,
800 cols,
801 planes,
802 sRowStep,
803 sColStep,
804 sPlaneStep,
805 dRowStep,
806 dColStep,
807 dPlaneStep);
808
809 break;
810
811 }
812
813 case 2:
814 {
815
816 DoCopyArea16 ((const uint16 *) sPtr,
817 (uint16 *) dPtr,
818 rows,
819 cols,
820 planes,
821 sRowStep,
822 sColStep,
823 sPlaneStep,
824 dRowStep,
825 dColStep,
826 dPlaneStep);
827
828 break;
829
830 }
831
832 case 4:
833 {
834
835 DoCopyArea32 ((const uint32 *) sPtr,
836 (uint32 *) dPtr,
837 rows,
838 cols,
839 planes,
840 sRowStep,
841 sColStep,
842 sPlaneStep,
843 dRowStep,
844 dColStep,
845 dPlaneStep);
846
847 break;
848
849 }
850
851 default:
852 {
853
854 ThrowNotYetImplemented ();
855
856 }
857
858 }
859
860 }
861
862 else if (src.fPixelType == ttByte)
863 {
864
865 switch (fPixelType)
866 {
867
868 case ttShort:
869 {
870
871 DoCopyArea8_16 ((const uint8 *) sPtr,
872 (uint16 *) dPtr,
873 rows,
874 cols,
875 planes,
876 sRowStep,
877 sColStep,
878 sPlaneStep,
879 dRowStep,
880 dColStep,
881 dPlaneStep);
882
883 break;
884
885 }
886
887 case ttSShort:
888 {
889
890 DoCopyArea8_S16 ((const uint8 *) sPtr,
891 (int16 *) dPtr,
892 rows,
893 cols,
894 planes,
895 sRowStep,
896 sColStep,
897 sPlaneStep,
898 dRowStep,
899 dColStep,
900 dPlaneStep);
901
902 break;
903
904 }
905
906 case ttLong:
907 {
908
909 DoCopyArea8_32 ((const uint8 *) sPtr,
910 (uint32 *) dPtr,
911 rows,
912 cols,
913 planes,
914 sRowStep,
915 sColStep,
916 sPlaneStep,
917 dRowStep,
918 dColStep,
919 dPlaneStep);
920
921 break;
922
923 }
924
925 case ttFloat:
926 {
927
928 DoCopyArea8_R32 ((const uint8 *) sPtr,
929 (real32 *) dPtr,
930 rows,
931 cols,
932 planes,
933 sRowStep,
934 sColStep,
935 sPlaneStep,
936 dRowStep,
937 dColStep,
938 dPlaneStep,
939 src.PixelRange ());
940
941 break;
942
943 }
944
945 default:
946 {
947
948 ThrowNotYetImplemented ();
949
950 }
951
952 }
953
954 }
955
956 else if (src.fPixelType == ttShort)
957 {
958
959 switch (fPixelType)
960 {
961
962 case ttByte:
963 {
964
965 DoCopyArea8 (((const uint8 *) sPtr) + (qDNGBigEndian ? 1 : 0),
966 (uint8 *) dPtr,
967 rows,
968 cols,
969 planes,
970 sRowStep << 1,
971 sColStep << 1,
972 sPlaneStep << 1,
973 dRowStep,
974 dColStep,
975 dPlaneStep);
976
977 break;
978
979 }
980
981 case ttSShort:
982 {
983
984 DoCopyArea16_S16 ((const uint16 *) sPtr,
985 (int16 *) dPtr,
986 rows,
987 cols,
988 planes,
989 sRowStep,
990 sColStep,
991 sPlaneStep,
992 dRowStep,
993 dColStep,
994 dPlaneStep);
995
996 break;
997
998 }
999
1000 case ttLong:
1001 {
1002
1003 DoCopyArea16_32 ((const uint16 *) sPtr,
1004 (uint32 *) dPtr,
1005 rows,
1006 cols,
1007 planes,
1008 sRowStep,
1009 sColStep,
1010 sPlaneStep,
1011 dRowStep,
1012 dColStep,
1013 dPlaneStep);
1014
1015 break;
1016
1017 }
1018
1019 case ttFloat:
1020 {
1021
1022 DoCopyArea16_R32 ((const uint16 *) sPtr,
1023 (real32 *) dPtr,
1024 rows,
1025 cols,
1026 planes,
1027 sRowStep,
1028 sColStep,
1029 sPlaneStep,
1030 dRowStep,
1031 dColStep,
1032 dPlaneStep,
1033 src.PixelRange ());
1034
1035 break;
1036
1037 }
1038
1039 default:
1040 {
1041
1042 ThrowNotYetImplemented ();
1043
1044 }
1045
1046 }
1047
1048 }
1049
1050 else if (src.fPixelType == ttSShort)
1051 {
1052
1053 switch (fPixelType)
1054 {
1055
1056 case ttByte:
1057 {
1058
1059 DoCopyArea8 (((const uint8 *) sPtr) + (qDNGBigEndian ? 1 : 0),
1060 (uint8 *) dPtr,
1061 rows,
1062 cols,
1063 planes,
1064 sRowStep << 1,
1065 sColStep << 1,
1066 sPlaneStep << 1,
1067 dRowStep,
1068 dColStep,
1069 dPlaneStep);
1070
1071 break;
1072
1073 }
1074
1075 case ttShort:
1076 {
1077
1078 // Moving between signed 16 bit values and unsigned 16
1079 // bit values just requires toggling the sign bit. So
1080 // we can use the "backwards" bottleneck.
1081
1082 DoCopyArea16_S16 ((const uint16 *) sPtr,
1083 (int16 *) dPtr,
1084 rows,
1085 cols,
1086 planes,
1087 sRowStep,
1088 sColStep,
1089 sPlaneStep,
1090 dRowStep,
1091 dColStep,
1092 dPlaneStep);
1093
1094 break;
1095
1096 }
1097
1098 case ttFloat:
1099 {
1100
1101 DoCopyAreaS16_R32 ((const int16 *) sPtr,
1102 (real32 *) dPtr,
1103 rows,
1104 cols,
1105 planes,
1106 sRowStep,
1107 sColStep,
1108 sPlaneStep,
1109 dRowStep,
1110 dColStep,
1111 dPlaneStep,
1112 src.PixelRange ());
1113
1114 break;
1115
1116 }
1117
1118 default:
1119 {
1120
1121 ThrowNotYetImplemented ();
1122
1123 }
1124
1125 }
1126
1127 }
1128
1129 else if (src.fPixelType == ttLong)
1130 {
1131
1132 switch (fPixelType)
1133 {
1134
1135 case ttByte:
1136 {
1137
1138 DoCopyArea8 (((const uint8 *) sPtr) + (qDNGBigEndian ? 3 : 0),
1139 (uint8 *) dPtr,
1140 rows,
1141 cols,
1142 planes,
1143 sRowStep << 2,
1144 sColStep << 2,
1145 sPlaneStep << 2,
1146 dRowStep,
1147 dColStep,
1148 dPlaneStep);
1149
1150 break;
1151
1152 }
1153
1154 case ttShort:
1155 {
1156
1157 DoCopyArea16 (((const uint16 *) sPtr) + (qDNGBigEndian ? 1 : 0),
1158 (uint16 *) dPtr,
1159 rows,
1160 cols,
1161 planes,
1162 sRowStep << 1,
1163 sColStep << 1,
1164 sPlaneStep << 1,
1165 dRowStep,
1166 dColStep,
1167 dPlaneStep);
1168
1169 break;
1170
1171 }
1172
1173 default:
1174 {
1175
1176 ThrowNotYetImplemented ();
1177
1178 }
1179
1180 }
1181
1182 }
1183
1184 else if (src.fPixelType == ttFloat)
1185 {
1186
1187 switch (fPixelType)
1188 {
1189
1190 case ttByte:
1191 {
1192
1193 DoCopyAreaR32_8 ((const real32 *) sPtr,
1194 (uint8 *) dPtr,
1195 rows,
1196 cols,
1197 planes,
1198 sRowStep,
1199 sColStep,
1200 sPlaneStep,
1201 dRowStep,
1202 dColStep,
1203 dPlaneStep,
1204 PixelRange ());
1205
1206 break;
1207
1208 }
1209
1210 case ttShort:
1211 {
1212
1213 DoCopyAreaR32_16 ((const real32 *) sPtr,
1214 (uint16 *) dPtr,
1215 rows,
1216 cols,
1217 planes,
1218 sRowStep,
1219 sColStep,
1220 sPlaneStep,
1221 dRowStep,
1222 dColStep,
1223 dPlaneStep,
1224 PixelRange ());
1225
1226 break;
1227
1228 }
1229
1230 case ttSShort:
1231 {
1232
1233 DoCopyAreaR32_S16 ((const real32 *) sPtr,
1234 (int16 *) dPtr,
1235 rows,
1236 cols,
1237 planes,
1238 sRowStep,
1239 sColStep,
1240 sPlaneStep,
1241 dRowStep,
1242 dColStep,
1243 dPlaneStep,
1244 PixelRange ());
1245
1246 break;
1247
1248 }
1249
1250 default:
1251 {
1252
1253 ThrowNotYetImplemented ();
1254
1255 }
1256
1257 }
1258
1259 }
1260
1261 else
1262 {
1263
1264 ThrowNotYetImplemented ();
1265
1266 }
1267
1268 }
1269
1270 /*****************************************************************************/
1271
1272 dng_point dng_pixel_buffer::RepeatPhase (const dng_rect &srcArea,
1273 const dng_rect &dstArea)
1274 {
1275
1276 int32 repeatV = srcArea.H ();
1277 int32 repeatH = srcArea.W ();
1278
1279 int32 phaseV;
1280 int32 phaseH;
1281
1282 if (repeatV == 0 ||
1283 repeatH == 0)
1284 {
1285 DNG_REPORT ("Bad srcArea in RepeatPhase");
1286 return dng_point ();
1287 }
1288
1289 if (srcArea.t >= dstArea.t)
1290 {
1291 phaseV = (repeatV - ((srcArea.t - dstArea.t) % repeatV)) % repeatV;
1292 }
1293 else
1294 {
1295 phaseV = (dstArea.t - srcArea.t) % repeatV;
1296 }
1297
1298 if (srcArea.l >= dstArea.l)
1299 {
1300 phaseH = (repeatH - ((srcArea.l - dstArea.l) % repeatH)) % repeatH;
1301 }
1302 else
1303 {
1304 phaseH = (dstArea.l - srcArea.l) % repeatH;
1305 }
1306
1307 return dng_point (phaseV, phaseH);
1308
1309 }
1310
1311 /*****************************************************************************/
1312
1313 void dng_pixel_buffer::RepeatArea (const dng_rect &srcArea,
1314 const dng_rect &dstArea)
1315 {
1316
1317 dng_point repeat = srcArea.Size ();
1318
1319 dng_point phase = RepeatPhase (srcArea,
1320 dstArea);
1321
1322 const void *sPtr = ConstPixel (srcArea.t,
1323 srcArea.l,
1324 fPlane);
1325
1326 void *dPtr = DirtyPixel (dstArea.t,
1327 dstArea.l,
1328 fPlane);
1329
1330 uint32 rows = dstArea.H ();
1331 uint32 cols = dstArea.W ();
1332
1333 switch (fPixelSize)
1334 {
1335
1336 case 1:
1337 {
1338
1339 DoRepeatArea8 ((const uint8 *) sPtr,
1340 (uint8 *) dPtr,
1341 rows,
1342 cols,
1343 fPlanes,
1344 fRowStep,
1345 fColStep,
1346 fPlaneStep,
1347 repeat.v,
1348 repeat.h,
1349 phase.v,
1350 phase.h);
1351
1352 break;
1353
1354 }
1355
1356 case 2:
1357 {
1358
1359 DoRepeatArea16 ((const uint16 *) sPtr,
1360 (uint16 *) dPtr,
1361 rows,
1362 cols,
1363 fPlanes,
1364 fRowStep,
1365 fColStep,
1366 fPlaneStep,
1367 repeat.v,
1368 repeat.h,
1369 phase.v,
1370 phase.h);
1371
1372 break;
1373
1374 }
1375
1376 case 4:
1377 {
1378
1379 DoRepeatArea32 ((const uint32 *) sPtr,
1380 (uint32 *) dPtr,
1381 rows,
1382 cols,
1383 fPlanes,
1384 fRowStep,
1385 fColStep,
1386 fPlaneStep,
1387 repeat.v,
1388 repeat.h,
1389 phase.v,
1390 phase.h);
1391
1392 break;
1393
1394 }
1395
1396 default:
1397 {
1398
1399 ThrowNotYetImplemented ();
1400
1401 }
1402
1403 }
1404
1405 }
1406
1407 /*****************************************************************************/
1408
1409 void dng_pixel_buffer::RepeatSubArea (const dng_rect subArea,
1410 uint32 repeatV,
1411 uint32 repeatH)
1412 {
1413
1414 if (fArea.t < subArea.t)
1415 {
1416
1417 RepeatArea (dng_rect (subArea.t , fArea.l,
1418 subArea.t + repeatV, fArea.r),
1419 dng_rect (fArea.t , fArea.l,
1420 subArea.t , fArea.r));
1421
1422 }
1423
1424 if (fArea.b > subArea.b)
1425 {
1426
1427 RepeatArea (dng_rect (subArea.b - repeatV, fArea.l,
1428 subArea.b , fArea.r),
1429 dng_rect (subArea.b , fArea.l,
1430 fArea.b , fArea.r));
1431
1432 }
1433
1434 if (fArea.l < subArea.l)
1435 {
1436
1437 RepeatArea (dng_rect (fArea.t, subArea.l ,
1438 fArea.b, subArea.l + repeatH),
1439 dng_rect (fArea.t, fArea.l ,
1440 fArea.b, subArea.l ));
1441
1442 }
1443
1444 if (fArea.r > subArea.r)
1445 {
1446
1447 RepeatArea (dng_rect (fArea.t, subArea.r - repeatH,
1448 fArea.b, subArea.r ),
1449 dng_rect (fArea.t, subArea.r ,
1450 fArea.b, fArea.r ));
1451
1452 }
1453
1454 }
1455
1456 /*****************************************************************************/
1457
1458 void dng_pixel_buffer::ShiftRight (uint32 shift)
1459 {
1460
1461 if (fPixelType != ttShort)
1462 {
1463
1464 ThrowNotYetImplemented ();
1465
1466 }
1467
1468 uint32 rows = fArea.H ();
1469 uint32 cols = fArea.W ();
1470
1471 uint32 planes = fPlanes;
1472
1473 void *dPtr = DirtyPixel (fArea.t,
1474 fArea.l,
1475 fPlane);
1476
1477 const void *sPtr = dPtr;
1478
1479 int32 sRowStep = fRowStep;
1480 int32 sColStep = fColStep;
1481 int32 sPlaneStep = fPlaneStep;
1482
1483 int32 dRowStep = fRowStep;
1484 int32 dColStep = fColStep;
1485 int32 dPlaneStep = fPlaneStep;
1486
1487 OptimizeOrder (sPtr,
1488 dPtr,
1489 fPixelSize,
1490 fPixelSize,
1491 rows,
1492 cols,
1493 planes,
1494 sRowStep,
1495 sColStep,
1496 sPlaneStep,
1497 dRowStep,
1498 dColStep,
1499 dPlaneStep);
1500
1501 DoShiftRight16 ((uint16 *) dPtr,
1502 rows,
1503 cols,
1504 planes,
1505 dRowStep,
1506 dColStep,
1507 dPlaneStep,
1508 shift);
1509
1510 }
1511
1512 /*****************************************************************************/
1513
1514 void dng_pixel_buffer::FlipH ()
1515 {
1516
1517 fData = InternalPixel (fArea.t, fArea.r - 1);
1518
1519 fColStep = -fColStep;
1520
1521 }
1522
1523 /*****************************************************************************/
1524
1525 void dng_pixel_buffer::FlipV ()
1526 {
1527
1528 fData = InternalPixel (fArea.b - 1, fArea.l);
1529
1530 fRowStep = -fRowStep;
1531
1532 }
1533
1534 /*****************************************************************************/
1535
1536 void dng_pixel_buffer::FlipZ ()
1537 {
1538
1539 fData = InternalPixel (fArea.t, fArea.l, fPlanes - 1);
1540
1541 fPlaneStep = -fPlaneStep;
1542
1543 }
1544
1545 /*****************************************************************************/
1546
1547 bool dng_pixel_buffer::EqualArea (const dng_pixel_buffer &src,
1548 const dng_rect &area,
1549 uint32 plane,
1550 uint32 planes) const
1551 {
1552
1553 uint32 rows = area.H ();
1554 uint32 cols = area.W ();
1555
1556 const void *sPtr = src.ConstPixel (area.t,
1557 area.l,
1558 plane);
1559
1560 const void *dPtr = ConstPixel (area.t,
1561 area.l,
1562 plane);
1563
1564 int32 sRowStep = src.fRowStep;
1565 int32 sColStep = src.fColStep;
1566 int32 sPlaneStep = src.fPlaneStep;
1567
1568 int32 dRowStep = fRowStep;
1569 int32 dColStep = fColStep;
1570 int32 dPlaneStep = fPlaneStep;
1571
1572 if (fPixelType == src.fPixelType)
1573 {
1574
1575 if (rows == 1 && cols == 1 && sPlaneStep == 1 && dPlaneStep == 1)
1576 {
1577
1578 return DoEqualBytes (sPtr,
1579 dPtr,
1580 planes * fPixelSize);
1581
1582 }
1583
1584 else switch (fPixelSize)
1585 {
1586
1587 case 1:
1588 {
1589
1590 return DoEqualArea8 ((const uint8 *) sPtr,
1591 (const uint8 *) dPtr,
1592 rows,
1593 cols,
1594 planes,
1595 sRowStep,
1596 sColStep,
1597 sPlaneStep,
1598 dRowStep,
1599 dColStep,
1600 dPlaneStep);
1601
1602 break;
1603
1604 }
1605
1606 case 2:
1607 {
1608
1609 return DoEqualArea16 ((const uint16 *) sPtr,
1610 (const uint16 *) dPtr,
1611 rows,
1612 cols,
1613 planes,
1614 sRowStep,
1615 sColStep,
1616 sPlaneStep,
1617 dRowStep,
1618 dColStep,
1619 dPlaneStep);
1620
1621 break;
1622
1623 }
1624
1625 case 4:
1626 {
1627
1628 return DoEqualArea32 ((const uint32 *) sPtr,
1629 (const uint32 *) dPtr,
1630 rows,
1631 cols,
1632 planes,
1633 sRowStep,
1634 sColStep,
1635 sPlaneStep,
1636 dRowStep,
1637 dColStep,
1638 dPlaneStep);
1639
1640 break;
1641
1642 }
1643
1644 default:
1645 {
1646
1647 ThrowNotYetImplemented ();
1648
1649 return false;
1650
1651 }
1652
1653 }
1654
1655 }
1656
1657 else
1658 return false;
1659
1660 }
1661
1662 /*****************************************************************************/
1663
1664 namespace
1665 {
1666
1667 template <typename T>
1668 real64 MaxDiff (const T *src1,
1669 int32 s1RowStep,
1670 int32 s1PlaneStep,
1671 const T *src2,
1672 int32 s2RowStep,
1673 int32 s2PlaneStep,
1674 uint32 rows,
1675 uint32 cols,
1676 uint32 planes)
1677 {
1678
1679 real64 result = 0.0;
1680
1681 for (uint32 plane = 0; plane < planes; plane++)
1682 {
1683
1684 const T *src1Save = src1;
1685 const T *src2Save = src2;
1686
1687 for (uint32 row = 0; row < rows; row++)
1688 {
1689
1690 for (uint32 col = 0; col < cols; col++)
1691 {
1692 real64 diff = fabs ((real64)src1 [col] - src2 [col]);
1693
1694 if (diff > result)
1695 result = diff;
1696
1697 }
1698
1699 src1 += s1RowStep;
1700 src2 += s2RowStep;
1701
1702 }
1703
1704 src1 = src1Save + s1PlaneStep;
1705 src2 = src2Save + s2PlaneStep;
1706
1707 }
1708
1709 return result;
1710
1711 }
1712
1713 template <typename T>
1714 real64 MaxDiff (const T *src1,
1715 int32 s1ColStep,
1716 int32 s1RowStep,
1717 int32 s1PlaneStep,
1718 const T *src2,
1719 int32 s2ColStep,
1720 int32 s2RowStep,
1721 int32 s2PlaneStep,
1722 uint32 rows,
1723 uint32 cols,
1724 uint32 planes)
1725 {
1726
1727 if (s1ColStep == s2ColStep &&
1728 s1ColStep == 1)
1729 return MaxDiff (src1,
1730 s1RowStep,
1731 s1PlaneStep,
1732 src2,
1733 s2RowStep,
1734 s2PlaneStep,
1735 rows,
1736 cols,
1737 planes);
1738
1739 real64 result = 0.0;
1740
1741 for (uint32 plane = 0; plane < planes; plane++)
1742 {
1743
1744 const T *src1Save = src1;
1745 const T *src2Save = src2;
1746
1747 for (uint32 row = 0; row < rows; row++)
1748 {
1749
1750 for (uint32 col = 0; col < cols; col++)
1751 {
1752 real64 diff = fabs ((real64)src1 [col * s1ColStep] - src2 [col * s2ColStep]);
1753
1754 if (diff > result)
1755 result = diff;
1756
1757 }
1758
1759 src1 += s1RowStep;
1760 src2 += s2RowStep;
1761
1762 }
1763
1764 src1 = src1Save + s1PlaneStep;
1765 src2 = src2Save + s2PlaneStep;
1766
1767 }
1768
1769
1770 return result;
1771
1772 }
1773 }
1774
1775 real64 dng_pixel_buffer::MaximumDifference (const dng_pixel_buffer &rhs,
1776 const dng_rect &area,
1777 uint32 plane,
1778 uint32 planes) const
1779 {
1780
1781 uint32 rows = area.H ();
1782 uint32 cols = area.W ();
1783
1784 const void *s1Ptr = rhs.ConstPixel (area.t,
1785 area.l,
1786 plane);
1787
1788 const void *s2Ptr = ConstPixel (area.t,
1789 area.l,
1790 plane);
1791
1792 int32 s1RowStep = rhs.fRowStep;
1793 int32 s1ColStep = rhs.fColStep;
1794 int32 s1PlaneStep = rhs.fPlaneStep;
1795
1796 int32 s2RowStep = fRowStep;
1797 int32 s2ColStep = fColStep;
1798 int32 s2PlaneStep = fPlaneStep;
1799
1800 if (fPixelType == rhs.fPixelType)
1801 {
1802
1803 switch (fPixelType)
1804 {
1805
1806 case ttByte:
1807 return MaxDiff ((const uint8 *)s1Ptr,
1808 s1ColStep,
1809 s1RowStep,
1810 s1PlaneStep,
1811 (const uint8 *)s2Ptr,
1812 s2ColStep,
1813 s2RowStep,
1814 s2PlaneStep,
1815 rows,
1816 cols,
1817 planes);
1818
1819 break;
1820
1821 case ttShort:
1822 return MaxDiff ((const uint16 *)s1Ptr,
1823 s1ColStep,
1824 s1RowStep,
1825 s1PlaneStep,
1826 (const uint16 *)s2Ptr,
1827 s2ColStep,
1828 s2RowStep,
1829 s2PlaneStep,
1830 rows,
1831 cols,
1832 planes);
1833
1834 break;
1835
1836 case ttLong:
1837 return MaxDiff ((const uint32 *)s1Ptr,
1838 s1ColStep,
1839 s1RowStep,
1840 s1PlaneStep,
1841 (const uint32 *)s2Ptr,
1842 s2ColStep,
1843 s2RowStep,
1844 s2PlaneStep,
1845 rows,
1846 cols,
1847 planes);
1848
1849 break;
1850
1851 case ttSByte:
1852 return MaxDiff ((const int8 *)s1Ptr,
1853 s1ColStep,
1854 s1RowStep,
1855 s1PlaneStep,
1856 (const int8 *)s2Ptr,
1857 s2ColStep,
1858 s2RowStep,
1859 s2PlaneStep,
1860 rows,
1861 cols,
1862 planes);
1863
1864 break;
1865
1866 case ttSShort:
1867 return MaxDiff ((const int16 *)s1Ptr,
1868 s1ColStep,
1869 s1RowStep,
1870 s1PlaneStep,
1871 (const int16 *)s2Ptr,
1872 s2ColStep,
1873 s2RowStep,
1874 s2PlaneStep,
1875 rows,
1876 cols,
1877 planes);
1878
1879 break;
1880
1881 case ttSLong:
1882 return MaxDiff ((const int32 *)s1Ptr,
1883 s1ColStep,
1884 s1RowStep,
1885 s1PlaneStep,
1886 (const int32 *)s2Ptr,
1887 s2ColStep,
1888 s2RowStep,
1889 s2PlaneStep,
1890 rows,
1891 cols,
1892 planes);
1893
1894 break;
1895
1896 case ttFloat:
1897 return MaxDiff ((const real32 *)s1Ptr,
1898 s1ColStep,
1899 s1RowStep,
1900 s1PlaneStep,
1901 (const real32 *)s2Ptr,
1902 s2ColStep,
1903 s2RowStep,
1904 s2PlaneStep,
1905 rows,
1906 cols,
1907 planes);
1908
1909 break;
1910
1911 case ttDouble:
1912 return MaxDiff ((const real64 *)s1Ptr,
1913 s1ColStep,
1914 s1RowStep,
1915 s1PlaneStep,
1916 (const real64 *)s2Ptr,
1917 s2ColStep,
1918 s2RowStep,
1919 s2PlaneStep,
1920 rows,
1921 cols,
1922 planes);
1923
1924 break;
1925
1926
1927 default:
1928 {
1929
1930 ThrowNotYetImplemented ();
1931
1932 return 0.0;
1933
1934 }
1935
1936 }
1937
1938 }
1939
1940 else
1941 ThrowProgramError ("attempt to difference pixel buffers of different formats.");
1942
1943 return 0.0;
1944
1945 }
1946
1947 /*****************************************************************************/