libopenraw
crwdecompressor.cpp
1 /*
2  * libopenraw - crwdecompressor.h
3  *
4  * Copyright (C) 2007-2008 Hubert Figuiere
5  *
6  * This library is free software: you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public License
8  * as published by the Free Software Foundation, either version 3 of
9  * the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library. If not, see
18  * <http://www.gnu.org/licenses/>.
19  */
20 /*
21  Simple reference decompresser for Canon digital cameras.
22  Outputs raw 16-bit CCD data, no header, native byte order.
23 
24  Written by Dave Coffin.
25  Downloaded from http://cybercom.net/~dcoffin/dcraw/decompress.c
26 
27  $Revision: 1.1 $
28  $Date: 2005/06/27 14:07:24 $
29 */
30 
31 #include <assert.h>
32 #include <string.h>
33 #include <libopenraw++/rawdata.h>
34 
35 #include "crwdecompressor.h"
36 #include "trace.h"
37 #include "rawcontainer.h"
38 #include "io/stream.h"
39 #include "exception.h"
40 
41 namespace OpenRaw { namespace Internals {
42 
43 CrwDecompressor::CrwDecompressor(IO::Stream * stream,
44  RawContainer * container)
45  : Decompressor(stream, container),
46  m_table(0),
47  m_height(0), m_width(0),
48  m_free(0), m_leaf(0),
49  m_bitbuf(0), m_vbits(0)
50 {
51 }
52 
53 
54 CrwDecompressor::~CrwDecompressor()
55 {
56 }
57 
58 
59 /*
60  A rough description of Canon's compression algorithm:
61 
62  + Each pixel outputs a 10-bit sample, from 0 to 1023.
63  + Split the data into blocks of 64 samples each.
64  + Subtract from each sample the value of the sample two positions
65  to the left, which has the same color filter. From the two
66  leftmost samples in each row, subtract 512.
67  + For each nonzero sample, make a token consisting of two four-bit
68  numbers. The low nibble is the number of bits required to
69  represent the sample, and the high nibble is the number of
70  zero samples preceding this sample.
71  + Output this token as a variable-length bitstring using
72  one of three tablesets. Follow it with a fixed-length
73  bitstring containing the sample.
74 
75  The "first_decode" table is used for the first sample in each
76  block, and the "second_decode" table is used for the others.
77 */
78 
79 /*
80  Construct a decode tree according the specification in *source.
81  The first 16 bytes specify how many codes should be 1-bit, 2-bit
82  3-bit, etc. Bytes after that are the leaf values.
83 
84  For example, if the source is
85 
86  { 0,1,4,2,3,1,2,0,0,0,0,0,0,0,0,0,
87  0x04,0x03,0x05,0x06,0x02,0x07,0x01,0x08,0x09,0x00,0x0a,0x0b,0xff },
88 
89  then the code is
90 
91  00 0x04
92  010 0x03
93  011 0x05
94  100 0x06
95  101 0x02
96  1100 0x07
97  1101 0x01
98  11100 0x08
99  11101 0x09
100  11110 0x00
101  111110 0x0a
102  1111110 0x0b
103  1111111 0xff
104 */
105 void CrwDecompressor::make_decoder(decode_t *dest, const uint8_t *source,
106  int level)
107 {
108  int i, next;
109 
110  if (level==0) {
111  m_free = dest;
112  m_leaf = 0;
113  }
114  m_free++;
115 /*
116  At what level should the next leaf appear?
117 */
118  for (i=next=0; i <= m_leaf && next < 16; ) {
119  i += source[next++];
120  }
121 
122  if (i > m_leaf) {
123  if (level < next) { /* Are we there yet? */
124  dest->branch[0] = m_free;
125  make_decoder(m_free,source,level+1);
126  dest->branch[1] = m_free;
127  make_decoder(m_free,source,level+1);
128  }
129  else {
130  dest->leaf = source[16 + m_leaf++];
131  }
132  }
133 }
134 
135 void CrwDecompressor::init_tables(uint32_t table_idx)
136 {
137  static const uint8_t first_tree[3][29] = {
138  { 0,1,4,2,3,1,2,0,0,0,0,0,0,0,0,0,
139  0x04,0x03,0x05,0x06,0x02,0x07,0x01,0x08,0x09,0x00,0x0a,0x0b,0xff },
140 
141  { 0,2,2,3,1,1,1,1,2,0,0,0,0,0,0,0,
142  0x03,0x02,0x04,0x01,0x05,0x00,0x06,0x07,0x09,0x08,0x0a,0x0b,0xff },
143 
144  { 0,0,6,3,1,1,2,0,0,0,0,0,0,0,0,0,
145  0x06,0x05,0x07,0x04,0x08,0x03,0x09,0x02,0x00,0x0a,0x01,0x0b,0xff },
146  };
147 
148  static const uint8_t second_tree[3][180] = {
149  { 0,2,2,2,1,4,2,1,2,5,1,1,0,0,0,139,
150  0x03,0x04,0x02,0x05,0x01,0x06,0x07,0x08,
151  0x12,0x13,0x11,0x14,0x09,0x15,0x22,0x00,0x21,0x16,0x0a,0xf0,
152  0x23,0x17,0x24,0x31,0x32,0x18,0x19,0x33,0x25,0x41,0x34,0x42,
153  0x35,0x51,0x36,0x37,0x38,0x29,0x79,0x26,0x1a,0x39,0x56,0x57,
154  0x28,0x27,0x52,0x55,0x58,0x43,0x76,0x59,0x77,0x54,0x61,0xf9,
155  0x71,0x78,0x75,0x96,0x97,0x49,0xb7,0x53,0xd7,0x74,0xb6,0x98,
156  0x47,0x48,0x95,0x69,0x99,0x91,0xfa,0xb8,0x68,0xb5,0xb9,0xd6,
157  0xf7,0xd8,0x67,0x46,0x45,0x94,0x89,0xf8,0x81,0xd5,0xf6,0xb4,
158  0x88,0xb1,0x2a,0x44,0x72,0xd9,0x87,0x66,0xd4,0xf5,0x3a,0xa7,
159  0x73,0xa9,0xa8,0x86,0x62,0xc7,0x65,0xc8,0xc9,0xa1,0xf4,0xd1,
160  0xe9,0x5a,0x92,0x85,0xa6,0xe7,0x93,0xe8,0xc1,0xc6,0x7a,0x64,
161  0xe1,0x4a,0x6a,0xe6,0xb3,0xf1,0xd3,0xa5,0x8a,0xb2,0x9a,0xba,
162  0x84,0xa4,0x63,0xe5,0xc5,0xf3,0xd2,0xc4,0x82,0xaa,0xda,0xe4,
163  0xf2,0xca,0x83,0xa3,0xa2,0xc3,0xea,0xc2,0xe2,0xe3,0xff,0xff },
164 
165  { 0,2,2,1,4,1,4,1,3,3,1,0,0,0,0,140,
166  0x02,0x03,0x01,0x04,0x05,0x12,0x11,0x06,
167  0x13,0x07,0x08,0x14,0x22,0x09,0x21,0x00,0x23,0x15,0x31,0x32,
168  0x0a,0x16,0xf0,0x24,0x33,0x41,0x42,0x19,0x17,0x25,0x18,0x51,
169  0x34,0x43,0x52,0x29,0x35,0x61,0x39,0x71,0x62,0x36,0x53,0x26,
170  0x38,0x1a,0x37,0x81,0x27,0x91,0x79,0x55,0x45,0x28,0x72,0x59,
171  0xa1,0xb1,0x44,0x69,0x54,0x58,0xd1,0xfa,0x57,0xe1,0xf1,0xb9,
172  0x49,0x47,0x63,0x6a,0xf9,0x56,0x46,0xa8,0x2a,0x4a,0x78,0x99,
173  0x3a,0x75,0x74,0x86,0x65,0xc1,0x76,0xb6,0x96,0xd6,0x89,0x85,
174  0xc9,0xf5,0x95,0xb4,0xc7,0xf7,0x8a,0x97,0xb8,0x73,0xb7,0xd8,
175  0xd9,0x87,0xa7,0x7a,0x48,0x82,0x84,0xea,0xf4,0xa6,0xc5,0x5a,
176  0x94,0xa4,0xc6,0x92,0xc3,0x68,0xb5,0xc8,0xe4,0xe5,0xe6,0xe9,
177  0xa2,0xa3,0xe3,0xc2,0x66,0x67,0x93,0xaa,0xd4,0xd5,0xe7,0xf8,
178  0x88,0x9a,0xd7,0x77,0xc4,0x64,0xe2,0x98,0xa5,0xca,0xda,0xe8,
179  0xf3,0xf6,0xa9,0xb2,0xb3,0xf2,0xd2,0x83,0xba,0xd3,0xff,0xff },
180 
181  { 0,0,6,2,1,3,3,2,5,1,2,2,8,10,0,117,
182  0x04,0x05,0x03,0x06,0x02,0x07,0x01,0x08,
183  0x09,0x12,0x13,0x14,0x11,0x15,0x0a,0x16,0x17,0xf0,0x00,0x22,
184  0x21,0x18,0x23,0x19,0x24,0x32,0x31,0x25,0x33,0x38,0x37,0x34,
185  0x35,0x36,0x39,0x79,0x57,0x58,0x59,0x28,0x56,0x78,0x27,0x41,
186  0x29,0x77,0x26,0x42,0x76,0x99,0x1a,0x55,0x98,0x97,0xf9,0x48,
187  0x54,0x96,0x89,0x47,0xb7,0x49,0xfa,0x75,0x68,0xb6,0x67,0x69,
188  0xb9,0xb8,0xd8,0x52,0xd7,0x88,0xb5,0x74,0x51,0x46,0xd9,0xf8,
189  0x3a,0xd6,0x87,0x45,0x7a,0x95,0xd5,0xf6,0x86,0xb4,0xa9,0x94,
190  0x53,0x2a,0xa8,0x43,0xf5,0xf7,0xd4,0x66,0xa7,0x5a,0x44,0x8a,
191  0xc9,0xe8,0xc8,0xe7,0x9a,0x6a,0x73,0x4a,0x61,0xc7,0xf4,0xc6,
192  0x65,0xe9,0x72,0xe6,0x71,0x91,0x93,0xa6,0xda,0x92,0x85,0x62,
193  0xf3,0xc5,0xb2,0xa4,0x84,0xba,0x64,0xa5,0xb3,0xd2,0x81,0xe5,
194  0xd3,0xaa,0xc4,0xca,0xf2,0xb1,0xe4,0xd1,0x83,0x63,0xea,0xc3,
195  0xe2,0x82,0xf1,0xa3,0xc2,0xa1,0xc1,0xe3,0xa2,0xe1,0xff,0xff }
196  };
197 
198  if (table_idx > 2)
199  table_idx = 2;
200  memset( m_first_decode, 0, sizeof(m_first_decode));
201  memset(m_second_decode, 0, sizeof(m_second_decode));
202  make_decoder(m_first_decode, first_tree[table_idx], 0);
203  make_decoder(m_second_decode, second_tree[table_idx], 0);
204 }
205 
206 /*
207  getbits(-1) initializes the buffer
208  getbits(n) where 0 <= n <= 25 returns an n-bit integer
209 */
210 uint32_t CrwDecompressor::getbits(IO::Stream * s, int nbits)
211 {
212  uint32_t ret = 0;
213  uint8_t c;
214 
215  if (nbits == 0)
216  return 0;
217  if (nbits == -1)
218  ret = m_bitbuf = m_vbits = 0;
219  else {
220  ret = m_bitbuf << (32 - m_vbits) >> (32 - nbits);
221  m_vbits -= nbits;
222  }
223  while (m_vbits < 25) {
224  try {
225  c = s->readByte();
226  m_bitbuf = (m_bitbuf << 8) + c;
227  if (c == 0xff)
228  s->readByte(); /* always extra 00 after ff */
229  m_vbits += 8;
230  }
231  catch(const Internals::IOException &)
232  {
233  break;
234  }
235  }
236  return ret;
237 }
238 
239 namespace {
240 
241 static
242 int canon_has_lowbits(IO::Stream * s)
243 {
244  uint8_t test[0x4000 - 26];
245  int ret=1;
246  uint32_t i;
247 
248  s->seek (0, SEEK_SET);
249  s->read (test, sizeof(test));
250  for (i=514; i < sizeof(test) - 1; i++)
251  if (test[i] == 0xff) {
252  if (test[i+1])
253  return 1;
254  ret=0;
255  }
256  return ret;
257 }
258 
259 }
260 
261 
262 // int oldmain(int argc, char **argv)
264 {
265  decode_t *decode, *dindex;
266  int i, j, leaf, len, diff, diffbuf[64], r, save;
267  int carry=0, base[2];
268  uint32_t column = 0;
269  uint16_t outbuf[64];
270  uint8_t c;
271 
272  RawData *bitmap;
273  if(in == NULL)
274  bitmap = new RawData();
275  else
276  bitmap = in;
277  bitmap->setDataType(OR_DATA_TYPE_CFA);
278  // we know the 10-bits are hardcoded in the CRW
279  bitmap->setBpc(10);
280  bitmap->setMax((1 << 10) - 1);
281  uint8_t *rawbuf = (uint8_t*)bitmap->allocData(m_width
282  * sizeof(uint16_t)
283  * m_height);
284  bitmap->setDimensions(m_width,
285  m_height);
286 
287  init_tables(m_table);
288 
289  int lowbits = canon_has_lowbits(m_stream);
290  Debug::Trace(DEBUG2) << "lowbits = " << lowbits
291  << " height = " << m_height
292  << " width = " << m_width
293  << "\n";
294  m_stream->seek(514 + lowbits*m_height*m_width/4, SEEK_SET);
295  getbits(m_stream, -1); /* Prime the bit buffer */
296 
297  while (column < m_width * m_height) {
298  memset(diffbuf,0,sizeof(diffbuf));
299  decode = m_first_decode;
300  for (i=0; i < 64; i++ ) {
301 
302  for (dindex=decode; dindex->branch[0]; )
303  dindex = dindex->branch[getbits(m_stream, 1)];
304  leaf = dindex->leaf;
305  decode = m_second_decode;
306 
307  if (leaf == 0 && i)
308  break;
309  if (leaf == 0xff)
310  continue;
311  i += leaf >> 4;
312  len = leaf & 15;
313  if (len == 0)
314  continue;
315  diff = getbits(m_stream, len);
316  if ((diff & (1 << (len-1))) == 0)
317  diff -= (1 << len) - 1;
318  if (i < 64)
319  diffbuf[i] = diff;
320  }
321  diffbuf[0] += carry;
322  carry = diffbuf[0];
323  for (i=0; i < 64; i++ ) {
324  if (column++ % m_width == 0)
325  base[0] = base[1] = 512;
326  outbuf[i] = ( base[i & 1] += diffbuf[i] );
327  }
328  if (lowbits) {
329  save = m_stream->seek(0, SEEK_CUR);
330  m_stream->seek((column-64)/4, SEEK_SET);
331  for (i=j=0; j < 64/4; j++ ) {
332  c = m_stream->readByte();
333  for (r = 0; r < 8; r += 2) {
334  outbuf[i] = (outbuf[i+1] << 2) + ((c >> r) & 3);
335  i++;
336  }
337  }
338  m_stream->seek(save, SEEK_SET);
339  }
340  memcpy(rawbuf, outbuf, 2 * 64);
341  rawbuf += 2 * 64;
342  }
343  return bitmap;
344 }
345 
346 
347 
348 } }
349 
350 /*
351  Local Variables:
352  mode:c++
353  c-file-style:"stroustrup"
354  c-file-offsets:((innamespace . 0))
355  indent-tabs-mode:nil
356  fill-column:80
357  End:
358 */
CIFF is the container for CRW files. It is an attempt from Canon to make this a standard. I guess it failed.
Definition: arwfile.cpp:33
virtual RawData * decompress(RawData *in=NULL)
virtual void setDimensions(uint32_t x, uint32_t y)
Definition: rawdata.cpp:132
void setBpc(uint32_t _bpc)
Definition: bitmapdata.cpp:154
virtual int seek(off_t offset, int whence)=0
void setDataType(DataType _type)
Definition: bitmapdata.cpp:92