---

JPXStream.h

Go to the documentation of this file.

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

#ifndef JPXSTREAM_H
#define JPXSTREAM_H

#include <aconf.h>

#ifdef USE_GCC_PRAGMAS
#pragma interface
#endif

#include "gtypes.h"
#include "Object.h"
#include "Stream.h"

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 JPXColorSpec {
  Guint meth;                   // method
  int prec;                     // precedence
  union {
    struct {
      JPXColorSpaceType type;   // color space type
      union {
        struct {
          Guint rl, ol, ra, oa, rb, ob, il;
        } cieLab;
      };
    } enumerated;
  };
};

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

struct JPXPalette {
  Guint nEntries;               // number of entries in the palette
  Guint nComps;                 // number of components in each entry
  Guint *bpc;                   // bits per component, for each component
  int *c;                       // color data:
                                //   c[i*nComps+j] = entry i, component j
};

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

struct JPXCompMap {
  Guint nChannels;              // number of channels
  Guint *comp;                  // codestream components mapped to each channel
  Guint *type;                  // 0 for direct use, 1 for palette mapping
  Guint *pComp;                 // palette components to use
};

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

struct JPXChannelDefn {
  Guint nChannels;              // number of channels
  Guint *idx;                   // channel indexes
  Guint *type;                  // channel types
  Guint *assoc;                 // channel associations
};

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

struct JPXTagTreeNode {
  GBool finished;               // true if this node is finished
  Guint val;                    // current value
};

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

struct JPXCoeff {
  Gushort flags;                // flag bits
  Gushort len;                  // number of significant bits in mag
  Guint mag;                    // magnitude value
};

// coefficient flags
#define jpxCoeffSignificantB  0
#define jpxCoeffTouchedB      1
#define jpxCoeffFirstMagRefB  2
#define jpxCoeffSignB         7
#define jpxCoeffSignificant   (1 << jpxCoeffSignificantB)
#define jpxCoeffTouched       (1 << jpxCoeffTouchedB)
#define jpxCoeffFirstMagRef   (1 << jpxCoeffFirstMagRefB)
#define jpxCoeffSign          (1 << jpxCoeffSignB)

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

struct JPXCodeBlock {
  //----- size
  Guint x0, y0, x1, y1;         // bounds

  //----- persistent state
  GBool seen;                   // true if this code-block has already
                                //   been seen
  Guint lBlock;                 // base number of bits used for pkt data length
  Guint nextPass;               // next coding pass

  //---- info from first packet
  Guint nZeroBitPlanes;         // number of zero bit planes

  //----- info for the current packet
  Guint included;               // code-block inclusion in this packet:
                                //   0=not included, 1=included
  Guint nCodingPasses;          // number of coding passes in this pkt
  Guint dataLen;                // pkt data length

  //----- coefficient data
  JPXCoeff *coeffs;             // the coefficients
  JArithmeticDecoderStats       // arithmetic decoder stats
    *stats;
};

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

struct JPXSubband {
  //----- computed
  Guint x0, y0, x1, y1;         // bounds
  Guint nXCBs, nYCBs;           // number of code-blocks in the x and y
                                //   directions

  //----- tag trees
  Guint 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
  Guint x0, y0, x1, y1;         // bounds of the precinct

  //----- children
  JPXSubband *subbands;         // the subbands
};

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

struct JPXResLevel {
  //----- from the COD and COC segments (main and tile)
  Guint precinctWidth;          // log2(precinct width)
  Guint precinctHeight;         // log2(precinct height)

  //----- computed
  Guint x0, y0, x1, y1;         // bounds of the tile-comp (for this res level)
  Guint bx0[3], by0[3],         // subband bounds
        bx1[3], by1[3];

  //---- children
  JPXPrecinct *precincts;       // the precincts
};

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

struct JPXTileComp {
  //----- from the SIZ segment
  GBool sgned;                  // 1 for signed, 0 for unsigned
  Guint prec;                   // precision, in bits
  Guint hSep;                   // horizontal separation of samples
  Guint vSep;                   // vertical separation of samples

  //----- from the COD and COC segments (main and tile)
  Guint style;                  // coding style parameter (Scod / Scoc)
  Guint nDecompLevels;          // number of decomposition levels
  Guint codeBlockW;             // log2(code-block width)
  Guint codeBlockH;             // log2(code-block height)
  Guint codeBlockStyle;         // code-block style
  Guint transform;              // wavelet transformation

  //----- from the QCD and QCC segments (main and tile)
  Guint quantStyle;             // quantization style
  Guint *quantSteps;            // quantization step size for each subband
  Guint nQuantSteps;            // number of entries in quantSteps

  //----- computed
  Guint x0, y0, x1, y1;         // bounds of the tile-comp, in ref coords
  Guint cbW;                    // code-block width
  Guint 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 {
  //----- from the COD segments (main and tile)
  Guint progOrder;              // progression order
  Guint nLayers;                // number of layers
  Guint multiComp;              // multiple component transformation

  //----- computed
  Guint x0, y0, x1, y1;         // bounds of the tile, in ref coords
  Guint maxNDecompLevels;       // max number of decomposition levels used
                                //   in any component in this tile

  //----- progression order loop counters
  Guint comp;                   //   component
  Guint res;                    //   resolution level
  Guint precinct;               //   precinct
  Guint layer;                  //   layer

  //----- children
  JPXTileComp *tileComps;       // the tile-components (len = JPXImage.nComps)
};

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

struct JPXImage {
  //----- from the SIZ segment
  Guint xSize, ySize;           // size of reference grid
  Guint xOffset, yOffset;       // image offset
  Guint xTileSize, yTileSize;   // size of tiles
  Guint xTileOffset,            // offset of first tile
        yTileOffset;
  Guint nComps;                 // number of components

  //----- computed
  Guint nXTiles;                // number of tiles in x direction
  Guint 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() { return strJPX; }
  virtual void reset();
  virtual int getChar();
  virtual int lookChar();
  virtual GString *getPSFilter(int psLevel, char *indent);
  virtual GBool isBinary(GBool last = gTrue);

private:

  void fillReadBuf();
  GBool readBoxes();
  GBool readColorSpecBox(Guint dataLen);
  GBool readCodestream(Guint len);
  GBool readTilePart();
  GBool readTilePartData(Guint tileIdx,
                         Guint tilePartLen, GBool tilePartToEOC);
  GBool readCodeBlockData(JPXTileComp *tileComp,
                          JPXResLevel *resLevel,
                          JPXPrecinct *precinct,
                          JPXSubband *subband,
                          Guint res, Guint sb,
                          JPXCodeBlock *cb);
  void inverseTransform(JPXTileComp *tileComp);
  void inverseTransformLevel(JPXTileComp *tileComp,
                             Guint r, JPXResLevel *resLevel,
                             Guint nx0, Guint ny0,
                             Guint nx1, Guint ny1);
  void inverseTransform1D(JPXTileComp *tileComp,
                          int *data, Guint stride,
                          Guint i0, Guint i1);
  GBool inverseMultiCompAndDC(JPXTile *tile);
  GBool readBoxHdr(Guint *boxType, Guint *boxLen, Guint *dataLen);
  int readMarkerHdr(int *segType, Guint *segLen);
  GBool readUByte(Guint *x);
  GBool readByte(int *x);
  GBool readUWord(Guint *x);
  GBool readULong(Guint *x);
  GBool readNBytes(int nBytes, GBool signd, int *x);
  GBool readBits(int nBits, Guint *x);
  void clearBitBuf();

  Guint nComps;                 // number of components
  Guint *bpc;                   // bits per component, for each component
  Guint width, height;          // image size
  GBool haveImgHdr;             // set if a JP2/JPX image header has been
                                //   found
  JPXColorSpec cs;              // color specification
  GBool haveCS;                 // set if a color spec has been found
  JPXPalette palette;           // the palette
  GBool havePalette;            // set if a palette has been found
  JPXCompMap compMap;           // the component mapping
  GBool haveCompMap;            // set if a component mapping has been found
  JPXChannelDefn channelDefn;   // channel definition
  GBool haveChannelDefn;        // set if a channel defn has been found

  JPXImage img;                 // JPEG2000 decoder data
  Guint bitBuf;                 // buffer for bit reads
  int bitBufLen;                // number of bits in bitBuf
  GBool bitBufSkip;             // true if next bit should be skipped
                                //   (for bit stuffing)
  Guint byteCount;              // number of bytes read since last call
                                //   to clearBitBuf

  Guint curX, curY, curComp;    // current position for lookChar/getChar
  Guint readBuf;                // read buffer
  Guint readBufLen;             // number of valid bits in readBuf
};

#endif

---