xpdf-3.02 fixes
[swftools.git] / lib / xpdf / JPXStream.cc
1 //========================================================================
2 //
3 // JPXStream.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 "gmem.h"
16 #include "Error.h"
17 #include "JArithmeticDecoder.h"
18 #include "JPXStream.h"
19
20 //~ to do:
21 //  - precincts
22 //  - ROI
23 //  - progression order changes
24 //  - packed packet headers
25 //  - support for palettes, channel maps, etc.
26 //  - make sure all needed JP2/JPX subboxes are parsed (readBoxes)
27 //  - can we assume that QCC segments must come after the QCD segment?
28 //  - skip EPH markers (readTilePartData)
29 //  - handle tilePartToEOC in readTilePartData
30 //  - deal with multiple codeword segments (readTilePartData,
31 //    readCodeBlockData)
32 //  - progression orders 2, 3, and 4
33 //  - in coefficient decoding (readCodeBlockData):
34 //    - termination pattern: terminate after every coding pass
35 //    - error resilience segmentation symbol
36 //    - selective arithmetic coding bypass
37 //    - vertically causal context formation
38 //    - coeffs longer than 31 bits (should just ignore the extra bits?)
39 //  - handle boxes larger than 2^32 bytes
40 //  - the fixed-point arithmetic won't handle 16-bit pixels
41
42 //------------------------------------------------------------------------
43
44 // number of contexts for the arithmetic decoder
45 #define jpxNContexts        19
46
47 #define jpxContextSigProp    0  // 0 - 8: significance prop and cleanup
48 #define jpxContextSign       9  // 9 - 13: sign
49 #define jpxContextMagRef    14  // 14 -16: magnitude refinement
50 #define jpxContextRunLength 17  // cleanup: run length
51 #define jpxContextUniform   18  // cleanup: first signif coeff
52
53 //------------------------------------------------------------------------
54
55 #define jpxPassSigProp       0
56 #define jpxPassMagRef        1
57 #define jpxPassCleanup       2
58
59 //------------------------------------------------------------------------
60
61 // arithmetic decoder context for the significance propagation and
62 // cleanup passes:
63 //     [horiz][vert][diag][subband]
64 // where subband = 0 for HL
65 //               = 1 for LH and LL
66 //               = 2 for HH
67 static Guint sigPropContext[3][3][5][3] = {
68   {{{ 0, 0, 0 },   // horiz=0, vert=0, diag=0
69     { 1, 1, 3 },   // horiz=0, vert=0, diag=1
70     { 2, 2, 6 },   // horiz=0, vert=0, diag=2
71     { 2, 2, 8 },   // horiz=0, vert=0, diag=3
72     { 2, 2, 8 }},  // horiz=0, vert=0, diag=4
73    {{ 5, 3, 1 },   // horiz=0, vert=1, diag=0
74     { 6, 3, 4 },   // horiz=0, vert=1, diag=1
75     { 6, 3, 7 },   // horiz=0, vert=1, diag=2
76     { 6, 3, 8 },   // horiz=0, vert=1, diag=3
77     { 6, 3, 8 }},  // horiz=0, vert=1, diag=4
78    {{ 8, 4, 2 },   // horiz=0, vert=2, diag=0
79     { 8, 4, 5 },   // horiz=0, vert=2, diag=1
80     { 8, 4, 7 },   // horiz=0, vert=2, diag=2
81     { 8, 4, 8 },   // horiz=0, vert=2, diag=3
82     { 8, 4, 8 }}}, // horiz=0, vert=2, diag=4
83   {{{ 3, 5, 1 },   // horiz=1, vert=0, diag=0
84     { 3, 6, 4 },   // horiz=1, vert=0, diag=1
85     { 3, 6, 7 },   // horiz=1, vert=0, diag=2
86     { 3, 6, 8 },   // horiz=1, vert=0, diag=3
87     { 3, 6, 8 }},  // horiz=1, vert=0, diag=4
88    {{ 7, 7, 2 },   // horiz=1, vert=1, diag=0
89     { 7, 7, 5 },   // horiz=1, vert=1, diag=1
90     { 7, 7, 7 },   // horiz=1, vert=1, diag=2
91     { 7, 7, 8 },   // horiz=1, vert=1, diag=3
92     { 7, 7, 8 }},  // horiz=1, vert=1, diag=4
93    {{ 8, 7, 2 },   // horiz=1, vert=2, diag=0
94     { 8, 7, 5 },   // horiz=1, vert=2, diag=1
95     { 8, 7, 7 },   // horiz=1, vert=2, diag=2
96     { 8, 7, 8 },   // horiz=1, vert=2, diag=3
97     { 8, 7, 8 }}}, // horiz=1, vert=2, diag=4
98   {{{ 4, 8, 2 },   // horiz=2, vert=0, diag=0
99     { 4, 8, 5 },   // horiz=2, vert=0, diag=1
100     { 4, 8, 7 },   // horiz=2, vert=0, diag=2
101     { 4, 8, 8 },   // horiz=2, vert=0, diag=3
102     { 4, 8, 8 }},  // horiz=2, vert=0, diag=4
103    {{ 7, 8, 2 },   // horiz=2, vert=1, diag=0
104     { 7, 8, 5 },   // horiz=2, vert=1, diag=1
105     { 7, 8, 7 },   // horiz=2, vert=1, diag=2
106     { 7, 8, 8 },   // horiz=2, vert=1, diag=3
107     { 7, 8, 8 }},  // horiz=2, vert=1, diag=4
108    {{ 8, 8, 2 },   // horiz=2, vert=2, diag=0
109     { 8, 8, 5 },   // horiz=2, vert=2, diag=1
110     { 8, 8, 7 },   // horiz=2, vert=2, diag=2
111     { 8, 8, 8 },   // horiz=2, vert=2, diag=3
112     { 8, 8, 8 }}}  // horiz=2, vert=2, diag=4
113 };
114
115 // arithmetic decoder context and xor bit for the sign bit in the
116 // significance propagation pass:
117 //     [horiz][vert][k]
118 // where horiz/vert are offset by 2 (i.e., range is -2 .. 2)
119 // and k = 0 for the context
120 //       = 1 for the xor bit
121 static Guint signContext[5][5][2] = {
122   {{ 13, 1 },  // horiz=-2, vert=-2
123    { 13, 1 },  // horiz=-2, vert=-1
124    { 12, 1 },  // horiz=-2, vert= 0
125    { 11, 1 },  // horiz=-2, vert=+1
126    { 11, 1 }}, // horiz=-2, vert=+2
127   {{ 13, 1 },  // horiz=-1, vert=-2
128    { 13, 1 },  // horiz=-1, vert=-1
129    { 12, 1 },  // horiz=-1, vert= 0
130    { 11, 1 },  // horiz=-1, vert=+1
131    { 11, 1 }}, // horiz=-1, vert=+2
132   {{ 10, 1 },  // horiz= 0, vert=-2
133    { 10, 1 },  // horiz= 0, vert=-1
134    {  9, 0 },  // horiz= 0, vert= 0
135    { 10, 0 },  // horiz= 0, vert=+1
136    { 10, 0 }}, // horiz= 0, vert=+2
137   {{ 11, 0 },  // horiz=+1, vert=-2
138    { 11, 0 },  // horiz=+1, vert=-1
139    { 12, 0 },  // horiz=+1, vert= 0
140    { 13, 0 },  // horiz=+1, vert=+1
141    { 13, 0 }}, // horiz=+1, vert=+2
142   {{ 11, 0 },  // horiz=+2, vert=-2
143    { 11, 0 },  // horiz=+2, vert=-1
144    { 12, 0 },  // horiz=+2, vert= 0
145    { 13, 0 },  // horiz=+2, vert=+1
146    { 13, 0 }}, // horiz=+2, vert=+2
147 };
148
149 //------------------------------------------------------------------------
150
151 // constants used in the IDWT
152 #define idwtAlpha  -1.586134342059924
153 #define idwtBeta   -0.052980118572961
154 #define idwtGamma   0.882911075530934
155 #define idwtDelta   0.443506852043971
156 #define idwtKappa   1.230174104914001
157 #define idwtIKappa  (1.0 / idwtKappa)
158
159 // number of bits to the right of the decimal point for the fixed
160 // point arithmetic used in the IDWT
161 #define fracBits 16
162
163 //------------------------------------------------------------------------
164
165 // floor(x / y)
166 #define jpxFloorDiv(x, y) ((x) / (y))
167
168 // floor(x / 2^y)
169 #define jpxFloorDivPow2(x, y) ((x) >> (y))
170
171 // ceil(x / y)
172 #define jpxCeilDiv(x, y) (((x) + (y) - 1) / (y))
173
174 // ceil(x / 2^y)
175 #define jpxCeilDivPow2(x, y) (((x) + (1 << (y)) - 1) >> (y))
176
177 //------------------------------------------------------------------------
178
179 JPXStream::JPXStream(Stream *strA):
180   FilterStream(strA)
181 {
182   nComps = 0;
183   bpc = NULL;
184   width = height = 0;
185   haveCS = gFalse;
186   havePalette = gFalse;
187   haveCompMap = gFalse;
188   haveChannelDefn = gFalse;
189
190   img.tiles = NULL;
191   bitBuf = 0;
192   bitBufLen = 0;
193   bitBufSkip = gFalse;
194   byteCount = 0;
195 }
196
197 JPXStream::~JPXStream() {
198   JPXTile *tile;
199   JPXTileComp *tileComp;
200   JPXResLevel *resLevel;
201   JPXPrecinct *precinct;
202   JPXSubband *subband;
203   JPXCodeBlock *cb;
204   Guint comp, i, k, r, pre, sb;
205
206   gfree(bpc);
207   if (havePalette) {
208     gfree(palette.bpc);
209     gfree(palette.c);
210   }
211   if (haveCompMap) {
212     gfree(compMap.comp);
213     gfree(compMap.type);
214     gfree(compMap.pComp);
215   }
216   if (haveChannelDefn) {
217     gfree(channelDefn.idx);
218     gfree(channelDefn.type);
219     gfree(channelDefn.assoc);
220   }
221
222   if (img.tiles) {
223     for (i = 0; i < img.nXTiles * img.nYTiles; ++i) {
224       tile = &img.tiles[i];
225       if (tile->tileComps) {
226         for (comp = 0; comp < img.nComps; ++comp) {
227           tileComp = &tile->tileComps[comp];
228           gfree(tileComp->quantSteps);
229           gfree(tileComp->data);
230           gfree(tileComp->buf);
231           if (tileComp->resLevels) {
232             for (r = 0; r <= tileComp->nDecompLevels; ++r) {
233               resLevel = &tileComp->resLevels[r];
234               if (resLevel->precincts) {
235                 for (pre = 0; pre < 1; ++pre) {
236                   precinct = &resLevel->precincts[pre];
237                   if (precinct->subbands) {
238                     for (sb = 0; sb < (r == 0 ? 1 : 3); ++sb) {
239                       subband = &precinct->subbands[sb];
240                       gfree(subband->inclusion);
241                       gfree(subband->zeroBitPlane);
242                       if (subband->cbs) {
243                         for (k = 0; k < subband->nXCBs * subband->nYCBs; ++k) {
244                           cb = &subband->cbs[k];
245                           gfree(cb->coeffs);
246                           if (cb->arithDecoder) {
247                             delete cb->arithDecoder;
248                           }
249                           if (cb->stats) {
250                             delete cb->stats;
251                           }
252                         }
253                         gfree(subband->cbs);
254                       }
255                     }
256                     gfree(precinct->subbands);
257                   }
258                 }
259                 gfree(img.tiles[i].tileComps[comp].resLevels[r].precincts);
260               }
261             }
262             gfree(img.tiles[i].tileComps[comp].resLevels);
263           }
264         }
265         gfree(img.tiles[i].tileComps);
266       }
267     }
268     gfree(img.tiles);
269   }
270   delete str;
271 }
272
273 void JPXStream::reset() {
274   str->reset();
275   if (readBoxes()) {
276     curY = img.yOffset;
277   } else {
278     // readBoxes reported an error, so we go immediately to EOF
279     curY = img.ySize;
280   }
281   curX = img.xOffset;
282   curComp = 0;
283   readBufLen = 0;
284 }
285
286 int JPXStream::getChar() {
287   int c;
288
289   if (readBufLen < 8) {
290     fillReadBuf();
291   }
292   if (readBufLen == 8) {
293     c = readBuf & 0xff;
294     readBufLen = 0;
295   } else if (readBufLen > 8) {
296     c = (readBuf >> (readBufLen - 8)) & 0xff;
297     readBufLen -= 8;
298   } else if (readBufLen == 0) {
299     c = EOF;
300   } else {
301     c = (readBuf << (8 - readBufLen)) & 0xff;
302     readBufLen = 0;
303   }
304   return c;
305 }
306
307 int JPXStream::lookChar() {
308   int c;
309
310   if (readBufLen < 8) {
311     fillReadBuf();
312   }
313   if (readBufLen == 8) {
314     c = readBuf & 0xff;
315   } else if (readBufLen > 8) {
316     c = (readBuf >> (readBufLen - 8)) & 0xff;
317   } else if (readBufLen == 0) {
318     c = EOF;
319   } else {
320     c = (readBuf << (8 - readBufLen)) & 0xff;
321   }
322   return c;
323 }
324
325 void JPXStream::fillReadBuf() {
326   JPXTileComp *tileComp;
327   Guint tileIdx, tx, ty;
328   int pix, pixBits;
329
330   do {
331     if (curY >= img.ySize) {
332       return;
333     }
334     tileIdx = ((curY - img.yTileOffset) / img.yTileSize) * img.nXTiles
335               + (curX - img.xTileOffset) / img.xTileSize;
336 #if 1 //~ ignore the palette, assume the PDF ColorSpace object is valid
337     tileComp = &img.tiles[tileIdx].tileComps[curComp];
338 #else
339     tileComp = &img.tiles[tileIdx].tileComps[havePalette ? 0 : curComp];
340 #endif
341     tx = jpxCeilDiv((curX - img.xTileOffset) % img.xTileSize, tileComp->hSep);
342     ty = jpxCeilDiv((curY - img.yTileOffset) % img.yTileSize, tileComp->vSep);
343     pix = (int)tileComp->data[ty * (tileComp->x1 - tileComp->x0) + tx];
344     pixBits = tileComp->prec;
345 #if 1 //~ ignore the palette, assume the PDF ColorSpace object is valid
346     if (++curComp == img.nComps) {
347 #else
348     if (havePalette) {
349       if (pix >= 0 && pix < palette.nEntries) {
350         pix = palette.c[pix * palette.nComps + curComp];
351       } else {
352         pix = 
353       pixBits = palette.bpc[curComp];
354     }
355     if (++curComp == (Guint)(havePalette ? palette.nComps : img.nComps)) {
356 #endif
357       curComp = 0;
358       if (++curX == img.xSize) {
359         curX = img.xOffset;
360         ++curY;
361       }
362     }
363     if (pixBits == 8) {
364       readBuf = (readBuf << 8) | (pix & 0xff);
365     } else {
366       readBuf = (readBuf << pixBits) | (pix & ((1 << pixBits) - 1));
367     }
368     readBufLen += pixBits;
369   } while (readBufLen < 8);
370 }
371
372 GString *JPXStream::getPSFilter(int psLevel, char *indent) {
373   return NULL;
374 }
375
376 GBool JPXStream::isBinary(GBool last) {
377   return str->isBinary(gTrue);
378 }
379
380 void JPXStream::getImageParams(int *bitsPerComponent,
381                                StreamColorSpaceMode *csMode) {
382   Guint boxType, boxLen, dataLen, csEnum;
383   Guint bpc1, dummy, i;
384   int csMeth, csPrec, csPrec1, dummy2;
385   StreamColorSpaceMode csMode1;
386   GBool haveBPC, haveCSMode;
387
388   csPrec = 0; // make gcc happy
389   haveBPC = haveCSMode = gFalse;
390   str->reset();
391   if (str->lookChar() == 0xff) {
392     getImageParams2(bitsPerComponent, csMode);
393   } else {
394     while (readBoxHdr(&boxType, &boxLen, &dataLen)) {
395       if (boxType == 0x6a703268) { // JP2 header
396         // skip the superbox
397       } else if (boxType == 0x69686472) { // image header
398         if (readULong(&dummy) &&
399             readULong(&dummy) &&
400             readUWord(&dummy) &&
401             readUByte(&bpc1) &&
402             readUByte(&dummy) &&
403             readUByte(&dummy) &&
404             readUByte(&dummy)) {
405           *bitsPerComponent = bpc1 + 1;
406           haveBPC = gTrue;
407         }
408       } else if (boxType == 0x636F6C72) { // color specification
409         if (readByte(&csMeth) &&
410             readByte(&csPrec1) &&
411             readByte(&dummy2)) {
412           if (csMeth == 1) {
413             if (readULong(&csEnum)) {
414               csMode1 = streamCSNone;
415               if (csEnum == jpxCSBiLevel ||
416                   csEnum == jpxCSGrayscale) {
417                 csMode1 = streamCSDeviceGray;
418               } else if (csEnum == jpxCSCMYK) {
419                 csMode1 = streamCSDeviceCMYK;
420               } else if (csEnum == jpxCSsRGB ||
421                          csEnum == jpxCSCISesRGB ||
422                          csEnum == jpxCSROMMRGB) {
423                 csMode1 = streamCSDeviceRGB;
424               }
425               if (csMode1 != streamCSNone &&
426                   (!haveCSMode || csPrec1 > csPrec)) {
427                 *csMode = csMode1;
428                 csPrec = csPrec1;
429                 haveCSMode = gTrue;
430               }
431               for (i = 0; i < dataLen - 7; ++i) {
432                 str->getChar();
433               }
434             }
435           } else {
436             for (i = 0; i < dataLen - 3; ++i) {
437               str->getChar();
438             }
439           }
440         }
441       } else if (boxType == 0x6A703263) { // codestream
442         if (!(haveBPC && haveCSMode)) {
443           getImageParams2(bitsPerComponent, csMode);
444         }
445         break;
446       } else {
447         for (i = 0; i < dataLen; ++i) {
448           str->getChar();
449         }
450       }
451     }
452   }
453   str->close();
454 }
455
456 // Get image parameters from the codestream.
457 void JPXStream::getImageParams2(int *bitsPerComponent,
458                                 StreamColorSpaceMode *csMode) {
459   int segType;
460   Guint segLen, nComps1, bpc1, dummy, i;
461
462   while (readMarkerHdr(&segType, &segLen)) {
463     if (segType == 0x51) { // SIZ - image and tile size
464       if (readUWord(&dummy) &&
465           readULong(&dummy) &&
466           readULong(&dummy) &&
467           readULong(&dummy) &&
468           readULong(&dummy) &&
469           readULong(&dummy) &&
470           readULong(&dummy) &&
471           readULong(&dummy) &&
472           readULong(&dummy) &&
473           readUWord(&nComps1) &&
474           readUByte(&bpc1)) {
475         *bitsPerComponent = (bpc1 & 0x7f) + 1;
476         // if there's no color space info, take a guess
477         if (nComps1 == 1) {
478           *csMode = streamCSDeviceGray;
479         } else if (nComps1 == 3) {
480           *csMode = streamCSDeviceRGB;
481         } else if (nComps1 == 4) {
482           *csMode = streamCSDeviceCMYK;
483         }
484       }
485       break;
486     } else {
487       if (segLen > 2) {
488         for (i = 0; i < segLen - 2; ++i) {
489           str->getChar();
490         }
491       }
492     }
493   }
494 }
495
496 GBool JPXStream::readBoxes() {
497   Guint boxType, boxLen, dataLen;
498   Guint bpc1, compression, unknownColorspace, ipr;
499   Guint i, j;
500
501   haveImgHdr = gFalse;
502
503   // check for a naked JPEG 2000 codestream (without the JP2/JPX
504   // wrapper) -- this appears to be a violation of the PDF spec, but
505   // Acrobat allows it
506   if (str->lookChar() == 0xff) {
507     error(getPos(), "Naked JPEG 2000 codestream, missing JP2/JPX wrapper");
508     readCodestream(0);
509     nComps = img.nComps;
510     bpc = (Guint *)gmallocn(nComps, sizeof(Guint));
511     for (i = 0; i < nComps; ++i) {
512       bpc[i] = img.tiles[0].tileComps[i].prec;
513     }
514     width = img.xSize - img.xOffset;
515     height = img.ySize - img.yOffset;
516     return gTrue;
517   }
518
519   while (readBoxHdr(&boxType, &boxLen, &dataLen)) {
520     switch (boxType) {
521     case 0x6a703268:            // JP2 header
522       // this is a grouping box ('superbox') which has no real
523       // contents and doesn't appear to be used consistently, i.e.,
524       // some things which should be subboxes of the JP2 header box
525       // show up outside of it - so we simply ignore the JP2 header
526       // box
527       break;
528     case 0x69686472:            // image header
529       if (!readULong(&height) ||
530           !readULong(&width) ||
531           !readUWord(&nComps) ||
532           !readUByte(&bpc1) ||
533           !readUByte(&compression) ||
534           !readUByte(&unknownColorspace) ||
535           !readUByte(&ipr)) {
536         error(getPos(), "Unexpected EOF in JPX stream");
537         return gFalse;
538       }
539       if (compression != 7) {
540         error(getPos(), "Unknown compression type in JPX stream");
541         return gFalse;
542       }
543       bpc = (Guint *)gmallocn(nComps, sizeof(Guint));
544       for (i = 0; i < nComps; ++i) {
545         bpc[i] = bpc1;
546       }
547       haveImgHdr = gTrue;
548       break;
549     case 0x62706363:            // bits per component
550       if (!haveImgHdr) {
551         error(getPos(), "Found bits per component box before image header box in JPX stream");
552         return gFalse;
553       }
554       if (dataLen != nComps) {
555         error(getPos(), "Invalid bits per component box in JPX stream");
556         return gFalse;
557       }
558       for (i = 0; i < nComps; ++i) {
559         if (!readUByte(&bpc[i])) {
560           error(getPos(), "Unexpected EOF in JPX stream");
561           return gFalse;
562         }
563       }
564       break;
565     case 0x636F6C72:            // color specification
566       if (!readColorSpecBox(dataLen)) {
567         return gFalse;
568       }
569       break;
570     case 0x70636c72:            // palette
571       if (!readUWord(&palette.nEntries) ||
572           !readUByte(&palette.nComps)) {
573         error(getPos(), "Unexpected EOF in JPX stream");
574         return gFalse;
575       }
576       palette.bpc = (Guint *)gmallocn(palette.nComps, sizeof(Guint));
577       palette.c =
578           (int *)gmallocn(palette.nEntries * palette.nComps, sizeof(int));
579       for (i = 0; i < palette.nComps; ++i) {
580         if (!readUByte(&palette.bpc[i])) {
581           error(getPos(), "Unexpected EOF in JPX stream");
582           return gFalse;
583         }
584         ++palette.bpc[i];
585       }
586       for (i = 0; i < palette.nEntries; ++i) {
587         for (j = 0; j < palette.nComps; ++j) {
588           if (!readNBytes(((palette.bpc[j] & 0x7f) + 7) >> 3,
589                           (palette.bpc[j] & 0x80) ? gTrue : gFalse,
590                           &palette.c[i * palette.nComps + j])) {
591             error(getPos(), "Unexpected EOF in JPX stream");
592             return gFalse;
593           }
594         }
595       }
596       havePalette = gTrue;
597       break;
598     case 0x636d6170:            // component mapping
599       compMap.nChannels = dataLen / 4;
600       compMap.comp = (Guint *)gmallocn(compMap.nChannels, sizeof(Guint));
601       compMap.type = (Guint *)gmallocn(compMap.nChannels, sizeof(Guint));
602       compMap.pComp = (Guint *)gmallocn(compMap.nChannels, sizeof(Guint));
603       for (i = 0; i < compMap.nChannels; ++i) {
604         if (!readUWord(&compMap.comp[i]) ||
605             !readUByte(&compMap.type[i]) ||
606             !readUByte(&compMap.pComp[i])) {
607           error(getPos(), "Unexpected EOF in JPX stream");
608           return gFalse;
609         }
610       }
611       haveCompMap = gTrue;
612       break;
613     case 0x63646566:            // channel definition
614       if (!readUWord(&channelDefn.nChannels)) {
615         error(getPos(), "Unexpected EOF in JPX stream");
616         return gFalse;
617       }
618       channelDefn.idx =
619           (Guint *)gmallocn(channelDefn.nChannels, sizeof(Guint));
620       channelDefn.type =
621           (Guint *)gmallocn(channelDefn.nChannels, sizeof(Guint));
622       channelDefn.assoc =
623           (Guint *)gmallocn(channelDefn.nChannels, sizeof(Guint));
624       for (i = 0; i < channelDefn.nChannels; ++i) {
625         if (!readUWord(&channelDefn.idx[i]) ||
626             !readUWord(&channelDefn.type[i]) ||
627             !readUWord(&channelDefn.assoc[i])) {
628           error(getPos(), "Unexpected EOF in JPX stream");
629           return gFalse;
630         }
631       }
632       haveChannelDefn = gTrue;
633       break;
634     case 0x6A703263:            // contiguous codestream
635       if (!bpc) {
636         error(getPos(), "JPX stream is missing the image header box");
637       }
638       if (!haveCS) {
639         error(getPos(), "JPX stream has no supported color spec");
640       }
641       if (!readCodestream(dataLen)) {
642         return gFalse;
643       }
644       break;
645     default:
646       for (i = 0; i < dataLen; ++i) {
647         if (str->getChar() == EOF) {
648           error(getPos(), "Unexpected EOF in JPX stream");
649           return gFalse;
650         }
651       }
652       break;
653     }
654   }
655   return gTrue;
656 }
657
658 GBool JPXStream::readColorSpecBox(Guint dataLen) {
659   JPXColorSpec newCS;
660   Guint csApprox, csEnum;
661   Guint i;
662   GBool ok;
663
664   ok = gFalse;
665   if (!readUByte(&newCS.meth) ||
666       !readByte(&newCS.prec) ||
667       !readUByte(&csApprox)) {
668     goto err;
669   }
670   switch (newCS.meth) {
671   case 1:                       // enumerated colorspace
672     if (!readULong(&csEnum)) {
673       goto err;
674     }
675     newCS.enumerated.type = (JPXColorSpaceType)csEnum;
676     switch (newCS.enumerated.type) {
677     case jpxCSBiLevel:
678       ok = gTrue;
679       break;
680     case jpxCSYCbCr1:
681       ok = gTrue;
682       break;
683     case jpxCSYCbCr2:
684       ok = gTrue;
685       break;
686     case jpxCSYCBCr3:
687       ok = gTrue;
688       break;
689     case jpxCSPhotoYCC:
690       ok = gTrue;
691       break;
692     case jpxCSCMY:
693       ok = gTrue;
694       break;
695     case jpxCSCMYK:
696       ok = gTrue;
697       break;
698     case jpxCSYCCK:
699       ok = gTrue;
700       break;
701     case jpxCSCIELab:
702       if (dataLen == 7 + 7*4) {
703         if (!readULong(&newCS.enumerated.cieLab.rl) ||
704             !readULong(&newCS.enumerated.cieLab.ol) ||
705             !readULong(&newCS.enumerated.cieLab.ra) ||
706             !readULong(&newCS.enumerated.cieLab.oa) ||
707             !readULong(&newCS.enumerated.cieLab.rb) ||
708             !readULong(&newCS.enumerated.cieLab.ob) ||
709             !readULong(&newCS.enumerated.cieLab.il)) {
710           goto err;
711         }
712       } else if (dataLen == 7) {
713         //~ this assumes the 8-bit case
714         newCS.enumerated.cieLab.rl = 100;
715         newCS.enumerated.cieLab.ol = 0;
716         newCS.enumerated.cieLab.ra = 255;
717         newCS.enumerated.cieLab.oa = 128;
718         newCS.enumerated.cieLab.rb = 255;
719         newCS.enumerated.cieLab.ob = 96;
720         newCS.enumerated.cieLab.il = 0x00443530;
721       } else {
722         goto err;
723       }
724       ok = gTrue;
725       break;
726     case jpxCSsRGB:
727       ok = gTrue;
728       break;
729     case jpxCSGrayscale:
730       ok = gTrue;
731       break;
732     case jpxCSBiLevel2:
733       ok = gTrue;
734       break;
735     case jpxCSCIEJab:
736       // not allowed in PDF
737       goto err;
738     case jpxCSCISesRGB:
739       ok = gTrue;
740       break;
741     case jpxCSROMMRGB:
742       ok = gTrue;
743       break;
744     case jpxCSsRGBYCbCr:
745       ok = gTrue;
746       break;
747     case jpxCSYPbPr1125:
748       ok = gTrue;
749       break;
750     case jpxCSYPbPr1250:
751       ok = gTrue;
752       break;
753     default:
754       goto err;
755     }
756     break;
757   case 2:                       // restricted ICC profile
758   case 3:                       // any ICC profile (JPX)
759   case 4:                       // vendor color (JPX)
760     for (i = 0; i < dataLen - 3; ++i) {
761       if (str->getChar() == EOF) {
762         goto err;
763       }
764     }
765     break;
766   }
767
768   if (ok && (!haveCS || newCS.prec > cs.prec)) {
769     cs = newCS;
770     haveCS = gTrue;
771   }
772
773   return gTrue;
774
775  err:
776   error(getPos(), "Error in JPX color spec");
777   return gFalse;
778 }
779
780 GBool JPXStream::readCodestream(Guint len) {
781   JPXTile *tile;
782   JPXTileComp *tileComp;
783   int segType;
784   GBool haveSIZ, haveCOD, haveQCD, haveSOT;
785   Guint precinctSize, style;
786   Guint segLen, capabilities, nTiles, comp, i, j, r;
787
788   //----- main header
789   haveSIZ = haveCOD = haveQCD = haveSOT = gFalse;
790   do {
791     if (!readMarkerHdr(&segType, &segLen)) {
792       error(getPos(), "Error in JPX codestream");
793       return gFalse;
794     }
795     switch (segType) {
796     case 0x4f:                  // SOC - start of codestream
797       // marker only
798       break;
799     case 0x51:                  // SIZ - image and tile size
800       if (!readUWord(&capabilities) ||
801           !readULong(&img.xSize) ||
802           !readULong(&img.ySize) ||
803           !readULong(&img.xOffset) ||
804           !readULong(&img.yOffset) ||
805           !readULong(&img.xTileSize) ||
806           !readULong(&img.yTileSize) ||
807           !readULong(&img.xTileOffset) ||
808           !readULong(&img.yTileOffset) ||
809           !readUWord(&img.nComps)) {
810         error(getPos(), "Error in JPX SIZ marker segment");
811         return gFalse;
812       }
813       if (haveImgHdr && img.nComps != nComps) {
814         error(getPos(), "Different number of components in JPX SIZ marker segment");
815         return gFalse;
816       }
817       img.nXTiles = (img.xSize - img.xTileOffset + img.xTileSize - 1)
818                     / img.xTileSize;
819       img.nYTiles = (img.ySize - img.yTileOffset + img.yTileSize - 1)
820                     / img.yTileSize;
821       nTiles = img.nXTiles * img.nYTiles;
822       // check for overflow before allocating memory
823       if (nTiles == 0 || nTiles / img.nXTiles != img.nYTiles) {
824         error(getPos(), "Bad tile count in JPX SIZ marker segment");
825         return gFalse;
826       }
827       img.tiles = (JPXTile *)gmallocn(nTiles, sizeof(JPXTile));
828       for (i = 0; i < img.nXTiles * img.nYTiles; ++i) {
829         img.tiles[i].tileComps = (JPXTileComp *)gmallocn(img.nComps,
830                                                          sizeof(JPXTileComp));
831         for (comp = 0; comp < img.nComps; ++comp) {
832           img.tiles[i].tileComps[comp].quantSteps = NULL;
833           img.tiles[i].tileComps[comp].data = NULL;
834           img.tiles[i].tileComps[comp].buf = NULL;
835           img.tiles[i].tileComps[comp].resLevels = NULL;
836         }
837       }
838       for (comp = 0; comp < img.nComps; ++comp) {
839         if (!readUByte(&img.tiles[0].tileComps[comp].prec) ||
840             !readUByte(&img.tiles[0].tileComps[comp].hSep) ||
841             !readUByte(&img.tiles[0].tileComps[comp].vSep)) {
842           error(getPos(), "Error in JPX SIZ marker segment");
843           return gFalse;
844         }
845         img.tiles[0].tileComps[comp].sgned =
846             (img.tiles[0].tileComps[comp].prec & 0x80) ? gTrue : gFalse;
847         img.tiles[0].tileComps[comp].prec =
848             (img.tiles[0].tileComps[comp].prec & 0x7f) + 1;
849         for (i = 1; i < img.nXTiles * img.nYTiles; ++i) {
850           img.tiles[i].tileComps[comp] = img.tiles[0].tileComps[comp];
851         }
852       }
853       haveSIZ = gTrue;
854       break;
855     case 0x52:                  // COD - coding style default
856       if (!readUByte(&img.tiles[0].tileComps[0].style) ||
857           !readUByte(&img.tiles[0].progOrder) ||
858           !readUWord(&img.tiles[0].nLayers) ||
859           !readUByte(&img.tiles[0].multiComp) ||
860           !readUByte(&img.tiles[0].tileComps[0].nDecompLevels) ||
861           !readUByte(&img.tiles[0].tileComps[0].codeBlockW) ||
862           !readUByte(&img.tiles[0].tileComps[0].codeBlockH) ||
863           !readUByte(&img.tiles[0].tileComps[0].codeBlockStyle) ||
864           !readUByte(&img.tiles[0].tileComps[0].transform)) {
865         error(getPos(), "Error in JPX COD marker segment");
866         return gFalse;
867       }
868       img.tiles[0].tileComps[0].codeBlockW += 2;
869       img.tiles[0].tileComps[0].codeBlockH += 2;
870       for (i = 0; i < img.nXTiles * img.nYTiles; ++i) {
871         if (i != 0) {
872           img.tiles[i].progOrder = img.tiles[0].progOrder;
873           img.tiles[i].nLayers = img.tiles[0].nLayers;
874           img.tiles[i].multiComp = img.tiles[0].multiComp;
875         }
876         for (comp = 0; comp < img.nComps; ++comp) {
877           if (!(i == 0 && comp == 0)) {
878             img.tiles[i].tileComps[comp].style =
879                 img.tiles[0].tileComps[0].style;
880             img.tiles[i].tileComps[comp].nDecompLevels =
881                 img.tiles[0].tileComps[0].nDecompLevels;
882             img.tiles[i].tileComps[comp].codeBlockW =
883                 img.tiles[0].tileComps[0].codeBlockW;
884             img.tiles[i].tileComps[comp].codeBlockH =
885                 img.tiles[0].tileComps[0].codeBlockH;
886             img.tiles[i].tileComps[comp].codeBlockStyle =
887                 img.tiles[0].tileComps[0].codeBlockStyle;
888             img.tiles[i].tileComps[comp].transform =
889                 img.tiles[0].tileComps[0].transform;
890           }
891           img.tiles[i].tileComps[comp].resLevels =
892               (JPXResLevel *)gmallocn(
893                      (img.tiles[i].tileComps[comp].nDecompLevels + 1),
894                      sizeof(JPXResLevel));
895           for (r = 0; r <= img.tiles[i].tileComps[comp].nDecompLevels; ++r) {
896             img.tiles[i].tileComps[comp].resLevels[r].precincts = NULL;
897           }
898         }
899       }
900       for (r = 0; r <= img.tiles[0].tileComps[0].nDecompLevels; ++r) {
901         if (img.tiles[0].tileComps[0].style & 0x01) {
902           if (!readUByte(&precinctSize)) {
903             error(getPos(), "Error in JPX COD marker segment");
904             return gFalse;
905           }
906           img.tiles[0].tileComps[0].resLevels[r].precinctWidth =
907               precinctSize & 0x0f;
908           img.tiles[0].tileComps[0].resLevels[r].precinctHeight =
909               (precinctSize >> 4) & 0x0f;
910         } else {
911           img.tiles[0].tileComps[0].resLevels[r].precinctWidth = 15;
912           img.tiles[0].tileComps[0].resLevels[r].precinctHeight = 15;
913         }
914       }
915       for (i = 0; i < img.nXTiles * img.nYTiles; ++i) {
916         for (comp = 0; comp < img.nComps; ++comp) {
917           if (!(i == 0 && comp == 0)) {
918             for (r = 0; r <= img.tiles[i].tileComps[comp].nDecompLevels; ++r) {
919               img.tiles[i].tileComps[comp].resLevels[r].precinctWidth =
920                   img.tiles[0].tileComps[0].resLevels[r].precinctWidth;
921               img.tiles[i].tileComps[comp].resLevels[r].precinctHeight =
922                   img.tiles[0].tileComps[0].resLevels[r].precinctHeight;
923             }
924           }
925         }
926       }
927       haveCOD = gTrue;
928       break;
929     case 0x53:                  // COC - coding style component
930       if (!haveCOD) {
931         error(getPos(), "JPX COC marker segment before COD segment");
932         return gFalse;
933       }
934       if ((img.nComps > 256 && !readUWord(&comp)) ||
935           (img.nComps <= 256 && !readUByte(&comp)) ||
936           comp >= img.nComps ||
937           !readUByte(&style) ||
938           !readUByte(&img.tiles[0].tileComps[comp].nDecompLevels) ||
939           !readUByte(&img.tiles[0].tileComps[comp].codeBlockW) ||
940           !readUByte(&img.tiles[0].tileComps[comp].codeBlockH) ||
941           !readUByte(&img.tiles[0].tileComps[comp].codeBlockStyle) ||
942           !readUByte(&img.tiles[0].tileComps[comp].transform)) {
943         error(getPos(), "Error in JPX COC marker segment");
944         return gFalse;
945       }
946       img.tiles[0].tileComps[comp].style =
947           (img.tiles[0].tileComps[comp].style & ~1) | (style & 1);
948       img.tiles[0].tileComps[comp].codeBlockW += 2;
949       img.tiles[0].tileComps[comp].codeBlockH += 2;
950       for (i = 0; i < img.nXTiles * img.nYTiles; ++i) {
951         if (i != 0) {
952           img.tiles[i].tileComps[comp].style =
953               img.tiles[0].tileComps[comp].style;
954           img.tiles[i].tileComps[comp].nDecompLevels =
955               img.tiles[0].tileComps[comp].nDecompLevels;
956           img.tiles[i].tileComps[comp].codeBlockW =
957               img.tiles[0].tileComps[comp].codeBlockW;
958           img.tiles[i].tileComps[comp].codeBlockH =
959               img.tiles[0].tileComps[comp].codeBlockH;
960           img.tiles[i].tileComps[comp].codeBlockStyle =
961               img.tiles[0].tileComps[comp].codeBlockStyle;
962           img.tiles[i].tileComps[comp].transform =
963               img.tiles[0].tileComps[comp].transform;
964         }
965         img.tiles[i].tileComps[comp].resLevels =
966             (JPXResLevel *)greallocn(
967                      img.tiles[i].tileComps[comp].resLevels,
968                      (img.tiles[i].tileComps[comp].nDecompLevels + 1),
969                      sizeof(JPXResLevel));
970         for (r = 0; r <= img.tiles[i].tileComps[comp].nDecompLevels; ++r) {
971           img.tiles[i].tileComps[comp].resLevels[r].precincts = NULL;
972         }
973       }
974       for (r = 0; r <= img.tiles[0].tileComps[comp].nDecompLevels; ++r) {
975         if (img.tiles[0].tileComps[comp].style & 0x01) {
976           if (!readUByte(&precinctSize)) {
977             error(getPos(), "Error in JPX COD marker segment");
978             return gFalse;
979           }
980           img.tiles[0].tileComps[comp].resLevels[r].precinctWidth =
981               precinctSize & 0x0f;
982           img.tiles[0].tileComps[comp].resLevels[r].precinctHeight =
983               (precinctSize >> 4) & 0x0f;
984         } else {
985           img.tiles[0].tileComps[comp].resLevels[r].precinctWidth = 15;
986           img.tiles[0].tileComps[comp].resLevels[r].precinctHeight = 15;
987         }
988       }
989       for (i = 1; i < img.nXTiles * img.nYTiles; ++i) {
990         for (r = 0; r <= img.tiles[i].tileComps[comp].nDecompLevels; ++r) {
991           img.tiles[i].tileComps[comp].resLevels[r].precinctWidth =
992               img.tiles[0].tileComps[comp].resLevels[r].precinctWidth;
993           img.tiles[i].tileComps[comp].resLevels[r].precinctHeight =
994               img.tiles[0].tileComps[comp].resLevels[r].precinctHeight;
995         }
996       }
997       break;
998     case 0x5c:                  // QCD - quantization default
999       if (!readUByte(&img.tiles[0].tileComps[0].quantStyle)) {
1000         error(getPos(), "Error in JPX QCD marker segment");
1001         return gFalse;
1002       }
1003       if ((img.tiles[0].tileComps[0].quantStyle & 0x1f) == 0x00) {
1004         img.tiles[0].tileComps[0].nQuantSteps = segLen - 3;
1005         img.tiles[0].tileComps[0].quantSteps =
1006             (Guint *)greallocn(img.tiles[0].tileComps[0].quantSteps,
1007                                img.tiles[0].tileComps[0].nQuantSteps,
1008                                sizeof(Guint));
1009         for (i = 0; i < img.tiles[0].tileComps[0].nQuantSteps; ++i) {
1010           if (!readUByte(&img.tiles[0].tileComps[0].quantSteps[i])) {
1011             error(getPos(), "Error in JPX QCD marker segment");
1012             return gFalse;
1013           }
1014         }
1015       } else if ((img.tiles[0].tileComps[0].quantStyle & 0x1f) == 0x01) {
1016         img.tiles[0].tileComps[0].nQuantSteps = 1;
1017         img.tiles[0].tileComps[0].quantSteps =
1018             (Guint *)greallocn(img.tiles[0].tileComps[0].quantSteps,
1019                                img.tiles[0].tileComps[0].nQuantSteps,
1020                                sizeof(Guint));
1021         if (!readUWord(&img.tiles[0].tileComps[0].quantSteps[0])) {
1022           error(getPos(), "Error in JPX QCD marker segment");
1023           return gFalse;
1024         }
1025       } else if ((img.tiles[0].tileComps[0].quantStyle & 0x1f) == 0x02) {
1026         img.tiles[0].tileComps[0].nQuantSteps = (segLen - 3) / 2;
1027         img.tiles[0].tileComps[0].quantSteps =
1028             (Guint *)greallocn(img.tiles[0].tileComps[0].quantSteps,
1029                                img.tiles[0].tileComps[0].nQuantSteps,
1030                                sizeof(Guint));
1031         for (i = 0; i < img.tiles[0].tileComps[0].nQuantSteps; ++i) {
1032           if (!readUWord(&img.tiles[0].tileComps[0].quantSteps[i])) {
1033             error(getPos(), "Error in JPX QCD marker segment");
1034             return gFalse;
1035           }
1036         }
1037       } else {
1038         error(getPos(), "Error in JPX QCD marker segment");
1039         return gFalse;
1040       }
1041       for (i = 0; i < img.nXTiles * img.nYTiles; ++i) {
1042         for (comp = 0; comp < img.nComps; ++comp) {
1043           if (!(i == 0 && comp == 0)) {
1044             img.tiles[i].tileComps[comp].quantStyle =
1045                 img.tiles[0].tileComps[0].quantStyle;
1046             img.tiles[i].tileComps[comp].nQuantSteps =
1047                 img.tiles[0].tileComps[0].nQuantSteps;
1048             img.tiles[i].tileComps[comp].quantSteps = 
1049                 (Guint *)greallocn(img.tiles[i].tileComps[comp].quantSteps,
1050                                    img.tiles[0].tileComps[0].nQuantSteps,
1051                                    sizeof(Guint));
1052             for (j = 0; j < img.tiles[0].tileComps[0].nQuantSteps; ++j) {
1053               img.tiles[i].tileComps[comp].quantSteps[j] =
1054                   img.tiles[0].tileComps[0].quantSteps[j];
1055             }
1056           }
1057         }
1058       }
1059       haveQCD = gTrue;
1060       break;
1061     case 0x5d:                  // QCC - quantization component
1062       if (!haveQCD) {
1063         error(getPos(), "JPX QCC marker segment before QCD segment");
1064         return gFalse;
1065       }
1066       if ((img.nComps > 256 && !readUWord(&comp)) ||
1067           (img.nComps <= 256 && !readUByte(&comp)) ||
1068           comp >= img.nComps ||
1069           !readUByte(&img.tiles[0].tileComps[comp].quantStyle)) {
1070         error(getPos(), "Error in JPX QCC marker segment");
1071         return gFalse;
1072       }
1073       if ((img.tiles[0].tileComps[comp].quantStyle & 0x1f) == 0x00) {
1074         img.tiles[0].tileComps[comp].nQuantSteps =
1075             segLen - (img.nComps > 256 ? 5 : 4);
1076         img.tiles[0].tileComps[comp].quantSteps =
1077             (Guint *)greallocn(img.tiles[0].tileComps[comp].quantSteps,
1078                                img.tiles[0].tileComps[comp].nQuantSteps,
1079                                sizeof(Guint));
1080         for (i = 0; i < img.tiles[0].tileComps[comp].nQuantSteps; ++i) {
1081           if (!readUByte(&img.tiles[0].tileComps[comp].quantSteps[i])) {
1082             error(getPos(), "Error in JPX QCC marker segment");
1083             return gFalse;
1084           }
1085         }
1086       } else if ((img.tiles[0].tileComps[comp].quantStyle & 0x1f) == 0x01) {
1087         img.tiles[0].tileComps[comp].nQuantSteps = 1;
1088         img.tiles[0].tileComps[comp].quantSteps =
1089             (Guint *)greallocn(img.tiles[0].tileComps[comp].quantSteps,
1090                                img.tiles[0].tileComps[comp].nQuantSteps,
1091                                sizeof(Guint));
1092         if (!readUWord(&img.tiles[0].tileComps[comp].quantSteps[0])) {
1093           error(getPos(), "Error in JPX QCC marker segment");
1094           return gFalse;
1095         }
1096       } else if ((img.tiles[0].tileComps[comp].quantStyle & 0x1f) == 0x02) {
1097         img.tiles[0].tileComps[comp].nQuantSteps =
1098             (segLen - (img.nComps > 256 ? 5 : 4)) / 2;
1099         img.tiles[0].tileComps[comp].quantSteps =
1100             (Guint *)greallocn(img.tiles[0].tileComps[comp].quantSteps,
1101                                img.tiles[0].tileComps[comp].nQuantSteps,
1102                                sizeof(Guint));
1103         for (i = 0; i < img.tiles[0].tileComps[comp].nQuantSteps; ++i) {
1104           if (!readUWord(&img.tiles[0].tileComps[comp].quantSteps[i])) {
1105             error(getPos(), "Error in JPX QCD marker segment");
1106             return gFalse;
1107           }
1108         }
1109       } else {
1110         error(getPos(), "Error in JPX QCC marker segment");
1111         return gFalse;
1112       }
1113       for (i = 1; i < img.nXTiles * img.nYTiles; ++i) {
1114         img.tiles[i].tileComps[comp].quantStyle =
1115             img.tiles[0].tileComps[comp].quantStyle;
1116         img.tiles[i].tileComps[comp].nQuantSteps =
1117             img.tiles[0].tileComps[comp].nQuantSteps;
1118         img.tiles[i].tileComps[comp].quantSteps = 
1119             (Guint *)greallocn(img.tiles[i].tileComps[comp].quantSteps,
1120                                img.tiles[0].tileComps[comp].nQuantSteps,
1121                                sizeof(Guint));
1122         for (j = 0; j < img.tiles[0].tileComps[comp].nQuantSteps; ++j) {
1123           img.tiles[i].tileComps[comp].quantSteps[j] =
1124               img.tiles[0].tileComps[comp].quantSteps[j];
1125         }
1126       }
1127       break;
1128     case 0x5e:                  // RGN - region of interest
1129 #if 1 //~ ROI is unimplemented
1130       fprintf(stderr, "RGN\n");
1131       for (i = 0; i < segLen - 2; ++i) {
1132         if (str->getChar() == EOF) {
1133           error(getPos(), "Error in JPX PPM marker segment");
1134           return gFalse;
1135         }
1136       }
1137 #else
1138       if ((img.nComps > 256 && !readUWord(&comp)) ||
1139           (img.nComps <= 256 && !readUByte(&comp)) ||
1140           comp >= img.nComps ||
1141           !readUByte(&compInfo[comp].defROI.style) ||
1142           !readUByte(&compInfo[comp].defROI.shift)) {
1143         error(getPos(), "Error in JPX RGN marker segment");
1144         return gFalse;
1145       }
1146 #endif
1147       break;
1148     case 0x5f:                  // POC - progression order change
1149 #if 1 //~ progression order changes are unimplemented
1150       fprintf(stderr, "POC\n");
1151       for (i = 0; i < segLen - 2; ++i) {
1152         if (str->getChar() == EOF) {
1153           error(getPos(), "Error in JPX PPM marker segment");
1154           return gFalse;
1155         }
1156       }
1157 #else
1158       nProgs = (segLen - 2) / (img.nComps > 256 ? 9 : 7);
1159       progs = (JPXProgOrder *)gmallocn(nProgs, sizeof(JPXProgOrder));
1160       for (i = 0; i < nProgs; ++i) {
1161         if (!readUByte(&progs[i].startRes) ||
1162             !(img.nComps > 256 && readUWord(&progs[i].startComp)) ||
1163             !(img.nComps <= 256 && readUByte(&progs[i].startComp)) ||
1164             !readUWord(&progs[i].endLayer) ||
1165             !readUByte(&progs[i].endRes) ||
1166             !(img.nComps > 256 && readUWord(&progs[i].endComp)) ||
1167             !(img.nComps <= 256 && readUByte(&progs[i].endComp)) ||
1168             !readUByte(&progs[i].progOrder)) {
1169           error(getPos(), "Error in JPX POC marker segment");
1170           return gFalse;
1171         }
1172       }
1173 #endif
1174       break;
1175     case 0x60:                  // PPM - packed packet headers, main header
1176 #if 1 //~ packed packet headers are unimplemented
1177       fprintf(stderr, "PPM\n");
1178       for (i = 0; i < segLen - 2; ++i) {
1179         if (str->getChar() == EOF) {
1180           error(getPos(), "Error in JPX PPM marker segment");
1181           return gFalse;
1182         }
1183       }
1184 #endif
1185       break;
1186     case 0x55:                  // TLM - tile-part lengths
1187       // skipped
1188       for (i = 0; i < segLen - 2; ++i) {
1189         if (str->getChar() == EOF) {
1190           error(getPos(), "Error in JPX TLM marker segment");
1191           return gFalse;
1192         }
1193       }
1194       break;
1195     case 0x57:                  // PLM - packet length, main header
1196       // skipped
1197       for (i = 0; i < segLen - 2; ++i) {
1198         if (str->getChar() == EOF) {
1199           error(getPos(), "Error in JPX PLM marker segment");
1200           return gFalse;
1201         }
1202       }
1203       break;
1204     case 0x63:                  // CRG - component registration
1205       // skipped
1206       for (i = 0; i < segLen - 2; ++i) {
1207         if (str->getChar() == EOF) {
1208           error(getPos(), "Error in JPX CRG marker segment");
1209           return gFalse;
1210         }
1211       }
1212       break;
1213     case 0x64:                  // COM - comment
1214       // skipped
1215       for (i = 0; i < segLen - 2; ++i) {
1216         if (str->getChar() == EOF) {
1217           error(getPos(), "Error in JPX COM marker segment");
1218           return gFalse;
1219         }
1220       }
1221       break;
1222     case 0x90:                  // SOT - start of tile
1223       haveSOT = gTrue;
1224       break;
1225     default:
1226       error(getPos(), "Unknown marker segment %02x in JPX stream", segType);
1227       for (i = 0; i < segLen - 2; ++i) {
1228         if (str->getChar() == EOF) {
1229           break;
1230         }
1231       }
1232       break;
1233     }
1234   } while (!haveSOT);
1235
1236   if (!haveSIZ) {
1237     error(getPos(), "Missing SIZ marker segment in JPX stream");
1238     return gFalse;
1239   }
1240   if (!haveCOD) {
1241     error(getPos(), "Missing COD marker segment in JPX stream");
1242     return gFalse;
1243   }
1244   if (!haveQCD) {
1245     error(getPos(), "Missing QCD marker segment in JPX stream");
1246     return gFalse;
1247   }
1248
1249   //----- read the tile-parts
1250   while (1) {
1251     if (!readTilePart()) {
1252       return gFalse;
1253     }
1254     if (!readMarkerHdr(&segType, &segLen)) {
1255       error(getPos(), "Error in JPX codestream");
1256       return gFalse;
1257     }
1258     if (segType != 0x90) {      // SOT - start of tile
1259       break;
1260     }
1261   }
1262
1263   if (segType != 0xd9) {        // EOC - end of codestream
1264     error(getPos(), "Missing EOC marker in JPX codestream");
1265     return gFalse;
1266   }
1267
1268   //----- finish decoding the image
1269   for (i = 0; i < img.nXTiles * img.nYTiles; ++i) {
1270     tile = &img.tiles[i];
1271     for (comp = 0; comp < img.nComps; ++comp) {
1272       tileComp = &tile->tileComps[comp];
1273       inverseTransform(tileComp);
1274     }
1275     if (!inverseMultiCompAndDC(tile)) {
1276       return gFalse;
1277     }
1278   }
1279
1280   //~ can free memory below tileComps here, and also tileComp.buf
1281
1282   return gTrue;
1283 }
1284
1285 GBool JPXStream::readTilePart() {
1286   JPXTile *tile;
1287   JPXTileComp *tileComp;
1288   JPXResLevel *resLevel;
1289   JPXPrecinct *precinct;
1290   JPXSubband *subband;
1291   JPXCodeBlock *cb;
1292   GBool haveSOD;
1293   Guint tileIdx, tilePartLen, tilePartIdx, nTileParts;
1294   GBool tilePartToEOC;
1295   Guint precinctSize, style;
1296   Guint n, nSBs, nx, ny, sbx0, sby0, comp, segLen;
1297   Guint i, j, k, cbX, cbY, r, pre, sb, cbi;
1298   int segType, level;
1299
1300   // process the SOT marker segment
1301   if (!readUWord(&tileIdx) ||
1302       !readULong(&tilePartLen) ||
1303       !readUByte(&tilePartIdx) ||
1304       !readUByte(&nTileParts)) {
1305     error(getPos(), "Error in JPX SOT marker segment");
1306     return gFalse;
1307   }
1308
1309   if (tileIdx >= img.nXTiles * img.nYTiles) {
1310     error(getPos(), "Weird tile index in JPX stream");
1311     return gFalse;
1312   }
1313
1314   tilePartToEOC = tilePartLen == 0;
1315   tilePartLen -= 12; // subtract size of SOT segment
1316
1317   haveSOD = gFalse;
1318   do {
1319     if (!readMarkerHdr(&segType, &segLen)) {
1320       error(getPos(), "Error in JPX tile-part codestream");
1321       return gFalse;
1322     }
1323     tilePartLen -= 2 + segLen;
1324     switch (segType) {
1325     case 0x52:                  // COD - coding style default
1326       if (!readUByte(&img.tiles[tileIdx].tileComps[0].style) ||
1327           !readUByte(&img.tiles[tileIdx].progOrder) ||
1328           !readUWord(&img.tiles[tileIdx].nLayers) ||
1329           !readUByte(&img.tiles[tileIdx].multiComp) ||
1330           !readUByte(&img.tiles[tileIdx].tileComps[0].nDecompLevels) ||
1331           !readUByte(&img.tiles[tileIdx].tileComps[0].codeBlockW) ||
1332           !readUByte(&img.tiles[tileIdx].tileComps[0].codeBlockH) ||
1333           !readUByte(&img.tiles[tileIdx].tileComps[0].codeBlockStyle) ||
1334           !readUByte(&img.tiles[tileIdx].tileComps[0].transform)) {
1335         error(getPos(), "Error in JPX COD marker segment");
1336         return gFalse;
1337       }
1338       img.tiles[tileIdx].tileComps[0].codeBlockW += 2;
1339       img.tiles[tileIdx].tileComps[0].codeBlockH += 2;
1340       for (comp = 0; comp < img.nComps; ++comp) {
1341         if (comp != 0) {
1342           img.tiles[tileIdx].tileComps[comp].style =
1343               img.tiles[tileIdx].tileComps[0].style;
1344           img.tiles[tileIdx].tileComps[comp].nDecompLevels =
1345               img.tiles[tileIdx].tileComps[0].nDecompLevels;
1346           img.tiles[tileIdx].tileComps[comp].codeBlockW =
1347               img.tiles[tileIdx].tileComps[0].codeBlockW;
1348           img.tiles[tileIdx].tileComps[comp].codeBlockH =
1349               img.tiles[tileIdx].tileComps[0].codeBlockH;
1350           img.tiles[tileIdx].tileComps[comp].codeBlockStyle =
1351               img.tiles[tileIdx].tileComps[0].codeBlockStyle;
1352           img.tiles[tileIdx].tileComps[comp].transform =
1353               img.tiles[tileIdx].tileComps[0].transform;
1354         }
1355         img.tiles[tileIdx].tileComps[comp].resLevels =
1356             (JPXResLevel *)greallocn(
1357                      img.tiles[tileIdx].tileComps[comp].resLevels,
1358                      (img.tiles[tileIdx].tileComps[comp].nDecompLevels + 1),
1359                      sizeof(JPXResLevel));
1360         for (r = 0;
1361              r <= img.tiles[tileIdx].tileComps[comp].nDecompLevels;
1362              ++r) {
1363           img.tiles[tileIdx].tileComps[comp].resLevels[r].precincts = NULL;
1364         }
1365       }
1366       for (r = 0; r <= img.tiles[tileIdx].tileComps[0].nDecompLevels; ++r) {
1367         if (img.tiles[tileIdx].tileComps[0].style & 0x01) {
1368           if (!readUByte(&precinctSize)) {
1369             error(getPos(), "Error in JPX COD marker segment");
1370             return gFalse;
1371           }
1372           img.tiles[tileIdx].tileComps[0].resLevels[r].precinctWidth =
1373               precinctSize & 0x0f;
1374           img.tiles[tileIdx].tileComps[0].resLevels[r].precinctHeight =
1375               (precinctSize >> 4) & 0x0f;
1376         } else {
1377           img.tiles[tileIdx].tileComps[0].resLevels[r].precinctWidth = 15;
1378           img.tiles[tileIdx].tileComps[0].resLevels[r].precinctHeight = 15;
1379         }
1380       }
1381       for (comp = 1; comp < img.nComps; ++comp) {
1382         for (r = 0;
1383              r <= img.tiles[tileIdx].tileComps[comp].nDecompLevels;
1384              ++r) {
1385           img.tiles[tileIdx].tileComps[comp].resLevels[r].precinctWidth =
1386               img.tiles[tileIdx].tileComps[0].resLevels[r].precinctWidth;
1387           img.tiles[tileIdx].tileComps[comp].resLevels[r].precinctHeight =
1388               img.tiles[tileIdx].tileComps[0].resLevels[r].precinctHeight;
1389         }
1390       }
1391       break;
1392     case 0x53:                  // COC - coding style component
1393       if ((img.nComps > 256 && !readUWord(&comp)) ||
1394           (img.nComps <= 256 && !readUByte(&comp)) ||
1395           comp >= img.nComps ||
1396           !readUByte(&style) ||
1397           !readUByte(&img.tiles[tileIdx].tileComps[comp].nDecompLevels) ||
1398           !readUByte(&img.tiles[tileIdx].tileComps[comp].codeBlockW) ||
1399           !readUByte(&img.tiles[tileIdx].tileComps[comp].codeBlockH) ||
1400           !readUByte(&img.tiles[tileIdx].tileComps[comp].codeBlockStyle) ||
1401           !readUByte(&img.tiles[tileIdx].tileComps[comp].transform)) {
1402         error(getPos(), "Error in JPX COC marker segment");
1403         return gFalse;
1404       }
1405       img.tiles[tileIdx].tileComps[comp].style =
1406           (img.tiles[tileIdx].tileComps[comp].style & ~1) | (style & 1);
1407       img.tiles[tileIdx].tileComps[comp].codeBlockW += 2;
1408       img.tiles[tileIdx].tileComps[comp].codeBlockH += 2;
1409       img.tiles[tileIdx].tileComps[comp].resLevels =
1410           (JPXResLevel *)greallocn(
1411                      img.tiles[tileIdx].tileComps[comp].resLevels,
1412                      (img.tiles[tileIdx].tileComps[comp].nDecompLevels + 1),
1413                      sizeof(JPXResLevel));
1414       for (r = 0; r <= img.tiles[tileIdx].tileComps[comp].nDecompLevels; ++r) {
1415         img.tiles[tileIdx].tileComps[comp].resLevels[r].precincts = NULL;
1416       }
1417       for (r = 0; r <= img.tiles[tileIdx].tileComps[comp].nDecompLevels; ++r) {
1418         if (img.tiles[tileIdx].tileComps[comp].style & 0x01) {
1419           if (!readUByte(&precinctSize)) {
1420             error(getPos(), "Error in JPX COD marker segment");
1421             return gFalse;
1422           }
1423           img.tiles[tileIdx].tileComps[comp].resLevels[r].precinctWidth =
1424               precinctSize & 0x0f;
1425           img.tiles[tileIdx].tileComps[comp].resLevels[r].precinctHeight =
1426               (precinctSize >> 4) & 0x0f;
1427         } else {
1428           img.tiles[tileIdx].tileComps[comp].resLevels[r].precinctWidth = 15;
1429           img.tiles[tileIdx].tileComps[comp].resLevels[r].precinctHeight = 15;
1430         }
1431       }
1432       break;
1433     case 0x5c:                  // QCD - quantization default
1434       if (!readUByte(&img.tiles[tileIdx].tileComps[0].quantStyle)) {
1435         error(getPos(), "Error in JPX QCD marker segment");
1436         return gFalse;
1437       }
1438       if ((img.tiles[tileIdx].tileComps[0].quantStyle & 0x1f) == 0x00) {
1439         img.tiles[tileIdx].tileComps[0].nQuantSteps =
1440             segLen - 3;
1441         img.tiles[tileIdx].tileComps[0].quantSteps =
1442             (Guint *)greallocn(img.tiles[tileIdx].tileComps[0].quantSteps,
1443                                img.tiles[tileIdx].tileComps[0].nQuantSteps,
1444                                sizeof(Guint));
1445         for (i = 0; i < img.tiles[tileIdx].tileComps[0].nQuantSteps; ++i) {
1446           if (!readUByte(&img.tiles[tileIdx].tileComps[0].quantSteps[i])) {
1447             error(getPos(), "Error in JPX QCD marker segment");
1448             return gFalse;
1449           }
1450         }
1451       } else if ((img.tiles[tileIdx].tileComps[0].quantStyle & 0x1f) == 0x01) {
1452         img.tiles[tileIdx].tileComps[0].nQuantSteps = 1;
1453         img.tiles[tileIdx].tileComps[0].quantSteps =
1454             (Guint *)greallocn(img.tiles[tileIdx].tileComps[0].quantSteps,
1455                                img.tiles[tileIdx].tileComps[0].nQuantSteps,
1456                                sizeof(Guint));
1457         if (!readUWord(&img.tiles[tileIdx].tileComps[0].quantSteps[0])) {
1458           error(getPos(), "Error in JPX QCD marker segment");
1459           return gFalse;
1460         }
1461       } else if ((img.tiles[tileIdx].tileComps[0].quantStyle & 0x1f) == 0x02) {
1462         img.tiles[tileIdx].tileComps[0].nQuantSteps = (segLen - 3) / 2;
1463         img.tiles[tileIdx].tileComps[0].quantSteps =
1464             (Guint *)greallocn(img.tiles[tileIdx].tileComps[0].quantSteps,
1465                                img.tiles[tileIdx].tileComps[0].nQuantSteps,
1466                                sizeof(Guint));
1467         for (i = 0; i < img.tiles[tileIdx].tileComps[0].nQuantSteps; ++i) {
1468           if (!readUWord(&img.tiles[tileIdx].tileComps[0].quantSteps[i])) {
1469             error(getPos(), "Error in JPX QCD marker segment");
1470             return gFalse;
1471           }
1472         }
1473       } else {
1474         error(getPos(), "Error in JPX QCD marker segment");
1475         return gFalse;
1476       }
1477       for (comp = 1; comp < img.nComps; ++comp) {
1478         img.tiles[tileIdx].tileComps[comp].quantStyle =
1479             img.tiles[tileIdx].tileComps[0].quantStyle;
1480         img.tiles[tileIdx].tileComps[comp].nQuantSteps =
1481             img.tiles[tileIdx].tileComps[0].nQuantSteps;
1482         img.tiles[tileIdx].tileComps[comp].quantSteps = 
1483             (Guint *)greallocn(img.tiles[tileIdx].tileComps[comp].quantSteps,
1484                                img.tiles[tileIdx].tileComps[0].nQuantSteps,
1485                                sizeof(Guint));
1486         for (j = 0; j < img.tiles[tileIdx].tileComps[0].nQuantSteps; ++j) {
1487           img.tiles[tileIdx].tileComps[comp].quantSteps[j] =
1488               img.tiles[tileIdx].tileComps[0].quantSteps[j];
1489         }
1490       }
1491       break;
1492     case 0x5d:                  // QCC - quantization component
1493       if ((img.nComps > 256 && !readUWord(&comp)) ||
1494           (img.nComps <= 256 && !readUByte(&comp)) ||
1495           comp >= img.nComps ||
1496           !readUByte(&img.tiles[tileIdx].tileComps[comp].quantStyle)) {
1497         error(getPos(), "Error in JPX QCC marker segment");
1498         return gFalse;
1499       }
1500       if ((img.tiles[tileIdx].tileComps[comp].quantStyle & 0x1f) == 0x00) {
1501         img.tiles[tileIdx].tileComps[comp].nQuantSteps =
1502             segLen - (img.nComps > 256 ? 5 : 4);
1503         img.tiles[tileIdx].tileComps[comp].quantSteps =
1504             (Guint *)greallocn(img.tiles[tileIdx].tileComps[comp].quantSteps,
1505                                img.tiles[tileIdx].tileComps[comp].nQuantSteps,
1506                                sizeof(Guint));
1507         for (i = 0; i < img.tiles[tileIdx].tileComps[comp].nQuantSteps; ++i) {
1508           if (!readUByte(&img.tiles[tileIdx].tileComps[comp].quantSteps[i])) {
1509             error(getPos(), "Error in JPX QCC marker segment");
1510             return gFalse;
1511           }
1512         }
1513       } else if ((img.tiles[tileIdx].tileComps[comp].quantStyle & 0x1f)
1514                  == 0x01) {
1515         img.tiles[tileIdx].tileComps[comp].nQuantSteps = 1;
1516         img.tiles[tileIdx].tileComps[comp].quantSteps =
1517             (Guint *)greallocn(img.tiles[tileIdx].tileComps[comp].quantSteps,
1518                                img.tiles[tileIdx].tileComps[comp].nQuantSteps,
1519                                sizeof(Guint));
1520         if (!readUWord(&img.tiles[tileIdx].tileComps[comp].quantSteps[0])) {
1521           error(getPos(), "Error in JPX QCC marker segment");
1522           return gFalse;
1523         }
1524       } else if ((img.tiles[tileIdx].tileComps[comp].quantStyle & 0x1f)
1525                  == 0x02) {
1526         img.tiles[tileIdx].tileComps[comp].nQuantSteps =
1527             (segLen - (img.nComps > 256 ? 5 : 4)) / 2;
1528         img.tiles[tileIdx].tileComps[comp].quantSteps =
1529             (Guint *)greallocn(img.tiles[tileIdx].tileComps[comp].quantSteps,
1530                                img.tiles[tileIdx].tileComps[comp].nQuantSteps,
1531                                sizeof(Guint));
1532         for (i = 0; i < img.tiles[tileIdx].tileComps[comp].nQuantSteps; ++i) {
1533           if (!readUWord(&img.tiles[tileIdx].tileComps[comp].quantSteps[i])) {
1534             error(getPos(), "Error in JPX QCD marker segment");
1535             return gFalse;
1536           }
1537         }
1538       } else {
1539         error(getPos(), "Error in JPX QCC marker segment");
1540         return gFalse;
1541       }
1542       break;
1543     case 0x5e:                  // RGN - region of interest
1544 #if 1 //~ ROI is unimplemented
1545       fprintf(stderr, "RGN\n");
1546       for (i = 0; i < segLen - 2; ++i) {
1547         if (str->getChar() == EOF) {
1548           error(getPos(), "Error in JPX PPM marker segment");
1549           return gFalse;
1550         }
1551       }
1552 #else
1553       if ((img.nComps > 256 && !readUWord(&comp)) ||
1554           (img.nComps <= 256 && !readUByte(&comp)) ||
1555           comp >= img.nComps ||
1556           !readUByte(&compInfo[comp].roi.style) ||
1557           !readUByte(&compInfo[comp].roi.shift)) {
1558         error(getPos(), "Error in JPX RGN marker segment");
1559         return gFalse;
1560       }
1561 #endif
1562       break;
1563     case 0x5f:                  // POC - progression order change
1564 #if 1 //~ progression order changes are unimplemented
1565       fprintf(stderr, "POC\n");
1566       for (i = 0; i < segLen - 2; ++i) {
1567         if (str->getChar() == EOF) {
1568           error(getPos(), "Error in JPX PPM marker segment");
1569           return gFalse;
1570         }
1571       }
1572 #else
1573       nTileProgs = (segLen - 2) / (img.nComps > 256 ? 9 : 7);
1574       tileProgs = (JPXProgOrder *)gmallocn(nTileProgs, sizeof(JPXProgOrder));
1575       for (i = 0; i < nTileProgs; ++i) {
1576         if (!readUByte(&tileProgs[i].startRes) ||
1577             !(img.nComps > 256 && readUWord(&tileProgs[i].startComp)) ||
1578             !(img.nComps <= 256 && readUByte(&tileProgs[i].startComp)) ||
1579             !readUWord(&tileProgs[i].endLayer) ||
1580             !readUByte(&tileProgs[i].endRes) ||
1581             !(img.nComps > 256 && readUWord(&tileProgs[i].endComp)) ||
1582             !(img.nComps <= 256 && readUByte(&tileProgs[i].endComp)) ||
1583             !readUByte(&tileProgs[i].progOrder)) {
1584           error(getPos(), "Error in JPX POC marker segment");
1585           return gFalse;
1586         }
1587       }
1588 #endif
1589       break;
1590     case 0x61:                  // PPT - packed packet headers, tile-part hdr
1591 #if 1 //~ packed packet headers are unimplemented
1592       fprintf(stderr, "PPT\n");
1593       for (i = 0; i < segLen - 2; ++i) {
1594         if (str->getChar() == EOF) {
1595           error(getPos(), "Error in JPX PPT marker segment");
1596           return gFalse;
1597         }
1598       }
1599 #endif
1600     case 0x58:                  // PLT - packet length, tile-part header
1601       // skipped
1602       for (i = 0; i < segLen - 2; ++i) {
1603         if (str->getChar() == EOF) {
1604           error(getPos(), "Error in JPX PLT marker segment");
1605           return gFalse;
1606         }
1607       }
1608       break;
1609     case 0x64:                  // COM - comment
1610       // skipped
1611       for (i = 0; i < segLen - 2; ++i) {
1612         if (str->getChar() == EOF) {
1613           error(getPos(), "Error in JPX COM marker segment");
1614           return gFalse;
1615         }
1616       }
1617       break;
1618     case 0x93:                  // SOD - start of data
1619       haveSOD = gTrue;
1620       break;
1621     default:
1622       error(getPos(), "Unknown marker segment %02x in JPX tile-part stream",
1623             segType);
1624       for (i = 0; i < segLen - 2; ++i) {
1625         if (str->getChar() == EOF) {
1626           break;
1627         }
1628       }
1629       break;
1630     }
1631   } while (!haveSOD);
1632
1633   //----- initialize the tile, precincts, and code-blocks
1634   if (tilePartIdx == 0) {
1635     tile = &img.tiles[tileIdx];
1636     i = tileIdx / img.nXTiles;
1637     j = tileIdx % img.nXTiles;
1638     if ((tile->x0 = img.xTileOffset + j * img.xTileSize) < img.xOffset) {
1639       tile->x0 = img.xOffset;
1640     }
1641     if ((tile->y0 = img.yTileOffset + i * img.yTileSize) < img.yOffset) {
1642       tile->y0 = img.yOffset;
1643     }
1644     if ((tile->x1 = img.xTileOffset + (j + 1) * img.xTileSize) > img.xSize) {
1645       tile->x1 = img.xSize;
1646     }
1647     if ((tile->y1 = img.yTileOffset + (i + 1) * img.yTileSize) > img.ySize) {
1648       tile->y1 = img.ySize;
1649     }
1650     tile->comp = 0;
1651     tile->res = 0;
1652     tile->precinct = 0;
1653     tile->layer = 0;
1654     tile->maxNDecompLevels = 0;
1655     for (comp = 0; comp < img.nComps; ++comp) {
1656       tileComp = &tile->tileComps[comp];
1657       if (tileComp->nDecompLevels > tile->maxNDecompLevels) {
1658         tile->maxNDecompLevels = tileComp->nDecompLevels;
1659       }
1660       tileComp->x0 = jpxCeilDiv(tile->x0, tileComp->hSep);
1661       tileComp->y0 = jpxCeilDiv(tile->y0, tileComp->hSep);
1662       tileComp->x1 = jpxCeilDiv(tile->x1, tileComp->hSep);
1663       tileComp->y1 = jpxCeilDiv(tile->y1, tileComp->hSep);
1664       tileComp->cbW = 1 << tileComp->codeBlockW;
1665       tileComp->cbH = 1 << tileComp->codeBlockH;
1666       tileComp->data = (int *)gmallocn((tileComp->x1 - tileComp->x0) *
1667                                        (tileComp->y1 - tileComp->y0),
1668                                        sizeof(int));
1669       if (tileComp->x1 - tileComp->x0 > tileComp->y1 - tileComp->y0) {
1670         n = tileComp->x1 - tileComp->x0;
1671       } else {
1672         n = tileComp->y1 - tileComp->y0;
1673       }
1674       tileComp->buf = (int *)gmallocn(n + 8, sizeof(int));
1675       for (r = 0; r <= tileComp->nDecompLevels; ++r) {
1676         resLevel = &tileComp->resLevels[r];
1677         k = r == 0 ? tileComp->nDecompLevels
1678                    : tileComp->nDecompLevels - r + 1;
1679         resLevel->x0 = jpxCeilDivPow2(tileComp->x0, k);
1680         resLevel->y0 = jpxCeilDivPow2(tileComp->y0, k);
1681         resLevel->x1 = jpxCeilDivPow2(tileComp->x1, k);
1682         resLevel->y1 = jpxCeilDivPow2(tileComp->y1, k);
1683         if (r == 0) {
1684           resLevel->bx0[0] = resLevel->x0;
1685           resLevel->by0[0] = resLevel->y0;
1686           resLevel->bx1[0] = resLevel->x1;
1687           resLevel->by1[0] = resLevel->y1;
1688         } else {
1689           resLevel->bx0[0] = jpxCeilDivPow2(tileComp->x0 - (1 << (k-1)), k);
1690           resLevel->by0[0] = resLevel->y0;
1691           resLevel->bx1[0] = jpxCeilDivPow2(tileComp->x1 - (1 << (k-1)), k);
1692           resLevel->by1[0] = resLevel->y1;
1693           resLevel->bx0[1] = resLevel->x0;
1694           resLevel->by0[1] = jpxCeilDivPow2(tileComp->y0 - (1 << (k-1)), k);
1695           resLevel->bx1[1] = resLevel->x1;
1696           resLevel->by1[1] = jpxCeilDivPow2(tileComp->y1 - (1 << (k-1)), k);
1697           resLevel->bx0[2] = jpxCeilDivPow2(tileComp->x0 - (1 << (k-1)), k);
1698           resLevel->by0[2] = jpxCeilDivPow2(tileComp->y0 - (1 << (k-1)), k);
1699           resLevel->bx1[2] = jpxCeilDivPow2(tileComp->x1 - (1 << (k-1)), k);
1700           resLevel->by1[2] = jpxCeilDivPow2(tileComp->y1 - (1 << (k-1)), k);
1701         }
1702         resLevel->precincts = (JPXPrecinct *)gmallocn(1, sizeof(JPXPrecinct));
1703         for (pre = 0; pre < 1; ++pre) {
1704           precinct = &resLevel->precincts[pre];
1705           precinct->x0 = resLevel->x0;
1706           precinct->y0 = resLevel->y0;
1707           precinct->x1 = resLevel->x1;
1708           precinct->y1 = resLevel->y1;
1709           nSBs = r == 0 ? 1 : 3;
1710           precinct->subbands =
1711               (JPXSubband *)gmallocn(nSBs, sizeof(JPXSubband));
1712           for (sb = 0; sb < nSBs; ++sb) {
1713             subband = &precinct->subbands[sb];
1714             subband->x0 = resLevel->bx0[sb];
1715             subband->y0 = resLevel->by0[sb];
1716             subband->x1 = resLevel->bx1[sb];
1717             subband->y1 = resLevel->by1[sb];
1718             subband->nXCBs = jpxCeilDivPow2(subband->x1,
1719                                             tileComp->codeBlockW)
1720                              - jpxFloorDivPow2(subband->x0,
1721                                                tileComp->codeBlockW);
1722             subband->nYCBs = jpxCeilDivPow2(subband->y1,
1723                                             tileComp->codeBlockH)
1724                              - jpxFloorDivPow2(subband->y0,
1725                                                tileComp->codeBlockH);
1726             n = subband->nXCBs > subband->nYCBs ? subband->nXCBs
1727                                                 : subband->nYCBs;
1728             for (subband->maxTTLevel = 0, --n;
1729                  n;
1730                  ++subband->maxTTLevel, n >>= 1) ;
1731             n = 0;
1732             for (level = subband->maxTTLevel; level >= 0; --level) {
1733               nx = jpxCeilDivPow2(subband->nXCBs, level);
1734               ny = jpxCeilDivPow2(subband->nYCBs, level);
1735               n += nx * ny;
1736             }
1737             subband->inclusion =
1738                 (JPXTagTreeNode *)gmallocn(n, sizeof(JPXTagTreeNode));
1739             subband->zeroBitPlane =
1740                 (JPXTagTreeNode *)gmallocn(n, sizeof(JPXTagTreeNode));
1741             for (k = 0; k < n; ++k) {
1742               subband->inclusion[k].finished = gFalse;
1743               subband->inclusion[k].val = 0;
1744               subband->zeroBitPlane[k].finished = gFalse;
1745               subband->zeroBitPlane[k].val = 0;
1746             }
1747             subband->cbs = (JPXCodeBlock *)gmallocn(subband->nXCBs *
1748                                                       subband->nYCBs,
1749                                                     sizeof(JPXCodeBlock));
1750             sbx0 = jpxFloorDivPow2(subband->x0, tileComp->codeBlockW);
1751             sby0 = jpxFloorDivPow2(subband->y0, tileComp->codeBlockH);
1752             cb = subband->cbs;
1753             for (cbY = 0; cbY < subband->nYCBs; ++cbY) {
1754               for (cbX = 0; cbX < subband->nXCBs; ++cbX) {
1755                 cb->x0 = (sbx0 + cbX) << tileComp->codeBlockW;
1756                 cb->x1 = cb->x0 + tileComp->cbW;
1757                 if (subband->x0 > cb->x0) {
1758                   cb->x0 = subband->x0;
1759                 }
1760                 if (subband->x1 < cb->x1) {
1761                   cb->x1 = subband->x1;
1762                 }
1763                 cb->y0 = (sby0 + cbY) << tileComp->codeBlockH;
1764                 cb->y1 = cb->y0 + tileComp->cbH;
1765                 if (subband->y0 > cb->y0) {
1766                   cb->y0 = subband->y0;
1767                 }
1768                 if (subband->y1 < cb->y1) {
1769                   cb->y1 = subband->y1;
1770                 }
1771                 cb->seen = gFalse;
1772                 cb->lBlock = 3;
1773                 cb->nextPass = jpxPassCleanup;
1774                 cb->nZeroBitPlanes = 0;
1775                 cb->coeffs =
1776                     (JPXCoeff *)gmallocn((1 << (tileComp->codeBlockW
1777                                                 + tileComp->codeBlockH)),
1778                                          sizeof(JPXCoeff));
1779                 for (cbi = 0;
1780                      cbi < (Guint)(1 << (tileComp->codeBlockW
1781                                          + tileComp->codeBlockH));
1782                      ++cbi) {
1783                   cb->coeffs[cbi].flags = 0;
1784                   cb->coeffs[cbi].len = 0;
1785                   cb->coeffs[cbi].mag = 0;
1786                 }
1787                 cb->arithDecoder = NULL;
1788                 cb->stats = NULL;
1789                 ++cb;
1790               }
1791             }
1792           }
1793         }
1794       }
1795     }
1796   }
1797
1798   return readTilePartData(tileIdx, tilePartLen, tilePartToEOC);
1799 }
1800
1801 GBool JPXStream::readTilePartData(Guint tileIdx,
1802                                   Guint tilePartLen, GBool tilePartToEOC) {
1803   JPXTile *tile;
1804   JPXTileComp *tileComp;
1805   JPXResLevel *resLevel;
1806   JPXPrecinct *precinct;
1807   JPXSubband *subband;
1808   JPXCodeBlock *cb;
1809   Guint ttVal;
1810   Guint bits, cbX, cbY, nx, ny, i, j, n, sb;
1811   int level;
1812
1813   tile = &img.tiles[tileIdx];
1814
1815   // read all packets from this tile-part
1816   while (1) {
1817     if (tilePartToEOC) {
1818       //~ peek for an EOC marker
1819     } else if (tilePartLen == 0) {
1820       break;
1821     }
1822
1823     tileComp = &tile->tileComps[tile->comp];
1824     resLevel = &tileComp->resLevels[tile->res];
1825     precinct = &resLevel->precincts[tile->precinct];
1826
1827     //----- packet header
1828
1829     // zero-length flag
1830     if (!readBits(1, &bits)) {
1831       goto err;
1832     }
1833     if (!bits) {
1834       // packet is empty -- clear all code-block inclusion flags
1835       for (sb = 0; sb < (tile->res == 0 ? 1 : 3); ++sb) {
1836         subband = &precinct->subbands[sb];
1837         for (cbY = 0; cbY < subband->nYCBs; ++cbY) {
1838           for (cbX = 0; cbX < subband->nXCBs; ++cbX) {
1839             cb = &subband->cbs[cbY * subband->nXCBs + cbX];
1840             cb->included = gFalse;
1841           }
1842         }
1843       }
1844     } else {
1845
1846       for (sb = 0; sb < (tile->res == 0 ? 1 : 3); ++sb) {
1847         subband = &precinct->subbands[sb];
1848         for (cbY = 0; cbY < subband->nYCBs; ++cbY) {
1849           for (cbX = 0; cbX < subband->nXCBs; ++cbX) {
1850             cb = &subband->cbs[cbY * subband->nXCBs + cbX];
1851
1852             // skip code-blocks with no coefficients
1853             if (cb->x0 >= cb->x1 || cb->y0 >= cb->y1) {
1854               cb->included = gFalse;
1855               continue;
1856             }
1857
1858             // code-block inclusion
1859             if (cb->seen) {
1860               if (!readBits(1, &cb->included)) {
1861                 goto err;
1862               }
1863             } else {
1864               ttVal = 0;
1865               i = 0;
1866               for (level = subband->maxTTLevel; level >= 0; --level) {
1867                 nx = jpxCeilDivPow2(subband->nXCBs, level);
1868                 ny = jpxCeilDivPow2(subband->nYCBs, level);
1869                 j = i + (cbY >> level) * nx + (cbX >> level);
1870                 if (!subband->inclusion[j].finished &&
1871                     !subband->inclusion[j].val) {
1872                   subband->inclusion[j].val = ttVal;
1873                 } else {
1874                   ttVal = subband->inclusion[j].val;
1875                 }
1876                 while (!subband->inclusion[j].finished &&
1877                        ttVal <= tile->layer) {
1878                   if (!readBits(1, &bits)) {
1879                     goto err;
1880                   }
1881                   if (bits == 1) {
1882                     subband->inclusion[j].finished = gTrue;
1883                   } else {
1884                     ++ttVal;
1885                   }
1886                 }
1887                 subband->inclusion[j].val = ttVal;
1888                 if (ttVal > tile->layer) {
1889                   break;
1890                 }
1891                 i += nx * ny;
1892               }
1893               cb->included = level < 0;
1894             }
1895
1896             if (cb->included) {
1897
1898               // zero bit-plane count
1899               if (!cb->seen) {
1900                 ttVal = 0;
1901                 i = 0;
1902                 for (level = subband->maxTTLevel; level >= 0; --level) {
1903                   nx = jpxCeilDivPow2(subband->nXCBs, level);
1904                   ny = jpxCeilDivPow2(subband->nYCBs, level);
1905                   j = i + (cbY >> level) * nx + (cbX >> level);
1906                   if (!subband->zeroBitPlane[j].finished &&
1907                       !subband->zeroBitPlane[j].val) {
1908                     subband->zeroBitPlane[j].val = ttVal;
1909                   } else {
1910                     ttVal = subband->zeroBitPlane[j].val;
1911                   }
1912                   while (!subband->zeroBitPlane[j].finished) {
1913                     if (!readBits(1, &bits)) {
1914                       goto err;
1915                     }
1916                     if (bits == 1) {
1917                       subband->zeroBitPlane[j].finished = gTrue;
1918                     } else {
1919                       ++ttVal;
1920                     }
1921                   }
1922                   subband->zeroBitPlane[j].val = ttVal;
1923                   i += nx * ny;
1924                 }
1925                 cb->nZeroBitPlanes = ttVal;
1926               }
1927
1928               // number of coding passes
1929               if (!readBits(1, &bits)) {
1930                 goto err;
1931               }
1932               if (bits == 0) {
1933                 cb->nCodingPasses = 1;
1934               } else {
1935                 if (!readBits(1, &bits)) {
1936                   goto err;
1937                 }
1938                 if (bits == 0) {
1939                   cb->nCodingPasses = 2;
1940                 } else {
1941                   if (!readBits(2, &bits)) {
1942                     goto err;
1943                   }
1944                   if (bits < 3) {
1945                     cb->nCodingPasses = 3 + bits;
1946                   } else {
1947                     if (!readBits(5, &bits)) {
1948                       goto err;
1949                     }
1950                     if (bits < 31) {
1951                       cb->nCodingPasses = 6 + bits;
1952                     } else {
1953                       if (!readBits(7, &bits)) {
1954                         goto err;
1955                       }
1956                       cb->nCodingPasses = 37 + bits;
1957                     }
1958                   }
1959                 }
1960               }
1961
1962               // update Lblock
1963               while (1) {
1964                 if (!readBits(1, &bits)) {
1965                   goto err;
1966                 }
1967                 if (!bits) {
1968                   break;
1969                 }
1970                 ++cb->lBlock;
1971               }
1972
1973               // length of compressed data
1974               //~ deal with multiple codeword segments
1975               for (n = cb->lBlock, i = cb->nCodingPasses >> 1;
1976                    i;
1977                    ++n, i >>= 1) ;
1978               if (!readBits(n, &cb->dataLen)) {
1979                 goto err;
1980               }
1981             }
1982           }
1983         }
1984       }
1985     }
1986     tilePartLen -= byteCount;
1987     clearBitBuf();
1988
1989     //----- packet data
1990
1991     for (sb = 0; sb < (tile->res == 0 ? 1 : 3); ++sb) {
1992       subband = &precinct->subbands[sb];
1993       for (cbY = 0; cbY < subband->nYCBs; ++cbY) {
1994         for (cbX = 0; cbX < subband->nXCBs; ++cbX) {
1995           cb = &subband->cbs[cbY * subband->nXCBs + cbX];
1996           if (cb->included) {
1997             if (!readCodeBlockData(tileComp, resLevel, precinct, subband,
1998                                    tile->res, sb, cb)) {
1999               return gFalse;
2000             }
2001             tilePartLen -= cb->dataLen;
2002             cb->seen = gTrue;
2003           }
2004         }
2005       }
2006     }
2007
2008     //----- next packet
2009
2010     switch (tile->progOrder) {
2011     case 0: // layer, resolution level, component, precinct
2012       if (++tile->comp == img.nComps) {
2013         tile->comp = 0;
2014         if (++tile->res == tile->maxNDecompLevels + 1) {
2015           tile->res = 0;
2016           if (++tile->layer == tile->nLayers) {
2017             tile->layer = 0;
2018           }
2019         }
2020       }
2021       break;
2022     case 1: // resolution level, layer, component, precinct
2023       if (++tile->comp == img.nComps) {
2024         tile->comp = 0;
2025         if (++tile->layer == tile->nLayers) {
2026           tile->layer = 0;
2027           if (++tile->res == tile->maxNDecompLevels + 1) {
2028             tile->res = 0;
2029           }
2030         }
2031       }
2032       break;
2033     case 2: // resolution level, precinct, component, layer
2034       //~ this isn't correct -- see B.12.1.3
2035       if (++tile->layer == tile->nLayers) {
2036         tile->layer = 0;
2037         if (++tile->comp == img.nComps) {
2038           tile->comp = 0;
2039           if (++tile->res == tile->maxNDecompLevels + 1) {
2040             tile->res = 0;
2041           }
2042         }
2043       }
2044       break;
2045     case 3: // precinct, component, resolution level, layer
2046       //~ this isn't correct -- see B.12.1.4
2047       if (++tile->layer == tile->nLayers) {
2048         tile->layer = 0;
2049         if (++tile->res == tile->maxNDecompLevels + 1) {
2050           tile->res = 0;
2051           if (++tile->comp == img.nComps) {
2052             tile->comp = 0;
2053           }
2054         }
2055       }
2056       break;
2057     case 4: // component, precinct, resolution level, layer
2058       //~ this isn't correct -- see B.12.1.5
2059       if (++tile->layer == tile->nLayers) {
2060         tile->layer = 0;
2061         if (++tile->res == tile->maxNDecompLevels + 1) {
2062           tile->res = 0;
2063           if (++tile->comp == img.nComps) {
2064             tile->comp = 0;
2065           }
2066         }
2067       }
2068       break;
2069     }
2070   }
2071
2072   return gTrue;
2073
2074  err:
2075   error(getPos(), "Error in JPX stream");
2076   return gFalse;
2077 }
2078
2079 GBool JPXStream::readCodeBlockData(JPXTileComp *tileComp,
2080                                    JPXResLevel *resLevel,
2081                                    JPXPrecinct *precinct,
2082                                    JPXSubband *subband,
2083                                    Guint res, Guint sb,
2084                                    JPXCodeBlock *cb) {
2085   JPXCoeff *coeff0, *coeff1, *coeff;
2086   Guint horiz, vert, diag, all, cx, xorBit;
2087   int horizSign, vertSign;
2088   Guint i, x, y0, y1, y2;
2089
2090   if (cb->arithDecoder) {
2091     cb->arithDecoder->restart(cb->dataLen);
2092   } else {
2093     cb->arithDecoder = new JArithmeticDecoder();
2094     cb->arithDecoder->setStream(str, cb->dataLen);
2095     cb->arithDecoder->start();
2096     cb->stats = new JArithmeticDecoderStats(jpxNContexts);
2097     cb->stats->setEntry(jpxContextSigProp, 4, 0);
2098     cb->stats->setEntry(jpxContextRunLength, 3, 0);
2099     cb->stats->setEntry(jpxContextUniform, 46, 0);
2100   }
2101
2102   for (i = 0; i < cb->nCodingPasses; ++i) {
2103     switch (cb->nextPass) {
2104
2105     //----- significance propagation pass
2106     case jpxPassSigProp:
2107       for (y0 = cb->y0, coeff0 = cb->coeffs;
2108            y0 < cb->y1;
2109            y0 += 4, coeff0 += 4 << tileComp->codeBlockW) {
2110         for (x = cb->x0, coeff1 = coeff0;
2111              x < cb->x1;
2112              ++x, ++coeff1) {
2113           for (y1 = 0, coeff = coeff1;
2114                y1 < 4 && y0+y1 < cb->y1;
2115                ++y1, coeff += tileComp->cbW) {
2116             if (!(coeff->flags & jpxCoeffSignificant)) {
2117               horiz = vert = diag = 0;
2118               horizSign = vertSign = 2;
2119               if (x > cb->x0) {
2120                 if (coeff[-1].flags & jpxCoeffSignificant) {
2121                   ++horiz;
2122                   horizSign += (coeff[-1].flags & jpxCoeffSign) ? -1 : 1;
2123                 }
2124                 if (y0+y1 > cb->y0) {
2125                   diag += (coeff[-(int)tileComp->cbW - 1].flags
2126                            >> jpxCoeffSignificantB) & 1;
2127                 }
2128                 if (y0+y1 < cb->y1 - 1) {
2129                   diag += (coeff[tileComp->cbW - 1].flags
2130                            >> jpxCoeffSignificantB) & 1;
2131                 }
2132               }
2133               if (x < cb->x1 - 1) {
2134                 if (coeff[1].flags & jpxCoeffSignificant) {
2135                   ++horiz;
2136                   horizSign += (coeff[1].flags & jpxCoeffSign) ? -1 : 1;
2137                 }
2138                 if (y0+y1 > cb->y0) {
2139                   diag += (coeff[-(int)tileComp->cbW + 1].flags
2140                            >> jpxCoeffSignificantB) & 1;
2141                 }
2142                 if (y0+y1 < cb->y1 - 1) {
2143                   diag += (coeff[tileComp->cbW + 1].flags
2144                            >> jpxCoeffSignificantB) & 1;
2145                 }
2146               }
2147               if (y0+y1 > cb->y0) {
2148                 if (coeff[-(int)tileComp->cbW].flags & jpxCoeffSignificant) {
2149                   ++vert;
2150                   vertSign += (coeff[-(int)tileComp->cbW].flags & jpxCoeffSign)
2151                               ? -1 : 1;
2152                 }
2153               }
2154               if (y0+y1 < cb->y1 - 1) {
2155                 if (coeff[tileComp->cbW].flags & jpxCoeffSignificant) {
2156                   ++vert;
2157                   vertSign += (coeff[tileComp->cbW].flags & jpxCoeffSign)
2158                               ? -1 : 1;
2159                 }
2160               }
2161               cx = sigPropContext[horiz][vert][diag][res == 0 ? 1 : sb];
2162               if (cx != 0) {
2163                 if (cb->arithDecoder->decodeBit(cx, cb->stats)) {
2164                   coeff->flags |= jpxCoeffSignificant | jpxCoeffFirstMagRef;
2165                   coeff->mag = (coeff->mag << 1) | 1;
2166                   cx = signContext[horizSign][vertSign][0];
2167                   xorBit = signContext[horizSign][vertSign][1];
2168                   if (cb->arithDecoder->decodeBit(cx, cb->stats) ^ xorBit) {
2169                     coeff->flags |= jpxCoeffSign;
2170                   }
2171                 }
2172                 ++coeff->len;
2173                 coeff->flags |= jpxCoeffTouched;
2174               }
2175             }
2176           }
2177         }
2178       }
2179       ++cb->nextPass;
2180       break;
2181
2182     //----- magnitude refinement pass
2183     case jpxPassMagRef:
2184       for (y0 = cb->y0, coeff0 = cb->coeffs;
2185            y0 < cb->y1;
2186            y0 += 4, coeff0 += 4 << tileComp->codeBlockW) {
2187         for (x = cb->x0, coeff1 = coeff0;
2188              x < cb->x1;
2189              ++x, ++coeff1) {
2190           for (y1 = 0, coeff = coeff1;
2191                y1 < 4 && y0+y1 < cb->y1;
2192                ++y1, coeff += tileComp->cbW) {
2193             if ((coeff->flags & jpxCoeffSignificant) &&
2194                 !(coeff->flags & jpxCoeffTouched)) {
2195               if (coeff->flags & jpxCoeffFirstMagRef) {
2196                 all = 0;
2197                 if (x > cb->x0) {
2198                   all += (coeff[-1].flags >> jpxCoeffSignificantB) & 1;
2199                   if (y0+y1 > cb->y0) {
2200                     all += (coeff[-(int)tileComp->cbW - 1].flags
2201                             >> jpxCoeffSignificantB) & 1;
2202                   }
2203                   if (y0+y1 < cb->y1 - 1) {
2204                     all += (coeff[tileComp->cbW - 1].flags
2205                             >> jpxCoeffSignificantB) & 1;
2206                   }
2207                 }
2208                 if (x < cb->x1 - 1) {
2209                   all += (coeff[1].flags >> jpxCoeffSignificantB) & 1;
2210                   if (y0+y1 > cb->y0) {
2211                     all += (coeff[-(int)tileComp->cbW + 1].flags
2212                             >> jpxCoeffSignificantB) & 1;
2213                   }
2214                   if (y0+y1 < cb->y1 - 1) {
2215                     all += (coeff[tileComp->cbW + 1].flags
2216                             >> jpxCoeffSignificantB) & 1;
2217                   }
2218                 }
2219                 if (y0+y1 > cb->y0) {
2220                   all += (coeff[-(int)tileComp->cbW].flags
2221                           >> jpxCoeffSignificantB) & 1;
2222                 }
2223                 if (y0+y1 < cb->y1 - 1) {
2224                   all += (coeff[tileComp->cbW].flags
2225                           >> jpxCoeffSignificantB) & 1;
2226                 }
2227                 cx = all ? 15 : 14;
2228               } else {
2229                 cx = 16;
2230               }
2231               coeff->mag = (coeff->mag << 1) |
2232                            cb->arithDecoder->decodeBit(cx, cb->stats);
2233               ++coeff->len;
2234               coeff->flags |= jpxCoeffTouched;
2235               coeff->flags &= ~jpxCoeffFirstMagRef;
2236             }
2237           }
2238         }
2239       }
2240       ++cb->nextPass;
2241       break;
2242
2243     //----- cleanup pass
2244     case jpxPassCleanup:
2245       for (y0 = cb->y0, coeff0 = cb->coeffs;
2246            y0 < cb->y1;
2247            y0 += 4, coeff0 += 4 << tileComp->codeBlockW) {
2248         for (x = cb->x0, coeff1 = coeff0;
2249              x < cb->x1;
2250              ++x, ++coeff1) {
2251           y1 = 0;
2252           if (y0 + 3 < cb->y1 &&
2253               !(coeff1->flags & jpxCoeffTouched) &&
2254               !(coeff1[tileComp->cbW].flags & jpxCoeffTouched) &&
2255               !(coeff1[2 * tileComp->cbW].flags & jpxCoeffTouched) &&
2256               !(coeff1[3 * tileComp->cbW].flags & jpxCoeffTouched) &&
2257               (x == cb->x0 || y0 == cb->y0 ||
2258                !(coeff1[-(int)tileComp->cbW - 1].flags
2259                  & jpxCoeffSignificant)) &&
2260               (y0 == cb->y0 ||
2261                !(coeff1[-(int)tileComp->cbW].flags
2262                  & jpxCoeffSignificant)) &&
2263               (x == cb->x1 - 1 || y0 == cb->y0 ||
2264                !(coeff1[-(int)tileComp->cbW + 1].flags
2265                  & jpxCoeffSignificant)) &&
2266               (x == cb->x0 ||
2267                (!(coeff1[-1].flags & jpxCoeffSignificant) &&
2268                 !(coeff1[tileComp->cbW - 1].flags
2269                   & jpxCoeffSignificant) &&
2270                 !(coeff1[2 * tileComp->cbW - 1].flags
2271                   & jpxCoeffSignificant) && 
2272                 !(coeff1[3 * tileComp->cbW - 1].flags
2273                   & jpxCoeffSignificant))) &&
2274               (x == cb->x1 - 1 ||
2275                (!(coeff1[1].flags & jpxCoeffSignificant) &&
2276                 !(coeff1[tileComp->cbW + 1].flags
2277                   & jpxCoeffSignificant) &&
2278                 !(coeff1[2 * tileComp->cbW + 1].flags
2279                   & jpxCoeffSignificant) &&
2280                 !(coeff1[3 * tileComp->cbW + 1].flags
2281                   & jpxCoeffSignificant))) &&
2282               (x == cb->x0 || y0+4 == cb->y1 ||
2283                !(coeff1[4 * tileComp->cbW - 1].flags & jpxCoeffSignificant)) &&
2284               (y0+4 == cb->y1 ||
2285                !(coeff1[4 * tileComp->cbW].flags & jpxCoeffSignificant)) &&
2286               (x == cb->x1 - 1 || y0+4 == cb->y1 ||
2287                !(coeff1[4 * tileComp->cbW + 1].flags
2288                  & jpxCoeffSignificant))) {
2289             if (cb->arithDecoder->decodeBit(jpxContextRunLength, cb->stats)) {
2290               y1 = cb->arithDecoder->decodeBit(jpxContextUniform, cb->stats);
2291               y1 = (y1 << 1) |
2292                    cb->arithDecoder->decodeBit(jpxContextUniform, cb->stats);
2293               for (y2 = 0, coeff = coeff1;
2294                    y2 < y1;
2295                    ++y2, coeff += tileComp->cbW) {
2296                 ++coeff->len;
2297               }
2298               coeff->flags |= jpxCoeffSignificant | jpxCoeffFirstMagRef;
2299               coeff->mag = (coeff->mag << 1) | 1;
2300               ++coeff->len;
2301               cx = signContext[2][2][0];
2302               xorBit = signContext[2][2][1];
2303               if (cb->arithDecoder->decodeBit(cx, cb->stats) ^ xorBit) {
2304                 coeff->flags |= jpxCoeffSign;
2305               }
2306               ++y1;
2307             } else {
2308               for (y1 = 0, coeff = coeff1;
2309                    y1 < 4;
2310                    ++y1, coeff += tileComp->cbW) {
2311                 ++coeff->len;
2312               }
2313               y1 = 4;
2314             }
2315           }
2316           for (coeff = &coeff1[y1 << tileComp->codeBlockW];
2317                y1 < 4 && y0 + y1 < cb->y1;
2318                ++y1, coeff += tileComp->cbW) {
2319             if (!(coeff->flags & jpxCoeffTouched)) {
2320               horiz = vert = diag = 0;
2321               horizSign = vertSign = 2;
2322               if (x > cb->x0) {
2323                 if (coeff[-1].flags & jpxCoeffSignificant) {
2324                   ++horiz;
2325                   horizSign += (coeff[-1].flags & jpxCoeffSign) ? -1 : 1;
2326                 }
2327                 if (y0+y1 > cb->y0) {
2328                   diag += (coeff[-(int)tileComp->cbW - 1].flags
2329                            >> jpxCoeffSignificantB) & 1;
2330                 }
2331                 if (y0+y1 < cb->y1 - 1) {
2332                   diag += (coeff[tileComp->cbW - 1].flags
2333                            >> jpxCoeffSignificantB) & 1;
2334                 }
2335               }
2336               if (x < cb->x1 - 1) {
2337                 if (coeff[1].flags & jpxCoeffSignificant) {
2338                   ++horiz;
2339                   horizSign += (coeff[1].flags & jpxCoeffSign) ? -1 : 1;
2340                 }
2341                 if (y0+y1 > cb->y0) {
2342                   diag += (coeff[-(int)tileComp->cbW + 1].flags
2343                            >> jpxCoeffSignificantB) & 1;
2344                 }
2345                 if (y0+y1 < cb->y1 - 1) {
2346                   diag += (coeff[tileComp->cbW + 1].flags
2347                            >> jpxCoeffSignificantB) & 1;
2348                 }
2349               }
2350               if (y0+y1 > cb->y0) {
2351                 if (coeff[-(int)tileComp->cbW].flags & jpxCoeffSignificant) {
2352                   ++vert;
2353                   vertSign += (coeff[-(int)tileComp->cbW].flags & jpxCoeffSign)
2354                               ? -1 : 1;
2355                 }
2356               }
2357               if (y0+y1 < cb->y1 - 1) {
2358                 if (coeff[tileComp->cbW].flags & jpxCoeffSignificant) {
2359                   ++vert;
2360                   vertSign += (coeff[tileComp->cbW].flags & jpxCoeffSign)
2361                               ? -1 : 1;
2362                 }
2363               }
2364               cx = sigPropContext[horiz][vert][diag][res == 0 ? 1 : sb];
2365               if (cb->arithDecoder->decodeBit(cx, cb->stats)) {
2366                 coeff->flags |= jpxCoeffSignificant | jpxCoeffFirstMagRef;
2367                 coeff->mag = (coeff->mag << 1) | 1;
2368                 cx = signContext[horizSign][vertSign][0];
2369                 xorBit = signContext[horizSign][vertSign][1];
2370                 if (cb->arithDecoder->decodeBit(cx, cb->stats) ^ xorBit) {
2371                   coeff->flags |= jpxCoeffSign;
2372                 }
2373               }
2374               ++coeff->len;
2375             } else {
2376               coeff->flags &= ~jpxCoeffTouched;
2377             }
2378           }
2379         }
2380       }
2381       cb->nextPass = jpxPassSigProp;
2382       break;
2383     }
2384   }
2385
2386   cb->arithDecoder->cleanup();
2387   return gTrue;
2388 }
2389
2390 // Inverse quantization, and wavelet transform (IDWT).  This also does
2391 // the initial shift to convert to fixed point format.
2392 void JPXStream::inverseTransform(JPXTileComp *tileComp) {
2393   JPXResLevel *resLevel;
2394   JPXPrecinct *precinct;
2395   JPXSubband *subband;
2396   JPXCodeBlock *cb;
2397   JPXCoeff *coeff0, *coeff;
2398   Guint qStyle, guard, eps, shift;
2399   int shift2;
2400   double mu;
2401   int val;
2402   int *dataPtr;
2403   Guint nx0, ny0, nx1, ny1;
2404   Guint r, cbX, cbY, x, y;
2405
2406   //----- (NL)LL subband (resolution level 0)
2407
2408   resLevel = &tileComp->resLevels[0];
2409   precinct = &resLevel->precincts[0];
2410   subband = &precinct->subbands[0];
2411
2412   // i-quant parameters
2413   qStyle = tileComp->quantStyle & 0x1f;
2414   guard = (tileComp->quantStyle >> 5) & 7;
2415   if (qStyle == 0) {
2416     eps = (tileComp->quantSteps[0] >> 3) & 0x1f;
2417     shift = guard + eps - 1;
2418     mu = 0; // make gcc happy
2419   } else {
2420     shift = guard - 1 + tileComp->prec;
2421     mu = (double)(0x800 + (tileComp->quantSteps[0] & 0x7ff)) / 2048.0;
2422   }
2423   if (tileComp->transform == 0) {
2424     shift += fracBits;
2425   }
2426
2427   // copy (NL)LL into the upper-left corner of the data array, doing
2428   // the fixed point adjustment and dequantization along the way
2429   cb = subband->cbs;
2430   for (cbY = 0; cbY < subband->nYCBs; ++cbY) {
2431     for (cbX = 0; cbX < subband->nXCBs; ++cbX) {
2432       for (y = cb->y0, coeff0 = cb->coeffs;
2433            y < cb->y1;
2434            ++y, coeff0 += tileComp->cbW) {
2435         dataPtr = &tileComp->data[(y - subband->y0)
2436                                   * (tileComp->x1 - tileComp->x0)
2437                                   + (cb->x0 - subband->x0)];
2438         for (x = cb->x0, coeff = coeff0; x < cb->x1; ++x, ++coeff) {
2439           val = (int)coeff->mag;
2440           if (val != 0) {
2441             shift2 = shift - (cb->nZeroBitPlanes + coeff->len);
2442             if (shift2 > 0) {
2443               val = (val << shift2) + (1 << (shift2 - 1));
2444             } else {
2445               val >>= -shift2;
2446             }
2447             if (qStyle == 0) {
2448               if (tileComp->transform == 0) {
2449                 val &= -1 << fracBits;
2450               }
2451             } else {
2452               val = (int)((double)val * mu);
2453             }
2454             if (coeff->flags & jpxCoeffSign) {
2455               val = -val;
2456             }
2457           }
2458           *dataPtr++ = val;
2459         }
2460       }
2461       ++cb;
2462     }
2463   }
2464
2465   //----- IDWT for each level
2466
2467   for (r = 1; r <= tileComp->nDecompLevels; ++r) {
2468     resLevel = &tileComp->resLevels[r];
2469
2470     // (n)LL is already in the upper-left corner of the
2471     // tile-component data array -- interleave with (n)HL/LH/HH
2472     // and inverse transform to get (n-1)LL, which will be stored
2473     // in the upper-left corner of the tile-component data array
2474     if (r == tileComp->nDecompLevels) {
2475       nx0 = tileComp->x0;
2476       ny0 = tileComp->y0;
2477       nx1 = tileComp->x1;
2478       ny1 = tileComp->y1;
2479     } else {
2480       nx0 = tileComp->resLevels[r+1].x0;
2481       ny0 = tileComp->resLevels[r+1].y0;
2482       nx1 = tileComp->resLevels[r+1].x1;
2483       ny1 = tileComp->resLevels[r+1].y1;
2484     }
2485     inverseTransformLevel(tileComp, r, resLevel, nx0, ny0, nx1, ny1);
2486   }
2487 }
2488
2489 // Do one level of the inverse transform:
2490 // - take (n)LL from the tile-component data array
2491 // - take (n)HL/LH/HH from <resLevel>
2492 // - leave the resulting (n-1)LL in the tile-component data array
2493 void JPXStream::inverseTransformLevel(JPXTileComp *tileComp,
2494                                       Guint r, JPXResLevel *resLevel,
2495                                       Guint nx0, Guint ny0,
2496                                       Guint nx1, Guint ny1) {
2497   JPXPrecinct *precinct;
2498   JPXSubband *subband;
2499   JPXCodeBlock *cb;
2500   JPXCoeff *coeff0, *coeff;
2501   Guint qStyle, guard, eps, shift, t;
2502   int shift2;
2503   double mu;
2504   int val;
2505   int *dataPtr;
2506   Guint xo, yo;
2507   Guint x, y, sb, cbX, cbY;
2508   int xx, yy;
2509
2510   //----- interleave
2511
2512   // spread out LL
2513   for (yy = resLevel->y1 - 1; yy >= (int)resLevel->y0; --yy) {
2514     for (xx = resLevel->x1 - 1; xx >= (int)resLevel->x0; --xx) {
2515       tileComp->data[(2 * yy - ny0) * (tileComp->x1 - tileComp->x0)
2516                      + (2 * xx - nx0)] =
2517           tileComp->data[(yy - resLevel->y0) * (tileComp->x1 - tileComp->x0)
2518                          + (xx - resLevel->x0)];
2519     }
2520   }
2521
2522   // i-quant parameters
2523   qStyle = tileComp->quantStyle & 0x1f;
2524   guard = (tileComp->quantStyle >> 5) & 7;
2525
2526   // interleave HL/LH/HH
2527   precinct = &resLevel->precincts[0];
2528   for (sb = 0; sb < 3; ++sb) {
2529
2530     // i-quant parameters
2531     if (qStyle == 0) {
2532       eps = (tileComp->quantSteps[3*r - 2 + sb] >> 3) & 0x1f;
2533       shift = guard + eps - 1;
2534       mu = 0; // make gcc happy
2535     } else {
2536       shift = guard + tileComp->prec;
2537       if (sb == 2) {
2538         ++shift;
2539       }
2540       t = tileComp->quantSteps[qStyle == 1 ? 0 : (3*r - 2 + sb)];
2541       mu = (double)(0x800 + (t & 0x7ff)) / 2048.0;
2542     }
2543     if (tileComp->transform == 0) {
2544       shift += fracBits;
2545     }
2546
2547     // copy the subband coefficients into the data array, doing the
2548     // fixed point adjustment and dequantization along the way
2549     xo = (sb & 1) ? 0 : 1;
2550     yo = (sb > 0) ? 1 : 0;
2551     subband = &precinct->subbands[sb];
2552     cb = subband->cbs;
2553     for (cbY = 0; cbY < subband->nYCBs; ++cbY) {
2554       for (cbX = 0; cbX < subband->nXCBs; ++cbX) {
2555         for (y = cb->y0, coeff0 = cb->coeffs;
2556              y < cb->y1;
2557              ++y, coeff0 += tileComp->cbW) {
2558           dataPtr = &tileComp->data[(2 * y + yo - ny0)
2559                                     * (tileComp->x1 - tileComp->x0)
2560                                     + (2 * cb->x0 + xo - nx0)];
2561           for (x = cb->x0, coeff = coeff0; x < cb->x1; ++x, ++coeff) {
2562             val = (int)coeff->mag;
2563             if (val != 0) {
2564               shift2 = shift - (cb->nZeroBitPlanes + coeff->len);
2565               if (shift2 > 0) {
2566                 val = (val << shift2) + (1 << (shift2 - 1));
2567               } else {
2568                 val >>= -shift2;
2569               }
2570               if (qStyle == 0) {
2571                 if (tileComp->transform == 0) {
2572                   val &= -1 << fracBits;
2573                 }
2574               } else {
2575                 val = (int)((double)val * mu);
2576               }
2577               if (coeff->flags & jpxCoeffSign) {
2578                 val = -val;
2579               }
2580             }
2581             *dataPtr = val;
2582             dataPtr += 2;
2583           }
2584         }
2585         ++cb;
2586       }
2587     }
2588   }
2589
2590   //----- horizontal (row) transforms
2591   dataPtr = tileComp->data;
2592   for (y = 0; y < ny1 - ny0; ++y) {
2593     inverseTransform1D(tileComp, dataPtr, 1, nx0, nx1);
2594     dataPtr += tileComp->x1 - tileComp->x0;
2595   }
2596
2597   //----- vertical (column) transforms
2598   dataPtr = tileComp->data;
2599   for (x = 0; x < nx1 - nx0; ++x) {
2600     inverseTransform1D(tileComp, dataPtr,
2601                        tileComp->x1 - tileComp->x0, ny0, ny1);
2602     ++dataPtr;
2603   }
2604 }
2605
2606 void JPXStream::inverseTransform1D(JPXTileComp *tileComp,
2607                                    int *data, Guint stride,
2608                                    Guint i0, Guint i1) {
2609   int *buf;
2610   Guint offset, end, i;
2611
2612   //----- special case for length = 1
2613   if (i1 - i0 == 1) {
2614     if (i0 & 1) {
2615       *data >>= 1;
2616     }
2617
2618   } else {
2619
2620     // choose an offset: this makes even buf[] indexes correspond to
2621     // odd values of i, and vice versa
2622     offset = 3 + (i0 & 1);
2623     end = offset + i1 - i0;
2624
2625     //----- gather
2626     buf = tileComp->buf;
2627     for (i = 0; i < i1 - i0; ++i) {
2628       buf[offset + i] = data[i * stride];
2629     }
2630
2631     //----- extend right
2632     buf[end] = buf[end - 2];
2633     if (i1 - i0 == 2) {
2634       buf[end+1] = buf[offset + 1];
2635       buf[end+2] = buf[offset];
2636       buf[end+3] = buf[offset + 1];
2637     } else {
2638       buf[end+1] = buf[end - 3];
2639       if (i1 - i0 == 3) {
2640         buf[end+2] = buf[offset + 1];
2641         buf[end+3] = buf[offset + 2];
2642       } else {
2643         buf[end+2] = buf[end - 4];
2644         if (i1 - i0 == 4) {
2645           buf[end+3] = buf[offset + 1];
2646         } else {
2647           buf[end+3] = buf[end - 5];
2648         }
2649       }
2650     }
2651
2652     //----- extend left
2653     buf[offset - 1] = buf[offset + 1];
2654     buf[offset - 2] = buf[offset + 2];
2655     buf[offset - 3] = buf[offset + 3];
2656     if (offset == 4) {
2657       buf[0] = buf[offset + 4];
2658     }
2659
2660     //----- 9-7 irreversible filter
2661
2662     if (tileComp->transform == 0) {
2663       // step 1 (even)
2664       for (i = 1; i <= end + 2; i += 2) {
2665         buf[i] = (int)(idwtKappa * buf[i]);
2666       }
2667       // step 2 (odd)
2668       for (i = 0; i <= end + 3; i += 2) {
2669         buf[i] = (int)(idwtIKappa * buf[i]);
2670       }
2671       // step 3 (even)
2672       for (i = 1; i <= end + 2; i += 2) {
2673         buf[i] = (int)(buf[i] - idwtDelta * (buf[i-1] + buf[i+1]));
2674       }
2675       // step 4 (odd)
2676       for (i = 2; i <= end + 1; i += 2) {
2677         buf[i] = (int)(buf[i] - idwtGamma * (buf[i-1] + buf[i+1]));
2678       }
2679       // step 5 (even)
2680       for (i = 3; i <= end; i += 2) {
2681         buf[i] = (int)(buf[i] - idwtBeta * (buf[i-1] + buf[i+1]));
2682       }
2683       // step 6 (odd)
2684       for (i = 4; i <= end - 1; i += 2) {
2685         buf[i] = (int)(buf[i] - idwtAlpha * (buf[i-1] + buf[i+1]));
2686       }
2687
2688     //----- 5-3 reversible filter
2689
2690     } else {
2691       // step 1 (even)
2692       for (i = 3; i <= end; i += 2) {
2693         buf[i] -= (buf[i-1] + buf[i+1] + 2) >> 2;
2694       }
2695       // step 2 (odd)
2696       for (i = 4; i < end; i += 2) {
2697         buf[i] += (buf[i-1] + buf[i+1]) >> 1;
2698       }
2699     }
2700
2701     //----- scatter
2702     for (i = 0; i < i1 - i0; ++i) {
2703       data[i * stride] = buf[offset + i];
2704     }
2705   }
2706 }
2707
2708 // Inverse multi-component transform and DC level shift.  This also
2709 // converts fixed point samples back to integers.
2710 GBool JPXStream::inverseMultiCompAndDC(JPXTile *tile) {
2711   JPXTileComp *tileComp;
2712   int coeff, d0, d1, d2, t, minVal, maxVal, zeroVal;
2713   int *dataPtr;
2714   Guint j, comp, x, y;
2715
2716   //----- inverse multi-component transform
2717
2718   if (tile->multiComp == 1) {
2719     if (img.nComps < 3 ||
2720         tile->tileComps[0].hSep != tile->tileComps[1].hSep ||
2721         tile->tileComps[0].vSep != tile->tileComps[1].vSep ||
2722         tile->tileComps[1].hSep != tile->tileComps[2].hSep ||
2723         tile->tileComps[1].vSep != tile->tileComps[2].vSep) {
2724       return gFalse;
2725     }
2726
2727     // inverse irreversible multiple component transform
2728     if (tile->tileComps[0].transform == 0) {
2729       j = 0;
2730       for (y = 0; y < tile->tileComps[0].y1 - tile->tileComps[0].y0; ++y) {
2731         for (x = 0; x < tile->tileComps[0].x1 - tile->tileComps[0].x0; ++x) {
2732           d0 = tile->tileComps[0].data[j];
2733           d1 = tile->tileComps[1].data[j];
2734           d2 = tile->tileComps[2].data[j];
2735           tile->tileComps[0].data[j] = (int)(d0 + 1.402 * d2 + 0.5);
2736           tile->tileComps[1].data[j] =
2737               (int)(d0 - 0.34413 * d1 - 0.71414 * d2 + 0.5);
2738           tile->tileComps[2].data[j] = (int)(d0 + 1.772 * d1 + 0.5);
2739           ++j;
2740         }
2741       }
2742
2743     // inverse reversible multiple component transform
2744     } else {
2745       j = 0;
2746       for (y = 0; y < tile->tileComps[0].y1 - tile->tileComps[0].y0; ++y) {
2747         for (x = 0; x < tile->tileComps[0].x1 - tile->tileComps[0].x0; ++x) {
2748           d0 = tile->tileComps[0].data[j];
2749           d1 = tile->tileComps[1].data[j];
2750           d2 = tile->tileComps[2].data[j];
2751           tile->tileComps[1].data[j] = t = d0 - ((d2 + d1) >> 2);
2752           tile->tileComps[0].data[j] = d2 + t;
2753           tile->tileComps[2].data[j] = d1 + t;
2754           ++j;
2755         }
2756       }
2757     }
2758   }
2759
2760   //----- DC level shift
2761   for (comp = 0; comp < img.nComps; ++comp) {
2762     tileComp = &tile->tileComps[comp];
2763
2764     // signed: clip
2765     if (tileComp->sgned) {
2766       minVal = -(1 << (tileComp->prec - 1));
2767       maxVal = (1 << (tileComp->prec - 1)) - 1;
2768       dataPtr = tileComp->data;
2769       for (y = 0; y < tileComp->y1 - tileComp->y0; ++y) {
2770         for (x = 0; x < tileComp->x1 - tileComp->x0; ++x) {
2771           coeff = *dataPtr;
2772           if (tileComp->transform == 0) {
2773             coeff >>= fracBits;
2774           }
2775           if (coeff < minVal) {
2776             coeff = minVal;
2777           } else if (coeff > maxVal) {
2778             coeff = maxVal;
2779           }
2780           *dataPtr++ = coeff;
2781         }
2782       }
2783
2784     // unsigned: inverse DC level shift and clip
2785     } else {
2786       maxVal = (1 << tileComp->prec) - 1;
2787       zeroVal = 1 << (tileComp->prec - 1);
2788       dataPtr = tileComp->data;
2789       for (y = 0; y < tileComp->y1 - tileComp->y0; ++y) {
2790         for (x = 0; x < tileComp->x1 - tileComp->x0; ++x) {
2791           coeff = *dataPtr;
2792           if (tileComp->transform == 0) {
2793             coeff >>= fracBits;
2794           }
2795           coeff += zeroVal;
2796           if (coeff < 0) {
2797             coeff = 0;
2798           } else if (coeff > maxVal) {
2799             coeff = maxVal;
2800           }
2801           *dataPtr++ = coeff;
2802         }
2803       }
2804     }
2805   }
2806
2807   return gTrue;
2808 }
2809
2810 GBool JPXStream::readBoxHdr(Guint *boxType, Guint *boxLen, Guint *dataLen) {
2811   Guint len, lenH;
2812
2813   if (!readULong(&len) ||
2814       !readULong(boxType)) {
2815     return gFalse;
2816   }
2817   if (len == 1) {
2818     if (!readULong(&lenH) || !readULong(&len)) {
2819       return gFalse;
2820     }
2821     if (lenH) {
2822       error(getPos(), "JPX stream contains a box larger than 2^32 bytes");
2823       return gFalse;
2824     }
2825     *boxLen = len;
2826     *dataLen = len - 16;
2827   } else if (len == 0) {
2828     *boxLen = 0;
2829     *dataLen = 0;
2830   } else {
2831     *boxLen = len;
2832     *dataLen = len - 8;
2833   }
2834   return gTrue;
2835 }
2836
2837 int JPXStream::readMarkerHdr(int *segType, Guint *segLen) {
2838   int c;
2839
2840   do {
2841     do {
2842       if ((c = str->getChar()) == EOF) {
2843         return gFalse;
2844       }
2845     } while (c != 0xff);
2846     do {
2847       if ((c = str->getChar()) == EOF) {
2848         return gFalse;
2849       }
2850     } while (c == 0xff);
2851   } while (c == 0x00);
2852   *segType = c;
2853   if ((c >= 0x30 && c <= 0x3f) ||
2854       c == 0x4f || c == 0x92 || c == 0x93 || c == 0xd9) {
2855     *segLen = 0;
2856     return gTrue;
2857   }
2858   return readUWord(segLen);
2859 }
2860
2861 GBool JPXStream::readUByte(Guint *x) {
2862   int c0;
2863
2864   if ((c0 = str->getChar()) == EOF) {
2865     return gFalse;
2866   }
2867   *x = (Guint)c0;
2868   return gTrue;
2869 }
2870
2871 GBool JPXStream::readByte(int *x) {
2872  int c0;
2873
2874   if ((c0 = str->getChar()) == EOF) {
2875     return gFalse;
2876   }
2877   *x = c0;
2878   if (c0 & 0x80) {
2879     *x |= -1 - 0xff;
2880   }
2881   return gTrue;
2882 }
2883
2884 GBool JPXStream::readUWord(Guint *x) {
2885   int c0, c1;
2886
2887   if ((c0 = str->getChar()) == EOF ||
2888       (c1 = str->getChar()) == EOF) {
2889     return gFalse;
2890   }
2891   *x = (Guint)((c0 << 8) | c1);
2892   return gTrue;
2893 }
2894
2895 GBool JPXStream::readULong(Guint *x) {
2896   int c0, c1, c2, c3;
2897
2898   if ((c0 = str->getChar()) == EOF ||
2899       (c1 = str->getChar()) == EOF ||
2900       (c2 = str->getChar()) == EOF ||
2901       (c3 = str->getChar()) == EOF) {
2902     return gFalse;
2903   }
2904   *x = (Guint)((c0 << 24) | (c1 << 16) | (c2 << 8) | c3);
2905   return gTrue;
2906 }
2907
2908 GBool JPXStream::readNBytes(int nBytes, GBool signd, int *x) {
2909   int y, c, i;
2910
2911   y = 0;
2912   for (i = 0; i < nBytes; ++i) {
2913     if ((c = str->getChar()) == EOF) {
2914       return gFalse;
2915     }
2916     y = (y << 8) + c;
2917   }
2918   if (signd) {
2919     if (y & (1 << (8 * nBytes - 1))) {
2920       y |= -1 << (8 * nBytes);
2921     }
2922   }
2923   *x = y;
2924   return gTrue;
2925 }
2926
2927 GBool JPXStream::readBits(int nBits, Guint *x) {
2928   int c;
2929
2930   while (bitBufLen < nBits) {
2931     if ((c = str->getChar()) == EOF) {
2932       return gFalse;
2933     }
2934     ++byteCount;
2935     if (bitBufSkip) {
2936       bitBuf = (bitBuf << 7) | (c & 0x7f);
2937       bitBufLen += 7;
2938     } else {
2939       bitBuf = (bitBuf << 8) | (c & 0xff);
2940       bitBufLen += 8;
2941     }
2942     bitBufSkip = c == 0xff;
2943   }
2944   *x = (bitBuf >> (bitBufLen - nBits)) & ((1 << nBits) - 1);
2945   bitBufLen -= nBits;
2946   return gTrue;
2947 }
2948
2949 void JPXStream::clearBitBuf() {
2950   bitBufLen = 0;
2951   bitBufSkip = gFalse;
2952   byteCount = 0;
2953 }