1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
|
//========================================================================
//
// JPXStream.h
//
// Copyright 2002-2003 Glyph & Cog, LLC
//
//========================================================================
#ifndef JPXSTREAM_H
#define JPXSTREAM_H
#include <aconf.h>
#include "gtypes.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 {
Guint rl, ol, ra, oa, rb, ob, il;
};
struct JPXColorSpecEnumerated {
JPXColorSpaceType type; // color space type
union {
JPXColorSpecCIELab cieLab;
};
};
struct JPXColorSpec {
Guint meth; // method
int prec; // precedence
union {
JPXColorSpecEnumerated 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 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; // data lengths (one per codeword segment)
Guint dataLenSize; // size of the dataLen array
//----- coefficient data
int *coeffs;
char *touched; // coefficient 'touched' flags
Gushort len; // coefficient length
JArithmeticDecoder // arithmetic decoder
*arithDecoder;
JArithmeticDecoderStats // arithmetic decoder stats
*stats;
};
//------------------------------------------------------------------------
struct JPXSubband {
//----- computed
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 {
//----- 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)
Guint nPrecincts;
//----- computed
Guint x0, y0, x1, y1; // bounds of this tile-comp at this res level
Guint bx0[3], by0[3], // subband bounds
bx1[3], by1[3];
Guint codeBlockW; // log2(code-block width)
Guint codeBlockH; // log2(code-block height)
Guint cbW; // code-block width
Guint cbH; // code-block height
GBool empty; // true if all subbands and precincts are
// zero width or height
//---- 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 x0r, y0r; // x0 >> reduction, y0 >> reduction
Guint w, h; // data size = {x1 - x0, y1 - y0} >> reduction
//----- 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 {
GBool init;
//----- 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
Guint maxNPrecincts; // max number of precints in any
// component/res level in this tile
//----- progression order loop counters
Guint comp; // component
Guint res; // resolution level
Guint precinct; // precinct
Guint layer; // layer
GBool done; // set when this tile is done
//----- tile part info
Guint nextTilePart; // next expected tile-part
//----- 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 xSizeR, ySizeR; // size of reference grid >> reduction
Guint xOffsetR, yOffsetR; // image offset >> reduction
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)
};
//------------------------------------------------------------------------
enum JPXDecodeResult {
jpxDecodeOk,
jpxDecodeNonFatalError,
jpxDecodeFatalError
};
//------------------------------------------------------------------------
class JPXStream: public FilterStream {
public:
JPXStream(Stream *strA);
virtual ~JPXStream();
virtual Stream *copy();
virtual StreamKind getKind() { return strJPX; }
virtual void reset();
virtual void close();
virtual int getChar();
virtual int lookChar();
virtual GString *getPSFilter(int psLevel, const char *indent,
GBool okToReadStream);
virtual GBool isBinary(GBool last = gTrue);
virtual GBool hasStrongCompression() { return gTrue; }
virtual void getImageParams(int *bitsPerComponent,
StreamColorSpaceMode *csMode);
void reduceResolution(int reductionA) { reduction = reductionA; }
private:
void decodeImage();
void fillReadBuf();
void getImageParams2(int *bitsPerComponent, StreamColorSpaceMode *csMode);
JPXDecodeResult readBoxes();
GBool readColorSpecBox(Guint dataLen);
JPXDecodeResult 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);
void inverseTransform1D(JPXTileComp *tileComp, int *data,
Guint offset, Guint n);
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);
void startBitBuf(Guint byteCountA);
GBool readBits(int nBits, Guint *x);
void skipSOP();
void skipEPH();
Guint finishBitBuf();
BufStream *bufStr; // buffered stream (for lookahead)
GBool decoded; // set when the image has been decoded
Guint nComps; // number of components
Guint *bpc; // bits per component, for each component
Guint width, height; // image size
int reduction; // log2(reduction in resolution)
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 available bytes left
Guint curX, curY, curComp; // current position for lookChar/getChar
Guint readBuf; // read buffer
Guint readBufLen; // number of valid bits in readBuf
};
#endif
|