| //======================================================================== |
| // |
| // JPXStream.h |
| // |
| // Copyright 2002-2003 Glyph & Cog, LLC |
| // |
| //======================================================================== |
| |
| #ifndef JPXSTREAM_H |
| #define JPXSTREAM_H |
| |
| #include "Object.h" |
| #include "Stream.h" |
| |
| class JArithmeticDecoder; |
| class JArithmeticDecoderStats; |
| |
| //------------------------------------------------------------------------ |
| |
| enum JPXColorSpaceType { |
| jpxCSBiLevel = 0, |
| jpxCSYCbCr1 = 1, |
| jpxCSYCbCr2 = 3, |
| jpxCSYCBCr3 = 4, |
| jpxCSPhotoYCC = 9, |
| jpxCSCMY = 11, |
| jpxCSCMYK = 12, |
| jpxCSYCCK = 13, |
| jpxCSCIELab = 14, |
| jpxCSsRGB = 16, |
| jpxCSGrayscale = 17, |
| jpxCSBiLevel2 = 18, |
| jpxCSCIEJab = 19, |
| jpxCSCISesRGB = 20, |
| jpxCSROMMRGB = 21, |
| jpxCSsRGBYCbCr = 22, |
| jpxCSYPbPr1125 = 23, |
| jpxCSYPbPr1250 = 24 |
| }; |
| |
| struct JPXColorSpecCIELab { |
| unsigned int rl, ol, ra, oa, rb, ob, il; |
| }; |
| |
| struct JPXColorSpecEnumerated { |
| JPXColorSpaceType type; // color space type |
| union { |
| JPXColorSpecCIELab cieLab; |
| }; |
| }; |
| |
| struct JPXColorSpec { |
| unsigned int meth; // method |
| int prec; // precedence |
| union { |
| JPXColorSpecEnumerated enumerated; |
| }; |
| }; |
| |
| //------------------------------------------------------------------------ |
| |
| struct JPXPalette { |
| unsigned int nEntries; // number of entries in the palette |
| unsigned int nComps; // number of components in each entry |
| unsigned int *bpc; // bits per component, for each component |
| int *c; // color data: |
| // c[i*nComps+j] = entry i, component j |
| }; |
| |
| //------------------------------------------------------------------------ |
| |
| struct JPXCompMap { |
| unsigned int nChannels; // number of channels |
| unsigned int *comp; // codestream components mapped to each channel |
| unsigned int *type; // 0 for direct use, 1 for palette mapping |
| unsigned int *pComp; // palette components to use |
| }; |
| |
| //------------------------------------------------------------------------ |
| |
| struct JPXChannelDefn { |
| unsigned int nChannels; // number of channels |
| unsigned int *idx; // channel indexes |
| unsigned int *type; // channel types |
| unsigned int *assoc; // channel associations |
| }; |
| |
| //------------------------------------------------------------------------ |
| |
| struct JPXTagTreeNode { |
| bool finished; // true if this node is finished |
| unsigned int val; // current value |
| }; |
| |
| //------------------------------------------------------------------------ |
| |
| struct JPXCodeBlock { |
| //----- size |
| unsigned int x0, y0, x1, y1; // bounds |
| |
| //----- persistent state |
| bool seen; // true if this code-block has already |
| // been seen |
| unsigned int lBlock; // base number of bits used for pkt data length |
| unsigned int nextPass; // next coding pass |
| |
| //---- info from first packet |
| unsigned int nZeroBitPlanes; // number of zero bit planes |
| |
| //----- info for the current packet |
| unsigned int included; // code-block inclusion in this packet: |
| // 0=not included, 1=included |
| unsigned int nCodingPasses; // number of coding passes in this pkt |
| unsigned int *dataLen; // data lengths (one per codeword segment) |
| unsigned int dataLenSize; // size of the dataLen array |
| |
| //----- coefficient data |
| int *coeffs; |
| char *touched; // coefficient 'touched' flags |
| unsigned short len; // coefficient length |
| JArithmeticDecoder // arithmetic decoder |
| *arithDecoder; |
| JArithmeticDecoderStats // arithmetic decoder stats |
| *stats; |
| }; |
| |
| //------------------------------------------------------------------------ |
| |
| struct JPXSubband { |
| //----- computed |
| unsigned int x0, y0, x1, y1; // bounds |
| unsigned int nXCBs, nYCBs; // number of code-blocks in the x and y |
| // directions |
| |
| //----- tag trees |
| unsigned int maxTTLevel; // max tag tree level |
| JPXTagTreeNode *inclusion; // inclusion tag tree for each subband |
| JPXTagTreeNode *zeroBitPlane; // zero-bit plane tag tree for each |
| // subband |
| |
| //----- children |
| JPXCodeBlock *cbs; // the code-blocks (len = nXCBs * nYCBs) |
| }; |
| |
| //------------------------------------------------------------------------ |
| |
| struct JPXPrecinct { |
| //----- computed |
| unsigned int x0, y0, x1, y1; // bounds of the precinct |
| |
| //----- children |
| JPXSubband *subbands; // the subbands |
| }; |
| |
| //------------------------------------------------------------------------ |
| |
| struct JPXResLevel { |
| //----- from the COD and COC segments (main and tile) |
| unsigned int precinctWidth; // log2(precinct width) |
| unsigned int precinctHeight; // log2(precinct height) |
| |
| //----- computed |
| unsigned int x0, y0, x1, y1; // bounds of the tile-comp (for this res level) |
| unsigned int bx0[3], by0[3], // subband bounds |
| bx1[3], by1[3]; |
| |
| //---- children |
| JPXPrecinct *precincts; // the precincts |
| }; |
| |
| //------------------------------------------------------------------------ |
| |
| struct JPXTileComp { |
| //----- from the SIZ segment |
| bool sgned; // 1 for signed, 0 for unsigned |
| unsigned int prec; // precision, in bits |
| unsigned int hSep; // horizontal separation of samples |
| unsigned int vSep; // vertical separation of samples |
| |
| //----- from the COD and COC segments (main and tile) |
| unsigned int style; // coding style parameter (Scod / Scoc) |
| unsigned int nDecompLevels; // number of decomposition levels |
| unsigned int codeBlockW; // log2(code-block width) |
| unsigned int codeBlockH; // log2(code-block height) |
| unsigned int codeBlockStyle; // code-block style |
| unsigned int transform; // wavelet transformation |
| |
| //----- from the QCD and QCC segments (main and tile) |
| unsigned int quantStyle; // quantization style |
| unsigned int *quantSteps; // quantization step size for each subband |
| unsigned int nQuantSteps; // number of entries in quantSteps |
| |
| //----- computed |
| unsigned int x0, y0, x1, y1; // bounds of the tile-comp, in ref coords |
| unsigned int w; // x1 - x0 |
| unsigned int cbW; // code-block width |
| unsigned int cbH; // code-block height |
| |
| //----- image data |
| int *data; // the decoded image data |
| int *buf; // intermediate buffer for the inverse |
| // transform |
| |
| //----- children |
| JPXResLevel *resLevels; // the resolution levels |
| // (len = nDecompLevels + 1) |
| }; |
| |
| //------------------------------------------------------------------------ |
| |
| struct JPXTile { |
| bool init; |
| |
| //----- from the COD segments (main and tile) |
| unsigned int progOrder; // progression order |
| unsigned int nLayers; // number of layers |
| unsigned int multiComp; // multiple component transformation |
| |
| //----- computed |
| unsigned int x0, y0, x1, y1; // bounds of the tile, in ref coords |
| unsigned int maxNDecompLevels; // max number of decomposition levels used |
| // in any component in this tile |
| |
| //----- progression order loop counters |
| unsigned int comp; // component |
| unsigned int res; // resolution level |
| unsigned int precinct; // precinct |
| unsigned int layer; // layer |
| |
| //----- children |
| JPXTileComp *tileComps; // the tile-components (len = JPXImage.nComps) |
| }; |
| |
| //------------------------------------------------------------------------ |
| |
| struct JPXImage { |
| //----- from the SIZ segment |
| unsigned int xSize, ySize; // size of reference grid |
| unsigned int xOffset, yOffset; // image offset |
| unsigned int xTileSize, yTileSize; // size of tiles |
| unsigned int xTileOffset, // offset of first tile |
| yTileOffset; |
| unsigned int nComps; // number of components |
| |
| //----- computed |
| unsigned int nXTiles; // number of tiles in x direction |
| unsigned int nYTiles; // number of tiles in y direction |
| |
| //----- children |
| JPXTile *tiles; // the tiles (len = nXTiles * nYTiles) |
| }; |
| |
| //------------------------------------------------------------------------ |
| |
| class JPXStream: public FilterStream { |
| public: |
| |
| JPXStream(Stream *strA); |
| virtual ~JPXStream(); |
| virtual StreamKind getKind() override { return strJPX; } |
| virtual void reset() override; |
| virtual void close() override; |
| virtual int getChar() override; |
| virtual int lookChar() override; |
| virtual GooString *getPSFilter(int psLevel, const char *indent) override; |
| virtual bool isBinary(bool last = true) override; |
| virtual void getImageParams(int *bitsPerComponent, |
| StreamColorSpaceMode *csMode) override; |
| |
| private: |
| |
| void fillReadBuf(); |
| void getImageParams2(int *bitsPerComponent, StreamColorSpaceMode *csMode); |
| bool readBoxes(); |
| bool readColorSpecBox(unsigned int dataLen); |
| bool readCodestream(unsigned int len); |
| bool readTilePart(); |
| bool readTilePartData(unsigned int tileIdx, |
| unsigned int tilePartLen, bool tilePartToEOC); |
| bool readCodeBlockData(JPXTileComp *tileComp, |
| JPXResLevel *resLevel, |
| JPXPrecinct *precinct, |
| JPXSubband *subband, |
| unsigned int res, unsigned int sb, |
| JPXCodeBlock *cb); |
| void inverseTransform(JPXTileComp *tileComp); |
| void inverseTransformLevel(JPXTileComp *tileComp, |
| unsigned int r, JPXResLevel *resLevel); |
| void inverseTransform1D(JPXTileComp *tileComp, int *data, |
| unsigned int offset, unsigned int n); |
| bool inverseMultiCompAndDC(JPXTile *tile); |
| bool readBoxHdr(unsigned int *boxType, unsigned int *boxLen, unsigned int *dataLen); |
| int readMarkerHdr(int *segType, unsigned int *segLen); |
| bool readUByte(unsigned int *x); |
| bool readByte(int *x); |
| bool readUWord(unsigned int *x); |
| bool readULong(unsigned int *x); |
| bool readNBytes(int nBytes, bool signd, int *x); |
| void startBitBuf(unsigned int byteCountA); |
| bool readBits(int nBits, unsigned int *x); |
| void skipSOP(); |
| void skipEPH(); |
| unsigned int finishBitBuf(); |
| |
| BufStream *bufStr; // buffered stream (for lookahead) |
| |
| unsigned int nComps; // number of components |
| unsigned int *bpc; // bits per component, for each component |
| unsigned int width, height; // image size |
| bool haveImgHdr; // set if a JP2/JPX image header has been |
| // found |
| JPXColorSpec cs; // color specification |
| bool haveCS; // set if a color spec has been found |
| JPXPalette palette; // the palette |
| bool havePalette; // set if a palette has been found |
| JPXCompMap compMap; // the component mapping |
| bool haveCompMap; // set if a component mapping has been found |
| JPXChannelDefn channelDefn; // channel definition |
| bool haveChannelDefn; // set if a channel defn has been found |
| |
| JPXImage img; // JPEG2000 decoder data |
| unsigned int bitBuf; // buffer for bit reads |
| int bitBufLen; // number of bits in bitBuf |
| bool bitBufSkip; // true if next bit should be skipped |
| // (for bit stuffing) |
| unsigned int byteCount; // number of available bytes left |
| |
| unsigned int curX, curY, curComp; // current position for lookChar/getChar |
| unsigned int readBuf; // read buffer |
| unsigned int readBufLen; // number of valid bits in readBuf |
| }; |
| |
| #endif |
