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
89struct 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
120static 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
276struct 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
307struct 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
368typedef uint16 ComponentType; 		// the type of image components
369
370typedef ComponentType *MCU;  		// MCU - array of samples
371
372/*****************************************************************************/
373
374class 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
420		uint8 GetJpegChar ()
421			{
422			return fStream->Get_uint8 ();
423			}
424
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
498dng_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
529uint16 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
557void 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
585void 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
661void 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
691void 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
718void 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
807void 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
888void 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
916int32 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
966JpegMarker 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
1052void 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
1109int32 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
1155void 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
1268void 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
1329void 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
1402inline 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
1468inline 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
1549inline 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
1561inline void dng_lossless_decoder::flush_bits (int32 nbits)
1562	{
1563
1564	bitsLeft -= nbits;
1565
1566	}
1567
1568/*****************************************************************************/
1569
1570inline 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
1587inline 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
1616inline 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
1681inline 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
1695void 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
1730void 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
1852void 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
2542void 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
2560void dng_lossless_decoder::FinishRead ()
2561	{
2562
2563	DecodeImage ();
2564
2565	}
2566
2567/*****************************************************************************/
2568
2569void 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
2605class 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
2688dng_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
2734inline 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
2765inline 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
2821void 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
2853inline 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
2896inline 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
2964void 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
3072void 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
3182void 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
3413void 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
3472void 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
3499void 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
3525void 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
3569void 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
3614void 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
3657void 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
3684void 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
3718void dng_lossless_encoder::WriteFileTrailer ()
3719	{
3720
3721    EmitMarker (M_EOI);
3722
3723	}
3724
3725/*****************************************************************************/
3726
3727void 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
3755void 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