Go to most recent revision | Details | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
4349 | Serge | 1 | /* |
2 | * JPEG 2000 image decoder |
||
3 | * Copyright (c) 2007 Kamil Nowosad |
||
4 | * Copyright (c) 2013 Nicolas Bertrand |
||
5 | * |
||
6 | * This file is part of FFmpeg. |
||
7 | * |
||
8 | * FFmpeg is free software; you can redistribute it and/or |
||
9 | * modify it under the terms of the GNU Lesser General Public |
||
10 | * License as published by the Free Software Foundation; either |
||
11 | * version 2.1 of the License, or (at your option) any later version. |
||
12 | * |
||
13 | * FFmpeg is distributed in the hope that it will be useful, |
||
14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
||
15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
||
16 | * Lesser General Public License for more details. |
||
17 | * |
||
18 | * You should have received a copy of the GNU Lesser General Public |
||
19 | * License along with FFmpeg; if not, write to the Free Software |
||
20 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
||
21 | */ |
||
22 | |||
23 | /** |
||
24 | * @file |
||
25 | * JPEG 2000 image decoder |
||
26 | */ |
||
27 | |||
28 | #include "libavutil/avassert.h" |
||
29 | #include "libavutil/common.h" |
||
30 | #include "libavutil/opt.h" |
||
31 | #include "libavutil/pixdesc.h" |
||
32 | #include "avcodec.h" |
||
33 | #include "bytestream.h" |
||
34 | #include "internal.h" |
||
35 | #include "thread.h" |
||
36 | #include "jpeg2000.h" |
||
37 | |||
38 | #define JP2_SIG_TYPE 0x6A502020 |
||
39 | #define JP2_SIG_VALUE 0x0D0A870A |
||
40 | #define JP2_CODESTREAM 0x6A703263 |
||
41 | #define JP2_HEADER 0x6A703268 |
||
42 | |||
43 | #define HAD_COC 0x01 |
||
44 | #define HAD_QCC 0x02 |
||
45 | |||
46 | typedef struct Jpeg2000TilePart { |
||
47 | uint8_t tile_index; // Tile index who refers the tile-part |
||
48 | const uint8_t *tp_end; |
||
49 | GetByteContext tpg; // bit stream in tile-part |
||
50 | } Jpeg2000TilePart; |
||
51 | |||
52 | /* RMK: For JPEG2000 DCINEMA 3 tile-parts in a tile |
||
53 | * one per component, so tile_part elements have a size of 3 */ |
||
54 | typedef struct Jpeg2000Tile { |
||
55 | Jpeg2000Component *comp; |
||
56 | uint8_t properties[4]; |
||
57 | Jpeg2000CodingStyle codsty[4]; |
||
58 | Jpeg2000QuantStyle qntsty[4]; |
||
59 | Jpeg2000TilePart tile_part[4]; |
||
60 | uint16_t tp_idx; // Tile-part index |
||
61 | } Jpeg2000Tile; |
||
62 | |||
63 | typedef struct Jpeg2000DecoderContext { |
||
64 | AVClass *class; |
||
65 | AVCodecContext *avctx; |
||
66 | GetByteContext g; |
||
67 | |||
68 | int width, height; |
||
69 | int image_offset_x, image_offset_y; |
||
70 | int tile_offset_x, tile_offset_y; |
||
71 | uint8_t cbps[4]; // bits per sample in particular components |
||
72 | uint8_t sgnd[4]; // if a component is signed |
||
73 | uint8_t properties[4]; |
||
74 | int cdx[4], cdy[4]; |
||
75 | int precision; |
||
76 | int ncomponents; |
||
77 | int colour_space; |
||
78 | uint32_t palette[256]; |
||
79 | int8_t pal8; |
||
80 | int cdef[4]; |
||
81 | int tile_width, tile_height; |
||
82 | unsigned numXtiles, numYtiles; |
||
83 | int maxtilelen; |
||
84 | |||
85 | Jpeg2000CodingStyle codsty[4]; |
||
86 | Jpeg2000QuantStyle qntsty[4]; |
||
87 | |||
88 | int bit_index; |
||
89 | |||
90 | int curtileno; |
||
91 | |||
92 | Jpeg2000Tile *tile; |
||
93 | |||
94 | /*options parameters*/ |
||
95 | int reduction_factor; |
||
96 | } Jpeg2000DecoderContext; |
||
97 | |||
98 | /* get_bits functions for JPEG2000 packet bitstream |
||
99 | * It is a get_bit function with a bit-stuffing routine. If the value of the |
||
100 | * byte is 0xFF, the next byte includes an extra zero bit stuffed into the MSB. |
||
101 | * cf. ISO-15444-1:2002 / B.10.1 Bit-stuffing routine */ |
||
102 | static int get_bits(Jpeg2000DecoderContext *s, int n) |
||
103 | { |
||
104 | int res = 0; |
||
105 | |||
106 | while (--n >= 0) { |
||
107 | res <<= 1; |
||
108 | if (s->bit_index == 0) { |
||
109 | s->bit_index = 7 + (bytestream2_get_byte(&s->g) != 0xFFu); |
||
110 | } |
||
111 | s->bit_index--; |
||
112 | res |= (bytestream2_peek_byte(&s->g) >> s->bit_index) & 1; |
||
113 | } |
||
114 | return res; |
||
115 | } |
||
116 | |||
117 | static void jpeg2000_flush(Jpeg2000DecoderContext *s) |
||
118 | { |
||
119 | if (bytestream2_get_byte(&s->g) == 0xff) |
||
120 | bytestream2_skip(&s->g, 1); |
||
121 | s->bit_index = 8; |
||
122 | } |
||
123 | |||
124 | /* decode the value stored in node */ |
||
125 | static int tag_tree_decode(Jpeg2000DecoderContext *s, Jpeg2000TgtNode *node, |
||
126 | int threshold) |
||
127 | { |
||
128 | Jpeg2000TgtNode *stack[30]; |
||
129 | int sp = -1, curval = 0; |
||
130 | |||
131 | if (!node) |
||
132 | return AVERROR_INVALIDDATA; |
||
133 | |||
134 | while (node && !node->vis) { |
||
135 | stack[++sp] = node; |
||
136 | node = node->parent; |
||
137 | } |
||
138 | |||
139 | if (node) |
||
140 | curval = node->val; |
||
141 | else |
||
142 | curval = stack[sp]->val; |
||
143 | |||
144 | while (curval < threshold && sp >= 0) { |
||
145 | if (curval < stack[sp]->val) |
||
146 | curval = stack[sp]->val; |
||
147 | while (curval < threshold) { |
||
148 | int ret; |
||
149 | if ((ret = get_bits(s, 1)) > 0) { |
||
150 | stack[sp]->vis++; |
||
151 | break; |
||
152 | } else if (!ret) |
||
153 | curval++; |
||
154 | else |
||
155 | return ret; |
||
156 | } |
||
157 | stack[sp]->val = curval; |
||
158 | sp--; |
||
159 | } |
||
160 | return curval; |
||
161 | } |
||
162 | |||
163 | static int pix_fmt_match(enum AVPixelFormat pix_fmt, int components, |
||
164 | int bpc, uint32_t log2_chroma_wh, int pal8) |
||
165 | { |
||
166 | int match = 1; |
||
167 | const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt); |
||
168 | |||
169 | if (desc->nb_components != components) { |
||
170 | return 0; |
||
171 | } |
||
172 | |||
173 | switch (components) { |
||
174 | case 4: |
||
175 | match = match && desc->comp[3].depth_minus1 + 1 >= bpc && |
||
176 | (log2_chroma_wh >> 14 & 3) == 0 && |
||
177 | (log2_chroma_wh >> 12 & 3) == 0; |
||
178 | case 3: |
||
179 | match = match && desc->comp[2].depth_minus1 + 1 >= bpc && |
||
180 | (log2_chroma_wh >> 10 & 3) == desc->log2_chroma_w && |
||
181 | (log2_chroma_wh >> 8 & 3) == desc->log2_chroma_h; |
||
182 | case 2: |
||
183 | match = match && desc->comp[1].depth_minus1 + 1 >= bpc && |
||
184 | (log2_chroma_wh >> 6 & 3) == desc->log2_chroma_w && |
||
185 | (log2_chroma_wh >> 4 & 3) == desc->log2_chroma_h; |
||
186 | |||
187 | case 1: |
||
188 | match = match && desc->comp[0].depth_minus1 + 1 >= bpc && |
||
189 | (log2_chroma_wh >> 2 & 3) == 0 && |
||
190 | (log2_chroma_wh & 3) == 0 && |
||
191 | (desc->flags & AV_PIX_FMT_FLAG_PAL) == pal8 * AV_PIX_FMT_FLAG_PAL; |
||
192 | } |
||
193 | return match; |
||
194 | } |
||
195 | |||
196 | // pix_fmts with lower bpp have to be listed before |
||
197 | // similar pix_fmts with higher bpp. |
||
198 | #define RGB_PIXEL_FORMATS AV_PIX_FMT_PAL8,AV_PIX_FMT_RGB24,AV_PIX_FMT_RGBA,AV_PIX_FMT_RGB48,AV_PIX_FMT_RGBA64 |
||
199 | #define GRAY_PIXEL_FORMATS AV_PIX_FMT_GRAY8,AV_PIX_FMT_GRAY8A,AV_PIX_FMT_GRAY16 |
||
200 | #define YUV_PIXEL_FORMATS AV_PIX_FMT_YUV410P,AV_PIX_FMT_YUV411P,AV_PIX_FMT_YUVA420P, \ |
||
201 | AV_PIX_FMT_YUV420P,AV_PIX_FMT_YUV422P,AV_PIX_FMT_YUVA422P, \ |
||
202 | AV_PIX_FMT_YUV440P,AV_PIX_FMT_YUV444P,AV_PIX_FMT_YUVA444P, \ |
||
203 | AV_PIX_FMT_YUV420P9,AV_PIX_FMT_YUV422P9,AV_PIX_FMT_YUV444P9, \ |
||
204 | AV_PIX_FMT_YUVA420P9,AV_PIX_FMT_YUVA422P9,AV_PIX_FMT_YUVA444P9, \ |
||
205 | AV_PIX_FMT_YUV420P10,AV_PIX_FMT_YUV422P10,AV_PIX_FMT_YUV444P10, \ |
||
206 | AV_PIX_FMT_YUVA420P10,AV_PIX_FMT_YUVA422P10,AV_PIX_FMT_YUVA444P10, \ |
||
207 | AV_PIX_FMT_YUV420P12,AV_PIX_FMT_YUV422P12,AV_PIX_FMT_YUV444P12, \ |
||
208 | AV_PIX_FMT_YUV420P14,AV_PIX_FMT_YUV422P14,AV_PIX_FMT_YUV444P14, \ |
||
209 | AV_PIX_FMT_YUV420P16,AV_PIX_FMT_YUV422P16,AV_PIX_FMT_YUV444P16, \ |
||
210 | AV_PIX_FMT_YUVA420P16,AV_PIX_FMT_YUVA422P16,AV_PIX_FMT_YUVA444P16 |
||
211 | #define XYZ_PIXEL_FORMATS AV_PIX_FMT_XYZ12 |
||
212 | |||
213 | static const enum AVPixelFormat rgb_pix_fmts[] = {RGB_PIXEL_FORMATS}; |
||
214 | static const enum AVPixelFormat gray_pix_fmts[] = {GRAY_PIXEL_FORMATS}; |
||
215 | static const enum AVPixelFormat yuv_pix_fmts[] = {YUV_PIXEL_FORMATS}; |
||
216 | static const enum AVPixelFormat xyz_pix_fmts[] = {XYZ_PIXEL_FORMATS}; |
||
217 | static const enum AVPixelFormat all_pix_fmts[] = {RGB_PIXEL_FORMATS, |
||
218 | GRAY_PIXEL_FORMATS, |
||
219 | YUV_PIXEL_FORMATS, |
||
220 | XYZ_PIXEL_FORMATS}; |
||
221 | |||
222 | /* marker segments */ |
||
223 | /* get sizes and offsets of image, tiles; number of components */ |
||
224 | static int get_siz(Jpeg2000DecoderContext *s) |
||
225 | { |
||
226 | int i; |
||
227 | int ncomponents; |
||
228 | uint32_t log2_chroma_wh = 0; |
||
229 | const enum AVPixelFormat *possible_fmts = NULL; |
||
230 | int possible_fmts_nb = 0; |
||
231 | |||
232 | if (bytestream2_get_bytes_left(&s->g) < 36) |
||
233 | return AVERROR_INVALIDDATA; |
||
234 | |||
235 | s->avctx->profile = bytestream2_get_be16u(&s->g); // Rsiz |
||
236 | s->width = bytestream2_get_be32u(&s->g); // Width |
||
237 | s->height = bytestream2_get_be32u(&s->g); // Height |
||
238 | s->image_offset_x = bytestream2_get_be32u(&s->g); // X0Siz |
||
239 | s->image_offset_y = bytestream2_get_be32u(&s->g); // Y0Siz |
||
240 | s->tile_width = bytestream2_get_be32u(&s->g); // XTSiz |
||
241 | s->tile_height = bytestream2_get_be32u(&s->g); // YTSiz |
||
242 | s->tile_offset_x = bytestream2_get_be32u(&s->g); // XT0Siz |
||
243 | s->tile_offset_y = bytestream2_get_be32u(&s->g); // YT0Siz |
||
244 | ncomponents = bytestream2_get_be16u(&s->g); // CSiz |
||
245 | |||
246 | if (s->image_offset_x || s->image_offset_y) { |
||
247 | avpriv_request_sample(s->avctx, "Support for image offsets"); |
||
248 | return AVERROR_PATCHWELCOME; |
||
249 | } |
||
250 | |||
251 | if (ncomponents <= 0) { |
||
252 | av_log(s->avctx, AV_LOG_ERROR, "Invalid number of components: %d\n", |
||
253 | s->ncomponents); |
||
254 | return AVERROR_INVALIDDATA; |
||
255 | } |
||
256 | |||
257 | if (ncomponents > 4) { |
||
258 | avpriv_request_sample(s->avctx, "Support for %d components", |
||
259 | s->ncomponents); |
||
260 | return AVERROR_PATCHWELCOME; |
||
261 | } |
||
262 | |||
263 | s->ncomponents = ncomponents; |
||
264 | |||
265 | if (s->tile_width <= 0 || s->tile_height <= 0) { |
||
266 | av_log(s->avctx, AV_LOG_ERROR, "Invalid tile dimension %dx%d.\n", |
||
267 | s->tile_width, s->tile_height); |
||
268 | return AVERROR_INVALIDDATA; |
||
269 | } |
||
270 | |||
271 | if (bytestream2_get_bytes_left(&s->g) < 3 * s->ncomponents) |
||
272 | return AVERROR_INVALIDDATA; |
||
273 | |||
274 | for (i = 0; i < s->ncomponents; i++) { // Ssiz_i XRsiz_i, YRsiz_i |
||
275 | uint8_t x = bytestream2_get_byteu(&s->g); |
||
276 | s->cbps[i] = (x & 0x7f) + 1; |
||
277 | s->precision = FFMAX(s->cbps[i], s->precision); |
||
278 | s->sgnd[i] = !!(x & 0x80); |
||
279 | s->cdx[i] = bytestream2_get_byteu(&s->g); |
||
280 | s->cdy[i] = bytestream2_get_byteu(&s->g); |
||
281 | if ( !s->cdx[i] || s->cdx[i] == 3 || s->cdx[i] > 4 |
||
282 | || !s->cdy[i] || s->cdy[i] == 3 || s->cdy[i] > 4) { |
||
283 | av_log(s->avctx, AV_LOG_ERROR, "Invalid sample separation %d/%d\n", s->cdx[i], s->cdy[i]); |
||
284 | return AVERROR_INVALIDDATA; |
||
285 | } |
||
286 | log2_chroma_wh |= s->cdy[i] >> 1 << i * 4 | s->cdx[i] >> 1 << i * 4 + 2; |
||
287 | } |
||
288 | |||
289 | s->numXtiles = ff_jpeg2000_ceildiv(s->width - s->tile_offset_x, s->tile_width); |
||
290 | s->numYtiles = ff_jpeg2000_ceildiv(s->height - s->tile_offset_y, s->tile_height); |
||
291 | |||
292 | if (s->numXtiles * (uint64_t)s->numYtiles > INT_MAX/sizeof(*s->tile)) { |
||
293 | s->numXtiles = s->numYtiles = 0; |
||
294 | return AVERROR(EINVAL); |
||
295 | } |
||
296 | |||
297 | s->tile = av_mallocz_array(s->numXtiles * s->numYtiles, sizeof(*s->tile)); |
||
298 | if (!s->tile) { |
||
299 | s->numXtiles = s->numYtiles = 0; |
||
300 | return AVERROR(ENOMEM); |
||
301 | } |
||
302 | |||
303 | for (i = 0; i < s->numXtiles * s->numYtiles; i++) { |
||
304 | Jpeg2000Tile *tile = s->tile + i; |
||
305 | |||
306 | tile->comp = av_mallocz(s->ncomponents * sizeof(*tile->comp)); |
||
307 | if (!tile->comp) |
||
308 | return AVERROR(ENOMEM); |
||
309 | } |
||
310 | |||
311 | /* compute image size with reduction factor */ |
||
312 | s->avctx->width = ff_jpeg2000_ceildivpow2(s->width - s->image_offset_x, |
||
313 | s->reduction_factor); |
||
314 | s->avctx->height = ff_jpeg2000_ceildivpow2(s->height - s->image_offset_y, |
||
315 | s->reduction_factor); |
||
316 | |||
317 | if (s->avctx->profile == FF_PROFILE_JPEG2000_DCINEMA_2K || |
||
318 | s->avctx->profile == FF_PROFILE_JPEG2000_DCINEMA_4K) { |
||
319 | possible_fmts = xyz_pix_fmts; |
||
320 | possible_fmts_nb = FF_ARRAY_ELEMS(xyz_pix_fmts); |
||
321 | } else { |
||
322 | switch (s->colour_space) { |
||
323 | case 16: |
||
324 | possible_fmts = rgb_pix_fmts; |
||
325 | possible_fmts_nb = FF_ARRAY_ELEMS(rgb_pix_fmts); |
||
326 | break; |
||
327 | case 17: |
||
328 | possible_fmts = gray_pix_fmts; |
||
329 | possible_fmts_nb = FF_ARRAY_ELEMS(gray_pix_fmts); |
||
330 | break; |
||
331 | case 18: |
||
332 | possible_fmts = yuv_pix_fmts; |
||
333 | possible_fmts_nb = FF_ARRAY_ELEMS(yuv_pix_fmts); |
||
334 | break; |
||
335 | default: |
||
336 | possible_fmts = all_pix_fmts; |
||
337 | possible_fmts_nb = FF_ARRAY_ELEMS(all_pix_fmts); |
||
338 | break; |
||
339 | } |
||
340 | } |
||
341 | for (i = 0; i < possible_fmts_nb; ++i) { |
||
342 | if (pix_fmt_match(possible_fmts[i], ncomponents, s->precision, log2_chroma_wh, s->pal8)) { |
||
343 | s->avctx->pix_fmt = possible_fmts[i]; |
||
344 | break; |
||
345 | } |
||
346 | } |
||
347 | if (s->avctx->pix_fmt == AV_PIX_FMT_NONE) { |
||
348 | av_log(s->avctx, AV_LOG_ERROR, |
||
349 | "Unknown pix_fmt, profile: %d, colour_space: %d, " |
||
350 | "components: %d, precision: %d, " |
||
351 | "cdx[1]: %d, cdy[1]: %d, cdx[2]: %d, cdy[2]: %d\n", |
||
352 | s->avctx->profile, s->colour_space, ncomponents, s->precision, |
||
353 | ncomponents > 2 ? s->cdx[1] : 0, |
||
354 | ncomponents > 2 ? s->cdy[1] : 0, |
||
355 | ncomponents > 2 ? s->cdx[2] : 0, |
||
356 | ncomponents > 2 ? s->cdy[2] : 0); |
||
357 | } |
||
358 | s->avctx->bits_per_raw_sample = s->precision; |
||
359 | return 0; |
||
360 | } |
||
361 | |||
362 | /* get common part for COD and COC segments */ |
||
363 | static int get_cox(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c) |
||
364 | { |
||
365 | uint8_t byte; |
||
366 | |||
367 | if (bytestream2_get_bytes_left(&s->g) < 5) |
||
368 | return AVERROR_INVALIDDATA; |
||
369 | |||
370 | /* nreslevels = number of resolution levels |
||
371 | = number of decomposition level +1 */ |
||
372 | c->nreslevels = bytestream2_get_byteu(&s->g) + 1; |
||
373 | if (c->nreslevels >= JPEG2000_MAX_RESLEVELS) { |
||
374 | av_log(s->avctx, AV_LOG_ERROR, "nreslevels %d is invalid\n", c->nreslevels); |
||
375 | return AVERROR_INVALIDDATA; |
||
376 | } |
||
377 | |||
378 | if (c->nreslevels <= s->reduction_factor) { |
||
379 | /* we are forced to update reduction_factor as its requested value is |
||
380 | not compatible with this bitstream, and as we might have used it |
||
381 | already in setup earlier we have to fail this frame until |
||
382 | reinitialization is implemented */ |
||
383 | av_log(s->avctx, AV_LOG_ERROR, "reduction_factor too large for this bitstream, max is %d\n", c->nreslevels - 1); |
||
384 | s->reduction_factor = c->nreslevels - 1; |
||
385 | return AVERROR(EINVAL); |
||
386 | } |
||
387 | |||
388 | /* compute number of resolution levels to decode */ |
||
389 | c->nreslevels2decode = c->nreslevels - s->reduction_factor; |
||
390 | |||
391 | c->log2_cblk_width = (bytestream2_get_byteu(&s->g) & 15) + 2; // cblk width |
||
392 | c->log2_cblk_height = (bytestream2_get_byteu(&s->g) & 15) + 2; // cblk height |
||
393 | |||
394 | if (c->log2_cblk_width > 10 || c->log2_cblk_height > 10 || |
||
395 | c->log2_cblk_width + c->log2_cblk_height > 12) { |
||
396 | av_log(s->avctx, AV_LOG_ERROR, "cblk size invalid\n"); |
||
397 | return AVERROR_INVALIDDATA; |
||
398 | } |
||
399 | |||
400 | if (c->log2_cblk_width > 6 || c->log2_cblk_height > 6) { |
||
401 | avpriv_request_sample(s->avctx, "cblk size > 64"); |
||
402 | return AVERROR_PATCHWELCOME; |
||
403 | } |
||
404 | |||
405 | c->cblk_style = bytestream2_get_byteu(&s->g); |
||
406 | if (c->cblk_style != 0) { // cblk style |
||
407 | av_log(s->avctx, AV_LOG_WARNING, "extra cblk styles %X\n", c->cblk_style); |
||
408 | } |
||
409 | c->transform = bytestream2_get_byteu(&s->g); // DWT transformation type |
||
410 | /* set integer 9/7 DWT in case of BITEXACT flag */ |
||
411 | if ((s->avctx->flags & CODEC_FLAG_BITEXACT) && (c->transform == FF_DWT97)) |
||
412 | c->transform = FF_DWT97_INT; |
||
413 | |||
414 | if (c->csty & JPEG2000_CSTY_PREC) { |
||
415 | int i; |
||
416 | for (i = 0; i < c->nreslevels; i++) { |
||
417 | byte = bytestream2_get_byte(&s->g); |
||
418 | c->log2_prec_widths[i] = byte & 0x0F; // precinct PPx |
||
419 | c->log2_prec_heights[i] = (byte >> 4) & 0x0F; // precinct PPy |
||
420 | } |
||
421 | } else { |
||
422 | memset(c->log2_prec_widths , 15, sizeof(c->log2_prec_widths )); |
||
423 | memset(c->log2_prec_heights, 15, sizeof(c->log2_prec_heights)); |
||
424 | } |
||
425 | return 0; |
||
426 | } |
||
427 | |||
428 | /* get coding parameters for a particular tile or whole image*/ |
||
429 | static int get_cod(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c, |
||
430 | uint8_t *properties) |
||
431 | { |
||
432 | Jpeg2000CodingStyle tmp; |
||
433 | int compno, ret; |
||
434 | |||
435 | if (bytestream2_get_bytes_left(&s->g) < 5) |
||
436 | return AVERROR_INVALIDDATA; |
||
437 | |||
438 | tmp.csty = bytestream2_get_byteu(&s->g); |
||
439 | |||
440 | // get progression order |
||
441 | tmp.prog_order = bytestream2_get_byteu(&s->g); |
||
442 | |||
443 | tmp.nlayers = bytestream2_get_be16u(&s->g); |
||
444 | tmp.mct = bytestream2_get_byteu(&s->g); // multiple component transformation |
||
445 | |||
446 | if (tmp.mct && s->ncomponents < 3) { |
||
447 | av_log(s->avctx, AV_LOG_ERROR, |
||
448 | "MCT %d with too few components (%d)\n", |
||
449 | tmp.mct, s->ncomponents); |
||
450 | return AVERROR_INVALIDDATA; |
||
451 | } |
||
452 | |||
453 | if ((ret = get_cox(s, &tmp)) < 0) |
||
454 | return ret; |
||
455 | |||
456 | for (compno = 0; compno < s->ncomponents; compno++) |
||
457 | if (!(properties[compno] & HAD_COC)) |
||
458 | memcpy(c + compno, &tmp, sizeof(tmp)); |
||
459 | return 0; |
||
460 | } |
||
461 | |||
462 | /* Get coding parameters for a component in the whole image or a |
||
463 | * particular tile. */ |
||
464 | static int get_coc(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c, |
||
465 | uint8_t *properties) |
||
466 | { |
||
467 | int compno, ret; |
||
468 | |||
469 | if (bytestream2_get_bytes_left(&s->g) < 2) |
||
470 | return AVERROR_INVALIDDATA; |
||
471 | |||
472 | compno = bytestream2_get_byteu(&s->g); |
||
473 | |||
474 | if (compno >= s->ncomponents) { |
||
475 | av_log(s->avctx, AV_LOG_ERROR, |
||
476 | "Invalid compno %d. There are %d components in the image.\n", |
||
477 | compno, s->ncomponents); |
||
478 | return AVERROR_INVALIDDATA; |
||
479 | } |
||
480 | |||
481 | c += compno; |
||
482 | c->csty = bytestream2_get_byteu(&s->g); |
||
483 | |||
484 | if ((ret = get_cox(s, c)) < 0) |
||
485 | return ret; |
||
486 | |||
487 | properties[compno] |= HAD_COC; |
||
488 | return 0; |
||
489 | } |
||
490 | |||
491 | /* Get common part for QCD and QCC segments. */ |
||
492 | static int get_qcx(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q) |
||
493 | { |
||
494 | int i, x; |
||
495 | |||
496 | if (bytestream2_get_bytes_left(&s->g) < 1) |
||
497 | return AVERROR_INVALIDDATA; |
||
498 | |||
499 | x = bytestream2_get_byteu(&s->g); // Sqcd |
||
500 | |||
501 | q->nguardbits = x >> 5; |
||
502 | q->quantsty = x & 0x1f; |
||
503 | |||
504 | if (q->quantsty == JPEG2000_QSTY_NONE) { |
||
505 | n -= 3; |
||
506 | if (bytestream2_get_bytes_left(&s->g) < n || |
||
507 | n > JPEG2000_MAX_DECLEVELS*3) |
||
508 | return AVERROR_INVALIDDATA; |
||
509 | for (i = 0; i < n; i++) |
||
510 | q->expn[i] = bytestream2_get_byteu(&s->g) >> 3; |
||
511 | } else if (q->quantsty == JPEG2000_QSTY_SI) { |
||
512 | if (bytestream2_get_bytes_left(&s->g) < 2) |
||
513 | return AVERROR_INVALIDDATA; |
||
514 | x = bytestream2_get_be16u(&s->g); |
||
515 | q->expn[0] = x >> 11; |
||
516 | q->mant[0] = x & 0x7ff; |
||
517 | for (i = 1; i < JPEG2000_MAX_DECLEVELS * 3; i++) { |
||
518 | int curexpn = FFMAX(0, q->expn[0] - (i - 1) / 3); |
||
519 | q->expn[i] = curexpn; |
||
520 | q->mant[i] = q->mant[0]; |
||
521 | } |
||
522 | } else { |
||
523 | n = (n - 3) >> 1; |
||
524 | if (bytestream2_get_bytes_left(&s->g) < 2 * n || |
||
525 | n > JPEG2000_MAX_DECLEVELS*3) |
||
526 | return AVERROR_INVALIDDATA; |
||
527 | for (i = 0; i < n; i++) { |
||
528 | x = bytestream2_get_be16u(&s->g); |
||
529 | q->expn[i] = x >> 11; |
||
530 | q->mant[i] = x & 0x7ff; |
||
531 | } |
||
532 | } |
||
533 | return 0; |
||
534 | } |
||
535 | |||
536 | /* Get quantization parameters for a particular tile or a whole image. */ |
||
537 | static int get_qcd(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q, |
||
538 | uint8_t *properties) |
||
539 | { |
||
540 | Jpeg2000QuantStyle tmp; |
||
541 | int compno, ret; |
||
542 | |||
543 | if ((ret = get_qcx(s, n, &tmp)) < 0) |
||
544 | return ret; |
||
545 | for (compno = 0; compno < s->ncomponents; compno++) |
||
546 | if (!(properties[compno] & HAD_QCC)) |
||
547 | memcpy(q + compno, &tmp, sizeof(tmp)); |
||
548 | return 0; |
||
549 | } |
||
550 | |||
551 | /* Get quantization parameters for a component in the whole image |
||
552 | * on in a particular tile. */ |
||
553 | static int get_qcc(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q, |
||
554 | uint8_t *properties) |
||
555 | { |
||
556 | int compno; |
||
557 | |||
558 | if (bytestream2_get_bytes_left(&s->g) < 1) |
||
559 | return AVERROR_INVALIDDATA; |
||
560 | |||
561 | compno = bytestream2_get_byteu(&s->g); |
||
562 | |||
563 | if (compno >= s->ncomponents) { |
||
564 | av_log(s->avctx, AV_LOG_ERROR, |
||
565 | "Invalid compno %d. There are %d components in the image.\n", |
||
566 | compno, s->ncomponents); |
||
567 | return AVERROR_INVALIDDATA; |
||
568 | } |
||
569 | |||
570 | properties[compno] |= HAD_QCC; |
||
571 | return get_qcx(s, n - 1, q + compno); |
||
572 | } |
||
573 | |||
574 | /* Get start of tile segment. */ |
||
575 | static int get_sot(Jpeg2000DecoderContext *s, int n) |
||
576 | { |
||
577 | Jpeg2000TilePart *tp; |
||
578 | uint16_t Isot; |
||
579 | uint32_t Psot; |
||
580 | uint8_t TPsot; |
||
581 | |||
582 | if (bytestream2_get_bytes_left(&s->g) < 8) |
||
583 | return AVERROR_INVALIDDATA; |
||
584 | |||
585 | s->curtileno = 0; |
||
586 | Isot = bytestream2_get_be16u(&s->g); // Isot |
||
587 | if (Isot >= s->numXtiles * s->numYtiles) |
||
588 | return AVERROR_INVALIDDATA; |
||
589 | |||
590 | s->curtileno = Isot; |
||
591 | Psot = bytestream2_get_be32u(&s->g); // Psot |
||
592 | TPsot = bytestream2_get_byteu(&s->g); // TPsot |
||
593 | |||
594 | /* Read TNSot but not used */ |
||
595 | bytestream2_get_byteu(&s->g); // TNsot |
||
596 | |||
597 | if (Psot > bytestream2_get_bytes_left(&s->g) + n + 2) { |
||
598 | av_log(s->avctx, AV_LOG_ERROR, "Psot %d too big\n", Psot); |
||
599 | return AVERROR_INVALIDDATA; |
||
600 | } |
||
601 | |||
602 | if (TPsot >= FF_ARRAY_ELEMS(s->tile[Isot].tile_part)) { |
||
603 | avpriv_request_sample(s->avctx, "Support for %d components", TPsot); |
||
604 | return AVERROR_PATCHWELCOME; |
||
605 | } |
||
606 | |||
607 | s->tile[Isot].tp_idx = TPsot; |
||
608 | tp = s->tile[Isot].tile_part + TPsot; |
||
609 | tp->tile_index = Isot; |
||
610 | tp->tp_end = s->g.buffer + Psot - n - 2; |
||
611 | |||
612 | if (!TPsot) { |
||
613 | Jpeg2000Tile *tile = s->tile + s->curtileno; |
||
614 | |||
615 | /* copy defaults */ |
||
616 | memcpy(tile->codsty, s->codsty, s->ncomponents * sizeof(Jpeg2000CodingStyle)); |
||
617 | memcpy(tile->qntsty, s->qntsty, s->ncomponents * sizeof(Jpeg2000QuantStyle)); |
||
618 | } |
||
619 | |||
620 | return 0; |
||
621 | } |
||
622 | |||
623 | /* Tile-part lengths: see ISO 15444-1:2002, section A.7.1 |
||
624 | * Used to know the number of tile parts and lengths. |
||
625 | * There may be multiple TLMs in the header. |
||
626 | * TODO: The function is not used for tile-parts management, nor anywhere else. |
||
627 | * It can be useful to allocate memory for tile parts, before managing the SOT |
||
628 | * markers. Parsing the TLM header is needed to increment the input header |
||
629 | * buffer. |
||
630 | * This marker is mandatory for DCI. */ |
||
631 | static uint8_t get_tlm(Jpeg2000DecoderContext *s, int n) |
||
632 | { |
||
633 | uint8_t Stlm, ST, SP, tile_tlm, i; |
||
634 | bytestream2_get_byte(&s->g); /* Ztlm: skipped */ |
||
635 | Stlm = bytestream2_get_byte(&s->g); |
||
636 | |||
637 | // too complex ? ST = ((Stlm >> 4) & 0x01) + ((Stlm >> 4) & 0x02); |
||
638 | ST = (Stlm >> 4) & 0x03; |
||
639 | // TODO: Manage case of ST = 0b11 --> raise error |
||
640 | SP = (Stlm >> 6) & 0x01; |
||
641 | tile_tlm = (n - 4) / ((SP + 1) * 2 + ST); |
||
642 | for (i = 0; i < tile_tlm; i++) { |
||
643 | switch (ST) { |
||
644 | case 0: |
||
645 | break; |
||
646 | case 1: |
||
647 | bytestream2_get_byte(&s->g); |
||
648 | break; |
||
649 | case 2: |
||
650 | bytestream2_get_be16(&s->g); |
||
651 | break; |
||
652 | case 3: |
||
653 | bytestream2_get_be32(&s->g); |
||
654 | break; |
||
655 | } |
||
656 | if (SP == 0) { |
||
657 | bytestream2_get_be16(&s->g); |
||
658 | } else { |
||
659 | bytestream2_get_be32(&s->g); |
||
660 | } |
||
661 | } |
||
662 | return 0; |
||
663 | } |
||
664 | |||
665 | static int init_tile(Jpeg2000DecoderContext *s, int tileno) |
||
666 | { |
||
667 | int compno; |
||
668 | int tilex = tileno % s->numXtiles; |
||
669 | int tiley = tileno / s->numXtiles; |
||
670 | Jpeg2000Tile *tile = s->tile + tileno; |
||
671 | |||
672 | if (!tile->comp) |
||
673 | return AVERROR(ENOMEM); |
||
674 | |||
675 | for (compno = 0; compno < s->ncomponents; compno++) { |
||
676 | Jpeg2000Component *comp = tile->comp + compno; |
||
677 | Jpeg2000CodingStyle *codsty = tile->codsty + compno; |
||
678 | Jpeg2000QuantStyle *qntsty = tile->qntsty + compno; |
||
679 | int ret; // global bandno |
||
680 | |||
681 | comp->coord_o[0][0] = FFMAX(tilex * s->tile_width + s->tile_offset_x, s->image_offset_x); |
||
682 | comp->coord_o[0][1] = FFMIN((tilex + 1) * s->tile_width + s->tile_offset_x, s->width); |
||
683 | comp->coord_o[1][0] = FFMAX(tiley * s->tile_height + s->tile_offset_y, s->image_offset_y); |
||
684 | comp->coord_o[1][1] = FFMIN((tiley + 1) * s->tile_height + s->tile_offset_y, s->height); |
||
685 | |||
686 | comp->coord[0][0] = ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], s->reduction_factor); |
||
687 | comp->coord[0][1] = ff_jpeg2000_ceildivpow2(comp->coord_o[0][1], s->reduction_factor); |
||
688 | comp->coord[1][0] = ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], s->reduction_factor); |
||
689 | comp->coord[1][1] = ff_jpeg2000_ceildivpow2(comp->coord_o[1][1], s->reduction_factor); |
||
690 | |||
691 | if (ret = ff_jpeg2000_init_component(comp, codsty, qntsty, |
||
692 | s->cbps[compno], s->cdx[compno], |
||
693 | s->cdy[compno], s->avctx)) |
||
694 | return ret; |
||
695 | } |
||
696 | return 0; |
||
697 | } |
||
698 | |||
699 | /* Read the number of coding passes. */ |
||
700 | static int getnpasses(Jpeg2000DecoderContext *s) |
||
701 | { |
||
702 | int num; |
||
703 | if (!get_bits(s, 1)) |
||
704 | return 1; |
||
705 | if (!get_bits(s, 1)) |
||
706 | return 2; |
||
707 | if ((num = get_bits(s, 2)) != 3) |
||
708 | return num < 0 ? num : 3 + num; |
||
709 | if ((num = get_bits(s, 5)) != 31) |
||
710 | return num < 0 ? num : 6 + num; |
||
711 | num = get_bits(s, 7); |
||
712 | return num < 0 ? num : 37 + num; |
||
713 | } |
||
714 | |||
715 | static int getlblockinc(Jpeg2000DecoderContext *s) |
||
716 | { |
||
717 | int res = 0, ret; |
||
718 | while (ret = get_bits(s, 1)) { |
||
719 | if (ret < 0) |
||
720 | return ret; |
||
721 | res++; |
||
722 | } |
||
723 | return res; |
||
724 | } |
||
725 | |||
726 | static int jpeg2000_decode_packet(Jpeg2000DecoderContext *s, |
||
727 | Jpeg2000CodingStyle *codsty, |
||
728 | Jpeg2000ResLevel *rlevel, int precno, |
||
729 | int layno, uint8_t *expn, int numgbits) |
||
730 | { |
||
731 | int bandno, cblkno, ret, nb_code_blocks; |
||
732 | |||
733 | if (!(ret = get_bits(s, 1))) { |
||
734 | jpeg2000_flush(s); |
||
735 | return 0; |
||
736 | } else if (ret < 0) |
||
737 | return ret; |
||
738 | |||
739 | for (bandno = 0; bandno < rlevel->nbands; bandno++) { |
||
740 | Jpeg2000Band *band = rlevel->band + bandno; |
||
741 | Jpeg2000Prec *prec = band->prec + precno; |
||
742 | |||
743 | if (band->coord[0][0] == band->coord[0][1] || |
||
744 | band->coord[1][0] == band->coord[1][1]) |
||
745 | continue; |
||
746 | nb_code_blocks = prec->nb_codeblocks_height * |
||
747 | prec->nb_codeblocks_width; |
||
748 | for (cblkno = 0; cblkno < nb_code_blocks; cblkno++) { |
||
749 | Jpeg2000Cblk *cblk = prec->cblk + cblkno; |
||
750 | int incl, newpasses, llen; |
||
751 | |||
752 | if (cblk->npasses) |
||
753 | incl = get_bits(s, 1); |
||
754 | else |
||
755 | incl = tag_tree_decode(s, prec->cblkincl + cblkno, layno + 1) == layno; |
||
756 | if (!incl) |
||
757 | continue; |
||
758 | else if (incl < 0) |
||
759 | return incl; |
||
760 | |||
761 | if (!cblk->npasses) { |
||
762 | int v = expn[bandno] + numgbits - 1 - |
||
763 | tag_tree_decode(s, prec->zerobits + cblkno, 100); |
||
764 | if (v < 0) { |
||
765 | av_log(s->avctx, AV_LOG_ERROR, |
||
766 | "nonzerobits %d invalid\n", v); |
||
767 | return AVERROR_INVALIDDATA; |
||
768 | } |
||
769 | cblk->nonzerobits = v; |
||
770 | } |
||
771 | if ((newpasses = getnpasses(s)) < 0) |
||
772 | return newpasses; |
||
773 | if ((llen = getlblockinc(s)) < 0) |
||
774 | return llen; |
||
775 | cblk->lblock += llen; |
||
776 | if ((ret = get_bits(s, av_log2(newpasses) + cblk->lblock)) < 0) |
||
777 | return ret; |
||
778 | if (ret > sizeof(cblk->data)) { |
||
779 | avpriv_request_sample(s->avctx, |
||
780 | "Block with lengthinc greater than %zu", |
||
781 | sizeof(cblk->data)); |
||
782 | return AVERROR_PATCHWELCOME; |
||
783 | } |
||
784 | cblk->lengthinc = ret; |
||
785 | cblk->npasses += newpasses; |
||
786 | } |
||
787 | } |
||
788 | jpeg2000_flush(s); |
||
789 | |||
790 | if (codsty->csty & JPEG2000_CSTY_EPH) { |
||
791 | if (bytestream2_peek_be16(&s->g) == JPEG2000_EPH) |
||
792 | bytestream2_skip(&s->g, 2); |
||
793 | else |
||
794 | av_log(s->avctx, AV_LOG_ERROR, "EPH marker not found.\n"); |
||
795 | } |
||
796 | |||
797 | for (bandno = 0; bandno < rlevel->nbands; bandno++) { |
||
798 | Jpeg2000Band *band = rlevel->band + bandno; |
||
799 | Jpeg2000Prec *prec = band->prec + precno; |
||
800 | |||
801 | nb_code_blocks = prec->nb_codeblocks_height * prec->nb_codeblocks_width; |
||
802 | for (cblkno = 0; cblkno < nb_code_blocks; cblkno++) { |
||
803 | Jpeg2000Cblk *cblk = prec->cblk + cblkno; |
||
804 | if ( bytestream2_get_bytes_left(&s->g) < cblk->lengthinc |
||
805 | || sizeof(cblk->data) < cblk->length + cblk->lengthinc + 2 |
||
806 | ) { |
||
807 | av_log(s->avctx, AV_LOG_ERROR, |
||
808 | "Block length %d or lengthinc %d is too large\n", |
||
809 | cblk->length, cblk->lengthinc); |
||
810 | return AVERROR_INVALIDDATA; |
||
811 | } |
||
812 | |||
813 | bytestream2_get_bufferu(&s->g, cblk->data + cblk->length, cblk->lengthinc); |
||
814 | cblk->length += cblk->lengthinc; |
||
815 | cblk->lengthinc = 0; |
||
816 | } |
||
817 | } |
||
818 | return 0; |
||
819 | } |
||
820 | |||
821 | static int jpeg2000_decode_packets(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile) |
||
822 | { |
||
823 | int ret = 0; |
||
824 | int layno, reslevelno, compno, precno, ok_reslevel; |
||
825 | int x, y; |
||
826 | |||
827 | s->bit_index = 8; |
||
828 | switch (tile->codsty[0].prog_order) { |
||
829 | case JPEG2000_PGOD_RLCP: |
||
830 | avpriv_request_sample(s->avctx, "Progression order RLCP"); |
||
831 | |||
832 | case JPEG2000_PGOD_LRCP: |
||
833 | for (layno = 0; layno < tile->codsty[0].nlayers; layno++) { |
||
834 | ok_reslevel = 1; |
||
835 | for (reslevelno = 0; ok_reslevel; reslevelno++) { |
||
836 | ok_reslevel = 0; |
||
837 | for (compno = 0; compno < s->ncomponents; compno++) { |
||
838 | Jpeg2000CodingStyle *codsty = tile->codsty + compno; |
||
839 | Jpeg2000QuantStyle *qntsty = tile->qntsty + compno; |
||
840 | if (reslevelno < codsty->nreslevels) { |
||
841 | Jpeg2000ResLevel *rlevel = tile->comp[compno].reslevel + |
||
842 | reslevelno; |
||
843 | ok_reslevel = 1; |
||
844 | for (precno = 0; precno < rlevel->num_precincts_x * rlevel->num_precincts_y; precno++) |
||
845 | if ((ret = jpeg2000_decode_packet(s, |
||
846 | codsty, rlevel, |
||
847 | precno, layno, |
||
848 | qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0), |
||
849 | qntsty->nguardbits)) < 0) |
||
850 | return ret; |
||
851 | } |
||
852 | } |
||
853 | } |
||
854 | } |
||
855 | break; |
||
856 | |||
857 | case JPEG2000_PGOD_CPRL: |
||
858 | for (compno = 0; compno < s->ncomponents; compno++) { |
||
859 | Jpeg2000CodingStyle *codsty = tile->codsty + compno; |
||
860 | Jpeg2000QuantStyle *qntsty = tile->qntsty + compno; |
||
861 | |||
862 | /* Set bit stream buffer address according to tile-part. |
||
863 | * For DCinema one tile-part per component, so can be |
||
864 | * indexed by component. */ |
||
865 | s->g = tile->tile_part[compno].tpg; |
||
866 | |||
867 | /* Position loop (y axis) |
||
868 | * TODO: Automate computing of step 256. |
||
869 | * Fixed here, but to be computed before entering here. */ |
||
870 | for (y = 0; y < s->height; y += 256) { |
||
871 | /* Position loop (y axis) |
||
872 | * TODO: automate computing of step 256. |
||
873 | * Fixed here, but to be computed before entering here. */ |
||
874 | for (x = 0; x < s->width; x += 256) { |
||
875 | for (reslevelno = 0; reslevelno < codsty->nreslevels; reslevelno++) { |
||
876 | uint16_t prcx, prcy; |
||
877 | uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r |
||
878 | Jpeg2000ResLevel *rlevel = tile->comp[compno].reslevel + reslevelno; |
||
879 | |||
880 | if (!((y % (1 << (rlevel->log2_prec_height + reducedresno)) == 0) || |
||
881 | (y == 0))) // TODO: 2nd condition simplified as try0 always =0 for dcinema |
||
882 | continue; |
||
883 | |||
884 | if (!((x % (1 << (rlevel->log2_prec_width + reducedresno)) == 0) || |
||
885 | (x == 0))) // TODO: 2nd condition simplified as try0 always =0 for dcinema |
||
886 | continue; |
||
887 | |||
888 | // check if a precinct exists |
||
889 | prcx = ff_jpeg2000_ceildivpow2(x, reducedresno) >> rlevel->log2_prec_width; |
||
890 | prcy = ff_jpeg2000_ceildivpow2(y, reducedresno) >> rlevel->log2_prec_height; |
||
891 | precno = prcx + rlevel->num_precincts_x * prcy; |
||
892 | for (layno = 0; layno < tile->codsty[0].nlayers; layno++) { |
||
893 | if ((ret = jpeg2000_decode_packet(s, codsty, rlevel, |
||
894 | precno, layno, |
||
895 | qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0), |
||
896 | qntsty->nguardbits)) < 0) |
||
897 | return ret; |
||
898 | } |
||
899 | } |
||
900 | } |
||
901 | } |
||
902 | } |
||
903 | break; |
||
904 | |||
905 | case JPEG2000_PGOD_RPCL: |
||
906 | avpriv_request_sample(s->avctx, "Progression order RPCL"); |
||
907 | ret = AVERROR_PATCHWELCOME; |
||
908 | break; |
||
909 | |||
910 | case JPEG2000_PGOD_PCRL: |
||
911 | avpriv_request_sample(s->avctx, "Progression order PCRL"); |
||
912 | ret = AVERROR_PATCHWELCOME; |
||
913 | break; |
||
914 | |||
915 | default: |
||
916 | break; |
||
917 | } |
||
918 | |||
919 | /* EOC marker reached */ |
||
920 | bytestream2_skip(&s->g, 2); |
||
921 | |||
922 | return ret; |
||
923 | } |
||
924 | |||
925 | /* TIER-1 routines */ |
||
926 | static void decode_sigpass(Jpeg2000T1Context *t1, int width, int height, |
||
927 | int bpno, int bandno, int bpass_csty_symbol, |
||
928 | int vert_causal_ctx_csty_symbol) |
||
929 | { |
||
930 | int mask = 3 << (bpno - 1), y0, x, y; |
||
931 | |||
932 | for (y0 = 0; y0 < height; y0 += 4) |
||
933 | for (x = 0; x < width; x++) |
||
934 | for (y = y0; y < height && y < y0 + 4; y++) { |
||
935 | if ((t1->flags[y+1][x+1] & JPEG2000_T1_SIG_NB) |
||
936 | && !(t1->flags[y+1][x+1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS))) { |
||
937 | int flags_mask = -1; |
||
938 | if (vert_causal_ctx_csty_symbol && y == y0 + 3) |
||
939 | flags_mask &= ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE); |
||
940 | if (ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ff_jpeg2000_getsigctxno(t1->flags[y+1][x+1] & flags_mask, bandno))) { |
||
941 | int xorbit, ctxno = ff_jpeg2000_getsgnctxno(t1->flags[y+1][x+1], &xorbit); |
||
942 | if (bpass_csty_symbol) |
||
943 | t1->data[y][x] = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ctxno) ? -mask : mask; |
||
944 | else |
||
945 | t1->data[y][x] = (ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ctxno) ^ xorbit) ? |
||
946 | -mask : mask; |
||
947 | |||
948 | ff_jpeg2000_set_significance(t1, x, y, |
||
949 | t1->data[y][x] < 0); |
||
950 | } |
||
951 | t1->flags[y + 1][x + 1] |= JPEG2000_T1_VIS; |
||
952 | } |
||
953 | } |
||
954 | } |
||
955 | |||
956 | static void decode_refpass(Jpeg2000T1Context *t1, int width, int height, |
||
957 | int bpno) |
||
958 | { |
||
959 | int phalf, nhalf; |
||
960 | int y0, x, y; |
||
961 | |||
962 | phalf = 1 << (bpno - 1); |
||
963 | nhalf = -phalf; |
||
964 | |||
965 | for (y0 = 0; y0 < height; y0 += 4) |
||
966 | for (x = 0; x < width; x++) |
||
967 | for (y = y0; y < height && y < y0 + 4; y++) |
||
968 | if ((t1->flags[y + 1][x + 1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS)) == JPEG2000_T1_SIG) { |
||
969 | int ctxno = ff_jpeg2000_getrefctxno(t1->flags[y + 1][x + 1]); |
||
970 | int r = ff_mqc_decode(&t1->mqc, |
||
971 | t1->mqc.cx_states + ctxno) |
||
972 | ? phalf : nhalf; |
||
973 | t1->data[y][x] += t1->data[y][x] < 0 ? -r : r; |
||
974 | t1->flags[y + 1][x + 1] |= JPEG2000_T1_REF; |
||
975 | } |
||
976 | } |
||
977 | |||
978 | static void decode_clnpass(Jpeg2000DecoderContext *s, Jpeg2000T1Context *t1, |
||
979 | int width, int height, int bpno, int bandno, |
||
980 | int seg_symbols, int vert_causal_ctx_csty_symbol) |
||
981 | { |
||
982 | int mask = 3 << (bpno - 1), y0, x, y, runlen, dec; |
||
983 | |||
984 | for (y0 = 0; y0 < height; y0 += 4) { |
||
985 | for (x = 0; x < width; x++) { |
||
986 | if (y0 + 3 < height && |
||
987 | !((t1->flags[y0 + 1][x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) || |
||
988 | (t1->flags[y0 + 2][x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) || |
||
989 | (t1->flags[y0 + 3][x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) || |
||
990 | (t1->flags[y0 + 4][x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)))) { |
||
991 | if (!ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_RL)) |
||
992 | continue; |
||
993 | runlen = ff_mqc_decode(&t1->mqc, |
||
994 | t1->mqc.cx_states + MQC_CX_UNI); |
||
995 | runlen = (runlen << 1) | ff_mqc_decode(&t1->mqc, |
||
996 | t1->mqc.cx_states + |
||
997 | MQC_CX_UNI); |
||
998 | dec = 1; |
||
999 | } else { |
||
1000 | runlen = 0; |
||
1001 | dec = 0; |
||
1002 | } |
||
1003 | |||
1004 | for (y = y0 + runlen; y < y0 + 4 && y < height; y++) { |
||
1005 | if (!dec) { |
||
1006 | if (!(t1->flags[y+1][x+1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS))) { |
||
1007 | int flags_mask = -1; |
||
1008 | if (vert_causal_ctx_csty_symbol && y == y0 + 3) |
||
1009 | flags_mask &= ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE); |
||
1010 | dec = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ff_jpeg2000_getsigctxno(t1->flags[y+1][x+1] & flags_mask, |
||
1011 | bandno)); |
||
1012 | } |
||
1013 | } |
||
1014 | if (dec) { |
||
1015 | int xorbit; |
||
1016 | int ctxno = ff_jpeg2000_getsgnctxno(t1->flags[y + 1][x + 1], |
||
1017 | &xorbit); |
||
1018 | t1->data[y][x] = (ff_mqc_decode(&t1->mqc, |
||
1019 | t1->mqc.cx_states + ctxno) ^ |
||
1020 | xorbit) |
||
1021 | ? -mask : mask; |
||
1022 | ff_jpeg2000_set_significance(t1, x, y, t1->data[y][x] < 0); |
||
1023 | } |
||
1024 | dec = 0; |
||
1025 | t1->flags[y + 1][x + 1] &= ~JPEG2000_T1_VIS; |
||
1026 | } |
||
1027 | } |
||
1028 | } |
||
1029 | if (seg_symbols) { |
||
1030 | int val; |
||
1031 | val = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI); |
||
1032 | val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI); |
||
1033 | val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI); |
||
1034 | val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI); |
||
1035 | if (val != 0xa) |
||
1036 | av_log(s->avctx, AV_LOG_ERROR, |
||
1037 | "Segmentation symbol value incorrect\n"); |
||
1038 | } |
||
1039 | } |
||
1040 | |||
1041 | static int decode_cblk(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *codsty, |
||
1042 | Jpeg2000T1Context *t1, Jpeg2000Cblk *cblk, |
||
1043 | int width, int height, int bandpos) |
||
1044 | { |
||
1045 | int passno = cblk->npasses, pass_t = 2, bpno = cblk->nonzerobits - 1, y; |
||
1046 | int clnpass_cnt = 0; |
||
1047 | int bpass_csty_symbol = codsty->cblk_style & JPEG2000_CBLK_BYPASS; |
||
1048 | int vert_causal_ctx_csty_symbol = codsty->cblk_style & JPEG2000_CBLK_VSC; |
||
1049 | |||
1050 | av_assert0(width <= JPEG2000_MAX_CBLKW); |
||
1051 | av_assert0(height <= JPEG2000_MAX_CBLKH); |
||
1052 | |||
1053 | for (y = 0; y < height; y++) |
||
1054 | memset(t1->data[y], 0, width * sizeof(**t1->data)); |
||
1055 | |||
1056 | /* If code-block contains no compressed data: nothing to do. */ |
||
1057 | if (!cblk->length) |
||
1058 | return 0; |
||
1059 | |||
1060 | for (y = 0; y < height + 2; y++) |
||
1061 | memset(t1->flags[y], 0, (width + 2) * sizeof(**t1->flags)); |
||
1062 | |||
1063 | cblk->data[cblk->length] = 0xff; |
||
1064 | cblk->data[cblk->length+1] = 0xff; |
||
1065 | ff_mqc_initdec(&t1->mqc, cblk->data); |
||
1066 | |||
1067 | while (passno--) { |
||
1068 | switch(pass_t) { |
||
1069 | case 0: |
||
1070 | decode_sigpass(t1, width, height, bpno + 1, bandpos, |
||
1071 | bpass_csty_symbol && (clnpass_cnt >= 4), |
||
1072 | vert_causal_ctx_csty_symbol); |
||
1073 | break; |
||
1074 | case 1: |
||
1075 | decode_refpass(t1, width, height, bpno + 1); |
||
1076 | if (bpass_csty_symbol && clnpass_cnt >= 4) |
||
1077 | ff_mqc_initdec(&t1->mqc, cblk->data); |
||
1078 | break; |
||
1079 | case 2: |
||
1080 | decode_clnpass(s, t1, width, height, bpno + 1, bandpos, |
||
1081 | codsty->cblk_style & JPEG2000_CBLK_SEGSYM, |
||
1082 | vert_causal_ctx_csty_symbol); |
||
1083 | clnpass_cnt = clnpass_cnt + 1; |
||
1084 | if (bpass_csty_symbol && clnpass_cnt >= 4) |
||
1085 | ff_mqc_initdec(&t1->mqc, cblk->data); |
||
1086 | break; |
||
1087 | } |
||
1088 | |||
1089 | pass_t++; |
||
1090 | if (pass_t == 3) { |
||
1091 | bpno--; |
||
1092 | pass_t = 0; |
||
1093 | } |
||
1094 | } |
||
1095 | return 0; |
||
1096 | } |
||
1097 | |||
1098 | /* TODO: Verify dequantization for lossless case |
||
1099 | * comp->data can be float or int |
||
1100 | * band->stepsize can be float or int |
||
1101 | * depending on the type of DWT transformation. |
||
1102 | * see ISO/IEC 15444-1:2002 A.6.1 */ |
||
1103 | |||
1104 | /* Float dequantization of a codeblock.*/ |
||
1105 | static void dequantization_float(int x, int y, Jpeg2000Cblk *cblk, |
||
1106 | Jpeg2000Component *comp, |
||
1107 | Jpeg2000T1Context *t1, Jpeg2000Band *band) |
||
1108 | { |
||
1109 | int i, j; |
||
1110 | int w = cblk->coord[0][1] - cblk->coord[0][0]; |
||
1111 | for (j = 0; j < (cblk->coord[1][1] - cblk->coord[1][0]); ++j) { |
||
1112 | float *datap = &comp->f_data[(comp->coord[0][1] - comp->coord[0][0]) * (y + j) + x]; |
||
1113 | int *src = t1->data[j]; |
||
1114 | for (i = 0; i < w; ++i) |
||
1115 | datap[i] = src[i] * band->f_stepsize; |
||
1116 | } |
||
1117 | } |
||
1118 | |||
1119 | /* Integer dequantization of a codeblock.*/ |
||
1120 | static void dequantization_int(int x, int y, Jpeg2000Cblk *cblk, |
||
1121 | Jpeg2000Component *comp, |
||
1122 | Jpeg2000T1Context *t1, Jpeg2000Band *band) |
||
1123 | { |
||
1124 | int i, j; |
||
1125 | int w = cblk->coord[0][1] - cblk->coord[0][0]; |
||
1126 | for (j = 0; j < (cblk->coord[1][1] - cblk->coord[1][0]); ++j) { |
||
1127 | int32_t *datap = &comp->i_data[(comp->coord[0][1] - comp->coord[0][0]) * (y + j) + x]; |
||
1128 | int *src = t1->data[j]; |
||
1129 | for (i = 0; i < w; ++i) |
||
1130 | datap[i] = (src[i] * band->i_stepsize + (1 << 14)) >> 15; |
||
1131 | } |
||
1132 | } |
||
1133 | |||
1134 | /* Inverse ICT parameters in float and integer. |
||
1135 | * int value = (float value) * (1<<16) */ |
||
1136 | static const float f_ict_params[4] = { |
||
1137 | 1.402f, |
||
1138 | 0.34413f, |
||
1139 | 0.71414f, |
||
1140 | 1.772f |
||
1141 | }; |
||
1142 | static const int i_ict_params[4] = { |
||
1143 | 91881, |
||
1144 | 22553, |
||
1145 | 46802, |
||
1146 | 116130 |
||
1147 | }; |
||
1148 | |||
1149 | static void mct_decode(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile) |
||
1150 | { |
||
1151 | int i, csize = 1; |
||
1152 | int32_t *src[3], i0, i1, i2; |
||
1153 | float *srcf[3], i0f, i1f, i2f; |
||
1154 | |||
1155 | for (i = 1; i < 3; i++) |
||
1156 | if (tile->codsty[0].transform != tile->codsty[i].transform) { |
||
1157 | av_log(s->avctx, AV_LOG_ERROR, "Transforms mismatch, MCT not supported\n"); |
||
1158 | return; |
||
1159 | } |
||
1160 | |||
1161 | for (i = 0; i < 3; i++) |
||
1162 | if (tile->codsty[0].transform == FF_DWT97) |
||
1163 | srcf[i] = tile->comp[i].f_data; |
||
1164 | else |
||
1165 | src [i] = tile->comp[i].i_data; |
||
1166 | |||
1167 | for (i = 0; i < 2; i++) |
||
1168 | csize *= tile->comp[0].coord[i][1] - tile->comp[0].coord[i][0]; |
||
1169 | |||
1170 | switch (tile->codsty[0].transform) { |
||
1171 | case FF_DWT97: |
||
1172 | for (i = 0; i < csize; i++) { |
||
1173 | i0f = *srcf[0] + (f_ict_params[0] * *srcf[2]); |
||
1174 | i1f = *srcf[0] - (f_ict_params[1] * *srcf[1]) |
||
1175 | - (f_ict_params[2] * *srcf[2]); |
||
1176 | i2f = *srcf[0] + (f_ict_params[3] * *srcf[1]); |
||
1177 | *srcf[0]++ = i0f; |
||
1178 | *srcf[1]++ = i1f; |
||
1179 | *srcf[2]++ = i2f; |
||
1180 | } |
||
1181 | break; |
||
1182 | case FF_DWT97_INT: |
||
1183 | for (i = 0; i < csize; i++) { |
||
1184 | i0 = *src[0] + (((i_ict_params[0] * *src[2]) + (1 << 15)) >> 16); |
||
1185 | i1 = *src[0] - (((i_ict_params[1] * *src[1]) + (1 << 15)) >> 16) |
||
1186 | - (((i_ict_params[2] * *src[2]) + (1 << 15)) >> 16); |
||
1187 | i2 = *src[0] + (((i_ict_params[3] * *src[1]) + (1 << 15)) >> 16); |
||
1188 | *src[0]++ = i0; |
||
1189 | *src[1]++ = i1; |
||
1190 | *src[2]++ = i2; |
||
1191 | } |
||
1192 | break; |
||
1193 | case FF_DWT53: |
||
1194 | for (i = 0; i < csize; i++) { |
||
1195 | i1 = *src[0] - (*src[2] + *src[1] >> 2); |
||
1196 | i0 = i1 + *src[2]; |
||
1197 | i2 = i1 + *src[1]; |
||
1198 | *src[0]++ = i0; |
||
1199 | *src[1]++ = i1; |
||
1200 | *src[2]++ = i2; |
||
1201 | } |
||
1202 | break; |
||
1203 | } |
||
1204 | } |
||
1205 | |||
1206 | static int jpeg2000_decode_tile(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile, |
||
1207 | AVFrame *picture) |
||
1208 | { |
||
1209 | int compno, reslevelno, bandno; |
||
1210 | int x, y; |
||
1211 | |||
1212 | uint8_t *line; |
||
1213 | Jpeg2000T1Context t1; |
||
1214 | |||
1215 | /* Loop on tile components */ |
||
1216 | for (compno = 0; compno < s->ncomponents; compno++) { |
||
1217 | Jpeg2000Component *comp = tile->comp + compno; |
||
1218 | Jpeg2000CodingStyle *codsty = tile->codsty + compno; |
||
1219 | |||
1220 | /* Loop on resolution levels */ |
||
1221 | for (reslevelno = 0; reslevelno < codsty->nreslevels2decode; reslevelno++) { |
||
1222 | Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno; |
||
1223 | /* Loop on bands */ |
||
1224 | for (bandno = 0; bandno < rlevel->nbands; bandno++) { |
||
1225 | int nb_precincts, precno; |
||
1226 | Jpeg2000Band *band = rlevel->band + bandno; |
||
1227 | int cblkno = 0, bandpos; |
||
1228 | |||
1229 | bandpos = bandno + (reslevelno > 0); |
||
1230 | |||
1231 | if (band->coord[0][0] == band->coord[0][1] || |
||
1232 | band->coord[1][0] == band->coord[1][1]) |
||
1233 | continue; |
||
1234 | |||
1235 | nb_precincts = rlevel->num_precincts_x * rlevel->num_precincts_y; |
||
1236 | /* Loop on precincts */ |
||
1237 | for (precno = 0; precno < nb_precincts; precno++) { |
||
1238 | Jpeg2000Prec *prec = band->prec + precno; |
||
1239 | |||
1240 | /* Loop on codeblocks */ |
||
1241 | for (cblkno = 0; cblkno < prec->nb_codeblocks_width * prec->nb_codeblocks_height; cblkno++) { |
||
1242 | int x, y; |
||
1243 | Jpeg2000Cblk *cblk = prec->cblk + cblkno; |
||
1244 | decode_cblk(s, codsty, &t1, cblk, |
||
1245 | cblk->coord[0][1] - cblk->coord[0][0], |
||
1246 | cblk->coord[1][1] - cblk->coord[1][0], |
||
1247 | bandpos); |
||
1248 | |||
1249 | x = cblk->coord[0][0]; |
||
1250 | y = cblk->coord[1][0]; |
||
1251 | |||
1252 | if (codsty->transform == FF_DWT97) |
||
1253 | dequantization_float(x, y, cblk, comp, &t1, band); |
||
1254 | else |
||
1255 | dequantization_int(x, y, cblk, comp, &t1, band); |
||
1256 | } /* end cblk */ |
||
1257 | } /*end prec */ |
||
1258 | } /* end band */ |
||
1259 | } /* end reslevel */ |
||
1260 | |||
1261 | /* inverse DWT */ |
||
1262 | ff_dwt_decode(&comp->dwt, codsty->transform == FF_DWT97 ? (void*)comp->f_data : (void*)comp->i_data); |
||
1263 | } /*end comp */ |
||
1264 | |||
1265 | /* inverse MCT transformation */ |
||
1266 | if (tile->codsty[0].mct) |
||
1267 | mct_decode(s, tile); |
||
1268 | |||
1269 | if (s->cdef[0] < 0) { |
||
1270 | for (x = 0; x < s->ncomponents; x++) |
||
1271 | s->cdef[x] = x + 1; |
||
1272 | if ((s->ncomponents & 1) == 0) |
||
1273 | s->cdef[s->ncomponents-1] = 0; |
||
1274 | } |
||
1275 | |||
1276 | if (s->precision <= 8) { |
||
1277 | for (compno = 0; compno < s->ncomponents; compno++) { |
||
1278 | Jpeg2000Component *comp = tile->comp + compno; |
||
1279 | Jpeg2000CodingStyle *codsty = tile->codsty + compno; |
||
1280 | float *datap = comp->f_data; |
||
1281 | int32_t *i_datap = comp->i_data; |
||
1282 | int cbps = s->cbps[compno]; |
||
1283 | int w = tile->comp[compno].coord[0][1] - s->image_offset_x; |
||
1284 | int planar = !!picture->data[2]; |
||
1285 | int pixelsize = planar ? 1 : s->ncomponents; |
||
1286 | int plane = 0; |
||
1287 | |||
1288 | if (planar) |
||
1289 | plane = s->cdef[compno] ? s->cdef[compno]-1 : (s->ncomponents-1); |
||
1290 | |||
1291 | |||
1292 | y = tile->comp[compno].coord[1][0] - s->image_offset_y; |
||
1293 | line = picture->data[plane] + y / s->cdy[compno] * picture->linesize[plane]; |
||
1294 | for (; y < tile->comp[compno].coord[1][1] - s->image_offset_y; y += s->cdy[compno]) { |
||
1295 | uint8_t *dst; |
||
1296 | |||
1297 | x = tile->comp[compno].coord[0][0] - s->image_offset_x; |
||
1298 | dst = line + x / s->cdx[compno] * pixelsize + compno*!planar; |
||
1299 | |||
1300 | if (codsty->transform == FF_DWT97) { |
||
1301 | for (; x < w; x += s->cdx[compno]) { |
||
1302 | int val = lrintf(*datap) + (1 << (cbps - 1)); |
||
1303 | /* DC level shift and clip see ISO 15444-1:2002 G.1.2 */ |
||
1304 | val = av_clip(val, 0, (1 << cbps) - 1); |
||
1305 | *dst = val << (8 - cbps); |
||
1306 | datap++; |
||
1307 | dst += pixelsize; |
||
1308 | } |
||
1309 | } else { |
||
1310 | for (; x < w; x += s->cdx[compno]) { |
||
1311 | int val = *i_datap + (1 << (cbps - 1)); |
||
1312 | /* DC level shift and clip see ISO 15444-1:2002 G.1.2 */ |
||
1313 | val = av_clip(val, 0, (1 << cbps) - 1); |
||
1314 | *dst = val << (8 - cbps); |
||
1315 | i_datap++; |
||
1316 | dst += pixelsize; |
||
1317 | } |
||
1318 | } |
||
1319 | line += picture->linesize[plane]; |
||
1320 | } |
||
1321 | } |
||
1322 | } else { |
||
1323 | for (compno = 0; compno < s->ncomponents; compno++) { |
||
1324 | Jpeg2000Component *comp = tile->comp + compno; |
||
1325 | Jpeg2000CodingStyle *codsty = tile->codsty + compno; |
||
1326 | float *datap = comp->f_data; |
||
1327 | int32_t *i_datap = comp->i_data; |
||
1328 | uint16_t *linel; |
||
1329 | int cbps = s->cbps[compno]; |
||
1330 | int w = tile->comp[compno].coord[0][1] - s->image_offset_x; |
||
1331 | int planar = !!picture->data[2]; |
||
1332 | int pixelsize = planar ? 1 : s->ncomponents; |
||
1333 | int plane = 0; |
||
1334 | |||
1335 | if (planar) |
||
1336 | plane = s->cdef[compno] ? s->cdef[compno]-1 : (s->ncomponents-1); |
||
1337 | |||
1338 | y = tile->comp[compno].coord[1][0] - s->image_offset_y; |
||
1339 | linel = (uint16_t *)picture->data[plane] + y / s->cdy[compno] * (picture->linesize[plane] >> 1); |
||
1340 | for (; y < tile->comp[compno].coord[1][1] - s->image_offset_y; y += s->cdy[compno]) { |
||
1341 | uint16_t *dst; |
||
1342 | |||
1343 | x = tile->comp[compno].coord[0][0] - s->image_offset_x; |
||
1344 | dst = linel + (x / s->cdx[compno] * pixelsize + compno*!planar); |
||
1345 | if (codsty->transform == FF_DWT97) { |
||
1346 | for (; x < w; x += s-> cdx[compno]) { |
||
1347 | int val = lrintf(*datap) + (1 << (cbps - 1)); |
||
1348 | /* DC level shift and clip see ISO 15444-1:2002 G.1.2 */ |
||
1349 | val = av_clip(val, 0, (1 << cbps) - 1); |
||
1350 | /* align 12 bit values in little-endian mode */ |
||
1351 | *dst = val << (16 - cbps); |
||
1352 | datap++; |
||
1353 | dst += pixelsize; |
||
1354 | } |
||
1355 | } else { |
||
1356 | for (; x < w; x += s-> cdx[compno]) { |
||
1357 | int val = *i_datap + (1 << (cbps - 1)); |
||
1358 | /* DC level shift and clip see ISO 15444-1:2002 G.1.2 */ |
||
1359 | val = av_clip(val, 0, (1 << cbps) - 1); |
||
1360 | /* align 12 bit values in little-endian mode */ |
||
1361 | *dst = val << (16 - cbps); |
||
1362 | i_datap++; |
||
1363 | dst += pixelsize; |
||
1364 | } |
||
1365 | } |
||
1366 | linel += picture->linesize[plane] >> 1; |
||
1367 | } |
||
1368 | } |
||
1369 | } |
||
1370 | |||
1371 | return 0; |
||
1372 | } |
||
1373 | |||
1374 | static void jpeg2000_dec_cleanup(Jpeg2000DecoderContext *s) |
||
1375 | { |
||
1376 | int tileno, compno; |
||
1377 | for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++) { |
||
1378 | if (s->tile[tileno].comp) { |
||
1379 | for (compno = 0; compno < s->ncomponents; compno++) { |
||
1380 | Jpeg2000Component *comp = s->tile[tileno].comp + compno; |
||
1381 | Jpeg2000CodingStyle *codsty = s->tile[tileno].codsty + compno; |
||
1382 | |||
1383 | ff_jpeg2000_cleanup(comp, codsty); |
||
1384 | } |
||
1385 | av_freep(&s->tile[tileno].comp); |
||
1386 | } |
||
1387 | } |
||
1388 | av_freep(&s->tile); |
||
1389 | memset(s->codsty, 0, sizeof(s->codsty)); |
||
1390 | memset(s->qntsty, 0, sizeof(s->qntsty)); |
||
1391 | s->numXtiles = s->numYtiles = 0; |
||
1392 | } |
||
1393 | |||
1394 | static int jpeg2000_read_main_headers(Jpeg2000DecoderContext *s) |
||
1395 | { |
||
1396 | Jpeg2000CodingStyle *codsty = s->codsty; |
||
1397 | Jpeg2000QuantStyle *qntsty = s->qntsty; |
||
1398 | uint8_t *properties = s->properties; |
||
1399 | |||
1400 | for (;;) { |
||
1401 | int len, ret = 0; |
||
1402 | uint16_t marker; |
||
1403 | int oldpos; |
||
1404 | |||
1405 | if (bytestream2_get_bytes_left(&s->g) < 2) { |
||
1406 | av_log(s->avctx, AV_LOG_ERROR, "Missing EOC\n"); |
||
1407 | break; |
||
1408 | } |
||
1409 | |||
1410 | marker = bytestream2_get_be16u(&s->g); |
||
1411 | oldpos = bytestream2_tell(&s->g); |
||
1412 | |||
1413 | if (marker == JPEG2000_SOD) { |
||
1414 | Jpeg2000Tile *tile; |
||
1415 | Jpeg2000TilePart *tp; |
||
1416 | |||
1417 | if (!s->tile) { |
||
1418 | av_log(s->avctx, AV_LOG_ERROR, "Missing SIZ\n"); |
||
1419 | return AVERROR_INVALIDDATA; |
||
1420 | } |
||
1421 | if (s->curtileno < 0) { |
||
1422 | av_log(s->avctx, AV_LOG_ERROR, "Missing SOT\n"); |
||
1423 | return AVERROR_INVALIDDATA; |
||
1424 | } |
||
1425 | |||
1426 | tile = s->tile + s->curtileno; |
||
1427 | tp = tile->tile_part + tile->tp_idx; |
||
1428 | if (tp->tp_end < s->g.buffer) { |
||
1429 | av_log(s->avctx, AV_LOG_ERROR, "Invalid tpend\n"); |
||
1430 | return AVERROR_INVALIDDATA; |
||
1431 | } |
||
1432 | bytestream2_init(&tp->tpg, s->g.buffer, tp->tp_end - s->g.buffer); |
||
1433 | bytestream2_skip(&s->g, tp->tp_end - s->g.buffer); |
||
1434 | |||
1435 | continue; |
||
1436 | } |
||
1437 | if (marker == JPEG2000_EOC) |
||
1438 | break; |
||
1439 | |||
1440 | len = bytestream2_get_be16(&s->g); |
||
1441 | if (len < 2 || bytestream2_get_bytes_left(&s->g) < len - 2) |
||
1442 | return AVERROR_INVALIDDATA; |
||
1443 | |||
1444 | switch (marker) { |
||
1445 | case JPEG2000_SIZ: |
||
1446 | ret = get_siz(s); |
||
1447 | if (!s->tile) |
||
1448 | s->numXtiles = s->numYtiles = 0; |
||
1449 | break; |
||
1450 | case JPEG2000_COC: |
||
1451 | ret = get_coc(s, codsty, properties); |
||
1452 | break; |
||
1453 | case JPEG2000_COD: |
||
1454 | ret = get_cod(s, codsty, properties); |
||
1455 | break; |
||
1456 | case JPEG2000_QCC: |
||
1457 | ret = get_qcc(s, len, qntsty, properties); |
||
1458 | break; |
||
1459 | case JPEG2000_QCD: |
||
1460 | ret = get_qcd(s, len, qntsty, properties); |
||
1461 | break; |
||
1462 | case JPEG2000_SOT: |
||
1463 | if (!(ret = get_sot(s, len))) { |
||
1464 | av_assert1(s->curtileno >= 0); |
||
1465 | codsty = s->tile[s->curtileno].codsty; |
||
1466 | qntsty = s->tile[s->curtileno].qntsty; |
||
1467 | properties = s->tile[s->curtileno].properties; |
||
1468 | } |
||
1469 | break; |
||
1470 | case JPEG2000_COM: |
||
1471 | // the comment is ignored |
||
1472 | bytestream2_skip(&s->g, len - 2); |
||
1473 | break; |
||
1474 | case JPEG2000_TLM: |
||
1475 | // Tile-part lengths |
||
1476 | ret = get_tlm(s, len); |
||
1477 | break; |
||
1478 | default: |
||
1479 | av_log(s->avctx, AV_LOG_ERROR, |
||
1480 | "unsupported marker 0x%.4X at pos 0x%X\n", |
||
1481 | marker, bytestream2_tell(&s->g) - 4); |
||
1482 | bytestream2_skip(&s->g, len - 2); |
||
1483 | break; |
||
1484 | } |
||
1485 | if (bytestream2_tell(&s->g) - oldpos != len || ret) { |
||
1486 | av_log(s->avctx, AV_LOG_ERROR, |
||
1487 | "error during processing marker segment %.4x\n", marker); |
||
1488 | return ret ? ret : -1; |
||
1489 | } |
||
1490 | } |
||
1491 | return 0; |
||
1492 | } |
||
1493 | |||
1494 | /* Read bit stream packets --> T2 operation. */ |
||
1495 | static int jpeg2000_read_bitstream_packets(Jpeg2000DecoderContext *s) |
||
1496 | { |
||
1497 | int ret = 0; |
||
1498 | int tileno; |
||
1499 | |||
1500 | for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++) { |
||
1501 | Jpeg2000Tile *tile = s->tile + tileno; |
||
1502 | |||
1503 | if (ret = init_tile(s, tileno)) |
||
1504 | return ret; |
||
1505 | |||
1506 | s->g = tile->tile_part[0].tpg; |
||
1507 | if (ret = jpeg2000_decode_packets(s, tile)) |
||
1508 | return ret; |
||
1509 | } |
||
1510 | |||
1511 | return 0; |
||
1512 | } |
||
1513 | |||
1514 | static int jp2_find_codestream(Jpeg2000DecoderContext *s) |
||
1515 | { |
||
1516 | uint32_t atom_size, atom, atom_end; |
||
1517 | int search_range = 10; |
||
1518 | |||
1519 | while (search_range |
||
1520 | && |
||
1521 | bytestream2_get_bytes_left(&s->g) >= 8) { |
||
1522 | atom_size = bytestream2_get_be32u(&s->g); |
||
1523 | atom = bytestream2_get_be32u(&s->g); |
||
1524 | atom_end = bytestream2_tell(&s->g) + atom_size - 8; |
||
1525 | |||
1526 | if (atom == JP2_CODESTREAM) |
||
1527 | return 1; |
||
1528 | |||
1529 | if (bytestream2_get_bytes_left(&s->g) < atom_size || atom_end < atom_size) |
||
1530 | return 0; |
||
1531 | |||
1532 | if (atom == JP2_HEADER && |
||
1533 | atom_size >= 16) { |
||
1534 | uint32_t atom2_size, atom2, atom2_end; |
||
1535 | do { |
||
1536 | atom2_size = bytestream2_get_be32u(&s->g); |
||
1537 | atom2 = bytestream2_get_be32u(&s->g); |
||
1538 | atom2_end = bytestream2_tell(&s->g) + atom2_size - 8; |
||
1539 | if (atom2_size < 8 || atom2_end > atom_end || atom2_end < atom2_size) |
||
1540 | break; |
||
1541 | if (atom2 == JP2_CODESTREAM) { |
||
1542 | return 1; |
||
1543 | } else if (atom2 == MKBETAG('c','o','l','r') && atom2_size >= 7) { |
||
1544 | int method = bytestream2_get_byteu(&s->g); |
||
1545 | bytestream2_skipu(&s->g, 2); |
||
1546 | if (method == 1) { |
||
1547 | s->colour_space = bytestream2_get_be32u(&s->g); |
||
1548 | } |
||
1549 | } else if (atom2 == MKBETAG('p','c','l','r') && atom2_size >= 6) { |
||
1550 | int i, size, colour_count, colour_channels, colour_depth[3]; |
||
1551 | uint32_t r, g, b; |
||
1552 | colour_count = bytestream2_get_be16u(&s->g); |
||
1553 | colour_channels = bytestream2_get_byteu(&s->g); |
||
1554 | // FIXME: Do not ignore channel_sign |
||
1555 | colour_depth[0] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1; |
||
1556 | colour_depth[1] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1; |
||
1557 | colour_depth[2] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1; |
||
1558 | size = (colour_depth[0] + 7 >> 3) * colour_count + |
||
1559 | (colour_depth[1] + 7 >> 3) * colour_count + |
||
1560 | (colour_depth[2] + 7 >> 3) * colour_count; |
||
1561 | if (colour_count > 256 || |
||
1562 | colour_channels != 3 || |
||
1563 | colour_depth[0] > 16 || |
||
1564 | colour_depth[1] > 16 || |
||
1565 | colour_depth[2] > 16 || |
||
1566 | atom2_size < size) { |
||
1567 | avpriv_request_sample(s->avctx, "Unknown palette"); |
||
1568 | bytestream2_seek(&s->g, atom2_end, SEEK_SET); |
||
1569 | continue; |
||
1570 | } |
||
1571 | s->pal8 = 1; |
||
1572 | for (i = 0; i < colour_count; i++) { |
||
1573 | if (colour_depth[0] <= 8) { |
||
1574 | r = bytestream2_get_byteu(&s->g) << 8 - colour_depth[0]; |
||
1575 | r |= r >> colour_depth[0]; |
||
1576 | } else { |
||
1577 | r = bytestream2_get_be16u(&s->g) >> colour_depth[0] - 8; |
||
1578 | } |
||
1579 | if (colour_depth[1] <= 8) { |
||
1580 | g = bytestream2_get_byteu(&s->g) << 8 - colour_depth[1]; |
||
1581 | r |= r >> colour_depth[1]; |
||
1582 | } else { |
||
1583 | g = bytestream2_get_be16u(&s->g) >> colour_depth[1] - 8; |
||
1584 | } |
||
1585 | if (colour_depth[2] <= 8) { |
||
1586 | b = bytestream2_get_byteu(&s->g) << 8 - colour_depth[2]; |
||
1587 | r |= r >> colour_depth[2]; |
||
1588 | } else { |
||
1589 | b = bytestream2_get_be16u(&s->g) >> colour_depth[2] - 8; |
||
1590 | } |
||
1591 | s->palette[i] = 0xffu << 24 | r << 16 | g << 8 | b; |
||
1592 | } |
||
1593 | } else if (atom2 == MKBETAG('c','d','e','f') && atom2_size >= 2) { |
||
1594 | int n = bytestream2_get_be16u(&s->g); |
||
1595 | for (; n>0; n--) { |
||
1596 | int cn = bytestream2_get_be16(&s->g); |
||
1597 | int av_unused typ = bytestream2_get_be16(&s->g); |
||
1598 | int asoc = bytestream2_get_be16(&s->g); |
||
1599 | if (cn < 4 || asoc < 4) |
||
1600 | s->cdef[cn] = asoc; |
||
1601 | } |
||
1602 | } |
||
1603 | bytestream2_seek(&s->g, atom2_end, SEEK_SET); |
||
1604 | } while (atom_end - atom2_end >= 8); |
||
1605 | } else { |
||
1606 | search_range--; |
||
1607 | } |
||
1608 | bytestream2_seek(&s->g, atom_end, SEEK_SET); |
||
1609 | } |
||
1610 | |||
1611 | return 0; |
||
1612 | } |
||
1613 | |||
1614 | static int jpeg2000_decode_frame(AVCodecContext *avctx, void *data, |
||
1615 | int *got_frame, AVPacket *avpkt) |
||
1616 | { |
||
1617 | Jpeg2000DecoderContext *s = avctx->priv_data; |
||
1618 | ThreadFrame frame = { .f = data }; |
||
1619 | AVFrame *picture = data; |
||
1620 | int tileno, ret; |
||
1621 | |||
1622 | s->avctx = avctx; |
||
1623 | bytestream2_init(&s->g, avpkt->data, avpkt->size); |
||
1624 | s->curtileno = -1; |
||
1625 | memset(s->cdef, -1, sizeof(s->cdef)); |
||
1626 | |||
1627 | if (bytestream2_get_bytes_left(&s->g) < 2) { |
||
1628 | ret = AVERROR_INVALIDDATA; |
||
1629 | goto end; |
||
1630 | } |
||
1631 | |||
1632 | // check if the image is in jp2 format |
||
1633 | if (bytestream2_get_bytes_left(&s->g) >= 12 && |
||
1634 | (bytestream2_get_be32u(&s->g) == 12) && |
||
1635 | (bytestream2_get_be32u(&s->g) == JP2_SIG_TYPE) && |
||
1636 | (bytestream2_get_be32u(&s->g) == JP2_SIG_VALUE)) { |
||
1637 | if (!jp2_find_codestream(s)) { |
||
1638 | av_log(avctx, AV_LOG_ERROR, |
||
1639 | "Could not find Jpeg2000 codestream atom.\n"); |
||
1640 | ret = AVERROR_INVALIDDATA; |
||
1641 | goto end; |
||
1642 | } |
||
1643 | } else { |
||
1644 | bytestream2_seek(&s->g, 0, SEEK_SET); |
||
1645 | } |
||
1646 | |||
1647 | while (bytestream2_get_bytes_left(&s->g) >= 3 && bytestream2_peek_be16(&s->g) != JPEG2000_SOC) |
||
1648 | bytestream2_skip(&s->g, 1); |
||
1649 | |||
1650 | if (bytestream2_get_be16u(&s->g) != JPEG2000_SOC) { |
||
1651 | av_log(avctx, AV_LOG_ERROR, "SOC marker not present\n"); |
||
1652 | ret = AVERROR_INVALIDDATA; |
||
1653 | goto end; |
||
1654 | } |
||
1655 | if (ret = jpeg2000_read_main_headers(s)) |
||
1656 | goto end; |
||
1657 | |||
1658 | /* get picture buffer */ |
||
1659 | if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0) |
||
1660 | goto end; |
||
1661 | picture->pict_type = AV_PICTURE_TYPE_I; |
||
1662 | picture->key_frame = 1; |
||
1663 | |||
1664 | if (ret = jpeg2000_read_bitstream_packets(s)) |
||
1665 | goto end; |
||
1666 | |||
1667 | for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++) |
||
1668 | if (ret = jpeg2000_decode_tile(s, s->tile + tileno, picture)) |
||
1669 | goto end; |
||
1670 | |||
1671 | jpeg2000_dec_cleanup(s); |
||
1672 | |||
1673 | *got_frame = 1; |
||
1674 | |||
1675 | if (s->avctx->pix_fmt == AV_PIX_FMT_PAL8) |
||
1676 | memcpy(picture->data[1], s->palette, 256 * sizeof(uint32_t)); |
||
1677 | |||
1678 | return bytestream2_tell(&s->g); |
||
1679 | |||
1680 | end: |
||
1681 | jpeg2000_dec_cleanup(s); |
||
1682 | return ret; |
||
1683 | } |
||
1684 | |||
1685 | static void jpeg2000_init_static_data(AVCodec *codec) |
||
1686 | { |
||
1687 | ff_jpeg2000_init_tier1_luts(); |
||
1688 | ff_mqc_init_context_tables(); |
||
1689 | } |
||
1690 | |||
1691 | #define OFFSET(x) offsetof(Jpeg2000DecoderContext, x) |
||
1692 | #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM |
||
1693 | |||
1694 | static const AVOption options[] = { |
||
1695 | { "lowres", "Lower the decoding resolution by a power of two", |
||
1696 | OFFSET(reduction_factor), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, JPEG2000_MAX_RESLEVELS - 1, VD }, |
||
1697 | { NULL }, |
||
1698 | }; |
||
1699 | |||
1700 | static const AVProfile profiles[] = { |
||
1701 | { FF_PROFILE_JPEG2000_CSTREAM_RESTRICTION_0, "JPEG 2000 codestream restriction 0" }, |
||
1702 | { FF_PROFILE_JPEG2000_CSTREAM_RESTRICTION_1, "JPEG 2000 codestream restriction 1" }, |
||
1703 | { FF_PROFILE_JPEG2000_CSTREAM_NO_RESTRICTION, "JPEG 2000 no codestream restrictions" }, |
||
1704 | { FF_PROFILE_JPEG2000_DCINEMA_2K, "JPEG 2000 digital cinema 2K" }, |
||
1705 | { FF_PROFILE_JPEG2000_DCINEMA_4K, "JPEG 2000 digital cinema 4K" }, |
||
1706 | { FF_PROFILE_UNKNOWN }, |
||
1707 | }; |
||
1708 | |||
1709 | static const AVClass jpeg2000_class = { |
||
1710 | .class_name = "jpeg2000", |
||
1711 | .item_name = av_default_item_name, |
||
1712 | .option = options, |
||
1713 | .version = LIBAVUTIL_VERSION_INT, |
||
1714 | }; |
||
1715 | |||
1716 | AVCodec ff_jpeg2000_decoder = { |
||
1717 | .name = "jpeg2000", |
||
1718 | .long_name = NULL_IF_CONFIG_SMALL("JPEG 2000"), |
||
1719 | .type = AVMEDIA_TYPE_VIDEO, |
||
1720 | .id = AV_CODEC_ID_JPEG2000, |
||
1721 | .capabilities = CODEC_CAP_FRAME_THREADS, |
||
1722 | .priv_data_size = sizeof(Jpeg2000DecoderContext), |
||
1723 | .init_static_data = jpeg2000_init_static_data, |
||
1724 | .decode = jpeg2000_decode_frame, |
||
1725 | .priv_class = &jpeg2000_class, |
||
1726 | .max_lowres = 5, |
||
1727 | .profiles = NULL_IF_CONFIG_SMALL(profiles) |
||
1728 | };>>>>>><>><>><>><>=>><>=>><>=>>>>>>>>>>>>>>>><>><>><>>><>><>><>>>>><>><>><>>><>><>><>>>>=>>>>>>>>>><>><>><>><>>>>>>16)><16)>><>>>>>>>=>=>><>><>><>>>>><>>>>><>>>>>>><>>>>>>><>>>><>><>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>=>>>>><>><>>>=>=>=>>>>>=><=> |