]>
Commit | Line | Data |
---|---|---|
ef416fc2 | 1 | //======================================================================== |
2 | // | |
3 | // JPXStream.h | |
4 | // | |
5 | // Copyright 2002-2003 Glyph & Cog, LLC | |
6 | // | |
7 | //======================================================================== | |
8 | ||
9 | #ifndef JPXSTREAM_H | |
10 | #define JPXSTREAM_H | |
11 | ||
12 | #include <config.h> | |
13 | ||
14 | #ifdef USE_GCC_PRAGMAS | |
15 | #pragma interface | |
16 | #endif | |
17 | ||
18 | #include "gtypes.h" | |
19 | #include "Object.h" | |
20 | #include "Stream.h" | |
21 | ||
22 | class JArithmeticDecoderStats; | |
23 | ||
24 | //------------------------------------------------------------------------ | |
25 | ||
26 | enum JPXColorSpaceType { | |
27 | jpxCSBiLevel = 0, | |
28 | jpxCSYCbCr1 = 1, | |
29 | jpxCSYCbCr2 = 3, | |
30 | jpxCSYCBCr3 = 4, | |
31 | jpxCSPhotoYCC = 9, | |
32 | jpxCSCMY = 11, | |
33 | jpxCSCMYK = 12, | |
34 | jpxCSYCCK = 13, | |
35 | jpxCSCIELab = 14, | |
36 | jpxCSsRGB = 16, | |
37 | jpxCSGrayscale = 17, | |
38 | jpxCSBiLevel2 = 18, | |
39 | jpxCSCIEJab = 19, | |
40 | jpxCSCISesRGB = 20, | |
41 | jpxCSROMMRGB = 21, | |
42 | jpxCSsRGBYCbCr = 22, | |
43 | jpxCSYPbPr1125 = 23, | |
44 | jpxCSYPbPr1250 = 24 | |
45 | }; | |
46 | ||
47 | struct JPXColorSpecCIELab { | |
48 | Guint rl, ol, ra, oa, rb, ob, il; | |
49 | }; | |
50 | ||
51 | struct JPXColorSpecEnumerated { | |
52 | JPXColorSpaceType type; // color space type | |
53 | union { | |
54 | JPXColorSpecCIELab cieLab; | |
55 | }; | |
56 | }; | |
57 | ||
58 | struct JPXColorSpec { | |
59 | Guint meth; // method | |
60 | int prec; // precedence | |
61 | union { | |
62 | JPXColorSpecEnumerated enumerated; | |
63 | }; | |
64 | }; | |
65 | ||
66 | //------------------------------------------------------------------------ | |
67 | ||
68 | struct JPXPalette { | |
69 | Guint nEntries; // number of entries in the palette | |
70 | Guint nComps; // number of components in each entry | |
71 | Guint *bpc; // bits per component, for each component | |
72 | int *c; // color data: | |
73 | // c[i*nComps+j] = entry i, component j | |
74 | }; | |
75 | ||
76 | //------------------------------------------------------------------------ | |
77 | ||
78 | struct JPXCompMap { | |
79 | Guint nChannels; // number of channels | |
80 | Guint *comp; // codestream components mapped to each channel | |
81 | Guint *type; // 0 for direct use, 1 for palette mapping | |
82 | Guint *pComp; // palette components to use | |
83 | }; | |
84 | ||
85 | //------------------------------------------------------------------------ | |
86 | ||
87 | struct JPXChannelDefn { | |
88 | Guint nChannels; // number of channels | |
89 | Guint *idx; // channel indexes | |
90 | Guint *type; // channel types | |
91 | Guint *assoc; // channel associations | |
92 | }; | |
93 | ||
94 | //------------------------------------------------------------------------ | |
95 | ||
96 | struct JPXTagTreeNode { | |
97 | GBool finished; // true if this node is finished | |
98 | Guint val; // current value | |
99 | }; | |
100 | ||
101 | //------------------------------------------------------------------------ | |
102 | ||
103 | struct JPXCoeff { | |
104 | Gushort flags; // flag bits | |
105 | Gushort len; // number of significant bits in mag | |
106 | Guint mag; // magnitude value | |
107 | }; | |
108 | ||
109 | // coefficient flags | |
110 | #define jpxCoeffSignificantB 0 | |
111 | #define jpxCoeffTouchedB 1 | |
112 | #define jpxCoeffFirstMagRefB 2 | |
113 | #define jpxCoeffSignB 7 | |
114 | #define jpxCoeffSignificant (1 << jpxCoeffSignificantB) | |
115 | #define jpxCoeffTouched (1 << jpxCoeffTouchedB) | |
116 | #define jpxCoeffFirstMagRef (1 << jpxCoeffFirstMagRefB) | |
117 | #define jpxCoeffSign (1 << jpxCoeffSignB) | |
118 | ||
119 | //------------------------------------------------------------------------ | |
120 | ||
121 | struct JPXCodeBlock { | |
122 | //----- size | |
123 | Guint x0, y0, x1, y1; // bounds | |
124 | ||
125 | //----- persistent state | |
126 | GBool seen; // true if this code-block has already | |
127 | // been seen | |
128 | Guint lBlock; // base number of bits used for pkt data length | |
129 | Guint nextPass; // next coding pass | |
130 | ||
131 | //---- info from first packet | |
132 | Guint nZeroBitPlanes; // number of zero bit planes | |
133 | ||
134 | //----- info for the current packet | |
135 | Guint included; // code-block inclusion in this packet: | |
136 | // 0=not included, 1=included | |
137 | Guint nCodingPasses; // number of coding passes in this pkt | |
138 | Guint dataLen; // pkt data length | |
139 | ||
140 | //----- coefficient data | |
141 | JPXCoeff *coeffs; // the coefficients | |
142 | JArithmeticDecoder // arithmetic decoder | |
143 | *arithDecoder; | |
144 | JArithmeticDecoderStats // arithmetic decoder stats | |
145 | *stats; | |
146 | }; | |
147 | ||
148 | //------------------------------------------------------------------------ | |
149 | ||
150 | struct JPXSubband { | |
151 | //----- computed | |
152 | Guint x0, y0, x1, y1; // bounds | |
153 | Guint nXCBs, nYCBs; // number of code-blocks in the x and y | |
154 | // directions | |
155 | ||
156 | //----- tag trees | |
157 | Guint maxTTLevel; // max tag tree level | |
158 | JPXTagTreeNode *inclusion; // inclusion tag tree for each subband | |
159 | JPXTagTreeNode *zeroBitPlane; // zero-bit plane tag tree for each | |
160 | // subband | |
161 | ||
162 | //----- children | |
163 | JPXCodeBlock *cbs; // the code-blocks (len = nXCBs * nYCBs) | |
164 | }; | |
165 | ||
166 | //------------------------------------------------------------------------ | |
167 | ||
168 | struct JPXPrecinct { | |
169 | //----- computed | |
170 | Guint x0, y0, x1, y1; // bounds of the precinct | |
171 | ||
172 | //----- children | |
173 | JPXSubband *subbands; // the subbands | |
174 | }; | |
175 | ||
176 | //------------------------------------------------------------------------ | |
177 | ||
178 | struct JPXResLevel { | |
179 | //----- from the COD and COC segments (main and tile) | |
180 | Guint precinctWidth; // log2(precinct width) | |
181 | Guint precinctHeight; // log2(precinct height) | |
182 | ||
183 | //----- computed | |
184 | Guint x0, y0, x1, y1; // bounds of the tile-comp (for this res level) | |
185 | Guint bx0[3], by0[3], // subband bounds | |
186 | bx1[3], by1[3]; | |
187 | ||
188 | //---- children | |
189 | JPXPrecinct *precincts; // the precincts | |
190 | }; | |
191 | ||
192 | //------------------------------------------------------------------------ | |
193 | ||
194 | struct JPXTileComp { | |
195 | //----- from the SIZ segment | |
196 | GBool sgned; // 1 for signed, 0 for unsigned | |
197 | Guint prec; // precision, in bits | |
198 | Guint hSep; // horizontal separation of samples | |
199 | Guint vSep; // vertical separation of samples | |
200 | ||
201 | //----- from the COD and COC segments (main and tile) | |
202 | Guint style; // coding style parameter (Scod / Scoc) | |
203 | Guint nDecompLevels; // number of decomposition levels | |
204 | Guint codeBlockW; // log2(code-block width) | |
205 | Guint codeBlockH; // log2(code-block height) | |
206 | Guint codeBlockStyle; // code-block style | |
207 | Guint transform; // wavelet transformation | |
208 | ||
209 | //----- from the QCD and QCC segments (main and tile) | |
210 | Guint quantStyle; // quantization style | |
211 | Guint *quantSteps; // quantization step size for each subband | |
212 | Guint nQuantSteps; // number of entries in quantSteps | |
213 | ||
214 | //----- computed | |
215 | Guint x0, y0, x1, y1; // bounds of the tile-comp, in ref coords | |
216 | Guint cbW; // code-block width | |
217 | Guint cbH; // code-block height | |
218 | ||
219 | //----- image data | |
220 | int *data; // the decoded image data | |
221 | int *buf; // intermediate buffer for the inverse | |
222 | // transform | |
223 | ||
224 | //----- children | |
225 | JPXResLevel *resLevels; // the resolution levels | |
226 | // (len = nDecompLevels + 1) | |
227 | }; | |
228 | ||
229 | //------------------------------------------------------------------------ | |
230 | ||
231 | struct JPXTile { | |
232 | //----- from the COD segments (main and tile) | |
233 | Guint progOrder; // progression order | |
234 | Guint nLayers; // number of layers | |
235 | Guint multiComp; // multiple component transformation | |
236 | ||
237 | //----- computed | |
238 | Guint x0, y0, x1, y1; // bounds of the tile, in ref coords | |
239 | Guint maxNDecompLevels; // max number of decomposition levels used | |
240 | // in any component in this tile | |
241 | ||
242 | //----- progression order loop counters | |
243 | Guint comp; // component | |
244 | Guint res; // resolution level | |
245 | Guint precinct; // precinct | |
246 | Guint layer; // layer | |
247 | ||
248 | //----- children | |
249 | JPXTileComp *tileComps; // the tile-components (len = JPXImage.nComps) | |
250 | }; | |
251 | ||
252 | //------------------------------------------------------------------------ | |
253 | ||
254 | struct JPXImage { | |
255 | //----- from the SIZ segment | |
256 | Guint xSize, ySize; // size of reference grid | |
257 | Guint xOffset, yOffset; // image offset | |
258 | Guint xTileSize, yTileSize; // size of tiles | |
259 | Guint xTileOffset, // offset of first tile | |
260 | yTileOffset; | |
261 | Guint nComps; // number of components | |
262 | ||
263 | //----- computed | |
264 | Guint nXTiles; // number of tiles in x direction | |
265 | Guint nYTiles; // number of tiles in y direction | |
266 | ||
267 | //----- children | |
268 | JPXTile *tiles; // the tiles (len = nXTiles * nYTiles) | |
269 | }; | |
270 | ||
271 | //------------------------------------------------------------------------ | |
272 | ||
273 | class JPXStream: public FilterStream { | |
274 | public: | |
275 | ||
276 | JPXStream(Stream *strA); | |
277 | virtual ~JPXStream(); | |
278 | virtual StreamKind getKind() { return strJPX; } | |
279 | virtual void reset(); | |
280 | virtual int getChar(); | |
281 | virtual int lookChar(); | |
282 | virtual GString *getPSFilter(int psLevel, char *indent); | |
283 | virtual GBool isBinary(GBool last = gTrue); | |
284 | virtual void getImageParams(int *bitsPerComponent, | |
285 | StreamColorSpaceMode *csMode); | |
286 | ||
287 | private: | |
288 | ||
289 | void fillReadBuf(); | |
290 | void getImageParams2(int *bitsPerComponent, StreamColorSpaceMode *csMode); | |
291 | GBool readBoxes(); | |
292 | GBool readColorSpecBox(Guint dataLen); | |
293 | GBool readCodestream(Guint len); | |
294 | GBool readTilePart(); | |
295 | GBool readTilePartData(Guint tileIdx, | |
296 | Guint tilePartLen, GBool tilePartToEOC); | |
297 | GBool readCodeBlockData(JPXTileComp *tileComp, | |
298 | JPXResLevel *resLevel, | |
299 | JPXPrecinct *precinct, | |
300 | JPXSubband *subband, | |
301 | Guint res, Guint sb, | |
302 | JPXCodeBlock *cb); | |
303 | void inverseTransform(JPXTileComp *tileComp); | |
304 | void inverseTransformLevel(JPXTileComp *tileComp, | |
305 | Guint r, JPXResLevel *resLevel, | |
306 | Guint nx0, Guint ny0, | |
307 | Guint nx1, Guint ny1); | |
308 | void inverseTransform1D(JPXTileComp *tileComp, | |
309 | int *data, Guint stride, | |
310 | Guint i0, Guint i1); | |
311 | GBool inverseMultiCompAndDC(JPXTile *tile); | |
312 | GBool readBoxHdr(Guint *boxType, Guint *boxLen, Guint *dataLen); | |
313 | int readMarkerHdr(int *segType, Guint *segLen); | |
314 | GBool readUByte(Guint *x); | |
315 | GBool readByte(int *x); | |
316 | GBool readUWord(Guint *x); | |
317 | GBool readULong(Guint *x); | |
318 | GBool readNBytes(int nBytes, GBool signd, int *x); | |
319 | GBool readBits(int nBits, Guint *x); | |
320 | void clearBitBuf(); | |
321 | ||
322 | Guint nComps; // number of components | |
323 | Guint *bpc; // bits per component, for each component | |
324 | Guint width, height; // image size | |
325 | GBool haveImgHdr; // set if a JP2/JPX image header has been | |
326 | // found | |
327 | JPXColorSpec cs; // color specification | |
328 | GBool haveCS; // set if a color spec has been found | |
329 | JPXPalette palette; // the palette | |
330 | GBool havePalette; // set if a palette has been found | |
331 | JPXCompMap compMap; // the component mapping | |
332 | GBool haveCompMap; // set if a component mapping has been found | |
333 | JPXChannelDefn channelDefn; // channel definition | |
334 | GBool haveChannelDefn; // set if a channel defn has been found | |
335 | ||
336 | JPXImage img; // JPEG2000 decoder data | |
337 | Guint bitBuf; // buffer for bit reads | |
338 | int bitBufLen; // number of bits in bitBuf | |
339 | GBool bitBufSkip; // true if next bit should be skipped | |
340 | // (for bit stuffing) | |
341 | Guint byteCount; // number of bytes read since last call | |
342 | // to clearBitBuf | |
343 | ||
344 | Guint curX, curY, curComp; // current position for lookChar/getChar | |
345 | Guint readBuf; // read buffer | |
346 | Guint readBufLen; // number of valid bits in readBuf | |
347 | }; | |
348 | ||
349 | #endif |