upgrade to xpdf 3.00.
[swftools.git] / pdf2swf / xpdf / JBIG2Stream.cc
1 //========================================================================
2 //
3 // JBIG2Stream.cc
4 //
5 // Copyright 2002-2003 Glyph & Cog, LLC
6 //
7 //========================================================================
8
9 #include <aconf.h>
10
11 #ifdef USE_GCC_PRAGMAS
12 #pragma implementation
13 #endif
14
15 #include <stdlib.h>
16 #include "GList.h"
17 #include "Error.h"
18 #include "JArithmeticDecoder.h"
19 #include "JBIG2Stream.h"
20
21 //~ share these tables
22 #include "Stream-CCITT.h"
23
24 //------------------------------------------------------------------------
25
26 static int contextSize[4] = { 16, 13, 10, 10 };
27 static int refContextSize[2] = { 13, 10 };
28
29 //------------------------------------------------------------------------
30 // JBIG2HuffmanTable
31 //------------------------------------------------------------------------
32
33 #define jbig2HuffmanLOW 0xfffffffd
34 #define jbig2HuffmanOOB 0xfffffffe
35 #define jbig2HuffmanEOT 0xffffffff
36
37 struct JBIG2HuffmanTable {
38   int val;
39   Guint prefixLen;
40   Guint rangeLen;               // can also be LOW, OOB, or EOT
41   Guint prefix;
42 };
43
44 JBIG2HuffmanTable huffTableA[] = {
45   {     0, 1,  4,              0x000 },
46   {    16, 2,  8,              0x002 },
47   {   272, 3, 16,              0x006 },
48   { 65808, 3, 32,              0x007 },
49   {     0, 0, jbig2HuffmanEOT, 0     }
50 };
51
52 JBIG2HuffmanTable huffTableB[] = {
53   {     0, 1,  0,              0x000 },
54   {     1, 2,  0,              0x002 },
55   {     2, 3,  0,              0x006 },
56   {     3, 4,  3,              0x00e },
57   {    11, 5,  6,              0x01e },
58   {    75, 6, 32,              0x03e },
59   {     0, 6, jbig2HuffmanOOB, 0x03f },
60   {     0, 0, jbig2HuffmanEOT, 0     }
61 };
62
63 JBIG2HuffmanTable huffTableC[] = {
64   {     0, 1,  0,              0x000 },
65   {     1, 2,  0,              0x002 },
66   {     2, 3,  0,              0x006 },
67   {     3, 4,  3,              0x00e },
68   {    11, 5,  6,              0x01e },
69   {     0, 6, jbig2HuffmanOOB, 0x03e },
70   {    75, 7, 32,              0x0fe },
71   {  -256, 8,  8,              0x0fe },
72   {  -257, 8, jbig2HuffmanLOW, 0x0ff },
73   {     0, 0, jbig2HuffmanEOT, 0     }
74 };
75
76 JBIG2HuffmanTable huffTableD[] = {
77   {     1, 1,  0,              0x000 },
78   {     2, 2,  0,              0x002 },
79   {     3, 3,  0,              0x006 },
80   {     4, 4,  3,              0x00e },
81   {    12, 5,  6,              0x01e },
82   {    76, 5, 32,              0x01f },
83   {     0, 0, jbig2HuffmanEOT, 0     }
84 };
85
86 JBIG2HuffmanTable huffTableE[] = {
87   {     1, 1,  0,              0x000 },
88   {     2, 2,  0,              0x002 },
89   {     3, 3,  0,              0x006 },
90   {     4, 4,  3,              0x00e },
91   {    12, 5,  6,              0x01e },
92   {    76, 6, 32,              0x03e },
93   {  -255, 7,  8,              0x07e },
94   {  -256, 7, jbig2HuffmanLOW, 0x07f },
95   {     0, 0, jbig2HuffmanEOT, 0     }
96 };
97
98 JBIG2HuffmanTable huffTableF[] = {
99   {     0, 2,  7,              0x000 },
100   {   128, 3,  7,              0x002 },
101   {   256, 3,  8,              0x003 },
102   { -1024, 4,  9,              0x008 },
103   {  -512, 4,  8,              0x009 },
104   {  -256, 4,  7,              0x00a },
105   {   -32, 4,  5,              0x00b },
106   {   512, 4,  9,              0x00c },
107   {  1024, 4, 10,              0x00d },
108   { -2048, 5, 10,              0x01c },
109   {  -128, 5,  6,              0x01d },
110   {   -64, 5,  5,              0x01e },
111   { -2049, 6, jbig2HuffmanLOW, 0x03e },
112   {  2048, 6, 32,              0x03f },
113   {     0, 0, jbig2HuffmanEOT, 0     }
114 };
115
116 JBIG2HuffmanTable huffTableG[] = {
117   {  -512, 3,  8,              0x000 },
118   {   256, 3,  8,              0x001 },
119   {   512, 3,  9,              0x002 },
120   {  1024, 3, 10,              0x003 },
121   { -1024, 4,  9,              0x008 },
122   {  -256, 4,  7,              0x009 },
123   {   -32, 4,  5,              0x00a },
124   {     0, 4,  5,              0x00b },
125   {   128, 4,  7,              0x00c },
126   {  -128, 5,  6,              0x01a },
127   {   -64, 5,  5,              0x01b },
128   {    32, 5,  5,              0x01c },
129   {    64, 5,  6,              0x01d },
130   { -1025, 5, jbig2HuffmanLOW, 0x01e },
131   {  2048, 5, 32,              0x01f },
132   {     0, 0, jbig2HuffmanEOT, 0     }
133 };
134
135 JBIG2HuffmanTable huffTableH[] = {
136   {     0, 2,  1,              0x000 },
137   {     0, 2, jbig2HuffmanOOB, 0x001 },
138   {     4, 3,  4,              0x004 },
139   {    -1, 4,  0,              0x00a },
140   {    22, 4,  4,              0x00b },
141   {    38, 4,  5,              0x00c },
142   {     2, 5,  0,              0x01a },
143   {    70, 5,  6,              0x01b },
144   {   134, 5,  7,              0x01c },
145   {     3, 6,  0,              0x03a },
146   {    20, 6,  1,              0x03b },
147   {   262, 6,  7,              0x03c },
148   {   646, 6, 10,              0x03d },
149   {    -2, 7,  0,              0x07c },
150   {   390, 7,  8,              0x07d },
151   {   -15, 8,  3,              0x0fc },
152   {    -5, 8,  1,              0x0fd },
153   {    -7, 9,  1,              0x1fc },
154   {    -3, 9,  0,              0x1fd },
155   {   -16, 9, jbig2HuffmanLOW, 0x1fe },
156   {  1670, 9, 32,              0x1ff },
157   {     0, 0, jbig2HuffmanEOT, 0     }
158 };
159
160 JBIG2HuffmanTable huffTableI[] = {
161   {     0, 2, jbig2HuffmanOOB, 0x000 },
162   {    -1, 3,  1,              0x002 },
163   {     1, 3,  1,              0x003 },
164   {     7, 3,  5,              0x004 },
165   {    -3, 4,  1,              0x00a },
166   {    43, 4,  5,              0x00b },
167   {    75, 4,  6,              0x00c },
168   {     3, 5,  1,              0x01a },
169   {   139, 5,  7,              0x01b },
170   {   267, 5,  8,              0x01c },
171   {     5, 6,  1,              0x03a },
172   {    39, 6,  2,              0x03b },
173   {   523, 6,  8,              0x03c },
174   {  1291, 6, 11,              0x03d },
175   {    -5, 7,  1,              0x07c },
176   {   779, 7,  9,              0x07d },
177   {   -31, 8,  4,              0x0fc },
178   {   -11, 8,  2,              0x0fd },
179   {   -15, 9,  2,              0x1fc },
180   {    -7, 9,  1,              0x1fd },
181   {   -32, 9, jbig2HuffmanLOW, 0x1fe },
182   {  3339, 9, 32,              0x1ff },
183   {     0, 0, jbig2HuffmanEOT, 0     }
184 };
185
186 JBIG2HuffmanTable huffTableJ[] = {
187   {    -2, 2,  2,              0x000 },
188   {     6, 2,  6,              0x001 },
189   {     0, 2, jbig2HuffmanOOB, 0x002 },
190   {    -3, 5,  0,              0x018 },
191   {     2, 5,  0,              0x019 },
192   {    70, 5,  5,              0x01a },
193   {     3, 6,  0,              0x036 },
194   {   102, 6,  5,              0x037 },
195   {   134, 6,  6,              0x038 },
196   {   198, 6,  7,              0x039 },
197   {   326, 6,  8,              0x03a },
198   {   582, 6,  9,              0x03b },
199   {  1094, 6, 10,              0x03c },
200   {   -21, 7,  4,              0x07a },
201   {    -4, 7,  0,              0x07b },
202   {     4, 7,  0,              0x07c },
203   {  2118, 7, 11,              0x07d },
204   {    -5, 8,  0,              0x0fc },
205   {     5, 8,  0,              0x0fd },
206   {   -22, 8, jbig2HuffmanLOW, 0x0fe },
207   {  4166, 8, 32,              0x0ff },
208   {     0, 0, jbig2HuffmanEOT, 0     }
209 };
210
211 JBIG2HuffmanTable huffTableK[] = {
212   {     1, 1,  0,              0x000 },
213   {     2, 2,  1,              0x002 },
214   {     4, 4,  0,              0x00c },
215   {     5, 4,  1,              0x00d },
216   {     7, 5,  1,              0x01c },
217   {     9, 5,  2,              0x01d },
218   {    13, 6,  2,              0x03c },
219   {    17, 7,  2,              0x07a },
220   {    21, 7,  3,              0x07b },
221   {    29, 7,  4,              0x07c },
222   {    45, 7,  5,              0x07d },
223   {    77, 7,  6,              0x07e },
224   {   141, 7, 32,              0x07f },
225   {     0, 0, jbig2HuffmanEOT, 0     }
226 };
227
228 JBIG2HuffmanTable huffTableL[] = {
229   {     1, 1,  0,              0x000 },
230   {     2, 2,  0,              0x002 },
231   {     3, 3,  1,              0x006 },
232   {     5, 5,  0,              0x01c },
233   {     6, 5,  1,              0x01d },
234   {     8, 6,  1,              0x03c },
235   {    10, 7,  0,              0x07a },
236   {    11, 7,  1,              0x07b },
237   {    13, 7,  2,              0x07c },
238   {    17, 7,  3,              0x07d },
239   {    25, 7,  4,              0x07e },
240   {    41, 8,  5,              0x0fe },
241   {    73, 8, 32,              0x0ff },
242   {     0, 0, jbig2HuffmanEOT, 0     }
243 };
244
245 JBIG2HuffmanTable huffTableM[] = {
246   {     1, 1,  0,              0x000 },
247   {     2, 3,  0,              0x004 },
248   {     7, 3,  3,              0x005 },
249   {     3, 4,  0,              0x00c },
250   {     5, 4,  1,              0x00d },
251   {     4, 5,  0,              0x01c },
252   {    15, 6,  1,              0x03a },
253   {    17, 6,  2,              0x03b },
254   {    21, 6,  3,              0x03c },
255   {    29, 6,  4,              0x03d },
256   {    45, 6,  5,              0x03e },
257   {    77, 7,  6,              0x07e },
258   {   141, 7, 32,              0x07f },
259   {     0, 0, jbig2HuffmanEOT, 0     }
260 };
261
262 JBIG2HuffmanTable huffTableN[] = {
263   {     0, 1,  0,              0x000 },
264   {    -2, 3,  0,              0x004 },
265   {    -1, 3,  0,              0x005 },
266   {     1, 3,  0,              0x006 },
267   {     2, 3,  0,              0x007 },
268   {     0, 0, jbig2HuffmanEOT, 0     }
269 };
270
271 JBIG2HuffmanTable huffTableO[] = {
272   {     0, 1,  0,              0x000 },
273   {    -1, 3,  0,              0x004 },
274   {     1, 3,  0,              0x005 },
275   {    -2, 4,  0,              0x00c },
276   {     2, 4,  0,              0x00d },
277   {    -4, 5,  1,              0x01c },
278   {     3, 5,  1,              0x01d },
279   {    -8, 6,  2,              0x03c },
280   {     5, 6,  2,              0x03d },
281   {   -24, 7,  4,              0x07c },
282   {     9, 7,  4,              0x07d },
283   {   -25, 7, jbig2HuffmanLOW, 0x07e },
284   {    25, 7, 32,              0x07f },
285   {     0, 0, jbig2HuffmanEOT, 0     }
286 };
287
288 //------------------------------------------------------------------------
289 // JBIG2HuffmanDecoder
290 //------------------------------------------------------------------------
291
292 class JBIG2HuffmanDecoder {
293 public:
294
295   JBIG2HuffmanDecoder();
296   ~JBIG2HuffmanDecoder();
297   void setStream(Stream *strA) { str = strA; }
298
299   void reset();
300
301   // Returns false for OOB, otherwise sets *<x> and returns true.
302   GBool decodeInt(int *x, JBIG2HuffmanTable *table);
303
304   Guint readBits(Guint n);
305   Guint readBit();
306
307   // Sort the table by prefix length and assign prefix values.
308   void buildTable(JBIG2HuffmanTable *table, Guint len);
309
310 private:
311
312   Stream *str;
313   Guint buf;
314   Guint bufLen;
315 };
316
317 JBIG2HuffmanDecoder::JBIG2HuffmanDecoder() {
318   str = NULL;
319   reset();
320 }
321
322 JBIG2HuffmanDecoder::~JBIG2HuffmanDecoder() {
323 }
324
325 void JBIG2HuffmanDecoder::reset() {
326   buf = 0;
327   bufLen = 0;
328 }
329
330 //~ optimize this
331 GBool JBIG2HuffmanDecoder::decodeInt(int *x, JBIG2HuffmanTable *table) {
332   Guint i, len, prefix;
333
334   i = 0;
335   len = 0;
336   prefix = 0;
337   while (table[i].rangeLen != jbig2HuffmanEOT) {
338     while (len < table[i].prefixLen) {
339       prefix = (prefix << 1) | readBit();
340       ++len;
341     }
342     if (prefix == table[i].prefix) {
343       if (table[i].rangeLen == jbig2HuffmanOOB) {
344         return gFalse;
345       }
346       if (table[i].rangeLen == jbig2HuffmanLOW) {
347         *x = table[i].val - readBits(32);
348       } else if (table[i].rangeLen > 0) {
349         *x = table[i].val + readBits(table[i].rangeLen);
350       } else {
351         *x = table[i].val;
352       }
353       return gTrue;
354     }
355     ++i;
356   }
357   return gFalse;
358 }
359
360 Guint JBIG2HuffmanDecoder::readBits(Guint n) {
361   Guint x, mask, nLeft;
362
363   mask = (n == 32) ? 0xffffffff : ((1 << n) - 1);
364   if (bufLen >= n) {
365     x = (buf >> (bufLen - n)) & mask;
366     bufLen -= n;
367   } else {
368     x = buf & ((1 << bufLen) - 1);
369     nLeft = n - bufLen;
370     bufLen = 0;
371     while (nLeft >= 8) {
372       x = (x << 8) | (str->getChar() & 0xff);
373       nLeft -= 8;
374     }
375     if (nLeft > 0) {
376       buf = str->getChar();
377       bufLen = 8 - nLeft;
378       x = (x << nLeft) | ((buf >> bufLen) & ((1 << nLeft) - 1));
379     }
380   }
381   return x;
382 }
383
384 Guint JBIG2HuffmanDecoder::readBit() {
385   if (bufLen == 0) {
386     buf = str->getChar();
387     bufLen = 8;
388   }
389   --bufLen;
390   return (buf >> bufLen) & 1;
391 }
392
393 void JBIG2HuffmanDecoder::buildTable(JBIG2HuffmanTable *table, Guint len) {
394   Guint i, j, k, prefix;
395   JBIG2HuffmanTable tab;
396
397   // stable selection sort:
398   // - entries with prefixLen > 0, in ascending prefixLen order
399   // - entry with prefixLen = 0, rangeLen = EOT
400   // - all other entries with prefixLen = 0
401   // (on entry, table[len] has prefixLen = 0, rangeLen = EOT)
402   for (i = 0; i < len; ++i) {
403     for (j = i; j < len && table[j].prefixLen == 0; ++j) ;
404     if (j == len) {
405       break;
406     }
407     for (k = j + 1; k < len; ++k) {
408       if (table[k].prefixLen > 0 &&
409           table[k].prefixLen < table[j].prefixLen) {
410         j = k;
411       }
412     }
413     if (j != i) {
414       tab = table[j];
415       for (k = j; k > i; --k) {
416         table[k] = table[k - 1];
417       }
418       table[i] = tab;
419     }
420   }
421   table[i] = table[len];
422
423   // assign prefixes
424   i = 0;
425   prefix = 0;
426   table[i++].prefix = prefix++;
427   for (; table[i].rangeLen != jbig2HuffmanEOT; ++i) {
428     prefix <<= table[i].prefixLen - table[i-1].prefixLen;
429     table[i].prefix = prefix++;
430   }
431 }
432
433 //------------------------------------------------------------------------
434 // JBIG2MMRDecoder
435 //------------------------------------------------------------------------
436
437 class JBIG2MMRDecoder {
438 public:
439
440   JBIG2MMRDecoder();
441   ~JBIG2MMRDecoder();
442   void setStream(Stream *strA) { str = strA; }
443   void reset();
444   int get2DCode();
445   int getBlackCode();
446   int getWhiteCode();
447   Guint get24Bits();
448   void skipTo(Guint length);
449
450 private:
451
452   Stream *str;
453   Guint buf;
454   Guint bufLen;
455   Guint nBytesRead;
456 };
457
458 JBIG2MMRDecoder::JBIG2MMRDecoder() {
459   str = NULL;
460   reset();
461 }
462
463 JBIG2MMRDecoder::~JBIG2MMRDecoder() {
464 }
465
466 void JBIG2MMRDecoder::reset() {
467   buf = 0;
468   bufLen = 0;
469   nBytesRead = 0;
470 }
471
472 int JBIG2MMRDecoder::get2DCode() {
473   CCITTCode *p;
474
475   if (bufLen == 0) {
476     buf = str->getChar() & 0xff;
477     bufLen = 8;
478     ++nBytesRead;
479     p = &twoDimTab1[(buf >> 1) & 0x7f];
480   } else if (bufLen == 8) {
481     p = &twoDimTab1[(buf >> 1) & 0x7f];
482   } else {
483     p = &twoDimTab1[(buf << (7 - bufLen)) & 0x7f];
484     if (p->bits < 0 || p->bits > (int)bufLen) {
485       buf = (buf << 8) | (str->getChar() & 0xff);
486       bufLen += 8;
487       ++nBytesRead;
488       p = &twoDimTab1[(buf >> (bufLen - 7)) & 0x7f];
489     }
490   }
491   if (p->bits < 0) {
492     error(str->getPos(), "Bad two dim code in JBIG2 MMR stream");
493     return 0;
494   }
495   bufLen -= p->bits;
496   return p->n;
497 }
498
499 int JBIG2MMRDecoder::getWhiteCode() {
500   CCITTCode *p;
501   Guint code;
502
503   if (bufLen == 0) {
504     buf = str->getChar() & 0xff;
505     bufLen = 8;
506     ++nBytesRead;
507   }
508   while (1) {
509     if (bufLen >= 7 && ((buf >> (bufLen - 7)) & 0x7f) == 0) {
510       if (bufLen <= 12) {
511         code = buf << (12 - bufLen);
512       } else {
513         code = buf >> (bufLen - 12);
514       }
515       p = &whiteTab1[code & 0x1f];
516     } else {
517       if (bufLen <= 9) {
518         code = buf << (9 - bufLen);
519       } else {
520         code = buf >> (bufLen - 9);
521       }
522       p = &whiteTab2[code & 0x1ff];
523     }
524     if (p->bits > 0 && p->bits <= (int)bufLen) {
525       bufLen -= p->bits;
526       return p->n;
527     }
528     if (bufLen >= 12) {
529       break;
530     }
531     buf = (buf << 8) | (str->getChar() & 0xff);
532     bufLen += 8;
533     ++nBytesRead;
534   }
535   error(str->getPos(), "Bad white code in JBIG2 MMR stream");
536   // eat a bit and return a positive number so that the caller doesn't
537   // go into an infinite loop
538   --bufLen;
539   return 1;
540 }
541
542 int JBIG2MMRDecoder::getBlackCode() {
543   CCITTCode *p;
544   Guint code;
545
546   if (bufLen == 0) {
547     buf = str->getChar() & 0xff;
548     bufLen = 8;
549     ++nBytesRead;
550   }
551   while (1) {
552     if (bufLen >= 6 && ((buf >> (bufLen - 6)) & 0x3f) == 0) {
553       if (bufLen <= 13) {
554         code = buf << (13 - bufLen);
555       } else {
556         code = buf >> (bufLen - 13);
557       }
558       p = &blackTab1[code & 0x7f];
559     } else if (bufLen >= 4 && ((buf >> (bufLen - 4)) & 0x0f) == 0) {
560       if (bufLen <= 12) {
561         code = buf << (12 - bufLen);
562       } else {
563         code = buf >> (bufLen - 12);
564       }
565       p = &blackTab2[(code & 0xff) - 64];
566     } else {
567       if (bufLen <= 6) {
568         code = buf << (6 - bufLen);
569       } else {
570         code = buf >> (bufLen - 6);
571       }
572       p = &blackTab3[code & 0x3f];
573     }
574     if (p->bits > 0 && p->bits <= (int)bufLen) {
575       bufLen -= p->bits;
576       return p->n;
577     }
578     if (bufLen >= 13) {
579       break;
580     }
581     buf = (buf << 8) | (str->getChar() & 0xff);
582     bufLen += 8;
583     ++nBytesRead;
584   }
585   error(str->getPos(), "Bad black code in JBIG2 MMR stream");
586   // eat a bit and return a positive number so that the caller doesn't
587   // go into an infinite loop
588   --bufLen;
589   return 1;
590 }
591
592 Guint JBIG2MMRDecoder::get24Bits() {
593   while (bufLen < 24) {
594     buf = (buf << 8) | (str->getChar() & 0xff);
595     bufLen += 8;
596     ++nBytesRead;
597   }
598   return (buf >> (bufLen - 24)) & 0xffffff;
599 }
600
601 void JBIG2MMRDecoder::skipTo(Guint length) {
602   while (nBytesRead < length) {
603     str->getChar();
604     ++nBytesRead;
605   }
606 }
607
608 //------------------------------------------------------------------------
609 // JBIG2Segment
610 //------------------------------------------------------------------------
611
612 enum JBIG2SegmentType {
613   jbig2SegBitmap,
614   jbig2SegSymbolDict,
615   jbig2SegPatternDict,
616   jbig2SegCodeTable
617 };
618
619 class JBIG2Segment {
620 public:
621
622   JBIG2Segment(Guint segNumA) { segNum = segNumA; }
623   virtual ~JBIG2Segment() {}
624   void setSegNum(Guint segNumA) { segNum = segNumA; }
625   Guint getSegNum() { return segNum; }
626   virtual JBIG2SegmentType getType() = 0;
627
628 private:
629
630   Guint segNum;
631 };
632
633 //------------------------------------------------------------------------
634 // JBIG2Bitmap
635 //------------------------------------------------------------------------
636
637 struct JBIG2BitmapPtr {
638   Guchar *p;
639   int shift;
640   int x;
641 };
642
643 class JBIG2Bitmap: public JBIG2Segment {
644 public:
645
646   JBIG2Bitmap(Guint segNumA, int wA, int hA);
647   virtual ~JBIG2Bitmap();
648   virtual JBIG2SegmentType getType() { return jbig2SegBitmap; }
649   JBIG2Bitmap *copy() { return new JBIG2Bitmap(0, this); }
650   JBIG2Bitmap *getSlice(Guint x, Guint y, Guint wA, Guint hA);
651   void expand(int newH, Guint pixel);
652   void clearToZero();
653   void clearToOne();
654   int getWidth() { return w; }
655   int getHeight() { return h; }
656   int getPixel(int x, int y)
657     { return (x < 0 || x >= w || y < 0 || y >= h) ? 0 :
658              (data[y * line + (x >> 3)] >> (7 - (x & 7))) & 1; }
659   void setPixel(int x, int y)
660     { data[y * line + (x >> 3)] |= 1 << (7 - (x & 7)); }
661   void clearPixel(int x, int y)
662     { data[y * line + (x >> 3)] &= 0x7f7f >> (x & 7); }
663   void getPixelPtr(int x, int y, JBIG2BitmapPtr *ptr);
664   int nextPixel(JBIG2BitmapPtr *ptr);
665   void duplicateRow(int yDest, int ySrc);
666   void combine(JBIG2Bitmap *bitmap, int x, int y, Guint combOp);
667   Guchar *getDataPtr() { return data; }
668   int getDataSize() { return h * line; }
669
670 private:
671
672   JBIG2Bitmap(Guint segNumA, JBIG2Bitmap *bitmap);
673
674   int w, h, line;
675   Guchar *data;
676 };
677
678 JBIG2Bitmap::JBIG2Bitmap(Guint segNumA, int wA, int hA):
679   JBIG2Segment(segNumA)
680 {
681   w = wA;
682   h = hA;
683   line = (wA + 7) >> 3;
684   data = (Guchar *)gmalloc(h * line);
685 }
686
687 JBIG2Bitmap::JBIG2Bitmap(Guint segNumA, JBIG2Bitmap *bitmap):
688   JBIG2Segment(segNumA)
689 {
690   w = bitmap->w;
691   h = bitmap->h;
692   line = bitmap->line;
693   data = (Guchar *)gmalloc(h * line);
694   memcpy(data, bitmap->data, h * line);
695 }
696
697 JBIG2Bitmap::~JBIG2Bitmap() {
698   gfree(data);
699 }
700
701 //~ optimize this
702 JBIG2Bitmap *JBIG2Bitmap::getSlice(Guint x, Guint y, Guint wA, Guint hA) {
703   JBIG2Bitmap *slice;
704   Guint xx, yy;
705
706   slice = new JBIG2Bitmap(0, wA, hA);
707   slice->clearToZero();
708   for (yy = 0; yy < hA; ++yy) {
709     for (xx = 0; xx < wA; ++xx) {
710       if (getPixel(x + xx, y + yy)) {
711         slice->setPixel(xx, yy);
712       }
713     }
714   }
715   return slice;
716 }
717
718 void JBIG2Bitmap::expand(int newH, Guint pixel) {
719   if (newH <= h) {
720     return;
721   }
722   data = (Guchar *)grealloc(data, newH * line);
723   if (pixel) {
724     memset(data + h * line, 0xff, (newH - h) * line);
725   } else {
726     memset(data + h * line, 0x00, (newH - h) * line);
727   }
728   h = newH;
729 }
730
731 void JBIG2Bitmap::clearToZero() {
732   memset(data, 0, h * line);
733 }
734
735 void JBIG2Bitmap::clearToOne() {
736   memset(data, 0xff, h * line);
737 }
738
739 inline void JBIG2Bitmap::getPixelPtr(int x, int y, JBIG2BitmapPtr *ptr) {
740   if (y < 0 || y >= h || x >= w) {
741     ptr->p = NULL;
742   } else if (x < 0) {
743     ptr->p = &data[y * line];
744     ptr->shift = 7;
745     ptr->x = x;
746   } else {
747     ptr->p = &data[y * line + (x >> 3)];
748     ptr->shift = 7 - (x & 7);
749     ptr->x = x;
750   }
751 }
752
753 inline int JBIG2Bitmap::nextPixel(JBIG2BitmapPtr *ptr) {
754   int pix;
755
756   if (!ptr->p) {
757     pix = 0;
758   } else if (ptr->x < 0) {
759     ++ptr->x;
760     pix = 0;
761   } else {
762     pix = (*ptr->p >> ptr->shift) & 1;
763     if (++ptr->x == w) {
764       ptr->p = NULL;
765     } else if (ptr->shift == 0) {
766       ++ptr->p;
767       ptr->shift = 7;
768     } else {
769       --ptr->shift;
770     }
771   }
772   return pix;
773 }
774
775 void JBIG2Bitmap::duplicateRow(int yDest, int ySrc) {
776   memcpy(data + yDest * line, data + ySrc * line, line);
777 }
778
779 void JBIG2Bitmap::combine(JBIG2Bitmap *bitmap, int x, int y,
780                           Guint combOp) {
781   int x0, x1, y0, y1, xx, yy;
782   Guchar *srcPtr, *destPtr;
783   Guint src0, src1, src, dest, s1, s2, m1, m2, m3;
784   GBool oneByte;
785
786   if (y < 0) {
787     y0 = -y;
788   } else {
789     y0 = 0;
790   }
791   if (y + bitmap->h > h) {
792     y1 = h - y;
793   } else {
794     y1 = bitmap->h;
795   }
796   if (y0 >= y1) {
797     return;
798   }
799
800   if (x >= 0) {
801     x0 = x & ~7;
802   } else {
803     x0 = 0;
804   }
805   x1 = x + bitmap->w;
806   if (x1 > w) {
807     x1 = w;
808   }
809   if (x0 >= x1) {
810     return;
811   }
812
813   s1 = x & 7;
814   s2 = 8 - s1;
815   m1 = 0xff >> (x1 & 7);
816   m2 = 0xff << (((x1 & 7) == 0) ? 0 : 8 - (x1 & 7));
817   m3 = (0xff >> s1) & m2;
818
819   oneByte = x0 == ((x1 - 1) & ~7);
820
821   for (yy = y0; yy < y1; ++yy) {
822
823     // one byte per line -- need to mask both left and right side
824     if (oneByte) {
825       if (x >= 0) {
826         destPtr = data + (y + yy) * line + (x >> 3);
827         srcPtr = bitmap->data + yy * bitmap->line;
828         dest = *destPtr;
829         src1 = *srcPtr;
830         switch (combOp) {
831         case 0: // or
832           dest |= (src1 >> s1) & m2;
833           break;
834         case 1: // and
835           dest &= ((0xff00 | src1) >> s1) | m1;
836           break;
837         case 2: // xor
838           dest ^= (src1 >> s1) & m2;
839           break;
840         case 3: // xnor
841           dest ^= ((src1 ^ 0xff) >> s1) & m2;
842           break;
843         case 4: // replace
844           dest = (dest & ~m3) | ((src1 >> s1) & m3);
845           break;
846         }
847         *destPtr = dest;
848       } else {
849         destPtr = data + (y + yy) * line;
850         srcPtr = bitmap->data + yy * bitmap->line + (-x >> 3);
851         dest = *destPtr;
852         src1 = *srcPtr;
853         switch (combOp) {
854         case 0: // or
855           dest |= src1 & m2;
856           break;
857         case 1: // and
858           dest &= src1 | m1;
859           break;
860         case 2: // xor
861           dest ^= src1 & m2;
862           break;
863         case 3: // xnor
864           dest ^= (src1 ^ 0xff) & m2;
865           break;
866         case 4: // replace
867           dest = (src1 & m2) | (dest & m1);
868           break;
869         }
870         *destPtr = dest;
871       }
872
873     // multiple bytes per line -- need to mask left side of left-most
874     // byte and right side of right-most byte
875     } else {
876
877       // left-most byte
878       if (x >= 0) {
879         destPtr = data + (y + yy) * line + (x >> 3);
880         srcPtr = bitmap->data + yy * bitmap->line;
881         src1 = *srcPtr++;
882         dest = *destPtr;
883         switch (combOp) {
884         case 0: // or
885           dest |= src1 >> s1;
886           break;
887         case 1: // and
888           dest &= (0xff00 | src1) >> s1;
889           break;
890         case 2: // xor
891           dest ^= src1 >> s1;
892           break;
893         case 3: // xnor
894           dest ^= (src1 ^ 0xff) >> s1;
895           break;
896         case 4: // replace
897           dest = (dest & (0xff << s2)) | (src1 >> s1);
898           break;
899         }
900         *destPtr++ = dest;
901         xx = x0 + 8;
902       } else {
903         destPtr = data + (y + yy) * line;
904         srcPtr = bitmap->data + yy * bitmap->line + (-x >> 3);
905         src1 = *srcPtr++;
906         xx = x0;
907       }
908
909       // middle bytes
910       for (; xx < x1 - 8; xx += 8) {
911         dest = *destPtr;
912         src0 = src1;
913         src1 = *srcPtr++;
914         src = (((src0 << 8) | src1) >> s1) & 0xff;
915         switch (combOp) {
916         case 0: // or
917           dest |= src;
918           break;
919         case 1: // and
920           dest &= src;
921           break;
922         case 2: // xor
923           dest ^= src;
924           break;
925         case 3: // xnor
926           dest ^= src ^ 0xff;
927           break;
928         case 4: // replace
929           dest = src;
930           break;
931         }
932         *destPtr++ = dest;
933       }
934
935       // right-most byte
936       dest = *destPtr;
937       src0 = src1;
938       src1 = *srcPtr++;
939       src = (((src0 << 8) | src1) >> s1) & 0xff;
940       switch (combOp) {
941       case 0: // or
942         dest |= src & m2;
943         break;
944       case 1: // and
945         dest &= src | m1;
946         break;
947       case 2: // xor
948         dest ^= src & m2;
949         break;
950       case 3: // xnor
951         dest ^= (src ^ 0xff) & m2;
952         break;
953       case 4: // replace
954         dest = (src & m2) | (dest & m1);
955         break;
956       }
957       *destPtr = dest;
958     }
959   }
960 }
961
962 //------------------------------------------------------------------------
963 // JBIG2SymbolDict
964 //------------------------------------------------------------------------
965
966 class JBIG2SymbolDict: public JBIG2Segment {
967 public:
968
969   JBIG2SymbolDict(Guint segNumA, Guint sizeA);
970   virtual ~JBIG2SymbolDict();
971   virtual JBIG2SegmentType getType() { return jbig2SegSymbolDict; }
972   Guint getSize() { return size; }
973   void setBitmap(Guint idx, JBIG2Bitmap *bitmap) { bitmaps[idx] = bitmap; }
974   JBIG2Bitmap *getBitmap(Guint idx) { return bitmaps[idx]; }
975   void setGenericRegionStats(JArithmeticDecoderStats *stats)
976     { genericRegionStats = stats; }
977   void setRefinementRegionStats(JArithmeticDecoderStats *stats)
978     { refinementRegionStats = stats; }
979   JArithmeticDecoderStats *getGenericRegionStats()
980     { return genericRegionStats; }
981   JArithmeticDecoderStats *getRefinementRegionStats()
982     { return refinementRegionStats; }
983
984 private:
985
986   Guint size;
987   JBIG2Bitmap **bitmaps;
988   JArithmeticDecoderStats *genericRegionStats;
989   JArithmeticDecoderStats *refinementRegionStats;
990 };
991
992 JBIG2SymbolDict::JBIG2SymbolDict(Guint segNumA, Guint sizeA):
993   JBIG2Segment(segNumA)
994 {
995   size = sizeA;
996   bitmaps = (JBIG2Bitmap **)gmalloc(size * sizeof(JBIG2Bitmap *));
997   genericRegionStats = NULL;
998   refinementRegionStats = NULL;
999 }
1000
1001 JBIG2SymbolDict::~JBIG2SymbolDict() {
1002   Guint i;
1003
1004   for (i = 0; i < size; ++i) {
1005     delete bitmaps[i];
1006   }
1007   gfree(bitmaps);
1008   if (genericRegionStats) {
1009     delete genericRegionStats;
1010   }
1011   if (refinementRegionStats) {
1012     delete refinementRegionStats;
1013   }
1014 }
1015
1016 //------------------------------------------------------------------------
1017 // JBIG2PatternDict
1018 //------------------------------------------------------------------------
1019
1020 class JBIG2PatternDict: public JBIG2Segment {
1021 public:
1022
1023   JBIG2PatternDict(Guint segNumA, Guint sizeA);
1024   virtual ~JBIG2PatternDict();
1025   virtual JBIG2SegmentType getType() { return jbig2SegPatternDict; }
1026   Guint getSize() { return size; }
1027   void setBitmap(Guint idx, JBIG2Bitmap *bitmap) { bitmaps[idx] = bitmap; }
1028   JBIG2Bitmap *getBitmap(Guint idx) { return bitmaps[idx]; }
1029
1030 private:
1031
1032   Guint size;
1033   JBIG2Bitmap **bitmaps;
1034 };
1035
1036 JBIG2PatternDict::JBIG2PatternDict(Guint segNumA, Guint sizeA):
1037   JBIG2Segment(segNumA)
1038 {
1039   size = sizeA;
1040   bitmaps = (JBIG2Bitmap **)gmalloc(size * sizeof(JBIG2Bitmap *));
1041 }
1042
1043 JBIG2PatternDict::~JBIG2PatternDict() {
1044   Guint i;
1045
1046   for (i = 0; i < size; ++i) {
1047     delete bitmaps[i];
1048   }
1049   gfree(bitmaps);
1050 }
1051
1052 //------------------------------------------------------------------------
1053 // JBIG2CodeTable
1054 //------------------------------------------------------------------------
1055
1056 class JBIG2CodeTable: public JBIG2Segment {
1057 public:
1058
1059   JBIG2CodeTable(Guint segNumA, JBIG2HuffmanTable *tableA);
1060   virtual ~JBIG2CodeTable();
1061   virtual JBIG2SegmentType getType() { return jbig2SegCodeTable; }
1062   JBIG2HuffmanTable *getHuffTable() { return table; }
1063
1064 private:
1065
1066   JBIG2HuffmanTable *table;
1067 };
1068
1069 JBIG2CodeTable::JBIG2CodeTable(Guint segNumA, JBIG2HuffmanTable *tableA):
1070   JBIG2Segment(segNumA)
1071 {
1072   table = tableA;
1073 }
1074
1075 JBIG2CodeTable::~JBIG2CodeTable() {
1076   gfree(table);
1077 }
1078
1079 //------------------------------------------------------------------------
1080 // JBIG2Stream
1081 //------------------------------------------------------------------------
1082
1083 JBIG2Stream::JBIG2Stream(Stream *strA, Object *globalsStream):
1084   FilterStream(strA)
1085 {
1086   pageBitmap = NULL;
1087
1088   arithDecoder = new JArithmeticDecoder();
1089   genericRegionStats = new JArithmeticDecoderStats(1 << 1);
1090   refinementRegionStats = new JArithmeticDecoderStats(1 << 1);
1091   iadhStats = new JArithmeticDecoderStats(1 << 9);
1092   iadwStats = new JArithmeticDecoderStats(1 << 9);
1093   iaexStats = new JArithmeticDecoderStats(1 << 9);
1094   iaaiStats = new JArithmeticDecoderStats(1 << 9);
1095   iadtStats = new JArithmeticDecoderStats(1 << 9);
1096   iaitStats = new JArithmeticDecoderStats(1 << 9);
1097   iafsStats = new JArithmeticDecoderStats(1 << 9);
1098   iadsStats = new JArithmeticDecoderStats(1 << 9);
1099   iardxStats = new JArithmeticDecoderStats(1 << 9);
1100   iardyStats = new JArithmeticDecoderStats(1 << 9);
1101   iardwStats = new JArithmeticDecoderStats(1 << 9);
1102   iardhStats = new JArithmeticDecoderStats(1 << 9);
1103   iariStats = new JArithmeticDecoderStats(1 << 9);
1104   iaidStats = new JArithmeticDecoderStats(1 << 1);
1105   huffDecoder = new JBIG2HuffmanDecoder();
1106   mmrDecoder = new JBIG2MMRDecoder();
1107
1108   segments = globalSegments = new GList();
1109   if (globalsStream->isStream()) {
1110     curStr = globalsStream->getStream();
1111     curStr->reset();
1112     arithDecoder->setStream(curStr);
1113     huffDecoder->setStream(curStr);
1114     mmrDecoder->setStream(curStr);
1115     readSegments();
1116   }
1117
1118   segments = NULL;
1119   curStr = NULL;
1120   dataPtr = dataEnd = NULL;
1121 }
1122
1123 JBIG2Stream::~JBIG2Stream() {
1124   delete arithDecoder;
1125   delete genericRegionStats;
1126   delete refinementRegionStats;
1127   delete iadhStats;
1128   delete iadwStats;
1129   delete iaexStats;
1130   delete iaaiStats;
1131   delete iadtStats;
1132   delete iaitStats;
1133   delete iafsStats;
1134   delete iadsStats;
1135   delete iardxStats;
1136   delete iardyStats;
1137   delete iardwStats;
1138   delete iardhStats;
1139   delete iariStats;
1140   delete iaidStats;
1141   delete huffDecoder;
1142   delete mmrDecoder;
1143   if (pageBitmap) {
1144     delete pageBitmap;
1145   }
1146   if (segments) {
1147     deleteGList(segments, JBIG2Segment);
1148   }
1149   if (globalSegments) {
1150     deleteGList(globalSegments, JBIG2Segment);
1151   }
1152   delete str;
1153 }
1154
1155 void JBIG2Stream::reset() {
1156   if (pageBitmap) {
1157     delete pageBitmap;
1158     pageBitmap = NULL;
1159   }
1160   if (segments) {
1161     deleteGList(segments, JBIG2Segment);
1162   }
1163   segments = new GList();
1164
1165   curStr = str;
1166   curStr->reset();
1167   arithDecoder->setStream(curStr);
1168   huffDecoder->setStream(curStr);
1169   mmrDecoder->setStream(curStr);
1170   readSegments();
1171
1172   if (pageBitmap) {
1173     dataPtr = pageBitmap->getDataPtr();
1174     dataEnd = dataPtr + pageBitmap->getDataSize();
1175   } else {
1176     dataPtr = NULL;
1177   }
1178 }
1179
1180 int JBIG2Stream::getChar() {
1181   if (dataPtr && dataPtr < dataEnd) {
1182     return (*dataPtr++ ^ 0xff) & 0xff;
1183   }
1184   return EOF;
1185 }
1186
1187 int JBIG2Stream::lookChar() {
1188   if (dataPtr && dataPtr < dataEnd) {
1189     return (*dataPtr ^ 0xff) & 0xff;
1190   }
1191   return EOF;
1192 }
1193
1194 GString *JBIG2Stream::getPSFilter(int psLevel, char *indent) {
1195   return NULL;
1196 }
1197
1198 GBool JBIG2Stream::isBinary(GBool last) {
1199   return str->isBinary(gTrue);
1200 }
1201
1202 void JBIG2Stream::readSegments() {
1203   Guint segNum, segFlags, segType, page, segLength;
1204   Guint refFlags, nRefSegs;
1205   Guint *refSegs;
1206   int c1, c2, c3;
1207   Guint i;
1208
1209   while (readULong(&segNum)) {
1210
1211     // segment header flags
1212     if (!readUByte(&segFlags)) {
1213       goto eofError1;
1214     }
1215     segType = segFlags & 0x3f;
1216
1217     // referred-to segment count and retention flags
1218     if (!readUByte(&refFlags)) {
1219       goto eofError1;
1220     }
1221     nRefSegs = refFlags >> 5;
1222     if (nRefSegs == 7) {
1223       if ((c1 = curStr->getChar()) == EOF ||
1224           (c2 = curStr->getChar()) == EOF ||
1225           (c3 = curStr->getChar()) == EOF) {
1226         goto eofError1;
1227       }
1228       refFlags = (refFlags << 24) | (c1 << 16) | (c2 << 8) | c3;
1229       nRefSegs = refFlags & 0x1fffffff;
1230       for (i = 0; i < (nRefSegs + 9) >> 3; ++i) {
1231         c1 = curStr->getChar();
1232       }
1233     }
1234
1235     // referred-to segment numbers
1236     refSegs = (Guint *)gmalloc(nRefSegs * sizeof(Guint));
1237     if (segNum <= 256) {
1238       for (i = 0; i < nRefSegs; ++i) {
1239         if (!readUByte(&refSegs[i])) {
1240           goto eofError2;
1241         }
1242       }
1243     } else if (segNum <= 65536) {
1244       for (i = 0; i < nRefSegs; ++i) {
1245         if (!readUWord(&refSegs[i])) {
1246           goto eofError2;
1247         }
1248       }
1249     } else {
1250       for (i = 0; i < nRefSegs; ++i) {
1251         if (!readULong(&refSegs[i])) {
1252           goto eofError2;
1253         }
1254       }
1255     }
1256
1257     // segment page association
1258     if (segFlags & 0x40) {
1259       if (!readULong(&page)) {
1260         goto eofError2;
1261       }
1262     } else {
1263       if (!readUByte(&page)) {
1264         goto eofError2;
1265       }
1266     }
1267
1268     // segment data length
1269     if (!readULong(&segLength)) {
1270       goto eofError2;
1271     }
1272
1273     // read the segment data
1274     switch (segType) {
1275     case 0:
1276       readSymbolDictSeg(segNum, segLength, refSegs, nRefSegs);
1277       break;
1278     case 4:
1279       readTextRegionSeg(segNum, gFalse, gFalse, segLength, refSegs, nRefSegs);
1280       break;
1281     case 6:
1282       readTextRegionSeg(segNum, gTrue, gFalse, segLength, refSegs, nRefSegs);
1283       break;
1284     case 7:
1285       readTextRegionSeg(segNum, gTrue, gTrue, segLength, refSegs, nRefSegs);
1286       break;
1287     case 16:
1288       readPatternDictSeg(segNum, segLength);
1289       break;
1290     case 20:
1291       readHalftoneRegionSeg(segNum, gFalse, gFalse, segLength,
1292                             refSegs, nRefSegs);
1293       break;
1294     case 22:
1295       readHalftoneRegionSeg(segNum, gTrue, gFalse, segLength,
1296                             refSegs, nRefSegs);
1297       break;
1298     case 23:
1299       readHalftoneRegionSeg(segNum, gTrue, gTrue, segLength,
1300                             refSegs, nRefSegs);
1301       break;
1302     case 36:
1303       readGenericRegionSeg(segNum, gFalse, gFalse, segLength);
1304       break;
1305     case 38:
1306       readGenericRegionSeg(segNum, gTrue, gFalse, segLength);
1307       break;
1308     case 39:
1309       readGenericRegionSeg(segNum, gTrue, gTrue, segLength);
1310       break;
1311     case 40:
1312       readGenericRefinementRegionSeg(segNum, gFalse, gFalse, segLength,
1313                                      refSegs, nRefSegs);
1314       break;
1315     case 42:
1316       readGenericRefinementRegionSeg(segNum, gTrue, gFalse, segLength,
1317                                      refSegs, nRefSegs);
1318       break;
1319     case 43:
1320       readGenericRefinementRegionSeg(segNum, gTrue, gTrue, segLength,
1321                                      refSegs, nRefSegs);
1322       break;
1323     case 48:
1324       readPageInfoSeg(segLength);
1325       break;
1326     case 50:
1327       readEndOfStripeSeg(segLength);
1328       break;
1329     case 52:
1330       readProfilesSeg(segLength);
1331       break;
1332     case 53:
1333       readCodeTableSeg(segNum, segLength);
1334       break;
1335     case 62:
1336       readExtensionSeg(segLength);
1337       break;
1338     default:
1339       error(getPos(), "Unknown segment type in JBIG2 stream");
1340       for (i = 0; i < segLength; ++i) {
1341         if ((c1 = curStr->getChar()) == EOF) {
1342           goto eofError2;
1343         }
1344       }
1345       break;
1346     }
1347
1348     gfree(refSegs);
1349   }
1350
1351   return;
1352
1353  eofError2:
1354   gfree(refSegs);
1355  eofError1:
1356   error(getPos(), "Unexpected EOF in JBIG2 stream");
1357 }
1358
1359 void JBIG2Stream::readSymbolDictSeg(Guint segNum, Guint length,
1360                                     Guint *refSegs, Guint nRefSegs) {
1361   JBIG2SymbolDict *symbolDict;
1362   JBIG2HuffmanTable *huffDHTable, *huffDWTable;
1363   JBIG2HuffmanTable *huffBMSizeTable, *huffAggInstTable;
1364   JBIG2Segment *seg;
1365   GList *codeTables;
1366   JBIG2SymbolDict *inputSymbolDict;
1367   Guint flags, sdTemplate, sdrTemplate, huff, refAgg;
1368   Guint huffDH, huffDW, huffBMSize, huffAggInst;
1369   Guint contextUsed, contextRetained;
1370   int sdATX[4], sdATY[4], sdrATX[2], sdrATY[2];
1371   Guint numExSyms, numNewSyms, numInputSyms, symCodeLen;
1372   JBIG2Bitmap **bitmaps;
1373   JBIG2Bitmap *collBitmap, *refBitmap;
1374   Guint *symWidths;
1375   Guint symHeight, symWidth, totalWidth, x, symID;
1376   int dh, dw, refAggNum, refDX, refDY, bmSize;
1377   GBool ex;
1378   int run, cnt;
1379   Guint i, j, k;
1380   Guchar *p;
1381
1382   // symbol dictionary flags
1383   if (!readUWord(&flags)) {
1384     goto eofError;
1385   }
1386   sdTemplate = (flags >> 10) & 3;
1387   sdrTemplate = (flags >> 12) & 1;
1388   huff = flags & 1;
1389   refAgg = (flags >> 1) & 1;
1390   huffDH = (flags >> 2) & 3;
1391   huffDW = (flags >> 4) & 3;
1392   huffBMSize = (flags >> 6) & 1;
1393   huffAggInst = (flags >> 7) & 1;
1394   contextUsed = (flags >> 8) & 1;
1395   contextRetained = (flags >> 9) & 1;
1396
1397   // symbol dictionary AT flags
1398   if (!huff) {
1399     if (sdTemplate == 0) {
1400       if (!readByte(&sdATX[0]) ||
1401           !readByte(&sdATY[0]) ||
1402           !readByte(&sdATX[1]) ||
1403           !readByte(&sdATY[1]) ||
1404           !readByte(&sdATX[2]) ||
1405           !readByte(&sdATY[2]) ||
1406           !readByte(&sdATX[3]) ||
1407           !readByte(&sdATY[3])) {
1408         goto eofError;
1409       }
1410     } else {
1411       if (!readByte(&sdATX[0]) ||
1412           !readByte(&sdATY[0])) {
1413         goto eofError;
1414       }
1415     }
1416   }
1417
1418   // symbol dictionary refinement AT flags
1419   if (refAgg && !sdrTemplate) {
1420     if (!readByte(&sdrATX[0]) ||
1421         !readByte(&sdrATY[0]) ||
1422         !readByte(&sdrATX[1]) ||
1423         !readByte(&sdrATY[1])) {
1424       goto eofError;
1425     }
1426   }
1427
1428   // SDNUMEXSYMS and SDNUMNEWSYMS
1429   if (!readULong(&numExSyms) || !readULong(&numNewSyms)) {
1430     goto eofError;
1431   }
1432
1433   // get referenced segments: input symbol dictionaries and code tables
1434   codeTables = new GList();
1435   numInputSyms = 0;
1436   for (i = 0; i < nRefSegs; ++i) {
1437     seg = findSegment(refSegs[i]);
1438     if (seg->getType() == jbig2SegSymbolDict) {
1439       numInputSyms += ((JBIG2SymbolDict *)seg)->getSize();
1440     } else if (seg->getType() == jbig2SegCodeTable) {
1441       codeTables->append(seg);
1442     }
1443   }
1444
1445   // compute symbol code length
1446   symCodeLen = 0;
1447   i = 1;
1448   while (i < numInputSyms + numNewSyms) {
1449     ++symCodeLen;
1450     i <<= 1;
1451   }
1452
1453   // get the input symbol bitmaps
1454   bitmaps = (JBIG2Bitmap **)gmalloc((numInputSyms + numNewSyms) *
1455                                     sizeof(JBIG2Bitmap *));
1456   k = 0;
1457   inputSymbolDict = NULL;
1458   for (i = 0; i < nRefSegs; ++i) {
1459     seg = findSegment(refSegs[i]);
1460     if (seg->getType() == jbig2SegSymbolDict) {
1461       inputSymbolDict = (JBIG2SymbolDict *)seg;
1462       for (j = 0; j < inputSymbolDict->getSize(); ++j) {
1463         bitmaps[k++] = inputSymbolDict->getBitmap(j);
1464       }
1465     }
1466   }
1467
1468   // get the Huffman tables
1469   huffDHTable = huffDWTable = NULL; // make gcc happy
1470   huffBMSizeTable = huffAggInstTable = NULL; // make gcc happy
1471   i = 0;
1472   if (huff) {
1473     if (huffDH == 0) {
1474       huffDHTable = huffTableD;
1475     } else if (huffDH == 1) {
1476       huffDHTable = huffTableE;
1477     } else {
1478       huffDHTable = ((JBIG2CodeTable *)codeTables->get(i++))->getHuffTable();
1479     }
1480     if (huffDW == 0) {
1481       huffDWTable = huffTableB;
1482     } else if (huffDW == 1) {
1483       huffDWTable = huffTableC;
1484     } else {
1485       huffDWTable = ((JBIG2CodeTable *)codeTables->get(i++))->getHuffTable();
1486     }
1487     if (huffBMSize == 0) {
1488       huffBMSizeTable = huffTableA;
1489     } else {
1490       huffBMSizeTable =
1491           ((JBIG2CodeTable *)codeTables->get(i++))->getHuffTable();
1492     }
1493     if (huffAggInst == 0) {
1494       huffAggInstTable = huffTableA;
1495     } else {
1496       huffAggInstTable =
1497           ((JBIG2CodeTable *)codeTables->get(i++))->getHuffTable();
1498     }
1499   }
1500   delete codeTables;
1501
1502   // set up the Huffman decoder
1503   if (huff) {
1504     huffDecoder->reset();
1505
1506   // set up the arithmetic decoder
1507   } else {
1508     if (contextUsed && inputSymbolDict) {
1509       resetGenericStats(sdTemplate, inputSymbolDict->getGenericRegionStats());
1510     } else {
1511       resetGenericStats(sdTemplate, NULL);
1512     }
1513     resetIntStats(symCodeLen);
1514     arithDecoder->start();
1515   }
1516
1517   // set up the arithmetic decoder for refinement/aggregation
1518   if (refAgg) {
1519     if (contextUsed && inputSymbolDict) {
1520       resetRefinementStats(sdrTemplate,
1521                            inputSymbolDict->getRefinementRegionStats());
1522     } else {
1523       resetRefinementStats(sdrTemplate, NULL);
1524     }
1525   }
1526
1527   // allocate symbol widths storage
1528   symWidths = NULL;
1529   if (huff && !refAgg) {
1530     symWidths = (Guint *)gmalloc(numNewSyms * sizeof(Guint));
1531   }
1532
1533   symHeight = 0;
1534   i = 0;
1535   while (i < numNewSyms) {
1536
1537     // read the height class delta height
1538     if (huff) {
1539       huffDecoder->decodeInt(&dh, huffDHTable);
1540     } else {
1541       arithDecoder->decodeInt(&dh, iadhStats);
1542     }
1543     symHeight += dh;
1544     symWidth = 0;
1545     totalWidth = 0;
1546     j = i;
1547
1548     // read the symbols in this height class
1549     while (1) {
1550
1551       // read the delta width
1552       if (huff) {
1553         if (!huffDecoder->decodeInt(&dw, huffDWTable)) {
1554           break;
1555         }
1556       } else {
1557         if (!arithDecoder->decodeInt(&dw, iadwStats)) {
1558           break;
1559         }
1560       }
1561       symWidth += dw;
1562
1563       // using a collective bitmap, so don't read a bitmap here
1564       if (huff && !refAgg) {
1565         symWidths[i] = symWidth;
1566         totalWidth += symWidth;
1567
1568       // refinement/aggregate coding
1569       } else if (refAgg) {
1570         if (huff) {
1571           if (!huffDecoder->decodeInt(&refAggNum, huffAggInstTable)) {
1572             break;
1573           }
1574         } else {
1575           if (!arithDecoder->decodeInt(&refAggNum, iaaiStats)) {
1576             break;
1577           }
1578         }
1579 #if 0 //~ This special case was added about a year before the final draft
1580       //~ of the JBIG2 spec was released.  I have encountered some old
1581       //~ JBIG2 images that predate it.
1582         if (0) {
1583 #else
1584         if (refAggNum == 1) {
1585 #endif
1586           if (huff) {
1587             symID = huffDecoder->readBits(symCodeLen);
1588             huffDecoder->decodeInt(&refDX, huffTableO);
1589             huffDecoder->decodeInt(&refDY, huffTableO);
1590             huffDecoder->decodeInt(&bmSize, huffTableA);
1591             huffDecoder->reset();
1592             arithDecoder->start();
1593           } else {
1594             symID = arithDecoder->decodeIAID(symCodeLen, iaidStats);
1595             arithDecoder->decodeInt(&refDX, iardxStats);
1596             arithDecoder->decodeInt(&refDY, iardyStats);
1597           }
1598           refBitmap = bitmaps[symID];
1599           bitmaps[numInputSyms + i] =
1600               readGenericRefinementRegion(symWidth, symHeight,
1601                                           sdrTemplate, gFalse,
1602                                           refBitmap, refDX, refDY,
1603                                           sdrATX, sdrATY);
1604           //~ do we need to use the bmSize value here (in Huffman mode)?
1605         } else {
1606           bitmaps[numInputSyms + i] =
1607               readTextRegion(huff, gTrue, symWidth, symHeight,
1608                              refAggNum, 0, numInputSyms + i, NULL,
1609                              symCodeLen, bitmaps, 0, 0, 0, 1, 0,
1610                              huffTableF, huffTableH, huffTableK, huffTableO,
1611                              huffTableO, huffTableO, huffTableO, huffTableA,
1612                              sdrTemplate, sdrATX, sdrATY);
1613         }
1614
1615       // non-ref/agg coding
1616       } else {
1617         bitmaps[numInputSyms + i] =
1618             readGenericBitmap(gFalse, symWidth, symHeight,
1619                               sdTemplate, gFalse, gFalse, NULL,
1620                               sdATX, sdATY, 0);
1621       }
1622
1623       ++i;
1624     }
1625
1626     // read the collective bitmap
1627     if (huff && !refAgg) {
1628       huffDecoder->decodeInt(&bmSize, huffBMSizeTable);
1629       huffDecoder->reset();
1630       if (bmSize == 0) {
1631         collBitmap = new JBIG2Bitmap(0, totalWidth, symHeight);
1632         bmSize = symHeight * ((totalWidth + 7) >> 3);
1633         p = collBitmap->getDataPtr();
1634         for (k = 0; k < (Guint)bmSize; ++k) {
1635           *p++ = curStr->getChar();
1636         }
1637       } else {
1638         collBitmap = readGenericBitmap(gTrue, totalWidth, symHeight,
1639                                        0, gFalse, gFalse, NULL, NULL, NULL,
1640                                        bmSize);
1641       }
1642       x = 0;
1643       for (; j < i; ++j) {
1644         bitmaps[numInputSyms + j] =
1645             collBitmap->getSlice(x, 0, symWidths[j], symHeight);
1646         x += symWidths[j];
1647       }
1648       delete collBitmap;
1649     }
1650   }
1651
1652   // create the symbol dict object
1653   symbolDict = new JBIG2SymbolDict(segNum, numExSyms);
1654
1655   // exported symbol list
1656   i = j = 0;
1657   ex = gFalse;
1658   while (i < numInputSyms + numNewSyms) {
1659     if (huff) {
1660       huffDecoder->decodeInt(&run, huffTableA);
1661     } else {
1662       arithDecoder->decodeInt(&run, iaexStats);
1663     }
1664     if (ex) {
1665       for (cnt = 0; cnt < run; ++cnt) {
1666         symbolDict->setBitmap(j++, bitmaps[i++]->copy());
1667       }
1668     } else {
1669       i += run;
1670     }
1671     ex = !ex;
1672   }
1673
1674   for (i = 0; i < numNewSyms; ++i) {
1675     delete bitmaps[numInputSyms + i];
1676   }
1677   gfree(bitmaps);
1678   if (symWidths) {
1679     gfree(symWidths);
1680   }
1681
1682   // save the arithmetic decoder stats
1683   if (!huff && contextRetained) {
1684     symbolDict->setGenericRegionStats(genericRegionStats->copy());
1685     if (refAgg) {
1686       symbolDict->setRefinementRegionStats(refinementRegionStats->copy());
1687     }
1688   }
1689
1690   // store the new symbol dict
1691   segments->append(symbolDict);
1692
1693   return;
1694
1695  eofError:
1696   error(getPos(), "Unexpected EOF in JBIG2 stream");
1697 }
1698
1699 void JBIG2Stream::readTextRegionSeg(Guint segNum, GBool imm,
1700                                     GBool lossless, Guint length,
1701                                     Guint *refSegs, Guint nRefSegs) {
1702   JBIG2Bitmap *bitmap;
1703   JBIG2HuffmanTable runLengthTab[36];
1704   JBIG2HuffmanTable *symCodeTab;
1705   JBIG2HuffmanTable *huffFSTable, *huffDSTable, *huffDTTable;
1706   JBIG2HuffmanTable *huffRDWTable, *huffRDHTable;
1707   JBIG2HuffmanTable *huffRDXTable, *huffRDYTable, *huffRSizeTable;
1708   JBIG2Segment *seg;
1709   GList *codeTables;
1710   JBIG2SymbolDict *symbolDict;
1711   JBIG2Bitmap **syms;
1712   Guint w, h, x, y, segInfoFlags, extCombOp;
1713   Guint flags, huff, refine, logStrips, refCorner, transposed;
1714   Guint combOp, defPixel, templ;
1715   int sOffset;
1716   Guint huffFlags, huffFS, huffDS, huffDT;
1717   Guint huffRDW, huffRDH, huffRDX, huffRDY, huffRSize;
1718   Guint numInstances, numSyms, symCodeLen;
1719   int atx[2], aty[2];
1720   Guint i, k, kk;
1721   int j;
1722
1723   // region segment info field
1724   if (!readULong(&w) || !readULong(&h) ||
1725       !readULong(&x) || !readULong(&y) ||
1726       !readUByte(&segInfoFlags)) {
1727     goto eofError;
1728   }
1729   extCombOp = segInfoFlags & 7;
1730
1731   // rest of the text region header
1732   if (!readUWord(&flags)) {
1733     goto eofError;
1734   }
1735   huff = flags & 1;
1736   refine = (flags >> 1) & 1;
1737   logStrips = (flags >> 2) & 3;
1738   refCorner = (flags >> 4) & 3;
1739   transposed = (flags >> 6) & 1;
1740   combOp = (flags >> 7) & 3;
1741   defPixel = (flags >> 9) & 1;
1742   sOffset = (flags >> 10) & 0x1f;
1743   if (sOffset & 0x10) {
1744     sOffset |= -1 - 0x0f;
1745   }
1746   templ = (flags >> 15) & 1;
1747   huffFS = huffDS = huffDT = 0; // make gcc happy
1748   huffRDW = huffRDH = huffRDX = huffRDY = huffRSize = 0; // make gcc happy
1749   if (huff) {
1750     if (!readUWord(&huffFlags)) {
1751       goto eofError;
1752     }
1753     huffFS = huffFlags & 3;
1754     huffDS = (huffFlags >> 2) & 3;
1755     huffDT = (huffFlags >> 4) & 3;
1756     huffRDW = (huffFlags >> 6) & 3;
1757     huffRDH = (huffFlags >> 8) & 3;
1758     huffRDX = (huffFlags >> 10) & 3;
1759     huffRDY = (huffFlags >> 12) & 3;
1760     huffRSize = (huffFlags >> 14) & 1;
1761   }
1762   if (refine && templ == 0) {
1763     if (!readByte(&atx[0]) || !readByte(&aty[0]) ||
1764         !readByte(&atx[1]) || !readByte(&aty[1])) {
1765       goto eofError;
1766     }
1767   }
1768   if (!readULong(&numInstances)) {
1769     goto eofError;
1770   }
1771
1772   // get symbol dictionaries and tables
1773   codeTables = new GList();
1774   numSyms = 0;
1775   for (i = 0; i < nRefSegs; ++i) {
1776     seg = findSegment(refSegs[i]);
1777     if (seg->getType() == jbig2SegSymbolDict) {
1778       numSyms += ((JBIG2SymbolDict *)seg)->getSize();
1779     } else if (seg->getType() == jbig2SegCodeTable) {
1780       codeTables->append(seg);
1781     }
1782   }
1783   symCodeLen = 0;
1784   i = 1;
1785   while (i < numSyms) {
1786     ++symCodeLen;
1787     i <<= 1;
1788   }
1789
1790   // get the symbol bitmaps
1791   syms = (JBIG2Bitmap **)gmalloc(numSyms * sizeof(JBIG2Bitmap *));
1792   kk = 0;
1793   for (i = 0; i < nRefSegs; ++i) {
1794     seg = findSegment(refSegs[i]);
1795     if (seg->getType() == jbig2SegSymbolDict) {
1796       symbolDict = (JBIG2SymbolDict *)seg;
1797       for (k = 0; k < symbolDict->getSize(); ++k) {
1798         syms[kk++] = symbolDict->getBitmap(k);
1799       }
1800     }
1801   }
1802
1803   // get the Huffman tables
1804   huffFSTable = huffDSTable = huffDTTable = NULL; // make gcc happy
1805   huffRDWTable = huffRDHTable = NULL; // make gcc happy
1806   huffRDXTable = huffRDYTable = huffRSizeTable = NULL; // make gcc happy
1807   i = 0;
1808   if (huff) {
1809     if (huffFS == 0) {
1810       huffFSTable = huffTableF;
1811     } else if (huffFS == 1) {
1812       huffFSTable = huffTableG;
1813     } else {
1814       huffFSTable = ((JBIG2CodeTable *)codeTables->get(i++))->getHuffTable();
1815     }
1816     if (huffDS == 0) {
1817       huffDSTable = huffTableH;
1818     } else if (huffDS == 1) {
1819       huffDSTable = huffTableI;
1820     } else if (huffDS == 2) {
1821       huffDSTable = huffTableJ;
1822     } else {
1823       huffDSTable = ((JBIG2CodeTable *)codeTables->get(i++))->getHuffTable();
1824     }
1825     if (huffDT == 0) {
1826       huffDTTable = huffTableK;
1827     } else if (huffDT == 1) {
1828       huffDTTable = huffTableL;
1829     } else if (huffDT == 2) {
1830       huffDTTable = huffTableM;
1831     } else {
1832       huffDTTable = ((JBIG2CodeTable *)codeTables->get(i++))->getHuffTable();
1833     }
1834     if (huffRDW == 0) {
1835       huffRDWTable = huffTableN;
1836     } else if (huffRDW == 1) {
1837       huffRDWTable = huffTableO;
1838     } else {
1839       huffRDWTable = ((JBIG2CodeTable *)codeTables->get(i++))->getHuffTable();
1840     }
1841     if (huffRDH == 0) {
1842       huffRDHTable = huffTableN;
1843     } else if (huffRDH == 1) {
1844       huffRDHTable = huffTableO;
1845     } else {
1846       huffRDHTable = ((JBIG2CodeTable *)codeTables->get(i++))->getHuffTable();
1847     }
1848     if (huffRDX == 0) {
1849       huffRDXTable = huffTableN;
1850     } else if (huffRDX == 1) {
1851       huffRDXTable = huffTableO;
1852     } else {
1853       huffRDXTable = ((JBIG2CodeTable *)codeTables->get(i++))->getHuffTable();
1854     }
1855     if (huffRDY == 0) {
1856       huffRDYTable = huffTableN;
1857     } else if (huffRDY == 1) {
1858       huffRDYTable = huffTableO;
1859     } else {
1860       huffRDYTable = ((JBIG2CodeTable *)codeTables->get(i++))->getHuffTable();
1861     }
1862     if (huffRSize == 0) {
1863       huffRSizeTable = huffTableA;
1864     } else {
1865       huffRSizeTable =
1866           ((JBIG2CodeTable *)codeTables->get(i++))->getHuffTable();
1867     }
1868   }
1869   delete codeTables;
1870
1871   // symbol ID Huffman decoding table
1872   if (huff) {
1873     huffDecoder->reset();
1874     for (i = 0; i < 32; ++i) {
1875       runLengthTab[i].val = i;
1876       runLengthTab[i].prefixLen = huffDecoder->readBits(4);
1877       runLengthTab[i].rangeLen = 0;
1878     }
1879     runLengthTab[32].val = 0x103;
1880     runLengthTab[32].prefixLen = huffDecoder->readBits(4);
1881     runLengthTab[32].rangeLen = 2;
1882     runLengthTab[33].val = 0x203;
1883     runLengthTab[33].prefixLen = huffDecoder->readBits(4);
1884     runLengthTab[33].rangeLen = 3;
1885     runLengthTab[34].val = 0x20b;
1886     runLengthTab[34].prefixLen = huffDecoder->readBits(4);
1887     runLengthTab[34].rangeLen = 7;
1888     runLengthTab[35].prefixLen = 0;
1889     runLengthTab[35].rangeLen = jbig2HuffmanEOT;
1890     huffDecoder->buildTable(runLengthTab, 35);
1891     symCodeTab = (JBIG2HuffmanTable *)gmalloc((numSyms + 1) *
1892                                               sizeof(JBIG2HuffmanTable));
1893     for (i = 0; i < numSyms; ++i) {
1894       symCodeTab[i].val = i;
1895       symCodeTab[i].rangeLen = 0;
1896     }
1897     i = 0;
1898     while (i < numSyms) {
1899       huffDecoder->decodeInt(&j, runLengthTab);
1900       if (j > 0x200) {
1901         for (j -= 0x200; j && i < numSyms; --j) {
1902           symCodeTab[i++].prefixLen = 0;
1903         }
1904       } else if (j > 0x100) {
1905         for (j -= 0x100; j && i < numSyms; --j) {
1906           symCodeTab[i].prefixLen = symCodeTab[i-1].prefixLen;
1907           ++i;
1908         }
1909       } else {
1910         symCodeTab[i++].prefixLen = j;
1911       }
1912     }
1913     symCodeTab[numSyms].prefixLen = 0;
1914     symCodeTab[numSyms].rangeLen = jbig2HuffmanEOT;
1915     huffDecoder->buildTable(symCodeTab, numSyms);
1916     huffDecoder->reset();
1917
1918   // set up the arithmetic decoder
1919   } else {
1920     symCodeTab = NULL;
1921     resetIntStats(symCodeLen);
1922     arithDecoder->start();
1923   }
1924   if (refine) {
1925     resetRefinementStats(templ, NULL);
1926   }
1927
1928   bitmap = readTextRegion(huff, refine, w, h, numInstances,
1929                           logStrips, numSyms, symCodeTab, symCodeLen, syms,
1930                           defPixel, combOp, transposed, refCorner, sOffset,
1931                           huffFSTable, huffDSTable, huffDTTable,
1932                           huffRDWTable, huffRDHTable,
1933                           huffRDXTable, huffRDYTable, huffRSizeTable,
1934                           templ, atx, aty);
1935
1936   gfree(syms);
1937
1938   // combine the region bitmap into the page bitmap
1939   if (imm) {
1940     if (pageH == 0xffffffff && y + h > curPageH) {
1941       pageBitmap->expand(y + h, pageDefPixel);
1942     }
1943     pageBitmap->combine(bitmap, x, y, extCombOp);
1944     delete bitmap;
1945
1946   // store the region bitmap
1947   } else {
1948     bitmap->setSegNum(segNum);
1949     segments->append(bitmap);
1950   }
1951
1952   // clean up the Huffman decoder
1953   if (huff) {
1954     gfree(symCodeTab);
1955   }
1956
1957   return;
1958
1959  eofError:
1960   error(getPos(), "Unexpected EOF in JBIG2 stream");
1961 }
1962
1963 JBIG2Bitmap *JBIG2Stream::readTextRegion(GBool huff, GBool refine,
1964                                          int w, int h,
1965                                          Guint numInstances,
1966                                          Guint logStrips,
1967                                          int numSyms,
1968                                          JBIG2HuffmanTable *symCodeTab,
1969                                          Guint symCodeLen,
1970                                          JBIG2Bitmap **syms,
1971                                          Guint defPixel, Guint combOp,
1972                                          Guint transposed, Guint refCorner,
1973                                          int sOffset,
1974                                          JBIG2HuffmanTable *huffFSTable,
1975                                          JBIG2HuffmanTable *huffDSTable,
1976                                          JBIG2HuffmanTable *huffDTTable,
1977                                          JBIG2HuffmanTable *huffRDWTable,
1978                                          JBIG2HuffmanTable *huffRDHTable,
1979                                          JBIG2HuffmanTable *huffRDXTable,
1980                                          JBIG2HuffmanTable *huffRDYTable,
1981                                          JBIG2HuffmanTable *huffRSizeTable,
1982                                          Guint templ,
1983                                          int *atx, int *aty) {
1984   JBIG2Bitmap *bitmap;
1985   JBIG2Bitmap *symbolBitmap;
1986   Guint strips;
1987   int t, dt, tt, s, ds, sFirst, j;
1988   int rdw, rdh, rdx, rdy, ri, refDX, refDY, bmSize;
1989   Guint symID, inst, bw, bh;
1990
1991   strips = 1 << logStrips;
1992
1993   // allocate the bitmap
1994   bitmap = new JBIG2Bitmap(0, w, h);
1995   if (defPixel) {
1996     bitmap->clearToOne();
1997   } else {
1998     bitmap->clearToZero();
1999   }
2000
2001   // decode initial T value
2002   if (huff) {
2003     huffDecoder->decodeInt(&t, huffDTTable);
2004   } else {
2005     arithDecoder->decodeInt(&t, iadtStats);
2006   }
2007   t *= -(int)strips;
2008
2009   inst = 0;
2010   sFirst = 0;
2011   while (inst < numInstances) {
2012
2013     // decode delta-T
2014     if (huff) {
2015       huffDecoder->decodeInt(&dt, huffDTTable);
2016     } else {
2017       arithDecoder->decodeInt(&dt, iadtStats);
2018     }
2019     t += dt * strips;
2020
2021     // first S value
2022     if (huff) {
2023       huffDecoder->decodeInt(&ds, huffFSTable);
2024     } else {
2025       arithDecoder->decodeInt(&ds, iafsStats);
2026     }
2027     sFirst += ds;
2028     s = sFirst;
2029
2030     // read the instances
2031     while (1) {
2032
2033       // T value
2034       if (strips == 1) {
2035         dt = 0;
2036       } else if (huff) {
2037         dt = huffDecoder->readBits(logStrips);
2038       } else {
2039         arithDecoder->decodeInt(&dt, iaitStats);
2040       }
2041       tt = t + dt;
2042
2043       // symbol ID
2044       if (huff) {
2045         if (symCodeTab) {
2046           huffDecoder->decodeInt(&j, symCodeTab);
2047           symID = (Guint)j;
2048         } else {
2049           symID = huffDecoder->readBits(symCodeLen);
2050         }
2051       } else {
2052         symID = arithDecoder->decodeIAID(symCodeLen, iaidStats);
2053       }
2054
2055       // get the symbol bitmap
2056       symbolBitmap = NULL;
2057       if (refine) {
2058         if (huff) {
2059           ri = (int)huffDecoder->readBit();
2060         } else {
2061           arithDecoder->decodeInt(&ri, iariStats);
2062         }
2063       } else {
2064         ri = 0;
2065       }
2066       if (ri) {
2067         if (huff) {
2068           huffDecoder->decodeInt(&rdw, huffRDWTable);
2069           huffDecoder->decodeInt(&rdh, huffRDHTable);
2070           huffDecoder->decodeInt(&rdx, huffRDXTable);
2071           huffDecoder->decodeInt(&rdy, huffRDYTable);
2072           huffDecoder->decodeInt(&bmSize, huffRSizeTable);
2073           huffDecoder->reset();
2074           arithDecoder->start();
2075         } else {
2076           arithDecoder->decodeInt(&rdw, iardwStats);
2077           arithDecoder->decodeInt(&rdh, iardhStats);
2078           arithDecoder->decodeInt(&rdx, iardxStats);
2079           arithDecoder->decodeInt(&rdy, iardyStats);
2080         }
2081         refDX = ((rdw >= 0) ? rdw : rdw - 1) / 2 + rdx;
2082         refDY = ((rdh >= 0) ? rdh : rdh - 1) / 2 + rdy;
2083
2084         symbolBitmap =
2085           readGenericRefinementRegion(rdw + syms[symID]->getWidth(),
2086                                       rdh + syms[symID]->getHeight(),
2087                                       templ, gFalse, syms[symID],
2088                                       refDX, refDY, atx, aty);
2089         //~ do we need to use the bmSize value here (in Huffman mode)?
2090       } else {
2091         symbolBitmap = syms[symID];
2092       }
2093
2094       // combine the symbol bitmap into the region bitmap
2095       //~ something is wrong here - refCorner shouldn't degenerate into
2096       //~   two cases
2097       bw = symbolBitmap->getWidth() - 1;
2098       bh = symbolBitmap->getHeight() - 1;
2099       if (transposed) {
2100         switch (refCorner) {
2101         case 0: // bottom left
2102           bitmap->combine(symbolBitmap, tt, s, combOp);
2103           break;
2104         case 1: // top left
2105           bitmap->combine(symbolBitmap, tt, s, combOp);
2106           break;
2107         case 2: // bottom right
2108           bitmap->combine(symbolBitmap, tt - bw, s, combOp);
2109           break;
2110         case 3: // top right
2111           bitmap->combine(symbolBitmap, tt - bw, s, combOp);
2112           break;
2113         }
2114         s += bh;
2115       } else {
2116         switch (refCorner) {
2117         case 0: // bottom left
2118           bitmap->combine(symbolBitmap, s, tt - bh, combOp);
2119           break;
2120         case 1: // top left
2121           bitmap->combine(symbolBitmap, s, tt, combOp);
2122           break;
2123         case 2: // bottom right
2124           bitmap->combine(symbolBitmap, s, tt - bh, combOp);
2125           break;
2126         case 3: // top right
2127           bitmap->combine(symbolBitmap, s, tt, combOp);
2128           break;
2129         }
2130         s += bw;
2131       }
2132       if (ri) {
2133         delete symbolBitmap;
2134       }
2135
2136       // next instance
2137       ++inst;
2138
2139       // next S value
2140       if (huff) {
2141         if (!huffDecoder->decodeInt(&ds, huffDSTable)) {
2142           break;
2143         }
2144       } else {
2145         if (!arithDecoder->decodeInt(&ds, iadsStats)) {
2146           break;
2147         }
2148       }
2149       s += sOffset + ds;
2150     }
2151   }
2152
2153   return bitmap;
2154 }
2155
2156 void JBIG2Stream::readPatternDictSeg(Guint segNum, Guint length) {
2157   JBIG2PatternDict *patternDict;
2158   JBIG2Bitmap *bitmap;
2159   Guint flags, patternW, patternH, grayMax, templ, mmr;
2160   int atx[4], aty[4];
2161   Guint i, x;
2162
2163   // halftone dictionary flags, pattern width and height, max gray value
2164   if (!readUByte(&flags) ||
2165       !readUByte(&patternW) ||
2166       !readUByte(&patternH) ||
2167       !readULong(&grayMax)) {
2168     goto eofError;
2169   }
2170   templ = (flags >> 1) & 3;
2171   mmr = flags & 1;
2172
2173   // set up the arithmetic decoder
2174   if (!mmr) {
2175     resetGenericStats(templ, NULL);
2176     arithDecoder->start();
2177   }
2178
2179   // read the bitmap
2180   atx[0] = -(int)patternW; aty[0] =  0;
2181   atx[1] = -3;             aty[1] = -1;
2182   atx[2] =  2;             aty[2] = -2;
2183   atx[3] = -2;             aty[3] = -2;
2184   bitmap = readGenericBitmap(mmr, (grayMax + 1) * patternW, patternH,
2185                              templ, gFalse, gFalse, NULL,
2186                              atx, aty, length - 7);
2187
2188   // create the pattern dict object
2189   patternDict = new JBIG2PatternDict(segNum, grayMax + 1);
2190
2191   // split up the bitmap
2192   x = 0;
2193   for (i = 0; i <= grayMax; ++i) {
2194     patternDict->setBitmap(i, bitmap->getSlice(x, 0, patternW, patternH));
2195     x += patternW;
2196   }
2197
2198   // free memory
2199   delete bitmap;
2200
2201   // store the new pattern dict
2202   segments->append(patternDict);
2203
2204   return;
2205
2206  eofError:
2207   error(getPos(), "Unexpected EOF in JBIG2 stream");
2208 }
2209
2210 void JBIG2Stream::readHalftoneRegionSeg(Guint segNum, GBool imm,
2211                                         GBool lossless, Guint length,
2212                                         Guint *refSegs, Guint nRefSegs) {
2213   JBIG2Bitmap *bitmap;
2214   JBIG2Segment *seg;
2215   JBIG2PatternDict *patternDict;
2216   JBIG2Bitmap *skipBitmap;
2217   Guint *grayImg;
2218   JBIG2Bitmap *grayBitmap;
2219   JBIG2Bitmap *patternBitmap;
2220   Guint w, h, x, y, segInfoFlags, extCombOp;
2221   Guint flags, mmr, templ, enableSkip, combOp;
2222   Guint gridW, gridH, stepX, stepY, patW, patH;
2223   int atx[4], aty[4];
2224   int gridX, gridY, xx, yy, bit, j;
2225   Guint bpp, m, n, i;
2226
2227   // region segment info field
2228   if (!readULong(&w) || !readULong(&h) ||
2229       !readULong(&x) || !readULong(&y) ||
2230       !readUByte(&segInfoFlags)) {
2231     goto eofError;
2232   }
2233   extCombOp = segInfoFlags & 7;
2234
2235   // rest of the halftone region header
2236   if (!readUByte(&flags)) {
2237     goto eofError;
2238   }
2239   mmr = flags & 1;
2240   templ = (flags >> 1) & 3;
2241   enableSkip = (flags >> 3) & 1;
2242   combOp = (flags >> 4) & 7;
2243   if (!readULong(&gridW) || !readULong(&gridH) ||
2244       !readLong(&gridX) || !readLong(&gridY) ||
2245       !readUWord(&stepX) || !readUWord(&stepY)) {
2246     goto eofError;
2247   }
2248
2249   // get pattern dictionary
2250   if (nRefSegs != 1) {
2251     error(getPos(), "Bad symbol dictionary reference in JBIG2 halftone segment");
2252     return;
2253   }
2254   seg = findSegment(refSegs[0]);
2255   if (seg->getType() != jbig2SegPatternDict) {
2256     error(getPos(), "Bad symbol dictionary reference in JBIG2 halftone segment");
2257     return;
2258   }
2259   patternDict = (JBIG2PatternDict *)seg;
2260   bpp = 0;
2261   i = 1;
2262   while (i < patternDict->getSize()) {
2263     ++bpp;
2264     i <<= 1;
2265   }
2266   patW = patternDict->getBitmap(0)->getWidth();
2267   patH = patternDict->getBitmap(0)->getHeight();
2268
2269   // set up the arithmetic decoder
2270   if (!mmr) {
2271     resetGenericStats(templ, NULL);
2272     arithDecoder->start();
2273   }
2274
2275   // allocate the bitmap
2276   bitmap = new JBIG2Bitmap(segNum, w, h);
2277   if (flags & 0x80) { // HDEFPIXEL
2278     bitmap->clearToOne();
2279   } else {
2280     bitmap->clearToZero();
2281   }
2282
2283   // compute the skip bitmap
2284   skipBitmap = NULL;
2285   if (enableSkip) {
2286     skipBitmap = new JBIG2Bitmap(0, gridW, gridH);
2287     skipBitmap->clearToZero();
2288     for (m = 0; m < gridH; ++m) {
2289       xx = gridX + m * stepY;
2290       yy = gridY + m * stepX;
2291       for (n = 0; n < gridW; ++n) {
2292         if (((xx + (int)patW) >> 8) <= 0 || (xx >> 8) >= (int)w ||
2293             ((yy + (int)patH) >> 8) <= 0 || (yy >> 8) >= (int)h) {
2294           skipBitmap->setPixel(n, m);
2295         }
2296       }
2297     }
2298   }
2299
2300   // read the gray-scale image
2301   grayImg = (Guint *)gmalloc(gridW * gridH * sizeof(Guint));
2302   memset(grayImg, 0, gridW * gridH * sizeof(Guint));
2303   atx[0] = templ <= 1 ? 3 : 2;  aty[0] = -1;
2304   atx[1] = -3;                  aty[1] = -1;
2305   atx[2] =  2;                  aty[2] = -2;
2306   atx[3] = -2;                  aty[3] = -2;
2307   for (j = bpp - 1; j >= 0; --j) {
2308     grayBitmap = readGenericBitmap(mmr, gridW, gridH, templ, gFalse,
2309                                    enableSkip, skipBitmap, atx, aty, -1);
2310     i = 0;
2311     for (m = 0; m < gridH; ++m) {
2312       for (n = 0; n < gridW; ++n) {
2313         bit = grayBitmap->getPixel(n, m) ^ (grayImg[i] & 1);
2314         grayImg[i] = (grayImg[i] << 1) | bit;
2315         ++i;
2316       }
2317     }
2318     delete grayBitmap;
2319   }
2320
2321   // decode the image
2322   i = 0;
2323   for (m = 0; m < gridH; ++m) {
2324     xx = gridX + m * stepY;
2325     yy = gridY + m * stepX;
2326     for (n = 0; n < gridW; ++n) {
2327       if (!(enableSkip && skipBitmap->getPixel(n, m))) {
2328         patternBitmap = patternDict->getBitmap(grayImg[i]);
2329         bitmap->combine(patternBitmap, xx >> 8, yy >> 8, combOp);
2330       }
2331       xx += stepX;
2332       yy -= stepY;
2333       ++i;
2334     }
2335   }
2336
2337   gfree(grayImg);
2338
2339   // combine the region bitmap into the page bitmap
2340   if (imm) {
2341     if (pageH == 0xffffffff && y + h > curPageH) {
2342       pageBitmap->expand(y + h, pageDefPixel);
2343     }
2344     pageBitmap->combine(bitmap, x, y, extCombOp);
2345     delete bitmap;
2346
2347   // store the region bitmap
2348   } else {
2349     segments->append(bitmap);
2350   }
2351
2352   return;
2353
2354  eofError:
2355   error(getPos(), "Unexpected EOF in JBIG2 stream");
2356 }
2357
2358 void JBIG2Stream::readGenericRegionSeg(Guint segNum, GBool imm,
2359                                        GBool lossless, Guint length) {
2360   JBIG2Bitmap *bitmap;
2361   Guint w, h, x, y, segInfoFlags, extCombOp;
2362   Guint flags, mmr, templ, tpgdOn;
2363   int atx[4], aty[4];
2364
2365   // region segment info field
2366   if (!readULong(&w) || !readULong(&h) ||
2367       !readULong(&x) || !readULong(&y) ||
2368       !readUByte(&segInfoFlags)) {
2369     goto eofError;
2370   }
2371   extCombOp = segInfoFlags & 7;
2372
2373   // rest of the generic region segment header
2374   if (!readUByte(&flags)) {
2375     goto eofError;
2376   }
2377   mmr = flags & 1;
2378   templ = (flags >> 1) & 3;
2379   tpgdOn = (flags >> 3) & 1;
2380
2381   // AT flags
2382   if (!mmr) {
2383     if (templ == 0) {
2384       if (!readByte(&atx[0]) ||
2385           !readByte(&aty[0]) ||
2386           !readByte(&atx[1]) ||
2387           !readByte(&aty[1]) ||
2388           !readByte(&atx[2]) ||
2389           !readByte(&aty[2]) ||
2390           !readByte(&atx[3]) ||
2391           !readByte(&aty[3])) {
2392         goto eofError;
2393       }
2394     } else {
2395       if (!readByte(&atx[0]) ||
2396           !readByte(&aty[0])) {
2397         goto eofError;
2398       }
2399     }
2400   }
2401
2402   // set up the arithmetic decoder
2403   if (!mmr) {
2404     resetGenericStats(templ, NULL);
2405     arithDecoder->start();
2406   }
2407
2408   // read the bitmap
2409   bitmap = readGenericBitmap(mmr, w, h, templ, tpgdOn, gFalse,
2410                              NULL, atx, aty, mmr ? 0 : length - 18);
2411
2412   // combine the region bitmap into the page bitmap
2413   if (imm) {
2414     if (pageH == 0xffffffff && y + h > curPageH) {
2415       pageBitmap->expand(y + h, pageDefPixel);
2416     }
2417     pageBitmap->combine(bitmap, x, y, extCombOp);
2418     delete bitmap;
2419
2420   // store the region bitmap
2421   } else {
2422     bitmap->setSegNum(segNum);
2423     segments->append(bitmap);
2424   }
2425
2426   return;
2427
2428  eofError:
2429   error(getPos(), "Unexpected EOF in JBIG2 stream");
2430 }
2431
2432 JBIG2Bitmap *JBIG2Stream::readGenericBitmap(GBool mmr, int w, int h,
2433                                             int templ, GBool tpgdOn,
2434                                             GBool useSkip, JBIG2Bitmap *skip,
2435                                             int *atx, int *aty,
2436                                             int mmrDataLength) {
2437   JBIG2Bitmap *bitmap;
2438   GBool ltp;
2439   Guint ltpCX, cx, cx0, cx1, cx2;
2440   JBIG2BitmapPtr cxPtr0, cxPtr1;
2441   JBIG2BitmapPtr atPtr0, atPtr1, atPtr2, atPtr3;
2442   int *refLine, *codingLine;
2443   int code1, code2, code3;
2444   int x, y, a0, pix, i, refI, codingI;
2445
2446   bitmap = new JBIG2Bitmap(0, w, h);
2447   bitmap->clearToZero();
2448
2449   //----- MMR decode
2450
2451   if (mmr) {
2452
2453     mmrDecoder->reset();
2454     refLine = (int *)gmalloc((w + 2) * sizeof(int));
2455     codingLine = (int *)gmalloc((w + 2) * sizeof(int));
2456     codingLine[0] = codingLine[1] = w;
2457
2458     for (y = 0; y < h; ++y) {
2459
2460       // copy coding line to ref line
2461       for (i = 0; codingLine[i] < w; ++i) {
2462         refLine[i] = codingLine[i];
2463       }
2464       refLine[i] = refLine[i + 1] = w;
2465
2466       // decode a line
2467       refI = 0;     // b1 = refLine[refI]
2468       codingI = 0;  // a1 = codingLine[codingI]
2469       a0 = 0;
2470       do {
2471         code1 = mmrDecoder->get2DCode();
2472         switch (code1) {
2473         case twoDimPass:
2474           if (refLine[refI] < w) {
2475             a0 = refLine[refI + 1];
2476             refI += 2;
2477           }
2478           break;
2479         case twoDimHoriz:
2480           if (codingI & 1) {
2481             code1 = 0;
2482             do {
2483               code1 += code3 = mmrDecoder->getBlackCode();
2484             } while (code3 >= 64);
2485             code2 = 0;
2486             do {
2487               code2 += code3 = mmrDecoder->getWhiteCode();
2488             } while (code3 >= 64);
2489           } else {
2490             code1 = 0;
2491             do {
2492               code1 += code3 = mmrDecoder->getWhiteCode();
2493             } while (code3 >= 64);
2494             code2 = 0;
2495             do {
2496               code2 += code3 = mmrDecoder->getBlackCode();
2497             } while (code3 >= 64);
2498           }
2499           if (code1 > 0 || code2 > 0) {
2500             a0 = codingLine[codingI++] = a0 + code1;
2501             a0 = codingLine[codingI++] = a0 + code2;
2502             while (refLine[refI] <= a0 && refLine[refI] < w) {
2503               refI += 2;
2504             }
2505           }
2506           break;
2507         case twoDimVert0:
2508           a0 = codingLine[codingI++] = refLine[refI];
2509           if (refLine[refI] < w) {
2510             ++refI;
2511           }
2512           break;
2513         case twoDimVertR1:
2514           a0 = codingLine[codingI++] = refLine[refI] + 1;
2515           if (refLine[refI] < w) {
2516             ++refI;
2517             while (refLine[refI] <= a0 && refLine[refI] < w) {
2518               refI += 2;
2519             }
2520           }
2521           break;
2522         case twoDimVertR2:
2523           a0 = codingLine[codingI++] = refLine[refI] + 2;
2524           if (refLine[refI] < w) {
2525             ++refI;
2526             while (refLine[refI] <= a0 && refLine[refI] < w) {
2527               refI += 2;
2528             }
2529           }
2530           break;
2531         case twoDimVertR3:
2532           a0 = codingLine[codingI++] = refLine[refI] + 3;
2533           if (refLine[refI] < w) {
2534             ++refI;
2535             while (refLine[refI] <= a0 && refLine[refI] < w) {
2536               refI += 2;
2537             }
2538           }
2539           break;
2540         case twoDimVertL1:
2541           a0 = codingLine[codingI++] = refLine[refI] - 1;
2542           if (refI > 0) {
2543             --refI;
2544           } else {
2545             ++refI;
2546           }
2547           while (refLine[refI] <= a0 && refLine[refI] < w) {
2548             refI += 2;
2549           }
2550           break;
2551         case twoDimVertL2:
2552           a0 = codingLine[codingI++] = refLine[refI] - 2;
2553           if (refI > 0) {
2554             --refI;
2555           } else {
2556             ++refI;
2557           }
2558           while (refLine[refI] <= a0 && refLine[refI] < w) {
2559             refI += 2;
2560           }
2561           break;
2562         case twoDimVertL3:
2563           a0 = codingLine[codingI++] = refLine[refI] - 3;
2564           if (refI > 0) {
2565             --refI;
2566           } else {
2567             ++refI;
2568           }
2569           while (refLine[refI] <= a0 && refLine[refI] < w) {
2570             refI += 2;
2571           }
2572           break;
2573         default:
2574           error(getPos(), "Illegal code in JBIG2 MMR bitmap data");
2575           break;
2576         }
2577       } while (a0 < w);
2578       codingLine[codingI++] = w;
2579
2580       // convert the run lengths to a bitmap line
2581       i = 0;
2582       while (codingLine[i] < w) {
2583         for (x = codingLine[i]; x < codingLine[i+1]; ++x) {
2584           bitmap->setPixel(x, y);
2585         }
2586         i += 2;
2587       }
2588     }
2589
2590     if (mmrDataLength >= 0) {
2591       mmrDecoder->skipTo(mmrDataLength);
2592     } else {
2593       if (mmrDecoder->get24Bits() != 0x001001) {
2594         error(getPos(), "Missing EOFB in JBIG2 MMR bitmap data");
2595       }
2596     }
2597
2598     gfree(refLine);
2599     gfree(codingLine);
2600
2601   //----- arithmetic decode
2602
2603   } else {
2604     // set up the typical row context
2605     ltpCX = 0; // make gcc happy
2606     if (tpgdOn) {
2607       switch (templ) {
2608       case 0:
2609         ltpCX = 0x3953; // 001 11001 0101 0011
2610         break;
2611       case 1:
2612         ltpCX = 0x079a; // 0011 11001 101 0
2613         break;
2614       case 2:
2615         ltpCX = 0x0e3; // 001 1100 01 1
2616         break;
2617       case 3:
2618         ltpCX = 0x18a; // 01100 0101 1
2619         break;
2620       }
2621     }
2622
2623     ltp = 0;
2624     cx = cx0 = cx1 = cx2 = 0; // make gcc happy
2625     for (y = 0; y < h; ++y) {
2626
2627       // check for a "typical" (duplicate) row
2628       if (tpgdOn) {
2629         if (arithDecoder->decodeBit(ltpCX, genericRegionStats)) {
2630           ltp = !ltp;
2631         }
2632         if (ltp) {
2633           bitmap->duplicateRow(y, y-1);
2634           continue;
2635         }
2636       }
2637
2638       switch (templ) {
2639       case 0:
2640
2641         // set up the context
2642         bitmap->getPixelPtr(0, y-2, &cxPtr0);
2643         cx0 = bitmap->nextPixel(&cxPtr0);
2644         cx0 = (cx0 << 1) | bitmap->nextPixel(&cxPtr0);
2645         bitmap->getPixelPtr(0, y-1, &cxPtr1);
2646         cx1 = bitmap->nextPixel(&cxPtr1);
2647         cx1 = (cx1 << 1) | bitmap->nextPixel(&cxPtr1);
2648         cx1 = (cx1 << 1) | bitmap->nextPixel(&cxPtr1);
2649         cx2 = 0;
2650         bitmap->getPixelPtr(atx[0], y + aty[0], &atPtr0);
2651         bitmap->getPixelPtr(atx[1], y + aty[1], &atPtr1);
2652         bitmap->getPixelPtr(atx[2], y + aty[2], &atPtr2);
2653         bitmap->getPixelPtr(atx[3], y + aty[3], &atPtr3);
2654
2655         // decode the row
2656         for (x = 0; x < w; ++x) {
2657
2658           // build the context
2659           cx = (cx0 << 13) | (cx1 << 8) | (cx2 << 4) |
2660                (bitmap->nextPixel(&atPtr0) << 3) |
2661                (bitmap->nextPixel(&atPtr1) << 2) |
2662                (bitmap->nextPixel(&atPtr2) << 1) |
2663                bitmap->nextPixel(&atPtr3);
2664
2665           // check for a skipped pixel
2666           if (useSkip && skip->getPixel(x, y)) {
2667             pix = 0;
2668
2669           // decode the pixel
2670           } else if ((pix = arithDecoder->decodeBit(cx, genericRegionStats))) {
2671             bitmap->setPixel(x, y);
2672           }
2673
2674           // update the context
2675           cx0 = ((cx0 << 1) | bitmap->nextPixel(&cxPtr0)) & 0x07;
2676           cx1 = ((cx1 << 1) | bitmap->nextPixel(&cxPtr1)) & 0x1f;
2677           cx2 = ((cx2 << 1) | pix) & 0x0f;
2678         }
2679         break;
2680
2681       case 1:
2682
2683         // set up the context
2684         bitmap->getPixelPtr(0, y-2, &cxPtr0);
2685         cx0 = bitmap->nextPixel(&cxPtr0);
2686         cx0 = (cx0 << 1) | bitmap->nextPixel(&cxPtr0);
2687         cx0 = (cx0 << 1) | bitmap->nextPixel(&cxPtr0);
2688         bitmap->getPixelPtr(0, y-1, &cxPtr1);
2689         cx1 = bitmap->nextPixel(&cxPtr1);
2690         cx1 = (cx1 << 1) | bitmap->nextPixel(&cxPtr1);
2691         cx1 = (cx1 << 1) | bitmap->nextPixel(&cxPtr1);
2692         cx2 = 0;
2693         bitmap->getPixelPtr(atx[0], y + aty[0], &atPtr0);
2694
2695         // decode the row
2696         for (x = 0; x < w; ++x) {
2697
2698           // build the context
2699           cx = (cx0 << 9) | (cx1 << 4) | (cx2 << 1) |
2700                bitmap->nextPixel(&atPtr0);
2701
2702           // check for a skipped pixel
2703           if (useSkip && skip->getPixel(x, y)) {
2704             pix = 0;
2705
2706           // decode the pixel
2707           } else if ((pix = arithDecoder->decodeBit(cx, genericRegionStats))) {
2708             bitmap->setPixel(x, y);
2709           }
2710
2711           // update the context
2712           cx0 = ((cx0 << 1) | bitmap->nextPixel(&cxPtr0)) & 0x0f;
2713           cx1 = ((cx1 << 1) | bitmap->nextPixel(&cxPtr1)) & 0x1f;
2714           cx2 = ((cx2 << 1) | pix) & 0x07;
2715         }
2716         break;
2717
2718       case 2:
2719
2720         // set up the context
2721         bitmap->getPixelPtr(0, y-2, &cxPtr0);
2722         cx0 = bitmap->nextPixel(&cxPtr0);
2723         cx0 = (cx0 << 1) | bitmap->nextPixel(&cxPtr0);
2724         bitmap->getPixelPtr(0, y-1, &cxPtr1);
2725         cx1 = bitmap->nextPixel(&cxPtr1);
2726         cx1 = (cx1 << 1) | bitmap->nextPixel(&cxPtr1);
2727         cx2 = 0;
2728         bitmap->getPixelPtr(atx[0], y + aty[0], &atPtr0);
2729
2730         // decode the row
2731         for (x = 0; x < w; ++x) {
2732
2733           // build the context
2734           cx = (cx0 << 7) | (cx1 << 3) | (cx2 << 1) |
2735                bitmap->nextPixel(&atPtr0);
2736
2737           // check for a skipped pixel
2738           if (useSkip && skip->getPixel(x, y)) {
2739             pix = 0;
2740
2741           // decode the pixel
2742           } else if ((pix = arithDecoder->decodeBit(cx, genericRegionStats))) {
2743             bitmap->setPixel(x, y);
2744           }
2745
2746           // update the context
2747           cx0 = ((cx0 << 1) | bitmap->nextPixel(&cxPtr0)) & 0x07;
2748           cx1 = ((cx1 << 1) | bitmap->nextPixel(&cxPtr1)) & 0x0f;
2749           cx2 = ((cx2 << 1) | pix) & 0x03;
2750         }
2751         break;
2752
2753       case 3:
2754
2755         // set up the context
2756         bitmap->getPixelPtr(0, y-1, &cxPtr1);
2757         cx1 = bitmap->nextPixel(&cxPtr1);
2758         cx1 = (cx1 << 1) | bitmap->nextPixel(&cxPtr1);
2759         cx2 = 0;
2760         bitmap->getPixelPtr(atx[0], y + aty[0], &atPtr0);
2761
2762         // decode the row
2763         for (x = 0; x < w; ++x) {
2764
2765           // build the context
2766           cx = (cx1 << 5) | (cx2 << 1) |
2767                bitmap->nextPixel(&atPtr0);
2768
2769           // check for a skipped pixel
2770           if (useSkip && skip->getPixel(x, y)) {
2771             pix = 0;
2772
2773           // decode the pixel
2774           } else if ((pix = arithDecoder->decodeBit(cx, genericRegionStats))) {
2775             bitmap->setPixel(x, y);
2776           }
2777
2778           // update the context
2779           cx1 = ((cx1 << 1) | bitmap->nextPixel(&cxPtr1)) & 0x1f;
2780           cx2 = ((cx2 << 1) | pix) & 0x0f;
2781         }
2782         break;
2783       }
2784     }
2785   }
2786
2787   return bitmap;
2788 }
2789
2790 void JBIG2Stream::readGenericRefinementRegionSeg(Guint segNum, GBool imm,
2791                                                  GBool lossless, Guint length,
2792                                                  Guint *refSegs,
2793                                                  Guint nRefSegs) {
2794   JBIG2Bitmap *bitmap, *refBitmap;
2795   Guint w, h, x, y, segInfoFlags, extCombOp;
2796   Guint flags, templ, tpgrOn;
2797   int atx[2], aty[2];
2798   JBIG2Segment *seg;
2799
2800   // region segment info field
2801   if (!readULong(&w) || !readULong(&h) ||
2802       !readULong(&x) || !readULong(&y) ||
2803       !readUByte(&segInfoFlags)) {
2804     goto eofError;
2805   }
2806   extCombOp = segInfoFlags & 7;
2807
2808   // rest of the generic refinement region segment header
2809   if (!readUByte(&flags)) {
2810     goto eofError;
2811   }
2812   templ = flags & 1;
2813   tpgrOn = (flags >> 1) & 1;
2814
2815   // AT flags
2816   if (!templ) {
2817     if (!readByte(&atx[0]) || !readByte(&aty[0]) ||
2818         !readByte(&atx[1]) || !readByte(&aty[1])) {
2819       goto eofError;
2820     }
2821   }
2822
2823   // resize the page bitmap if needed
2824   if (nRefSegs == 0 || imm) {
2825     if (pageH == 0xffffffff && y + h > curPageH) {
2826       pageBitmap->expand(y + h, pageDefPixel);
2827     }
2828   }
2829
2830   // get referenced bitmap
2831   if (nRefSegs > 1) {
2832     error(getPos(), "Bad reference in JBIG2 generic refinement segment");
2833     return;
2834   }
2835   if (nRefSegs == 1) {
2836     seg = findSegment(refSegs[0]);
2837     if (seg->getType() != jbig2SegBitmap) {
2838       error(getPos(), "Bad bitmap reference in JBIG2 generic refinement segment");
2839       return;
2840     }
2841     refBitmap = (JBIG2Bitmap *)seg;
2842   } else {
2843     refBitmap = pageBitmap->getSlice(x, y, w, h);
2844   }
2845
2846   // set up the arithmetic decoder
2847   resetRefinementStats(templ, NULL);
2848   arithDecoder->start();
2849
2850   // read
2851   bitmap = readGenericRefinementRegion(w, h, templ, tpgrOn,
2852                                        refBitmap, 0, 0, atx, aty);
2853
2854   // combine the region bitmap into the page bitmap
2855   if (imm) {
2856     pageBitmap->combine(bitmap, x, y, extCombOp);
2857     delete bitmap;
2858
2859   // store the region bitmap
2860   } else {
2861     bitmap->setSegNum(segNum);
2862     segments->append(bitmap);
2863   }
2864
2865   // delete the referenced bitmap
2866   if (nRefSegs == 1) {
2867     discardSegment(refSegs[0]);
2868   } else {
2869     delete refBitmap;
2870   }
2871
2872   return;
2873
2874  eofError:
2875   error(getPos(), "Unexpected EOF in JBIG2 stream");
2876 }
2877
2878 JBIG2Bitmap *JBIG2Stream::readGenericRefinementRegion(int w, int h,
2879                                                       int templ, GBool tpgrOn,
2880                                                       JBIG2Bitmap *refBitmap,
2881                                                       int refDX, int refDY,
2882                                                       int *atx, int *aty) {
2883   JBIG2Bitmap *bitmap;
2884   GBool ltp;
2885   Guint ltpCX, cx, cx0, cx2, cx3, cx4, tpgrCX0, tpgrCX1, tpgrCX2;
2886   JBIG2BitmapPtr cxPtr0, cxPtr1, cxPtr2, cxPtr3, cxPtr4, cxPtr5, cxPtr6;
2887   JBIG2BitmapPtr tpgrCXPtr0, tpgrCXPtr1, tpgrCXPtr2;
2888   int x, y, pix;
2889
2890   bitmap = new JBIG2Bitmap(0, w, h);
2891   bitmap->clearToZero();
2892
2893   // set up the typical row context
2894   if (templ) {
2895     ltpCX = 0x008;
2896   } else {
2897     ltpCX = 0x0010;
2898   }
2899
2900   ltp = 0;
2901   for (y = 0; y < h; ++y) {
2902
2903     if (templ) {
2904
2905       // set up the context
2906       bitmap->getPixelPtr(0, y-1, &cxPtr0);
2907       cx0 = bitmap->nextPixel(&cxPtr0);
2908       bitmap->getPixelPtr(-1, y, &cxPtr1);
2909       refBitmap->getPixelPtr(-refDX, y-1-refDY, &cxPtr2);
2910       refBitmap->getPixelPtr(-1-refDX, y-refDY, &cxPtr3);
2911       cx3 = refBitmap->nextPixel(&cxPtr3);
2912       cx3 = (cx3 << 1) | refBitmap->nextPixel(&cxPtr3);
2913       refBitmap->getPixelPtr(-refDX, y+1-refDY, &cxPtr4);
2914       cx4 = refBitmap->nextPixel(&cxPtr4);
2915
2916       // set up the typical prediction context
2917       tpgrCX0 = tpgrCX1 = tpgrCX2 = 0; // make gcc happy
2918       if (tpgrOn) {
2919         refBitmap->getPixelPtr(-1-refDX, y-1-refDY, &tpgrCXPtr0);
2920         tpgrCX0 = refBitmap->nextPixel(&tpgrCXPtr0);
2921         tpgrCX0 = (tpgrCX0 << 1) | refBitmap->nextPixel(&tpgrCXPtr0);
2922         tpgrCX0 = (tpgrCX0 << 1) | refBitmap->nextPixel(&tpgrCXPtr0);
2923         refBitmap->getPixelPtr(-1-refDX, y-refDY, &tpgrCXPtr1);
2924         tpgrCX1 = refBitmap->nextPixel(&tpgrCXPtr1);
2925         tpgrCX1 = (tpgrCX1 << 1) | refBitmap->nextPixel(&tpgrCXPtr1);
2926         tpgrCX1 = (tpgrCX1 << 1) | refBitmap->nextPixel(&tpgrCXPtr1);
2927         refBitmap->getPixelPtr(-1-refDX, y+1-refDY, &tpgrCXPtr2);
2928         tpgrCX2 = refBitmap->nextPixel(&tpgrCXPtr2);
2929         tpgrCX2 = (tpgrCX2 << 1) | refBitmap->nextPixel(&tpgrCXPtr2);
2930         tpgrCX2 = (tpgrCX2 << 1) | refBitmap->nextPixel(&tpgrCXPtr2);
2931       }
2932
2933       for (x = 0; x < w; ++x) {
2934
2935         // update the context
2936         cx0 = ((cx0 << 1) | bitmap->nextPixel(&cxPtr0)) & 7;
2937         cx3 = ((cx3 << 1) | refBitmap->nextPixel(&cxPtr3)) & 7;
2938         cx4 = ((cx4 << 1) | refBitmap->nextPixel(&cxPtr4)) & 3;
2939
2940         if (tpgrOn) {
2941           // update the typical predictor context
2942           tpgrCX0 = ((tpgrCX0 << 1) | refBitmap->nextPixel(&tpgrCXPtr0)) & 7;
2943           tpgrCX1 = ((tpgrCX1 << 1) | refBitmap->nextPixel(&tpgrCXPtr1)) & 7;
2944           tpgrCX2 = ((tpgrCX2 << 1) | refBitmap->nextPixel(&tpgrCXPtr2)) & 7;
2945
2946           // check for a "typical" pixel
2947           if (arithDecoder->decodeBit(ltpCX, refinementRegionStats)) {
2948             ltp = !ltp;
2949           }
2950           if (tpgrCX0 == 0 && tpgrCX1 == 0 && tpgrCX2 == 0) {
2951             bitmap->clearPixel(x, y);
2952             continue;
2953           } else if (tpgrCX0 == 7 && tpgrCX1 == 7 && tpgrCX2 == 7) {
2954             bitmap->setPixel(x, y);
2955             continue;
2956           }
2957         }
2958
2959         // build the context
2960         cx = (cx0 << 7) | (bitmap->nextPixel(&cxPtr1) << 6) |
2961              (refBitmap->nextPixel(&cxPtr2) << 5) |
2962              (cx3 << 2) | cx4;
2963
2964         // decode the pixel
2965         if ((pix = arithDecoder->decodeBit(cx, refinementRegionStats))) {
2966           bitmap->setPixel(x, y);
2967         }
2968       }
2969
2970     } else {
2971
2972       // set up the context
2973       bitmap->getPixelPtr(0, y-1, &cxPtr0);
2974       cx0 = bitmap->nextPixel(&cxPtr0);
2975       bitmap->getPixelPtr(-1, y, &cxPtr1);
2976       refBitmap->getPixelPtr(-refDX, y-1-refDY, &cxPtr2);
2977       cx2 = refBitmap->nextPixel(&cxPtr2);
2978       refBitmap->getPixelPtr(-1-refDX, y-refDY, &cxPtr3);
2979       cx3 = refBitmap->nextPixel(&cxPtr3);
2980       cx3 = (cx3 << 1) | refBitmap->nextPixel(&cxPtr3);
2981       refBitmap->getPixelPtr(-1-refDX, y+1-refDY, &cxPtr4);
2982       cx4 = refBitmap->nextPixel(&cxPtr4);
2983       cx4 = (cx4 << 1) | refBitmap->nextPixel(&cxPtr4);
2984       bitmap->getPixelPtr(atx[0], y+aty[0], &cxPtr5);
2985       refBitmap->getPixelPtr(atx[1]-refDX, y+aty[1]-refDY, &cxPtr6);
2986
2987       // set up the typical prediction context
2988       tpgrCX0 = tpgrCX1 = tpgrCX2 = 0; // make gcc happy
2989       if (tpgrOn) {
2990         refBitmap->getPixelPtr(-1-refDX, y-1-refDY, &tpgrCXPtr0);
2991         tpgrCX0 = refBitmap->nextPixel(&tpgrCXPtr0);
2992         tpgrCX0 = (tpgrCX0 << 1) | refBitmap->nextPixel(&tpgrCXPtr0);
2993         tpgrCX0 = (tpgrCX0 << 1) | refBitmap->nextPixel(&tpgrCXPtr0);
2994         refBitmap->getPixelPtr(-1-refDX, y-refDY, &tpgrCXPtr1);
2995         tpgrCX1 = refBitmap->nextPixel(&tpgrCXPtr1);
2996         tpgrCX1 = (tpgrCX1 << 1) | refBitmap->nextPixel(&tpgrCXPtr1);
2997         tpgrCX1 = (tpgrCX1 << 1) | refBitmap->nextPixel(&tpgrCXPtr1);
2998         refBitmap->getPixelPtr(-1-refDX, y+1-refDY, &tpgrCXPtr2);
2999         tpgrCX2 = refBitmap->nextPixel(&tpgrCXPtr2);
3000         tpgrCX2 = (tpgrCX2 << 1) | refBitmap->nextPixel(&tpgrCXPtr2);
3001         tpgrCX2 = (tpgrCX2 << 1) | refBitmap->nextPixel(&tpgrCXPtr2);
3002       }
3003
3004       for (x = 0; x < w; ++x) {
3005
3006         // update the context
3007         cx0 = ((cx0 << 1) | bitmap->nextPixel(&cxPtr0)) & 3;
3008         cx2 = ((cx2 << 1) | refBitmap->nextPixel(&cxPtr2)) & 3;
3009         cx3 = ((cx3 << 1) | refBitmap->nextPixel(&cxPtr3)) & 7;
3010         cx4 = ((cx4 << 1) | refBitmap->nextPixel(&cxPtr4)) & 7;
3011
3012         if (tpgrOn) {
3013           // update the typical predictor context
3014           tpgrCX0 = ((tpgrCX0 << 1) | refBitmap->nextPixel(&tpgrCXPtr0)) & 7;
3015           tpgrCX1 = ((tpgrCX1 << 1) | refBitmap->nextPixel(&tpgrCXPtr1)) & 7;
3016           tpgrCX2 = ((tpgrCX2 << 1) | refBitmap->nextPixel(&tpgrCXPtr2)) & 7;
3017
3018           // check for a "typical" pixel
3019           if (arithDecoder->decodeBit(ltpCX, refinementRegionStats)) {
3020             ltp = !ltp;
3021           }
3022           if (tpgrCX0 == 0 && tpgrCX1 == 0 && tpgrCX2 == 0) {
3023             bitmap->clearPixel(x, y);
3024             continue;
3025           } else if (tpgrCX0 == 7 && tpgrCX1 == 7 && tpgrCX2 == 7) {
3026             bitmap->setPixel(x, y);
3027             continue;
3028           }
3029         }
3030
3031         // build the context
3032         cx = (cx0 << 11) | (bitmap->nextPixel(&cxPtr1) << 10) |
3033              (cx2 << 8) | (cx3 << 5) | (cx4 << 2) |
3034              (bitmap->nextPixel(&cxPtr5) << 1) |
3035              refBitmap->nextPixel(&cxPtr6);
3036
3037         // decode the pixel
3038         if ((pix = arithDecoder->decodeBit(cx, refinementRegionStats))) {
3039           bitmap->setPixel(x, y);
3040         }
3041       }
3042     }
3043   }
3044
3045   return bitmap;
3046 }
3047
3048 void JBIG2Stream::readPageInfoSeg(Guint length) {
3049   Guint xRes, yRes, flags, striping;
3050
3051   if (!readULong(&pageW) || !readULong(&pageH) ||
3052       !readULong(&xRes) || !readULong(&yRes) ||
3053       !readUByte(&flags) || !readUWord(&striping)) {
3054     goto eofError;
3055   }
3056   pageDefPixel = (flags >> 2) & 1;
3057   defCombOp = (flags >> 3) & 3;
3058
3059   // allocate the page bitmap
3060   if (pageH == 0xffffffff) {
3061     curPageH = striping & 0x7fff;
3062   } else {
3063     curPageH = pageH;
3064   }
3065   pageBitmap = new JBIG2Bitmap(0, pageW, curPageH);
3066
3067   // default pixel value
3068   if (pageDefPixel) {
3069     pageBitmap->clearToOne();
3070   } else {
3071     pageBitmap->clearToZero();
3072   }
3073
3074   return;
3075
3076  eofError:
3077   error(getPos(), "Unexpected EOF in JBIG2 stream");
3078 }
3079
3080 void JBIG2Stream::readEndOfStripeSeg(Guint length) {
3081   Guint i;
3082
3083   // skip the segment
3084   for (i = 0; i < length; ++i) {
3085     curStr->getChar();
3086   }
3087 }
3088
3089 void JBIG2Stream::readProfilesSeg(Guint length) {
3090   Guint i;
3091
3092   // skip the segment
3093   for (i = 0; i < length; ++i) {
3094     curStr->getChar();
3095   }
3096 }
3097
3098 void JBIG2Stream::readCodeTableSeg(Guint segNum, Guint length) {
3099   JBIG2HuffmanTable *huffTab;
3100   Guint flags, oob, prefixBits, rangeBits;
3101   int lowVal, highVal, val;
3102   Guint huffTabSize, i;
3103
3104   if (!readUByte(&flags) || !readLong(&lowVal) || !readLong(&highVal)) {
3105     goto eofError;
3106   }
3107   oob = flags & 1;
3108   prefixBits = ((flags >> 1) & 7) + 1;
3109   rangeBits = ((flags >> 4) & 7) + 1;
3110
3111   huffDecoder->reset();
3112   huffTabSize = 8;
3113   huffTab = (JBIG2HuffmanTable *)
3114                 gmalloc(huffTabSize * sizeof(JBIG2HuffmanTable));
3115   i = 0;
3116   val = lowVal;
3117   while (val < highVal) {
3118     if (i == huffTabSize) {
3119       huffTabSize *= 2;
3120       huffTab = (JBIG2HuffmanTable *)
3121                     grealloc(huffTab, huffTabSize * sizeof(JBIG2HuffmanTable));
3122     }
3123     huffTab[i].val = val;
3124     huffTab[i].prefixLen = huffDecoder->readBits(prefixBits);
3125     huffTab[i].rangeLen = huffDecoder->readBits(rangeBits);
3126     val += 1 << huffTab[i].rangeLen;
3127     ++i;
3128   }
3129   if (i + oob + 3 > huffTabSize) {
3130     huffTabSize = i + oob + 3;
3131     huffTab = (JBIG2HuffmanTable *)
3132                   grealloc(huffTab, huffTabSize * sizeof(JBIG2HuffmanTable));
3133   }
3134   huffTab[i].val = lowVal - 1;
3135   huffTab[i].prefixLen = huffDecoder->readBits(prefixBits);
3136   huffTab[i].rangeLen = jbig2HuffmanLOW;
3137   ++i;
3138   huffTab[i].val = highVal;
3139   huffTab[i].prefixLen = huffDecoder->readBits(prefixBits);
3140   huffTab[i].rangeLen = 32;
3141   ++i;
3142   if (oob) {
3143     huffTab[i].val = 0;
3144     huffTab[i].prefixLen = huffDecoder->readBits(prefixBits);
3145     huffTab[i].rangeLen = jbig2HuffmanOOB;
3146     ++i;
3147   }
3148   huffTab[i].val = 0;
3149   huffTab[i].prefixLen = 0;
3150   huffTab[i].rangeLen = jbig2HuffmanEOT;
3151   huffDecoder->buildTable(huffTab, i);
3152
3153   // create and store the new table segment
3154   segments->append(new JBIG2CodeTable(segNum, huffTab));
3155
3156   return;
3157
3158  eofError:
3159   error(getPos(), "Unexpected EOF in JBIG2 stream");
3160 }
3161
3162 void JBIG2Stream::readExtensionSeg(Guint length) {
3163   Guint i;
3164
3165   // skip the segment
3166   for (i = 0; i < length; ++i) {
3167     curStr->getChar();
3168   }
3169 }
3170
3171 JBIG2Segment *JBIG2Stream::findSegment(Guint segNum) {
3172   JBIG2Segment *seg;
3173   int i;
3174
3175   for (i = 0; i < globalSegments->getLength(); ++i) {
3176     seg = (JBIG2Segment *)globalSegments->get(i);
3177     if (seg->getSegNum() == segNum) {
3178       return seg;
3179     }
3180   }
3181   for (i = 0; i < segments->getLength(); ++i) {
3182     seg = (JBIG2Segment *)segments->get(i);
3183     if (seg->getSegNum() == segNum) {
3184       return seg;
3185     }
3186   }
3187   return NULL;
3188 }
3189
3190 void JBIG2Stream::discardSegment(Guint segNum) {
3191   JBIG2Segment *seg;
3192   int i;
3193
3194   for (i = 0; i < globalSegments->getLength(); ++i) {
3195     seg = (JBIG2Segment *)globalSegments->get(i);
3196     if (seg->getSegNum() == segNum) {
3197       globalSegments->del(i);
3198       return;
3199     }
3200   }
3201   for (i = 0; i < segments->getLength(); ++i) {
3202     seg = (JBIG2Segment *)segments->get(i);
3203     if (seg->getSegNum() == segNum) {
3204       segments->del(i);
3205       return;
3206     }
3207   }
3208 }
3209
3210 void JBIG2Stream::resetGenericStats(Guint templ,
3211                                     JArithmeticDecoderStats *prevStats) {
3212   int size;
3213
3214   size = contextSize[templ];
3215   if (prevStats && prevStats->getContextSize() == size) {
3216     if (genericRegionStats->getContextSize() == size) {
3217       genericRegionStats->copyFrom(prevStats);
3218     } else {
3219       delete genericRegionStats;
3220       genericRegionStats = prevStats->copy();
3221     }
3222   } else {
3223     if (genericRegionStats->getContextSize() == size) {
3224       genericRegionStats->reset();
3225     } else {
3226       delete genericRegionStats;
3227       genericRegionStats = new JArithmeticDecoderStats(1 << size);
3228     }
3229   }
3230 }
3231
3232 void JBIG2Stream::resetRefinementStats(Guint templ,
3233                                        JArithmeticDecoderStats *prevStats) {
3234   int size;
3235
3236   size = refContextSize[templ];
3237   if (prevStats && prevStats->getContextSize() == size) {
3238     if (refinementRegionStats->getContextSize() == size) {
3239       refinementRegionStats->copyFrom(prevStats);
3240     } else {
3241       delete refinementRegionStats;
3242       refinementRegionStats = prevStats->copy();
3243     }
3244   } else {
3245     if (refinementRegionStats->getContextSize() == size) {
3246       refinementRegionStats->reset();
3247     } else {
3248       delete refinementRegionStats;
3249       refinementRegionStats = new JArithmeticDecoderStats(1 << size);
3250     }
3251   }
3252 }
3253
3254 void JBIG2Stream::resetIntStats(int symCodeLen) {
3255   iadhStats->reset();
3256   iadwStats->reset();
3257   iaexStats->reset();
3258   iaaiStats->reset();
3259   iadtStats->reset();
3260   iaitStats->reset();
3261   iafsStats->reset();
3262   iadsStats->reset();
3263   iardxStats->reset();
3264   iardyStats->reset();
3265   iardwStats->reset();
3266   iardhStats->reset();
3267   iariStats->reset();
3268   if (iaidStats->getContextSize() == symCodeLen + 1) {
3269     iaidStats->reset();
3270   } else {
3271     delete iaidStats;
3272     iaidStats = new JArithmeticDecoderStats(1 << (symCodeLen + 1));
3273   }
3274 }
3275
3276 GBool JBIG2Stream::readUByte(Guint *x) {
3277   int c0;
3278
3279   if ((c0 = curStr->getChar()) == EOF) {
3280     return gFalse;
3281   }
3282   *x = (Guint)c0;
3283   return gTrue;
3284 }
3285
3286 GBool JBIG2Stream::readByte(int *x) {
3287  int c0;
3288
3289   if ((c0 = curStr->getChar()) == EOF) {
3290     return gFalse;
3291   }
3292   *x = c0;
3293   if (c0 & 0x80) {
3294     *x |= -1 - 0xff;
3295   }
3296   return gTrue;
3297 }
3298
3299 GBool JBIG2Stream::readUWord(Guint *x) {
3300   int c0, c1;
3301
3302   if ((c0 = curStr->getChar()) == EOF ||
3303       (c1 = curStr->getChar()) == EOF) {
3304     return gFalse;
3305   }
3306   *x = (Guint)((c0 << 8) | c1);
3307   return gTrue;
3308 }
3309
3310 GBool JBIG2Stream::readULong(Guint *x) {
3311   int c0, c1, c2, c3;
3312
3313   if ((c0 = curStr->getChar()) == EOF ||
3314       (c1 = curStr->getChar()) == EOF ||
3315       (c2 = curStr->getChar()) == EOF ||
3316       (c3 = curStr->getChar()) == EOF) {
3317     return gFalse;
3318   }
3319   *x = (Guint)((c0 << 24) | (c1 << 16) | (c2 << 8) | c3);
3320   return gTrue;
3321 }
3322
3323 GBool JBIG2Stream::readLong(int *x) {
3324   int c0, c1, c2, c3;
3325
3326   if ((c0 = curStr->getChar()) == EOF ||
3327       (c1 = curStr->getChar()) == EOF ||
3328       (c2 = curStr->getChar()) == EOF ||
3329       (c3 = curStr->getChar()) == EOF) {
3330     return gFalse;
3331   }
3332   *x = ((c0 << 24) | (c1 << 16) | (c2 << 8) | c3);
3333   if (c0 & 0x80) {
3334     *x |= -1 - (int)0xffffffff;
3335   }
3336   return gTrue;
3337 }