/*****************************************************************************/ // Copyright 2006-2007 Adobe Systems Incorporated // All Rights Reserved. // // NOTICE: Adobe permits you to use, modify, and distribute this file in // accordance with the terms of the Adobe license agreement accompanying it. /*****************************************************************************/ /* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_lossless_jpeg.cpp#2 $ */ /* $DateTime: 2012/06/01 07:28:57 $ */ /* $Change: 832715 $ */ /* $Author: tknoll $ */ /*****************************************************************************/ // Lossless JPEG code adapted from: /* Copyright (C) 1991, 1992, Thomas G. Lane. * Part of the Independent JPEG Group's software. * See the file Copyright for more details. * * Copyright (c) 1993 Brian C. Smith, The Regents of the University * of California * All rights reserved. * * Copyright (c) 1994 Kongji Huang and Brian C. Smith. * Cornell University * All rights reserved. * * Permission to use, copy, modify, and distribute this software and its * documentation for any purpose, without fee, and without written agreement is * hereby granted, provided that the above copyright notice and the following * two paragraphs appear in all copies of this software. * * IN NO EVENT SHALL CORNELL UNIVERSITY BE LIABLE TO ANY PARTY FOR * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT * OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF CORNELL * UNIVERSITY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * CORNELL UNIVERSITY SPECIFICALLY DISCLAIMS ANY WARRANTIES, * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS * ON AN "AS IS" BASIS, AND CORNELL UNIVERSITY HAS NO OBLIGATION TO * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. */ /*****************************************************************************/ #include "dng_lossless_jpeg.h" #include "dng_assertions.h" #include "dng_exceptions.h" #include "dng_memory.h" #include "dng_stream.h" #include "dng_tag_codes.h" /*****************************************************************************/ // This module contains routines that should be as fast as possible, even // at the expense of slight code size increases. #include "dng_fast_module.h" /*****************************************************************************/ // The qSupportCanon_sRAW stuff not actually required for DNG support, but // only included to allow this code to be used on Canon sRAW files. #ifndef qSupportCanon_sRAW #define qSupportCanon_sRAW 1 #endif // The qSupportHasselblad_3FR stuff not actually required for DNG support, but // only included to allow this code to be used on Hasselblad 3FR files. #ifndef qSupportHasselblad_3FR #define qSupportHasselblad_3FR 1 #endif /*****************************************************************************/ /* * One of the following structures is created for each huffman coding * table. We use the same structure for encoding and decoding, so there * may be some extra fields for encoding that aren't used in the decoding * and vice-versa. */ struct HuffmanTable { /* * These two fields directly represent the contents of a JPEG DHT * marker */ uint8 bits[17]; uint8 huffval[256]; /* * The remaining fields are computed from the above to allow more * efficient coding and decoding. These fields should be considered * private to the Huffman compression & decompression modules. */ uint16 mincode[17]; int32 maxcode[18]; int16 valptr[17]; int32 numbits[256]; int32 value[256]; uint16 ehufco[256]; int8 ehufsi[256]; }; /*****************************************************************************/ // Computes the derived fields in the Huffman table structure. static void FixHuffTbl (HuffmanTable *htbl) { int32 l; int32 i; const uint32 bitMask [] = { 0xffffffff, 0x7fffffff, 0x3fffffff, 0x1fffffff, 0x0fffffff, 0x07ffffff, 0x03ffffff, 0x01ffffff, 0x00ffffff, 0x007fffff, 0x003fffff, 0x001fffff, 0x000fffff, 0x0007ffff, 0x0003ffff, 0x0001ffff, 0x0000ffff, 0x00007fff, 0x00003fff, 0x00001fff, 0x00000fff, 0x000007ff, 0x000003ff, 0x000001ff, 0x000000ff, 0x0000007f, 0x0000003f, 0x0000001f, 0x0000000f, 0x00000007, 0x00000003, 0x00000001 }; // Figure C.1: make table of Huffman code length for each symbol // Note that this is in code-length order. int8 huffsize [257]; int32 p = 0; for (l = 1; l <= 16; l++) { for (i = 1; i <= (int32) htbl->bits [l]; i++) huffsize [p++] = (int8) l; } huffsize [p] = 0; int32 lastp = p; // Figure C.2: generate the codes themselves // Note that this is in code-length order. uint16 huffcode [257]; uint16 code = 0; int32 si = huffsize [0]; p = 0; while (huffsize [p]) { while (((int32) huffsize [p]) == si) { huffcode [p++] = code; code++; } code <<= 1; si++; } // Figure C.3: generate encoding tables // These are code and size indexed by symbol value // Set any codeless symbols to have code length 0; this allows // EmitBits to detect any attempt to emit such symbols. memset (htbl->ehufsi, 0, sizeof (htbl->ehufsi)); for (p = 0; p < lastp; p++) { htbl->ehufco [htbl->huffval [p]] = huffcode [p]; htbl->ehufsi [htbl->huffval [p]] = huffsize [p]; } // Figure F.15: generate decoding tables p = 0; for (l = 1; l <= 16; l++) { if (htbl->bits [l]) { htbl->valptr [l] = (int16) p; htbl->mincode [l] = huffcode [p]; p += htbl->bits [l]; htbl->maxcode [l] = huffcode [p - 1]; } else { htbl->maxcode [l] = -1; } } // We put in this value to ensure HuffDecode terminates. htbl->maxcode[17] = 0xFFFFFL; // Build the numbits, value lookup tables. // These table allow us to gather 8 bits from the bits stream, // and immediately lookup the size and value of the huffman codes. // If size is zero, it means that more than 8 bits are in the huffman // code (this happens about 3-4% of the time). memset (htbl->numbits, 0, sizeof (htbl->numbits)); for (p = 0; p < lastp; p++) { int32 size = huffsize [p]; if (size <= 8) { int32 value = htbl->huffval [p]; code = huffcode [p]; int32 ll = code << (8 -size); int32 ul = (size < 8 ? ll | bitMask [24 + size] : ll); if (ul >= static_cast(sizeof(htbl->numbits) / sizeof(htbl->numbits[0])) || ul >= static_cast(sizeof(htbl->value) / sizeof(htbl->value[0]))) { ThrowBadFormat (); } for (i = ll; i <= ul; i++) { htbl->numbits [i] = size; htbl->value [i] = value; } } } } /*****************************************************************************/ /* * The following structure stores basic information about one component. */ struct JpegComponentInfo { /* * These values are fixed over the whole image. * They are read from the SOF marker. */ int16 componentId; /* identifier for this component (0..255) */ int16 componentIndex; /* its index in SOF or cPtr->compInfo[] */ /* * Downsampling is not normally used in lossless JPEG, although * it is permitted by the JPEG standard (DIS). We set all sampling * factors to 1 in this program. */ int16 hSampFactor; /* horizontal sampling factor */ int16 vSampFactor; /* vertical sampling factor */ /* * Huffman table selector (0..3). The value may vary * between scans. It is read from the SOS marker. */ int16 dcTblNo; }; /* * One of the following structures is used to pass around the * decompression information. */ struct DecompressInfo { /* * Image width, height, and image data precision (bits/sample) * These fields are set by ReadFileHeader or ReadScanHeader */ int32 imageWidth; int32 imageHeight; int32 dataPrecision; /* * compInfo[i] describes component that appears i'th in SOF * numComponents is the # of color components in JPEG image. */ JpegComponentInfo *compInfo; int16 numComponents; /* * *curCompInfo[i] describes component that appears i'th in SOS. * compsInScan is the # of color components in current scan. */ JpegComponentInfo *curCompInfo[4]; int16 compsInScan; /* * MCUmembership[i] indexes the i'th component of MCU into the * curCompInfo array. */ int16 MCUmembership[10]; /* * ptrs to Huffman coding tables, or NULL if not defined */ HuffmanTable *dcHuffTblPtrs[4]; /* * prediction selection value (PSV) and point transform parameter (Pt) */ int32 Ss; int32 Pt; /* * In lossless JPEG, restart interval shall be an integer * multiple of the number of MCU in a MCU row. */ int32 restartInterval;/* MCUs per restart interval, 0 = no restart */ int32 restartInRows; /*if > 0, MCU rows per restart interval; 0 = no restart*/ /* * these fields are private data for the entropy decoder */ int32 restartRowsToGo; /* MCUs rows left in this restart interval */ int16 nextRestartNum; /* # of next RSTn marker (0..7) */ }; /*****************************************************************************/ // An MCU (minimum coding unit) is an array of samples. typedef uint16 ComponentType; // the type of image components typedef ComponentType *MCU; // MCU - array of samples /*****************************************************************************/ class dng_lossless_decoder { private: dng_stream *fStream; // Input data. dng_spooler *fSpooler; // Output data. bool fBug16; // Decode data with the "16-bit" bug. dng_memory_data huffmanBuffer [4]; dng_memory_data compInfoBuffer; DecompressInfo info; dng_memory_data mcuBuffer1; dng_memory_data mcuBuffer2; dng_memory_data mcuBuffer3; dng_memory_data mcuBuffer4; MCU *mcuROW1; MCU *mcuROW2; uint64 getBuffer; // current bit-extraction buffer int32 bitsLeft; // # of unused bits in it #if qSupportHasselblad_3FR bool fHasselblad3FR; #endif public: dng_lossless_decoder (dng_stream *stream, dng_spooler *spooler, bool bug16); void StartRead (uint32 &imageWidth, uint32 &imageHeight, uint32 &imageChannels); void FinishRead (); private: uint8 GetJpegChar () { return fStream->Get_uint8 (); } void UnGetJpegChar () { fStream->SetReadPosition (fStream->Position () - 1); } uint16 Get2bytes (); void SkipVariable (); void GetDht (); void GetDri (); void GetApp0 (); void GetSof (int32 code); void GetSos (); void GetSoi (); int32 NextMarker (); JpegMarker ProcessTables (); void ReadFileHeader (); int32 ReadScanHeader (); void DecoderStructInit (); void HuffDecoderInit (); void ProcessRestart (); int32 QuickPredict (int32 col, int32 curComp, MCU *curRowBuf, MCU *prevRowBuf); void FillBitBuffer (int32 nbits); int32 show_bits8 (); void flush_bits (int32 nbits); int32 get_bits (int32 nbits); int32 get_bit (); int32 HuffDecode (HuffmanTable *htbl); void HuffExtend (int32 &x, int32 s); void PmPutRow (MCU *buf, int32 numComp, int32 numCol, int32 row); void DecodeFirstRow (MCU *curRowBuf); void DecodeImage (); // Hidden copy constructor and assignment operator. dng_lossless_decoder (const dng_lossless_decoder &decoder); dng_lossless_decoder & operator= (const dng_lossless_decoder &decoder); }; /*****************************************************************************/ dng_lossless_decoder::dng_lossless_decoder (dng_stream *stream, dng_spooler *spooler, bool bug16) : fStream (stream ) , fSpooler (spooler) , fBug16 (bug16 ) , compInfoBuffer () , info () , mcuBuffer1 () , mcuBuffer2 () , mcuBuffer3 () , mcuBuffer4 () , mcuROW1 (NULL) , mcuROW2 (NULL) , getBuffer (0) , bitsLeft (0) #if qSupportHasselblad_3FR , fHasselblad3FR (false) #endif { memset (&info, 0, sizeof (info)); } /*****************************************************************************/ uint16 dng_lossless_decoder::Get2bytes () { uint16 a = GetJpegChar (); return (uint16) ((a << 8) + GetJpegChar ()); } /*****************************************************************************/ /* *-------------------------------------------------------------- * * SkipVariable -- * * Skip over an unknown or uninteresting variable-length marker * * Results: * None. * * Side effects: * Bitstream is parsed over marker. * * *-------------------------------------------------------------- */ void dng_lossless_decoder::SkipVariable () { uint32 length = Get2bytes () - 2; fStream->Skip (length); } /*****************************************************************************/ /* *-------------------------------------------------------------- * * GetDht -- * * Process a DHT marker * * Results: * None * * Side effects: * A huffman table is read. * Exits on error. * *-------------------------------------------------------------- */ void dng_lossless_decoder::GetDht () { int32 length = Get2bytes () - 2; while (length > 0) { int32 index = GetJpegChar (); if (index < 0 || index >= 4) { ThrowBadFormat (); } HuffmanTable *&htblptr = info.dcHuffTblPtrs [index]; if (htblptr == NULL) { huffmanBuffer [index] . Allocate (sizeof (HuffmanTable)); htblptr = (HuffmanTable *) huffmanBuffer [index] . Buffer (); } htblptr->bits [0] = 0; int32 count = 0; for (int32 i = 1; i <= 16; i++) { htblptr->bits [i] = GetJpegChar (); count += htblptr->bits [i]; } if (count > 256) { ThrowBadFormat (); } for (int32 j = 0; j < count; j++) { htblptr->huffval [j] = GetJpegChar (); } length -= 1 + 16 + count; } } /*****************************************************************************/ /* *-------------------------------------------------------------- * * GetDri -- * * Process a DRI marker * * Results: * None * * Side effects: * Exits on error. * Bitstream is parsed. * *-------------------------------------------------------------- */ void dng_lossless_decoder::GetDri () { if (Get2bytes () != 4) { ThrowBadFormat (); } info.restartInterval = Get2bytes (); } /*****************************************************************************/ /* *-------------------------------------------------------------- * * GetApp0 -- * * Process an APP0 marker. * * Results: * None * * Side effects: * Bitstream is parsed * *-------------------------------------------------------------- */ void dng_lossless_decoder::GetApp0 () { SkipVariable (); } /*****************************************************************************/ /* *-------------------------------------------------------------- * * GetSof -- * * Process a SOFn marker * * Results: * None. * * Side effects: * Bitstream is parsed * Exits on error * info structure is filled in * *-------------------------------------------------------------- */ void dng_lossless_decoder::GetSof (int32 /*code*/) { int32 length = Get2bytes (); info.dataPrecision = GetJpegChar (); info.imageHeight = Get2bytes (); info.imageWidth = Get2bytes (); info.numComponents = GetJpegChar (); // We don't support files in which the image height is initially // specified as 0 and is later redefined by DNL. As long as we // have to check that, might as well have a general sanity check. if ((info.imageHeight <= 0) || (info.imageWidth <= 0) || (info.numComponents <= 0)) { ThrowBadFormat (); } // Lossless JPEG specifies data precision to be from 2 to 16 bits/sample. const int32 MinPrecisionBits = 2; const int32 MaxPrecisionBits = 16; if ((info.dataPrecision < MinPrecisionBits) || (info.dataPrecision > MaxPrecisionBits)) { ThrowBadFormat (); } // Check length of tag. if (length != (info.numComponents * 3 + 8)) { ThrowBadFormat (); } // Allocate per component info. // We can cast info.numComponents to a uint32 because the check above // guarantees that it cannot be negative. compInfoBuffer.Allocate (static_cast (info.numComponents), sizeof (JpegComponentInfo)); info.compInfo = (JpegComponentInfo *) compInfoBuffer.Buffer (); // Read in the per compent info. for (int32 ci = 0; ci < info.numComponents; ci++) { JpegComponentInfo *compptr = &info.compInfo [ci]; compptr->componentIndex = (int16) ci; compptr->componentId = GetJpegChar (); int32 c = GetJpegChar (); compptr->hSampFactor = (int16) ((c >> 4) & 15); compptr->vSampFactor = (int16) ((c ) & 15); (void) GetJpegChar (); /* skip Tq */ } } /*****************************************************************************/ /* *-------------------------------------------------------------- * * GetSos -- * * Process a SOS marker * * Results: * None. * * Side effects: * Bitstream is parsed. * Exits on error. * *-------------------------------------------------------------- */ void dng_lossless_decoder::GetSos () { int32 length = Get2bytes (); // Get the number of image components. int32 n = GetJpegChar (); info.compsInScan = (int16) n; // Check length. length -= 3; if (length != (n * 2 + 3) || n < 1 || n > 4) { ThrowBadFormat (); } // Find index and huffman table for each component. for (int32 i = 0; i < n; i++) { int32 cc = GetJpegChar (); int32 c = GetJpegChar (); int32 ci; for (ci = 0; ci < info.numComponents; ci++) { if (cc == info.compInfo[ci].componentId) { break; } } if (ci >= info.numComponents) { ThrowBadFormat (); } JpegComponentInfo *compptr = &info.compInfo [ci]; info.curCompInfo [i] = compptr; compptr->dcTblNo = (int16) ((c >> 4) & 15); } // Get the PSV, skip Se, and get the point transform parameter. info.Ss = GetJpegChar (); (void) GetJpegChar (); info.Pt = GetJpegChar () & 0x0F; } /*****************************************************************************/ /* *-------------------------------------------------------------- * * GetSoi -- * * Process an SOI marker * * Results: * None. * * Side effects: * Bitstream is parsed. * Exits on error. * *-------------------------------------------------------------- */ void dng_lossless_decoder::GetSoi () { // Reset all parameters that are defined to be reset by SOI info.restartInterval = 0; } /*****************************************************************************/ /* *-------------------------------------------------------------- * * NextMarker -- * * Find the next JPEG marker Note that the output might not * be a valid marker code but it will never be 0 or FF * * Results: * The marker found. * * Side effects: * Bitstream is parsed. * *-------------------------------------------------------------- */ int32 dng_lossless_decoder::NextMarker () { int32 c; do { // skip any non-FF bytes do { c = GetJpegChar (); } while (c != 0xFF); // skip any duplicate FFs, since extra FFs are legal do { c = GetJpegChar(); } while (c == 0xFF); } while (c == 0); // repeat if it was a stuffed FF/00 return c; } /*****************************************************************************/ /* *-------------------------------------------------------------- * * ProcessTables -- * * Scan and process JPEG markers that can appear in any order * Return when an SOI, EOI, SOFn, or SOS is found * * Results: * The marker found. * * Side effects: * Bitstream is parsed. * *-------------------------------------------------------------- */ JpegMarker dng_lossless_decoder::ProcessTables () { while (true) { int32 c = NextMarker (); switch (c) { case M_SOF0: case M_SOF1: case M_SOF2: case M_SOF3: case M_SOF5: case M_SOF6: case M_SOF7: case M_JPG: case M_SOF9: case M_SOF10: case M_SOF11: case M_SOF13: case M_SOF14: case M_SOF15: case M_SOI: case M_EOI: case M_SOS: return (JpegMarker) c; case M_DHT: GetDht (); break; case M_DQT: break; case M_DRI: GetDri (); break; case M_APP0: GetApp0 (); break; case M_RST0: // these are all parameterless case M_RST1: case M_RST2: case M_RST3: case M_RST4: case M_RST5: case M_RST6: case M_RST7: case M_TEM: break; default: // must be DNL, DHP, EXP, APPn, JPGn, COM, or RESn SkipVariable (); break; } } return M_ERROR; } /*****************************************************************************/ /* *-------------------------------------------------------------- * * ReadFileHeader -- * * Initialize and read the stream header (everything through * the SOF marker). * * Results: * None * * Side effects: * Exit on error. * *-------------------------------------------------------------- */ void dng_lossless_decoder::ReadFileHeader () { // Demand an SOI marker at the start of the stream --- otherwise it's // probably not a JPEG stream at all. int32 c = GetJpegChar (); int32 c2 = GetJpegChar (); if ((c != 0xFF) || (c2 != M_SOI)) { ThrowBadFormat (); } // OK, process SOI GetSoi (); // Process markers until SOF c = ProcessTables (); switch (c) { case M_SOF0: case M_SOF1: case M_SOF3: GetSof (c); break; default: ThrowBadFormat (); break; } } /*****************************************************************************/ /* *-------------------------------------------------------------- * * ReadScanHeader -- * * Read the start of a scan (everything through the SOS marker). * * Results: * 1 if find SOS, 0 if find EOI * * Side effects: * Bitstream is parsed, may exit on errors. * *-------------------------------------------------------------- */ int32 dng_lossless_decoder::ReadScanHeader () { // Process markers until SOS or EOI int32 c = ProcessTables (); switch (c) { case M_SOS: GetSos (); return 1; case M_EOI: return 0; default: ThrowBadFormat (); break; } return 0; } /*****************************************************************************/ /* *-------------------------------------------------------------- * * DecoderStructInit -- * * Initalize the rest of the fields in the decompression * structure. * * Results: * None. * * Side effects: * None. * *-------------------------------------------------------------- */ void dng_lossless_decoder::DecoderStructInit () { int32 ci; #if qSupportCanon_sRAW bool canon_sRAW = (info.numComponents == 3) && (info.compInfo [0].hSampFactor == 2) && (info.compInfo [1].hSampFactor == 1) && (info.compInfo [2].hSampFactor == 1) && (info.compInfo [0].vSampFactor == 1) && (info.compInfo [1].vSampFactor == 1) && (info.compInfo [2].vSampFactor == 1) && (info.dataPrecision == 15) && (info.Ss == 1) && ((info.imageWidth & 1) == 0); bool canon_sRAW2 = (info.numComponents == 3) && (info.compInfo [0].hSampFactor == 2) && (info.compInfo [1].hSampFactor == 1) && (info.compInfo [2].hSampFactor == 1) && (info.compInfo [0].vSampFactor == 2) && (info.compInfo [1].vSampFactor == 1) && (info.compInfo [2].vSampFactor == 1) && (info.dataPrecision == 15) && (info.Ss == 1) && ((info.imageWidth & 1) == 0) && ((info.imageHeight & 1) == 0); if (!canon_sRAW && !canon_sRAW2) #endif { // Check sampling factor validity. for (ci = 0; ci < info.numComponents; ci++) { JpegComponentInfo *compPtr = &info.compInfo [ci]; if (compPtr->hSampFactor != 1 || compPtr->vSampFactor != 1) { ThrowBadFormat (); } } } // Prepare array describing MCU composition. if (info.compsInScan < 0 || info.compsInScan > 4) { ThrowBadFormat (); } for (ci = 0; ci < info.compsInScan; ci++) { info.MCUmembership [ci] = (int16) ci; } // Initialize mucROW1 and mcuROW2 which buffer two rows of // pixels for predictor calculation. // This multiplication cannot overflow because info.compsInScan is // guaranteed to be between 0 and 4 inclusive (see checks above). int32 mcuSize = info.compsInScan * (uint32) sizeof (ComponentType); mcuBuffer1.Allocate (info.imageWidth, sizeof (MCU)); mcuBuffer2.Allocate (info.imageWidth, sizeof (MCU)); mcuROW1 = (MCU *) mcuBuffer1.Buffer (); mcuROW2 = (MCU *) mcuBuffer2.Buffer (); mcuBuffer3.Allocate (info.imageWidth, mcuSize); mcuBuffer4.Allocate (info.imageWidth, mcuSize); mcuROW1 [0] = (ComponentType *) mcuBuffer3.Buffer (); mcuROW2 [0] = (ComponentType *) mcuBuffer4.Buffer (); for (int32 j = 1; j < info.imageWidth; j++) { mcuROW1 [j] = mcuROW1 [j - 1] + info.compsInScan; mcuROW2 [j] = mcuROW2 [j - 1] + info.compsInScan; } } /*****************************************************************************/ /* *-------------------------------------------------------------- * * HuffDecoderInit -- * * Initialize for a Huffman-compressed scan. * This is invoked after reading the SOS marker. * * Results: * None * * Side effects: * None. * *-------------------------------------------------------------- */ void dng_lossless_decoder::HuffDecoderInit () { // Initialize bit parser state getBuffer = 0; bitsLeft = 0; // Prepare Huffman tables. for (int16 ci = 0; ci < info.compsInScan; ci++) { JpegComponentInfo *compptr = info.curCompInfo [ci]; // Make sure requested tables are present if (compptr->dcTblNo < 0 || compptr->dcTblNo > 3) { ThrowBadFormat (); } if (info.dcHuffTblPtrs [compptr->dcTblNo] == NULL) { ThrowBadFormat (); } // Compute derived values for Huffman tables. // We may do this more than once for same table, but it's not a // big deal FixHuffTbl (info.dcHuffTblPtrs [compptr->dcTblNo]); } // Initialize restart stuff info.restartInRows = info.restartInterval / info.imageWidth; info.restartRowsToGo = info.restartInRows; info.nextRestartNum = 0; } /*****************************************************************************/ /* *-------------------------------------------------------------- * * ProcessRestart -- * * Check for a restart marker & resynchronize decoder. * * Results: * None. * * Side effects: * BitStream is parsed, bit buffer is reset, etc. * *-------------------------------------------------------------- */ void dng_lossless_decoder::ProcessRestart () { // Throw away and unused odd bits in the bit buffer. fStream->SetReadPosition (fStream->Position () - bitsLeft / 8); bitsLeft = 0; getBuffer = 0; // Scan for next JPEG marker int32 c; do { // skip any non-FF bytes do { c = GetJpegChar (); } while (c != 0xFF); // skip any duplicate FFs do { c = GetJpegChar (); } while (c == 0xFF); } while (c == 0); // repeat if it was a stuffed FF/00 // Verify correct restart code. if (c != (M_RST0 + info.nextRestartNum)) { ThrowBadFormat (); } // Update restart state. info.restartRowsToGo = info.restartInRows; info.nextRestartNum = (info.nextRestartNum + 1) & 7; } /*****************************************************************************/ /* *-------------------------------------------------------------- * * QuickPredict -- * * Calculate the predictor for sample curRowBuf[col][curComp]. * It does not handle the special cases at image edges, such * as first row and first column of a scan. We put the special * case checkings outside so that the computations in main * loop can be simpler. This has enhenced the performance * significantly. * * Results: * predictor is passed out. * * Side effects: * None. * *-------------------------------------------------------------- */ inline int32 dng_lossless_decoder::QuickPredict (int32 col, int32 curComp, MCU *curRowBuf, MCU *prevRowBuf) { int32 diag = prevRowBuf [col - 1] [curComp]; int32 upper = prevRowBuf [col ] [curComp]; int32 left = curRowBuf [col - 1] [curComp]; switch (info.Ss) { case 0: return 0; case 1: return left; case 2: return upper; case 3: return diag; case 4: return left + upper - diag; case 5: return left + ((upper - diag) >> 1); case 6: return upper + ((left - diag) >> 1); case 7: return (left + upper) >> 1; default: { ThrowBadFormat (); return 0; } } } /*****************************************************************************/ /* *-------------------------------------------------------------- * * FillBitBuffer -- * * Load up the bit buffer with at least nbits * Process any stuffed bytes at this time. * * Results: * None * * Side effects: * The bitwise global variables are updated. * *-------------------------------------------------------------- */ inline void dng_lossless_decoder::FillBitBuffer (int32 nbits) { const int32 kMinGetBits = sizeof (uint32) * 8 - 7; #if qSupportHasselblad_3FR if (fHasselblad3FR) { while (bitsLeft < kMinGetBits) { int32 c0 = GetJpegChar (); int32 c1 = GetJpegChar (); int32 c2 = GetJpegChar (); int32 c3 = GetJpegChar (); getBuffer = (getBuffer << 8) | c3; getBuffer = (getBuffer << 8) | c2; getBuffer = (getBuffer << 8) | c1; getBuffer = (getBuffer << 8) | c0; bitsLeft += 32; } return; } #endif while (bitsLeft < kMinGetBits) { int32 c = GetJpegChar (); // If it's 0xFF, check and discard stuffed zero byte if (c == 0xFF) { int32 c2 = GetJpegChar (); if (c2 != 0) { // Oops, it's actually a marker indicating end of // compressed data. Better put it back for use later. UnGetJpegChar (); UnGetJpegChar (); // There should be enough bits still left in the data // segment; if so, just break out of the while loop. if (bitsLeft >= nbits) break; // Uh-oh. Corrupted data: stuff zeroes into the data // stream, since this sometimes occurs when we are on the // last show_bits8 during decoding of the Huffman // segment. c = 0; } } getBuffer = (getBuffer << 8) | c; bitsLeft += 8; } } /*****************************************************************************/ inline int32 dng_lossless_decoder::show_bits8 () { if (bitsLeft < 8) FillBitBuffer (8); return (int32) ((getBuffer >> (bitsLeft - 8)) & 0xff); } /*****************************************************************************/ inline void dng_lossless_decoder::flush_bits (int32 nbits) { bitsLeft -= nbits; } /*****************************************************************************/ inline int32 dng_lossless_decoder::get_bits (int32 nbits) { if (nbits > 16) { ThrowBadFormat (); } if (bitsLeft < nbits) FillBitBuffer (nbits); return (int32) ((getBuffer >> (bitsLeft -= nbits)) & (0x0FFFF >> (16 - nbits))); } /*****************************************************************************/ inline int32 dng_lossless_decoder::get_bit () { if (!bitsLeft) FillBitBuffer (1); return (int32) ((getBuffer >> (--bitsLeft)) & 1); } /*****************************************************************************/ /* *-------------------------------------------------------------- * * HuffDecode -- * * Taken from Figure F.16: extract next coded symbol from * input stream. This should becode a macro. * * Results: * Next coded symbol * * Side effects: * Bitstream is parsed. * *-------------------------------------------------------------- */ inline int32 dng_lossless_decoder::HuffDecode (HuffmanTable *htbl) { // If the huffman code is less than 8 bits, we can use the fast // table lookup to get its value. It's more than 8 bits about // 3-4% of the time. int32 code = show_bits8 (); if (htbl->numbits [code]) { flush_bits (htbl->numbits [code]); return htbl->value [code]; } else { flush_bits (8); int32 l = 8; while (code > htbl->maxcode [l]) { code = (code << 1) | get_bit (); l++; } // With garbage input we may reach the sentinel value l = 17. if (l > 16) { return 0; // fake a zero as the safest result } else { return htbl->huffval [htbl->valptr [l] + ((int32) (code - htbl->mincode [l]))]; } } } /*****************************************************************************/ /* *-------------------------------------------------------------- * * HuffExtend -- * * Code and table for Figure F.12: extend sign bit * * Results: * The extended value. * * Side effects: * None. * *-------------------------------------------------------------- */ inline void dng_lossless_decoder::HuffExtend (int32 &x, int32 s) { if (x < (0x08000 >> (16 - s))) { x += -(1 << s) + 1; } } /*****************************************************************************/ // Called from DecodeImage () to write one row. void dng_lossless_decoder::PmPutRow (MCU *buf, int32 numComp, int32 numCol, int32 /* row */) { uint16 *sPtr = &buf [0] [0]; uint32 pixels = numCol * numComp; fSpooler->Spool (sPtr, pixels * (uint32) sizeof (uint16)); } /*****************************************************************************/ /* *-------------------------------------------------------------- * * DecodeFirstRow -- * * Decode the first raster line of samples at the start of * the scan and at the beginning of each restart interval. * This includes modifying the component value so the real * value, not the difference is returned. * * Results: * None. * * Side effects: * Bitstream is parsed. * *-------------------------------------------------------------- */ void dng_lossless_decoder::DecodeFirstRow (MCU *curRowBuf) { int32 compsInScan = info.compsInScan; // Process the first column in the row. for (int32 curComp = 0; curComp < compsInScan; curComp++) { int32 ci = info.MCUmembership [curComp]; JpegComponentInfo *compptr = info.curCompInfo [ci]; HuffmanTable *dctbl = info.dcHuffTblPtrs [compptr->dcTblNo]; // Section F.2.2.1: decode the difference int32 d = 0; int32 s = HuffDecode (dctbl); if (s) { if (s == 16 && !fBug16) { d = -32768; } else { d = get_bits (s); HuffExtend (d, s); } } // Add the predictor to the difference. int32 Pr = info.dataPrecision; int32 Pt = info.Pt; curRowBuf [0] [curComp] = (ComponentType) (d + (1 << (Pr-Pt-1))); } // Process the rest of the row. int32 numCOL = info.imageWidth; for (int32 col = 1; col < numCOL; col++) { for (int32 curComp = 0; curComp < compsInScan; curComp++) { int32 ci = info.MCUmembership [curComp]; JpegComponentInfo *compptr = info.curCompInfo [ci]; HuffmanTable *dctbl = info.dcHuffTblPtrs [compptr->dcTblNo]; // Section F.2.2.1: decode the difference int32 d = 0; int32 s = HuffDecode (dctbl); if (s) { if (s == 16 && !fBug16) { d = -32768; } else { d = get_bits (s); HuffExtend (d, s); } } // Add the predictor to the difference. curRowBuf [col] [curComp] = (ComponentType) (d + curRowBuf [col-1] [curComp]); } } // Update the restart counter if (info.restartInRows) { info.restartRowsToGo--; } } /*****************************************************************************/ /* *-------------------------------------------------------------- * * DecodeImage -- * * Decode the input stream. This includes modifying * the component value so the real value, not the * difference is returned. * * Results: * None. * * Side effects: * Bitstream is parsed. * *-------------------------------------------------------------- */ void dng_lossless_decoder::DecodeImage () { #define swap(type,a,b) {type c; c=(a); (a)=(b); (b)=c;} int32 numCOL = info.imageWidth; int32 numROW = info.imageHeight; int32 compsInScan = info.compsInScan; // Precompute the decoding table for each table. HuffmanTable *ht [4]; for (int32 curComp = 0; curComp < compsInScan; curComp++) { int32 ci = info.MCUmembership [curComp]; JpegComponentInfo *compptr = info.curCompInfo [ci]; ht [curComp] = info.dcHuffTblPtrs [compptr->dcTblNo]; } MCU *prevRowBuf = mcuROW1; MCU *curRowBuf = mcuROW2; #if qSupportCanon_sRAW // Canon sRAW support if (info.compInfo [0].hSampFactor == 2 && info.compInfo [0].vSampFactor == 1) { for (int32 row = 0; row < numROW; row++) { // Initialize predictors. int32 p0; int32 p1; int32 p2; if (row == 0) { p0 = 1 << 14; p1 = 1 << 14; p2 = 1 << 14; } else { p0 = prevRowBuf [0] [0]; p1 = prevRowBuf [0] [1]; p2 = prevRowBuf [0] [2]; } for (int32 col = 0; col < numCOL; col += 2) { // Read first luminance component. { int32 d = 0; int32 s = HuffDecode (ht [0]); if (s) { if (s == 16) { d = -32768; } else { d = get_bits (s); HuffExtend (d, s); } } p0 += d; curRowBuf [col] [0] = (ComponentType) p0; } // Read second luminance component. { int32 d = 0; int32 s = HuffDecode (ht [0]); if (s) { if (s == 16) { d = -32768; } else { d = get_bits (s); HuffExtend (d, s); } } p0 += d; curRowBuf [col + 1] [0] = (ComponentType) p0; } // Read first chroma component. { int32 d = 0; int32 s = HuffDecode (ht [1]); if (s) { if (s == 16) { d = -32768; } else { d = get_bits (s); HuffExtend (d, s); } } p1 += d; curRowBuf [col ] [1] = (ComponentType) p1; curRowBuf [col + 1] [1] = (ComponentType) p1; } // Read second chroma component. { int32 d = 0; int32 s = HuffDecode (ht [2]); if (s) { if (s == 16) { d = -32768; } else { d = get_bits (s); HuffExtend (d, s); } } p2 += d; curRowBuf [col ] [2] = (ComponentType) p2; curRowBuf [col + 1] [2] = (ComponentType) p2; } } PmPutRow (curRowBuf, compsInScan, numCOL, row); swap (MCU *, prevRowBuf, curRowBuf); } return; } if (info.compInfo [0].hSampFactor == 2 && info.compInfo [0].vSampFactor == 2) { for (int32 row = 0; row < numROW; row += 2) { // Initialize predictors. int32 p0; int32 p1; int32 p2; if (row == 0) { p0 = 1 << 14; p1 = 1 << 14; p2 = 1 << 14; } else { p0 = prevRowBuf [0] [0]; p1 = prevRowBuf [0] [1]; p2 = prevRowBuf [0] [2]; } for (int32 col = 0; col < numCOL; col += 2) { // Read first luminance component. { int32 d = 0; int32 s = HuffDecode (ht [0]); if (s) { if (s == 16) { d = -32768; } else { d = get_bits (s); HuffExtend (d, s); } } p0 += d; prevRowBuf [col] [0] = (ComponentType) p0; } // Read second luminance component. { int32 d = 0; int32 s = HuffDecode (ht [0]); if (s) { if (s == 16) { d = -32768; } else { d = get_bits (s); HuffExtend (d, s); } } p0 += d; prevRowBuf [col + 1] [0] = (ComponentType) p0; } // Read third luminance component. { int32 d = 0; int32 s = HuffDecode (ht [0]); if (s) { if (s == 16) { d = -32768; } else { d = get_bits (s); HuffExtend (d, s); } } p0 += d; curRowBuf [col] [0] = (ComponentType) p0; } // Read fourth luminance component. { int32 d = 0; int32 s = HuffDecode (ht [0]); if (s) { if (s == 16) { d = -32768; } else { d = get_bits (s); HuffExtend (d, s); } } p0 += d; curRowBuf [col + 1] [0] = (ComponentType) p0; } // Read first chroma component. { int32 d = 0; int32 s = HuffDecode (ht [1]); if (s) { if (s == 16) { d = -32768; } else { d = get_bits (s); HuffExtend (d, s); } } p1 += d; prevRowBuf [col ] [1] = (ComponentType) p1; prevRowBuf [col + 1] [1] = (ComponentType) p1; curRowBuf [col ] [1] = (ComponentType) p1; curRowBuf [col + 1] [1] = (ComponentType) p1; } // Read second chroma component. { int32 d = 0; int32 s = HuffDecode (ht [2]); if (s) { if (s == 16) { d = -32768; } else { d = get_bits (s); HuffExtend (d, s); } } p2 += d; prevRowBuf [col ] [2] = (ComponentType) p2; prevRowBuf [col + 1] [2] = (ComponentType) p2; curRowBuf [col ] [2] = (ComponentType) p2; curRowBuf [col + 1] [2] = (ComponentType) p2; } } PmPutRow (prevRowBuf, compsInScan, numCOL, row); PmPutRow (curRowBuf, compsInScan, numCOL, row); } return; } #endif #if qSupportHasselblad_3FR if (info.Ss == 8) { fHasselblad3FR = true; for (int32 row = 0; row < numROW; row++) { int32 p0 = 32768; int32 p1 = 32768; for (int32 col = 0; col < numCOL; col += 2) { int32 s0 = HuffDecode (ht [0]); int32 s1 = HuffDecode (ht [0]); if (s0) { int32 d = get_bits (s0); if (s0 == 16) { d = -32768; } else { HuffExtend (d, s0); } p0 += d; } if (s1) { int32 d = get_bits (s1); if (s1 == 16) { d = -32768; } else { HuffExtend (d, s1); } p1 += d; } curRowBuf [col ] [0] = (ComponentType) p0; curRowBuf [col + 1] [0] = (ComponentType) p1; } PmPutRow (curRowBuf, compsInScan, numCOL, row); } return; } #endif // Decode the first row of image. Output the row and // turn this row into a previous row for later predictor // calculation. DecodeFirstRow (mcuROW1); PmPutRow (mcuROW1, compsInScan, numCOL, 0); // Process each row. for (int32 row = 1; row < numROW; row++) { // Account for restart interval, process restart marker if needed. if (info.restartInRows) { if (info.restartRowsToGo == 0) { ProcessRestart (); // Reset predictors at restart. DecodeFirstRow (curRowBuf); PmPutRow (curRowBuf, compsInScan, numCOL, row); swap (MCU *, prevRowBuf, curRowBuf); continue; } info.restartRowsToGo--; } // The upper neighbors are predictors for the first column. for (int32 curComp = 0; curComp < compsInScan; curComp++) { // Section F.2.2.1: decode the difference int32 d = 0; int32 s = HuffDecode (ht [curComp]); if (s) { if (s == 16 && !fBug16) { d = -32768; } else { d = get_bits (s); HuffExtend (d, s); } } // First column of row above is predictor for first column. curRowBuf [0] [curComp] = (ComponentType) (d + prevRowBuf [0] [curComp]); } // For the rest of the column on this row, predictor // calculations are based on PSV. if (compsInScan == 2 && info.Ss == 1) { // This is the combination used by both the Canon and Kodak raw formats. // Unrolling the general case logic results in a significant speed increase. uint16 *dPtr = &curRowBuf [1] [0]; int32 prev0 = dPtr [-2]; int32 prev1 = dPtr [-1]; for (int32 col = 1; col < numCOL; col++) { int32 s = HuffDecode (ht [0]); if (s) { int32 d; if (s == 16 && !fBug16) { d = -32768; } else { d = get_bits (s); HuffExtend (d, s); } prev0 += d; } s = HuffDecode (ht [1]); if (s) { int32 d; if (s == 16 && !fBug16) { d = -32768; } else { d = get_bits (s); HuffExtend (d, s); } prev1 += d; } dPtr [0] = (uint16) prev0; dPtr [1] = (uint16) prev1; dPtr += 2; } } else { for (int32 col = 1; col < numCOL; col++) { for (int32 curComp = 0; curComp < compsInScan; curComp++) { // Section F.2.2.1: decode the difference int32 d = 0; int32 s = HuffDecode (ht [curComp]); if (s) { if (s == 16 && !fBug16) { d = -32768; } else { d = get_bits (s); HuffExtend (d, s); } } // Predict the pixel value. int32 predictor = QuickPredict (col, curComp, curRowBuf, prevRowBuf); // Save the difference. curRowBuf [col] [curComp] = (ComponentType) (d + predictor); } } } PmPutRow (curRowBuf, compsInScan, numCOL, row); swap (MCU *, prevRowBuf, curRowBuf); } #undef swap } /*****************************************************************************/ void dng_lossless_decoder::StartRead (uint32 &imageWidth, uint32 &imageHeight, uint32 &imageChannels) { ReadFileHeader (); ReadScanHeader (); DecoderStructInit (); HuffDecoderInit (); imageWidth = info.imageWidth; imageHeight = info.imageHeight; imageChannels = info.compsInScan; } /*****************************************************************************/ void dng_lossless_decoder::FinishRead () { DecodeImage (); } /*****************************************************************************/ void DecodeLosslessJPEG (dng_stream &stream, dng_spooler &spooler, uint32 minDecodedSize, uint32 maxDecodedSize, bool bug16) { dng_lossless_decoder decoder (&stream, &spooler, bug16); uint32 imageWidth; uint32 imageHeight; uint32 imageChannels; decoder.StartRead (imageWidth, imageHeight, imageChannels); uint32 decodedSize = imageWidth * imageHeight * imageChannels * (uint32) sizeof (uint16); if (decodedSize < minDecodedSize || decodedSize > maxDecodedSize) { ThrowBadFormat (); } decoder.FinishRead (); } /*****************************************************************************/ class dng_lossless_encoder { private: const uint16 *fSrcData; uint32 fSrcRows; uint32 fSrcCols; uint32 fSrcChannels; uint32 fSrcBitDepth; int32 fSrcRowStep; int32 fSrcColStep; dng_stream &fStream; HuffmanTable huffTable [4]; uint32 freqCount [4] [257]; // Current bit-accumulation buffer int32 huffPutBuffer; int32 huffPutBits; // Lookup table for number of bits in an 8 bit value. int numBitsTable [256]; public: dng_lossless_encoder (const uint16 *srcData, uint32 srcRows, uint32 srcCols, uint32 srcChannels, uint32 srcBitDepth, int32 srcRowStep, int32 srcColStep, dng_stream &stream); void Encode (); private: void EmitByte (uint8 value); void EmitBits (int code, int size); void FlushBits (); void CountOneDiff (int diff, uint32 *countTable); void EncodeOneDiff (int diff, HuffmanTable *dctbl); void FreqCountSet (); void HuffEncode (); void GenHuffCoding (HuffmanTable *htbl, uint32 *freq); void HuffOptimize (); void EmitMarker (JpegMarker mark); void Emit2bytes (int value); void EmitDht (int index); void EmitSof (JpegMarker code); void EmitSos (); void WriteFileHeader (); void WriteScanHeader (); void WriteFileTrailer (); }; /*****************************************************************************/ dng_lossless_encoder::dng_lossless_encoder (const uint16 *srcData, uint32 srcRows, uint32 srcCols, uint32 srcChannels, uint32 srcBitDepth, int32 srcRowStep, int32 srcColStep, dng_stream &stream) : fSrcData (srcData ) , fSrcRows (srcRows ) , fSrcCols (srcCols ) , fSrcChannels (srcChannels) , fSrcBitDepth (srcBitDepth) , fSrcRowStep (srcRowStep ) , fSrcColStep (srcColStep ) , fStream (stream ) , huffPutBuffer (0) , huffPutBits (0) { // Initialize number of bits lookup table. numBitsTable [0] = 0; for (int i = 1; i < 256; i++) { int temp = i; int nbits = 1; while (temp >>= 1) { nbits++; } numBitsTable [i] = nbits; } } /*****************************************************************************/ inline void dng_lossless_encoder::EmitByte (uint8 value) { fStream.Put_uint8 (value); } /*****************************************************************************/ /* *-------------------------------------------------------------- * * EmitBits -- * * Code for outputting bits to the file * * Only the right 24 bits of huffPutBuffer are used; the valid * bits are left-justified in this part. At most 16 bits can be * passed to EmitBits in one call, and we never retain more than 7 * bits in huffPutBuffer between calls, so 24 bits are * sufficient. * * Results: * None. * * Side effects: * huffPutBuffer and huffPutBits are updated. * *-------------------------------------------------------------- */ inline void dng_lossless_encoder::EmitBits (int code, int size) { DNG_ASSERT (size != 0, "Bad Huffman table entry"); int putBits = size; int putBuffer = code; putBits += huffPutBits; putBuffer <<= 24 - putBits; putBuffer |= huffPutBuffer; while (putBits >= 8) { uint8 c = (uint8) (putBuffer >> 16); // Output whole bytes we've accumulated with byte stuffing EmitByte (c); if (c == 0xFF) { EmitByte (0); } putBuffer <<= 8; putBits -= 8; } huffPutBuffer = putBuffer; huffPutBits = putBits; } /*****************************************************************************/ /* *-------------------------------------------------------------- * * FlushBits -- * * Flush any remaining bits in the bit buffer. Used before emitting * a marker. * * Results: * None. * * Side effects: * huffPutBuffer and huffPutBits are reset * *-------------------------------------------------------------- */ void dng_lossless_encoder::FlushBits () { // The first call forces output of any partial bytes. EmitBits (0x007F, 7); // We can then zero the buffer. huffPutBuffer = 0; huffPutBits = 0; } /*****************************************************************************/ /* *-------------------------------------------------------------- * * CountOneDiff -- * * Count the difference value in countTable. * * Results: * diff is counted in countTable. * * Side effects: * None. * *-------------------------------------------------------------- */ inline void dng_lossless_encoder::CountOneDiff (int diff, uint32 *countTable) { // Encode the DC coefficient difference per section F.1.2.1 int temp = diff; if (temp < 0) { temp = -temp; } // Find the number of bits needed for the magnitude of the coefficient int nbits = temp >= 256 ? numBitsTable [temp >> 8 ] + 8 : numBitsTable [temp & 0xFF]; // Update count for this bit length countTable [nbits] ++; } /*****************************************************************************/ /* *-------------------------------------------------------------- * * EncodeOneDiff -- * * Encode a single difference value. * * Results: * None. * * Side effects: * None. * *-------------------------------------------------------------- */ inline void dng_lossless_encoder::EncodeOneDiff (int diff, HuffmanTable *dctbl) { // Encode the DC coefficient difference per section F.1.2.1 int temp = diff; int temp2 = diff; if (temp < 0) { temp = -temp; // For a negative input, want temp2 = bitwise complement of // abs (input). This code assumes we are on a two's complement // machine. temp2--; } // Find the number of bits needed for the magnitude of the coefficient int nbits = temp >= 256 ? numBitsTable [temp >> 8 ] + 8 : numBitsTable [temp & 0xFF]; // Emit the Huffman-coded symbol for the number of bits EmitBits (dctbl->ehufco [nbits], dctbl->ehufsi [nbits]); // Emit that number of bits of the value, if positive, // or the complement of its magnitude, if negative. // If the number of bits is 16, there is only one possible difference // value (-32786), so the lossless JPEG spec says not to output anything // in that case. So we only need to output the diference value if // the number of bits is between 1 and 15. if (nbits & 15) { EmitBits (temp2 & (0x0FFFF >> (16 - nbits)), nbits); } } /*****************************************************************************/ /* *-------------------------------------------------------------- * * FreqCountSet -- * * Count the times each category symbol occurs in this image. * * Results: * None. * * Side effects: * The freqCount has counted all category * symbols appeared in the image. * *-------------------------------------------------------------- */ void dng_lossless_encoder::FreqCountSet () { memset (freqCount, 0, sizeof (freqCount)); DNG_ASSERT ((int32)fSrcRows >= 0, "dng_lossless_encoder::FreqCountSet: fSrcRpws too large."); for (int32 row = 0; row < (int32)fSrcRows; row++) { const uint16 *sPtr = fSrcData + row * fSrcRowStep; // Initialize predictors for this row. int32 predictor [4]; for (int32 channel = 0; channel < (int32)fSrcChannels; channel++) { if (row == 0) predictor [channel] = 1 << (fSrcBitDepth - 1); else predictor [channel] = sPtr [channel - fSrcRowStep]; } // Unroll most common case of two channels if (fSrcChannels == 2) { int32 pred0 = predictor [0]; int32 pred1 = predictor [1]; uint32 srcCols = fSrcCols; int32 srcColStep = fSrcColStep; for (uint32 col = 0; col < srcCols; col++) { int32 pixel0 = sPtr [0]; int32 pixel1 = sPtr [1]; int16 diff0 = (int16) (pixel0 - pred0); int16 diff1 = (int16) (pixel1 - pred1); CountOneDiff (diff0, freqCount [0]); CountOneDiff (diff1, freqCount [1]); pred0 = pixel0; pred1 = pixel1; sPtr += srcColStep; } } // General case. else { for (uint32 col = 0; col < fSrcCols; col++) { for (uint32 channel = 0; channel < fSrcChannels; channel++) { int32 pixel = sPtr [channel]; int16 diff = (int16) (pixel - predictor [channel]); CountOneDiff (diff, freqCount [channel]); predictor [channel] = pixel; } sPtr += fSrcColStep; } } } } /*****************************************************************************/ /* *-------------------------------------------------------------- * * HuffEncode -- * * Encode and output Huffman-compressed image data. * * Results: * None. * * Side effects: * None. * *-------------------------------------------------------------- */ void dng_lossless_encoder::HuffEncode () { DNG_ASSERT ((int32)fSrcRows >= 0, "dng_lossless_encoder::HuffEncode: fSrcRows too large."); for (int32 row = 0; row < (int32)fSrcRows; row++) { const uint16 *sPtr = fSrcData + row * fSrcRowStep; // Initialize predictors for this row. int32 predictor [4]; for (int32 channel = 0; channel < (int32)fSrcChannels; channel++) { if (row == 0) predictor [channel] = 1 << (fSrcBitDepth - 1); else predictor [channel] = sPtr [channel - fSrcRowStep]; } // Unroll most common case of two channels if (fSrcChannels == 2) { int32 pred0 = predictor [0]; int32 pred1 = predictor [1]; uint32 srcCols = fSrcCols; int32 srcColStep = fSrcColStep; for (uint32 col = 0; col < srcCols; col++) { int32 pixel0 = sPtr [0]; int32 pixel1 = sPtr [1]; int16 diff0 = (int16) (pixel0 - pred0); int16 diff1 = (int16) (pixel1 - pred1); EncodeOneDiff (diff0, &huffTable [0]); EncodeOneDiff (diff1, &huffTable [1]); pred0 = pixel0; pred1 = pixel1; sPtr += srcColStep; } } // General case. else { for (uint32 col = 0; col < fSrcCols; col++) { for (uint32 channel = 0; channel < fSrcChannels; channel++) { int32 pixel = sPtr [channel]; int16 diff = (int16) (pixel - predictor [channel]); EncodeOneDiff (diff, &huffTable [channel]); predictor [channel] = pixel; } sPtr += fSrcColStep; } } } FlushBits (); } /*****************************************************************************/ /* *-------------------------------------------------------------- * * GenHuffCoding -- * * Generate the optimal coding for the given counts. * This algorithm is explained in section K.2 of the * JPEG standard. * * Results: * htbl->bits and htbl->huffval are constructed. * * Side effects: * None. * *-------------------------------------------------------------- */ void dng_lossless_encoder::GenHuffCoding (HuffmanTable *htbl, uint32 *freq) { int i; int j; const int MAX_CLEN = 32; // assumed maximum initial code length uint8 bits [MAX_CLEN + 1]; // bits [k] = # of symbols with code length k short codesize [257]; // codesize [k] = code length of symbol k short others [257]; // next symbol in current branch of tree memset (bits , 0, sizeof (bits )); memset (codesize, 0, sizeof (codesize)); for (i = 0; i < 257; i++) others [i] = -1; // init links to empty // Including the pseudo-symbol 256 in the Huffman procedure guarantees // that no real symbol is given code-value of all ones, because 256 // will be placed in the largest codeword category. freq [256] = 1; // make sure there is a nonzero count // Huffman's basic algorithm to assign optimal code lengths to symbols while (true) { // Find the smallest nonzero frequency, set c1 = its symbol. // In case of ties, take the larger symbol number. int c1 = -1; uint32 v = 0xFFFFFFFF; for (i = 0; i <= 256; i++) { if (freq [i] && freq [i] <= v) { v = freq [i]; c1 = i; } } // Find the next smallest nonzero frequency, set c2 = its symbol. // In case of ties, take the larger symbol number. int c2 = -1; v = 0xFFFFFFFF; for (i = 0; i <= 256; i++) { if (freq [i] && freq [i] <= v && i != c1) { v = freq [i]; c2 = i; } } // Done if we've merged everything into one frequency. if (c2 < 0) break; // Else merge the two counts/trees. freq [c1] += freq [c2]; freq [c2] = 0; // Increment the codesize of everything in c1's tree branch. codesize [c1] ++; while (others [c1] >= 0) { c1 = others [c1]; codesize [c1] ++; } // chain c2 onto c1's tree branch others [c1] = (short) c2; // Increment the codesize of everything in c2's tree branch. codesize [c2] ++; while (others [c2] >= 0) { c2 = others [c2]; codesize [c2] ++; } } // Now count the number of symbols of each code length. for (i = 0; i <= 256; i++) { if (codesize [i]) { // The JPEG standard seems to think that this can't happen, // but I'm paranoid... if (codesize [i] > MAX_CLEN) { DNG_REPORT ("Huffman code size table overflow"); ThrowProgramError (); } bits [codesize [i]]++; } } // JPEG doesn't allow symbols with code lengths over 16 bits, so if the pure // Huffman procedure assigned any such lengths, we must adjust the coding. // Here is what the JPEG spec says about how this next bit works: // Since symbols are paired for the longest Huffman code, the symbols are // removed from this length category two at a time. The prefix for the pair // (which is one bit shorter) is allocated to one of the pair; then, // skipping the BITS entry for that prefix length, a code word from the next // shortest nonzero BITS entry is converted into a prefix for two code words // one bit longer. for (i = MAX_CLEN; i > 16; i--) { while (bits [i] > 0) { // Kludge: I have never been able to test this logic, and there // are comments on the web that this encoder has bugs with 16-bit // data, so just throw an error if we get here and revert to a // default table. - tknoll 12/1/03. DNG_REPORT ("Info: Optimal huffman table bigger than 16 bits"); ThrowProgramError (); // Original logic: j = i - 2; // find length of new prefix to be used while (bits [j] == 0) j--; bits [i ] -= 2; // remove two symbols bits [i - 1] ++; // one goes in this length bits [j + 1] += 2; // two new symbols in this length bits [j ] --; // symbol of this length is now a prefix } } // Remove the count for the pseudo-symbol 256 from // the largest codelength. while (bits [i] == 0) // find largest codelength still in use i--; bits [i] --; // Return final symbol counts (only for lengths 0..16). memcpy (htbl->bits, bits, sizeof (htbl->bits)); // Return a list of the symbols sorted by code length. // It's not real clear to me why we don't need to consider the codelength // changes made above, but the JPEG spec seems to think this works. int p = 0; for (i = 1; i <= MAX_CLEN; i++) { for (j = 0; j <= 255; j++) { if (codesize [j] == i) { htbl->huffval [p] = (uint8) j; p++; } } } } /*****************************************************************************/ /* *-------------------------------------------------------------- * * HuffOptimize -- * * Find the best coding parameters for a Huffman-coded scan. * When called, the scan data has already been converted to * a sequence of MCU groups of source image samples, which * are stored in a "big" array, mcuTable. * * It counts the times each category symbol occurs. Based on * this counting, optimal Huffman tables are built. Then it * uses this optimal Huffman table and counting table to find * the best PSV. * * Results: * Optimal Huffman tables are retured in cPtr->dcHuffTblPtrs[tbl]. * Best PSV is retured in cPtr->Ss. * * Side effects: * None. * *-------------------------------------------------------------- */ void dng_lossless_encoder::HuffOptimize () { // Collect the frequency counts. FreqCountSet (); // Generate Huffman encoding tables. for (uint32 channel = 0; channel < fSrcChannels; channel++) { try { GenHuffCoding (&huffTable [channel], freqCount [channel]); } catch (...) { DNG_REPORT ("Info: Reverting to default huffman table"); for (uint32 j = 0; j <= 256; j++) { freqCount [channel] [j] = (j <= 16 ? 1 : 0); } GenHuffCoding (&huffTable [channel], freqCount [channel]); } FixHuffTbl (&huffTable [channel]); } } /*****************************************************************************/ /* *-------------------------------------------------------------- * * EmitMarker -- * * Emit a marker code into the output stream. * * Results: * None. * * Side effects: * None. * *-------------------------------------------------------------- */ void dng_lossless_encoder::EmitMarker (JpegMarker mark) { EmitByte (0xFF); EmitByte ((uint8) mark); } /*****************************************************************************/ /* *-------------------------------------------------------------- * * Emit2bytes -- * * Emit a 2-byte integer; these are always MSB first in JPEG * files * * Results: * None. * * Side effects: * None. * *-------------------------------------------------------------- */ void dng_lossless_encoder::Emit2bytes (int value) { EmitByte ((value >> 8) & 0xFF); EmitByte (value & 0xFF); } /*****************************************************************************/ /* *-------------------------------------------------------------- * * EmitDht -- * * Emit a DHT marker, follwed by the huffman data. * * Results: * None * * Side effects: * None * *-------------------------------------------------------------- */ void dng_lossless_encoder::EmitDht (int index) { int i; HuffmanTable *htbl = &huffTable [index]; EmitMarker (M_DHT); int length = 0; for (i = 1; i <= 16; i++) length += htbl->bits [i]; Emit2bytes (length + 2 + 1 + 16); EmitByte ((uint8) index); for (i = 1; i <= 16; i++) EmitByte (htbl->bits [i]); for (i = 0; i < length; i++) EmitByte (htbl->huffval [i]); } /*****************************************************************************/ /* *-------------------------------------------------------------- * * EmitSof -- * * Emit a SOF marker plus data. * * Results: * None. * * Side effects: * None. * *-------------------------------------------------------------- */ void dng_lossless_encoder::EmitSof (JpegMarker code) { EmitMarker (code); Emit2bytes (3 * fSrcChannels + 2 + 5 + 1); // length EmitByte ((uint8) fSrcBitDepth); Emit2bytes (fSrcRows); Emit2bytes (fSrcCols); EmitByte ((uint8) fSrcChannels); for (uint32 i = 0; i < fSrcChannels; i++) { EmitByte ((uint8) i); EmitByte ((uint8) ((1 << 4) + 1)); // Not subsampled. EmitByte (0); // Tq shall be 0 for lossless. } } /*****************************************************************************/ /* *-------------------------------------------------------------- * * EmitSos -- * * Emit a SOS marker plus data. * * Results: * None. * * Side effects: * None. * *-------------------------------------------------------------- */ void dng_lossless_encoder::EmitSos () { EmitMarker (M_SOS); Emit2bytes (2 * fSrcChannels + 2 + 1 + 3); // length EmitByte ((uint8) fSrcChannels); // Ns for (uint32 i = 0; i < fSrcChannels; i++) { // Cs,Td,Ta EmitByte ((uint8) i); EmitByte ((uint8) (i << 4)); } EmitByte (1); // PSV - hardcoded - tknoll EmitByte (0); // Spectral selection end - Se EmitByte (0); // The point transform parameter } /*****************************************************************************/ /* *-------------------------------------------------------------- * * WriteFileHeader -- * * Write the file header. * * Results: * None. * * Side effects: * None. * *-------------------------------------------------------------- */ void dng_lossless_encoder::WriteFileHeader () { EmitMarker (M_SOI); // first the SOI EmitSof (M_SOF3); } /*****************************************************************************/ /* *-------------------------------------------------------------- * * WriteScanHeader -- * * Write the start of a scan (everything through the SOS marker). * * Results: * None. * * Side effects: * None. * *-------------------------------------------------------------- */ void dng_lossless_encoder::WriteScanHeader () { // Emit Huffman tables. for (uint32 i = 0; i < fSrcChannels; i++) { EmitDht (i); } EmitSos (); } /*****************************************************************************/ /* *-------------------------------------------------------------- * * WriteFileTrailer -- * * Write the End of image marker at the end of a JPEG file. * * Results: * None. * * Side effects: * None. * *-------------------------------------------------------------- */ void dng_lossless_encoder::WriteFileTrailer () { EmitMarker (M_EOI); } /*****************************************************************************/ void dng_lossless_encoder::Encode () { DNG_ASSERT (fSrcChannels <= 4, "Too many components in scan"); // Count the times each difference category occurs. // Construct the optimal Huffman table. HuffOptimize (); // Write the frame and scan headers. WriteFileHeader (); WriteScanHeader (); // Encode the image. HuffEncode (); // Clean up everything. WriteFileTrailer (); } /*****************************************************************************/ void EncodeLosslessJPEG (const uint16 *srcData, uint32 srcRows, uint32 srcCols, uint32 srcChannels, uint32 srcBitDepth, int32 srcRowStep, int32 srcColStep, dng_stream &stream) { dng_lossless_encoder encoder (srcData, srcRows, srcCols, srcChannels, srcBitDepth, srcRowStep, srcColStep, stream); encoder.Encode (); } /*****************************************************************************/