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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
1052 | void dng_lossless_decoder:: () |
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 | |
1109 | int32 dng_lossless_decoder:: () |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
1561 | inline void dng_lossless_decoder::flush_bits (int32 nbits) |
1562 | { |
1563 | |
1564 | bitsLeft -= nbits; |
1565 | |
1566 | } |
1567 | |
1568 | /*****************************************************************************/ |
1569 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
2560 | void dng_lossless_decoder::FinishRead () |
2561 | { |
2562 | |
2563 | DecodeImage (); |
2564 | |
2565 | } |
2566 | |
2567 | /*****************************************************************************/ |
2568 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
3657 | void dng_lossless_encoder:: () |
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 | |
3684 | void dng_lossless_encoder:: () |
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 | |
3718 | void dng_lossless_encoder::WriteFileTrailer () |
3719 | { |
3720 | |
3721 | EmitMarker (M_EOI); |
3722 | |
3723 | } |
3724 | |
3725 | /*****************************************************************************/ |
3726 | |
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 | |
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 | |