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