1 /*****************************************************************************/
2 // Copyright 2006-2007 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_lossless_jpeg.cpp#2 $ */
10 /* $DateTime: 2012/06/01 07:28:57 $ */
11 /* $Change: 832715 $ */
12 /* $Author: tknoll $ */
13
14 /*****************************************************************************/
15
16 // Lossless JPEG code adapted from:
17
18 /* Copyright (C) 1991, 1992, Thomas G. Lane.
19 * Part of the Independent JPEG Group's software.
20 * See the file Copyright for more details.
21 *
22 * Copyright (c) 1993 Brian C. Smith, The Regents of the University
23 * of California
24 * All rights reserved.
25 *
26 * Copyright (c) 1994 Kongji Huang and Brian C. Smith.
27 * Cornell University
28 * All rights reserved.
29 *
30 * Permission to use, copy, modify, and distribute this software and its
31 * documentation for any purpose, without fee, and without written agreement is
32 * hereby granted, provided that the above copyright notice and the following
33 * two paragraphs appear in all copies of this software.
34 *
35 * IN NO EVENT SHALL CORNELL UNIVERSITY BE LIABLE TO ANY PARTY FOR
36 * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT
37 * OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF CORNELL
38 * UNIVERSITY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
39 *
40 * CORNELL UNIVERSITY SPECIFICALLY DISCLAIMS ANY WARRANTIES,
41 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
42 * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
43 * ON AN "AS IS" BASIS, AND CORNELL UNIVERSITY HAS NO OBLIGATION TO
44 * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
45 */
46
47 /*****************************************************************************/
48
49 #include "dng_lossless_jpeg.h"
50
51 #include "dng_assertions.h"
52 #include "dng_exceptions.h"
53 #include "dng_memory.h"
54 #include "dng_stream.h"
55 #include "dng_tag_codes.h"
56
57 /*****************************************************************************/
58
59 // This module contains routines that should be as fast as possible, even
60 // at the expense of slight code size increases.
61
62 #include "dng_fast_module.h"
63
64 /*****************************************************************************/
65
66 // The qSupportCanon_sRAW stuff not actually required for DNG support, but
67 // only included to allow this code to be used on Canon sRAW files.
68
69 #ifndef qSupportCanon_sRAW
70 #define qSupportCanon_sRAW 1
71 #endif
72
73 // The qSupportHasselblad_3FR stuff not actually required for DNG support, but
74 // only included to allow this code to be used on Hasselblad 3FR files.
75
76 #ifndef qSupportHasselblad_3FR
77 #define qSupportHasselblad_3FR 1
78 #endif
79
80 /*****************************************************************************/
81
82 /*
83 * One of the following structures is created for each huffman coding
84 * table. We use the same structure for encoding and decoding, so there
85 * may be some extra fields for encoding that aren't used in the decoding
86 * and vice-versa.
87 */
88
89 struct HuffmanTable
90 {
91
92 /*
93 * These two fields directly represent the contents of a JPEG DHT
94 * marker
95 */
96 uint8 bits[17];
97 uint8 huffval[256];
98
99 /*
100 * The remaining fields are computed from the above to allow more
101 * efficient coding and decoding. These fields should be considered
102 * private to the Huffman compression & decompression modules.
103 */
104
105 uint16 mincode[17];
106 int32 maxcode[18];
107 int16 valptr[17];
108 int32 numbits[256];
109 int32 value[256];
110
111 uint16 ehufco[256];
112 int8 ehufsi[256];
113
114 };
115
116 /*****************************************************************************/
117
118 // Computes the derived fields in the Huffman table structure.
119
FixHuffTbl(HuffmanTable * htbl)120 static void FixHuffTbl (HuffmanTable *htbl)
121 {
122
123 int32 l;
124 int32 i;
125
126 const uint32 bitMask [] =
127 {
128 0xffffffff, 0x7fffffff, 0x3fffffff, 0x1fffffff,
129 0x0fffffff, 0x07ffffff, 0x03ffffff, 0x01ffffff,
130 0x00ffffff, 0x007fffff, 0x003fffff, 0x001fffff,
131 0x000fffff, 0x0007ffff, 0x0003ffff, 0x0001ffff,
132 0x0000ffff, 0x00007fff, 0x00003fff, 0x00001fff,
133 0x00000fff, 0x000007ff, 0x000003ff, 0x000001ff,
134 0x000000ff, 0x0000007f, 0x0000003f, 0x0000001f,
135 0x0000000f, 0x00000007, 0x00000003, 0x00000001
136 };
137
138 // Figure C.1: make table of Huffman code length for each symbol
139 // Note that this is in code-length order.
140
141 int8 huffsize [257];
142
143 int32 p = 0;
144
145 for (l = 1; l <= 16; l++)
146 {
147
148 for (i = 1; i <= (int32) htbl->bits [l]; i++)
149 huffsize [p++] = (int8) l;
150
151 }
152
153 huffsize [p] = 0;
154
155 int32 lastp = p;
156
157 // Figure C.2: generate the codes themselves
158 // Note that this is in code-length order.
159
160 uint16 huffcode [257];
161
162 uint16 code = 0;
163
164 int32 si = huffsize [0];
165
166 p = 0;
167
168 while (huffsize [p])
169 {
170
171 while (((int32) huffsize [p]) == si)
172 {
173 huffcode [p++] = code;
174 code++;
175 }
176
177 code <<= 1;
178
179 si++;
180
181 }
182
183 // Figure C.3: generate encoding tables
184 // These are code and size indexed by symbol value
185 // Set any codeless symbols to have code length 0; this allows
186 // EmitBits to detect any attempt to emit such symbols.
187
188 memset (htbl->ehufsi, 0, sizeof (htbl->ehufsi));
189
190 for (p = 0; p < lastp; p++)
191 {
192
193 htbl->ehufco [htbl->huffval [p]] = huffcode [p];
194 htbl->ehufsi [htbl->huffval [p]] = huffsize [p];
195
196 }
197
198 // Figure F.15: generate decoding tables
199
200 p = 0;
201
202 for (l = 1; l <= 16; l++)
203 {
204
205 if (htbl->bits [l])
206 {
207
208 htbl->valptr [l] = (int16) p;
209 htbl->mincode [l] = huffcode [p];
210
211 p += htbl->bits [l];
212
213 htbl->maxcode [l] = huffcode [p - 1];
214
215 }
216
217 else
218 {
219 htbl->maxcode [l] = -1;
220 }
221
222 }
223
224 // We put in this value to ensure HuffDecode terminates.
225
226 htbl->maxcode[17] = 0xFFFFFL;
227
228 // Build the numbits, value lookup tables.
229 // These table allow us to gather 8 bits from the bits stream,
230 // and immediately lookup the size and value of the huffman codes.
231 // If size is zero, it means that more than 8 bits are in the huffman
232 // code (this happens about 3-4% of the time).
233
234 memset (htbl->numbits, 0, sizeof (htbl->numbits));
235
236 for (p = 0; p < lastp; p++)
237 {
238
239 int32 size = huffsize [p];
240
241 if (size <= 8)
242 {
243
244 int32 value = htbl->huffval [p];
245
246 code = huffcode [p];
247
248 int32 ll = code << (8 -size);
249
250 int32 ul = (size < 8 ? ll | bitMask [24 + size]
251 : ll);
252 if (ul >= static_cast<int32>(sizeof(htbl->numbits) / sizeof(htbl->numbits[0])) ||
253 ul >= static_cast<int32>(sizeof(htbl->value) / sizeof(htbl->value[0])))
254 {
255 ThrowBadFormat ();
256 }
257
258 for (i = ll; i <= ul; i++)
259 {
260 htbl->numbits [i] = size;
261 htbl->value [i] = value;
262 }
263
264 }
265
266 }
267
268 }
269
270 /*****************************************************************************/
271
272 /*
273 * The following structure stores basic information about one component.
274 */
275
276 struct JpegComponentInfo
277 {
278
279 /*
280 * These values are fixed over the whole image.
281 * They are read from the SOF marker.
282 */
283 int16 componentId; /* identifier for this component (0..255) */
284 int16 componentIndex; /* its index in SOF or cPtr->compInfo[] */
285
286 /*
287 * Downsampling is not normally used in lossless JPEG, although
288 * it is permitted by the JPEG standard (DIS). We set all sampling
289 * factors to 1 in this program.
290 */
291 int16 hSampFactor; /* horizontal sampling factor */
292 int16 vSampFactor; /* vertical sampling factor */
293
294 /*
295 * Huffman table selector (0..3). The value may vary
296 * between scans. It is read from the SOS marker.
297 */
298 int16 dcTblNo;
299
300 };
301
302 /*
303 * One of the following structures is used to pass around the
304 * decompression information.
305 */
306
307 struct DecompressInfo
308 {
309
310 /*
311 * Image width, height, and image data precision (bits/sample)
312 * These fields are set by ReadFileHeader or ReadScanHeader
313 */
314 int32 imageWidth;
315 int32 imageHeight;
316 int32 dataPrecision;
317
318 /*
319 * compInfo[i] describes component that appears i'th in SOF
320 * numComponents is the # of color components in JPEG image.
321 */
322 JpegComponentInfo *compInfo;
323 int16 numComponents;
324
325 /*
326 * *curCompInfo[i] describes component that appears i'th in SOS.
327 * compsInScan is the # of color components in current scan.
328 */
329 JpegComponentInfo *curCompInfo[4];
330 int16 compsInScan;
331
332 /*
333 * MCUmembership[i] indexes the i'th component of MCU into the
334 * curCompInfo array.
335 */
336 int16 MCUmembership[10];
337
338 /*
339 * ptrs to Huffman coding tables, or NULL if not defined
340 */
341 HuffmanTable *dcHuffTblPtrs[4];
342
343 /*
344 * prediction selection value (PSV) and point transform parameter (Pt)
345 */
346 int32 Ss;
347 int32 Pt;
348
349 /*
350 * In lossless JPEG, restart interval shall be an integer
351 * multiple of the number of MCU in a MCU row.
352 */
353 int32 restartInterval;/* MCUs per restart interval, 0 = no restart */
354 int32 restartInRows; /*if > 0, MCU rows per restart interval; 0 = no restart*/
355
356 /*
357 * these fields are private data for the entropy decoder
358 */
359 int32 restartRowsToGo; /* MCUs rows left in this restart interval */
360 int16 nextRestartNum; /* # of next RSTn marker (0..7) */
361
362 };
363
364 /*****************************************************************************/
365
366 // An MCU (minimum coding unit) is an array of samples.
367
368 typedef uint16 ComponentType; // the type of image components
369
370 typedef ComponentType *MCU; // MCU - array of samples
371
372 /*****************************************************************************/
373
374 class dng_lossless_decoder
375 {
376
377 private:
378
379 dng_stream *fStream; // Input data.
380
381 dng_spooler *fSpooler; // Output data.
382
383 bool fBug16; // Decode data with the "16-bit" bug.
384
385 dng_memory_data huffmanBuffer [4];
386
387 dng_memory_data compInfoBuffer;
388
389 DecompressInfo info;
390
391 dng_memory_data mcuBuffer1;
392 dng_memory_data mcuBuffer2;
393 dng_memory_data mcuBuffer3;
394 dng_memory_data mcuBuffer4;
395
396 MCU *mcuROW1;
397 MCU *mcuROW2;
398
399 uint64 getBuffer; // current bit-extraction buffer
400 int32 bitsLeft; // # of unused bits in it
401
402 #if qSupportHasselblad_3FR
403 bool fHasselblad3FR;
404 #endif
405
406 public:
407
408 dng_lossless_decoder (dng_stream *stream,
409 dng_spooler *spooler,
410 bool bug16);
411
412 void StartRead (uint32 &imageWidth,
413 uint32 &imageHeight,
414 uint32 &imageChannels);
415
416 void FinishRead ();
417
418 private:
419
GetJpegChar()420 uint8 GetJpegChar ()
421 {
422 return fStream->Get_uint8 ();
423 }
424
UnGetJpegChar()425 void UnGetJpegChar ()
426 {
427 fStream->SetReadPosition (fStream->Position () - 1);
428 }
429
430 uint16 Get2bytes ();
431
432 void SkipVariable ();
433
434 void GetDht ();
435
436 void GetDri ();
437
438 void GetApp0 ();
439
440 void GetSof (int32 code);
441
442 void GetSos ();
443
444 void GetSoi ();
445
446 int32 NextMarker ();
447
448 JpegMarker ProcessTables ();
449
450 void ReadFileHeader ();
451
452 int32 ReadScanHeader ();
453
454 void DecoderStructInit ();
455
456 void HuffDecoderInit ();
457
458 void ProcessRestart ();
459
460 int32 QuickPredict (int32 col,
461 int32 curComp,
462 MCU *curRowBuf,
463 MCU *prevRowBuf);
464
465 void FillBitBuffer (int32 nbits);
466
467 int32 show_bits8 ();
468
469 void flush_bits (int32 nbits);
470
471 int32 get_bits (int32 nbits);
472
473 int32 get_bit ();
474
475 int32 HuffDecode (HuffmanTable *htbl);
476
477 void HuffExtend (int32 &x, int32 s);
478
479 void PmPutRow (MCU *buf,
480 int32 numComp,
481 int32 numCol,
482 int32 row);
483
484 void DecodeFirstRow (MCU *curRowBuf);
485
486 void DecodeImage ();
487
488 // Hidden copy constructor and assignment operator.
489
490 dng_lossless_decoder (const dng_lossless_decoder &decoder);
491
492 dng_lossless_decoder & operator= (const dng_lossless_decoder &decoder);
493
494 };
495
496 /*****************************************************************************/
497
dng_lossless_decoder(dng_stream * stream,dng_spooler * spooler,bool bug16)498 dng_lossless_decoder::dng_lossless_decoder (dng_stream *stream,
499 dng_spooler *spooler,
500 bool bug16)
501
502 : fStream (stream )
503 , fSpooler (spooler)
504 , fBug16 (bug16 )
505
506 , compInfoBuffer ()
507 , info ()
508 , mcuBuffer1 ()
509 , mcuBuffer2 ()
510 , mcuBuffer3 ()
511 , mcuBuffer4 ()
512 , mcuROW1 (NULL)
513 , mcuROW2 (NULL)
514 , getBuffer (0)
515 , bitsLeft (0)
516
517 #if qSupportHasselblad_3FR
518 , fHasselblad3FR (false)
519 #endif
520
521 {
522
523 memset (&info, 0, sizeof (info));
524
525 }
526
527 /*****************************************************************************/
528
Get2bytes()529 uint16 dng_lossless_decoder::Get2bytes ()
530 {
531
532 uint16 a = GetJpegChar ();
533
534 return (uint16) ((a << 8) + GetJpegChar ());
535
536 }
537
538 /*****************************************************************************/
539
540 /*
541 *--------------------------------------------------------------
542 *
543 * SkipVariable --
544 *
545 * Skip over an unknown or uninteresting variable-length marker
546 *
547 * Results:
548 * None.
549 *
550 * Side effects:
551 * Bitstream is parsed over marker.
552 *
553 *
554 *--------------------------------------------------------------
555 */
556
SkipVariable()557 void dng_lossless_decoder::SkipVariable ()
558 {
559
560 uint32 length = Get2bytes () - 2;
561
562 fStream->Skip (length);
563
564 }
565
566 /*****************************************************************************/
567
568 /*
569 *--------------------------------------------------------------
570 *
571 * GetDht --
572 *
573 * Process a DHT marker
574 *
575 * Results:
576 * None
577 *
578 * Side effects:
579 * A huffman table is read.
580 * Exits on error.
581 *
582 *--------------------------------------------------------------
583 */
584
GetDht()585 void dng_lossless_decoder::GetDht ()
586 {
587
588 int32 length = Get2bytes () - 2;
589
590 while (length > 0)
591 {
592
593 int32 index = GetJpegChar ();
594
595 if (index < 0 || index >= 4)
596 {
597 ThrowBadFormat ();
598 }
599
600 HuffmanTable *&htblptr = info.dcHuffTblPtrs [index];
601
602 if (htblptr == NULL)
603 {
604
605 huffmanBuffer [index] . Allocate (sizeof (HuffmanTable));
606
607 htblptr = (HuffmanTable *) huffmanBuffer [index] . Buffer ();
608
609 }
610
611 htblptr->bits [0] = 0;
612
613 int32 count = 0;
614
615 for (int32 i = 1; i <= 16; i++)
616 {
617
618 htblptr->bits [i] = GetJpegChar ();
619
620 count += htblptr->bits [i];
621
622 }
623
624 if (count > 256)
625 {
626 ThrowBadFormat ();
627 }
628
629 for (int32 j = 0; j < count; j++)
630 {
631
632 htblptr->huffval [j] = GetJpegChar ();
633
634 }
635
636 length -= 1 + 16 + count;
637
638 }
639
640 }
641
642 /*****************************************************************************/
643
644 /*
645 *--------------------------------------------------------------
646 *
647 * GetDri --
648 *
649 * Process a DRI marker
650 *
651 * Results:
652 * None
653 *
654 * Side effects:
655 * Exits on error.
656 * Bitstream is parsed.
657 *
658 *--------------------------------------------------------------
659 */
660
GetDri()661 void dng_lossless_decoder::GetDri ()
662 {
663
664 if (Get2bytes () != 4)
665 {
666 ThrowBadFormat ();
667 }
668
669 info.restartInterval = Get2bytes ();
670
671 }
672
673 /*****************************************************************************/
674
675 /*
676 *--------------------------------------------------------------
677 *
678 * GetApp0 --
679 *
680 * Process an APP0 marker.
681 *
682 * Results:
683 * None
684 *
685 * Side effects:
686 * Bitstream is parsed
687 *
688 *--------------------------------------------------------------
689 */
690
GetApp0()691 void dng_lossless_decoder::GetApp0 ()
692 {
693
694 SkipVariable ();
695
696 }
697
698 /*****************************************************************************/
699
700 /*
701 *--------------------------------------------------------------
702 *
703 * GetSof --
704 *
705 * Process a SOFn marker
706 *
707 * Results:
708 * None.
709 *
710 * Side effects:
711 * Bitstream is parsed
712 * Exits on error
713 * info structure is filled in
714 *
715 *--------------------------------------------------------------
716 */
717
GetSof(int32)718 void dng_lossless_decoder::GetSof (int32 /*code*/)
719 {
720
721 int32 length = Get2bytes ();
722
723 info.dataPrecision = GetJpegChar ();
724 info.imageHeight = Get2bytes ();
725 info.imageWidth = Get2bytes ();
726 info.numComponents = GetJpegChar ();
727
728 // We don't support files in which the image height is initially
729 // specified as 0 and is later redefined by DNL. As long as we
730 // have to check that, might as well have a general sanity check.
731
732 if ((info.imageHeight <= 0) ||
733 (info.imageWidth <= 0) ||
734 (info.numComponents <= 0))
735 {
736 ThrowBadFormat ();
737 }
738
739 // Lossless JPEG specifies data precision to be from 2 to 16 bits/sample.
740
741 const int32 MinPrecisionBits = 2;
742 const int32 MaxPrecisionBits = 16;
743
744 if ((info.dataPrecision < MinPrecisionBits) ||
745 (info.dataPrecision > MaxPrecisionBits))
746 {
747 ThrowBadFormat ();
748 }
749
750 // Check length of tag.
751
752 if (length != (info.numComponents * 3 + 8))
753 {
754 ThrowBadFormat ();
755 }
756
757 // Allocate per component info.
758
759 // We can cast info.numComponents to a uint32 because the check above
760 // guarantees that it cannot be negative.
761 compInfoBuffer.Allocate (static_cast<uint32> (info.numComponents),
762 sizeof (JpegComponentInfo));
763
764 info.compInfo = (JpegComponentInfo *) compInfoBuffer.Buffer ();
765
766 // Read in the per compent info.
767
768 for (int32 ci = 0; ci < info.numComponents; ci++)
769 {
770
771 JpegComponentInfo *compptr = &info.compInfo [ci];
772
773 compptr->componentIndex = (int16) ci;
774
775 compptr->componentId = GetJpegChar ();
776
777 int32 c = GetJpegChar ();
778
779 compptr->hSampFactor = (int16) ((c >> 4) & 15);
780 compptr->vSampFactor = (int16) ((c ) & 15);
781
782 (void) GetJpegChar (); /* skip Tq */
783
784 }
785
786 }
787
788 /*****************************************************************************/
789
790 /*
791 *--------------------------------------------------------------
792 *
793 * GetSos --
794 *
795 * Process a SOS marker
796 *
797 * Results:
798 * None.
799 *
800 * Side effects:
801 * Bitstream is parsed.
802 * Exits on error.
803 *
804 *--------------------------------------------------------------
805 */
806
GetSos()807 void dng_lossless_decoder::GetSos ()
808 {
809
810 int32 length = Get2bytes ();
811
812 // Get the number of image components.
813
814 int32 n = GetJpegChar ();
815 info.compsInScan = (int16) n;
816
817 // Check length.
818
819 length -= 3;
820
821 if (length != (n * 2 + 3) || n < 1 || n > 4)
822 {
823 ThrowBadFormat ();
824 }
825
826 // Find index and huffman table for each component.
827
828 for (int32 i = 0; i < n; i++)
829 {
830
831 int32 cc = GetJpegChar ();
832 int32 c = GetJpegChar ();
833
834 int32 ci;
835
836 for (ci = 0; ci < info.numComponents; ci++)
837 {
838
839 if (cc == info.compInfo[ci].componentId)
840 {
841 break;
842 }
843
844 }
845
846 if (ci >= info.numComponents)
847 {
848 ThrowBadFormat ();
849 }
850
851 JpegComponentInfo *compptr = &info.compInfo [ci];
852
853 info.curCompInfo [i] = compptr;
854
855 compptr->dcTblNo = (int16) ((c >> 4) & 15);
856
857 }
858
859 // Get the PSV, skip Se, and get the point transform parameter.
860
861 info.Ss = GetJpegChar ();
862
863 (void) GetJpegChar ();
864
865 info.Pt = GetJpegChar () & 0x0F;
866
867 }
868
869 /*****************************************************************************/
870
871 /*
872 *--------------------------------------------------------------
873 *
874 * GetSoi --
875 *
876 * Process an SOI marker
877 *
878 * Results:
879 * None.
880 *
881 * Side effects:
882 * Bitstream is parsed.
883 * Exits on error.
884 *
885 *--------------------------------------------------------------
886 */
887
GetSoi()888 void dng_lossless_decoder::GetSoi ()
889 {
890
891 // Reset all parameters that are defined to be reset by SOI
892
893 info.restartInterval = 0;
894
895 }
896
897 /*****************************************************************************/
898
899 /*
900 *--------------------------------------------------------------
901 *
902 * NextMarker --
903 *
904 * Find the next JPEG marker Note that the output might not
905 * be a valid marker code but it will never be 0 or FF
906 *
907 * Results:
908 * The marker found.
909 *
910 * Side effects:
911 * Bitstream is parsed.
912 *
913 *--------------------------------------------------------------
914 */
915
NextMarker()916 int32 dng_lossless_decoder::NextMarker ()
917 {
918
919 int32 c;
920
921 do
922 {
923
924 // skip any non-FF bytes
925
926 do
927 {
928 c = GetJpegChar ();
929 }
930 while (c != 0xFF);
931
932 // skip any duplicate FFs, since extra FFs are legal
933
934 do
935 {
936 c = GetJpegChar();
937 }
938 while (c == 0xFF);
939
940 }
941 while (c == 0); // repeat if it was a stuffed FF/00
942
943 return c;
944
945 }
946
947 /*****************************************************************************/
948
949 /*
950 *--------------------------------------------------------------
951 *
952 * ProcessTables --
953 *
954 * Scan and process JPEG markers that can appear in any order
955 * Return when an SOI, EOI, SOFn, or SOS is found
956 *
957 * Results:
958 * The marker found.
959 *
960 * Side effects:
961 * Bitstream is parsed.
962 *
963 *--------------------------------------------------------------
964 */
965
ProcessTables()966 JpegMarker dng_lossless_decoder::ProcessTables ()
967 {
968
969 while (true)
970 {
971
972 int32 c = NextMarker ();
973
974 switch (c)
975 {
976
977 case M_SOF0:
978 case M_SOF1:
979 case M_SOF2:
980 case M_SOF3:
981 case M_SOF5:
982 case M_SOF6:
983 case M_SOF7:
984 case M_JPG:
985 case M_SOF9:
986 case M_SOF10:
987 case M_SOF11:
988 case M_SOF13:
989 case M_SOF14:
990 case M_SOF15:
991 case M_SOI:
992 case M_EOI:
993 case M_SOS:
994 return (JpegMarker) c;
995
996 case M_DHT:
997 GetDht ();
998 break;
999
1000 case M_DQT:
1001 break;
1002
1003 case M_DRI:
1004 GetDri ();
1005 break;
1006
1007 case M_APP0:
1008 GetApp0 ();
1009 break;
1010
1011 case M_RST0: // these are all parameterless
1012 case M_RST1:
1013 case M_RST2:
1014 case M_RST3:
1015 case M_RST4:
1016 case M_RST5:
1017 case M_RST6:
1018 case M_RST7:
1019 case M_TEM:
1020 break;
1021
1022 default: // must be DNL, DHP, EXP, APPn, JPGn, COM, or RESn
1023 SkipVariable ();
1024 break;
1025
1026 }
1027
1028 }
1029
1030 return M_ERROR;
1031 }
1032
1033 /*****************************************************************************/
1034
1035 /*
1036 *--------------------------------------------------------------
1037 *
1038 * ReadFileHeader --
1039 *
1040 * Initialize and read the stream header (everything through
1041 * the SOF marker).
1042 *
1043 * Results:
1044 * None
1045 *
1046 * Side effects:
1047 * Exit on error.
1048 *
1049 *--------------------------------------------------------------
1050 */
1051
ReadFileHeader()1052 void dng_lossless_decoder::ReadFileHeader ()
1053 {
1054
1055 // Demand an SOI marker at the start of the stream --- otherwise it's
1056 // probably not a JPEG stream at all.
1057
1058 int32 c = GetJpegChar ();
1059 int32 c2 = GetJpegChar ();
1060
1061 if ((c != 0xFF) || (c2 != M_SOI))
1062 {
1063 ThrowBadFormat ();
1064 }
1065
1066 // OK, process SOI
1067
1068 GetSoi ();
1069
1070 // Process markers until SOF
1071
1072 c = ProcessTables ();
1073
1074 switch (c)
1075 {
1076
1077 case M_SOF0:
1078 case M_SOF1:
1079 case M_SOF3:
1080 GetSof (c);
1081 break;
1082
1083 default:
1084 ThrowBadFormat ();
1085 break;
1086
1087 }
1088
1089 }
1090
1091 /*****************************************************************************/
1092
1093 /*
1094 *--------------------------------------------------------------
1095 *
1096 * ReadScanHeader --
1097 *
1098 * Read the start of a scan (everything through the SOS marker).
1099 *
1100 * Results:
1101 * 1 if find SOS, 0 if find EOI
1102 *
1103 * Side effects:
1104 * Bitstream is parsed, may exit on errors.
1105 *
1106 *--------------------------------------------------------------
1107 */
1108
ReadScanHeader()1109 int32 dng_lossless_decoder::ReadScanHeader ()
1110 {
1111
1112 // Process markers until SOS or EOI
1113
1114 int32 c = ProcessTables ();
1115
1116 switch (c)
1117 {
1118
1119 case M_SOS:
1120 GetSos ();
1121 return 1;
1122
1123 case M_EOI:
1124 return 0;
1125
1126 default:
1127 ThrowBadFormat ();
1128 break;
1129
1130 }
1131
1132 return 0;
1133
1134 }
1135
1136 /*****************************************************************************/
1137
1138 /*
1139 *--------------------------------------------------------------
1140 *
1141 * DecoderStructInit --
1142 *
1143 * Initalize the rest of the fields in the decompression
1144 * structure.
1145 *
1146 * Results:
1147 * None.
1148 *
1149 * Side effects:
1150 * None.
1151 *
1152 *--------------------------------------------------------------
1153 */
1154
DecoderStructInit()1155 void dng_lossless_decoder::DecoderStructInit ()
1156 {
1157
1158 int32 ci;
1159
1160 #if qSupportCanon_sRAW
1161
1162 bool canon_sRAW = (info.numComponents == 3) &&
1163 (info.compInfo [0].hSampFactor == 2) &&
1164 (info.compInfo [1].hSampFactor == 1) &&
1165 (info.compInfo [2].hSampFactor == 1) &&
1166 (info.compInfo [0].vSampFactor == 1) &&
1167 (info.compInfo [1].vSampFactor == 1) &&
1168 (info.compInfo [2].vSampFactor == 1) &&
1169 (info.dataPrecision == 15) &&
1170 (info.Ss == 1) &&
1171 ((info.imageWidth & 1) == 0);
1172
1173 bool canon_sRAW2 = (info.numComponents == 3) &&
1174 (info.compInfo [0].hSampFactor == 2) &&
1175 (info.compInfo [1].hSampFactor == 1) &&
1176 (info.compInfo [2].hSampFactor == 1) &&
1177 (info.compInfo [0].vSampFactor == 2) &&
1178 (info.compInfo [1].vSampFactor == 1) &&
1179 (info.compInfo [2].vSampFactor == 1) &&
1180 (info.dataPrecision == 15) &&
1181 (info.Ss == 1) &&
1182 ((info.imageWidth & 1) == 0) &&
1183 ((info.imageHeight & 1) == 0);
1184
1185 if (!canon_sRAW && !canon_sRAW2)
1186
1187 #endif
1188
1189 {
1190
1191 // Check sampling factor validity.
1192
1193 for (ci = 0; ci < info.numComponents; ci++)
1194 {
1195
1196 JpegComponentInfo *compPtr = &info.compInfo [ci];
1197
1198 if (compPtr->hSampFactor != 1 ||
1199 compPtr->vSampFactor != 1)
1200 {
1201 ThrowBadFormat ();
1202 }
1203
1204 }
1205
1206 }
1207
1208 // Prepare array describing MCU composition.
1209
1210 if (info.compsInScan < 0 || info.compsInScan > 4)
1211 {
1212 ThrowBadFormat ();
1213 }
1214
1215 for (ci = 0; ci < info.compsInScan; ci++)
1216 {
1217 info.MCUmembership [ci] = (int16) ci;
1218 }
1219
1220 // Initialize mucROW1 and mcuROW2 which buffer two rows of
1221 // pixels for predictor calculation.
1222
1223 // This multiplication cannot overflow because info.compsInScan is
1224 // guaranteed to be between 0 and 4 inclusive (see checks above).
1225 int32 mcuSize = info.compsInScan * (uint32) sizeof (ComponentType);
1226
1227 mcuBuffer1.Allocate (info.imageWidth, sizeof (MCU));
1228 mcuBuffer2.Allocate (info.imageWidth, sizeof (MCU));
1229
1230 mcuROW1 = (MCU *) mcuBuffer1.Buffer ();
1231 mcuROW2 = (MCU *) mcuBuffer2.Buffer ();
1232
1233 mcuBuffer3.Allocate (info.imageWidth, mcuSize);
1234 mcuBuffer4.Allocate (info.imageWidth, mcuSize);
1235
1236 mcuROW1 [0] = (ComponentType *) mcuBuffer3.Buffer ();
1237 mcuROW2 [0] = (ComponentType *) mcuBuffer4.Buffer ();
1238
1239 for (int32 j = 1; j < info.imageWidth; j++)
1240 {
1241
1242 mcuROW1 [j] = mcuROW1 [j - 1] + info.compsInScan;
1243 mcuROW2 [j] = mcuROW2 [j - 1] + info.compsInScan;
1244
1245 }
1246
1247 }
1248
1249 /*****************************************************************************/
1250
1251 /*
1252 *--------------------------------------------------------------
1253 *
1254 * HuffDecoderInit --
1255 *
1256 * Initialize for a Huffman-compressed scan.
1257 * This is invoked after reading the SOS marker.
1258 *
1259 * Results:
1260 * None
1261 *
1262 * Side effects:
1263 * None.
1264 *
1265 *--------------------------------------------------------------
1266 */
1267
HuffDecoderInit()1268 void dng_lossless_decoder::HuffDecoderInit ()
1269 {
1270
1271 // Initialize bit parser state
1272
1273 getBuffer = 0;
1274 bitsLeft = 0;
1275
1276 // Prepare Huffman tables.
1277
1278 for (int16 ci = 0; ci < info.compsInScan; ci++)
1279 {
1280
1281 JpegComponentInfo *compptr = info.curCompInfo [ci];
1282
1283 // Make sure requested tables are present
1284
1285 if (compptr->dcTblNo < 0 || compptr->dcTblNo > 3)
1286 {
1287 ThrowBadFormat ();
1288 }
1289
1290 if (info.dcHuffTblPtrs [compptr->dcTblNo] == NULL)
1291 {
1292 ThrowBadFormat ();
1293 }
1294
1295 // Compute derived values for Huffman tables.
1296 // We may do this more than once for same table, but it's not a
1297 // big deal
1298
1299 FixHuffTbl (info.dcHuffTblPtrs [compptr->dcTblNo]);
1300
1301 }
1302
1303 // Initialize restart stuff
1304
1305 info.restartInRows = info.restartInterval / info.imageWidth;
1306 info.restartRowsToGo = info.restartInRows;
1307 info.nextRestartNum = 0;
1308
1309 }
1310
1311 /*****************************************************************************/
1312
1313 /*
1314 *--------------------------------------------------------------
1315 *
1316 * ProcessRestart --
1317 *
1318 * Check for a restart marker & resynchronize decoder.
1319 *
1320 * Results:
1321 * None.
1322 *
1323 * Side effects:
1324 * BitStream is parsed, bit buffer is reset, etc.
1325 *
1326 *--------------------------------------------------------------
1327 */
1328
ProcessRestart()1329 void dng_lossless_decoder::ProcessRestart ()
1330 {
1331
1332 // Throw away and unused odd bits in the bit buffer.
1333
1334 fStream->SetReadPosition (fStream->Position () - bitsLeft / 8);
1335
1336 bitsLeft = 0;
1337 getBuffer = 0;
1338
1339 // Scan for next JPEG marker
1340
1341 int32 c;
1342
1343 do
1344 {
1345
1346 // skip any non-FF bytes
1347
1348 do
1349 {
1350 c = GetJpegChar ();
1351 }
1352 while (c != 0xFF);
1353
1354 // skip any duplicate FFs
1355
1356 do
1357 {
1358 c = GetJpegChar ();
1359 }
1360 while (c == 0xFF);
1361
1362 }
1363 while (c == 0); // repeat if it was a stuffed FF/00
1364
1365 // Verify correct restart code.
1366
1367 if (c != (M_RST0 + info.nextRestartNum))
1368 {
1369 ThrowBadFormat ();
1370 }
1371
1372 // Update restart state.
1373
1374 info.restartRowsToGo = info.restartInRows;
1375 info.nextRestartNum = (info.nextRestartNum + 1) & 7;
1376
1377 }
1378
1379 /*****************************************************************************/
1380
1381 /*
1382 *--------------------------------------------------------------
1383 *
1384 * QuickPredict --
1385 *
1386 * Calculate the predictor for sample curRowBuf[col][curComp].
1387 * It does not handle the special cases at image edges, such
1388 * as first row and first column of a scan. We put the special
1389 * case checkings outside so that the computations in main
1390 * loop can be simpler. This has enhenced the performance
1391 * significantly.
1392 *
1393 * Results:
1394 * predictor is passed out.
1395 *
1396 * Side effects:
1397 * None.
1398 *
1399 *--------------------------------------------------------------
1400 */
1401
QuickPredict(int32 col,int32 curComp,MCU * curRowBuf,MCU * prevRowBuf)1402 inline int32 dng_lossless_decoder::QuickPredict (int32 col,
1403 int32 curComp,
1404 MCU *curRowBuf,
1405 MCU *prevRowBuf)
1406 {
1407
1408 int32 diag = prevRowBuf [col - 1] [curComp];
1409 int32 upper = prevRowBuf [col ] [curComp];
1410 int32 left = curRowBuf [col - 1] [curComp];
1411
1412 switch (info.Ss)
1413 {
1414
1415 case 0:
1416 return 0;
1417
1418 case 1:
1419 return left;
1420
1421 case 2:
1422 return upper;
1423
1424 case 3:
1425 return diag;
1426
1427 case 4:
1428 return left + upper - diag;
1429
1430 case 5:
1431 return left + ((upper - diag) >> 1);
1432
1433 case 6:
1434 return upper + ((left - diag) >> 1);
1435
1436 case 7:
1437 return (left + upper) >> 1;
1438
1439 default:
1440 {
1441 ThrowBadFormat ();
1442 return 0;
1443 }
1444
1445 }
1446
1447 }
1448
1449 /*****************************************************************************/
1450
1451 /*
1452 *--------------------------------------------------------------
1453 *
1454 * FillBitBuffer --
1455 *
1456 * Load up the bit buffer with at least nbits
1457 * Process any stuffed bytes at this time.
1458 *
1459 * Results:
1460 * None
1461 *
1462 * Side effects:
1463 * The bitwise global variables are updated.
1464 *
1465 *--------------------------------------------------------------
1466 */
1467
FillBitBuffer(int32 nbits)1468 inline void dng_lossless_decoder::FillBitBuffer (int32 nbits)
1469 {
1470
1471 const int32 kMinGetBits = sizeof (uint32) * 8 - 7;
1472
1473 #if qSupportHasselblad_3FR
1474
1475 if (fHasselblad3FR)
1476 {
1477
1478 while (bitsLeft < kMinGetBits)
1479 {
1480
1481 int32 c0 = GetJpegChar ();
1482 int32 c1 = GetJpegChar ();
1483 int32 c2 = GetJpegChar ();
1484 int32 c3 = GetJpegChar ();
1485
1486 getBuffer = (getBuffer << 8) | c3;
1487 getBuffer = (getBuffer << 8) | c2;
1488 getBuffer = (getBuffer << 8) | c1;
1489 getBuffer = (getBuffer << 8) | c0;
1490
1491 bitsLeft += 32;
1492
1493 }
1494
1495 return;
1496
1497 }
1498
1499 #endif
1500
1501 while (bitsLeft < kMinGetBits)
1502 {
1503
1504 int32 c = GetJpegChar ();
1505
1506 // If it's 0xFF, check and discard stuffed zero byte
1507
1508 if (c == 0xFF)
1509 {
1510
1511 int32 c2 = GetJpegChar ();
1512
1513 if (c2 != 0)
1514 {
1515
1516 // Oops, it's actually a marker indicating end of
1517 // compressed data. Better put it back for use later.
1518
1519 UnGetJpegChar ();
1520 UnGetJpegChar ();
1521
1522 // There should be enough bits still left in the data
1523 // segment; if so, just break out of the while loop.
1524
1525 if (bitsLeft >= nbits)
1526 break;
1527
1528 // Uh-oh. Corrupted data: stuff zeroes into the data
1529 // stream, since this sometimes occurs when we are on the
1530 // last show_bits8 during decoding of the Huffman
1531 // segment.
1532
1533 c = 0;
1534
1535 }
1536
1537 }
1538
1539 getBuffer = (getBuffer << 8) | c;
1540
1541 bitsLeft += 8;
1542
1543 }
1544
1545 }
1546
1547 /*****************************************************************************/
1548
show_bits8()1549 inline int32 dng_lossless_decoder::show_bits8 ()
1550 {
1551
1552 if (bitsLeft < 8)
1553 FillBitBuffer (8);
1554
1555 return (int32) ((getBuffer >> (bitsLeft - 8)) & 0xff);
1556
1557 }
1558
1559 /*****************************************************************************/
1560
flush_bits(int32 nbits)1561 inline void dng_lossless_decoder::flush_bits (int32 nbits)
1562 {
1563
1564 bitsLeft -= nbits;
1565
1566 }
1567
1568 /*****************************************************************************/
1569
get_bits(int32 nbits)1570 inline int32 dng_lossless_decoder::get_bits (int32 nbits)
1571 {
1572
1573 if (nbits > 16)
1574 {
1575 ThrowBadFormat ();
1576 }
1577
1578 if (bitsLeft < nbits)
1579 FillBitBuffer (nbits);
1580
1581 return (int32) ((getBuffer >> (bitsLeft -= nbits)) & (0x0FFFF >> (16 - nbits)));
1582
1583 }
1584
1585 /*****************************************************************************/
1586
get_bit()1587 inline int32 dng_lossless_decoder::get_bit ()
1588 {
1589
1590 if (!bitsLeft)
1591 FillBitBuffer (1);
1592
1593 return (int32) ((getBuffer >> (--bitsLeft)) & 1);
1594
1595 }
1596
1597 /*****************************************************************************/
1598
1599 /*
1600 *--------------------------------------------------------------
1601 *
1602 * HuffDecode --
1603 *
1604 * Taken from Figure F.16: extract next coded symbol from
1605 * input stream. This should becode a macro.
1606 *
1607 * Results:
1608 * Next coded symbol
1609 *
1610 * Side effects:
1611 * Bitstream is parsed.
1612 *
1613 *--------------------------------------------------------------
1614 */
1615
HuffDecode(HuffmanTable * htbl)1616 inline int32 dng_lossless_decoder::HuffDecode (HuffmanTable *htbl)
1617 {
1618
1619 // If the huffman code is less than 8 bits, we can use the fast
1620 // table lookup to get its value. It's more than 8 bits about
1621 // 3-4% of the time.
1622
1623 int32 code = show_bits8 ();
1624
1625 if (htbl->numbits [code])
1626 {
1627
1628 flush_bits (htbl->numbits [code]);
1629
1630 return htbl->value [code];
1631
1632 }
1633
1634 else
1635 {
1636
1637 flush_bits (8);
1638
1639 int32 l = 8;
1640
1641 while (code > htbl->maxcode [l])
1642 {
1643 code = (code << 1) | get_bit ();
1644 l++;
1645 }
1646
1647 // With garbage input we may reach the sentinel value l = 17.
1648
1649 if (l > 16)
1650 {
1651 return 0; // fake a zero as the safest result
1652 }
1653 else
1654 {
1655 return htbl->huffval [htbl->valptr [l] +
1656 ((int32) (code - htbl->mincode [l]))];
1657 }
1658
1659 }
1660
1661 }
1662
1663 /*****************************************************************************/
1664
1665 /*
1666 *--------------------------------------------------------------
1667 *
1668 * HuffExtend --
1669 *
1670 * Code and table for Figure F.12: extend sign bit
1671 *
1672 * Results:
1673 * The extended value.
1674 *
1675 * Side effects:
1676 * None.
1677 *
1678 *--------------------------------------------------------------
1679 */
1680
HuffExtend(int32 & x,int32 s)1681 inline void dng_lossless_decoder::HuffExtend (int32 &x, int32 s)
1682 {
1683
1684 if (x < (0x08000 >> (16 - s)))
1685 {
1686 x += -(1 << s) + 1;
1687 }
1688
1689 }
1690
1691 /*****************************************************************************/
1692
1693 // Called from DecodeImage () to write one row.
1694
PmPutRow(MCU * buf,int32 numComp,int32 numCol,int32)1695 void dng_lossless_decoder::PmPutRow (MCU *buf,
1696 int32 numComp,
1697 int32 numCol,
1698 int32 /* row */)
1699 {
1700
1701 uint16 *sPtr = &buf [0] [0];
1702
1703 uint32 pixels = numCol * numComp;
1704
1705 fSpooler->Spool (sPtr, pixels * (uint32) sizeof (uint16));
1706
1707 }
1708
1709 /*****************************************************************************/
1710
1711 /*
1712 *--------------------------------------------------------------
1713 *
1714 * DecodeFirstRow --
1715 *
1716 * Decode the first raster line of samples at the start of
1717 * the scan and at the beginning of each restart interval.
1718 * This includes modifying the component value so the real
1719 * value, not the difference is returned.
1720 *
1721 * Results:
1722 * None.
1723 *
1724 * Side effects:
1725 * Bitstream is parsed.
1726 *
1727 *--------------------------------------------------------------
1728 */
1729
DecodeFirstRow(MCU * curRowBuf)1730 void dng_lossless_decoder::DecodeFirstRow (MCU *curRowBuf)
1731 {
1732
1733 int32 compsInScan = info.compsInScan;
1734
1735 // Process the first column in the row.
1736
1737 for (int32 curComp = 0; curComp < compsInScan; curComp++)
1738 {
1739
1740 int32 ci = info.MCUmembership [curComp];
1741
1742 JpegComponentInfo *compptr = info.curCompInfo [ci];
1743
1744 HuffmanTable *dctbl = info.dcHuffTblPtrs [compptr->dcTblNo];
1745
1746 // Section F.2.2.1: decode the difference
1747
1748 int32 d = 0;
1749
1750 int32 s = HuffDecode (dctbl);
1751
1752 if (s)
1753 {
1754
1755 if (s == 16 && !fBug16)
1756 {
1757 d = -32768;
1758 }
1759
1760 else
1761 {
1762 d = get_bits (s);
1763 HuffExtend (d, s);
1764 }
1765
1766 }
1767
1768 // Add the predictor to the difference.
1769
1770 int32 Pr = info.dataPrecision;
1771 int32 Pt = info.Pt;
1772
1773 curRowBuf [0] [curComp] = (ComponentType) (d + (1 << (Pr-Pt-1)));
1774
1775 }
1776
1777 // Process the rest of the row.
1778
1779 int32 numCOL = info.imageWidth;
1780
1781 for (int32 col = 1; col < numCOL; col++)
1782 {
1783
1784 for (int32 curComp = 0; curComp < compsInScan; curComp++)
1785 {
1786
1787 int32 ci = info.MCUmembership [curComp];
1788
1789 JpegComponentInfo *compptr = info.curCompInfo [ci];
1790
1791 HuffmanTable *dctbl = info.dcHuffTblPtrs [compptr->dcTblNo];
1792
1793 // Section F.2.2.1: decode the difference
1794
1795 int32 d = 0;
1796
1797 int32 s = HuffDecode (dctbl);
1798
1799 if (s)
1800 {
1801
1802 if (s == 16 && !fBug16)
1803 {
1804 d = -32768;
1805 }
1806
1807 else
1808 {
1809 d = get_bits (s);
1810 HuffExtend (d, s);
1811 }
1812
1813 }
1814
1815 // Add the predictor to the difference.
1816
1817 curRowBuf [col] [curComp] = (ComponentType) (d + curRowBuf [col-1] [curComp]);
1818
1819 }
1820
1821 }
1822
1823 // Update the restart counter
1824
1825 if (info.restartInRows)
1826 {
1827 info.restartRowsToGo--;
1828 }
1829
1830 }
1831
1832 /*****************************************************************************/
1833
1834 /*
1835 *--------------------------------------------------------------
1836 *
1837 * DecodeImage --
1838 *
1839 * Decode the input stream. This includes modifying
1840 * the component value so the real value, not the
1841 * difference is returned.
1842 *
1843 * Results:
1844 * None.
1845 *
1846 * Side effects:
1847 * Bitstream is parsed.
1848 *
1849 *--------------------------------------------------------------
1850 */
1851
DecodeImage()1852 void dng_lossless_decoder::DecodeImage ()
1853 {
1854
1855 #define swap(type,a,b) {type c; c=(a); (a)=(b); (b)=c;}
1856
1857 int32 numCOL = info.imageWidth;
1858 int32 numROW = info.imageHeight;
1859 int32 compsInScan = info.compsInScan;
1860
1861 // Precompute the decoding table for each table.
1862
1863 HuffmanTable *ht [4];
1864
1865 for (int32 curComp = 0; curComp < compsInScan; curComp++)
1866 {
1867
1868 int32 ci = info.MCUmembership [curComp];
1869
1870 JpegComponentInfo *compptr = info.curCompInfo [ci];
1871
1872 ht [curComp] = info.dcHuffTblPtrs [compptr->dcTblNo];
1873
1874 }
1875
1876 MCU *prevRowBuf = mcuROW1;
1877 MCU *curRowBuf = mcuROW2;
1878
1879 #if qSupportCanon_sRAW
1880
1881 // Canon sRAW support
1882
1883 if (info.compInfo [0].hSampFactor == 2 &&
1884 info.compInfo [0].vSampFactor == 1)
1885 {
1886
1887 for (int32 row = 0; row < numROW; row++)
1888 {
1889
1890 // Initialize predictors.
1891
1892 int32 p0;
1893 int32 p1;
1894 int32 p2;
1895
1896 if (row == 0)
1897 {
1898 p0 = 1 << 14;
1899 p1 = 1 << 14;
1900 p2 = 1 << 14;
1901 }
1902
1903 else
1904 {
1905 p0 = prevRowBuf [0] [0];
1906 p1 = prevRowBuf [0] [1];
1907 p2 = prevRowBuf [0] [2];
1908 }
1909
1910 for (int32 col = 0; col < numCOL; col += 2)
1911 {
1912
1913 // Read first luminance component.
1914
1915 {
1916
1917 int32 d = 0;
1918
1919 int32 s = HuffDecode (ht [0]);
1920
1921 if (s)
1922 {
1923
1924 if (s == 16)
1925 {
1926 d = -32768;
1927 }
1928
1929 else
1930 {
1931 d = get_bits (s);
1932 HuffExtend (d, s);
1933 }
1934
1935 }
1936
1937 p0 += d;
1938
1939 curRowBuf [col] [0] = (ComponentType) p0;
1940
1941 }
1942
1943 // Read second luminance component.
1944
1945 {
1946
1947 int32 d = 0;
1948
1949 int32 s = HuffDecode (ht [0]);
1950
1951 if (s)
1952 {
1953
1954 if (s == 16)
1955 {
1956 d = -32768;
1957 }
1958
1959 else
1960 {
1961 d = get_bits (s);
1962 HuffExtend (d, s);
1963 }
1964
1965 }
1966
1967 p0 += d;
1968
1969 curRowBuf [col + 1] [0] = (ComponentType) p0;
1970
1971 }
1972
1973 // Read first chroma component.
1974
1975 {
1976
1977 int32 d = 0;
1978
1979 int32 s = HuffDecode (ht [1]);
1980
1981 if (s)
1982 {
1983
1984 if (s == 16)
1985 {
1986 d = -32768;
1987 }
1988
1989 else
1990 {
1991 d = get_bits (s);
1992 HuffExtend (d, s);
1993 }
1994
1995 }
1996
1997 p1 += d;
1998
1999 curRowBuf [col ] [1] = (ComponentType) p1;
2000 curRowBuf [col + 1] [1] = (ComponentType) p1;
2001
2002 }
2003
2004 // Read second chroma component.
2005
2006 {
2007
2008 int32 d = 0;
2009
2010 int32 s = HuffDecode (ht [2]);
2011
2012 if (s)
2013 {
2014
2015 if (s == 16)
2016 {
2017 d = -32768;
2018 }
2019
2020 else
2021 {
2022 d = get_bits (s);
2023 HuffExtend (d, s);
2024 }
2025
2026 }
2027
2028 p2 += d;
2029
2030 curRowBuf [col ] [2] = (ComponentType) p2;
2031 curRowBuf [col + 1] [2] = (ComponentType) p2;
2032
2033 }
2034
2035 }
2036
2037 PmPutRow (curRowBuf, compsInScan, numCOL, row);
2038
2039 swap (MCU *, prevRowBuf, curRowBuf);
2040
2041 }
2042
2043 return;
2044
2045 }
2046
2047 if (info.compInfo [0].hSampFactor == 2 &&
2048 info.compInfo [0].vSampFactor == 2)
2049 {
2050
2051 for (int32 row = 0; row < numROW; row += 2)
2052 {
2053
2054 // Initialize predictors.
2055
2056 int32 p0;
2057 int32 p1;
2058 int32 p2;
2059
2060 if (row == 0)
2061 {
2062 p0 = 1 << 14;
2063 p1 = 1 << 14;
2064 p2 = 1 << 14;
2065 }
2066
2067 else
2068 {
2069 p0 = prevRowBuf [0] [0];
2070 p1 = prevRowBuf [0] [1];
2071 p2 = prevRowBuf [0] [2];
2072 }
2073
2074 for (int32 col = 0; col < numCOL; col += 2)
2075 {
2076
2077 // Read first luminance component.
2078
2079 {
2080
2081 int32 d = 0;
2082
2083 int32 s = HuffDecode (ht [0]);
2084
2085 if (s)
2086 {
2087
2088 if (s == 16)
2089 {
2090 d = -32768;
2091 }
2092
2093 else
2094 {
2095 d = get_bits (s);
2096 HuffExtend (d, s);
2097 }
2098
2099 }
2100
2101 p0 += d;
2102
2103 prevRowBuf [col] [0] = (ComponentType) p0;
2104
2105 }
2106
2107 // Read second luminance component.
2108
2109 {
2110
2111 int32 d = 0;
2112
2113 int32 s = HuffDecode (ht [0]);
2114
2115 if (s)
2116 {
2117
2118 if (s == 16)
2119 {
2120 d = -32768;
2121 }
2122
2123 else
2124 {
2125 d = get_bits (s);
2126 HuffExtend (d, s);
2127 }
2128
2129 }
2130
2131 p0 += d;
2132
2133 prevRowBuf [col + 1] [0] = (ComponentType) p0;
2134
2135 }
2136
2137 // Read third luminance component.
2138
2139 {
2140
2141 int32 d = 0;
2142
2143 int32 s = HuffDecode (ht [0]);
2144
2145 if (s)
2146 {
2147
2148 if (s == 16)
2149 {
2150 d = -32768;
2151 }
2152
2153 else
2154 {
2155 d = get_bits (s);
2156 HuffExtend (d, s);
2157 }
2158
2159 }
2160
2161 p0 += d;
2162
2163 curRowBuf [col] [0] = (ComponentType) p0;
2164
2165 }
2166
2167 // Read fourth luminance component.
2168
2169 {
2170
2171 int32 d = 0;
2172
2173 int32 s = HuffDecode (ht [0]);
2174
2175 if (s)
2176 {
2177
2178 if (s == 16)
2179 {
2180 d = -32768;
2181 }
2182
2183 else
2184 {
2185 d = get_bits (s);
2186 HuffExtend (d, s);
2187 }
2188
2189 }
2190
2191 p0 += d;
2192
2193 curRowBuf [col + 1] [0] = (ComponentType) p0;
2194
2195 }
2196
2197 // Read first chroma component.
2198
2199 {
2200
2201 int32 d = 0;
2202
2203 int32 s = HuffDecode (ht [1]);
2204
2205 if (s)
2206 {
2207
2208 if (s == 16)
2209 {
2210 d = -32768;
2211 }
2212
2213 else
2214 {
2215 d = get_bits (s);
2216 HuffExtend (d, s);
2217 }
2218
2219 }
2220
2221 p1 += d;
2222
2223 prevRowBuf [col ] [1] = (ComponentType) p1;
2224 prevRowBuf [col + 1] [1] = (ComponentType) p1;
2225
2226 curRowBuf [col ] [1] = (ComponentType) p1;
2227 curRowBuf [col + 1] [1] = (ComponentType) p1;
2228
2229 }
2230
2231 // Read second chroma component.
2232
2233 {
2234
2235 int32 d = 0;
2236
2237 int32 s = HuffDecode (ht [2]);
2238
2239 if (s)
2240 {
2241
2242 if (s == 16)
2243 {
2244 d = -32768;
2245 }
2246
2247 else
2248 {
2249 d = get_bits (s);
2250 HuffExtend (d, s);
2251 }
2252
2253 }
2254
2255 p2 += d;
2256
2257 prevRowBuf [col ] [2] = (ComponentType) p2;
2258 prevRowBuf [col + 1] [2] = (ComponentType) p2;
2259
2260 curRowBuf [col ] [2] = (ComponentType) p2;
2261 curRowBuf [col + 1] [2] = (ComponentType) p2;
2262
2263 }
2264
2265 }
2266
2267 PmPutRow (prevRowBuf, compsInScan, numCOL, row);
2268 PmPutRow (curRowBuf, compsInScan, numCOL, row);
2269
2270 }
2271
2272 return;
2273
2274 }
2275
2276 #endif
2277
2278 #if qSupportHasselblad_3FR
2279
2280 if (info.Ss == 8)
2281 {
2282
2283 fHasselblad3FR = true;
2284
2285 for (int32 row = 0; row < numROW; row++)
2286 {
2287
2288 int32 p0 = 32768;
2289 int32 p1 = 32768;
2290
2291 for (int32 col = 0; col < numCOL; col += 2)
2292 {
2293
2294 int32 s0 = HuffDecode (ht [0]);
2295 int32 s1 = HuffDecode (ht [0]);
2296
2297 if (s0)
2298 {
2299 int32 d = get_bits (s0);
2300 if (s0 == 16)
2301 {
2302 d = -32768;
2303 }
2304 else
2305 {
2306 HuffExtend (d, s0);
2307 }
2308 p0 += d;
2309 }
2310
2311 if (s1)
2312 {
2313 int32 d = get_bits (s1);
2314 if (s1 == 16)
2315 {
2316 d = -32768;
2317 }
2318 else
2319 {
2320 HuffExtend (d, s1);
2321 }
2322 p1 += d;
2323 }
2324
2325 curRowBuf [col ] [0] = (ComponentType) p0;
2326 curRowBuf [col + 1] [0] = (ComponentType) p1;
2327
2328 }
2329
2330 PmPutRow (curRowBuf, compsInScan, numCOL, row);
2331
2332 }
2333
2334 return;
2335
2336 }
2337
2338 #endif
2339
2340 // Decode the first row of image. Output the row and
2341 // turn this row into a previous row for later predictor
2342 // calculation.
2343
2344 DecodeFirstRow (mcuROW1);
2345
2346 PmPutRow (mcuROW1, compsInScan, numCOL, 0);
2347
2348 // Process each row.
2349
2350 for (int32 row = 1; row < numROW; row++)
2351 {
2352
2353 // Account for restart interval, process restart marker if needed.
2354
2355 if (info.restartInRows)
2356 {
2357
2358 if (info.restartRowsToGo == 0)
2359 {
2360
2361 ProcessRestart ();
2362
2363 // Reset predictors at restart.
2364
2365 DecodeFirstRow (curRowBuf);
2366
2367 PmPutRow (curRowBuf, compsInScan, numCOL, row);
2368
2369 swap (MCU *, prevRowBuf, curRowBuf);
2370
2371 continue;
2372
2373 }
2374
2375 info.restartRowsToGo--;
2376
2377 }
2378
2379 // The upper neighbors are predictors for the first column.
2380
2381 for (int32 curComp = 0; curComp < compsInScan; curComp++)
2382 {
2383
2384 // Section F.2.2.1: decode the difference
2385
2386 int32 d = 0;
2387
2388 int32 s = HuffDecode (ht [curComp]);
2389
2390 if (s)
2391 {
2392
2393 if (s == 16 && !fBug16)
2394 {
2395 d = -32768;
2396 }
2397
2398 else
2399 {
2400 d = get_bits (s);
2401 HuffExtend (d, s);
2402 }
2403
2404 }
2405
2406 // First column of row above is predictor for first column.
2407
2408 curRowBuf [0] [curComp] = (ComponentType) (d + prevRowBuf [0] [curComp]);
2409
2410 }
2411
2412 // For the rest of the column on this row, predictor
2413 // calculations are based on PSV.
2414
2415 if (compsInScan == 2 && info.Ss == 1)
2416 {
2417
2418 // This is the combination used by both the Canon and Kodak raw formats.
2419 // Unrolling the general case logic results in a significant speed increase.
2420
2421 uint16 *dPtr = &curRowBuf [1] [0];
2422
2423 int32 prev0 = dPtr [-2];
2424 int32 prev1 = dPtr [-1];
2425
2426 for (int32 col = 1; col < numCOL; col++)
2427 {
2428
2429 int32 s = HuffDecode (ht [0]);
2430
2431 if (s)
2432 {
2433
2434 int32 d;
2435
2436 if (s == 16 && !fBug16)
2437 {
2438 d = -32768;
2439 }
2440
2441 else
2442 {
2443 d = get_bits (s);
2444 HuffExtend (d, s);
2445 }
2446
2447 prev0 += d;
2448
2449 }
2450
2451 s = HuffDecode (ht [1]);
2452
2453 if (s)
2454 {
2455
2456 int32 d;
2457
2458 if (s == 16 && !fBug16)
2459 {
2460 d = -32768;
2461 }
2462
2463 else
2464 {
2465 d = get_bits (s);
2466 HuffExtend (d, s);
2467 }
2468
2469 prev1 += d;
2470
2471 }
2472
2473 dPtr [0] = (uint16) prev0;
2474 dPtr [1] = (uint16) prev1;
2475
2476 dPtr += 2;
2477
2478 }
2479
2480 }
2481
2482 else
2483 {
2484
2485 for (int32 col = 1; col < numCOL; col++)
2486 {
2487
2488 for (int32 curComp = 0; curComp < compsInScan; curComp++)
2489 {
2490
2491 // Section F.2.2.1: decode the difference
2492
2493 int32 d = 0;
2494
2495 int32 s = HuffDecode (ht [curComp]);
2496
2497 if (s)
2498 {
2499
2500 if (s == 16 && !fBug16)
2501 {
2502 d = -32768;
2503 }
2504
2505 else
2506 {
2507 d = get_bits (s);
2508 HuffExtend (d, s);
2509 }
2510
2511 }
2512
2513 // Predict the pixel value.
2514
2515 int32 predictor = QuickPredict (col,
2516 curComp,
2517 curRowBuf,
2518 prevRowBuf);
2519
2520 // Save the difference.
2521
2522 curRowBuf [col] [curComp] = (ComponentType) (d + predictor);
2523
2524 }
2525
2526 }
2527
2528 }
2529
2530 PmPutRow (curRowBuf, compsInScan, numCOL, row);
2531
2532 swap (MCU *, prevRowBuf, curRowBuf);
2533
2534 }
2535
2536 #undef swap
2537
2538 }
2539
2540 /*****************************************************************************/
2541
StartRead(uint32 & imageWidth,uint32 & imageHeight,uint32 & imageChannels)2542 void dng_lossless_decoder::StartRead (uint32 &imageWidth,
2543 uint32 &imageHeight,
2544 uint32 &imageChannels)
2545 {
2546
2547 ReadFileHeader ();
2548 ReadScanHeader ();
2549 DecoderStructInit ();
2550 HuffDecoderInit ();
2551
2552 imageWidth = info.imageWidth;
2553 imageHeight = info.imageHeight;
2554 imageChannels = info.compsInScan;
2555
2556 }
2557
2558 /*****************************************************************************/
2559
FinishRead()2560 void dng_lossless_decoder::FinishRead ()
2561 {
2562
2563 DecodeImage ();
2564
2565 }
2566
2567 /*****************************************************************************/
2568
DecodeLosslessJPEG(dng_stream & stream,dng_spooler & spooler,uint32 minDecodedSize,uint32 maxDecodedSize,bool bug16)2569 void DecodeLosslessJPEG (dng_stream &stream,
2570 dng_spooler &spooler,
2571 uint32 minDecodedSize,
2572 uint32 maxDecodedSize,
2573 bool bug16)
2574 {
2575
2576 dng_lossless_decoder decoder (&stream,
2577 &spooler,
2578 bug16);
2579
2580 uint32 imageWidth;
2581 uint32 imageHeight;
2582 uint32 imageChannels;
2583
2584 decoder.StartRead (imageWidth,
2585 imageHeight,
2586 imageChannels);
2587
2588 uint32 decodedSize = imageWidth *
2589 imageHeight *
2590 imageChannels *
2591 (uint32) sizeof (uint16);
2592
2593 if (decodedSize < minDecodedSize ||
2594 decodedSize > maxDecodedSize)
2595 {
2596 ThrowBadFormat ();
2597 }
2598
2599 decoder.FinishRead ();
2600
2601 }
2602
2603 /*****************************************************************************/
2604
2605 class dng_lossless_encoder
2606 {
2607
2608 private:
2609
2610 const uint16 *fSrcData;
2611
2612 uint32 fSrcRows;
2613 uint32 fSrcCols;
2614 uint32 fSrcChannels;
2615 uint32 fSrcBitDepth;
2616
2617 int32 fSrcRowStep;
2618 int32 fSrcColStep;
2619
2620 dng_stream &fStream;
2621
2622 HuffmanTable huffTable [4];
2623
2624 uint32 freqCount [4] [257];
2625
2626 // Current bit-accumulation buffer
2627
2628 int32 huffPutBuffer;
2629 int32 huffPutBits;
2630
2631 // Lookup table for number of bits in an 8 bit value.
2632
2633 int numBitsTable [256];
2634
2635 public:
2636
2637 dng_lossless_encoder (const uint16 *srcData,
2638 uint32 srcRows,
2639 uint32 srcCols,
2640 uint32 srcChannels,
2641 uint32 srcBitDepth,
2642 int32 srcRowStep,
2643 int32 srcColStep,
2644 dng_stream &stream);
2645
2646 void Encode ();
2647
2648 private:
2649
2650 void EmitByte (uint8 value);
2651
2652 void EmitBits (int code, int size);
2653
2654 void FlushBits ();
2655
2656 void CountOneDiff (int diff, uint32 *countTable);
2657
2658 void EncodeOneDiff (int diff, HuffmanTable *dctbl);
2659
2660 void FreqCountSet ();
2661
2662 void HuffEncode ();
2663
2664 void GenHuffCoding (HuffmanTable *htbl, uint32 *freq);
2665
2666 void HuffOptimize ();
2667
2668 void EmitMarker (JpegMarker mark);
2669
2670 void Emit2bytes (int value);
2671
2672 void EmitDht (int index);
2673
2674 void EmitSof (JpegMarker code);
2675
2676 void EmitSos ();
2677
2678 void WriteFileHeader ();
2679
2680 void WriteScanHeader ();
2681
2682 void WriteFileTrailer ();
2683
2684 };
2685
2686 /*****************************************************************************/
2687
dng_lossless_encoder(const uint16 * srcData,uint32 srcRows,uint32 srcCols,uint32 srcChannels,uint32 srcBitDepth,int32 srcRowStep,int32 srcColStep,dng_stream & stream)2688 dng_lossless_encoder::dng_lossless_encoder (const uint16 *srcData,
2689 uint32 srcRows,
2690 uint32 srcCols,
2691 uint32 srcChannels,
2692 uint32 srcBitDepth,
2693 int32 srcRowStep,
2694 int32 srcColStep,
2695 dng_stream &stream)
2696
2697 : fSrcData (srcData )
2698 , fSrcRows (srcRows )
2699 , fSrcCols (srcCols )
2700 , fSrcChannels (srcChannels)
2701 , fSrcBitDepth (srcBitDepth)
2702 , fSrcRowStep (srcRowStep )
2703 , fSrcColStep (srcColStep )
2704 , fStream (stream )
2705
2706 , huffPutBuffer (0)
2707 , huffPutBits (0)
2708
2709 {
2710
2711 // Initialize number of bits lookup table.
2712
2713 numBitsTable [0] = 0;
2714
2715 for (int i = 1; i < 256; i++)
2716 {
2717
2718 int temp = i;
2719 int nbits = 1;
2720
2721 while (temp >>= 1)
2722 {
2723 nbits++;
2724 }
2725
2726 numBitsTable [i] = nbits;
2727
2728 }
2729
2730 }
2731
2732 /*****************************************************************************/
2733
EmitByte(uint8 value)2734 inline void dng_lossless_encoder::EmitByte (uint8 value)
2735 {
2736
2737 fStream.Put_uint8 (value);
2738
2739 }
2740
2741 /*****************************************************************************/
2742
2743 /*
2744 *--------------------------------------------------------------
2745 *
2746 * EmitBits --
2747 *
2748 * Code for outputting bits to the file
2749 *
2750 * Only the right 24 bits of huffPutBuffer are used; the valid
2751 * bits are left-justified in this part. At most 16 bits can be
2752 * passed to EmitBits in one call, and we never retain more than 7
2753 * bits in huffPutBuffer between calls, so 24 bits are
2754 * sufficient.
2755 *
2756 * Results:
2757 * None.
2758 *
2759 * Side effects:
2760 * huffPutBuffer and huffPutBits are updated.
2761 *
2762 *--------------------------------------------------------------
2763 */
2764
EmitBits(int code,int size)2765 inline void dng_lossless_encoder::EmitBits (int code, int size)
2766 {
2767
2768 DNG_ASSERT (size != 0, "Bad Huffman table entry");
2769
2770 int putBits = size;
2771 int putBuffer = code;
2772
2773 putBits += huffPutBits;
2774
2775 putBuffer <<= 24 - putBits;
2776 putBuffer |= huffPutBuffer;
2777
2778 while (putBits >= 8)
2779 {
2780
2781 uint8 c = (uint8) (putBuffer >> 16);
2782
2783 // Output whole bytes we've accumulated with byte stuffing
2784
2785 EmitByte (c);
2786
2787 if (c == 0xFF)
2788 {
2789 EmitByte (0);
2790 }
2791
2792 putBuffer <<= 8;
2793 putBits -= 8;
2794
2795 }
2796
2797 huffPutBuffer = putBuffer;
2798 huffPutBits = putBits;
2799
2800 }
2801
2802 /*****************************************************************************/
2803
2804 /*
2805 *--------------------------------------------------------------
2806 *
2807 * FlushBits --
2808 *
2809 * Flush any remaining bits in the bit buffer. Used before emitting
2810 * a marker.
2811 *
2812 * Results:
2813 * None.
2814 *
2815 * Side effects:
2816 * huffPutBuffer and huffPutBits are reset
2817 *
2818 *--------------------------------------------------------------
2819 */
2820
FlushBits()2821 void dng_lossless_encoder::FlushBits ()
2822 {
2823
2824 // The first call forces output of any partial bytes.
2825
2826 EmitBits (0x007F, 7);
2827
2828 // We can then zero the buffer.
2829
2830 huffPutBuffer = 0;
2831 huffPutBits = 0;
2832
2833 }
2834
2835 /*****************************************************************************/
2836
2837 /*
2838 *--------------------------------------------------------------
2839 *
2840 * CountOneDiff --
2841 *
2842 * Count the difference value in countTable.
2843 *
2844 * Results:
2845 * diff is counted in countTable.
2846 *
2847 * Side effects:
2848 * None.
2849 *
2850 *--------------------------------------------------------------
2851 */
2852
CountOneDiff(int diff,uint32 * countTable)2853 inline void dng_lossless_encoder::CountOneDiff (int diff, uint32 *countTable)
2854 {
2855
2856 // Encode the DC coefficient difference per section F.1.2.1
2857
2858 int temp = diff;
2859
2860 if (temp < 0)
2861 {
2862
2863 temp = -temp;
2864
2865 }
2866
2867 // Find the number of bits needed for the magnitude of the coefficient
2868
2869 int nbits = temp >= 256 ? numBitsTable [temp >> 8 ] + 8
2870 : numBitsTable [temp & 0xFF];
2871
2872 // Update count for this bit length
2873
2874 countTable [nbits] ++;
2875
2876 }
2877
2878 /*****************************************************************************/
2879
2880 /*
2881 *--------------------------------------------------------------
2882 *
2883 * EncodeOneDiff --
2884 *
2885 * Encode a single difference value.
2886 *
2887 * Results:
2888 * None.
2889 *
2890 * Side effects:
2891 * None.
2892 *
2893 *--------------------------------------------------------------
2894 */
2895
EncodeOneDiff(int diff,HuffmanTable * dctbl)2896 inline void dng_lossless_encoder::EncodeOneDiff (int diff, HuffmanTable *dctbl)
2897 {
2898
2899 // Encode the DC coefficient difference per section F.1.2.1
2900
2901 int temp = diff;
2902 int temp2 = diff;
2903
2904 if (temp < 0)
2905 {
2906
2907 temp = -temp;
2908
2909 // For a negative input, want temp2 = bitwise complement of
2910 // abs (input). This code assumes we are on a two's complement
2911 // machine.
2912
2913 temp2--;
2914
2915 }
2916
2917 // Find the number of bits needed for the magnitude of the coefficient
2918
2919 int nbits = temp >= 256 ? numBitsTable [temp >> 8 ] + 8
2920 : numBitsTable [temp & 0xFF];
2921
2922 // Emit the Huffman-coded symbol for the number of bits
2923
2924 EmitBits (dctbl->ehufco [nbits],
2925 dctbl->ehufsi [nbits]);
2926
2927 // Emit that number of bits of the value, if positive,
2928 // or the complement of its magnitude, if negative.
2929
2930 // If the number of bits is 16, there is only one possible difference
2931 // value (-32786), so the lossless JPEG spec says not to output anything
2932 // in that case. So we only need to output the diference value if
2933 // the number of bits is between 1 and 15.
2934
2935 if (nbits & 15)
2936 {
2937
2938 EmitBits (temp2 & (0x0FFFF >> (16 - nbits)),
2939 nbits);
2940
2941 }
2942
2943 }
2944
2945 /*****************************************************************************/
2946
2947 /*
2948 *--------------------------------------------------------------
2949 *
2950 * FreqCountSet --
2951 *
2952 * Count the times each category symbol occurs in this image.
2953 *
2954 * Results:
2955 * None.
2956 *
2957 * Side effects:
2958 * The freqCount has counted all category
2959 * symbols appeared in the image.
2960 *
2961 *--------------------------------------------------------------
2962 */
2963
FreqCountSet()2964 void dng_lossless_encoder::FreqCountSet ()
2965 {
2966
2967 memset (freqCount, 0, sizeof (freqCount));
2968
2969 DNG_ASSERT ((int32)fSrcRows >= 0, "dng_lossless_encoder::FreqCountSet: fSrcRpws too large.");
2970
2971 for (int32 row = 0; row < (int32)fSrcRows; row++)
2972 {
2973
2974 const uint16 *sPtr = fSrcData + row * fSrcRowStep;
2975
2976 // Initialize predictors for this row.
2977
2978 int32 predictor [4];
2979
2980 for (int32 channel = 0; channel < (int32)fSrcChannels; channel++)
2981 {
2982
2983 if (row == 0)
2984 predictor [channel] = 1 << (fSrcBitDepth - 1);
2985
2986 else
2987 predictor [channel] = sPtr [channel - fSrcRowStep];
2988
2989 }
2990
2991 // Unroll most common case of two channels
2992
2993 if (fSrcChannels == 2)
2994 {
2995
2996 int32 pred0 = predictor [0];
2997 int32 pred1 = predictor [1];
2998
2999 uint32 srcCols = fSrcCols;
3000 int32 srcColStep = fSrcColStep;
3001
3002 for (uint32 col = 0; col < srcCols; col++)
3003 {
3004
3005 int32 pixel0 = sPtr [0];
3006 int32 pixel1 = sPtr [1];
3007
3008 int16 diff0 = (int16) (pixel0 - pred0);
3009 int16 diff1 = (int16) (pixel1 - pred1);
3010
3011 CountOneDiff (diff0, freqCount [0]);
3012 CountOneDiff (diff1, freqCount [1]);
3013
3014 pred0 = pixel0;
3015 pred1 = pixel1;
3016
3017 sPtr += srcColStep;
3018
3019 }
3020
3021 }
3022
3023 // General case.
3024
3025 else
3026 {
3027
3028 for (uint32 col = 0; col < fSrcCols; col++)
3029 {
3030
3031 for (uint32 channel = 0; channel < fSrcChannels; channel++)
3032 {
3033
3034 int32 pixel = sPtr [channel];
3035
3036 int16 diff = (int16) (pixel - predictor [channel]);
3037
3038 CountOneDiff (diff, freqCount [channel]);
3039
3040 predictor [channel] = pixel;
3041
3042 }
3043
3044 sPtr += fSrcColStep;
3045
3046 }
3047
3048 }
3049
3050 }
3051
3052 }
3053
3054 /*****************************************************************************/
3055
3056 /*
3057 *--------------------------------------------------------------
3058 *
3059 * HuffEncode --
3060 *
3061 * Encode and output Huffman-compressed image data.
3062 *
3063 * Results:
3064 * None.
3065 *
3066 * Side effects:
3067 * None.
3068 *
3069 *--------------------------------------------------------------
3070 */
3071
HuffEncode()3072 void dng_lossless_encoder::HuffEncode ()
3073 {
3074
3075 DNG_ASSERT ((int32)fSrcRows >= 0, "dng_lossless_encoder::HuffEncode: fSrcRows too large.");
3076
3077 for (int32 row = 0; row < (int32)fSrcRows; row++)
3078 {
3079
3080 const uint16 *sPtr = fSrcData + row * fSrcRowStep;
3081
3082 // Initialize predictors for this row.
3083
3084 int32 predictor [4];
3085
3086 for (int32 channel = 0; channel < (int32)fSrcChannels; channel++)
3087 {
3088
3089 if (row == 0)
3090 predictor [channel] = 1 << (fSrcBitDepth - 1);
3091
3092 else
3093 predictor [channel] = sPtr [channel - fSrcRowStep];
3094
3095 }
3096
3097 // Unroll most common case of two channels
3098
3099 if (fSrcChannels == 2)
3100 {
3101
3102 int32 pred0 = predictor [0];
3103 int32 pred1 = predictor [1];
3104
3105 uint32 srcCols = fSrcCols;
3106 int32 srcColStep = fSrcColStep;
3107
3108 for (uint32 col = 0; col < srcCols; col++)
3109 {
3110
3111 int32 pixel0 = sPtr [0];
3112 int32 pixel1 = sPtr [1];
3113
3114 int16 diff0 = (int16) (pixel0 - pred0);
3115 int16 diff1 = (int16) (pixel1 - pred1);
3116
3117 EncodeOneDiff (diff0, &huffTable [0]);
3118 EncodeOneDiff (diff1, &huffTable [1]);
3119
3120 pred0 = pixel0;
3121 pred1 = pixel1;
3122
3123 sPtr += srcColStep;
3124
3125 }
3126
3127 }
3128
3129 // General case.
3130
3131 else
3132 {
3133
3134 for (uint32 col = 0; col < fSrcCols; col++)
3135 {
3136
3137 for (uint32 channel = 0; channel < fSrcChannels; channel++)
3138 {
3139
3140 int32 pixel = sPtr [channel];
3141
3142 int16 diff = (int16) (pixel - predictor [channel]);
3143
3144 EncodeOneDiff (diff, &huffTable [channel]);
3145
3146 predictor [channel] = pixel;
3147
3148 }
3149
3150 sPtr += fSrcColStep;
3151
3152 }
3153
3154 }
3155
3156 }
3157
3158 FlushBits ();
3159
3160 }
3161
3162 /*****************************************************************************/
3163
3164 /*
3165 *--------------------------------------------------------------
3166 *
3167 * GenHuffCoding --
3168 *
3169 * Generate the optimal coding for the given counts.
3170 * This algorithm is explained in section K.2 of the
3171 * JPEG standard.
3172 *
3173 * Results:
3174 * htbl->bits and htbl->huffval are constructed.
3175 *
3176 * Side effects:
3177 * None.
3178 *
3179 *--------------------------------------------------------------
3180 */
3181
GenHuffCoding(HuffmanTable * htbl,uint32 * freq)3182 void dng_lossless_encoder::GenHuffCoding (HuffmanTable *htbl, uint32 *freq)
3183 {
3184
3185 int i;
3186 int j;
3187
3188 const int MAX_CLEN = 32; // assumed maximum initial code length
3189
3190 uint8 bits [MAX_CLEN + 1]; // bits [k] = # of symbols with code length k
3191 short codesize [257]; // codesize [k] = code length of symbol k
3192 short others [257]; // next symbol in current branch of tree
3193
3194 memset (bits , 0, sizeof (bits ));
3195 memset (codesize, 0, sizeof (codesize));
3196
3197 for (i = 0; i < 257; i++)
3198 others [i] = -1; // init links to empty
3199
3200 // Including the pseudo-symbol 256 in the Huffman procedure guarantees
3201 // that no real symbol is given code-value of all ones, because 256
3202 // will be placed in the largest codeword category.
3203
3204 freq [256] = 1; // make sure there is a nonzero count
3205
3206 // Huffman's basic algorithm to assign optimal code lengths to symbols
3207
3208 while (true)
3209 {
3210
3211 // Find the smallest nonzero frequency, set c1 = its symbol.
3212 // In case of ties, take the larger symbol number.
3213
3214 int c1 = -1;
3215
3216 uint32 v = 0xFFFFFFFF;
3217
3218 for (i = 0; i <= 256; i++)
3219 {
3220
3221 if (freq [i] && freq [i] <= v)
3222 {
3223 v = freq [i];
3224 c1 = i;
3225 }
3226
3227 }
3228
3229 // Find the next smallest nonzero frequency, set c2 = its symbol.
3230 // In case of ties, take the larger symbol number.
3231
3232 int c2 = -1;
3233
3234 v = 0xFFFFFFFF;
3235
3236 for (i = 0; i <= 256; i++)
3237 {
3238
3239 if (freq [i] && freq [i] <= v && i != c1)
3240 {
3241 v = freq [i];
3242 c2 = i;
3243 }
3244
3245 }
3246
3247 // Done if we've merged everything into one frequency.
3248
3249 if (c2 < 0)
3250 break;
3251
3252 // Else merge the two counts/trees.
3253
3254 freq [c1] += freq [c2];
3255 freq [c2] = 0;
3256
3257 // Increment the codesize of everything in c1's tree branch.
3258
3259 codesize [c1] ++;
3260
3261 while (others [c1] >= 0)
3262 {
3263 c1 = others [c1];
3264 codesize [c1] ++;
3265 }
3266
3267 // chain c2 onto c1's tree branch
3268
3269 others [c1] = (short) c2;
3270
3271 // Increment the codesize of everything in c2's tree branch.
3272
3273 codesize [c2] ++;
3274
3275 while (others [c2] >= 0)
3276 {
3277 c2 = others [c2];
3278 codesize [c2] ++;
3279 }
3280
3281 }
3282
3283 // Now count the number of symbols of each code length.
3284
3285 for (i = 0; i <= 256; i++)
3286 {
3287
3288 if (codesize [i])
3289 {
3290
3291 // The JPEG standard seems to think that this can't happen,
3292 // but I'm paranoid...
3293
3294 if (codesize [i] > MAX_CLEN)
3295 {
3296
3297 DNG_REPORT ("Huffman code size table overflow");
3298
3299 ThrowProgramError ();
3300
3301 }
3302
3303 bits [codesize [i]]++;
3304
3305 }
3306
3307 }
3308
3309 // JPEG doesn't allow symbols with code lengths over 16 bits, so if the pure
3310 // Huffman procedure assigned any such lengths, we must adjust the coding.
3311 // Here is what the JPEG spec says about how this next bit works:
3312 // Since symbols are paired for the longest Huffman code, the symbols are
3313 // removed from this length category two at a time. The prefix for the pair
3314 // (which is one bit shorter) is allocated to one of the pair; then,
3315 // skipping the BITS entry for that prefix length, a code word from the next
3316 // shortest nonzero BITS entry is converted into a prefix for two code words
3317 // one bit longer.
3318
3319 for (i = MAX_CLEN; i > 16; i--)
3320 {
3321
3322 while (bits [i] > 0)
3323 {
3324
3325 // Kludge: I have never been able to test this logic, and there
3326 // are comments on the web that this encoder has bugs with 16-bit
3327 // data, so just throw an error if we get here and revert to a
3328 // default table. - tknoll 12/1/03.
3329
3330 DNG_REPORT ("Info: Optimal huffman table bigger than 16 bits");
3331
3332 ThrowProgramError ();
3333
3334 // Original logic:
3335
3336 j = i - 2; // find length of new prefix to be used
3337
3338 while (bits [j] == 0)
3339 j--;
3340
3341 bits [i ] -= 2; // remove two symbols
3342 bits [i - 1] ++; // one goes in this length
3343 bits [j + 1] += 2; // two new symbols in this length
3344 bits [j ] --; // symbol of this length is now a prefix
3345
3346 }
3347
3348 }
3349
3350 // Remove the count for the pseudo-symbol 256 from
3351 // the largest codelength.
3352
3353 while (bits [i] == 0) // find largest codelength still in use
3354 i--;
3355
3356 bits [i] --;
3357
3358 // Return final symbol counts (only for lengths 0..16).
3359
3360 memcpy (htbl->bits, bits, sizeof (htbl->bits));
3361
3362 // Return a list of the symbols sorted by code length.
3363 // It's not real clear to me why we don't need to consider the codelength
3364 // changes made above, but the JPEG spec seems to think this works.
3365
3366 int p = 0;
3367
3368 for (i = 1; i <= MAX_CLEN; i++)
3369 {
3370
3371 for (j = 0; j <= 255; j++)
3372 {
3373
3374 if (codesize [j] == i)
3375 {
3376 htbl->huffval [p] = (uint8) j;
3377 p++;
3378 }
3379
3380 }
3381
3382 }
3383
3384 }
3385
3386 /*****************************************************************************/
3387
3388 /*
3389 *--------------------------------------------------------------
3390 *
3391 * HuffOptimize --
3392 *
3393 * Find the best coding parameters for a Huffman-coded scan.
3394 * When called, the scan data has already been converted to
3395 * a sequence of MCU groups of source image samples, which
3396 * are stored in a "big" array, mcuTable.
3397 *
3398 * It counts the times each category symbol occurs. Based on
3399 * this counting, optimal Huffman tables are built. Then it
3400 * uses this optimal Huffman table and counting table to find
3401 * the best PSV.
3402 *
3403 * Results:
3404 * Optimal Huffman tables are retured in cPtr->dcHuffTblPtrs[tbl].
3405 * Best PSV is retured in cPtr->Ss.
3406 *
3407 * Side effects:
3408 * None.
3409 *
3410 *--------------------------------------------------------------
3411 */
3412
HuffOptimize()3413 void dng_lossless_encoder::HuffOptimize ()
3414 {
3415
3416 // Collect the frequency counts.
3417
3418 FreqCountSet ();
3419
3420 // Generate Huffman encoding tables.
3421
3422 for (uint32 channel = 0; channel < fSrcChannels; channel++)
3423 {
3424
3425 try
3426 {
3427
3428 GenHuffCoding (&huffTable [channel], freqCount [channel]);
3429
3430 }
3431
3432 catch (...)
3433 {
3434
3435 DNG_REPORT ("Info: Reverting to default huffman table");
3436
3437 for (uint32 j = 0; j <= 256; j++)
3438 {
3439
3440 freqCount [channel] [j] = (j <= 16 ? 1 : 0);
3441
3442 }
3443
3444 GenHuffCoding (&huffTable [channel], freqCount [channel]);
3445
3446 }
3447
3448 FixHuffTbl (&huffTable [channel]);
3449
3450 }
3451
3452 }
3453
3454 /*****************************************************************************/
3455
3456 /*
3457 *--------------------------------------------------------------
3458 *
3459 * EmitMarker --
3460 *
3461 * Emit a marker code into the output stream.
3462 *
3463 * Results:
3464 * None.
3465 *
3466 * Side effects:
3467 * None.
3468 *
3469 *--------------------------------------------------------------
3470 */
3471
EmitMarker(JpegMarker mark)3472 void dng_lossless_encoder::EmitMarker (JpegMarker mark)
3473 {
3474
3475 EmitByte (0xFF);
3476 EmitByte ((uint8) mark);
3477
3478 }
3479
3480 /*****************************************************************************/
3481
3482 /*
3483 *--------------------------------------------------------------
3484 *
3485 * Emit2bytes --
3486 *
3487 * Emit a 2-byte integer; these are always MSB first in JPEG
3488 * files
3489 *
3490 * Results:
3491 * None.
3492 *
3493 * Side effects:
3494 * None.
3495 *
3496 *--------------------------------------------------------------
3497 */
3498
Emit2bytes(int value)3499 void dng_lossless_encoder::Emit2bytes (int value)
3500 {
3501
3502 EmitByte ((value >> 8) & 0xFF);
3503 EmitByte (value & 0xFF);
3504
3505 }
3506
3507 /*****************************************************************************/
3508
3509 /*
3510 *--------------------------------------------------------------
3511 *
3512 * EmitDht --
3513 *
3514 * Emit a DHT marker, follwed by the huffman data.
3515 *
3516 * Results:
3517 * None
3518 *
3519 * Side effects:
3520 * None
3521 *
3522 *--------------------------------------------------------------
3523 */
3524
EmitDht(int index)3525 void dng_lossless_encoder::EmitDht (int index)
3526 {
3527
3528 int i;
3529
3530 HuffmanTable *htbl = &huffTable [index];
3531
3532 EmitMarker (M_DHT);
3533
3534 int length = 0;
3535
3536 for (i = 1; i <= 16; i++)
3537 length += htbl->bits [i];
3538
3539 Emit2bytes (length + 2 + 1 + 16);
3540
3541 EmitByte ((uint8) index);
3542
3543 for (i = 1; i <= 16; i++)
3544 EmitByte (htbl->bits [i]);
3545
3546 for (i = 0; i < length; i++)
3547 EmitByte (htbl->huffval [i]);
3548
3549 }
3550
3551 /*****************************************************************************/
3552
3553 /*
3554 *--------------------------------------------------------------
3555 *
3556 * EmitSof --
3557 *
3558 * Emit a SOF marker plus data.
3559 *
3560 * Results:
3561 * None.
3562 *
3563 * Side effects:
3564 * None.
3565 *
3566 *--------------------------------------------------------------
3567 */
3568
EmitSof(JpegMarker code)3569 void dng_lossless_encoder::EmitSof (JpegMarker code)
3570 {
3571
3572 EmitMarker (code);
3573
3574 Emit2bytes (3 * fSrcChannels + 2 + 5 + 1); // length
3575
3576 EmitByte ((uint8) fSrcBitDepth);
3577
3578 Emit2bytes (fSrcRows);
3579 Emit2bytes (fSrcCols);
3580
3581 EmitByte ((uint8) fSrcChannels);
3582
3583 for (uint32 i = 0; i < fSrcChannels; i++)
3584 {
3585
3586 EmitByte ((uint8) i);
3587
3588 EmitByte ((uint8) ((1 << 4) + 1)); // Not subsampled.
3589
3590 EmitByte (0); // Tq shall be 0 for lossless.
3591
3592 }
3593
3594 }
3595
3596 /*****************************************************************************/
3597
3598 /*
3599 *--------------------------------------------------------------
3600 *
3601 * EmitSos --
3602 *
3603 * Emit a SOS marker plus data.
3604 *
3605 * Results:
3606 * None.
3607 *
3608 * Side effects:
3609 * None.
3610 *
3611 *--------------------------------------------------------------
3612 */
3613
EmitSos()3614 void dng_lossless_encoder::EmitSos ()
3615 {
3616
3617 EmitMarker (M_SOS);
3618
3619 Emit2bytes (2 * fSrcChannels + 2 + 1 + 3); // length
3620
3621 EmitByte ((uint8) fSrcChannels); // Ns
3622
3623 for (uint32 i = 0; i < fSrcChannels; i++)
3624 {
3625
3626 // Cs,Td,Ta
3627
3628 EmitByte ((uint8) i);
3629 EmitByte ((uint8) (i << 4));
3630
3631 }
3632
3633 EmitByte (1); // PSV - hardcoded - tknoll
3634 EmitByte (0); // Spectral selection end - Se
3635 EmitByte (0); // The point transform parameter
3636
3637 }
3638
3639 /*****************************************************************************/
3640
3641 /*
3642 *--------------------------------------------------------------
3643 *
3644 * WriteFileHeader --
3645 *
3646 * Write the file header.
3647 *
3648 * Results:
3649 * None.
3650 *
3651 * Side effects:
3652 * None.
3653 *
3654 *--------------------------------------------------------------
3655 */
3656
WriteFileHeader()3657 void dng_lossless_encoder::WriteFileHeader ()
3658 {
3659
3660 EmitMarker (M_SOI); // first the SOI
3661
3662 EmitSof (M_SOF3);
3663
3664 }
3665
3666 /*****************************************************************************/
3667
3668 /*
3669 *--------------------------------------------------------------
3670 *
3671 * WriteScanHeader --
3672 *
3673 * Write the start of a scan (everything through the SOS marker).
3674 *
3675 * Results:
3676 * None.
3677 *
3678 * Side effects:
3679 * None.
3680 *
3681 *--------------------------------------------------------------
3682 */
3683
WriteScanHeader()3684 void dng_lossless_encoder::WriteScanHeader ()
3685 {
3686
3687 // Emit Huffman tables.
3688
3689 for (uint32 i = 0; i < fSrcChannels; i++)
3690 {
3691
3692 EmitDht (i);
3693
3694 }
3695
3696 EmitSos ();
3697
3698 }
3699
3700 /*****************************************************************************/
3701
3702 /*
3703 *--------------------------------------------------------------
3704 *
3705 * WriteFileTrailer --
3706 *
3707 * Write the End of image marker at the end of a JPEG file.
3708 *
3709 * Results:
3710 * None.
3711 *
3712 * Side effects:
3713 * None.
3714 *
3715 *--------------------------------------------------------------
3716 */
3717
WriteFileTrailer()3718 void dng_lossless_encoder::WriteFileTrailer ()
3719 {
3720
3721 EmitMarker (M_EOI);
3722
3723 }
3724
3725 /*****************************************************************************/
3726
Encode()3727 void dng_lossless_encoder::Encode ()
3728 {
3729
3730 DNG_ASSERT (fSrcChannels <= 4, "Too many components in scan");
3731
3732 // Count the times each difference category occurs.
3733 // Construct the optimal Huffman table.
3734
3735 HuffOptimize ();
3736
3737 // Write the frame and scan headers.
3738
3739 WriteFileHeader ();
3740
3741 WriteScanHeader ();
3742
3743 // Encode the image.
3744
3745 HuffEncode ();
3746
3747 // Clean up everything.
3748
3749 WriteFileTrailer ();
3750
3751 }
3752
3753 /*****************************************************************************/
3754
EncodeLosslessJPEG(const uint16 * srcData,uint32 srcRows,uint32 srcCols,uint32 srcChannels,uint32 srcBitDepth,int32 srcRowStep,int32 srcColStep,dng_stream & stream)3755 void EncodeLosslessJPEG (const uint16 *srcData,
3756 uint32 srcRows,
3757 uint32 srcCols,
3758 uint32 srcChannels,
3759 uint32 srcBitDepth,
3760 int32 srcRowStep,
3761 int32 srcColStep,
3762 dng_stream &stream)
3763 {
3764
3765 dng_lossless_encoder encoder (srcData,
3766 srcRows,
3767 srcCols,
3768 srcChannels,
3769 srcBitDepth,
3770 srcRowStep,
3771 srcColStep,
3772 stream);
3773
3774 encoder.Encode ();
3775
3776 }
3777
3778 /*****************************************************************************/
3779