1/*****************************************************************************/
2// Copyright 2008-2009 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_misc_opcodes.cpp#1 $ */
10/* $DateTime: 2012/05/30 13:28:51 $ */
11/* $Change: 832332 $ */
12/* $Author: tknoll $ */
13
14/*****************************************************************************/
15
16#include "dng_misc_opcodes.h"
17
18#include "dng_bottlenecks.h"
19#include "dng_exceptions.h"
20#include "dng_globals.h"
21#include "dng_host.h"
22#include "dng_image.h"
23#include "dng_rect.h"
24#include "dng_safe_arithmetic.h"
25#include "dng_stream.h"
26#include "dng_tag_values.h"
27
28/*****************************************************************************/
29
30dng_opcode_TrimBounds::dng_opcode_TrimBounds (const dng_rect &bounds)
31
32 : dng_opcode (dngOpcode_TrimBounds,
33 dngVersion_1_3_0_0,
34 kFlag_None)
35
36 , fBounds (bounds)
37
38 {
39
40 }
41
42/*****************************************************************************/
43
44dng_opcode_TrimBounds::dng_opcode_TrimBounds (dng_stream &stream)
45
46 : dng_opcode (dngOpcode_TrimBounds,
47 stream,
48 "TrimBounds")
49
50 , fBounds ()
51
52 {
53
54 if (stream.Get_uint32 () != 16)
55 {
56 ThrowBadFormat ();
57 }
58
59 fBounds.t = stream.Get_int32 ();
60 fBounds.l = stream.Get_int32 ();
61 fBounds.b = stream.Get_int32 ();
62 fBounds.r = stream.Get_int32 ();
63
64 if (fBounds.IsEmpty ())
65 {
66 ThrowBadFormat ();
67 }
68
69 #if qDNGValidate
70
71 if (gVerbose)
72 {
73
74 printf ("Bounds: t=%d, l=%d, b=%d, r=%d\n",
75 (int) fBounds.t,
76 (int) fBounds.l,
77 (int) fBounds.b,
78 (int) fBounds.r);
79
80 }
81
82 #endif
83
84 }
85
86/*****************************************************************************/
87
88void dng_opcode_TrimBounds::PutData (dng_stream &stream) const
89 {
90
91 stream.Put_uint32 (16);
92
93 stream.Put_int32 (fBounds.t);
94 stream.Put_int32 (fBounds.l);
95 stream.Put_int32 (fBounds.b);
96 stream.Put_int32 (fBounds.r);
97
98 }
99
100/*****************************************************************************/
101
102void dng_opcode_TrimBounds::Apply (dng_host & /* host */,
103 dng_negative & /* negative */,
104 AutoPtr<dng_image> &image)
105 {
106
107 if (fBounds.IsEmpty () || (fBounds & image->Bounds ()) != fBounds)
108 {
109 ThrowBadFormat ();
110 }
111
112 image->Trim (fBounds);
113
114 }
115
116/*****************************************************************************/
117
118void dng_area_spec::GetData (dng_stream &stream)
119 {
120
121 fArea.t = stream.Get_int32 ();
122 fArea.l = stream.Get_int32 ();
123 fArea.b = stream.Get_int32 ();
124 fArea.r = stream.Get_int32 ();
125
126 fPlane = stream.Get_uint32 ();
127 fPlanes = stream.Get_uint32 ();
128
129 fRowPitch = stream.Get_uint32 ();
130 fColPitch = stream.Get_uint32 ();
131
132 if (fPlanes < 1)
133 {
134 ThrowBadFormat ();
135 }
136
137 if (fRowPitch < 1 || fColPitch < 1)
138 {
139 ThrowBadFormat ();
140 }
141
142 if (fArea.IsEmpty ())
143 {
144 if (fRowPitch != 1 || fColPitch != 1)
145 {
146 ThrowBadFormat ();
147 }
148 }
149
150 else
151 {
152 int32 width = 0;
153 int32 height = 0;
154 if (!SafeInt32Sub (fArea.b, fArea.t, &height) ||
155 !SafeInt32Sub (fArea.r, fArea.l, &width) ||
156 fRowPitch > static_cast<uint32>(height) ||
157 fColPitch > static_cast<uint32>(width))
158 {
159 ThrowBadFormat();
160 }
161 }
162
163 #if qDNGValidate
164
165 if (gVerbose)
166 {
167
168 printf ("AreaSpec: t=%d, l=%d, b=%d, r=%d, p=%u:%u, rp=%u, cp=%u\n",
169 (int) fArea.t,
170 (int) fArea.l,
171 (int) fArea.b,
172 (int) fArea.r,
173 (unsigned) fPlane,
174 (unsigned) fPlanes,
175 (unsigned) fRowPitch,
176 (unsigned) fColPitch);
177
178 }
179
180 #endif
181
182 }
183
184/*****************************************************************************/
185
186void dng_area_spec::PutData (dng_stream &stream) const
187 {
188
189 stream.Put_int32 (fArea.t);
190 stream.Put_int32 (fArea.l);
191 stream.Put_int32 (fArea.b);
192 stream.Put_int32 (fArea.r);
193
194 stream.Put_uint32 (fPlane);
195 stream.Put_uint32 (fPlanes);
196
197 stream.Put_uint32 (fRowPitch);
198 stream.Put_uint32 (fColPitch);
199
200 }
201
202/*****************************************************************************/
203
204dng_rect dng_area_spec::Overlap (const dng_rect &tile) const
205 {
206
207 // Special case - if the fArea is empty, then dng_area_spec covers
208 // the entire image, no matter how large it is.
209
210 if (fArea.IsEmpty ())
211 {
212 return tile;
213 }
214
215 dng_rect overlap = fArea & tile;
216
217 if (overlap.NotEmpty ())
218 {
219
220 overlap.t = fArea.t + ConvertUint32ToInt32(
221 RoundUpUint32ToMultiple(static_cast<uint32>(overlap.t - fArea.t),
222 fRowPitch));
223 overlap.l = fArea.l + ConvertUint32ToInt32(
224 RoundUpUint32ToMultiple(static_cast<uint32>(overlap.l - fArea.l),
225 fColPitch));
226
227 if (overlap.NotEmpty ())
228 {
229
230 overlap.b = overlap.t + ((overlap.H () - 1) / fRowPitch) * fRowPitch + 1;
231 overlap.r = overlap.l + ((overlap.W () - 1) / fColPitch) * fColPitch + 1;
232
233 return overlap;
234
235 }
236
237 }
238
239 return dng_rect ();
240
241 }
242
243/*****************************************************************************/
244
245dng_opcode_MapTable::dng_opcode_MapTable (dng_host &host,
246 const dng_area_spec &areaSpec,
247 const uint16 *table,
248 uint32 count)
249
250 : dng_inplace_opcode (dngOpcode_MapTable,
251 dngVersion_1_3_0_0,
252 kFlag_None)
253
254 , fAreaSpec (areaSpec)
255 , fTable ()
256 , fCount (count)
257
258 {
259
260 if (count == 0 || count > 0x10000)
261 {
262 ThrowProgramError ();
263 }
264
265 fTable.Reset (host.Allocate (0x10000 * sizeof (uint16)));
266
267 DoCopyBytes (table,
268 fTable->Buffer (),
269 count * (uint32) sizeof (uint16));
270
271 ReplicateLastEntry ();
272
273 }
274
275/*****************************************************************************/
276
277dng_opcode_MapTable::dng_opcode_MapTable (dng_host &host,
278 dng_stream &stream)
279
280 : dng_inplace_opcode (dngOpcode_MapTable,
281 stream,
282 "MapTable")
283
284 , fAreaSpec ()
285 , fTable ()
286 , fCount (0)
287
288 {
289
290 uint32 dataSize = stream.Get_uint32 ();
291
292 fAreaSpec.GetData (stream);
293
294 fCount = stream.Get_uint32 ();
295
296 uint32 requiredSize = SafeUint32Mult(fCount, 2);
297 requiredSize = SafeUint32Add(requiredSize, dng_area_spec::kDataSize);
298 requiredSize = SafeUint32Add(requiredSize, 4);
299 if (dataSize != requiredSize)
300 {
301 ThrowBadFormat ();
302 }
303
304 if (fCount == 0 || fCount > 0x10000)
305 {
306 ThrowBadFormat ();
307 }
308
309 fTable.Reset (host.Allocate (0x10000 * sizeof (uint16)));
310
311 uint16 *table = fTable->Buffer_uint16 ();
312
313 for (uint32 index = 0; index < fCount; index++)
314 {
315 table [index] = stream.Get_uint16 ();
316 }
317
318 ReplicateLastEntry ();
319
320 #if qDNGValidate
321
322 if (gVerbose)
323 {
324
325 printf ("Count: %u\n", (unsigned) fCount);
326
327 for (uint32 j = 0; j < fCount && j < gDumpLineLimit; j++)
328 {
329 printf (" Table [%5u] = %5u\n", (unsigned) j, (unsigned) table [j]);
330 }
331
332 if (fCount > gDumpLineLimit)
333 {
334 printf (" ... %u table entries skipped\n", (unsigned) (fCount - gDumpLineLimit));
335 }
336
337 }
338
339 #endif
340
341 }
342
343/*****************************************************************************/
344
345void dng_opcode_MapTable::ReplicateLastEntry ()
346 {
347
348 uint16 *table = fTable->Buffer_uint16 ();
349
350 uint16 lastEntry = table [fCount];
351
352 for (uint32 index = fCount; index < 0x10000; index++)
353 {
354 table [index] = lastEntry;
355 }
356
357 }
358
359/*****************************************************************************/
360
361void dng_opcode_MapTable::PutData (dng_stream &stream) const
362 {
363
364 stream.Put_uint32 (dng_area_spec::kDataSize + 4 + fCount * 2);
365
366 fAreaSpec.PutData (stream);
367
368 stream.Put_uint32 (fCount);
369
370 uint16 *table = fTable->Buffer_uint16 ();
371
372 for (uint32 index = 0; index < fCount; index++)
373 {
374 stream.Put_uint16 (table [index]);
375 }
376
377 }
378
379/*****************************************************************************/
380
381uint32 dng_opcode_MapTable::BufferPixelType (uint32 /* imagePixelType */)
382 {
383
384 return ttShort;
385
386 }
387
388/*****************************************************************************/
389
390dng_rect dng_opcode_MapTable::ModifiedBounds (const dng_rect &imageBounds)
391 {
392
393 return fAreaSpec.Overlap (imageBounds);
394
395 }
396
397/*****************************************************************************/
398
399void dng_opcode_MapTable::ProcessArea (dng_negative & /* negative */,
400 uint32 /* threadIndex */,
401 dng_pixel_buffer &buffer,
402 const dng_rect &dstArea,
403 const dng_rect & /* imageBounds */)
404 {
405
406 dng_rect overlap = fAreaSpec.Overlap (dstArea);
407
408 if (overlap.NotEmpty ())
409 {
410
411 for (uint32 plane = fAreaSpec.Plane ();
412 plane < fAreaSpec.Plane () + fAreaSpec.Planes () &&
413 plane < buffer.Planes ();
414 plane++)
415 {
416
417 DoMapArea16 (buffer.DirtyPixel_uint16 (overlap.t, overlap.l, plane),
418 1,
419 (overlap.H () + fAreaSpec.RowPitch () - 1) / fAreaSpec.RowPitch (),
420 (overlap.W () + fAreaSpec.ColPitch () - 1) / fAreaSpec.ColPitch (),
421 0,
422 fAreaSpec.RowPitch () * buffer.RowStep (),
423 fAreaSpec.ColPitch (),
424 fTable->Buffer_uint16 ());
425
426 }
427
428 }
429
430 }
431
432/*****************************************************************************/
433
434dng_opcode_MapPolynomial::dng_opcode_MapPolynomial (const dng_area_spec &areaSpec,
435 uint32 degree,
436 const real64 *coefficient)
437
438 : dng_inplace_opcode (dngOpcode_MapPolynomial,
439 dngVersion_1_3_0_0,
440 kFlag_None)
441
442 , fAreaSpec (areaSpec)
443 , fDegree (degree)
444
445 {
446
447 for (uint32 j = 0; j <= kMaxDegree; j++)
448 {
449
450 if (j <= fDegree)
451 {
452 fCoefficient [j] = coefficient [j];
453 }
454
455 else
456 {
457 fCoefficient [j] = 0.0;
458 }
459
460 }
461
462 // Reduce degree if possible.
463
464 while (fDegree > 0 && fCoefficient [fDegree] == 0.0)
465 {
466 fDegree--;
467 }
468
469 }
470
471/*****************************************************************************/
472
473dng_opcode_MapPolynomial::dng_opcode_MapPolynomial (dng_stream &stream)
474
475 : dng_inplace_opcode (dngOpcode_MapPolynomial,
476 stream,
477 "MapPolynomial")
478
479 , fAreaSpec ()
480 , fDegree (0)
481
482 {
483
484 uint32 dataSize = stream.Get_uint32 ();
485
486 fAreaSpec.GetData (stream);
487
488 fDegree = stream.Get_uint32 ();
489
490 if (fDegree > kMaxDegree)
491 {
492 ThrowBadFormat ();
493 }
494
495 if (dataSize != dng_area_spec::kDataSize + 4 + (fDegree + 1) * 8)
496 {
497 ThrowBadFormat ();
498 }
499
500 for (uint32 j = 0; j <= kMaxDegree; j++)
501 {
502
503 if (j <= fDegree)
504 {
505 fCoefficient [j] = stream.Get_real64 ();
506 }
507 else
508 {
509 fCoefficient [j] = 0.0;
510 }
511
512 }
513
514 #if qDNGValidate
515
516 if (gVerbose)
517 {
518
519 for (uint32 k = 0; k <= fDegree; k++)
520 {
521 printf (" Coefficient [%u] = %f\n", (unsigned) k, fCoefficient [k]);
522 }
523
524 }
525
526 #endif
527
528 }
529
530/*****************************************************************************/
531
532void dng_opcode_MapPolynomial::PutData (dng_stream &stream) const
533 {
534
535 stream.Put_uint32 (dng_area_spec::kDataSize + 4 + (fDegree + 1) * 8);
536
537 fAreaSpec.PutData (stream);
538
539 stream.Put_uint32 (fDegree);
540
541 for (uint32 j = 0; j <= fDegree; j++)
542 {
543 stream.Put_real64 (fCoefficient [j]);
544 }
545
546 }
547
548/*****************************************************************************/
549
550uint32 dng_opcode_MapPolynomial::BufferPixelType (uint32 imagePixelType)
551 {
552
553 // If we are operating on the stage 1 image, then we need
554 // to adjust the coefficients to convert from the image
555 // values to the 32-bit floating point values that this
556 // opcode operates on.
557
558 // If we are operating on the stage 2 or 3 image, the logical
559 // range of the image is already 0.0 to 1.0, so we don't
560 // need to adjust the values.
561
562 real64 scale32 = 1.0;
563
564 if (Stage () == 1)
565 {
566
567 switch (imagePixelType)
568 {
569
570 case ttFloat:
571 break;
572
573 case ttShort:
574 {
575 scale32 = (real64) 0xFFFF;
576 break;
577 }
578
579 case ttLong:
580 {
581 scale32 = (real64) 0xFFFFFFFF;
582 break;
583 }
584
585 default:
586 ThrowBadFormat ();
587
588 }
589
590 }
591
592 real64 factor32 = 1.0 / scale32;
593
594 for (uint32 j = 0; j <= kMaxDegree; j++)
595 {
596
597 fCoefficient32 [j] = ConvertDoubleToFloat(fCoefficient [j] * factor32);
598
599 factor32 *= scale32;
600
601 }
602
603 return ttFloat;
604
605 }
606
607/*****************************************************************************/
608
609dng_rect dng_opcode_MapPolynomial::ModifiedBounds (const dng_rect &imageBounds)
610 {
611
612 return fAreaSpec.Overlap (imageBounds);
613
614 }
615
616/*****************************************************************************/
617
618void dng_opcode_MapPolynomial::ProcessArea (dng_negative & /* negative */,
619 uint32 /* threadIndex */,
620 dng_pixel_buffer &buffer,
621 const dng_rect &dstArea,
622 const dng_rect & /* imageBounds */)
623 {
624
625 dng_rect overlap = fAreaSpec.Overlap (dstArea);
626
627 if (overlap.NotEmpty ())
628 {
629
630 uint32 cols = overlap.W ();
631
632 uint32 colPitch = fAreaSpec.ColPitch ();
633
634 for (uint32 plane = fAreaSpec.Plane ();
635 plane < fAreaSpec.Plane () + fAreaSpec.Planes () &&
636 plane < buffer.Planes ();
637 plane++)
638 {
639
640 for (int32 row = overlap.t; row < overlap.b; row += fAreaSpec.RowPitch ())
641 {
642
643 real32 *dPtr = buffer.DirtyPixel_real32 (row, overlap.l, plane);
644
645 switch (fDegree)
646 {
647
648 case 0:
649 {
650
651 real32 y = Pin_real32 (0.0f,
652 fCoefficient32 [0],
653 1.0f);
654
655 for (uint32 col = 0; col < cols; col += colPitch)
656 {
657
658 dPtr [col] = y;
659
660 }
661
662 break;
663
664 }
665
666 case 1:
667 {
668
669 real32 c0 = fCoefficient32 [0];
670 real32 c1 = fCoefficient32 [1];
671
672 if (c0 == 0.0f)
673 {
674
675 if (c1 > 0.0f)
676 {
677
678 for (uint32 col = 0; col < cols; col += colPitch)
679 {
680
681 real32 x = dPtr [col];
682
683 real32 y = c1 * x;
684
685 dPtr [col] = Min_real32 (y, 1.0f);
686
687 }
688
689 }
690
691 else
692 {
693
694 for (uint32 col = 0; col < cols; col += colPitch)
695 {
696
697 dPtr [col] = 0.0f;
698
699 }
700
701 }
702
703 }
704
705 else
706 {
707
708 for (uint32 col = 0; col < cols; col += colPitch)
709 {
710
711 real32 x = dPtr [col];
712
713 real32 y = c0 +
714 c1 * x;
715
716 dPtr [col] = Pin_real32 (0.0f, y, 1.0f);
717
718 }
719
720 }
721
722 break;
723
724 }
725
726 case 2:
727 {
728
729 for (uint32 col = 0; col < cols; col += colPitch)
730 {
731
732 real32 x = dPtr [col];
733
734 real32 y = fCoefficient32 [0] + x *
735 (fCoefficient32 [1] + x *
736 (fCoefficient32 [2]));
737
738 dPtr [col] = Pin_real32 (0.0f, y, 1.0f);
739
740 }
741
742 break;
743
744 }
745
746 case 3:
747 {
748
749 for (uint32 col = 0; col < cols; col += colPitch)
750 {
751
752 real32 x = dPtr [col];
753
754 real32 y = fCoefficient32 [0] + x *
755 (fCoefficient32 [1] + x *
756 (fCoefficient32 [2] + x *
757 (fCoefficient32 [3])));
758
759 dPtr [col] = Pin_real32 (0.0f, y, 1.0f);
760
761 }
762
763 break;
764
765 }
766
767 case 4:
768 {
769
770 for (uint32 col = 0; col < cols; col += colPitch)
771 {
772
773 real32 x = dPtr [col];
774
775 real32 y = fCoefficient32 [0] + x *
776 (fCoefficient32 [1] + x *
777 (fCoefficient32 [2] + x *
778 (fCoefficient32 [3] + x *
779 (fCoefficient32 [4]))));
780
781 dPtr [col] = Pin_real32 (0.0f, y, 1.0f);
782
783 }
784
785 break;
786
787 }
788
789 default:
790 {
791
792 for (uint32 col = 0; col < cols; col += colPitch)
793 {
794
795 real32 x = dPtr [col];
796
797 real32 y = fCoefficient32 [0];
798
799 real32 xx = x;
800
801 for (uint32 j = 1; j <= fDegree; j++)
802 {
803
804 y += fCoefficient32 [j] * xx;
805
806 xx *= x;
807
808 }
809
810 dPtr [col] = Pin_real32 (0.0f, y, 1.0f);
811
812 }
813
814 }
815
816 }
817
818 }
819
820 }
821
822 }
823
824 }
825
826/*****************************************************************************/
827
828dng_opcode_DeltaPerRow::dng_opcode_DeltaPerRow (const dng_area_spec &areaSpec,
829 AutoPtr<dng_memory_block> &table)
830
831 : dng_inplace_opcode (dngOpcode_DeltaPerRow,
832 dngVersion_1_3_0_0,
833 kFlag_None)
834
835 , fAreaSpec (areaSpec)
836 , fTable ()
837 , fScale (1.0f)
838
839 {
840
841 fTable.Reset (table.Release ());
842
843 }
844
845/*****************************************************************************/
846
847dng_opcode_DeltaPerRow::dng_opcode_DeltaPerRow (dng_host &host,
848 dng_stream &stream)
849
850 : dng_inplace_opcode (dngOpcode_DeltaPerRow,
851 stream,
852 "DeltaPerRow")
853
854 , fAreaSpec ()
855 , fTable ()
856 , fScale (1.0f)
857
858 {
859
860 uint32 dataSize = stream.Get_uint32 ();
861
862 fAreaSpec.GetData (stream);
863
864 uint32 deltas = SafeUint32DivideUp (fAreaSpec.Area ().H (),
865 fAreaSpec.RowPitch ());
866
867 if (deltas != stream.Get_uint32 ())
868 {
869 ThrowBadFormat ();
870 }
871
872 if (dataSize != dng_area_spec::kDataSize + 4 + deltas * 4)
873 {
874 ThrowBadFormat ();
875 }
876
877 fTable.Reset (host.Allocate (SafeUint32Mult (deltas,
878 static_cast<uint32> (sizeof (real32)))));
879
880 real32 *table = fTable->Buffer_real32 ();
881
882 for (uint32 j = 0; j < deltas; j++)
883 {
884 table [j] = stream.Get_real32 ();
885 }
886
887 #if qDNGValidate
888
889 if (gVerbose)
890 {
891
892 printf ("Count: %u\n", (unsigned) deltas);
893
894 for (uint32 k = 0; k < deltas && k < gDumpLineLimit; k++)
895 {
896 printf (" Delta [%u] = %f\n", (unsigned) k, table [k]);
897 }
898
899 if (deltas > gDumpLineLimit)
900 {
901 printf (" ... %u deltas skipped\n", (unsigned) (deltas - gDumpLineLimit));
902 }
903
904 }
905
906 #endif
907
908 }
909
910/*****************************************************************************/
911
912void dng_opcode_DeltaPerRow::PutData (dng_stream &stream) const
913 {
914
915 uint32 deltas = SafeUint32DivideUp (fAreaSpec.Area ().H (),
916 fAreaSpec.RowPitch ());
917
918 stream.Put_uint32 (dng_area_spec::kDataSize + 4 + deltas * 4);
919
920 fAreaSpec.PutData (stream);
921
922 stream.Put_uint32 (deltas);
923
924 real32 *table = fTable->Buffer_real32 ();
925
926 for (uint32 j = 0; j < deltas; j++)
927 {
928 stream.Put_real32 (table [j]);
929 }
930
931 }
932
933/*****************************************************************************/
934
935uint32 dng_opcode_DeltaPerRow::BufferPixelType (uint32 imagePixelType)
936 {
937
938 real64 scale32 = 1.0;
939
940 switch (imagePixelType)
941 {
942
943 case ttFloat:
944 break;
945
946 case ttShort:
947 {
948 scale32 = (real64) 0xFFFF;
949 break;
950 }
951
952 case ttLong:
953 {
954 scale32 = (real64) 0xFFFFFFFF;
955 break;
956 }
957
958 default:
959 ThrowBadFormat ();
960
961 }
962
963 fScale = (real32) (1.0 / scale32);
964
965 return ttFloat;
966
967 }
968
969/*****************************************************************************/
970
971dng_rect dng_opcode_DeltaPerRow::ModifiedBounds (const dng_rect &imageBounds)
972 {
973
974 return fAreaSpec.Overlap (imageBounds);
975
976 }
977
978/*****************************************************************************/
979
980void dng_opcode_DeltaPerRow::ProcessArea (dng_negative & /* negative */,
981 uint32 /* threadIndex */,
982 dng_pixel_buffer &buffer,
983 const dng_rect &dstArea,
984 const dng_rect & /* imageBounds */)
985 {
986
987 dng_rect overlap = fAreaSpec.Overlap (dstArea);
988
989 if (overlap.NotEmpty ())
990 {
991
992 uint32 cols = overlap.W ();
993
994 uint32 colPitch = fAreaSpec.ColPitch ();
995
996 for (uint32 plane = fAreaSpec.Plane ();
997 plane < fAreaSpec.Plane () + fAreaSpec.Planes () &&
998 plane < buffer.Planes ();
999 plane++)
1000 {
1001
1002 const real32 *table = fTable->Buffer_real32 () +
1003 ((overlap.t - fAreaSpec.Area ().t) /
1004 fAreaSpec.RowPitch ());
1005
1006 for (int32 row = overlap.t; row < overlap.b; row += fAreaSpec.RowPitch ())
1007 {
1008
1009 real32 rowDelta = *(table++) * fScale;
1010
1011 real32 *dPtr = buffer.DirtyPixel_real32 (row, overlap.l, plane);
1012
1013 for (uint32 col = 0; col < cols; col += colPitch)
1014 {
1015
1016 real32 x = dPtr [col];
1017
1018 real32 y = x + rowDelta;
1019
1020 dPtr [col] = Pin_real32 (0.0f, y, 1.0f);
1021
1022 }
1023
1024 }
1025
1026 }
1027
1028 }
1029
1030 }
1031
1032/*****************************************************************************/
1033
1034dng_opcode_DeltaPerColumn::dng_opcode_DeltaPerColumn (const dng_area_spec &areaSpec,
1035 AutoPtr<dng_memory_block> &table)
1036
1037 : dng_inplace_opcode (dngOpcode_DeltaPerColumn,
1038 dngVersion_1_3_0_0,
1039 kFlag_None)
1040
1041 , fAreaSpec (areaSpec)
1042 , fTable ()
1043 , fScale (1.0f)
1044
1045 {
1046
1047 fTable.Reset (table.Release ());
1048
1049 }
1050
1051/*****************************************************************************/
1052
1053dng_opcode_DeltaPerColumn::dng_opcode_DeltaPerColumn (dng_host &host,
1054 dng_stream &stream)
1055
1056 : dng_inplace_opcode (dngOpcode_DeltaPerColumn,
1057 stream,
1058 "DeltaPerColumn")
1059
1060 , fAreaSpec ()
1061 , fTable ()
1062 , fScale (1.0f)
1063
1064 {
1065
1066 uint32 dataSize = stream.Get_uint32 ();
1067
1068 fAreaSpec.GetData (stream);
1069
1070 uint32 deltas = SafeUint32DivideUp (fAreaSpec.Area ().W (),
1071 fAreaSpec.ColPitch ());
1072
1073 if (deltas != stream.Get_uint32 ())
1074 {
1075 ThrowBadFormat ();
1076 }
1077
1078 if (dataSize != dng_area_spec::kDataSize + 4 + deltas * 4)
1079 {
1080 ThrowBadFormat ();
1081 }
1082
1083 fTable.Reset (host.Allocate (SafeUint32Mult (deltas,
1084 static_cast<uint32> (sizeof (real32)))));
1085
1086 real32 *table = fTable->Buffer_real32 ();
1087
1088 for (uint32 j = 0; j < deltas; j++)
1089 {
1090 table [j] = stream.Get_real32 ();
1091 }
1092
1093 #if qDNGValidate
1094
1095 if (gVerbose)
1096 {
1097
1098 printf ("Count: %u\n", (unsigned) deltas);
1099
1100 for (uint32 k = 0; k < deltas && k < gDumpLineLimit; k++)
1101 {
1102 printf (" Delta [%u] = %f\n", (unsigned) k, table [k]);
1103 }
1104
1105 if (deltas > gDumpLineLimit)
1106 {
1107 printf (" ... %u deltas skipped\n", (unsigned) (deltas - gDumpLineLimit));
1108 }
1109
1110 }
1111
1112 #endif
1113
1114 }
1115
1116/*****************************************************************************/
1117
1118void dng_opcode_DeltaPerColumn::PutData (dng_stream &stream) const
1119 {
1120
1121 uint32 deltas = SafeUint32DivideUp (fAreaSpec.Area ().W (),
1122 fAreaSpec.ColPitch ());
1123
1124 stream.Put_uint32 (dng_area_spec::kDataSize + 4 + deltas * 4);
1125
1126 fAreaSpec.PutData (stream);
1127
1128 stream.Put_uint32 (deltas);
1129
1130 real32 *table = fTable->Buffer_real32 ();
1131
1132 for (uint32 j = 0; j < deltas; j++)
1133 {
1134 stream.Put_real32 (table [j]);
1135 }
1136
1137 }
1138
1139/*****************************************************************************/
1140
1141uint32 dng_opcode_DeltaPerColumn::BufferPixelType (uint32 imagePixelType)
1142 {
1143
1144 real64 scale32 = 1.0;
1145
1146 switch (imagePixelType)
1147 {
1148
1149 case ttFloat:
1150 break;
1151
1152 case ttShort:
1153 {
1154 scale32 = (real64) 0xFFFF;
1155 break;
1156 }
1157
1158 case ttLong:
1159 {
1160 scale32 = (real64) 0xFFFFFFFF;
1161 break;
1162 }
1163
1164 default:
1165 ThrowBadFormat ();
1166
1167 }
1168
1169 fScale = (real32) (1.0 / scale32);
1170
1171 return ttFloat;
1172
1173 }
1174
1175/*****************************************************************************/
1176
1177dng_rect dng_opcode_DeltaPerColumn::ModifiedBounds (const dng_rect &imageBounds)
1178 {
1179
1180 return fAreaSpec.Overlap (imageBounds);
1181
1182 }
1183
1184/*****************************************************************************/
1185
1186void dng_opcode_DeltaPerColumn::ProcessArea (dng_negative & /* negative */,
1187 uint32 /* threadIndex */,
1188 dng_pixel_buffer &buffer,
1189 const dng_rect &dstArea,
1190 const dng_rect & /* imageBounds */)
1191 {
1192
1193 dng_rect overlap = fAreaSpec.Overlap (dstArea);
1194
1195 if (overlap.NotEmpty ())
1196 {
1197
1198 uint32 rows = (overlap.H () + fAreaSpec.RowPitch () - 1) /
1199 fAreaSpec.RowPitch ();
1200
1201 int32 rowStep = buffer.RowStep () * fAreaSpec.RowPitch ();
1202
1203 for (uint32 plane = fAreaSpec.Plane ();
1204 plane < fAreaSpec.Plane () + fAreaSpec.Planes () &&
1205 plane < buffer.Planes ();
1206 plane++)
1207 {
1208
1209 const real32 *table = fTable->Buffer_real32 () +
1210 ((overlap.l - fAreaSpec.Area ().l) /
1211 fAreaSpec.ColPitch ());
1212
1213 for (int32 col = overlap.l; col < overlap.r; col += fAreaSpec.ColPitch ())
1214 {
1215
1216 real32 colDelta = *(table++) * fScale;
1217
1218 real32 *dPtr = buffer.DirtyPixel_real32 (overlap.t, col, plane);
1219
1220 for (uint32 row = 0; row < rows; row++)
1221 {
1222
1223 real32 x = dPtr [0];
1224
1225 real32 y = x + colDelta;
1226
1227 dPtr [0] = Pin_real32 (0.0f, y, 1.0f);
1228
1229 dPtr += rowStep;
1230
1231 }
1232
1233 }
1234
1235 }
1236
1237 }
1238
1239 }
1240
1241/*****************************************************************************/
1242
1243dng_opcode_ScalePerRow::dng_opcode_ScalePerRow (const dng_area_spec &areaSpec,
1244 AutoPtr<dng_memory_block> &table)
1245
1246 : dng_inplace_opcode (dngOpcode_ScalePerRow,
1247 dngVersion_1_3_0_0,
1248 kFlag_None)
1249
1250 , fAreaSpec (areaSpec)
1251 , fTable ()
1252
1253 {
1254
1255 fTable.Reset (table.Release ());
1256
1257 }
1258
1259/*****************************************************************************/
1260
1261dng_opcode_ScalePerRow::dng_opcode_ScalePerRow (dng_host &host,
1262 dng_stream &stream)
1263
1264 : dng_inplace_opcode (dngOpcode_ScalePerRow,
1265 stream,
1266 "ScalePerRow")
1267
1268 , fAreaSpec ()
1269 , fTable ()
1270
1271 {
1272
1273 uint32 dataSize = stream.Get_uint32 ();
1274
1275 fAreaSpec.GetData (stream);
1276
1277 uint32 scales = SafeUint32DivideUp (fAreaSpec.Area ().H (),
1278 fAreaSpec.RowPitch ());
1279
1280 if (scales != stream.Get_uint32 ())
1281 {
1282 ThrowBadFormat ();
1283 }
1284
1285 if (dataSize != dng_area_spec::kDataSize + 4 + scales * 4)
1286 {
1287 ThrowBadFormat ();
1288 }
1289
1290 fTable.Reset (host.Allocate (SafeUint32Mult (scales,
1291 static_cast<uint32> (sizeof (real32)))));
1292
1293 real32 *table = fTable->Buffer_real32 ();
1294
1295 for (uint32 j = 0; j < scales; j++)
1296 {
1297 table [j] = stream.Get_real32 ();
1298 }
1299
1300 #if qDNGValidate
1301
1302 if (gVerbose)
1303 {
1304
1305 printf ("Count: %u\n", (unsigned) scales);
1306
1307 for (uint32 k = 0; k < scales && k < gDumpLineLimit; k++)
1308 {
1309 printf (" Scale [%u] = %f\n", (unsigned) k, table [k]);
1310 }
1311
1312 if (scales > gDumpLineLimit)
1313 {
1314 printf (" ... %u scales skipped\n", (unsigned) (scales - gDumpLineLimit));
1315 }
1316
1317 }
1318
1319 #endif
1320
1321 }
1322
1323/*****************************************************************************/
1324
1325void dng_opcode_ScalePerRow::PutData (dng_stream &stream) const
1326 {
1327
1328 uint32 scales = SafeUint32DivideUp (fAreaSpec.Area ().H (),
1329 fAreaSpec.RowPitch ());
1330
1331 stream.Put_uint32 (dng_area_spec::kDataSize + 4 + scales * 4);
1332
1333 fAreaSpec.PutData (stream);
1334
1335 stream.Put_uint32 (scales);
1336
1337 real32 *table = fTable->Buffer_real32 ();
1338
1339 for (uint32 j = 0; j < scales; j++)
1340 {
1341 stream.Put_real32 (table [j]);
1342 }
1343
1344 }
1345
1346/*****************************************************************************/
1347
1348uint32 dng_opcode_ScalePerRow::BufferPixelType (uint32 /* imagePixelType */)
1349 {
1350
1351 return ttFloat;
1352
1353 }
1354
1355/*****************************************************************************/
1356
1357dng_rect dng_opcode_ScalePerRow::ModifiedBounds (const dng_rect &imageBounds)
1358 {
1359
1360 return fAreaSpec.Overlap (imageBounds);
1361
1362 }
1363
1364/*****************************************************************************/
1365
1366void dng_opcode_ScalePerRow::ProcessArea (dng_negative & /* negative */,
1367 uint32 /* threadIndex */,
1368 dng_pixel_buffer &buffer,
1369 const dng_rect &dstArea,
1370 const dng_rect & /* imageBounds */)
1371 {
1372
1373 dng_rect overlap = fAreaSpec.Overlap (dstArea);
1374
1375 if (overlap.NotEmpty ())
1376 {
1377
1378 uint32 cols = overlap.W ();
1379
1380 uint32 colPitch = fAreaSpec.ColPitch ();
1381
1382 for (uint32 plane = fAreaSpec.Plane ();
1383 plane < fAreaSpec.Plane () + fAreaSpec.Planes () &&
1384 plane < buffer.Planes ();
1385 plane++)
1386 {
1387
1388 const real32 *table = fTable->Buffer_real32 () +
1389 ((overlap.t - fAreaSpec.Area ().t) /
1390 fAreaSpec.RowPitch ());
1391
1392 for (int32 row = overlap.t; row < overlap.b; row += fAreaSpec.RowPitch ())
1393 {
1394
1395 real32 rowScale = *(table++);
1396
1397 real32 *dPtr = buffer.DirtyPixel_real32 (row, overlap.l, plane);
1398
1399 for (uint32 col = 0; col < cols; col += colPitch)
1400 {
1401
1402 real32 x = dPtr [col];
1403
1404 real32 y = x * rowScale;
1405
1406 dPtr [col] = Min_real32 (y, 1.0f);
1407
1408 }
1409
1410 }
1411
1412 }
1413
1414 }
1415
1416 }
1417
1418/*****************************************************************************/
1419
1420dng_opcode_ScalePerColumn::dng_opcode_ScalePerColumn (const dng_area_spec &areaSpec,
1421 AutoPtr<dng_memory_block> &table)
1422
1423 : dng_inplace_opcode (dngOpcode_ScalePerColumn,
1424 dngVersion_1_3_0_0,
1425 kFlag_None)
1426
1427 , fAreaSpec (areaSpec)
1428 , fTable ()
1429
1430 {
1431
1432 fTable.Reset (table.Release ());
1433
1434 }
1435
1436/*****************************************************************************/
1437
1438dng_opcode_ScalePerColumn::dng_opcode_ScalePerColumn (dng_host &host,
1439 dng_stream &stream)
1440
1441 : dng_inplace_opcode (dngOpcode_ScalePerColumn,
1442 stream,
1443 "ScalePerColumn")
1444
1445 , fAreaSpec ()
1446 , fTable ()
1447
1448 {
1449
1450 uint32 dataSize = stream.Get_uint32 ();
1451
1452 fAreaSpec.GetData (stream);
1453
1454 uint32 scales = SafeUint32DivideUp (fAreaSpec.Area ().W (),
1455 fAreaSpec.ColPitch());
1456
1457 if (scales != stream.Get_uint32 ())
1458 {
1459 ThrowBadFormat ();
1460 }
1461
1462 if (dataSize != dng_area_spec::kDataSize + 4 + scales * 4)
1463 {
1464 ThrowBadFormat ();
1465 }
1466
1467 fTable.Reset (host.Allocate (SafeUint32Mult (scales,
1468 static_cast<uint32> (sizeof (real32)))));
1469
1470 real32 *table = fTable->Buffer_real32 ();
1471
1472 for (uint32 j = 0; j < scales; j++)
1473 {
1474 table [j] = stream.Get_real32 ();
1475 }
1476
1477 #if qDNGValidate
1478
1479 if (gVerbose)
1480 {
1481
1482 printf ("Count: %u\n", (unsigned) scales);
1483
1484 for (uint32 k = 0; k < scales && k < gDumpLineLimit; k++)
1485 {
1486 printf (" Scale [%u] = %f\n", (unsigned) k, table [k]);
1487 }
1488
1489 if (scales > gDumpLineLimit)
1490 {
1491 printf (" ... %u deltas skipped\n", (unsigned) (scales - gDumpLineLimit));
1492 }
1493
1494 }
1495
1496 #endif
1497
1498 }
1499
1500/*****************************************************************************/
1501
1502void dng_opcode_ScalePerColumn::PutData (dng_stream &stream) const
1503 {
1504
1505 uint32 scales = SafeUint32DivideUp (fAreaSpec.Area ().W (),
1506 fAreaSpec.ColPitch ());
1507
1508 stream.Put_uint32 (dng_area_spec::kDataSize + 4 + scales * 4);
1509
1510 fAreaSpec.PutData (stream);
1511
1512 stream.Put_uint32 (scales);
1513
1514 real32 *table = fTable->Buffer_real32 ();
1515
1516 for (uint32 j = 0; j < scales; j++)
1517 {
1518 stream.Put_real32 (table [j]);
1519 }
1520
1521 }
1522
1523/*****************************************************************************/
1524
1525uint32 dng_opcode_ScalePerColumn::BufferPixelType (uint32 /* imagePixelType */)
1526 {
1527
1528 return ttFloat;
1529
1530 }
1531
1532/*****************************************************************************/
1533
1534dng_rect dng_opcode_ScalePerColumn::ModifiedBounds (const dng_rect &imageBounds)
1535 {
1536
1537 return fAreaSpec.Overlap (imageBounds);
1538
1539 }
1540
1541/*****************************************************************************/
1542
1543void dng_opcode_ScalePerColumn::ProcessArea (dng_negative & /* negative */,
1544 uint32 /* threadIndex */,
1545 dng_pixel_buffer &buffer,
1546 const dng_rect &dstArea,
1547 const dng_rect & /* imageBounds */)
1548 {
1549
1550 dng_rect overlap = fAreaSpec.Overlap (dstArea);
1551
1552 if (overlap.NotEmpty ())
1553 {
1554
1555 uint32 rows = (overlap.H () + fAreaSpec.RowPitch () - 1) /
1556 fAreaSpec.RowPitch ();
1557
1558 int32 rowStep = buffer.RowStep () * fAreaSpec.RowPitch ();
1559
1560 for (uint32 plane = fAreaSpec.Plane ();
1561 plane < fAreaSpec.Plane () + fAreaSpec.Planes () &&
1562 plane < buffer.Planes ();
1563 plane++)
1564 {
1565
1566 const real32 *table = fTable->Buffer_real32 () +
1567 ((overlap.l - fAreaSpec.Area ().l) /
1568 fAreaSpec.ColPitch ());
1569
1570 for (int32 col = overlap.l; col < overlap.r; col += fAreaSpec.ColPitch ())
1571 {
1572
1573 real32 colScale = *(table++);
1574
1575 real32 *dPtr = buffer.DirtyPixel_real32 (overlap.t, col, plane);
1576
1577 for (uint32 row = 0; row < rows; row++)
1578 {
1579
1580 real32 x = dPtr [0];
1581
1582 real32 y = x * colScale;
1583
1584 dPtr [0] = Min_real32 (y, 1.0f);
1585
1586 dPtr += rowStep;
1587
1588 }
1589
1590 }
1591
1592 }
1593
1594 }
1595
1596 }
1597
1598/*****************************************************************************/
1599