//========================================================================
//
// JPXStream.cc
//
// Copyright 2002-2003 Glyph & Cog, LLC
//
//========================================================================

//========================================================================
//
// Modified under the Poppler project - http://poppler.freedesktop.org
//
// All changes made under the Poppler project to this file are licensed
// under GPL version 2 or later
//
// Copyright (C) 2008, 2012 Albert Astals Cid <aacid@kde.org>
// Copyright (C) 2012 Thomas Freitag <Thomas.Freitag@alfa.de>
// Copyright (C) 2012 Even Rouault <even.rouault@mines-paris.org>
// Copyright (C) 2019 Robert Niemi <robert.den.klurige@gmail.com>
//
// To see a description of the changes please see the Changelog file that
// came with your tarball or type make ChangeLog if you are building from git
//
//========================================================================

#include <config.h>

#include <climits>
#include "gmem.h"
#include "Error.h"
#include "JArithmeticDecoder.h"
#include "JPXStream.h"

//~ to do:
//  - precincts
//  - ROI
//  - progression order changes
//  - packed packet headers
//  - support for palettes, channel maps, etc.
//  - make sure all needed JP2/JPX subboxes are parsed (readBoxes)
//  - can we assume that QCC segments must come after the QCD segment?
//  - handle tilePartToEOC in readTilePartData
//  - progression orders 2, 3, and 4
//  - in coefficient decoding (readCodeBlockData):
//    - selective arithmetic coding bypass
//      (this also affects reading the cb->dataLen array)
//    - coeffs longer than 31 bits (should just ignore the extra bits?)
//  - handle boxes larger than 2^32 bytes
//  - the fixed-point arithmetic won't handle 16-bit pixels

//------------------------------------------------------------------------

// number of contexts for the arithmetic decoder
#define jpxNContexts 19

#define jpxContextSigProp 0 // 0 - 8: significance prop and cleanup
#define jpxContextSign 9 // 9 - 13: sign
#define jpxContextMagRef 14 // 14 -16: magnitude refinement
#define jpxContextRunLength 17 // cleanup: run length
#define jpxContextUniform 18 // cleanup: first signif coeff

//------------------------------------------------------------------------

#define jpxPassSigProp 0
#define jpxPassMagRef 1
#define jpxPassCleanup 2

//------------------------------------------------------------------------

// arithmetic decoder context for the significance propagation and
// cleanup passes:
//     [horiz][vert][diag][subband]
// where subband = 0 for HL
//               = 1 for LH and LL
//               = 2 for HH
static const unsigned int sigPropContext[3][3][5][3] = {
    { { { 0, 0, 0 }, // horiz=0, vert=0, diag=0
        { 1, 1, 3 }, // horiz=0, vert=0, diag=1
        { 2, 2, 6 }, // horiz=0, vert=0, diag=2
        { 2, 2, 8 }, // horiz=0, vert=0, diag=3
        { 2, 2, 8 } }, // horiz=0, vert=0, diag=4
      { { 5, 3, 1 }, // horiz=0, vert=1, diag=0
        { 6, 3, 4 }, // horiz=0, vert=1, diag=1
        { 6, 3, 7 }, // horiz=0, vert=1, diag=2
        { 6, 3, 8 }, // horiz=0, vert=1, diag=3
        { 6, 3, 8 } }, // horiz=0, vert=1, diag=4
      { { 8, 4, 2 }, // horiz=0, vert=2, diag=0
        { 8, 4, 5 }, // horiz=0, vert=2, diag=1
        { 8, 4, 7 }, // horiz=0, vert=2, diag=2
        { 8, 4, 8 }, // horiz=0, vert=2, diag=3
        { 8, 4, 8 } } }, // horiz=0, vert=2, diag=4
    { { { 3, 5, 1 }, // horiz=1, vert=0, diag=0
        { 3, 6, 4 }, // horiz=1, vert=0, diag=1
        { 3, 6, 7 }, // horiz=1, vert=0, diag=2
        { 3, 6, 8 }, // horiz=1, vert=0, diag=3
        { 3, 6, 8 } }, // horiz=1, vert=0, diag=4
      { { 7, 7, 2 }, // horiz=1, vert=1, diag=0
        { 7, 7, 5 }, // horiz=1, vert=1, diag=1
        { 7, 7, 7 }, // horiz=1, vert=1, diag=2
        { 7, 7, 8 }, // horiz=1, vert=1, diag=3
        { 7, 7, 8 } }, // horiz=1, vert=1, diag=4
      { { 8, 7, 2 }, // horiz=1, vert=2, diag=0
        { 8, 7, 5 }, // horiz=1, vert=2, diag=1
        { 8, 7, 7 }, // horiz=1, vert=2, diag=2
        { 8, 7, 8 }, // horiz=1, vert=2, diag=3
        { 8, 7, 8 } } }, // horiz=1, vert=2, diag=4
    { { { 4, 8, 2 }, // horiz=2, vert=0, diag=0
        { 4, 8, 5 }, // horiz=2, vert=0, diag=1
        { 4, 8, 7 }, // horiz=2, vert=0, diag=2
        { 4, 8, 8 }, // horiz=2, vert=0, diag=3
        { 4, 8, 8 } }, // horiz=2, vert=0, diag=4
      { { 7, 8, 2 }, // horiz=2, vert=1, diag=0
        { 7, 8, 5 }, // horiz=2, vert=1, diag=1
        { 7, 8, 7 }, // horiz=2, vert=1, diag=2
        { 7, 8, 8 }, // horiz=2, vert=1, diag=3
        { 7, 8, 8 } }, // horiz=2, vert=1, diag=4
      { { 8, 8, 2 }, // horiz=2, vert=2, diag=0
        { 8, 8, 5 }, // horiz=2, vert=2, diag=1
        { 8, 8, 7 }, // horiz=2, vert=2, diag=2
        { 8, 8, 8 }, // horiz=2, vert=2, diag=3
        { 8, 8, 8 } } } // horiz=2, vert=2, diag=4
};

// arithmetic decoder context and xor bit for the sign bit in the
// significance propagation pass:
//     [horiz][vert][k]
// where horiz/vert are offset by 2 (i.e., range is -2 .. 2)
// and k = 0 for the context
//       = 1 for the xor bit
static const unsigned int signContext[5][5][2] = {
    { { 13, 1 }, // horiz=-2, vert=-2
      { 13, 1 }, // horiz=-2, vert=-1
      { 12, 1 }, // horiz=-2, vert= 0
      { 11, 1 }, // horiz=-2, vert=+1
      { 11, 1 } }, // horiz=-2, vert=+2
    { { 13, 1 }, // horiz=-1, vert=-2
      { 13, 1 }, // horiz=-1, vert=-1
      { 12, 1 }, // horiz=-1, vert= 0
      { 11, 1 }, // horiz=-1, vert=+1
      { 11, 1 } }, // horiz=-1, vert=+2
    { { 10, 1 }, // horiz= 0, vert=-2
      { 10, 1 }, // horiz= 0, vert=-1
      { 9, 0 }, // horiz= 0, vert= 0
      { 10, 0 }, // horiz= 0, vert=+1
      { 10, 0 } }, // horiz= 0, vert=+2
    { { 11, 0 }, // horiz=+1, vert=-2
      { 11, 0 }, // horiz=+1, vert=-1
      { 12, 0 }, // horiz=+1, vert= 0
      { 13, 0 }, // horiz=+1, vert=+1
      { 13, 0 } }, // horiz=+1, vert=+2
    { { 11, 0 }, // horiz=+2, vert=-2
      { 11, 0 }, // horiz=+2, vert=-1
      { 12, 0 }, // horiz=+2, vert= 0
      { 13, 0 }, // horiz=+2, vert=+1
      { 13, 0 } }, // horiz=+2, vert=+2
};

//------------------------------------------------------------------------

// constants used in the IDWT
#define idwtAlpha -1.586134342059924
#define idwtBeta -0.052980118572961
#define idwtGamma 0.882911075530934
#define idwtDelta 0.443506852043971
#define idwtKappa 1.230174104914001
#define idwtIKappa (1.0 / idwtKappa)

// number of bits to the right of the decimal point for the fixed
// point arithmetic used in the IDWT
#define fracBits 16

//------------------------------------------------------------------------

// floor(x / y)
#define jpxFloorDiv(x, y) ((x) / (y))

// floor(x / 2^y)
#define jpxFloorDivPow2(x, y) ((x) >> (y))

// ceil(x / y)
#define jpxCeilDiv(x, y) (((x) + (y)-1) / (y))

// ceil(x / 2^y)
#define jpxCeilDivPow2(x, y) (((x) + (1 << (y)) - 1) >> (y))

//------------------------------------------------------------------------

#if 1 //----- disable coverage tracking

#    define cover(idx)

#else //----- enable coverage tracking

class JPXCover
{
public:
    JPXCover(int sizeA);
    ~JPXCover();
    void incr(int idx);

private:
    int size, used;
    int *data;
};

JPXCover::JPXCover(int sizeA)
{
    size = sizeA;
    used = -1;
    data = (int *)gmallocn(size, sizeof(int));
    memset(data, 0, size * sizeof(int));
}

JPXCover::~JPXCover()
{
    int i;

    printf("JPX coverage:\n");
    for (i = 0; i <= used; ++i) {
        printf("  %4d: %8d\n", i, data[i]);
    }
    gfree(data);
}

void JPXCover::incr(int idx)
{
    if (idx < size) {
        ++data[idx];
        if (idx > used) {
            used = idx;
        }
    }
}

JPXCover jpxCover(150);

#    define cover(idx) jpxCover.incr(idx)

#endif //----- coverage tracking

//------------------------------------------------------------------------

JPXStream::JPXStream(Stream *strA) : FilterStream(strA)
{
    bufStr = new BufStream(str, 2);

    nComps = 0;
    bpc = nullptr;
    width = height = 0;
    haveCS = false;
    havePalette = false;
    haveCompMap = false;
    haveChannelDefn = false;

    img.tiles = nullptr;
    bitBuf = 0;
    bitBufLen = 0;
    bitBufSkip = false;
    byteCount = 0;

    curX = curY = 0;
    curComp = 0;
    readBufLen = 0;
}

JPXStream::~JPXStream()
{
    close();
    delete bufStr;
}

void JPXStream::reset()
{
    bufStr->reset();
    if (readBoxes()) {
        curY = img.yOffset;
    } else {
        // readBoxes reported an error, so we go immediately to EOF
        curY = img.ySize;
    }
    curX = img.xOffset;
    curComp = 0;
    readBufLen = 0;
}

void JPXStream::close()
{
    JPXTile *tile;
    JPXTileComp *tileComp;
    JPXResLevel *resLevel;
    JPXPrecinct *precinct;
    JPXSubband *subband;
    JPXCodeBlock *cb;
    unsigned int comp, i, k, r, pre, sb;

    gfree(bpc);
    bpc = nullptr;
    if (havePalette) {
        gfree(palette.bpc);
        gfree(palette.c);
        havePalette = false;
    }
    if (haveCompMap) {
        gfree(compMap.comp);
        gfree(compMap.type);
        gfree(compMap.pComp);
        haveCompMap = false;
    }
    if (haveChannelDefn) {
        gfree(channelDefn.idx);
        gfree(channelDefn.type);
        gfree(channelDefn.assoc);
        haveChannelDefn = false;
    }

    if (img.tiles) {
        for (i = 0; i < img.nXTiles * img.nYTiles; ++i) {
            tile = &img.tiles[i];
            if (tile->tileComps) {
                for (comp = 0; comp < img.nComps; ++comp) {
                    tileComp = &tile->tileComps[comp];
                    gfree(tileComp->quantSteps);
                    gfree(tileComp->data);
                    gfree(tileComp->buf);
                    if (tileComp->resLevels) {
                        for (r = 0; r <= tileComp->nDecompLevels; ++r) {
                            resLevel = &tileComp->resLevels[r];
                            if (resLevel->precincts) {
                                for (pre = 0; pre < 1; ++pre) {
                                    precinct = &resLevel->precincts[pre];
                                    if (precinct->subbands) {
                                        for (sb = 0; sb < (unsigned int)(r == 0 ? 1 : 3); ++sb) {
                                            subband = &precinct->subbands[sb];
                                            gfree(subband->inclusion);
                                            gfree(subband->zeroBitPlane);
                                            if (subband->cbs) {
                                                for (k = 0; k < subband->nXCBs * subband->nYCBs; ++k) {
                                                    cb = &subband->cbs[k];
                                                    gfree(cb->dataLen);
                                                    gfree(cb->touched);
                                                    if (cb->arithDecoder) {
                                                        delete cb->arithDecoder;
                                                    }
                                                    if (cb->stats) {
                                                        delete cb->stats;
                                                    }
                                                }
                                                gfree(subband->cbs);
                                            }
                                        }
                                        gfree(precinct->subbands);
                                    }
                                }
                                gfree(img.tiles[i].tileComps[comp].resLevels[r].precincts);
                            }
                        }
                        gfree(img.tiles[i].tileComps[comp].resLevels);
                    }
                }
                gfree(img.tiles[i].tileComps);
            }
        }
        gfree(img.tiles);
        img.tiles = nullptr;
    }
    bufStr->close();
}

int JPXStream::getChar()
{
    int c;

    if (readBufLen < 8) {
        fillReadBuf();
    }
    if (readBufLen == 8) {
        c = readBuf & 0xff;
        readBufLen = 0;
    } else if (readBufLen > 8) {
        c = (readBuf >> (readBufLen - 8)) & 0xff;
        readBufLen -= 8;
    } else if (readBufLen == 0) {
        c = EOF;
    } else {
        c = (readBuf << (8 - readBufLen)) & 0xff;
        readBufLen = 0;
    }
    return c;
}

int JPXStream::lookChar()
{
    int c;

    if (readBufLen < 8) {
        fillReadBuf();
    }
    if (readBufLen == 8) {
        c = readBuf & 0xff;
    } else if (readBufLen > 8) {
        c = (readBuf >> (readBufLen - 8)) & 0xff;
    } else if (readBufLen == 0) {
        c = EOF;
    } else {
        c = (readBuf << (8 - readBufLen)) & 0xff;
    }
    return c;
}

void JPXStream::fillReadBuf()
{
    JPXTileComp *tileComp;
    unsigned int tileIdx, tx, ty;
    int pix, pixBits;

    do {
        if (curY >= img.ySize) {
            return;
        }
        tileIdx = ((curY - img.yTileOffset) / img.yTileSize) * img.nXTiles + (curX - img.xTileOffset) / img.xTileSize;
#if 1 //~ ignore the palette, assume the PDF ColorSpace object is valid
        if (img.tiles == nullptr || tileIdx >= img.nXTiles * img.nYTiles || img.tiles[tileIdx].tileComps == nullptr) {
            error(errSyntaxError, getPos(), "Unexpected tileIdx in fillReadBuf in JPX stream");
            return;
        }
        tileComp = &img.tiles[tileIdx].tileComps[curComp];
#else
        tileComp = &img.tiles[tileIdx].tileComps[havePalette ? 0 : curComp];
#endif
        tx = jpxCeilDiv((curX - img.xTileOffset) % img.xTileSize, tileComp->hSep);
        ty = jpxCeilDiv((curY - img.yTileOffset) % img.yTileSize, tileComp->vSep);
        if (unlikely(ty >= (tileComp->y1 - tileComp->y0))) {
            error(errSyntaxError, getPos(), "Unexpected ty in fillReadBuf in JPX stream");
            return;
        }
        if (unlikely(tx >= (tileComp->x1 - tileComp->x0))) {
            error(errSyntaxError, getPos(), "Unexpected tx in fillReadBuf in JPX stream");
            return;
        }
        pix = (int)tileComp->data[ty * (tileComp->x1 - tileComp->x0) + tx];
        pixBits = tileComp->prec;
#if 1 //~ ignore the palette, assume the PDF ColorSpace object is valid
        if (++curComp == img.nComps) {
#else
        if (havePalette) {
            if (pix >= 0 && pix < palette.nEntries) {
                pix = palette.c[pix * palette.nComps + curComp];
            } else {
                pix = 0;
            }
            pixBits = palette.bpc[curComp];
        }
        if (++curComp == (unsigned int)(havePalette ? palette.nComps : img.nComps)) {
#endif
            curComp = 0;
            if (++curX == img.xSize) {
                curX = img.xOffset;
                ++curY;
                if (pixBits < 8) {
                    pix <<= 8 - pixBits;
                    pixBits = 8;
                }
            }
        }
        if (pixBits == 8) {
            readBuf = (readBuf << 8) | (pix & 0xff);
        } else {
            readBuf = (readBuf << pixBits) | (pix & ((1 << pixBits) - 1));
        }
        readBufLen += pixBits;
    } while (readBufLen < 8);
}

GooString *JPXStream::getPSFilter(int psLevel, const char *indent)
{
    return nullptr;
}

bool JPXStream::isBinary(bool last)
{
    return str->isBinary(true);
}

void JPXStream::getImageParams(int *bitsPerComponent, StreamColorSpaceMode *csMode)
{
    unsigned int boxType, boxLen, dataLen, csEnum;
    unsigned int bpc1, dummy, i;
    int csMeth, csPrec, csPrec1, dummy2;
    StreamColorSpaceMode csMode1;
    bool haveBPC, haveCSMode;

    csPrec = 0; // make gcc happy
    haveBPC = haveCSMode = false;
    bufStr->reset();
    if (bufStr->lookChar() == 0xff) {
        getImageParams2(bitsPerComponent, csMode);
    } else {
        while (readBoxHdr(&boxType, &boxLen, &dataLen)) {
            if (boxType == 0x6a703268) { // JP2 header
                cover(0);
                // skip the superbox
            } else if (boxType == 0x69686472) { // image header
                cover(1);
                if (readULong(&dummy) && readULong(&dummy) && readUWord(&dummy) && readUByte(&bpc1) && readUByte(&dummy) && readUByte(&dummy) && readUByte(&dummy)) {
                    *bitsPerComponent = bpc1 + 1;
                    haveBPC = true;
                }
            } else if (boxType == 0x636F6C72) { // color specification
                cover(2);
                if (readByte(&csMeth) && readByte(&csPrec1) && readByte(&dummy2)) {
                    if (csMeth == 1) {
                        if (readULong(&csEnum)) {
                            csMode1 = streamCSNone;
                            if (csEnum == jpxCSBiLevel || csEnum == jpxCSGrayscale) {
                                csMode1 = streamCSDeviceGray;
                            } else if (csEnum == jpxCSCMYK) {
                                csMode1 = streamCSDeviceCMYK;
                            } else if (csEnum == jpxCSsRGB || csEnum == jpxCSCISesRGB || csEnum == jpxCSROMMRGB) {
                                csMode1 = streamCSDeviceRGB;
                            }
                            if (csMode1 != streamCSNone && (!haveCSMode || csPrec1 > csPrec)) {
                                *csMode = csMode1;
                                csPrec = csPrec1;
                                haveCSMode = true;
                            }
                            if (dataLen >= 7) {
                                for (i = 0; i < dataLen - 7; ++i) {
                                    if (bufStr->getChar() == EOF)
                                        break;
                                }
                            }
                        }
                    } else {
                        if (dataLen >= 3) {
                            for (i = 0; i < dataLen - 3; ++i) {
                                if (bufStr->getChar() == EOF)
                                    break;
                            }
                        }
                    }
                }
            } else if (boxType == 0x6A703263) { // codestream
                cover(3);
                if (!(haveBPC && haveCSMode)) {
                    getImageParams2(bitsPerComponent, csMode);
                }
                break;
            } else {
                cover(4);
                for (i = 0; i < dataLen; ++i) {
                    if (unlikely(bufStr->getChar() == EOF)) {
                        error(errSyntaxError, getPos(), "Unexpected EOF in getImageParams in JPX stream");
                        break;
                    }
                }
            }
        }
    }
    bufStr->close();
}

// Get image parameters from the codestream.
void JPXStream::getImageParams2(int *bitsPerComponent, StreamColorSpaceMode *csMode)
{
    int segType;
    unsigned int segLen, nComps1, bpc1, dummy, i;

    while (readMarkerHdr(&segType, &segLen)) {
        if (segType == 0x51) { // SIZ - image and tile size
            cover(5);
            if (readUWord(&dummy) && readULong(&dummy) && readULong(&dummy) && readULong(&dummy) && readULong(&dummy) && readULong(&dummy) && readULong(&dummy) && readULong(&dummy) && readULong(&dummy) && readUWord(&nComps1)
                && readUByte(&bpc1)) {
                *bitsPerComponent = (bpc1 & 0x7f) + 1;
                // if there's no color space info, take a guess
                if (nComps1 == 1) {
                    *csMode = streamCSDeviceGray;
                } else if (nComps1 == 3) {
                    *csMode = streamCSDeviceRGB;
                } else if (nComps1 == 4) {
                    *csMode = streamCSDeviceCMYK;
                }
            }
            break;
        } else {
            cover(6);
            if (segLen > 2) {
                for (i = 0; i < segLen - 2; ++i) {
                    bufStr->getChar();
                }
            }
        }
    }
}

bool JPXStream::readBoxes()
{
    unsigned int boxType, boxLen, dataLen;
    unsigned int bpc1, compression, unknownColorspace, ipr;
    unsigned int i, j;

    haveImgHdr = false;

    // initialize in case there is a parse error
    img.xSize = img.ySize = 0;
    img.xOffset = img.yOffset = 0;
    img.xTileSize = img.yTileSize = 0;
    img.xTileOffset = img.yTileOffset = 0;
    img.nComps = 0;

    // check for a naked JPEG 2000 codestream (without the JP2/JPX
    // wrapper) -- this appears to be a violation of the PDF spec, but
    // Acrobat allows it
    if (bufStr->lookChar() == 0xff) {
        cover(7);
        error(errSyntaxWarning, getPos(), "Naked JPEG 2000 codestream, missing JP2/JPX wrapper");
        if (!readCodestream(0)) {
            return false;
        }
        nComps = img.nComps;
        bpc = (unsigned int *)gmallocn(nComps, sizeof(unsigned int));
        for (i = 0; i < nComps; ++i) {
            bpc[i] = img.tiles[0].tileComps[i].prec;
        }
        width = img.xSize - img.xOffset;
        height = img.ySize - img.yOffset;
        return true;
    }

    while (readBoxHdr(&boxType, &boxLen, &dataLen)) {
        switch (boxType) {
        case 0x6a703268: // JP2 header
            // this is a grouping box ('superbox') which has no real
            // contents and doesn't appear to be used consistently, i.e.,
            // some things which should be subboxes of the JP2 header box
            // show up outside of it - so we simply ignore the JP2 header
            // box
            cover(8);
            break;
        case 0x69686472: // image header
            cover(9);
            if (!readULong(&height) || !readULong(&width) || !readUWord(&nComps) || !readUByte(&bpc1) || !readUByte(&compression) || !readUByte(&unknownColorspace) || !readUByte(&ipr)) {
                error(errSyntaxError, getPos(), "Unexpected EOF in JPX stream");
                return false;
            }
            if (compression != 7) {
                error(errSyntaxError, getPos(), "Unknown compression type in JPX stream");
                return false;
            }
            bpc = (unsigned int *)gmallocn(nComps, sizeof(unsigned int));
            for (i = 0; i < nComps; ++i) {
                bpc[i] = bpc1;
            }
            haveImgHdr = true;
            break;
        case 0x62706363: // bits per component
            cover(10);
            if (!haveImgHdr) {
                error(errSyntaxError, getPos(), "Found bits per component box before image header box in JPX stream");
                return false;
            }
            if (dataLen != nComps) {
                error(errSyntaxError, getPos(), "Invalid bits per component box in JPX stream");
                return false;
            }
            for (i = 0; i < nComps; ++i) {
                if (!readUByte(&bpc[i])) {
                    error(errSyntaxError, getPos(), "Unexpected EOF in JPX stream");
                    return false;
                }
            }
            break;
        case 0x636F6C72: // color specification
            cover(11);
            if (!readColorSpecBox(dataLen)) {
                return false;
            }
            break;
        case 0x70636c72: // palette
            cover(12);
            if (!readUWord(&palette.nEntries) || !readUByte(&palette.nComps)) {
                error(errSyntaxError, getPos(), "Unexpected EOF in JPX stream");
                return false;
            }
            palette.bpc = (unsigned int *)gmallocn(palette.nComps, sizeof(unsigned int));
            palette.c = (int *)gmallocn(palette.nEntries * palette.nComps, sizeof(int));
            for (i = 0; i < palette.nComps; ++i) {
                if (!readUByte(&palette.bpc[i])) {
                    error(errSyntaxError, getPos(), "Unexpected EOF in JPX stream");
                    return false;
                }
                ++palette.bpc[i];
            }
            for (i = 0; i < palette.nEntries; ++i) {
                for (j = 0; j < palette.nComps; ++j) {
                    if (!readNBytes(((palette.bpc[j] & 0x7f) + 7) >> 3, (palette.bpc[j] & 0x80) ? true : false, &palette.c[i * palette.nComps + j])) {
                        error(errSyntaxError, getPos(), "Unexpected EOF in JPX stream");
                        return false;
                    }
                }
            }
            havePalette = true;
            break;
        case 0x636d6170: // component mapping
            cover(13);
            compMap.nChannels = dataLen / 4;
            compMap.comp = (unsigned int *)gmallocn(compMap.nChannels, sizeof(unsigned int));
            compMap.type = (unsigned int *)gmallocn(compMap.nChannels, sizeof(unsigned int));
            compMap.pComp = (unsigned int *)gmallocn(compMap.nChannels, sizeof(unsigned int));
            for (i = 0; i < compMap.nChannels; ++i) {
                if (!readUWord(&compMap.comp[i]) || !readUByte(&compMap.type[i]) || !readUByte(&compMap.pComp[i])) {
                    error(errSyntaxError, getPos(), "Unexpected EOF in JPX stream");
                    return false;
                }
            }
            haveCompMap = true;
            break;
        case 0x63646566: // channel definition
            cover(14);
            if (!readUWord(&channelDefn.nChannels)) {
                error(errSyntaxError, getPos(), "Unexpected EOF in JPX stream");
                return false;
            }
            channelDefn.idx = (unsigned int *)gmallocn(channelDefn.nChannels, sizeof(unsigned int));
            channelDefn.type = (unsigned int *)gmallocn(channelDefn.nChannels, sizeof(unsigned int));
            channelDefn.assoc = (unsigned int *)gmallocn(channelDefn.nChannels, sizeof(unsigned int));
            for (i = 0; i < channelDefn.nChannels; ++i) {
                if (!readUWord(&channelDefn.idx[i]) || !readUWord(&channelDefn.type[i]) || !readUWord(&channelDefn.assoc[i])) {
                    error(errSyntaxError, getPos(), "Unexpected EOF in JPX stream");
                    return false;
                }
            }
            haveChannelDefn = true;
            break;
        case 0x6A703263: // contiguous codestream
            cover(15);
            if (!bpc) {
                error(errSyntaxError, getPos(), "JPX stream is missing the image header box");
            }
            if (!haveCS) {
                error(errSyntaxError, getPos(), "JPX stream has no supported color spec");
            }
            if (!readCodestream(dataLen)) {
                return false;
            }
            break;
        default:
            cover(16);
            for (i = 0; i < dataLen; ++i) {
                if (bufStr->getChar() == EOF) {
                    error(errSyntaxError, getPos(), "Unexpected EOF in JPX stream");
                    return false;
                }
            }
            break;
        }
    }
    return true;
}

bool JPXStream::readColorSpecBox(unsigned int dataLen)
{
    JPXColorSpec newCS;
    unsigned int csApprox, csEnum;
    unsigned int i;
    bool ok;

    ok = false;
    if (!readUByte(&newCS.meth) || !readByte(&newCS.prec) || !readUByte(&csApprox)) {
        goto err;
    }
    switch (newCS.meth) {
    case 1: // enumerated colorspace
        cover(17);
        if (!readULong(&csEnum)) {
            goto err;
        }
        newCS.enumerated.type = (JPXColorSpaceType)csEnum;
        switch (newCS.enumerated.type) {
        case jpxCSBiLevel:
            ok = true;
            break;
        case jpxCSYCbCr1:
            ok = true;
            break;
        case jpxCSYCbCr2:
            ok = true;
            break;
        case jpxCSYCBCr3:
            ok = true;
            break;
        case jpxCSPhotoYCC:
            ok = true;
            break;
        case jpxCSCMY:
            ok = true;
            break;
        case jpxCSCMYK:
            ok = true;
            break;
        case jpxCSYCCK:
            ok = true;
            break;
        case jpxCSCIELab:
            if (dataLen == 7 + 7 * 4) {
                if (!readULong(&newCS.enumerated.cieLab.rl) || !readULong(&newCS.enumerated.cieLab.ol) || !readULong(&newCS.enumerated.cieLab.ra) || !readULong(&newCS.enumerated.cieLab.oa) || !readULong(&newCS.enumerated.cieLab.rb)
                    || !readULong(&newCS.enumerated.cieLab.ob) || !readULong(&newCS.enumerated.cieLab.il)) {
                    goto err;
                }
            } else if (dataLen == 7) {
                //~ this assumes the 8-bit case
                cover(92);
                newCS.enumerated.cieLab.rl = 100;
                newCS.enumerated.cieLab.ol = 0;
                newCS.enumerated.cieLab.ra = 255;
                newCS.enumerated.cieLab.oa = 128;
                newCS.enumerated.cieLab.rb = 255;
                newCS.enumerated.cieLab.ob = 96;
                newCS.enumerated.cieLab.il = 0x00443530;
            } else {
                goto err;
            }
            ok = true;
            break;
        case jpxCSsRGB:
            ok = true;
            break;
        case jpxCSGrayscale:
            ok = true;
            break;
        case jpxCSBiLevel2:
            ok = true;
            break;
        case jpxCSCIEJab:
            // not allowed in PDF
            goto err;
        case jpxCSCISesRGB:
            ok = true;
            break;
        case jpxCSROMMRGB:
            ok = true;
            break;
        case jpxCSsRGBYCbCr:
            ok = true;
            break;
        case jpxCSYPbPr1125:
            ok = true;
            break;
        case jpxCSYPbPr1250:
            ok = true;
            break;
        default:
            goto err;
        }
        break;
    case 2: // restricted ICC profile
    case 3: // any ICC profile (JPX)
    case 4: // vendor color (JPX)
        cover(18);
        for (i = 0; i < dataLen - 3; ++i) {
            if (bufStr->getChar() == EOF) {
                goto err;
            }
        }
        break;
    }

    if (ok && (!haveCS || newCS.prec > cs.prec)) {
        cs = newCS;
        haveCS = true;
    }

    return true;

err:
    error(errSyntaxError, getPos(), "Error in JPX color spec");
    return false;
}

bool JPXStream::readCodestream(unsigned int len)
{
    JPXTile *tile;
    JPXTileComp *tileComp;
    int segType;
    bool haveSIZ, haveCOD, haveQCD, haveSOT;
    unsigned int precinctSize, style, nDecompLevels;
    unsigned int segLen, capabilities, comp, i, j, r;

    //----- main header
    haveSIZ = haveCOD = haveQCD = haveSOT = false;
    do {
        if (!readMarkerHdr(&segType, &segLen)) {
            error(errSyntaxError, getPos(), "Error in JPX codestream");
            return false;
        }
        switch (segType) {
        case 0x4f: // SOC - start of codestream
            // marker only
            cover(19);
            break;
        case 0x51: // SIZ - image and tile size
            cover(20);
            if (haveSIZ) {
                error(errSyntaxError, getPos(), "Duplicate SIZ marker segment in JPX stream");
                return false;
            }
            if (!readUWord(&capabilities) || !readULong(&img.xSize) || !readULong(&img.ySize) || !readULong(&img.xOffset) || !readULong(&img.yOffset) || !readULong(&img.xTileSize) || !readULong(&img.yTileSize)
                || !readULong(&img.xTileOffset) || !readULong(&img.yTileOffset) || !readUWord(&img.nComps)) {
                error(errSyntaxError, getPos(), "Error in JPX SIZ marker segment");
                return false;
            }
            if (haveImgHdr && img.nComps != nComps) {
                error(errSyntaxError, getPos(), "Different number of components in JPX SIZ marker segment");
                return false;
            }
            if (img.xSize == 0 || img.ySize == 0 || img.xOffset >= img.xSize || img.yOffset >= img.ySize || img.xTileSize == 0 || img.yTileSize == 0 || img.xTileOffset > img.xOffset || img.yTileOffset > img.yOffset
                || img.xTileSize + img.xTileOffset <= img.xOffset || img.yTileSize + img.yTileOffset <= img.yOffset) {
                error(errSyntaxError, getPos(), "Error in JPX SIZ marker segment");
                return false;
            }
            img.nXTiles = (img.xSize - img.xTileOffset + img.xTileSize - 1) / img.xTileSize;
            img.nYTiles = (img.ySize - img.yTileOffset + img.yTileSize - 1) / img.yTileSize;
            // check for overflow before allocating memory
            if (img.nXTiles <= 0 || img.nYTiles <= 0 || img.nXTiles >= 65535 / img.nYTiles) {
                error(errSyntaxError, getPos(), "Bad tile count in JPX SIZ marker segment");
                return false;
            }
            img.tiles = (JPXTile *)gmallocn(img.nXTiles * img.nYTiles, sizeof(JPXTile));
            for (i = 0; i < img.nXTiles * img.nYTiles; ++i) {
                img.tiles[i].init = false;
                img.tiles[i].tileComps = (JPXTileComp *)gmallocn(img.nComps, sizeof(JPXTileComp));
                for (comp = 0; comp < img.nComps; ++comp) {
                    img.tiles[i].tileComps[comp].quantSteps = nullptr;
                    img.tiles[i].tileComps[comp].data = nullptr;
                    img.tiles[i].tileComps[comp].buf = nullptr;
                    img.tiles[i].tileComps[comp].resLevels = nullptr;
                }
            }
            for (comp = 0; comp < img.nComps; ++comp) {
                if (!readUByte(&img.tiles[0].tileComps[comp].prec) || !readUByte(&img.tiles[0].tileComps[comp].hSep) || !readUByte(&img.tiles[0].tileComps[comp].vSep)) {
                    error(errSyntaxError, getPos(), "Error in JPX SIZ marker segment");
                    return false;
                }
                if (img.tiles[0].tileComps[comp].hSep == 0 || img.tiles[0].tileComps[comp].vSep == 0) {
                    error(errSyntaxError, getPos(), "Error in JPX SIZ marker segment");
                    return false;
                }
                img.tiles[0].tileComps[comp].sgned = (img.tiles[0].tileComps[comp].prec & 0x80) ? true : false;
                img.tiles[0].tileComps[comp].prec = (img.tiles[0].tileComps[comp].prec & 0x7f) + 1;
                for (i = 1; i < img.nXTiles * img.nYTiles; ++i) {
                    img.tiles[i].tileComps[comp] = img.tiles[0].tileComps[comp];
                }
            }
            haveSIZ = true;
            break;
        case 0x52: // COD - coding style default
            cover(21);
            if (!haveSIZ) {
                error(errSyntaxError, getPos(), "JPX COD marker segment before SIZ segment");
                return false;
            }
            if (img.tiles == nullptr || img.nXTiles * img.nYTiles == 0 || img.tiles[0].tileComps == nullptr) {
                error(errSyntaxError, getPos(), "Error in JPX COD marker segment");
                return false;
            }
            if (!readUByte(&img.tiles[0].tileComps[0].style) || !readUByte(&img.tiles[0].progOrder) || !readUWord(&img.tiles[0].nLayers) || !readUByte(&img.tiles[0].multiComp) || !readUByte(&nDecompLevels)
                || !readUByte(&img.tiles[0].tileComps[0].codeBlockW) || !readUByte(&img.tiles[0].tileComps[0].codeBlockH) || !readUByte(&img.tiles[0].tileComps[0].codeBlockStyle) || !readUByte(&img.tiles[0].tileComps[0].transform)) {
                error(errSyntaxError, getPos(), "Error in JPX COD marker segment");
                return false;
            }
            if (nDecompLevels > 32 || img.tiles[0].tileComps[0].codeBlockW > 8 || img.tiles[0].tileComps[0].codeBlockH > 8) {
                error(errSyntaxError, getPos(), "Error in JPX COD marker segment");
                return false;
            }
            img.tiles[0].tileComps[0].nDecompLevels = nDecompLevels;
            img.tiles[0].tileComps[0].codeBlockW += 2;
            img.tiles[0].tileComps[0].codeBlockH += 2;
            for (i = 0; i < img.nXTiles * img.nYTiles; ++i) {
                if (i != 0) {
                    img.tiles[i].progOrder = img.tiles[0].progOrder;
                    img.tiles[i].nLayers = img.tiles[0].nLayers;
                    img.tiles[i].multiComp = img.tiles[0].multiComp;
                }
                for (comp = 0; comp < img.nComps; ++comp) {
                    if (!(i == 0 && comp == 0)) {
                        img.tiles[i].tileComps[comp].style = img.tiles[0].tileComps[0].style;
                        img.tiles[i].tileComps[comp].nDecompLevels = img.tiles[0].tileComps[0].nDecompLevels;
                        img.tiles[i].tileComps[comp].codeBlockW = img.tiles[0].tileComps[0].codeBlockW;
                        img.tiles[i].tileComps[comp].codeBlockH = img.tiles[0].tileComps[0].codeBlockH;
                        img.tiles[i].tileComps[comp].codeBlockStyle = img.tiles[0].tileComps[0].codeBlockStyle;
                        img.tiles[i].tileComps[comp].transform = img.tiles[0].tileComps[0].transform;
                    }
                    img.tiles[i].tileComps[comp].resLevels = (JPXResLevel *)gmallocn_checkoverflow((img.tiles[i].tileComps[comp].nDecompLevels + 1), sizeof(JPXResLevel));
                    if (img.tiles[i].tileComps[comp].resLevels == nullptr) {
                        error(errSyntaxError, getPos(), "Error in JPX COD marker segment");
                        return false;
                    }
                    for (r = 0; r <= img.tiles[i].tileComps[comp].nDecompLevels; ++r) {
                        img.tiles[i].tileComps[comp].resLevels[r].precincts = nullptr;
                    }
                }
            }
            for (r = 0; r <= img.tiles[0].tileComps[0].nDecompLevels; ++r) {
                if (img.tiles[0].tileComps[0].style & 0x01) {
                    cover(91);
                    if (!readUByte(&precinctSize)) {
                        error(errSyntaxError, getPos(), "Error in JPX COD marker segment");
                        return false;
                    }
                    img.tiles[0].tileComps[0].resLevels[r].precinctWidth = precinctSize & 0x0f;
                    img.tiles[0].tileComps[0].resLevels[r].precinctHeight = (precinctSize >> 4) & 0x0f;
                } else {
                    img.tiles[0].tileComps[0].resLevels[r].precinctWidth = 15;
                    img.tiles[0].tileComps[0].resLevels[r].precinctHeight = 15;
                }
            }
            for (i = 0; i < img.nXTiles * img.nYTiles; ++i) {
                for (comp = 0; comp < img.nComps; ++comp) {
                    if (!(i == 0 && comp == 0)) {
                        for (r = 0; r <= img.tiles[i].tileComps[comp].nDecompLevels; ++r) {
                            img.tiles[i].tileComps[comp].resLevels[r].precinctWidth = img.tiles[0].tileComps[0].resLevels[r].precinctWidth;
                            img.tiles[i].tileComps[comp].resLevels[r].precinctHeight = img.tiles[0].tileComps[0].resLevels[r].precinctHeight;
                        }
                    }
                }
            }
            haveCOD = true;
            break;
        case 0x53: // COC - coding style component
            cover(22);
            if (!haveCOD) {
                error(errSyntaxError, getPos(), "JPX COC marker segment before COD segment");
                return false;
            }
            if ((img.nComps > 256 && !readUWord(&comp)) || (img.nComps <= 256 && !readUByte(&comp)) || comp >= img.nComps || !readUByte(&style) || !readUByte(&nDecompLevels) || !readUByte(&img.tiles[0].tileComps[comp].codeBlockW)
                || !readUByte(&img.tiles[0].tileComps[comp].codeBlockH) || !readUByte(&img.tiles[0].tileComps[comp].codeBlockStyle) || !readUByte(&img.tiles[0].tileComps[comp].transform)) {
                error(errSyntaxError, getPos(), "Error in JPX COC marker segment");
                return false;
            }
            if (nDecompLevels > 32 || img.tiles[0].tileComps[comp].codeBlockW > 8 || img.tiles[0].tileComps[comp].codeBlockH > 8) {
                error(errSyntaxError, getPos(), "Error in JPX COC marker segment");
                return false;
            }
            img.tiles[0].tileComps[comp].nDecompLevels = nDecompLevels;
            img.tiles[0].tileComps[comp].style = (img.tiles[0].tileComps[comp].style & ~1) | (style & 1);
            img.tiles[0].tileComps[comp].codeBlockW += 2;
            img.tiles[0].tileComps[comp].codeBlockH += 2;
            for (i = 0; i < img.nXTiles * img.nYTiles; ++i) {
                if (i != 0) {
                    img.tiles[i].tileComps[comp].style = img.tiles[0].tileComps[comp].style;
                    img.tiles[i].tileComps[comp].nDecompLevels = img.tiles[0].tileComps[comp].nDecompLevels;
                    img.tiles[i].tileComps[comp].codeBlockW = img.tiles[0].tileComps[comp].codeBlockW;
                    img.tiles[i].tileComps[comp].codeBlockH = img.tiles[0].tileComps[comp].codeBlockH;
                    img.tiles[i].tileComps[comp].codeBlockStyle = img.tiles[0].tileComps[comp].codeBlockStyle;
                    img.tiles[i].tileComps[comp].transform = img.tiles[0].tileComps[comp].transform;
                }
                img.tiles[i].tileComps[comp].resLevels = (JPXResLevel *)greallocn(img.tiles[i].tileComps[comp].resLevels, (img.tiles[i].tileComps[comp].nDecompLevels + 1), sizeof(JPXResLevel));
                for (r = 0; r <= img.tiles[i].tileComps[comp].nDecompLevels; ++r) {
                    img.tiles[i].tileComps[comp].resLevels[r].precincts = nullptr;
                }
            }
            for (r = 0; r <= img.tiles[0].tileComps[comp].nDecompLevels; ++r) {
                if (img.tiles[0].tileComps[comp].style & 0x01) {
                    if (!readUByte(&precinctSize)) {
                        error(errSyntaxError, getPos(), "Error in JPX COD marker segment");
                        return false;
                    }
                    img.tiles[0].tileComps[comp].resLevels[r].precinctWidth = precinctSize & 0x0f;
                    img.tiles[0].tileComps[comp].resLevels[r].precinctHeight = (precinctSize >> 4) & 0x0f;
                } else {
                    img.tiles[0].tileComps[comp].resLevels[r].precinctWidth = 15;
                    img.tiles[0].tileComps[comp].resLevels[r].precinctHeight = 15;
                }
            }
            for (i = 1; i < img.nXTiles * img.nYTiles; ++i) {
                for (r = 0; r <= img.tiles[i].tileComps[comp].nDecompLevels; ++r) {
                    img.tiles[i].tileComps[comp].resLevels[r].precinctWidth = img.tiles[0].tileComps[comp].resLevels[r].precinctWidth;
                    img.tiles[i].tileComps[comp].resLevels[r].precinctHeight = img.tiles[0].tileComps[comp].resLevels[r].precinctHeight;
                }
            }
            break;
        case 0x5c: // QCD - quantization default
            cover(23);
            if (!haveSIZ) {
                error(errSyntaxError, getPos(), "JPX QCD marker segment before SIZ segment");
                return false;
            }
            if (!readUByte(&img.tiles[0].tileComps[0].quantStyle)) {
                error(errSyntaxError, getPos(), "Error in JPX QCD marker segment");
                return false;
            }
            if ((img.tiles[0].tileComps[0].quantStyle & 0x1f) == 0x00) {
                if (segLen <= 3) {
                    error(errSyntaxError, getPos(), "Error in JPX QCD marker segment");
                    return false;
                }
                img.tiles[0].tileComps[0].nQuantSteps = segLen - 3;
                img.tiles[0].tileComps[0].quantSteps = (unsigned int *)greallocn(img.tiles[0].tileComps[0].quantSteps, img.tiles[0].tileComps[0].nQuantSteps, sizeof(unsigned int));
                for (i = 0; i < img.tiles[0].tileComps[0].nQuantSteps; ++i) {
                    if (!readUByte(&img.tiles[0].tileComps[0].quantSteps[i])) {
                        error(errSyntaxError, getPos(), "Error in JPX QCD marker segment");
                        return false;
                    }
                }
            } else if ((img.tiles[0].tileComps[0].quantStyle & 0x1f) == 0x01) {
                img.tiles[0].tileComps[0].nQuantSteps = 1;
                img.tiles[0].tileComps[0].quantSteps = (unsigned int *)greallocn(img.tiles[0].tileComps[0].quantSteps, img.tiles[0].tileComps[0].nQuantSteps, sizeof(unsigned int));
                if (!readUWord(&img.tiles[0].tileComps[0].quantSteps[0])) {
                    error(errSyntaxError, getPos(), "Error in JPX QCD marker segment");
                    return false;
                }
            } else if ((img.tiles[0].tileComps[0].quantStyle & 0x1f) == 0x02) {
                if (segLen < 5) {
                    error(errSyntaxError, getPos(), "Error in JPX QCD marker segment");
                    return false;
                }
                img.tiles[0].tileComps[0].nQuantSteps = (segLen - 3) / 2;
                img.tiles[0].tileComps[0].quantSteps = (unsigned int *)greallocn(img.tiles[0].tileComps[0].quantSteps, img.tiles[0].tileComps[0].nQuantSteps, sizeof(unsigned int));
                for (i = 0; i < img.tiles[0].tileComps[0].nQuantSteps; ++i) {
                    if (!readUWord(&img.tiles[0].tileComps[0].quantSteps[i])) {
                        error(errSyntaxError, getPos(), "Error in JPX QCD marker segment");
                        return false;
                    }
                }
            } else {
                error(errSyntaxError, getPos(), "Error in JPX QCD marker segment");
                return false;
            }
            for (i = 0; i < img.nXTiles * img.nYTiles; ++i) {
                for (comp = 0; comp < img.nComps; ++comp) {
                    if (!(i == 0 && comp == 0)) {
                        img.tiles[i].tileComps[comp].quantStyle = img.tiles[0].tileComps[0].quantStyle;
                        img.tiles[i].tileComps[comp].nQuantSteps = img.tiles[0].tileComps[0].nQuantSteps;
                        img.tiles[i].tileComps[comp].quantSteps = (unsigned int *)greallocn(img.tiles[i].tileComps[comp].quantSteps, img.tiles[0].tileComps[0].nQuantSteps, sizeof(unsigned int));
                        for (j = 0; j < img.tiles[0].tileComps[0].nQuantSteps; ++j) {
                            img.tiles[i].tileComps[comp].quantSteps[j] = img.tiles[0].tileComps[0].quantSteps[j];
                        }
                    }
                }
            }
            haveQCD = true;
            break;
        case 0x5d: // QCC - quantization component
            cover(24);
            if (!haveQCD) {
                error(errSyntaxError, getPos(), "JPX QCC marker segment before QCD segment");
                return false;
            }
            if ((img.nComps > 256 && !readUWord(&comp)) || (img.nComps <= 256 && !readUByte(&comp)) || comp >= img.nComps || !readUByte(&img.tiles[0].tileComps[comp].quantStyle)) {
                error(errSyntaxError, getPos(), "Error in JPX QCC marker segment");
                return false;
            }
            if ((img.tiles[0].tileComps[comp].quantStyle & 0x1f) == 0x00) {
                if (segLen <= (img.nComps > 256 ? 5U : 4U)) {
                    error(errSyntaxError, getPos(), "Error in JPX QCC marker segment");
                    return false;
                }
                img.tiles[0].tileComps[comp].nQuantSteps = segLen - (img.nComps > 256 ? 5 : 4);
                img.tiles[0].tileComps[comp].quantSteps = (unsigned int *)greallocn(img.tiles[0].tileComps[comp].quantSteps, img.tiles[0].tileComps[comp].nQuantSteps, sizeof(unsigned int));
                for (i = 0; i < img.tiles[0].tileComps[comp].nQuantSteps; ++i) {
                    if (!readUByte(&img.tiles[0].tileComps[comp].quantSteps[i])) {
                        error(errSyntaxError, getPos(), "Error in JPX QCC marker segment");
                        return false;
                    }
                }
            } else if ((img.tiles[0].tileComps[comp].quantStyle & 0x1f) == 0x01) {
                img.tiles[0].tileComps[comp].nQuantSteps = 1;
                img.tiles[0].tileComps[comp].quantSteps = (unsigned int *)greallocn(img.tiles[0].tileComps[comp].quantSteps, img.tiles[0].tileComps[comp].nQuantSteps, sizeof(unsigned int));
                if (!readUWord(&img.tiles[0].tileComps[comp].quantSteps[0])) {
                    error(errSyntaxError, getPos(), "Error in JPX QCC marker segment");
                    return false;
                }
            } else if ((img.tiles[0].tileComps[comp].quantStyle & 0x1f) == 0x02) {
                if (segLen < (img.nComps > 256 ? 5U : 4U) + 2) {
                    error(errSyntaxError, getPos(), "Error in JPX QCC marker segment");
                    return false;
                }
                img.tiles[0].tileComps[comp].nQuantSteps = (segLen - (img.nComps > 256 ? 5 : 4)) / 2;
                img.tiles[0].tileComps[comp].quantSteps = (unsigned int *)greallocn(img.tiles[0].tileComps[comp].quantSteps, img.tiles[0].tileComps[comp].nQuantSteps, sizeof(unsigned int));
                for (i = 0; i < img.tiles[0].tileComps[comp].nQuantSteps; ++i) {
                    if (!readUWord(&img.tiles[0].tileComps[comp].quantSteps[i])) {
                        error(errSyntaxError, getPos(), "Error in JPX QCD marker segment");
                        return false;
                    }
                }
            } else {
                error(errSyntaxError, getPos(), "Error in JPX QCC marker segment");
                return false;
            }
            for (i = 1; i < img.nXTiles * img.nYTiles; ++i) {
                img.tiles[i].tileComps[comp].quantStyle = img.tiles[0].tileComps[comp].quantStyle;
                img.tiles[i].tileComps[comp].nQuantSteps = img.tiles[0].tileComps[comp].nQuantSteps;
                img.tiles[i].tileComps[comp].quantSteps = (unsigned int *)greallocn(img.tiles[i].tileComps[comp].quantSteps, img.tiles[0].tileComps[comp].nQuantSteps, sizeof(unsigned int));
                for (j = 0; j < img.tiles[0].tileComps[comp].nQuantSteps; ++j) {
                    img.tiles[i].tileComps[comp].quantSteps[j] = img.tiles[0].tileComps[comp].quantSteps[j];
                }
            }
            break;
        case 0x5e: // RGN - region of interest
            cover(25);
#if 1 //~ ROI is unimplemented
            error(errUnimplemented, -1, "got a JPX RGN segment");
            for (i = 0; i < segLen - 2; ++i) {
                if (bufStr->getChar() == EOF) {
                    error(errSyntaxError, getPos(), "Error in JPX RGN marker segment");
                    return false;
                }
            }
#else
            if ((img.nComps > 256 && !readUWord(&comp)) || (img.nComps <= 256 && !readUByte(&comp)) || comp >= img.nComps || !readUByte(&compInfo[comp].defROI.style) || !readUByte(&compInfo[comp].defROI.shift)) {
                error(errSyntaxError, getPos(), "Error in JPX RGN marker segment");
                return false;
            }
#endif
            break;
        case 0x5f: // POC - progression order change
            cover(26);
#if 1 //~ progression order changes are unimplemented
            error(errUnimplemented, -1, "got a JPX POC segment");
            for (i = 0; i < segLen - 2; ++i) {
                if (bufStr->getChar() == EOF) {
                    error(errSyntaxError, getPos(), "Error in JPX POC marker segment");
                    return false;
                }
            }
#else
            nProgs = (segLen - 2) / (img.nComps > 256 ? 9 : 7);
            progs = (JPXProgOrder *)gmallocn(nProgs, sizeof(JPXProgOrder));
            for (i = 0; i < nProgs; ++i) {
                if (!readUByte(&progs[i].startRes) || !(img.nComps > 256 && readUWord(&progs[i].startComp)) || !(img.nComps <= 256 && readUByte(&progs[i].startComp)) || !readUWord(&progs[i].endLayer) || !readUByte(&progs[i].endRes)
                    || !(img.nComps > 256 && readUWord(&progs[i].endComp)) || !(img.nComps <= 256 && readUByte(&progs[i].endComp)) || !readUByte(&progs[i].progOrder)) {
                    error(errSyntaxError, getPos(), "Error in JPX POC marker segment");
                    return false;
                }
            }
#endif
            break;
        case 0x60: // PPM - packed packet headers, main header
            cover(27);
#if 1 //~ packed packet headers are unimplemented
            error(errUnimplemented, -1, "Got a JPX PPM segment");
            for (i = 0; i < segLen - 2; ++i) {
                if (bufStr->getChar() == EOF) {
                    error(errSyntaxError, getPos(), "Error in JPX PPM marker segment");
                    return false;
                }
            }
#endif
            break;
        case 0x55: // TLM - tile-part lengths
            // skipped
            cover(28);
            for (i = 0; i < segLen - 2; ++i) {
                if (bufStr->getChar() == EOF) {
                    error(errSyntaxError, getPos(), "Error in JPX TLM marker segment");
                    return false;
                }
            }
            break;
        case 0x57: // PLM - packet length, main header
            // skipped
            cover(29);
            for (i = 0; i < segLen - 2; ++i) {
                if (bufStr->getChar() == EOF) {
                    error(errSyntaxError, getPos(), "Error in JPX PLM marker segment");
                    return false;
                }
            }
            break;
        case 0x63: // CRG - component registration
            // skipped
            cover(30);
            for (i = 0; i < segLen - 2; ++i) {
                if (bufStr->getChar() == EOF) {
                    error(errSyntaxError, getPos(), "Error in JPX CRG marker segment");
                    return false;
                }
            }
            break;
        case 0x64: // COM - comment
            // skipped
            cover(31);
            for (i = 0; i < segLen - 2; ++i) {
                if (bufStr->getChar() == EOF) {
                    error(errSyntaxError, getPos(), "Error in JPX COM marker segment");
                    return false;
                }
            }
            break;
        case 0x90: // SOT - start of tile
            cover(32);
            haveSOT = true;
            break;
        default:
            cover(33);
            error(errSyntaxError, getPos(), "Unknown marker segment {0:02x} in JPX stream", segType);
            for (i = 0; i < segLen - 2; ++i) {
                if (bufStr->getChar() == EOF) {
                    break;
                }
            }
            break;
        }
    } while (!haveSOT);

    if (!haveSIZ) {
        error(errSyntaxError, getPos(), "Missing SIZ marker segment in JPX stream");
        return false;
    }
    if (!haveCOD) {
        error(errSyntaxError, getPos(), "Missing COD marker segment in JPX stream");
        return false;
    }
    if (!haveQCD) {
        error(errSyntaxError, getPos(), "Missing QCD marker segment in JPX stream");
        return false;
    }

    //----- read the tile-parts
    while (1) {
        if (!readTilePart()) {
            return false;
        }
        if (!readMarkerHdr(&segType, &segLen)) {
            error(errSyntaxError, getPos(), "Error in JPX codestream");
            return false;
        }
        if (segType != 0x90) { // SOT - start of tile
            break;
        }
    }

    if (segType != 0xd9) { // EOC - end of codestream
        error(errSyntaxError, getPos(), "Missing EOC marker in JPX codestream");
        return false;
    }

    //----- finish decoding the image
    for (i = 0; i < img.nXTiles * img.nYTiles; ++i) {
        tile = &img.tiles[i];
        if (!tile->init) {
            error(errSyntaxError, getPos(), "Uninitialized tile in JPX codestream");
            return false;
        }
        for (comp = 0; comp < img.nComps; ++comp) {
            tileComp = &tile->tileComps[comp];
            inverseTransform(tileComp);
        }
        if (!inverseMultiCompAndDC(tile)) {
            return false;
        }
    }

    //~ can free memory below tileComps here, and also tileComp.buf

    return true;
}

bool JPXStream::readTilePart()
{
    JPXTile *tile;
    JPXTileComp *tileComp;
    JPXResLevel *resLevel;
    JPXPrecinct *precinct;
    JPXSubband *subband;
    JPXCodeBlock *cb;
    int *sbCoeffs;
    bool haveSOD;
    unsigned int tileIdx, tilePartLen, tilePartIdx, nTileParts;
    bool tilePartToEOC;
    unsigned int precinctSize, style, nDecompLevels;
    unsigned int n, nSBs, nx, ny, sbx0, sby0, comp, segLen;
    unsigned int i, j, k, cbX, cbY, r, pre, sb, cbi, cbj;
    int segType, level;

    // process the SOT marker segment
    if (!readUWord(&tileIdx) || !readULong(&tilePartLen) || !readUByte(&tilePartIdx) || !readUByte(&nTileParts)) {
        error(errSyntaxError, getPos(), "Error in JPX SOT marker segment");
        return false;
    }

    if (tileIdx >= img.nXTiles * img.nYTiles || (tilePartIdx > 0 && !img.tiles[tileIdx].init)) {
        error(errSyntaxError, getPos(), "Weird tile index in JPX stream");
        return false;
    }

    tilePartToEOC = tilePartLen == 0;
    tilePartLen -= 12; // subtract size of SOT segment

    haveSOD = false;
    do {
        if (!readMarkerHdr(&segType, &segLen)) {
            error(errSyntaxError, getPos(), "Error in JPX tile-part codestream");
            return false;
        }
        tilePartLen -= 2 + segLen;
        switch (segType) {
        case 0x52: // COD - coding style default
            cover(34);
            if (!readUByte(&img.tiles[tileIdx].tileComps[0].style) || !readUByte(&img.tiles[tileIdx].progOrder) || !readUWord(&img.tiles[tileIdx].nLayers) || !readUByte(&img.tiles[tileIdx].multiComp) || !readUByte(&nDecompLevels)
                || !readUByte(&img.tiles[tileIdx].tileComps[0].codeBlockW) || !readUByte(&img.tiles[tileIdx].tileComps[0].codeBlockH) || !readUByte(&img.tiles[tileIdx].tileComps[0].codeBlockStyle)
                || !readUByte(&img.tiles[tileIdx].tileComps[0].transform)) {
                error(errSyntaxError, getPos(), "Error in JPX COD marker segment");
                return false;
            }
            if (nDecompLevels > 32 || img.tiles[tileIdx].tileComps[0].codeBlockW > 8 || img.tiles[tileIdx].tileComps[0].codeBlockH > 8) {
                error(errSyntaxError, getPos(), "Error in JPX COD marker segment");
                return false;
            }
            img.tiles[tileIdx].tileComps[0].nDecompLevels = nDecompLevels;
            img.tiles[tileIdx].tileComps[0].codeBlockW += 2;
            img.tiles[tileIdx].tileComps[0].codeBlockH += 2;
            for (comp = 0; comp < img.nComps; ++comp) {
                if (comp != 0) {
                    img.tiles[tileIdx].tileComps[comp].style = img.tiles[tileIdx].tileComps[0].style;
                    img.tiles[tileIdx].tileComps[comp].nDecompLevels = img.tiles[tileIdx].tileComps[0].nDecompLevels;
                    img.tiles[tileIdx].tileComps[comp].codeBlockW = img.tiles[tileIdx].tileComps[0].codeBlockW;
                    img.tiles[tileIdx].tileComps[comp].codeBlockH = img.tiles[tileIdx].tileComps[0].codeBlockH;
                    img.tiles[tileIdx].tileComps[comp].codeBlockStyle = img.tiles[tileIdx].tileComps[0].codeBlockStyle;
                    img.tiles[tileIdx].tileComps[comp].transform = img.tiles[tileIdx].tileComps[0].transform;
                }
                img.tiles[tileIdx].tileComps[comp].resLevels = (JPXResLevel *)greallocn(img.tiles[tileIdx].tileComps[comp].resLevels, (img.tiles[tileIdx].tileComps[comp].nDecompLevels + 1), sizeof(JPXResLevel));
                for (r = 0; r <= img.tiles[tileIdx].tileComps[comp].nDecompLevels; ++r) {
                    img.tiles[tileIdx].tileComps[comp].resLevels[r].precincts = nullptr;
                }
            }
            for (r = 0; r <= img.tiles[tileIdx].tileComps[0].nDecompLevels; ++r) {
                if (img.tiles[tileIdx].tileComps[0].style & 0x01) {
                    if (!readUByte(&precinctSize)) {
                        error(errSyntaxError, getPos(), "Error in JPX COD marker segment");
                        return false;
                    }
                    img.tiles[tileIdx].tileComps[0].resLevels[r].precinctWidth = precinctSize & 0x0f;
                    img.tiles[tileIdx].tileComps[0].resLevels[r].precinctHeight = (precinctSize >> 4) & 0x0f;
                } else {
                    img.tiles[tileIdx].tileComps[0].resLevels[r].precinctWidth = 15;
                    img.tiles[tileIdx].tileComps[0].resLevels[r].precinctHeight = 15;
                }
            }
            for (comp = 1; comp < img.nComps; ++comp) {
                for (r = 0; r <= img.tiles[tileIdx].tileComps[comp].nDecompLevels; ++r) {
                    img.tiles[tileIdx].tileComps[comp].resLevels[r].precinctWidth = img.tiles[tileIdx].tileComps[0].resLevels[r].precinctWidth;
                    img.tiles[tileIdx].tileComps[comp].resLevels[r].precinctHeight = img.tiles[tileIdx].tileComps[0].resLevels[r].precinctHeight;
                }
            }
            break;
        case 0x53: // COC - coding style component
            cover(35);
            if ((img.nComps > 256 && !readUWord(&comp)) || (img.nComps <= 256 && !readUByte(&comp)) || comp >= img.nComps || !readUByte(&style) || !readUByte(&nDecompLevels) || !readUByte(&img.tiles[tileIdx].tileComps[comp].codeBlockW)
                || !readUByte(&img.tiles[tileIdx].tileComps[comp].codeBlockH) || !readUByte(&img.tiles[tileIdx].tileComps[comp].codeBlockStyle) || !readUByte(&img.tiles[tileIdx].tileComps[comp].transform)) {
                error(errSyntaxError, getPos(), "Error in JPX COC marker segment");
                return false;
            }
            if (nDecompLevels > 32 || img.tiles[tileIdx].tileComps[comp].codeBlockW > 8 || img.tiles[tileIdx].tileComps[comp].codeBlockH > 8) {
                error(errSyntaxError, getPos(), "Error in JPX COD marker segment");
                return false;
            }
            img.tiles[tileIdx].tileComps[comp].nDecompLevels = nDecompLevels;
            img.tiles[tileIdx].tileComps[comp].style = (img.tiles[tileIdx].tileComps[comp].style & ~1) | (style & 1);
            img.tiles[tileIdx].tileComps[comp].codeBlockW += 2;
            img.tiles[tileIdx].tileComps[comp].codeBlockH += 2;
            img.tiles[tileIdx].tileComps[comp].resLevels = (JPXResLevel *)greallocn(img.tiles[tileIdx].tileComps[comp].resLevels, (img.tiles[tileIdx].tileComps[comp].nDecompLevels + 1), sizeof(JPXResLevel));
            for (r = 0; r <= img.tiles[tileIdx].tileComps[comp].nDecompLevels; ++r) {
                img.tiles[tileIdx].tileComps[comp].resLevels[r].precincts = nullptr;
            }
            for (r = 0; r <= img.tiles[tileIdx].tileComps[comp].nDecompLevels; ++r) {
                if (img.tiles[tileIdx].tileComps[comp].style & 0x01) {
                    if (!readUByte(&precinctSize)) {
                        error(errSyntaxError, getPos(), "Error in JPX COD marker segment");
                        return false;
                    }
                    img.tiles[tileIdx].tileComps[comp].resLevels[r].precinctWidth = precinctSize & 0x0f;
                    img.tiles[tileIdx].tileComps[comp].resLevels[r].precinctHeight = (precinctSize >> 4) & 0x0f;
                } else {
                    img.tiles[tileIdx].tileComps[comp].resLevels[r].precinctWidth = 15;
                    img.tiles[tileIdx].tileComps[comp].resLevels[r].precinctHeight = 15;
                }
            }
            break;
        case 0x5c: // QCD - quantization default
            cover(36);
            if (!readUByte(&img.tiles[tileIdx].tileComps[0].quantStyle)) {
                error(errSyntaxError, getPos(), "Error in JPX QCD marker segment");
                return false;
            }
            if ((img.tiles[tileIdx].tileComps[0].quantStyle & 0x1f) == 0x00) {
                if (segLen <= 3) {
                    error(errSyntaxError, getPos(), "Error in JPX QCD marker segment");
                    return false;
                }
                img.tiles[tileIdx].tileComps[0].nQuantSteps = segLen - 3;
                img.tiles[tileIdx].tileComps[0].quantSteps = (unsigned int *)greallocn(img.tiles[tileIdx].tileComps[0].quantSteps, img.tiles[tileIdx].tileComps[0].nQuantSteps, sizeof(unsigned int));
                for (i = 0; i < img.tiles[tileIdx].tileComps[0].nQuantSteps; ++i) {
                    if (!readUByte(&img.tiles[tileIdx].tileComps[0].quantSteps[i])) {
                        error(errSyntaxError, getPos(), "Error in JPX QCD marker segment");
                        return false;
                    }
                }
            } else if ((img.tiles[tileIdx].tileComps[0].quantStyle & 0x1f) == 0x01) {
                img.tiles[tileIdx].tileComps[0].nQuantSteps = 1;
                img.tiles[tileIdx].tileComps[0].quantSteps = (unsigned int *)greallocn(img.tiles[tileIdx].tileComps[0].quantSteps, img.tiles[tileIdx].tileComps[0].nQuantSteps, sizeof(unsigned int));
                if (!readUWord(&img.tiles[tileIdx].tileComps[0].quantSteps[0])) {
                    error(errSyntaxError, getPos(), "Error in JPX QCD marker segment");
                    return false;
                }
            } else if ((img.tiles[tileIdx].tileComps[0].quantStyle & 0x1f) == 0x02) {
                if (segLen < 5) {
                    error(errSyntaxError, getPos(), "Error in JPX QCD marker segment");
                    return false;
                }
                img.tiles[tileIdx].tileComps[0].nQuantSteps = (segLen - 3) / 2;
                img.tiles[tileIdx].tileComps[0].quantSteps = (unsigned int *)greallocn(img.tiles[tileIdx].tileComps[0].quantSteps, img.tiles[tileIdx].tileComps[0].nQuantSteps, sizeof(unsigned int));
                for (i = 0; i < img.tiles[tileIdx].tileComps[0].nQuantSteps; ++i) {
                    if (!readUWord(&img.tiles[tileIdx].tileComps[0].quantSteps[i])) {
                        error(errSyntaxError, getPos(), "Error in JPX QCD marker segment");
                        return false;
                    }
                }
            } else {
                error(errSyntaxError, getPos(), "Error in JPX QCD marker segment");
                return false;
            }
            for (comp = 1; comp < img.nComps; ++comp) {
                img.tiles[tileIdx].tileComps[comp].quantStyle = img.tiles[tileIdx].tileComps[0].quantStyle;
                img.tiles[tileIdx].tileComps[comp].nQuantSteps = img.tiles[tileIdx].tileComps[0].nQuantSteps;
                img.tiles[tileIdx].tileComps[comp].quantSteps = (unsigned int *)greallocn(img.tiles[tileIdx].tileComps[comp].quantSteps, img.tiles[tileIdx].tileComps[0].nQuantSteps, sizeof(unsigned int));
                for (j = 0; j < img.tiles[tileIdx].tileComps[0].nQuantSteps; ++j) {
                    img.tiles[tileIdx].tileComps[comp].quantSteps[j] = img.tiles[tileIdx].tileComps[0].quantSteps[j];
                }
            }
            break;
        case 0x5d: // QCC - quantization component
            cover(37);
            if ((img.nComps > 256 && !readUWord(&comp)) || (img.nComps <= 256 && !readUByte(&comp)) || comp >= img.nComps || !readUByte(&img.tiles[tileIdx].tileComps[comp].quantStyle)) {
                error(errSyntaxError, getPos(), "Error in JPX QCC marker segment");
                return false;
            }
            if ((img.tiles[tileIdx].tileComps[comp].quantStyle & 0x1f) == 0x00) {
                if (segLen <= (img.nComps > 256 ? 5U : 4U)) {
                    error(errSyntaxError, getPos(), "Error in JPX QCC marker segment");
                    return false;
                }
                img.tiles[tileIdx].tileComps[comp].nQuantSteps = segLen - (img.nComps > 256 ? 5 : 4);
                img.tiles[tileIdx].tileComps[comp].quantSteps = (unsigned int *)greallocn(img.tiles[tileIdx].tileComps[comp].quantSteps, img.tiles[tileIdx].tileComps[comp].nQuantSteps, sizeof(unsigned int));
                for (i = 0; i < img.tiles[tileIdx].tileComps[comp].nQuantSteps; ++i) {
                    if (!readUByte(&img.tiles[tileIdx].tileComps[comp].quantSteps[i])) {
                        error(errSyntaxError, getPos(), "Error in JPX QCC marker segment");
                        return false;
                    }
                }
            } else if ((img.tiles[tileIdx].tileComps[comp].quantStyle & 0x1f) == 0x01) {
                img.tiles[tileIdx].tileComps[comp].nQuantSteps = 1;
                img.tiles[tileIdx].tileComps[comp].quantSteps = (unsigned int *)greallocn(img.tiles[tileIdx].tileComps[comp].quantSteps, img.tiles[tileIdx].tileComps[comp].nQuantSteps, sizeof(unsigned int));
                if (!readUWord(&img.tiles[tileIdx].tileComps[comp].quantSteps[0])) {
                    error(errSyntaxError, getPos(), "Error in JPX QCC marker segment");
                    return false;
                }
            } else if ((img.tiles[tileIdx].tileComps[comp].quantStyle & 0x1f) == 0x02) {
                if (segLen < (img.nComps > 256 ? 5U : 4U) + 2) {
                    error(errSyntaxError, getPos(), "Error in JPX QCC marker segment");
                    return false;
                }
                img.tiles[tileIdx].tileComps[comp].nQuantSteps = (segLen - (img.nComps > 256 ? 5 : 4)) / 2;
                img.tiles[tileIdx].tileComps[comp].quantSteps = (unsigned int *)greallocn(img.tiles[tileIdx].tileComps[comp].quantSteps, img.tiles[tileIdx].tileComps[comp].nQuantSteps, sizeof(unsigned int));
                for (i = 0; i < img.tiles[tileIdx].tileComps[comp].nQuantSteps; ++i) {
                    if (!readUWord(&img.tiles[tileIdx].tileComps[comp].quantSteps[i])) {
                        error(errSyntaxError, getPos(), "Error in JPX QCD marker segment");
                        return false;
                    }
                }
            } else {
                error(errSyntaxError, getPos(), "Error in JPX QCC marker segment");
                return false;
            }
            break;
        case 0x5e: // RGN - region of interest
            cover(38);
#if 1 //~ ROI is unimplemented
            error(errUnimplemented, -1, "Got a JPX RGN segment");
            for (i = 0; i < segLen - 2; ++i) {
                if (bufStr->getChar() == EOF) {
                    error(errSyntaxError, getPos(), "Error in JPX RGN marker segment");
                    return false;
                }
            }
#else
            if ((img.nComps > 256 && !readUWord(&comp)) || (img.nComps <= 256 && !readUByte(&comp)) || comp >= img.nComps || !readUByte(&compInfo[comp].roi.style) || !readUByte(&compInfo[comp].roi.shift)) {
                error(errSyntaxError, getPos(), "Error in JPX RGN marker segment");
                return false;
            }
#endif
            break;
        case 0x5f: // POC - progression order change
            cover(39);
#if 1 //~ progression order changes are unimplemented
            error(errUnimplemented, -1, "Got a JPX POC segment");
            for (i = 0; i < segLen - 2; ++i) {
                if (bufStr->getChar() == EOF) {
                    error(errSyntaxError, getPos(), "Error in JPX POC marker segment");
                    return false;
                }
            }
#else
            nTileProgs = (segLen - 2) / (img.nComps > 256 ? 9 : 7);
            tileProgs = (JPXProgOrder *)gmallocn(nTileProgs, sizeof(JPXProgOrder));
            for (i = 0; i < nTileProgs; ++i) {
                if (!readUByte(&tileProgs[i].startRes) || !(img.nComps > 256 && readUWord(&tileProgs[i].startComp)) || !(img.nComps <= 256 && readUByte(&tileProgs[i].startComp)) || !readUWord(&tileProgs[i].endLayer)
                    || !readUByte(&tileProgs[i].endRes) || !(img.nComps > 256 && readUWord(&tileProgs[i].endComp)) || !(img.nComps <= 256 && readUByte(&tileProgs[i].endComp)) || !readUByte(&tileProgs[i].progOrder)) {
                    error(errSyntaxError, getPos(), "Error in JPX POC marker segment");
                    return false;
                }
            }
#endif
            break;
        case 0x61: // PPT - packed packet headers, tile-part hdr
            cover(40);
#if 1 //~ packed packet headers are unimplemented
            error(errUnimplemented, -1, "Got a JPX PPT segment");
            for (i = 0; i < segLen - 2; ++i) {
                if (bufStr->getChar() == EOF) {
                    error(errSyntaxError, getPos(), "Error in JPX PPT marker segment");
                    return false;
                }
            }
#endif
        case 0x58: // PLT - packet length, tile-part header
            // skipped
            cover(41);
            for (i = 0; i < segLen - 2; ++i) {
                if (bufStr->getChar() == EOF) {
                    error(errSyntaxError, getPos(), "Error in JPX PLT marker segment");
                    return false;
                }
            }
            break;
        case 0x64: // COM - comment
            // skipped
            cover(42);
            for (i = 0; i < segLen - 2; ++i) {
                if (bufStr->getChar() == EOF) {
                    error(errSyntaxError, getPos(), "Error in JPX COM marker segment");
                    return false;
                }
            }
            break;
        case 0x93: // SOD - start of data
            cover(43);
            haveSOD = true;
            break;
        default:
            cover(44);
            error(errSyntaxError, getPos(), "Unknown marker segment {0:02x} in JPX tile-part stream", segType);
            for (i = 0; i < segLen - 2; ++i) {
                if (bufStr->getChar() == EOF) {
                    break;
                }
            }
            break;
        }
    } while (!haveSOD);

    //----- initialize the tile, precincts, and code-blocks
    if (tilePartIdx == 0) {
        tile = &img.tiles[tileIdx];
        tile->init = true;
        i = tileIdx / img.nXTiles;
        j = tileIdx % img.nXTiles;
        if ((tile->x0 = img.xTileOffset + j * img.xTileSize) < img.xOffset) {
            tile->x0 = img.xOffset;
        }
        if ((tile->y0 = img.yTileOffset + i * img.yTileSize) < img.yOffset) {
            tile->y0 = img.yOffset;
        }
        if ((tile->x1 = img.xTileOffset + (j + 1) * img.xTileSize) > img.xSize) {
            tile->x1 = img.xSize;
        }
        if ((tile->y1 = img.yTileOffset + (i + 1) * img.yTileSize) > img.ySize) {
            tile->y1 = img.ySize;
        }
        tile->comp = 0;
        tile->res = 0;
        tile->precinct = 0;
        tile->layer = 0;
        tile->maxNDecompLevels = 0;
        for (comp = 0; comp < img.nComps; ++comp) {
            tileComp = &tile->tileComps[comp];
            if (tileComp->nDecompLevels > tile->maxNDecompLevels) {
                tile->maxNDecompLevels = tileComp->nDecompLevels;
            }
            tileComp->x0 = jpxCeilDiv(tile->x0, tileComp->hSep);
            tileComp->y0 = jpxCeilDiv(tile->y0, tileComp->vSep);
            tileComp->x1 = jpxCeilDiv(tile->x1, tileComp->hSep);
            tileComp->y1 = jpxCeilDiv(tile->y1, tileComp->vSep);
            tileComp->w = tileComp->x1 - tileComp->x0;
            tileComp->cbW = 1 << tileComp->codeBlockW;
            tileComp->cbH = 1 << tileComp->codeBlockH;
            tileComp->data = (int *)gmallocn((tileComp->x1 - tileComp->x0) * (tileComp->y1 - tileComp->y0), sizeof(int));
            if (tileComp->x1 - tileComp->x0 > tileComp->y1 - tileComp->y0) {
                n = tileComp->x1 - tileComp->x0;
            } else {
                n = tileComp->y1 - tileComp->y0;
            }
            tileComp->buf = (int *)gmallocn(n + 8, sizeof(int));
            for (r = 0; r <= tileComp->nDecompLevels; ++r) {
                resLevel = &tileComp->resLevels[r];
                k = r == 0 ? tileComp->nDecompLevels : tileComp->nDecompLevels - r + 1;
                resLevel->x0 = jpxCeilDivPow2(tileComp->x0, k);
                resLevel->y0 = jpxCeilDivPow2(tileComp->y0, k);
                resLevel->x1 = jpxCeilDivPow2(tileComp->x1, k);
                resLevel->y1 = jpxCeilDivPow2(tileComp->y1, k);
                if (r == 0) {
                    resLevel->bx0[0] = resLevel->x0;
                    resLevel->by0[0] = resLevel->y0;
                    resLevel->bx1[0] = resLevel->x1;
                    resLevel->by1[0] = resLevel->y1;
                } else {
                    resLevel->bx0[0] = jpxCeilDivPow2(tileComp->x0 - (1 << (k - 1)), k);
                    resLevel->by0[0] = resLevel->y0;
                    resLevel->bx1[0] = jpxCeilDivPow2(tileComp->x1 - (1 << (k - 1)), k);
                    resLevel->by1[0] = resLevel->y1;
                    resLevel->bx0[1] = resLevel->x0;
                    resLevel->by0[1] = jpxCeilDivPow2(tileComp->y0 - (1 << (k - 1)), k);
                    resLevel->bx1[1] = resLevel->x1;
                    resLevel->by1[1] = jpxCeilDivPow2(tileComp->y1 - (1 << (k - 1)), k);
                    resLevel->bx0[2] = jpxCeilDivPow2(tileComp->x0 - (1 << (k - 1)), k);
                    resLevel->by0[2] = jpxCeilDivPow2(tileComp->y0 - (1 << (k - 1)), k);
                    resLevel->bx1[2] = jpxCeilDivPow2(tileComp->x1 - (1 << (k - 1)), k);
                    resLevel->by1[2] = jpxCeilDivPow2(tileComp->y1 - (1 << (k - 1)), k);
                }
                resLevel->precincts = (JPXPrecinct *)gmallocn(1, sizeof(JPXPrecinct));
                for (pre = 0; pre < 1; ++pre) {
                    precinct = &resLevel->precincts[pre];
                    precinct->x0 = resLevel->x0;
                    precinct->y0 = resLevel->y0;
                    precinct->x1 = resLevel->x1;
                    precinct->y1 = resLevel->y1;
                    nSBs = r == 0 ? 1 : 3;
                    precinct->subbands = (JPXSubband *)gmallocn(nSBs, sizeof(JPXSubband));
                    for (sb = 0; sb < nSBs; ++sb) {
                        subband = &precinct->subbands[sb];
                        subband->x0 = resLevel->bx0[sb];
                        subband->y0 = resLevel->by0[sb];
                        subband->x1 = resLevel->bx1[sb];
                        subband->y1 = resLevel->by1[sb];
                        subband->nXCBs = jpxCeilDivPow2(subband->x1, tileComp->codeBlockW) - jpxFloorDivPow2(subband->x0, tileComp->codeBlockW);
                        subband->nYCBs = jpxCeilDivPow2(subband->y1, tileComp->codeBlockH) - jpxFloorDivPow2(subband->y0, tileComp->codeBlockH);
                        n = subband->nXCBs > subband->nYCBs ? subband->nXCBs : subband->nYCBs;
                        for (subband->maxTTLevel = 0, --n; n; ++subband->maxTTLevel, n >>= 1)
                            ;
                        n = 0;
                        for (level = subband->maxTTLevel; level >= 0; --level) {
                            nx = jpxCeilDivPow2(subband->nXCBs, level);
                            ny = jpxCeilDivPow2(subband->nYCBs, level);
                            n += nx * ny;
                        }
                        subband->inclusion = (JPXTagTreeNode *)gmallocn(n, sizeof(JPXTagTreeNode));
                        subband->zeroBitPlane = (JPXTagTreeNode *)gmallocn(n, sizeof(JPXTagTreeNode));
                        for (k = 0; k < n; ++k) {
                            subband->inclusion[k].finished = false;
                            subband->inclusion[k].val = 0;
                            subband->zeroBitPlane[k].finished = false;
                            subband->zeroBitPlane[k].val = 0;
                        }
                        subband->cbs = (JPXCodeBlock *)gmallocn(subband->nXCBs * subband->nYCBs, sizeof(JPXCodeBlock));
                        sbx0 = jpxFloorDivPow2(subband->x0, tileComp->codeBlockW);
                        sby0 = jpxFloorDivPow2(subband->y0, tileComp->codeBlockH);
                        if (r == 0) { // (NL)LL
                            sbCoeffs = tileComp->data;
                        } else if (sb == 0) { // (NL-r+1)HL
                            sbCoeffs = tileComp->data + resLevel->bx1[1] - resLevel->bx0[1];
                        } else if (sb == 1) { // (NL-r+1)LH
                            sbCoeffs = tileComp->data + (resLevel->by1[0] - resLevel->by0[0]) * tileComp->w;
                        } else { // (NL-r+1)HH
                            sbCoeffs = tileComp->data + (resLevel->by1[0] - resLevel->by0[0]) * tileComp->w + resLevel->bx1[1] - resLevel->bx0[1];
                        }
                        cb = subband->cbs;
                        for (cbY = 0; cbY < subband->nYCBs; ++cbY) {
                            for (cbX = 0; cbX < subband->nXCBs; ++cbX) {
                                cb->x0 = (sbx0 + cbX) << tileComp->codeBlockW;
                                cb->x1 = cb->x0 + tileComp->cbW;
                                if (subband->x0 > cb->x0) {
                                    cb->x0 = subband->x0;
                                }
                                if (subband->x1 < cb->x1) {
                                    cb->x1 = subband->x1;
                                }
                                cb->y0 = (sby0 + cbY) << tileComp->codeBlockH;
                                cb->y1 = cb->y0 + tileComp->cbH;
                                if (subband->y0 > cb->y0) {
                                    cb->y0 = subband->y0;
                                }
                                if (subband->y1 < cb->y1) {
                                    cb->y1 = subband->y1;
                                }
                                cb->seen = false;
                                cb->lBlock = 3;
                                cb->nextPass = jpxPassCleanup;
                                cb->nZeroBitPlanes = 0;
                                cb->dataLenSize = 1;
                                cb->dataLen = (unsigned int *)gmalloc(sizeof(unsigned int));
                                cb->coeffs = sbCoeffs + (cb->y0 - subband->y0) * tileComp->w + (cb->x0 - subband->x0);
                                cb->touched = (char *)gmalloc(1 << (tileComp->codeBlockW + tileComp->codeBlockH));
                                cb->len = 0;
                                for (cbj = 0; cbj < cb->y1 - cb->y0; ++cbj) {
                                    for (cbi = 0; cbi < cb->x1 - cb->x0; ++cbi) {
                                        cb->coeffs[cbj * tileComp->w + cbi] = 0;
                                    }
                                }
                                memset(cb->touched, 0, (1 << (tileComp->codeBlockW + tileComp->codeBlockH)));
                                cb->arithDecoder = nullptr;
                                cb->stats = nullptr;
                                ++cb;
                            }
                        }
                    }
                }
            }
        }
    }

    return readTilePartData(tileIdx, tilePartLen, tilePartToEOC);
}

bool JPXStream::readTilePartData(unsigned int tileIdx, unsigned int tilePartLen, bool tilePartToEOC)
{
    JPXTile *tile;
    JPXTileComp *tileComp;
    JPXResLevel *resLevel;
    JPXPrecinct *precinct;
    JPXSubband *subband;
    JPXCodeBlock *cb;
    unsigned int ttVal;
    unsigned int bits, cbX, cbY, nx, ny, i, j, n, sb;
    int level;

    tile = &img.tiles[tileIdx];

    // read all packets from this tile-part
    while (1) {
        if (tilePartToEOC) {
            //~ peek for an EOC marker
            cover(93);
        } else if (tilePartLen == 0) {
            break;
        }

        tileComp = &tile->tileComps[tile->comp];
        resLevel = &tileComp->resLevels[tile->res];
        precinct = &resLevel->precincts[tile->precinct];

        //----- packet header

        // setup
        startBitBuf(tilePartLen);
        if (tileComp->style & 0x02) {
            skipSOP();
        }

        // zero-length flag
        if (!readBits(1, &bits)) {
            goto err;
        }
        if (!bits) {
            // packet is empty -- clear all code-block inclusion flags
            cover(45);
            for (sb = 0; sb < (unsigned int)(tile->res == 0 ? 1 : 3); ++sb) {
                subband = &precinct->subbands[sb];
                for (cbY = 0; cbY < subband->nYCBs; ++cbY) {
                    for (cbX = 0; cbX < subband->nXCBs; ++cbX) {
                        cb = &subband->cbs[cbY * subband->nXCBs + cbX];
                        cb->included = false;
                    }
                }
            }
        } else {

            for (sb = 0; sb < (unsigned int)(tile->res == 0 ? 1 : 3); ++sb) {
                subband = &precinct->subbands[sb];
                for (cbY = 0; cbY < subband->nYCBs; ++cbY) {
                    for (cbX = 0; cbX < subband->nXCBs; ++cbX) {
                        cb = &subband->cbs[cbY * subband->nXCBs + cbX];

                        // skip code-blocks with no coefficients
                        if (cb->x0 >= cb->x1 || cb->y0 >= cb->y1) {
                            cover(46);
                            cb->included = false;
                            continue;
                        }

                        // code-block inclusion
                        if (cb->seen) {
                            cover(47);
                            if (!readBits(1, &cb->included)) {
                                goto err;
                            }
                        } else {
                            cover(48);
                            ttVal = 0;
                            i = 0;
                            for (level = subband->maxTTLevel; level >= 0; --level) {
                                nx = jpxCeilDivPow2(subband->nXCBs, level);
                                ny = jpxCeilDivPow2(subband->nYCBs, level);
                                j = i + (cbY >> level) * nx + (cbX >> level);
                                if (!subband->inclusion[j].finished && !subband->inclusion[j].val) {
                                    subband->inclusion[j].val = ttVal;
                                } else {
                                    ttVal = subband->inclusion[j].val;
                                }
                                while (!subband->inclusion[j].finished && ttVal <= tile->layer) {
                                    if (!readBits(1, &bits)) {
                                        goto err;
                                    }
                                    if (bits == 1) {
                                        subband->inclusion[j].finished = true;
                                    } else {
                                        ++ttVal;
                                    }
                                }
                                subband->inclusion[j].val = ttVal;
                                if (ttVal > tile->layer) {
                                    break;
                                }
                                i += nx * ny;
                            }
                            cb->included = level < 0;
                        }

                        if (cb->included) {
                            cover(49);

                            // zero bit-plane count
                            if (!cb->seen) {
                                cover(50);
                                ttVal = 0;
                                i = 0;
                                for (level = subband->maxTTLevel; level >= 0; --level) {
                                    nx = jpxCeilDivPow2(subband->nXCBs, level);
                                    ny = jpxCeilDivPow2(subband->nYCBs, level);
                                    j = i + (cbY >> level) * nx + (cbX >> level);
                                    if (!subband->zeroBitPlane[j].finished && !subband->zeroBitPlane[j].val) {
                                        subband->zeroBitPlane[j].val = ttVal;
                                    } else {
                                        ttVal = subband->zeroBitPlane[j].val;
                                    }
                                    while (!subband->zeroBitPlane[j].finished) {
                                        if (!readBits(1, &bits)) {
                                            goto err;
                                        }
                                        if (bits == 1) {
                                            subband->zeroBitPlane[j].finished = true;
                                        } else {
                                            ++ttVal;
                                        }
                                    }
                                    subband->zeroBitPlane[j].val = ttVal;
                                    i += nx * ny;
                                }
                                cb->nZeroBitPlanes = ttVal;
                            }

                            // number of coding passes
                            if (!readBits(1, &bits)) {
                                goto err;
                            }
                            if (bits == 0) {
                                cover(51);
                                cb->nCodingPasses = 1;
                            } else {
                                if (!readBits(1, &bits)) {
                                    goto err;
                                }
                                if (bits == 0) {
                                    cover(52);
                                    cb->nCodingPasses = 2;
                                } else {
                                    cover(53);
                                    if (!readBits(2, &bits)) {
                                        goto err;
                                    }
                                    if (bits < 3) {
                                        cover(54);
                                        cb->nCodingPasses = 3 + bits;
                                    } else {
                                        cover(55);
                                        if (!readBits(5, &bits)) {
                                            goto err;
                                        }
                                        if (bits < 31) {
                                            cover(56);
                                            cb->nCodingPasses = 6 + bits;
                                        } else {
                                            cover(57);
                                            if (!readBits(7, &bits)) {
                                                goto err;
                                            }
                                            cb->nCodingPasses = 37 + bits;
                                        }
                                    }
                                }
                            }

                            // update Lblock
                            while (1) {
                                if (!readBits(1, &bits)) {
                                    goto err;
                                }
                                if (!bits) {
                                    break;
                                }
                                ++cb->lBlock;
                            }

                            // one codeword segment for each of the coding passes
                            if (tileComp->codeBlockStyle & 0x04) {
                                if (cb->nCodingPasses > cb->dataLenSize) {
                                    cb->dataLenSize = cb->nCodingPasses;
                                    cb->dataLen = (unsigned int *)greallocn(cb->dataLen, cb->dataLenSize, sizeof(unsigned int));
                                }

                                // read the lengths
                                for (i = 0; i < cb->nCodingPasses; ++i) {
                                    if (!readBits(cb->lBlock, &cb->dataLen[i])) {
                                        goto err;
                                    }
                                }

                                // one codeword segment for all of the coding passes
                            } else {

                                // read the length
                                for (n = cb->lBlock, i = cb->nCodingPasses >> 1; i; ++n, i >>= 1)
                                    ;
                                if (!readBits(n, &cb->dataLen[0])) {
                                    goto err;
                                }
                            }
                        }
                    }
                }
            }
        }
        if (tileComp->style & 0x04) {
            skipEPH();
        }
        tilePartLen = finishBitBuf();

        //----- packet data

        for (sb = 0; sb < (unsigned int)(tile->res == 0 ? 1 : 3); ++sb) {
            subband = &precinct->subbands[sb];
            for (cbY = 0; cbY < subband->nYCBs; ++cbY) {
                for (cbX = 0; cbX < subband->nXCBs; ++cbX) {
                    cb = &subband->cbs[cbY * subband->nXCBs + cbX];
                    if (cb->included) {
                        if (!readCodeBlockData(tileComp, resLevel, precinct, subband, tile->res, sb, cb)) {
                            return false;
                        }
                        if (tileComp->codeBlockStyle & 0x04) {
                            for (i = 0; i < cb->nCodingPasses; ++i) {
                                tilePartLen -= cb->dataLen[i];
                            }
                        } else {
                            tilePartLen -= cb->dataLen[0];
                        }
                        cb->seen = true;
                    }
                }
            }
        }

        //----- next packet

        switch (tile->progOrder) {
        case 0: // layer, resolution level, component, precinct
            cover(58);
            if (++tile->comp == img.nComps) {
                tile->comp = 0;
                if (++tile->res == tile->maxNDecompLevels + 1) {
                    tile->res = 0;
                    if (++tile->layer == tile->nLayers) {
                        tile->layer = 0;
                    }
                }
            }
            break;
        case 1: // resolution level, layer, component, precinct
            cover(59);
            if (++tile->comp == img.nComps) {
                tile->comp = 0;
                if (++tile->layer == tile->nLayers) {
                    tile->layer = 0;
                    if (++tile->res == tile->maxNDecompLevels + 1) {
                        tile->res = 0;
                    }
                }
            }
            break;
        case 2: // resolution level, precinct, component, layer
            //~ this isn't correct -- see B.12.1.3
            cover(60);
            if (++tile->layer == tile->nLayers) {
                tile->layer = 0;
                if (++tile->comp == img.nComps) {
                    tile->comp = 0;
                    if (++tile->res == tile->maxNDecompLevels + 1) {
                        tile->res = 0;
                    }
                }
                tileComp = &tile->tileComps[tile->comp];
                if (tile->res >= tileComp->nDecompLevels + 1) {
                    if (++tile->comp == img.nComps) {
                        return true;
                    }
                }
            }
            break;
        case 3: // precinct, component, resolution level, layer
            //~ this isn't correct -- see B.12.1.4
            cover(61);
            if (++tile->layer == tile->nLayers) {
                tile->layer = 0;
                if (++tile->res == tile->maxNDecompLevels + 1) {
                    tile->res = 0;
                    if (++tile->comp == img.nComps) {
                        tile->comp = 0;
                    }
                }
            }
            break;
        case 4: // component, precinct, resolution level, layer
            //~ this isn't correct -- see B.12.1.5
            cover(62);
            if (++tile->layer == tile->nLayers) {
                tile->layer = 0;
                if (++tile->res == tile->maxNDecompLevels + 1) {
                    tile->res = 0;
                    if (++tile->comp == img.nComps) {
                        tile->comp = 0;
                    }
                }
            }
            break;
        }
    }

    return true;

err:
    error(errSyntaxError, getPos(), "Error in JPX stream");
    return false;
}

bool JPXStream::readCodeBlockData(JPXTileComp *tileComp, JPXResLevel *resLevel, JPXPrecinct *precinct, JPXSubband *subband, unsigned int res, unsigned int sb, JPXCodeBlock *cb)
{
    int *coeff0, *coeff1, *coeff;
    char *touched0, *touched1, *touched;
    unsigned int horiz, vert, diag, all, cx, xorBit;
    int horizSign, vertSign, bit;
    int segSym;
    unsigned int i, x, y0, y1;

    if (cb->arithDecoder) {
        cover(63);
        cb->arithDecoder->restart(cb->dataLen[0]);
    } else {
        cover(64);
        cb->arithDecoder = new JArithmeticDecoder();
        cb->arithDecoder->setStream(bufStr, cb->dataLen[0]);
        cb->arithDecoder->start();
        cb->stats = new JArithmeticDecoderStats(jpxNContexts);
        cb->stats->setEntry(jpxContextSigProp, 4, 0);
        cb->stats->setEntry(jpxContextRunLength, 3, 0);
        cb->stats->setEntry(jpxContextUniform, 46, 0);
    }

    for (i = 0; i < cb->nCodingPasses; ++i) {
        if ((tileComp->codeBlockStyle & 0x04) && i > 0) {
            cb->arithDecoder->setStream(bufStr, cb->dataLen[i]);
            cb->arithDecoder->start();
        }

        switch (cb->nextPass) {

        //----- significance propagation pass
        case jpxPassSigProp:
            cover(65);
            for (y0 = cb->y0, coeff0 = cb->coeffs, touched0 = cb->touched; y0 < cb->y1; y0 += 4, coeff0 += 4 * tileComp->w, touched0 += 4 << tileComp->codeBlockW) {
                for (x = cb->x0, coeff1 = coeff0, touched1 = touched0; x < cb->x1; ++x, ++coeff1, ++touched1) {
                    for (y1 = 0, coeff = coeff1, touched = touched1; y1 < 4 && y0 + y1 < cb->y1; ++y1, coeff += tileComp->w, touched += tileComp->cbW) {
                        if (!*coeff) {
                            horiz = vert = diag = 0;
                            horizSign = vertSign = 2;
                            if (x > cb->x0) {
                                if (coeff[-1]) {
                                    ++horiz;
                                    horizSign += coeff[-1] < 0 ? -1 : 1;
                                }
                                if (y0 + y1 > cb->y0) {
                                    diag += coeff[-(int)tileComp->w - 1] ? 1 : 0;
                                }
                                if (y0 + y1 < cb->y1 - 1 && (!(tileComp->codeBlockStyle & 0x08) || y1 < 3)) {
                                    diag += coeff[tileComp->w - 1] ? 1 : 0;
                                }
                            }
                            if (x < cb->x1 - 1) {
                                if (coeff[1]) {
                                    ++horiz;
                                    horizSign += coeff[1] < 0 ? -1 : 1;
                                }
                                if (y0 + y1 > cb->y0) {
                                    diag += coeff[-(int)tileComp->w + 1] ? 1 : 0;
                                }
                                if (y0 + y1 < cb->y1 - 1 && (!(tileComp->codeBlockStyle & 0x08) || y1 < 3)) {
                                    diag += coeff[tileComp->w + 1] ? 1 : 0;
                                }
                            }
                            if (y0 + y1 > cb->y0) {
                                if (coeff[-(int)tileComp->w]) {
                                    ++vert;
                                    vertSign += coeff[-(int)tileComp->w] < 0 ? -1 : 1;
                                }
                            }
                            if (y0 + y1 < cb->y1 - 1 && (!(tileComp->codeBlockStyle & 0x08) || y1 < 3)) {
                                if (coeff[tileComp->w]) {
                                    ++vert;
                                    vertSign += coeff[tileComp->w] < 0 ? -1 : 1;
                                }
                            }
                            cx = sigPropContext[horiz][vert][diag][res == 0 ? 1 : sb];
                            if (cx != 0) {
                                if (cb->arithDecoder->decodeBit(cx, cb->stats)) {
                                    cx = signContext[horizSign][vertSign][0];
                                    xorBit = signContext[horizSign][vertSign][1];
                                    if (cb->arithDecoder->decodeBit(cx, cb->stats) ^ xorBit) {
                                        *coeff = -1;
                                    } else {
                                        *coeff = 1;
                                    }
                                }
                                *touched = 1;
                            }
                        }
                    }
                }
            }
            ++cb->nextPass;
            break;

        //----- magnitude refinement pass
        case jpxPassMagRef:
            cover(66);
            for (y0 = cb->y0, coeff0 = cb->coeffs, touched0 = cb->touched; y0 < cb->y1; y0 += 4, coeff0 += 4 * tileComp->w, touched0 += 4 << tileComp->codeBlockW) {
                for (x = cb->x0, coeff1 = coeff0, touched1 = touched0; x < cb->x1; ++x, ++coeff1, ++touched1) {
                    for (y1 = 0, coeff = coeff1, touched = touched1; y1 < 4 && y0 + y1 < cb->y1; ++y1, coeff += tileComp->w, touched += tileComp->cbW) {
                        if (*coeff && !*touched) {
                            if (*coeff == 1 || *coeff == -1) {
                                all = 0;
                                if (x > cb->x0) {
                                    all += coeff[-1] ? 1 : 0;
                                    if (y0 + y1 > cb->y0) {
                                        all += coeff[-(int)tileComp->w - 1] ? 1 : 0;
                                    }
                                    if (y0 + y1 < cb->y1 - 1 && (!(tileComp->codeBlockStyle & 0x08) || y1 < 3)) {
                                        all += coeff[tileComp->w - 1] ? 1 : 0;
                                    }
                                }
                                if (x < cb->x1 - 1) {
                                    all += coeff[1] ? 1 : 0;
                                    if (y0 + y1 > cb->y0) {
                                        all += coeff[-(int)tileComp->w + 1] ? 1 : 0;
                                    }
                                    if (y0 + y1 < cb->y1 - 1 && (!(tileComp->codeBlockStyle & 0x08) || y1 < 3)) {
                                        all += coeff[tileComp->w + 1] ? 1 : 0;
                                    }
                                }
                                if (y0 + y1 > cb->y0) {
                                    all += coeff[-(int)tileComp->w] ? 1 : 0;
                                }
                                if (y0 + y1 < cb->y1 - 1 && (!(tileComp->codeBlockStyle & 0x08) || y1 < 3)) {
                                    all += coeff[tileComp->w] ? 1 : 0;
                                }
                                cx = all ? 15 : 14;
                            } else {
                                cx = 16;
                            }
                            bit = cb->arithDecoder->decodeBit(cx, cb->stats);
                            if (*coeff < 0) {
                                *coeff = (*coeff << 1) - bit;
                            } else {
                                *coeff = (*coeff << 1) + bit;
                            }
                            *touched = 1;
                        }
                    }
                }
            }
            ++cb->nextPass;
            break;

        //----- cleanup pass
        case jpxPassCleanup:
            cover(67);
            for (y0 = cb->y0, coeff0 = cb->coeffs, touched0 = cb->touched; y0 < cb->y1; y0 += 4, coeff0 += 4 * tileComp->w, touched0 += 4 << tileComp->codeBlockW) {
                for (x = cb->x0, coeff1 = coeff0, touched1 = touched0; x < cb->x1; ++x, ++coeff1, ++touched1) {
                    y1 = 0;
                    if (y0 + 3 < cb->y1 && !(*touched1) && !(touched1[tileComp->cbW]) && !(touched1[2 * tileComp->cbW]) && !(touched1[3 * tileComp->cbW]) && (x == cb->x0 || y0 == cb->y0 || !coeff1[-(int)tileComp->w - 1])
                        && (y0 == cb->y0 || !coeff1[-(int)tileComp->w]) && (x == cb->x1 - 1 || y0 == cb->y0 || !coeff1[-(int)tileComp->w + 1])
                        && (x == cb->x0 || (!coeff1[-1] && !coeff1[tileComp->w - 1] && !coeff1[2 * tileComp->w - 1] && !coeff1[3 * tileComp->w - 1]))
                        && (x == cb->x1 - 1 || (!coeff1[1] && !coeff1[tileComp->w + 1] && !coeff1[2 * tileComp->w + 1] && !coeff1[3 * tileComp->w + 1]))
                        && ((tileComp->codeBlockStyle & 0x08)
                            || ((x == cb->x0 || y0 + 4 == cb->y1 || !coeff1[4 * tileComp->w - 1]) && (y0 + 4 == cb->y1 || !coeff1[4 * tileComp->w]) && (x == cb->x1 - 1 || y0 + 4 == cb->y1 || !coeff1[4 * tileComp->w + 1])))) {
                        if (cb->arithDecoder->decodeBit(jpxContextRunLength, cb->stats)) {
                            y1 = cb->arithDecoder->decodeBit(jpxContextUniform, cb->stats);
                            y1 = (y1 << 1) | cb->arithDecoder->decodeBit(jpxContextUniform, cb->stats);
                            coeff = &coeff1[y1 * tileComp->w];
                            cx = signContext[2][2][0];
                            xorBit = signContext[2][2][1];
                            if (cb->arithDecoder->decodeBit(cx, cb->stats) ^ xorBit) {
                                *coeff = -1;
                            } else {
                                *coeff = 1;
                            }
                            ++y1;
                        } else {
                            y1 = 4;
                        }
                    }
                    for (coeff = &coeff1[y1 * tileComp->w], touched = &touched1[y1 << tileComp->codeBlockW]; y1 < 4 && y0 + y1 < cb->y1; ++y1, coeff += tileComp->w, touched += tileComp->cbW) {
                        if (!*touched) {
                            horiz = vert = diag = 0;
                            horizSign = vertSign = 2;
                            if (x > cb->x0) {
                                if (coeff[-1]) {
                                    ++horiz;
                                    horizSign += coeff[-1] < 0 ? -1 : 1;
                                }
                                if (y0 + y1 > cb->y0) {
                                    diag += coeff[-(int)tileComp->w - 1] ? 1 : 0;
                                }
                                if (y0 + y1 < cb->y1 - 1 && (!(tileComp->codeBlockStyle & 0x08) || y1 < 3)) {
                                    diag += coeff[tileComp->w - 1] ? 1 : 0;
                                }
                            }
                            if (x < cb->x1 - 1) {
                                if (coeff[1]) {
                                    ++horiz;
                                    horizSign += coeff[1] < 0 ? -1 : 1;
                                }
                                if (y0 + y1 > cb->y0) {
                                    diag += coeff[-(int)tileComp->w + 1] ? 1 : 0;
                                }
                                if (y0 + y1 < cb->y1 - 1 && (!(tileComp->codeBlockStyle & 0x08) || y1 < 3)) {
                                    diag += coeff[tileComp->w + 1] ? 1 : 0;
                                }
                            }
                            if (y0 + y1 > cb->y0) {
                                if (coeff[-(int)tileComp->w]) {
                                    ++vert;
                                    vertSign += coeff[-(int)tileComp->w] < 0 ? -1 : 1;
                                }
                            }
                            if (y0 + y1 < cb->y1 - 1 && (!(tileComp->codeBlockStyle & 0x08) || y1 < 3)) {
                                if (coeff[tileComp->w]) {
                                    ++vert;
                                    vertSign += coeff[tileComp->w] < 0 ? -1 : 1;
                                }
                            }
                            cx = sigPropContext[horiz][vert][diag][res == 0 ? 1 : sb];
                            if (cb->arithDecoder->decodeBit(cx, cb->stats)) {
                                cx = signContext[horizSign][vertSign][0];
                                xorBit = signContext[horizSign][vertSign][1];
                                if (cb->arithDecoder->decodeBit(cx, cb->stats) ^ xorBit) {
                                    *coeff = -1;
                                } else {
                                    *coeff = 1;
                                }
                            }
                        } else {
                            *touched = 0;
                        }
                    }
                }
            }
            ++cb->len;
            // look for a segmentation symbol
            if (tileComp->codeBlockStyle & 0x20) {
                segSym = cb->arithDecoder->decodeBit(jpxContextUniform, cb->stats) << 3;
                segSym |= cb->arithDecoder->decodeBit(jpxContextUniform, cb->stats) << 2;
                segSym |= cb->arithDecoder->decodeBit(jpxContextUniform, cb->stats) << 1;
                segSym |= cb->arithDecoder->decodeBit(jpxContextUniform, cb->stats);
                if (segSym != 0x0a) {
                    // in theory this should be a fatal error, but it seems to
                    // be problematic
                    error(errSyntaxWarning, getPos(), "Missing or invalid segmentation symbol in JPX stream");
                }
            }
            cb->nextPass = jpxPassSigProp;
            break;
        }

        if (tileComp->codeBlockStyle & 0x02) {
            cb->stats->reset();
            cb->stats->setEntry(jpxContextSigProp, 4, 0);
            cb->stats->setEntry(jpxContextRunLength, 3, 0);
            cb->stats->setEntry(jpxContextUniform, 46, 0);
        }

        if (tileComp->codeBlockStyle & 0x04) {
            cb->arithDecoder->cleanup();
        }
    }

    cb->arithDecoder->cleanup();
    return true;
}

// Inverse quantization, and wavelet transform (IDWT).  This also does
// the initial shift to convert to fixed point format.
void JPXStream::inverseTransform(JPXTileComp *tileComp)
{
    JPXResLevel *resLevel;
    JPXPrecinct *precinct;
    JPXSubband *subband;
    JPXCodeBlock *cb;
    int *coeff0, *coeff;
    char *touched0, *touched;
    unsigned int qStyle, guard, eps, shift;
    int shift2;
    double mu;
    int val;
    unsigned int r, cbX, cbY, x, y;

    cover(68);

    //----- (NL)LL subband (resolution level 0)

    resLevel = &tileComp->resLevels[0];
    precinct = &resLevel->precincts[0];
    subband = &precinct->subbands[0];

    // i-quant parameters
    qStyle = tileComp->quantStyle & 0x1f;
    guard = (tileComp->quantStyle >> 5) & 7;
    if (qStyle == 0) {
        cover(69);
        eps = (tileComp->quantSteps[0] >> 3) & 0x1f;
        shift = guard + eps - 1;
        mu = 0; // make gcc happy
    } else {
        cover(70);
        shift = guard - 1 + tileComp->prec;
        mu = (double)(0x800 + (tileComp->quantSteps[0] & 0x7ff)) / 2048.0;
    }
    if (tileComp->transform == 0) {
        cover(71);
        shift += fracBits;
    }

    // do fixed point adjustment and dequantization on (NL)LL
    cb = subband->cbs;
    for (cbY = 0; cbY < subband->nYCBs; ++cbY) {
        for (cbX = 0; cbX < subband->nXCBs; ++cbX) {
            for (y = cb->y0, coeff0 = cb->coeffs, touched0 = cb->touched; y < cb->y1; ++y, coeff0 += tileComp->w, touched0 += tileComp->cbW) {
                for (x = cb->x0, coeff = coeff0, touched = touched0; x < cb->x1; ++x, ++coeff, ++touched) {
                    val = *coeff;
                    if (val != 0) {
                        shift2 = shift - (cb->nZeroBitPlanes + cb->len + *touched);
                        if (shift2 > 0) {
                            cover(94);
                            if (val < 0) {
                                val = (((unsigned int)val) << shift2) - (1 << (shift2 - 1));
                            } else {
                                val = (val << shift2) + (1 << (shift2 - 1));
                            }
                        } else {
                            cover(95);
                            val >>= -shift2;
                        }
                        if (qStyle == 0) {
                            cover(96);
                            if (tileComp->transform == 0) {
                                cover(97);
                                val &= 0xFFFFFFFF << fracBits;
                            }
                        } else {
                            cover(98);
                            val = (int)((double)val * mu);
                        }
                    }
                    *coeff = val;
                }
            }
            ++cb;
        }
    }

    //----- IDWT for each level

    for (r = 1; r <= tileComp->nDecompLevels; ++r) {
        resLevel = &tileComp->resLevels[r];

        // (n)LL is already in the upper-left corner of the
        // tile-component data array -- interleave with (n)HL/LH/HH
        // and inverse transform to get (n-1)LL, which will be stored
        // in the upper-left corner of the tile-component data array
        inverseTransformLevel(tileComp, r, resLevel);
    }
}

// Do one level of the inverse transform:
// - take (n)LL, (n)HL, (n)LH, and (n)HH from the upper-left corner
//   of the tile-component data array
// - leave the resulting (n-1)LL in the same place
void JPXStream::inverseTransformLevel(JPXTileComp *tileComp, unsigned int r, JPXResLevel *resLevel)
{
    JPXPrecinct *precinct;
    JPXSubband *subband;
    JPXCodeBlock *cb;
    int *coeff0, *coeff;
    char *touched0, *touched;
    unsigned int qStyle, guard, eps, shift, t;
    int shift2;
    double mu;
    int val;
    int *dataPtr, *bufPtr;
    unsigned int nx1, nx2, ny1, ny2, offset;
    unsigned int x, y, sb, cbX, cbY;

    //----- fixed-point adjustment and dequantization

    qStyle = tileComp->quantStyle & 0x1f;
    guard = (tileComp->quantStyle >> 5) & 7;
    precinct = &resLevel->precincts[0];
    for (sb = 0; sb < 3; ++sb) {

        // i-quant parameters
        if (qStyle == 0) {
            cover(100);
            const unsigned int stepIndex = 3 * r - 2 + sb;
            if (unlikely(stepIndex >= tileComp->nQuantSteps)) {
                error(errSyntaxError, getPos(), "Wrong index for quantSteps in inverseTransformLevel in JPX stream");
                break;
            }
            eps = (tileComp->quantSteps[stepIndex] >> 3) & 0x1f;
            shift = guard + eps - 1;
            mu = 0; // make gcc happy
        } else {
            cover(101);
            shift = guard + tileComp->prec;
            if (sb == 2) {
                cover(102);
                ++shift;
            }
            const unsigned int stepIndex = qStyle == 1 ? 0 : (3 * r - 2 + sb);
            if (unlikely(stepIndex >= tileComp->nQuantSteps)) {
                error(errSyntaxError, getPos(), "Wrong index for quantSteps in inverseTransformLevel in JPX stream");
                break;
            }
            t = tileComp->quantSteps[stepIndex];
            mu = (double)(0x800 + (t & 0x7ff)) / 2048.0;
        }
        if (tileComp->transform == 0) {
            cover(103);
            shift += fracBits;
        }

        // fixed point adjustment and dequantization
        subband = &precinct->subbands[sb];
        cb = subband->cbs;
        for (cbY = 0; cbY < subband->nYCBs; ++cbY) {
            for (cbX = 0; cbX < subband->nXCBs; ++cbX) {
                for (y = cb->y0, coeff0 = cb->coeffs, touched0 = cb->touched; y < cb->y1; ++y, coeff0 += tileComp->w, touched0 += tileComp->cbW) {
                    for (x = cb->x0, coeff = coeff0, touched = touched0; x < cb->x1; ++x, ++coeff, ++touched) {
                        val = *coeff;
                        if (val != 0) {
                            shift2 = shift - (cb->nZeroBitPlanes + cb->len + *touched);
                            if (shift2 > 0) {
                                cover(74);
                                if (val < 0) {
                                    val = (((unsigned int)val) << shift2) - (1 << (shift2 - 1));
                                } else {
                                    val = (val << shift2) + (1 << (shift2 - 1));
                                }
                            } else {
                                cover(75);
                                val >>= -shift2;
                            }
                            if (qStyle == 0) {
                                cover(76);
                                if (tileComp->transform == 0) {
                                    val &= 0xFFFFFFFF << fracBits;
                                }
                            } else {
                                cover(77);
                                val = (int)((double)val * mu);
                            }
                        }
                        *coeff = val;
                    }
                }
                ++cb;
            }
        }
    }

    //----- inverse transform

    // compute the subband bounds:
    //    0   nx1  nx2
    //    |    |    |
    //    v    v    v
    //   +----+----+
    //   | LL | HL | <- 0
    //   +----+----+
    //   | LH | HH | <- ny1
    //   +----+----+
    //               <- ny2
    nx1 = precinct->subbands[1].x1 - precinct->subbands[1].x0;
    nx2 = nx1 + precinct->subbands[0].x1 - precinct->subbands[0].x0;
    ny1 = precinct->subbands[0].y1 - precinct->subbands[0].y0;
    ny2 = ny1 + precinct->subbands[1].y1 - precinct->subbands[1].y0;

    // horizontal (row) transforms
    if (r == tileComp->nDecompLevels) {
        offset = 3 + (tileComp->x0 & 1);
    } else {
        offset = 3 + (tileComp->resLevels[r + 1].x0 & 1);
    }
    for (y = 0, dataPtr = tileComp->data; y < ny2; ++y, dataPtr += tileComp->w) {
        if (precinct->subbands[0].x0 == precinct->subbands[1].x0) {
            // fetch LL/LH
            for (x = 0, bufPtr = tileComp->buf + offset; x < nx1; ++x, bufPtr += 2) {
                *bufPtr = dataPtr[x];
            }
            // fetch HL/HH
            for (x = nx1, bufPtr = tileComp->buf + offset + 1; x < nx2; ++x, bufPtr += 2) {
                *bufPtr = dataPtr[x];
            }
        } else {
            // fetch LL/LH
            for (x = 0, bufPtr = tileComp->buf + offset + 1; x < nx1; ++x, bufPtr += 2) {
                *bufPtr = dataPtr[x];
            }
            // fetch HL/HH
            for (x = nx1, bufPtr = tileComp->buf + offset; x < nx2; ++x, bufPtr += 2) {
                *bufPtr = dataPtr[x];
            }
        }
        if (tileComp->x1 - tileComp->x0 > tileComp->y1 - tileComp->y0) {
            x = tileComp->x1 - tileComp->x0 + 5;
        } else {
            x = tileComp->y1 - tileComp->y0 + 5;
        }
        if (offset + nx2 > x || nx2 == 0) {
            error(errSyntaxError, getPos(), "Invalid call of inverseTransform1D in inverseTransformLevel in JPX stream");
            return;
        }
        inverseTransform1D(tileComp, tileComp->buf, offset, nx2);
        for (x = 0, bufPtr = tileComp->buf + offset; x < nx2; ++x, ++bufPtr) {
            dataPtr[x] = *bufPtr;
        }
    }

    // vertical (column) transforms
    if (r == tileComp->nDecompLevels) {
        offset = 3 + (tileComp->y0 & 1);
    } else {
        offset = 3 + (tileComp->resLevels[r + 1].y0 & 1);
    }
    for (x = 0, dataPtr = tileComp->data; x < nx2; ++x, ++dataPtr) {
        if (precinct->subbands[1].y0 == precinct->subbands[0].y0) {
            // fetch LL/HL
            for (y = 0, bufPtr = tileComp->buf + offset; y < ny1; ++y, bufPtr += 2) {
                *bufPtr = dataPtr[y * tileComp->w];
            }
            // fetch LH/HH
            for (y = ny1, bufPtr = tileComp->buf + offset + 1; y < ny2; ++y, bufPtr += 2) {
                *bufPtr = dataPtr[y * tileComp->w];
            }
        } else {
            // fetch LL/HL
            for (y = 0, bufPtr = tileComp->buf + offset + 1; y < ny1; ++y, bufPtr += 2) {
                *bufPtr = dataPtr[y * tileComp->w];
            }
            // fetch LH/HH
            for (y = ny1, bufPtr = tileComp->buf + offset; y < ny2; ++y, bufPtr += 2) {
                *bufPtr = dataPtr[y * tileComp->w];
            }
        }
        if (tileComp->x1 - tileComp->x0 > tileComp->y1 - tileComp->y0) {
            y = tileComp->x1 - tileComp->x0 + 5;
        } else {
            y = tileComp->y1 - tileComp->y0 + 5;
        }
        if (offset + ny2 > y || ny2 == 0) {
            error(errSyntaxError, getPos(), "Invalid call of inverseTransform1D in inverseTransformLevel in JPX stream");
            return;
        }
        inverseTransform1D(tileComp, tileComp->buf, offset, ny2);
        for (y = 0, bufPtr = tileComp->buf + offset; y < ny2; ++y, ++bufPtr) {
            dataPtr[y * tileComp->w] = *bufPtr;
        }
    }
}

void JPXStream::inverseTransform1D(JPXTileComp *tileComp, int *data, unsigned int offset, unsigned int n)
{
    unsigned int end, i;

    //----- special case for length = 1
    if (n == 1) {
        cover(79);
        if (offset == 4) {
            cover(104);
            *data >>= 1;
        }

    } else {
        cover(80);

        end = offset + n;

        //----- extend right
        data[end] = data[end - 2];
        if (n == 2) {
            cover(81);
            data[end + 1] = data[offset + 1];
            data[end + 2] = data[offset];
            data[end + 3] = data[offset + 1];
        } else {
            cover(82);
            data[end + 1] = data[end - 3];
            if (n == 3) {
                cover(105);
                data[end + 2] = data[offset + 1];
                data[end + 3] = data[offset + 2];
            } else {
                cover(106);
                data[end + 2] = data[end - 4];
                if (n == 4) {
                    cover(107);
                    data[end + 3] = data[offset + 1];
                } else {
                    cover(108);
                    data[end + 3] = data[end - 5];
                }
            }
        }

        //----- extend left
        data[offset - 1] = data[offset + 1];
        data[offset - 2] = data[offset + 2];
        data[offset - 3] = data[offset + 3];
        if (offset == 4) {
            cover(83);
            data[0] = data[offset + 4];
        }

        //----- 9-7 irreversible filter

        if (tileComp->transform == 0) {
            cover(84);
            // step 1 (even)
            for (i = 1; i <= end + 2; i += 2) {
                data[i] = (int)(idwtKappa * data[i]);
            }
            // step 2 (odd)
            for (i = 0; i <= end + 3; i += 2) {
                data[i] = (int)(idwtIKappa * data[i]);
            }
            // step 3 (even)
            for (i = 1; i <= end + 2; i += 2) {
                data[i] = (int)(data[i] - idwtDelta * (data[i - 1] + data[i + 1]));
            }
            // step 4 (odd)
            for (i = 2; i <= end + 1; i += 2) {
                data[i] = (int)(data[i] - idwtGamma * (data[i - 1] + data[i + 1]));
            }
            // step 5 (even)
            for (i = 3; i <= end; i += 2) {
                data[i] = (int)(data[i] - idwtBeta * (data[i - 1] + data[i + 1]));
            }
            // step 6 (odd)
            for (i = 4; i <= end - 1; i += 2) {
                data[i] = (int)(data[i] - idwtAlpha * (data[i - 1] + data[i + 1]));
            }

            //----- 5-3 reversible filter

        } else {
            cover(85);
            // step 1 (even)
            for (i = 3; i <= end; i += 2) {
                data[i] -= (data[i - 1] + data[i + 1] + 2) >> 2;
            }
            // step 2 (odd)
            for (i = 4; i < end; i += 2) {
                data[i] += (data[i - 1] + data[i + 1]) >> 1;
            }
        }
    }
}

// Inverse multi-component transform and DC level shift.  This also
// converts fixed point samples back to integers.
bool JPXStream::inverseMultiCompAndDC(JPXTile *tile)
{
    JPXTileComp *tileComp;
    int coeff, d0, d1, d2, t, minVal, maxVal, zeroVal;
    int *dataPtr;
    unsigned int j, comp, x, y;

    //----- inverse multi-component transform

    if (tile->multiComp == 1) {
        cover(86);
        if (img.nComps < 3 || tile->tileComps[0].hSep != tile->tileComps[1].hSep || tile->tileComps[0].vSep != tile->tileComps[1].vSep || tile->tileComps[1].hSep != tile->tileComps[2].hSep
            || tile->tileComps[1].vSep != tile->tileComps[2].vSep) {
            return false;
        }

        // inverse irreversible multiple component transform
        if (tile->tileComps[0].transform == 0) {
            cover(87);
            j = 0;
            for (y = 0; y < tile->tileComps[0].y1 - tile->tileComps[0].y0; ++y) {
                for (x = 0; x < tile->tileComps[0].x1 - tile->tileComps[0].x0; ++x) {
                    d0 = tile->tileComps[0].data[j];
                    d1 = tile->tileComps[1].data[j];
                    d2 = tile->tileComps[2].data[j];
                    tile->tileComps[0].data[j] = (int)(d0 + 1.402 * d2 + 0.5);
                    tile->tileComps[1].data[j] = (int)(d0 - 0.34413 * d1 - 0.71414 * d2 + 0.5);
                    tile->tileComps[2].data[j] = (int)(d0 + 1.772 * d1 + 0.5);
                    ++j;
                }
            }

            // inverse reversible multiple component transform
        } else {
            cover(88);
            j = 0;
            for (y = 0; y < tile->tileComps[0].y1 - tile->tileComps[0].y0; ++y) {
                for (x = 0; x < tile->tileComps[0].x1 - tile->tileComps[0].x0; ++x) {
                    d0 = tile->tileComps[0].data[j];
                    d1 = tile->tileComps[1].data[j];
                    d2 = tile->tileComps[2].data[j];
                    tile->tileComps[1].data[j] = t = d0 - ((d2 + d1) >> 2);
                    tile->tileComps[0].data[j] = d2 + t;
                    tile->tileComps[2].data[j] = d1 + t;
                    ++j;
                }
            }
        }
    }

    //----- DC level shift
    for (comp = 0; comp < img.nComps; ++comp) {
        tileComp = &tile->tileComps[comp];

        // signed: clip
        if (tileComp->sgned) {
            cover(89);
            minVal = -(1 << (tileComp->prec - 1));
            maxVal = (1 << (tileComp->prec - 1)) - 1;
            dataPtr = tileComp->data;
            for (y = 0; y < tileComp->y1 - tileComp->y0; ++y) {
                for (x = 0; x < tileComp->x1 - tileComp->x0; ++x) {
                    coeff = *dataPtr;
                    if (tileComp->transform == 0) {
                        cover(109);
                        coeff >>= fracBits;
                    }
                    if (coeff < minVal) {
                        cover(110);
                        coeff = minVal;
                    } else if (coeff > maxVal) {
                        cover(111);
                        coeff = maxVal;
                    }
                    *dataPtr++ = coeff;
                }
            }

            // unsigned: inverse DC level shift and clip
        } else {
            cover(90);
            maxVal = (1 << tileComp->prec) - 1;
            zeroVal = 1 << (tileComp->prec - 1);
            dataPtr = tileComp->data;
            for (y = 0; y < tileComp->y1 - tileComp->y0; ++y) {
                for (x = 0; x < tileComp->x1 - tileComp->x0; ++x) {
                    coeff = *dataPtr;
                    if (tileComp->transform == 0) {
                        cover(112);
                        coeff >>= fracBits;
                    }
                    coeff += zeroVal;
                    if (coeff < 0) {
                        cover(113);
                        coeff = 0;
                    } else if (coeff > maxVal) {
                        cover(114);
                        coeff = maxVal;
                    }
                    *dataPtr++ = coeff;
                }
            }
        }
    }

    return true;
}

bool JPXStream::readBoxHdr(unsigned int *boxType, unsigned int *boxLen, unsigned int *dataLen)
{
    unsigned int len, lenH;

    if (!readULong(&len) || !readULong(boxType)) {
        return false;
    }
    if (len == 1) {
        if (!readULong(&lenH) || !readULong(&len)) {
            return false;
        }
        if (lenH) {
            error(errSyntaxError, getPos(), "JPX stream contains a box larger than 2^32 bytes");
            return false;
        }
        *boxLen = len;
        *dataLen = len - 16;
    } else if (len == 0) {
        *boxLen = 0;
        *dataLen = 0;
    } else {
        *boxLen = len;
        *dataLen = len - 8;
    }
    return true;
}

int JPXStream::readMarkerHdr(int *segType, unsigned int *segLen)
{
    int c;

    do {
        do {
            if ((c = bufStr->getChar()) == EOF) {
                return false;
            }
        } while (c != 0xff);
        do {
            if ((c = bufStr->getChar()) == EOF) {
                return false;
            }
        } while (c == 0xff);
    } while (c == 0x00);
    *segType = c;
    if ((c >= 0x30 && c <= 0x3f) || c == 0x4f || c == 0x92 || c == 0x93 || c == 0xd9) {
        *segLen = 0;
        return true;
    }
    return readUWord(segLen);
}

bool JPXStream::readUByte(unsigned int *x)
{
    int c0;

    if ((c0 = bufStr->getChar()) == EOF) {
        return false;
    }
    *x = (unsigned int)c0;
    return true;
}

bool JPXStream::readByte(int *x)
{
    int c0;

    if ((c0 = bufStr->getChar()) == EOF) {
        return false;
    }
    *x = c0;
    if (c0 & 0x80) {
        *x |= -1 - 0xff;
    }
    return true;
}

bool JPXStream::readUWord(unsigned int *x)
{
    int c0, c1;

    if ((c0 = bufStr->getChar()) == EOF || (c1 = bufStr->getChar()) == EOF) {
        return false;
    }
    *x = (unsigned int)((c0 << 8) | c1);
    return true;
}

bool JPXStream::readULong(unsigned int *x)
{
    int c0, c1, c2, c3;

    if ((c0 = bufStr->getChar()) == EOF || (c1 = bufStr->getChar()) == EOF || (c2 = bufStr->getChar()) == EOF || (c3 = bufStr->getChar()) == EOF) {
        return false;
    }
    *x = (unsigned int)((c0 << 24) | (c1 << 16) | (c2 << 8) | c3);
    return true;
}

bool JPXStream::readNBytes(int nBytes, bool signd, int *x)
{
    int y, c, i;

    y = 0;
    for (i = 0; i < nBytes; ++i) {
        if ((c = bufStr->getChar()) == EOF) {
            return false;
        }
        y = (y << 8) + c;
    }
    if (signd) {
        if (y & (1 << (8 * nBytes - 1))) {
            y |= -1 << (8 * nBytes);
        }
    }
    *x = y;
    return true;
}

void JPXStream::startBitBuf(unsigned int byteCountA)
{
    bitBufLen = 0;
    bitBufSkip = false;
    byteCount = byteCountA;
}

bool JPXStream::readBits(int nBits, unsigned int *x)
{
    int c;

    while (bitBufLen < nBits) {
        if (byteCount == 0 || (c = bufStr->getChar()) == EOF) {
            return false;
        }
        --byteCount;
        if (bitBufSkip) {
            bitBuf = (bitBuf << 7) | (c & 0x7f);
            bitBufLen += 7;
        } else {
            bitBuf = (bitBuf << 8) | (c & 0xff);
            bitBufLen += 8;
        }
        bitBufSkip = c == 0xff;
    }
    *x = (bitBuf >> (bitBufLen - nBits)) & ((1 << nBits) - 1);
    bitBufLen -= nBits;
    return true;
}

void JPXStream::skipSOP()
{
    int i;

    // SOP occurs at the start of the packet header, so we don't need to
    // worry about bit-stuff prior to it
    if (byteCount >= 6 && bufStr->lookChar(0) == 0xff && bufStr->lookChar(1) == 0x91) {
        for (i = 0; i < 6; ++i) {
            bufStr->getChar();
        }
        byteCount -= 6;
        bitBufLen = 0;
        bitBufSkip = false;
    }
}

void JPXStream::skipEPH()
{
    int i, k;

    k = bitBufSkip ? 1 : 0;
    if (byteCount >= (unsigned int)(k + 2) && bufStr->lookChar(k) == 0xff && bufStr->lookChar(k + 1) == 0x92) {
        for (i = 0; i < k + 2; ++i) {
            bufStr->getChar();
        }
        byteCount -= k + 2;
        bitBufLen = 0;
        bitBufSkip = false;
    }
}

unsigned int JPXStream::finishBitBuf()
{
    if (bitBufSkip) {
        bufStr->getChar();
        --byteCount;
    }
    return byteCount;
}