source: trunk/libdjvu/MMRDecoder.cpp @ 209

Last change on this file since 209 was 206, checked in by Eugene Romanenko, 14 years ago

DJVU plugin: djvulibre updated to version 3.5.19

File size: 26.6 KB
Line 
1//C-  -*- C++ -*-
2//C- -------------------------------------------------------------------
3//C- DjVuLibre-3.5
4//C- Copyright (c) 2002  Leon Bottou and Yann Le Cun.
5//C- Copyright (c) 2001  AT&T
6//C-
7//C- This software is subject to, and may be distributed under, the
8//C- GNU General Public License, either Version 2 of the license,
9//C- or (at your option) any later version. The license should have
10//C- accompanied the software or you may obtain a copy of the license
11//C- from the Free Software Foundation at http://www.fsf.org .
12//C-
13//C- This program is distributed in the hope that it will be useful,
14//C- but WITHOUT ANY WARRANTY; without even the implied warranty of
15//C- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16//C- GNU General Public License for more details.
17//C-
18//C- DjVuLibre-3.5 is derived from the DjVu(r) Reference Library from
19//C- Lizardtech Software.  Lizardtech Software has authorized us to
20//C- replace the original DjVu(r) Reference Library notice by the following
21//C- text (see doc/lizard2002.djvu and doc/lizardtech2007.djvu):
22//C-
23//C-  ------------------------------------------------------------------
24//C- | DjVu (r) Reference Library (v. 3.5)
25//C- | Copyright (c) 1999-2001 LizardTech, Inc. All Rights Reserved.
26//C- | The DjVu Reference Library is protected by U.S. Pat. No.
27//C- | 6,058,214 and patents pending.
28//C- |
29//C- | This software is subject to, and may be distributed under, the
30//C- | GNU General Public License, either Version 2 of the license,
31//C- | or (at your option) any later version. The license should have
32//C- | accompanied the software or you may obtain a copy of the license
33//C- | from the Free Software Foundation at http://www.fsf.org .
34//C- |
35//C- | The computer code originally released by LizardTech under this
36//C- | license and unmodified by other parties is deemed "the LIZARDTECH
37//C- | ORIGINAL CODE."  Subject to any third party intellectual property
38//C- | claims, LizardTech grants recipient a worldwide, royalty-free,
39//C- | non-exclusive license to make, use, sell, or otherwise dispose of
40//C- | the LIZARDTECH ORIGINAL CODE or of programs derived from the
41//C- | LIZARDTECH ORIGINAL CODE in compliance with the terms of the GNU
42//C- | General Public License.   This grant only confers the right to
43//C- | infringe patent claims underlying the LIZARDTECH ORIGINAL CODE to
44//C- | the extent such infringement is reasonably necessary to enable
45//C- | recipient to make, have made, practice, sell, or otherwise dispose
46//C- | of the LIZARDTECH ORIGINAL CODE (or portions thereof) and not to
47//C- | any greater extent that may be necessary to utilize further
48//C- | modifications or combinations.
49//C- |
50//C- | The LIZARDTECH ORIGINAL CODE is provided "AS IS" WITHOUT WARRANTY
51//C- | OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
52//C- | TO ANY WARRANTY OF NON-INFRINGEMENT, OR ANY IMPLIED WARRANTY OF
53//C- | MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
54//C- +------------------------------------------------------------------
55//
56// $Id: MMRDecoder.cpp,v 1.9 2007/03/25 20:48:32 leonb Exp $
57// $Name: release_3_5_19 $
58
59#ifdef HAVE_CONFIG_H
60# include "config.h"
61#endif
62#if NEED_GNUG_PRAGMAS
63# pragma implementation
64#endif
65
66#include "MMRDecoder.h"
67#include "JB2Image.h"
68#include "ByteStream.h"
69#include "GBitmap.h"
70
71
72#ifdef HAVE_NAMESPACES
73namespace DJVU {
74# ifdef NOT_DEFINED // Just to fool emacs c++ mode
75}
76#endif
77#endif
78
79
80// ----------------------------------------
81// MMR CODEBOOKS
82
83static const char invalid_mmr_data[]= ERR_MSG("MMRDecoder.bad_data");
84
85struct VLCode
86{
87  unsigned short code;
88  short codelen;
89  short value;
90};
91
92enum MMRMode
93{ 
94  P=0, H=1, V0=2, VR1=3, VR2=4, VR3=5, VL1=6, VL2=7, VL3=8 
95};
96
97static const VLCode mrcodes[] =
98{   // Codes on 7 bits
99  // 7 bit codes
100  { 0x08,   4,    P }, // 0001
101  { 0x10,   3,    H }, // 001
102  { 0x40,   1,   V0 }, // 1
103  { 0x30,   3,  VR1 }, // 011
104  { 0x06,   6,  VR2 }, // 000011
105  { 0x03,   7,  VR3 }, // 0000011
106  { 0x20,   3,  VL1 }, // 010
107  { 0x04,   6,  VL2 }, // 000010
108  { 0x02,   7,  VL3 }, // 0000010
109  { 0x00,   0,   -1 }  // Illegal entry
110};
111
112
113static const VLCode wcodes[] = {   
114  // 13 bit codes
115  { 0x06a0,  8,    0 }, // 00110101
116  { 0x0380,  6,    1 }, // 000111
117  { 0x0e00,  4,    2 }, // 0111
118  { 0x1000,  4,    3 }, // 1000
119  { 0x1600,  4,    4 }, // 1011
120  { 0x1800,  4,    5 }, // 1100
121  { 0x1c00,  4,    6 }, // 1110
122  { 0x1e00,  4,    7 }, // 1111
123  { 0x1300,  5,    8 }, // 10011
124  { 0x1400,  5,    9 }, // 10100
125  { 0x0700,  5,   10 }, // 00111
126  { 0x0800,  5,   11 }, // 01000
127  { 0x0400,  6,   12 }, // 001000
128  { 0x0180,  6,   13 }, // 000011
129  { 0x1a00,  6,   14 }, // 110100
130  { 0x1a80,  6,   15 }, // 110101
131  { 0x1500,  6,   16 }, // 101010
132  { 0x1580,  6,   17 }, // 101011
133  { 0x09c0,  7,   18 }, // 0100111
134  { 0x0300,  7,   19 }, // 0001100
135  { 0x0200,  7,   20 }, // 0001000
136  { 0x05c0,  7,   21 }, // 0010111
137  { 0x00c0,  7,   22 }, // 0000011
138  { 0x0100,  7,   23 }, // 0000100
139  { 0x0a00,  7,   24 }, // 0101000
140  { 0x0ac0,  7,   25 }, // 0101011
141  { 0x04c0,  7,   26 }, // 0010011
142  { 0x0900,  7,   27 }, // 0100100
143  { 0x0600,  7,   28 }, // 0011000
144  { 0x0040,  8,   29 }, // 00000010
145  { 0x0060,  8,   30 }, // 00000011
146  { 0x0340,  8,   31 }, // 00011010
147  { 0x0360,  8,   32 }, // 00011011
148  { 0x0240,  8,   33 }, // 00010010
149  { 0x0260,  8,   34 }, // 00010011
150  { 0x0280,  8,   35 }, // 00010100
151  { 0x02a0,  8,   36 }, // 00010101
152  { 0x02c0,  8,   37 }, // 00010110
153  { 0x02e0,  8,   38 }, // 00010111
154  { 0x0500,  8,   39 }, // 00101000
155  { 0x0520,  8,   40 }, // 00101001
156  { 0x0540,  8,   41 }, // 00101010
157  { 0x0560,  8,   42 }, // 00101011
158  { 0x0580,  8,   43 }, // 00101100
159  { 0x05a0,  8,   44 }, // 00101101
160  { 0x0080,  8,   45 }, // 00000100
161  { 0x00a0,  8,   46 }, // 00000101
162  { 0x0140,  8,   47 }, // 00001010
163  { 0x0160,  8,   48 }, // 00001011
164  { 0x0a40,  8,   49 }, // 01010010
165  { 0x0a60,  8,   50 }, // 01010011
166  { 0x0a80,  8,   51 }, // 01010100
167  { 0x0aa0,  8,   52 }, // 01010101
168  { 0x0480,  8,   53 }, // 00100100
169  { 0x04a0,  8,   54 }, // 00100101
170  { 0x0b00,  8,   55 }, // 01011000
171  { 0x0b20,  8,   56 }, // 01011001
172  { 0x0b40,  8,   57 }, // 01011010
173  { 0x0b60,  8,   58 }, // 01011011
174  { 0x0940,  8,   59 }, // 01001010
175  { 0x0960,  8,   60 }, // 01001011
176  { 0x0640,  8,   61 }, // 00110010
177  { 0x0660,  8,   62 }, // 00110011
178  { 0x0680,  8,   63 }, // 00110100
179  { 0x1b00,  5,   64 }, // 11011
180  { 0x1200,  5,  128 }, // 10010
181  { 0x0b80,  6,  192 }, // 010111
182  { 0x0dc0,  7,  256 }, // 0110111
183  { 0x06c0,  8,  320 }, // 00110110
184  { 0x06e0,  8,  384 }, // 00110111
185  { 0x0c80,  8,  448 }, // 01100100
186  { 0x0ca0,  8,  512 }, // 01100101
187  { 0x0d00,  8,  576 }, // 01101000
188  { 0x0ce0,  8,  640 }, // 01100111
189  { 0x0cc0,  9,  704 }, // 011001100
190  { 0x0cd0,  9,  768 }, // 011001101
191  { 0x0d20,  9,  832 }, // 011010010
192  { 0x0d30,  9,  896 }, // 011010011
193  { 0x0d40,  9,  960 }, // 011010100
194  { 0x0d50,  9, 1024 }, // 011010101
195  { 0x0d60,  9, 1088 }, // 011010110
196  { 0x0d70,  9, 1152 }, // 011010111
197  { 0x0d80,  9, 1216 }, // 011011000
198  { 0x0d90,  9, 1280 }, // 011011001
199  { 0x0da0,  9, 1344 }, // 011011010
200  { 0x0db0,  9, 1408 }, // 011011011
201  { 0x0980,  9, 1472 }, // 010011000
202  { 0x0990,  9, 1536 }, // 010011001
203  { 0x09a0,  9, 1600 }, // 010011010
204  { 0x0c00,  6, 1664 }, // 011000  (what did they think?)
205  { 0x09b0,  9, 1728 }, // 010011011
206  { 0x0020, 11, 1792 }, // 00000001000
207  { 0x0030, 11, 1856 }, // 00000001100
208  { 0x0034, 11, 1920 }, // 00000001101
209  { 0x0024, 12, 1984 }, // 000000010010
210  { 0x0026, 12, 2048 }, // 000000010011
211  { 0x0028, 12, 2112 }, // 000000010100
212  { 0x002a, 12, 2176 }, // 000000010101
213  { 0x002c, 12, 2240 }, // 000000010110
214  { 0x002e, 12, 2304 }, // 000000010111
215  { 0x0038, 12, 2368 }, // 000000011100
216  { 0x003a, 12, 2432 }, // 000000011101
217  { 0x003c, 12, 2496 }, // 000000011110
218  { 0x003e, 12, 2560 }, // 000000011111
219  { 0x0000,  0,   -1 }  // Illegal entry
220};
221
222
223static const VLCode bcodes[] = {
224  // 13 bit codes
225  { 0x01b8, 10,    0 }, // 0000110111
226  { 0x0800,  3,    1 }, // 010
227  { 0x1800,  2,    2 }, // 11
228  { 0x1000,  2,    3 }, // 10
229  { 0x0c00,  3,    4 }, // 011
230  { 0x0600,  4,    5 }, // 0011
231  { 0x0400,  4,    6 }, // 0010
232  { 0x0300,  5,    7 }, // 00011
233  { 0x0280,  6,    8 }, // 000101
234  { 0x0200,  6,    9 }, // 000100
235  { 0x0100,  7,   10 }, // 0000100
236  { 0x0140,  7,   11 }, // 0000101
237  { 0x01c0,  7,   12 }, // 0000111
238  { 0x0080,  8,   13 }, // 00000100
239  { 0x00e0,  8,   14 }, // 00000111
240  { 0x0180,  9,   15 }, // 000011000
241  { 0x00b8, 10,   16 }, // 0000010111
242  { 0x00c0, 10,   17 }, // 0000011000
243  { 0x0040, 10,   18 }, // 0000001000
244  { 0x019c, 11,   19 }, // 00001100111
245  { 0x01a0, 11,   20 }, // 00001101000
246  { 0x01b0, 11,   21 }, // 00001101100
247  { 0x00dc, 11,   22 }, // 00000110111
248  { 0x00a0, 11,   23 }, // 00000101000
249  { 0x005c, 11,   24 }, // 00000010111
250  { 0x0060, 11,   25 }, // 00000011000
251  { 0x0194, 12,   26 }, // 000011001010
252  { 0x0196, 12,   27 }, // 000011001011
253  { 0x0198, 12,   28 }, // 000011001100
254  { 0x019a, 12,   29 }, // 000011001101
255  { 0x00d0, 12,   30 }, // 000001101000
256  { 0x00d2, 12,   31 }, // 000001101001
257  { 0x00d4, 12,   32 }, // 000001101010
258  { 0x00d6, 12,   33 }, // 000001101011
259  { 0x01a4, 12,   34 }, // 000011010010
260  { 0x01a6, 12,   35 }, // 000011010011
261  { 0x01a8, 12,   36 }, // 000011010100
262  { 0x01aa, 12,   37 }, // 000011010101
263  { 0x01ac, 12,   38 }, // 000011010110
264  { 0x01ae, 12,   39 }, // 000011010111
265  { 0x00d8, 12,   40 }, // 000001101100
266  { 0x00da, 12,   41 }, // 000001101101
267  { 0x01b4, 12,   42 }, // 000011011010
268  { 0x01b6, 12,   43 }, // 000011011011
269  { 0x00a8, 12,   44 }, // 000001010100
270  { 0x00aa, 12,   45 }, // 000001010101
271  { 0x00ac, 12,   46 }, // 000001010110
272  { 0x00ae, 12,   47 }, // 000001010111
273  { 0x00c8, 12,   48 }, // 000001100100
274  { 0x00ca, 12,   49 }, // 000001100101
275  { 0x00a4, 12,   50 }, // 000001010010
276  { 0x00a6, 12,   51 }, // 000001010011
277  { 0x0048, 12,   52 }, // 000000100100
278  { 0x006e, 12,   53 }, // 000000110111
279  { 0x0070, 12,   54 }, // 000000111000
280  { 0x004e, 12,   55 }, // 000000100111
281  { 0x0050, 12,   56 }, // 000000101000
282  { 0x00b0, 12,   57 }, // 000001011000
283  { 0x00b2, 12,   58 }, // 000001011001
284  { 0x0056, 12,   59 }, // 000000101011
285  { 0x0058, 12,   60 }, // 000000101100
286  { 0x00b4, 12,   61 }, // 000001011010
287  { 0x00cc, 12,   62 }, // 000001100110
288  { 0x00ce, 12,   63 }, // 000001100111
289  { 0x0078, 10,   64 }, // 0000001111
290  { 0x0190, 12,  128 }, // 000011001000
291  { 0x0192, 12,  192 }, // 000011001001
292  { 0x00b6, 12,  256 }, // 000001011011
293  { 0x0066, 12,  320 }, // 000000110011
294  { 0x0068, 12,  384 }, // 000000110100
295  { 0x006a, 12,  448 }, // 000000110101
296  { 0x006c, 13,  512 }, // 0000001101100
297  { 0x006d, 13,  576 }, // 0000001101101
298  { 0x004a, 13,  640 }, // 0000001001010
299  { 0x004b, 13,  704 }, // 0000001001011
300  { 0x004c, 13,  768 }, // 0000001001100
301  { 0x004d, 13,  832 }, // 0000001001101
302  { 0x0072, 13,  896 }, // 0000001110010
303  { 0x0073, 13,  960 }, // 0000001110011
304  { 0x0074, 13, 1024 }, // 0000001110100
305  { 0x0075, 13, 1088 }, // 0000001110101
306  { 0x0076, 13, 1152 }, // 0000001110110
307  { 0x0077, 13, 1216 }, // 0000001110111
308  { 0x0052, 13, 1280 }, // 0000001010010
309  { 0x0053, 13, 1344 }, // 0000001010011
310  { 0x0054, 13, 1408 }, // 0000001010100
311  { 0x0055, 13, 1472 }, // 0000001010101
312  { 0x005a, 13, 1536 }, // 0000001011010
313  { 0x005b, 13, 1600 }, // 0000001011011
314  { 0x0064, 13, 1664 }, // 0000001100100
315  { 0x0065, 13, 1728 }, // 0000001100101
316  { 0x0020, 11, 1792 }, // 00000001000
317  { 0x0030, 11, 1856 }, // 00000001100
318  { 0x0034, 11, 1920 }, // 00000001101
319  { 0x0024, 12, 1984 }, // 000000010010
320  { 0x0026, 12, 2048 }, // 000000010011
321  { 0x0028, 12, 2112 }, // 000000010100
322  { 0x002a, 12, 2176 }, // 000000010101
323  { 0x002c, 12, 2240 }, // 000000010110
324  { 0x002e, 12, 2304 }, // 000000010111
325  { 0x0038, 12, 2368 }, // 000000011100
326  { 0x003a, 12, 2432 }, // 000000011101
327  { 0x003c, 12, 2496 }, // 000000011110
328  { 0x003e, 12, 2560 }, // 000000011111
329  { 0x0000,  0,   -1 }  // Illegal entry
330};
331
332
333
334
335// ----------------------------------------
336// SOURCE OF BITS
337
338#define VLSBUFSIZE    64
339
340class MMRDecoder::VLSource : public GPEnabled
341{
342protected:
343  VLSource(GP<ByteStream> &inp);
344  void init(const bool striped);
345public:
346  // Initializes a bit source on a bytestream
347  static GP<VLSource> create(GP<ByteStream> &inp, const bool striped);
348
349  // Synchronize on the next stripe
350  void nextstripe(void);
351  // Returns a 32 bits integer with at least the
352  // next sixteen code bits in the high order bits.
353  inline unsigned int peek(void);
354  // Ensures that next #peek()# contains at least
355  // the next 24 code bits.
356  void preload(void);
357  // Consumes #n# bits.
358  void shift(const int n);
359private:
360  GP<ByteStream> ginp;
361  ByteStream &inp;
362  unsigned char buffer[ VLSBUFSIZE ];
363  unsigned int codeword;
364  int lowbits;
365  int bufpos;
366  int bufmax;
367  int readmax;
368};
369
370MMRDecoder::VLSource::VLSource(GP<ByteStream> &xinp)
371: ginp(xinp), inp(*ginp), codeword(0), 
372  lowbits(0), bufpos(0), bufmax(0),
373  readmax(-1)
374{}
375
376void
377MMRDecoder::VLSource::init(const bool striped)
378{
379  if (striped)
380    readmax = inp.read32();
381  lowbits = 32;
382  preload();
383}
384
385GP<MMRDecoder::VLSource>
386MMRDecoder::VLSource::create(GP<ByteStream> &inp, const bool striped)
387{
388  VLSource *src=new VLSource(inp);
389  GP<VLSource> retval=src;
390  src->init(striped);
391  return retval;
392}
393
394void 
395MMRDecoder::VLSource::shift(const int n)
396{ 
397  codeword<<=n;
398  lowbits+=n;
399  if (lowbits>=16)
400    preload();
401}
402
403inline unsigned int
404MMRDecoder::VLSource::peek(void)
405{
406  return codeword;
407}
408
409
410void
411MMRDecoder::VLSource::nextstripe(void)
412{
413  while (readmax>0)
414    {
415      int size = sizeof(buffer);
416      if (readmax < size) 
417        size = readmax;
418      inp.readall(buffer, size);
419      readmax -= size;
420    }
421  bufpos = bufmax = 0;
422  memset(buffer,0,sizeof(buffer));
423  readmax = inp.read32();
424  codeword = 0; 
425  lowbits = 32;
426  preload();
427}
428
429void
430MMRDecoder::VLSource::preload(void)
431{
432  while (lowbits>=8) 
433    {
434      if (bufpos >= bufmax) 
435        {
436          // Refill buffer
437          bufpos = bufmax = 0;
438          int size = sizeof(buffer);
439          if (readmax>=0 && readmax<size) 
440            size = readmax;
441          if (size>0)
442            bufmax = inp.read((void*)buffer, size);
443          readmax -= bufmax;
444          if (bufmax <= 0)
445            return;
446        }
447      lowbits -= 8;
448      codeword |= buffer[bufpos++] << lowbits;
449    }
450}
451
452
453
454// ----------------------------------------
455// VARIABLE LENGTH CODES
456
457
458
459class MMRDecoder::VLTable : public GPEnabled
460{
461protected:
462  VLTable(const VLCode *codes);
463  void init(const int nbits);
464public:
465  // Construct a VLTable given a codebook with #nbits# long codes.
466  static GP<VLTable> create(VLCode const * const codes, const int nbits);
467
468  // Reads one symbol from a VLSource
469  int decode(MMRDecoder::VLSource *src);
470
471  const VLCode *code;
472  int codewordshift;
473  unsigned char *index;
474  GPBuffer<unsigned char> gindex;
475};
476
477GP<MMRDecoder::VLTable>
478MMRDecoder::VLTable::create(VLCode const * const codes, const int nbits)
479{
480  VLTable *table=new VLTable(codes);
481  GP<VLTable> retval=table;
482  table->init(nbits);
483  return retval;
484}
485
486inline int
487MMRDecoder::VLTable::decode(MMRDecoder::VLSource *src)   
488{ 
489  const VLCode &c = code[ index[ src->peek() >> codewordshift ] ];
490  src->shift(c.codelen); 
491  return c.value; 
492}
493
494MMRDecoder::VLTable::VLTable(const VLCode *codes)
495: code(codes), codewordshift(0), gindex(index,0)
496{}
497
498void
499MMRDecoder::VLTable::init(const int nbits)
500{
501  // count entries
502  int ncodes = 0;
503  while (code[ncodes].codelen)
504    ncodes++;
505  // check arguments
506  if (nbits<=1 || nbits>16)
507    G_THROW(invalid_mmr_data);
508  if (ncodes>=256)
509    G_THROW(invalid_mmr_data);
510  codewordshift = 32 - nbits;
511  // allocate table
512  int size = (1<<nbits);
513  gindex.resize(size);
514  gindex.set(ncodes);
515  // process codes
516  for (int i=0; i<ncodes; i++) {
517    const int c = code[i].code;
518    const int b = code[i].codelen;
519    if(b<=0 || b>nbits)
520    {
521      G_THROW(invalid_mmr_data);
522    }
523    // fill table entries whose index high bits are code.
524    int n = c + (1<<(nbits-b));
525    while ( --n >= c ) {
526      if(index[n] != ncodes)
527       G_THROW( ERR_MSG("MMRDecoder.bad_codebook") );
528      index[n] = i;
529    }
530  }
531}
532
533// ----------------------------------------
534// MMR DECODER
535
536
537
538MMRDecoder::~MMRDecoder() {}
539
540MMRDecoder::MMRDecoder( const int xwidth, const int xheight )
541: width(xwidth), height(xheight), lineno(0), 
542  striplineno(0), rowsperstrip(0), gline(line,width+8),
543  glineruns(lineruns,width+4), gprevruns(prevruns,width+4)
544{
545  gline.clear();
546  glineruns.clear();
547  gprevruns.clear();
548  lineruns[0] = width;
549  prevruns[0] = width;
550}
551
552void
553MMRDecoder::init(GP<ByteStream> gbs, const bool striped)
554{
555  rowsperstrip = (striped ? gbs->read16() : height);
556  src = VLSource::create(gbs, striped);
557  mrtable = VLTable::create(mrcodes, 7);
558  btable = VLTable::create(bcodes, 13);
559  wtable = VLTable::create(wcodes, 13);
560}
561
562GP<MMRDecoder> 
563MMRDecoder::create( GP<ByteStream> gbs, const int width,
564  const int height, const bool striped )
565{
566  MMRDecoder *mmr=new MMRDecoder(width,height);
567  GP<MMRDecoder> retval=mmr;
568  mmr->init(gbs,striped);
569  return retval;
570}
571
572const unsigned short *
573MMRDecoder::scanruns(const unsigned short **endptr)
574{
575  // Check if all lines have been returned
576  if (lineno >= height)
577    return 0;
578  // Check end of stripe
579  if ( striplineno == rowsperstrip )
580    {
581      striplineno=0;
582      lineruns[0] = prevruns[0] = width;
583      src->nextstripe();
584    }
585  // Swap run buffers
586  unsigned short *pr = lineruns;
587  unsigned short *xr = prevruns;
588  prevruns = pr;
589  lineruns = xr;
590  // Loop until scanline is complete
591  bool a0color = false;
592  int a0,rle,b1;
593  for(a0=0,rle=0,b1=*pr++;a0 < width;)
594    {
595      // Process MMR codes
596      const int c=mrtable->decode(src);
597      switch ( c )
598      {
599          /* Pass Mode */
600        case P: 
601          { 
602            b1 += *pr++;
603            rle += b1 - a0;
604            a0 = b1;
605            b1 += *pr++;
606            break;
607          }
608          /* Horizontal Mode */
609        case H: 
610          { 
611            // First run
612            VLTable &table1 = *(a0color ? btable : wtable);
613            int inc;
614            do { inc=table1.decode(src); a0+=inc; rle+=inc; } while (inc>=64);
615            *xr = rle; xr++; rle = 0;
616            // Second run
617            VLTable &table2 = *(!a0color ? btable : wtable);
618            do { inc=table2.decode(src); a0+=inc; rle+=inc; } while (inc>=64);
619            *xr = rle; xr++; rle = 0;
620            break;
621          }
622          /* Vertical Modes */
623        case V0:
624        case VR3:
625        case VR2:
626        case VR1:
627        case VL3:
628        case VL2:
629        case VL1:
630        {
631          int inc=b1;
632          switch ( c )
633          {
634          case V0:
635            inc = b1;
636            b1 += *pr++;
637            break;
638          case VR3:
639            inc = b1+3;
640            b1 += *pr++;
641            break;
642          case VR2:
643            inc = b1+2;
644            b1 += *pr++;
645            break;
646          case VR1:
647            inc = b1+1;
648            b1 += *pr++;
649            break;
650          case VL3:
651            inc = b1-3;
652            b1 -= *--pr;
653            break;
654          case VL2:
655            inc = b1-2;
656            b1 -= *--pr;
657            break;
658          case VL1:
659            inc = b1-1;
660            b1 -= *--pr;
661            break;
662          }
663          *xr = inc+rle-a0;
664          xr++;
665          a0 = inc;
666          rle = 0;
667          a0color = !a0color;
668          break;
669        }
670          /* Uncommon modes */
671        default: 
672          {
673            src->preload();
674            unsigned int m = src->peek();
675            // -- Could be EOFB ``000000000001000000000001''
676            //    TIFF6 says that all remaining lines are white
677            if ((m & 0xffffff00) == 0x00100100)
678              {
679                lineno = height;
680                return 0;
681              }
682            // -- Could be UNCOMPRESSED ``0000001111''
683            //    TIFF6 says people should not do this.
684            //    RFC1314 says people should do this.
685            else if ((m & 0xffc00000) == 0x03c00000)
686              {
687#ifdef MMRDECODER_REFUSES_UNCOMPRESSED
688                G_THROW( ERR_MSG("MMRDecoder.cant_process") );
689#else
690                // ---THE-FOLLOWING-CODE-IS-POORLY-TESTED---
691                src->shift(10);
692                while ((m = (src->peek() & 0xfc000000)))
693                  {
694                    if (m == 0x04000000)       // 000001
695                      {
696                        src->shift(6);
697                        if (a0color)
698                        {
699                          *xr = rle;
700                          xr++;
701                          rle = 0;
702                          a0color = !a0color;
703                        }
704                        rle += 5;
705                        a0 += 5;
706                      }
707                    else                       // 000010 to 111111
708                      { 
709                        src->shift(1);
710                        if (a0color == !(m & 0x80000000))
711                        {
712                          *xr = rle;
713                          xr++;
714                          rle = 0;
715                          a0color = !a0color;
716                        }
717                        rle++;
718                        a0++;
719                      }
720                    if (a0 > width)
721                      G_THROW(invalid_mmr_data);
722                  }
723                // Analyze uncompressed termination code.
724                m = src->peek() & 0xff000000; 
725                src->shift(8);
726                if ( (m & 0xfe000000) != 0x02000000 )
727                  G_THROW(invalid_mmr_data);
728                if (rle)
729                {
730                  *xr = rle;
731                  xr++;
732                  rle = 0;
733                  a0color = !a0color;
734                }                 
735                if (a0color == !(m & 0x01000000))
736                {
737                  *xr = rle;
738                  xr++;
739                  rle = 0;
740                  a0color = !a0color;
741                }
742                // Cross fingers and proceed ...
743                break;
744#endif
745              }
746            // -- Unknown MMR code.
747            G_THROW(invalid_mmr_data);
748          }
749      }
750      // Next reference run
751      for(;b1<=a0 && b1<width;pr+=2)
752      {
753        b1 += pr[0]+pr[1];
754      }
755    }
756  // Final P must be followed by V0 (they say!)
757  if (rle > 0)
758  {
759    if (mrtable->decode(src) != V0)
760    {
761      G_THROW(invalid_mmr_data);
762    }
763  }
764  if (rle > 0)
765  {
766    *xr = rle;
767    xr++;
768  }
769  // At this point we should have A0 equal to WIDTH
770  // But there are buggy files around (Kofax!)
771  // and we are not the CCITT police.
772  if (a0 > width) 
773    {
774      while (a0 > width && xr > lineruns)
775        a0 -= *--xr;
776      if (a0 < width)
777      {
778        *xr = width-a0;
779        xr++;
780      }
781    }
782  /* Increment and return */
783  if (endptr) 
784    *endptr = xr;
785  xr[0] = 0;
786  xr[1] = 0;
787  lineno ++;
788  striplineno ++;
789  return lineruns;
790}
791
792
793
794const unsigned char *
795MMRDecoder::scanrle(const bool invert, const unsigned char **endptr)
796{
797  // Obtain run lengths
798  const unsigned short *xr = scanruns();
799  if (!xr) return 0;
800  unsigned char *p=line;
801  // Process inversion
802  if (invert)
803    {
804      if (! *xr) 
805      {
806        xr++;
807      }else
808      {
809        *p = 0; p++;
810      }
811    }
812  // Encode lenghts using the RLE format
813  for(int a0=0;a0 < width;)
814  {
815    int count = *xr++;
816    a0 += count;
817    GBitmap::append_run(p, count);
818  }
819  if (endptr)
820    *endptr = p;
821  p[0] = 0;
822  p[1] = 0;
823  return line;
824}
825
826
827#if 0
828const unsigned char *
829MMRDecoder::scanline(void)
830{
831  // Obtain run lengths
832  const unsigned short *xr = scanruns();
833  if (!xr) return 0;
834  // Allocate data buffer if needed
835  unsigned char *p = line;
836  // Decode run lengths
837  int a0 = 0;
838  int a0color = 0;
839  while (a0 < width)
840    {
841      int a1 = a0 + *xr++;
842      while (a0<a1 && a0<width)
843        line[a0++] = a0color;
844      a0color = !a0color;
845    }
846  return line;
847}
848#endif
849
850
851
852
853// ----------------------------------------
854// MAIN DECODING ROUTINE
855
856bool
857MMRDecoder::decode_header(
858  ByteStream &inp, int &width, int &height, int &invert)
859{
860  unsigned long int magic = inp.read32();
861  if((magic&0xfffffffc) != 0x4d4d5200)
862    G_THROW( ERR_MSG("MMRDecoder.unrecog_header") ); 
863  invert = ((magic & 0x1) ? 1 : 0);
864  const bool strip =  ((magic & 0x2) ? 1 : 0);
865  width = inp.read16();
866  height = inp.read16();
867  if (width<=0 || height<=0)
868    G_THROW( ERR_MSG("MMRDecoder.bad_header") );
869  return strip;
870}
871
872static inline int MAX(int a, int b) { return a>b ? a : b; }
873static inline int MIN(int a, int b) { return a<b ? a : b; }
874
875GP<JB2Image>
876MMRDecoder::decode(GP<ByteStream> gbs)
877{
878  ByteStream &inp=*gbs;
879  // Read header
880  int width, height, invert;
881  const bool striped=decode_header(inp, width, height, invert);
882  // Prepare image
883  GP<JB2Image> jimg = JB2Image::create();
884  jimg->set_dimension(width, height);
885  // Choose pertinent blocksize
886  int blocksize = MIN(500,MAX(64,MAX(width/17,height/22)));
887  int blocksperline = (width+blocksize-1)/blocksize;
888  // Prepare decoder
889  GP<MMRDecoder> gdcd=MMRDecoder::create(gbs, width, height, striped);
890  MMRDecoder &dcd=*gdcd;
891  // Loop on JB2 bands
892  int line = height-1;
893  while (line >= 0)
894    {
895      int bandline = MIN(blocksize-1,line);
896      GPArray<GBitmap> blocks(0,blocksperline-1);
897      // Loop on scanlines
898      for(; bandline >= 0; bandline--,line--)
899      {
900        // Decode one scanline
901        const unsigned short *s = dcd.scanruns();
902        if (s)
903        {
904          // Loop on blocks
905          int x = 0;
906          int b = 0;
907          int firstx = 0;
908          bool c = !!invert;
909          while (x < width)
910            {
911              int xend = x + *s++;
912              while (b<blocksperline)
913                {
914                  int lastx = MIN(firstx+blocksize,width);
915                  if (c)
916                    {
917                      if (!blocks[b])
918                        blocks[b] = GBitmap::create(bandline+1, lastx-firstx);
919                      unsigned char *bptr = (*blocks[b])[bandline] - firstx;
920                      int x1 = MAX(x,firstx);
921                      int x2 = MIN(xend,lastx);
922                      while (x1 < x2)
923                        bptr[x1++] = 1;
924                    }
925                  if (xend < lastx)
926                    break;
927                  firstx = lastx;
928                  b ++;
929                }
930              x = xend;
931              c = !c; 
932            }
933        }
934      }
935      // Insert blocks into JB2Image
936      for (int b=0; b<blocksperline; b++)
937        {
938          JB2Shape shape;
939          shape.bits = blocks[b];
940          if (shape.bits) 
941            {
942              shape.parent = -1;
943              shape.bits->compress();
944              JB2Blit blit;
945              blit.left = b*blocksize;
946              blit.bottom = line+1;
947              blit.shapeno = jimg->add_shape(shape);
948              jimg->add_blit(blit);
949            }
950        }
951    }
952  // Return
953  return jimg;
954}
955
956
957
958#ifdef HAVE_NAMESPACES
959}
960# ifndef NOT_USING_DJVU_NAMESPACE
961using namespace DJVU;
962# endif
963#endif
Note: See TracBrowser for help on using the repository browser.