libopenraw
|
00001 /* 00002 * libopenraw - crwdecompressor.h 00003 * 00004 * Copyright (C) 2007-2008 Hubert Figuiere 00005 * 00006 * This library is free software: you can redistribute it and/or 00007 * modify it under the terms of the GNU Lesser General Public License 00008 * as published by the Free Software Foundation, either version 3 of 00009 * the License, or (at your option) any later version. 00010 * 00011 * This library is distributed in the hope that it will be useful, 00012 * but WITHOUT ANY WARRANTY; without even the implied warranty of 00013 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 00014 * Lesser General Public License for more details. 00015 * 00016 * You should have received a copy of the GNU Lesser General Public 00017 * License along with this library. If not, see 00018 * <http://www.gnu.org/licenses/>. 00019 */ 00020 /* 00021 Simple reference decompresser for Canon digital cameras. 00022 Outputs raw 16-bit CCD data, no header, native byte order. 00023 00024 Written by Dave Coffin. 00025 Downloaded from http://cybercom.net/~dcoffin/dcraw/decompress.c 00026 00027 $Revision: 1.1 $ 00028 $Date: 2005/06/27 14:07:24 $ 00029 */ 00030 00031 #include <assert.h> 00032 #include <string.h> 00033 #include <libopenraw++/rawdata.h> 00034 00035 #include "crwdecompressor.h" 00036 #include "debug.h" 00037 #include "rawcontainer.h" 00038 #include "io/stream.h" 00039 #include "exception.h" 00040 00041 namespace OpenRaw { namespace Internals { 00042 00043 CrwDecompressor::CrwDecompressor(IO::Stream * stream, 00044 RawContainer * container) 00045 : Decompressor(stream, container), 00046 m_table(0), 00047 m_height(0), m_width(0), 00048 m_free(0), m_leaf(0), 00049 m_bitbuf(0), m_vbits(0) 00050 { 00051 } 00052 00053 00054 CrwDecompressor::~CrwDecompressor() 00055 { 00056 } 00057 00058 00059 /* 00060 A rough description of Canon's compression algorithm: 00061 00062 + Each pixel outputs a 10-bit sample, from 0 to 1023. 00063 + Split the data into blocks of 64 samples each. 00064 + Subtract from each sample the value of the sample two positions 00065 to the left, which has the same color filter. From the two 00066 leftmost samples in each row, subtract 512. 00067 + For each nonzero sample, make a token consisting of two four-bit 00068 numbers. The low nibble is the number of bits required to 00069 represent the sample, and the high nibble is the number of 00070 zero samples preceding this sample. 00071 + Output this token as a variable-length bitstring using 00072 one of three tablesets. Follow it with a fixed-length 00073 bitstring containing the sample. 00074 00075 The "first_decode" table is used for the first sample in each 00076 block, and the "second_decode" table is used for the others. 00077 */ 00078 00079 /* 00080 Construct a decode tree according the specification in *source. 00081 The first 16 bytes specify how many codes should be 1-bit, 2-bit 00082 3-bit, etc. Bytes after that are the leaf values. 00083 00084 For example, if the source is 00085 00086 { 0,1,4,2,3,1,2,0,0,0,0,0,0,0,0,0, 00087 0x04,0x03,0x05,0x06,0x02,0x07,0x01,0x08,0x09,0x00,0x0a,0x0b,0xff }, 00088 00089 then the code is 00090 00091 00 0x04 00092 010 0x03 00093 011 0x05 00094 100 0x06 00095 101 0x02 00096 1100 0x07 00097 1101 0x01 00098 11100 0x08 00099 11101 0x09 00100 11110 0x00 00101 111110 0x0a 00102 1111110 0x0b 00103 1111111 0xff 00104 */ 00105 void CrwDecompressor::make_decoder(decode_t *dest, const uint8_t *source, 00106 int level) 00107 { 00108 int i, next; 00109 00110 if (level==0) { 00111 m_free = dest; 00112 m_leaf = 0; 00113 } 00114 m_free++; 00115 /* 00116 At what level should the next leaf appear? 00117 */ 00118 for (i=next=0; i <= m_leaf && next < 16; ) { 00119 i += source[next++]; 00120 } 00121 00122 if (i > m_leaf) { 00123 if (level < next) { /* Are we there yet? */ 00124 dest->branch[0] = m_free; 00125 make_decoder(m_free,source,level+1); 00126 dest->branch[1] = m_free; 00127 make_decoder(m_free,source,level+1); 00128 } 00129 else { 00130 dest->leaf = source[16 + m_leaf++]; 00131 } 00132 } 00133 } 00134 00135 void CrwDecompressor::init_tables(uint32_t table_idx) 00136 { 00137 static const uint8_t first_tree[3][29] = { 00138 { 0,1,4,2,3,1,2,0,0,0,0,0,0,0,0,0, 00139 0x04,0x03,0x05,0x06,0x02,0x07,0x01,0x08,0x09,0x00,0x0a,0x0b,0xff }, 00140 00141 { 0,2,2,3,1,1,1,1,2,0,0,0,0,0,0,0, 00142 0x03,0x02,0x04,0x01,0x05,0x00,0x06,0x07,0x09,0x08,0x0a,0x0b,0xff }, 00143 00144 { 0,0,6,3,1,1,2,0,0,0,0,0,0,0,0,0, 00145 0x06,0x05,0x07,0x04,0x08,0x03,0x09,0x02,0x00,0x0a,0x01,0x0b,0xff }, 00146 }; 00147 00148 static const uint8_t second_tree[3][180] = { 00149 { 0,2,2,2,1,4,2,1,2,5,1,1,0,0,0,139, 00150 0x03,0x04,0x02,0x05,0x01,0x06,0x07,0x08, 00151 0x12,0x13,0x11,0x14,0x09,0x15,0x22,0x00,0x21,0x16,0x0a,0xf0, 00152 0x23,0x17,0x24,0x31,0x32,0x18,0x19,0x33,0x25,0x41,0x34,0x42, 00153 0x35,0x51,0x36,0x37,0x38,0x29,0x79,0x26,0x1a,0x39,0x56,0x57, 00154 0x28,0x27,0x52,0x55,0x58,0x43,0x76,0x59,0x77,0x54,0x61,0xf9, 00155 0x71,0x78,0x75,0x96,0x97,0x49,0xb7,0x53,0xd7,0x74,0xb6,0x98, 00156 0x47,0x48,0x95,0x69,0x99,0x91,0xfa,0xb8,0x68,0xb5,0xb9,0xd6, 00157 0xf7,0xd8,0x67,0x46,0x45,0x94,0x89,0xf8,0x81,0xd5,0xf6,0xb4, 00158 0x88,0xb1,0x2a,0x44,0x72,0xd9,0x87,0x66,0xd4,0xf5,0x3a,0xa7, 00159 0x73,0xa9,0xa8,0x86,0x62,0xc7,0x65,0xc8,0xc9,0xa1,0xf4,0xd1, 00160 0xe9,0x5a,0x92,0x85,0xa6,0xe7,0x93,0xe8,0xc1,0xc6,0x7a,0x64, 00161 0xe1,0x4a,0x6a,0xe6,0xb3,0xf1,0xd3,0xa5,0x8a,0xb2,0x9a,0xba, 00162 0x84,0xa4,0x63,0xe5,0xc5,0xf3,0xd2,0xc4,0x82,0xaa,0xda,0xe4, 00163 0xf2,0xca,0x83,0xa3,0xa2,0xc3,0xea,0xc2,0xe2,0xe3,0xff,0xff }, 00164 00165 { 0,2,2,1,4,1,4,1,3,3,1,0,0,0,0,140, 00166 0x02,0x03,0x01,0x04,0x05,0x12,0x11,0x06, 00167 0x13,0x07,0x08,0x14,0x22,0x09,0x21,0x00,0x23,0x15,0x31,0x32, 00168 0x0a,0x16,0xf0,0x24,0x33,0x41,0x42,0x19,0x17,0x25,0x18,0x51, 00169 0x34,0x43,0x52,0x29,0x35,0x61,0x39,0x71,0x62,0x36,0x53,0x26, 00170 0x38,0x1a,0x37,0x81,0x27,0x91,0x79,0x55,0x45,0x28,0x72,0x59, 00171 0xa1,0xb1,0x44,0x69,0x54,0x58,0xd1,0xfa,0x57,0xe1,0xf1,0xb9, 00172 0x49,0x47,0x63,0x6a,0xf9,0x56,0x46,0xa8,0x2a,0x4a,0x78,0x99, 00173 0x3a,0x75,0x74,0x86,0x65,0xc1,0x76,0xb6,0x96,0xd6,0x89,0x85, 00174 0xc9,0xf5,0x95,0xb4,0xc7,0xf7,0x8a,0x97,0xb8,0x73,0xb7,0xd8, 00175 0xd9,0x87,0xa7,0x7a,0x48,0x82,0x84,0xea,0xf4,0xa6,0xc5,0x5a, 00176 0x94,0xa4,0xc6,0x92,0xc3,0x68,0xb5,0xc8,0xe4,0xe5,0xe6,0xe9, 00177 0xa2,0xa3,0xe3,0xc2,0x66,0x67,0x93,0xaa,0xd4,0xd5,0xe7,0xf8, 00178 0x88,0x9a,0xd7,0x77,0xc4,0x64,0xe2,0x98,0xa5,0xca,0xda,0xe8, 00179 0xf3,0xf6,0xa9,0xb2,0xb3,0xf2,0xd2,0x83,0xba,0xd3,0xff,0xff }, 00180 00181 { 0,0,6,2,1,3,3,2,5,1,2,2,8,10,0,117, 00182 0x04,0x05,0x03,0x06,0x02,0x07,0x01,0x08, 00183 0x09,0x12,0x13,0x14,0x11,0x15,0x0a,0x16,0x17,0xf0,0x00,0x22, 00184 0x21,0x18,0x23,0x19,0x24,0x32,0x31,0x25,0x33,0x38,0x37,0x34, 00185 0x35,0x36,0x39,0x79,0x57,0x58,0x59,0x28,0x56,0x78,0x27,0x41, 00186 0x29,0x77,0x26,0x42,0x76,0x99,0x1a,0x55,0x98,0x97,0xf9,0x48, 00187 0x54,0x96,0x89,0x47,0xb7,0x49,0xfa,0x75,0x68,0xb6,0x67,0x69, 00188 0xb9,0xb8,0xd8,0x52,0xd7,0x88,0xb5,0x74,0x51,0x46,0xd9,0xf8, 00189 0x3a,0xd6,0x87,0x45,0x7a,0x95,0xd5,0xf6,0x86,0xb4,0xa9,0x94, 00190 0x53,0x2a,0xa8,0x43,0xf5,0xf7,0xd4,0x66,0xa7,0x5a,0x44,0x8a, 00191 0xc9,0xe8,0xc8,0xe7,0x9a,0x6a,0x73,0x4a,0x61,0xc7,0xf4,0xc6, 00192 0x65,0xe9,0x72,0xe6,0x71,0x91,0x93,0xa6,0xda,0x92,0x85,0x62, 00193 0xf3,0xc5,0xb2,0xa4,0x84,0xba,0x64,0xa5,0xb3,0xd2,0x81,0xe5, 00194 0xd3,0xaa,0xc4,0xca,0xf2,0xb1,0xe4,0xd1,0x83,0x63,0xea,0xc3, 00195 0xe2,0x82,0xf1,0xa3,0xc2,0xa1,0xc1,0xe3,0xa2,0xe1,0xff,0xff } 00196 }; 00197 00198 if (table_idx > 2) 00199 table_idx = 2; 00200 memset( m_first_decode, 0, sizeof(m_first_decode)); 00201 memset(m_second_decode, 0, sizeof(m_second_decode)); 00202 make_decoder(m_first_decode, first_tree[table_idx], 0); 00203 make_decoder(m_second_decode, second_tree[table_idx], 0); 00204 } 00205 00206 /* 00207 getbits(-1) initializes the buffer 00208 getbits(n) where 0 <= n <= 25 returns an n-bit integer 00209 */ 00210 uint32_t CrwDecompressor::getbits(IO::Stream * s, int nbits) 00211 { 00212 uint32_t ret = 0; 00213 uint8_t c; 00214 00215 if (nbits == 0) 00216 return 0; 00217 if (nbits == -1) 00218 ret = m_bitbuf = m_vbits = 0; 00219 else { 00220 ret = m_bitbuf << (32 - m_vbits) >> (32 - nbits); 00221 m_vbits -= nbits; 00222 } 00223 while (m_vbits < 25) { 00224 try { 00225 c = s->readByte(); 00226 m_bitbuf = (m_bitbuf << 8) + c; 00227 if (c == 0xff) 00228 s->readByte(); /* always extra 00 after ff */ 00229 m_vbits += 8; 00230 } 00231 catch(const Internals::IOException &) 00232 { 00233 break; 00234 } 00235 } 00236 return ret; 00237 } 00238 00239 namespace { 00240 00241 static 00242 int canon_has_lowbits(IO::Stream * s) 00243 { 00244 uint8_t test[0x4000 - 26]; 00245 int ret=1; 00246 uint32_t i; 00247 00248 s->seek (0, SEEK_SET); 00249 s->read (test, sizeof(test)); 00250 for (i=514; i < sizeof(test) - 1; i++) 00251 if (test[i] == 0xff) { 00252 if (test[i+1]) 00253 return 1; 00254 ret=0; 00255 } 00256 return ret; 00257 } 00258 00259 } 00260 00261 00262 // int oldmain(int argc, char **argv) 00263 RawData *CrwDecompressor::decompress(RawData *in) 00264 { 00265 decode_t *decode, *dindex; 00266 int i, j, leaf, len, diff, diffbuf[64], r, save; 00267 int carry=0, base[2]; 00268 uint32_t column = 0; 00269 uint16_t outbuf[64]; 00270 uint8_t c; 00271 00272 RawData *bitmap; 00273 if(in == NULL) 00274 bitmap = new RawData(); 00275 else 00276 bitmap = in; 00277 bitmap->setDataType(OR_DATA_TYPE_CFA); 00278 // we know the 10-bits are hardcoded in the CRW 00279 bitmap->setBpc(10); 00280 bitmap->setMax((1 << 10) - 1); 00281 uint8_t *rawbuf = (uint8_t*)bitmap->allocData(m_width 00282 * sizeof(uint16_t) 00283 * m_height); 00284 bitmap->setDimensions(m_width, 00285 m_height); 00286 00287 init_tables(m_table); 00288 00289 int lowbits = canon_has_lowbits(m_stream); 00290 Debug::Trace(DEBUG2) << "lowbits = " << lowbits 00291 << " height = " << m_height 00292 << " width = " << m_width 00293 << "\n"; 00294 m_stream->seek(514 + lowbits*m_height*m_width/4, SEEK_SET); 00295 getbits(m_stream, -1); /* Prime the bit buffer */ 00296 00297 while (column < m_width * m_height) { 00298 memset(diffbuf,0,sizeof(diffbuf)); 00299 decode = m_first_decode; 00300 for (i=0; i < 64; i++ ) { 00301 00302 for (dindex=decode; dindex->branch[0]; ) 00303 dindex = dindex->branch[getbits(m_stream, 1)]; 00304 leaf = dindex->leaf; 00305 decode = m_second_decode; 00306 00307 if (leaf == 0 && i) 00308 break; 00309 if (leaf == 0xff) 00310 continue; 00311 i += leaf >> 4; 00312 len = leaf & 15; 00313 if (len == 0) 00314 continue; 00315 diff = getbits(m_stream, len); 00316 if ((diff & (1 << (len-1))) == 0) 00317 diff -= (1 << len) - 1; 00318 if (i < 64) 00319 diffbuf[i] = diff; 00320 } 00321 diffbuf[0] += carry; 00322 carry = diffbuf[0]; 00323 for (i=0; i < 64; i++ ) { 00324 if (column++ % m_width == 0) 00325 base[0] = base[1] = 512; 00326 outbuf[i] = ( base[i & 1] += diffbuf[i] ); 00327 } 00328 if (lowbits) { 00329 save = m_stream->seek(0, SEEK_CUR); 00330 m_stream->seek((column-64)/4, SEEK_SET); 00331 for (i=j=0; j < 64/4; j++ ) { 00332 c = m_stream->readByte(); 00333 for (r = 0; r < 8; r += 2) { 00334 outbuf[i] = (outbuf[i+1] << 2) + ((c >> r) & 3); 00335 i++; 00336 } 00337 } 00338 m_stream->seek(save, SEEK_SET); 00339 } 00340 memcpy(rawbuf, outbuf, 2 * 64); 00341 rawbuf += 2 * 64; 00342 } 00343 return bitmap; 00344 } 00345 00346 00347 00348 } } 00349 00350 /* 00351 Local Variables: 00352 mode:c++ 00353 c-file-style:"stroustrup" 00354 c-file-offsets:((innamespace . 0)) 00355 indent-tabs-mode:nil 00356 fill-column:80 00357 End: 00358 */