1 /*
2 * JPEG 2000 image decoder
3 * Copyright (c) 2007 Kamil Nowosad
4 * Copyright (c) 2013 Nicolas Bertrand <nicoinattendu@gmail.com>
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 <inttypes.h>
29 #include <math.h>
30
31 #include "libavutil/attributes.h"
32 #include "libavutil/avassert.h"
33 #include "libavutil/common.h"
34 #include "libavutil/imgutils.h"
35 #include "libavutil/opt.h"
36 #include "libavutil/pixdesc.h"
37 #include "libavutil/thread.h"
38 #include "avcodec.h"
39 #include "bytestream.h"
40 #include "internal.h"
41 #include "thread.h"
42 #include "jpeg2000.h"
43 #include "jpeg2000dsp.h"
44 #include "profiles.h"
45
46 #define JP2_SIG_TYPE 0x6A502020
47 #define JP2_SIG_VALUE 0x0D0A870A
48 #define JP2_CODESTREAM 0x6A703263
49 #define JP2_HEADER 0x6A703268
50
51 #define HAD_COC 0x01
52 #define HAD_QCC 0x02
53
54 #define MAX_POCS 32
55
56 typedef struct Jpeg2000POCEntry {
57 uint16_t LYEpoc;
58 uint16_t CSpoc;
59 uint16_t CEpoc;
60 uint8_t RSpoc;
61 uint8_t REpoc;
62 uint8_t Ppoc;
63 } Jpeg2000POCEntry;
64
65 typedef struct Jpeg2000POC {
66 Jpeg2000POCEntry poc[MAX_POCS];
67 int nb_poc;
68 int is_default;
69 } Jpeg2000POC;
70
71 typedef struct Jpeg2000TilePart {
72 uint8_t tile_index; // Tile index who refers the tile-part
73 const uint8_t *tp_end;
74 GetByteContext header_tpg; // bit stream of header if PPM header is used
75 GetByteContext tpg; // bit stream in tile-part
76 } Jpeg2000TilePart;
77
78 /* RMK: For JPEG2000 DCINEMA 3 tile-parts in a tile
79 * one per component, so tile_part elements have a size of 3 */
80 typedef struct Jpeg2000Tile {
81 Jpeg2000Component *comp;
82 uint8_t properties[4];
83 Jpeg2000CodingStyle codsty[4];
84 Jpeg2000QuantStyle qntsty[4];
85 Jpeg2000POC poc;
86 Jpeg2000TilePart tile_part[32];
87 uint8_t has_ppt; // whether this tile has a ppt marker
88 uint8_t *packed_headers; // contains packed headers. Used only along with PPT marker
89 int packed_headers_size; // size in bytes of the packed headers
90 GetByteContext packed_headers_stream; // byte context corresponding to packed headers
91 uint16_t tp_idx; // Tile-part index
92 int coord[2][2]; // border coordinates {{x0, x1}, {y0, y1}}
93 } Jpeg2000Tile;
94
95 typedef struct Jpeg2000DecoderContext {
96 AVClass *class;
97 AVCodecContext *avctx;
98 GetByteContext g;
99
100 int width, height;
101 int image_offset_x, image_offset_y;
102 int tile_offset_x, tile_offset_y;
103 uint8_t cbps[4]; // bits per sample in particular components
104 uint8_t sgnd[4]; // if a component is signed
105 uint8_t properties[4];
106
107 uint8_t has_ppm;
108 uint8_t *packed_headers; // contains packed headers. Used only along with PPM marker
109 int packed_headers_size;
110 GetByteContext packed_headers_stream;
111 uint8_t in_tile_headers;
112
113 int cdx[4], cdy[4];
114 int precision;
115 int ncomponents;
116 int colour_space;
117 uint32_t palette[256];
118 int8_t pal8;
119 int cdef[4];
120 int tile_width, tile_height;
121 unsigned numXtiles, numYtiles;
122 int maxtilelen;
123 AVRational sar;
124
125 Jpeg2000CodingStyle codsty[4];
126 Jpeg2000QuantStyle qntsty[4];
127 Jpeg2000POC poc;
128 uint8_t roi_shift[4];
129
130 int bit_index;
131
132 int curtileno;
133
134 Jpeg2000Tile *tile;
135 Jpeg2000DSPContext dsp;
136
137 /*options parameters*/
138 int reduction_factor;
139 } Jpeg2000DecoderContext;
140
141 /* get_bits functions for JPEG2000 packet bitstream
142 * It is a get_bit function with a bit-stuffing routine. If the value of the
143 * byte is 0xFF, the next byte includes an extra zero bit stuffed into the MSB.
144 * cf. ISO-15444-1:2002 / B.10.1 Bit-stuffing routine */
get_bits(Jpeg2000DecoderContext * s,int n)145 static int get_bits(Jpeg2000DecoderContext *s, int n)
146 {
147 int res = 0;
148
149 while (--n >= 0) {
150 res <<= 1;
151 if (s->bit_index == 0) {
152 s->bit_index = 7 + (bytestream2_get_byte(&s->g) != 0xFFu);
153 }
154 s->bit_index--;
155 res |= (bytestream2_peek_byte(&s->g) >> s->bit_index) & 1;
156 }
157 return res;
158 }
159
jpeg2000_flush(Jpeg2000DecoderContext * s)160 static void jpeg2000_flush(Jpeg2000DecoderContext *s)
161 {
162 if (bytestream2_get_byte(&s->g) == 0xff)
163 bytestream2_skip(&s->g, 1);
164 s->bit_index = 8;
165 }
166
167 /* decode the value stored in node */
tag_tree_decode(Jpeg2000DecoderContext * s,Jpeg2000TgtNode * node,int threshold)168 static int tag_tree_decode(Jpeg2000DecoderContext *s, Jpeg2000TgtNode *node,
169 int threshold)
170 {
171 Jpeg2000TgtNode *stack[30];
172 int sp = -1, curval = 0;
173
174 if (!node) {
175 av_log(s->avctx, AV_LOG_ERROR, "missing node\n");
176 return AVERROR_INVALIDDATA;
177 }
178
179 while (node && !node->vis) {
180 stack[++sp] = node;
181 node = node->parent;
182 }
183
184 if (node)
185 curval = node->val;
186 else
187 curval = stack[sp]->val;
188
189 while (curval < threshold && sp >= 0) {
190 if (curval < stack[sp]->val)
191 curval = stack[sp]->val;
192 while (curval < threshold) {
193 int ret;
194 if ((ret = get_bits(s, 1)) > 0) {
195 stack[sp]->vis++;
196 break;
197 } else if (!ret)
198 curval++;
199 else
200 return ret;
201 }
202 stack[sp]->val = curval;
203 sp--;
204 }
205 return curval;
206 }
207
pix_fmt_match(enum AVPixelFormat pix_fmt,int components,int bpc,uint32_t log2_chroma_wh,int pal8)208 static int pix_fmt_match(enum AVPixelFormat pix_fmt, int components,
209 int bpc, uint32_t log2_chroma_wh, int pal8)
210 {
211 int match = 1;
212 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
213
214 av_assert2(desc);
215
216 if (desc->nb_components != components) {
217 return 0;
218 }
219
220 switch (components) {
221 case 4:
222 match = match && desc->comp[3].depth >= bpc &&
223 (log2_chroma_wh >> 14 & 3) == 0 &&
224 (log2_chroma_wh >> 12 & 3) == 0;
225 case 3:
226 match = match && desc->comp[2].depth >= bpc &&
227 (log2_chroma_wh >> 10 & 3) == desc->log2_chroma_w &&
228 (log2_chroma_wh >> 8 & 3) == desc->log2_chroma_h;
229 case 2:
230 match = match && desc->comp[1].depth >= bpc &&
231 (log2_chroma_wh >> 6 & 3) == desc->log2_chroma_w &&
232 (log2_chroma_wh >> 4 & 3) == desc->log2_chroma_h;
233
234 case 1:
235 match = match && desc->comp[0].depth >= bpc &&
236 (log2_chroma_wh >> 2 & 3) == 0 &&
237 (log2_chroma_wh & 3) == 0 &&
238 (desc->flags & AV_PIX_FMT_FLAG_PAL) == pal8 * AV_PIX_FMT_FLAG_PAL;
239 }
240 return match;
241 }
242
243 // pix_fmts with lower bpp have to be listed before
244 // similar pix_fmts with higher bpp.
245 #define RGB_PIXEL_FORMATS AV_PIX_FMT_PAL8,AV_PIX_FMT_RGB24,AV_PIX_FMT_RGBA,AV_PIX_FMT_RGB48,AV_PIX_FMT_RGBA64
246 #define GRAY_PIXEL_FORMATS AV_PIX_FMT_GRAY8,AV_PIX_FMT_GRAY8A,AV_PIX_FMT_GRAY16,AV_PIX_FMT_YA16
247 #define YUV_PIXEL_FORMATS AV_PIX_FMT_YUV410P,AV_PIX_FMT_YUV411P,AV_PIX_FMT_YUVA420P, \
248 AV_PIX_FMT_YUV420P,AV_PIX_FMT_YUV422P,AV_PIX_FMT_YUVA422P, \
249 AV_PIX_FMT_YUV440P,AV_PIX_FMT_YUV444P,AV_PIX_FMT_YUVA444P, \
250 AV_PIX_FMT_YUV420P9,AV_PIX_FMT_YUV422P9,AV_PIX_FMT_YUV444P9, \
251 AV_PIX_FMT_YUVA420P9,AV_PIX_FMT_YUVA422P9,AV_PIX_FMT_YUVA444P9, \
252 AV_PIX_FMT_YUV420P10,AV_PIX_FMT_YUV422P10,AV_PIX_FMT_YUV444P10, \
253 AV_PIX_FMT_YUVA420P10,AV_PIX_FMT_YUVA422P10,AV_PIX_FMT_YUVA444P10, \
254 AV_PIX_FMT_YUV420P12,AV_PIX_FMT_YUV422P12,AV_PIX_FMT_YUV444P12, \
255 AV_PIX_FMT_YUV420P14,AV_PIX_FMT_YUV422P14,AV_PIX_FMT_YUV444P14, \
256 AV_PIX_FMT_YUV420P16,AV_PIX_FMT_YUV422P16,AV_PIX_FMT_YUV444P16, \
257 AV_PIX_FMT_YUVA420P16,AV_PIX_FMT_YUVA422P16,AV_PIX_FMT_YUVA444P16
258 #define XYZ_PIXEL_FORMATS AV_PIX_FMT_XYZ12
259
260 static const enum AVPixelFormat rgb_pix_fmts[] = {RGB_PIXEL_FORMATS};
261 static const enum AVPixelFormat gray_pix_fmts[] = {GRAY_PIXEL_FORMATS};
262 static const enum AVPixelFormat yuv_pix_fmts[] = {YUV_PIXEL_FORMATS};
263 static const enum AVPixelFormat xyz_pix_fmts[] = {XYZ_PIXEL_FORMATS,
264 YUV_PIXEL_FORMATS};
265 static const enum AVPixelFormat all_pix_fmts[] = {RGB_PIXEL_FORMATS,
266 GRAY_PIXEL_FORMATS,
267 YUV_PIXEL_FORMATS,
268 XYZ_PIXEL_FORMATS};
269
270 /* marker segments */
271 /* get sizes and offsets of image, tiles; number of components */
get_siz(Jpeg2000DecoderContext * s)272 static int get_siz(Jpeg2000DecoderContext *s)
273 {
274 int i;
275 int ncomponents;
276 uint32_t log2_chroma_wh = 0;
277 const enum AVPixelFormat *possible_fmts = NULL;
278 int possible_fmts_nb = 0;
279 int ret;
280 int o_dimx, o_dimy; //original image dimensions.
281 int dimx, dimy;
282
283 if (bytestream2_get_bytes_left(&s->g) < 36) {
284 av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for SIZ\n");
285 return AVERROR_INVALIDDATA;
286 }
287
288 s->avctx->profile = bytestream2_get_be16u(&s->g); // Rsiz
289 s->width = bytestream2_get_be32u(&s->g); // Width
290 s->height = bytestream2_get_be32u(&s->g); // Height
291 s->image_offset_x = bytestream2_get_be32u(&s->g); // X0Siz
292 s->image_offset_y = bytestream2_get_be32u(&s->g); // Y0Siz
293 s->tile_width = bytestream2_get_be32u(&s->g); // XTSiz
294 s->tile_height = bytestream2_get_be32u(&s->g); // YTSiz
295 s->tile_offset_x = bytestream2_get_be32u(&s->g); // XT0Siz
296 s->tile_offset_y = bytestream2_get_be32u(&s->g); // YT0Siz
297 ncomponents = bytestream2_get_be16u(&s->g); // CSiz
298
299 if (av_image_check_size2(s->width, s->height, s->avctx->max_pixels, AV_PIX_FMT_NONE, 0, s->avctx)) {
300 avpriv_request_sample(s->avctx, "Large Dimensions");
301 return AVERROR_PATCHWELCOME;
302 }
303
304 if (ncomponents <= 0) {
305 av_log(s->avctx, AV_LOG_ERROR, "Invalid number of components: %d\n",
306 s->ncomponents);
307 return AVERROR_INVALIDDATA;
308 }
309
310 if (ncomponents > 4) {
311 avpriv_request_sample(s->avctx, "Support for %d components",
312 ncomponents);
313 return AVERROR_PATCHWELCOME;
314 }
315
316 if (s->tile_offset_x < 0 || s->tile_offset_y < 0 ||
317 s->image_offset_x < s->tile_offset_x ||
318 s->image_offset_y < s->tile_offset_y ||
319 s->tile_width + (int64_t)s->tile_offset_x <= s->image_offset_x ||
320 s->tile_height + (int64_t)s->tile_offset_y <= s->image_offset_y
321 ) {
322 av_log(s->avctx, AV_LOG_ERROR, "Tile offsets are invalid\n");
323 return AVERROR_INVALIDDATA;
324 }
325
326 s->ncomponents = ncomponents;
327
328 if (s->tile_width <= 0 || s->tile_height <= 0) {
329 av_log(s->avctx, AV_LOG_ERROR, "Invalid tile dimension %dx%d.\n",
330 s->tile_width, s->tile_height);
331 return AVERROR_INVALIDDATA;
332 }
333
334 if (bytestream2_get_bytes_left(&s->g) < 3 * s->ncomponents) {
335 av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for %d components in SIZ\n", s->ncomponents);
336 return AVERROR_INVALIDDATA;
337 }
338
339 for (i = 0; i < s->ncomponents; i++) { // Ssiz_i XRsiz_i, YRsiz_i
340 uint8_t x = bytestream2_get_byteu(&s->g);
341 s->cbps[i] = (x & 0x7f) + 1;
342 s->precision = FFMAX(s->cbps[i], s->precision);
343 s->sgnd[i] = !!(x & 0x80);
344 s->cdx[i] = bytestream2_get_byteu(&s->g);
345 s->cdy[i] = bytestream2_get_byteu(&s->g);
346 if ( !s->cdx[i] || s->cdx[i] == 3 || s->cdx[i] > 4
347 || !s->cdy[i] || s->cdy[i] == 3 || s->cdy[i] > 4) {
348 av_log(s->avctx, AV_LOG_ERROR, "Invalid sample separation %d/%d\n", s->cdx[i], s->cdy[i]);
349 return AVERROR_INVALIDDATA;
350 }
351 log2_chroma_wh |= s->cdy[i] >> 1 << i * 4 | s->cdx[i] >> 1 << i * 4 + 2;
352 }
353
354 s->numXtiles = ff_jpeg2000_ceildiv(s->width - s->tile_offset_x, s->tile_width);
355 s->numYtiles = ff_jpeg2000_ceildiv(s->height - s->tile_offset_y, s->tile_height);
356
357 // There must be at least a SOT and SOD per tile, their minimum size is 14
358 if (s->numXtiles * (uint64_t)s->numYtiles > INT_MAX/sizeof(*s->tile) ||
359 s->numXtiles * s->numYtiles * 14LL > bytestream2_size(&s->g)
360 ) {
361 s->numXtiles = s->numYtiles = 0;
362 return AVERROR(EINVAL);
363 }
364
365 s->tile = av_mallocz_array(s->numXtiles * s->numYtiles, sizeof(*s->tile));
366 if (!s->tile) {
367 s->numXtiles = s->numYtiles = 0;
368 return AVERROR(ENOMEM);
369 }
370
371 for (i = 0; i < s->numXtiles * s->numYtiles; i++) {
372 Jpeg2000Tile *tile = s->tile + i;
373
374 tile->comp = av_mallocz(s->ncomponents * sizeof(*tile->comp));
375 if (!tile->comp)
376 return AVERROR(ENOMEM);
377 }
378
379 /* compute image size with reduction factor */
380 o_dimx = ff_jpeg2000_ceildivpow2(s->width - s->image_offset_x,
381 s->reduction_factor);
382 o_dimy = ff_jpeg2000_ceildivpow2(s->height - s->image_offset_y,
383 s->reduction_factor);
384 dimx = ff_jpeg2000_ceildiv(o_dimx, s->cdx[0]);
385 dimy = ff_jpeg2000_ceildiv(o_dimy, s->cdy[0]);
386 for (i = 1; i < s->ncomponents; i++) {
387 dimx = FFMAX(dimx, ff_jpeg2000_ceildiv(o_dimx, s->cdx[i]));
388 dimy = FFMAX(dimy, ff_jpeg2000_ceildiv(o_dimy, s->cdy[i]));
389 }
390
391 ret = ff_set_dimensions(s->avctx, dimx, dimy);
392 if (ret < 0)
393 return ret;
394
395 if (s->avctx->profile == FF_PROFILE_JPEG2000_DCINEMA_2K ||
396 s->avctx->profile == FF_PROFILE_JPEG2000_DCINEMA_4K) {
397 possible_fmts = xyz_pix_fmts;
398 possible_fmts_nb = FF_ARRAY_ELEMS(xyz_pix_fmts);
399 } else {
400 switch (s->colour_space) {
401 case 16:
402 possible_fmts = rgb_pix_fmts;
403 possible_fmts_nb = FF_ARRAY_ELEMS(rgb_pix_fmts);
404 break;
405 case 17:
406 possible_fmts = gray_pix_fmts;
407 possible_fmts_nb = FF_ARRAY_ELEMS(gray_pix_fmts);
408 break;
409 case 18:
410 possible_fmts = yuv_pix_fmts;
411 possible_fmts_nb = FF_ARRAY_ELEMS(yuv_pix_fmts);
412 break;
413 default:
414 possible_fmts = all_pix_fmts;
415 possible_fmts_nb = FF_ARRAY_ELEMS(all_pix_fmts);
416 break;
417 }
418 }
419 if ( s->avctx->pix_fmt != AV_PIX_FMT_NONE
420 && !pix_fmt_match(s->avctx->pix_fmt, ncomponents, s->precision, log2_chroma_wh, s->pal8))
421 s->avctx->pix_fmt = AV_PIX_FMT_NONE;
422 if (s->avctx->pix_fmt == AV_PIX_FMT_NONE)
423 for (i = 0; i < possible_fmts_nb; ++i) {
424 if (pix_fmt_match(possible_fmts[i], ncomponents, s->precision, log2_chroma_wh, s->pal8)) {
425 s->avctx->pix_fmt = possible_fmts[i];
426 break;
427 }
428 }
429
430 if (i == possible_fmts_nb) {
431 if (ncomponents == 4 &&
432 s->cdy[0] == 1 && s->cdx[0] == 1 &&
433 s->cdy[1] == 1 && s->cdx[1] == 1 &&
434 s->cdy[2] == s->cdy[3] && s->cdx[2] == s->cdx[3]) {
435 if (s->precision == 8 && s->cdy[2] == 2 && s->cdx[2] == 2 && !s->pal8) {
436 s->avctx->pix_fmt = AV_PIX_FMT_YUVA420P;
437 s->cdef[0] = 0;
438 s->cdef[1] = 1;
439 s->cdef[2] = 2;
440 s->cdef[3] = 3;
441 i = 0;
442 }
443 } else if (ncomponents == 3 && s->precision == 8 &&
444 s->cdx[0] == s->cdx[1] && s->cdx[0] == s->cdx[2] &&
445 s->cdy[0] == s->cdy[1] && s->cdy[0] == s->cdy[2]) {
446 s->avctx->pix_fmt = AV_PIX_FMT_RGB24;
447 i = 0;
448 } else if (ncomponents == 2 && s->precision == 8 &&
449 s->cdx[0] == s->cdx[1] && s->cdy[0] == s->cdy[1]) {
450 s->avctx->pix_fmt = AV_PIX_FMT_YA8;
451 i = 0;
452 } else if (ncomponents == 1 && s->precision == 8) {
453 s->avctx->pix_fmt = AV_PIX_FMT_GRAY8;
454 i = 0;
455 }
456 }
457
458
459 if (i == possible_fmts_nb) {
460 av_log(s->avctx, AV_LOG_ERROR,
461 "Unknown pix_fmt, profile: %d, colour_space: %d, "
462 "components: %d, precision: %d\n"
463 "cdx[0]: %d, cdy[0]: %d\n"
464 "cdx[1]: %d, cdy[1]: %d\n"
465 "cdx[2]: %d, cdy[2]: %d\n"
466 "cdx[3]: %d, cdy[3]: %d\n",
467 s->avctx->profile, s->colour_space, ncomponents, s->precision,
468 s->cdx[0],
469 s->cdy[0],
470 ncomponents > 1 ? s->cdx[1] : 0,
471 ncomponents > 1 ? s->cdy[1] : 0,
472 ncomponents > 2 ? s->cdx[2] : 0,
473 ncomponents > 2 ? s->cdy[2] : 0,
474 ncomponents > 3 ? s->cdx[3] : 0,
475 ncomponents > 3 ? s->cdy[3] : 0);
476 return AVERROR_PATCHWELCOME;
477 }
478 s->avctx->bits_per_raw_sample = s->precision;
479 return 0;
480 }
481
482 /* get common part for COD and COC segments */
get_cox(Jpeg2000DecoderContext * s,Jpeg2000CodingStyle * c)483 static int get_cox(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c)
484 {
485 uint8_t byte;
486
487 if (bytestream2_get_bytes_left(&s->g) < 5) {
488 av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for COX\n");
489 return AVERROR_INVALIDDATA;
490 }
491
492 /* nreslevels = number of resolution levels
493 = number of decomposition level +1 */
494 c->nreslevels = bytestream2_get_byteu(&s->g) + 1;
495 if (c->nreslevels >= JPEG2000_MAX_RESLEVELS) {
496 av_log(s->avctx, AV_LOG_ERROR, "nreslevels %d is invalid\n", c->nreslevels);
497 return AVERROR_INVALIDDATA;
498 }
499
500 if (c->nreslevels <= s->reduction_factor) {
501 /* we are forced to update reduction_factor as its requested value is
502 not compatible with this bitstream, and as we might have used it
503 already in setup earlier we have to fail this frame until
504 reinitialization is implemented */
505 av_log(s->avctx, AV_LOG_ERROR, "reduction_factor too large for this bitstream, max is %d\n", c->nreslevels - 1);
506 s->reduction_factor = c->nreslevels - 1;
507 return AVERROR(EINVAL);
508 }
509
510 /* compute number of resolution levels to decode */
511 c->nreslevels2decode = c->nreslevels - s->reduction_factor;
512
513 c->log2_cblk_width = (bytestream2_get_byteu(&s->g) & 15) + 2; // cblk width
514 c->log2_cblk_height = (bytestream2_get_byteu(&s->g) & 15) + 2; // cblk height
515
516 if (c->log2_cblk_width > 10 || c->log2_cblk_height > 10 ||
517 c->log2_cblk_width + c->log2_cblk_height > 12) {
518 av_log(s->avctx, AV_LOG_ERROR, "cblk size invalid\n");
519 return AVERROR_INVALIDDATA;
520 }
521
522 c->cblk_style = bytestream2_get_byteu(&s->g);
523 if (c->cblk_style != 0) { // cblk style
524 av_log(s->avctx, AV_LOG_WARNING, "extra cblk styles %X\n", c->cblk_style);
525 if (c->cblk_style & JPEG2000_CBLK_BYPASS)
526 av_log(s->avctx, AV_LOG_WARNING, "Selective arithmetic coding bypass\n");
527 }
528 c->transform = bytestream2_get_byteu(&s->g); // DWT transformation type
529 /* set integer 9/7 DWT in case of BITEXACT flag */
530 if ((s->avctx->flags & AV_CODEC_FLAG_BITEXACT) && (c->transform == FF_DWT97))
531 c->transform = FF_DWT97_INT;
532 else if (c->transform == FF_DWT53) {
533 s->avctx->properties |= FF_CODEC_PROPERTY_LOSSLESS;
534 }
535
536 if (c->csty & JPEG2000_CSTY_PREC) {
537 int i;
538 for (i = 0; i < c->nreslevels; i++) {
539 byte = bytestream2_get_byte(&s->g);
540 c->log2_prec_widths[i] = byte & 0x0F; // precinct PPx
541 c->log2_prec_heights[i] = (byte >> 4) & 0x0F; // precinct PPy
542 if (i)
543 if (c->log2_prec_widths[i] == 0 || c->log2_prec_heights[i] == 0) {
544 av_log(s->avctx, AV_LOG_ERROR, "PPx %d PPy %d invalid\n",
545 c->log2_prec_widths[i], c->log2_prec_heights[i]);
546 c->log2_prec_widths[i] = c->log2_prec_heights[i] = 1;
547 return AVERROR_INVALIDDATA;
548 }
549 }
550 } else {
551 memset(c->log2_prec_widths , 15, sizeof(c->log2_prec_widths ));
552 memset(c->log2_prec_heights, 15, sizeof(c->log2_prec_heights));
553 }
554 return 0;
555 }
556
557 /* get coding parameters for a particular tile or whole image*/
get_cod(Jpeg2000DecoderContext * s,Jpeg2000CodingStyle * c,uint8_t * properties)558 static int get_cod(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c,
559 uint8_t *properties)
560 {
561 Jpeg2000CodingStyle tmp;
562 int compno, ret;
563
564 if (bytestream2_get_bytes_left(&s->g) < 5) {
565 av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for COD\n");
566 return AVERROR_INVALIDDATA;
567 }
568
569 tmp.csty = bytestream2_get_byteu(&s->g);
570
571 // get progression order
572 tmp.prog_order = bytestream2_get_byteu(&s->g);
573
574 tmp.nlayers = bytestream2_get_be16u(&s->g);
575 tmp.mct = bytestream2_get_byteu(&s->g); // multiple component transformation
576
577 if (tmp.mct && s->ncomponents < 3) {
578 av_log(s->avctx, AV_LOG_ERROR,
579 "MCT %"PRIu8" with too few components (%d)\n",
580 tmp.mct, s->ncomponents);
581 return AVERROR_INVALIDDATA;
582 }
583
584 if ((ret = get_cox(s, &tmp)) < 0)
585 return ret;
586 tmp.init = 1;
587 for (compno = 0; compno < s->ncomponents; compno++)
588 if (!(properties[compno] & HAD_COC))
589 memcpy(c + compno, &tmp, sizeof(tmp));
590 return 0;
591 }
592
593 /* Get coding parameters for a component in the whole image or a
594 * particular tile. */
get_coc(Jpeg2000DecoderContext * s,Jpeg2000CodingStyle * c,uint8_t * properties)595 static int get_coc(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c,
596 uint8_t *properties)
597 {
598 int compno, ret;
599 uint8_t has_eph, has_sop;
600
601 if (bytestream2_get_bytes_left(&s->g) < 2) {
602 av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for COC\n");
603 return AVERROR_INVALIDDATA;
604 }
605
606 compno = bytestream2_get_byteu(&s->g);
607
608 if (compno >= s->ncomponents) {
609 av_log(s->avctx, AV_LOG_ERROR,
610 "Invalid compno %d. There are %d components in the image.\n",
611 compno, s->ncomponents);
612 return AVERROR_INVALIDDATA;
613 }
614
615 c += compno;
616 has_eph = c->csty & JPEG2000_CSTY_EPH;
617 has_sop = c->csty & JPEG2000_CSTY_SOP;
618 c->csty = bytestream2_get_byteu(&s->g);
619 c->csty |= has_eph; //do not override eph present bits from COD
620 c->csty |= has_sop; //do not override sop present bits from COD
621
622 if ((ret = get_cox(s, c)) < 0)
623 return ret;
624
625 properties[compno] |= HAD_COC;
626 c->init = 1;
627 return 0;
628 }
629
get_rgn(Jpeg2000DecoderContext * s,int n)630 static int get_rgn(Jpeg2000DecoderContext *s, int n)
631 {
632 uint16_t compno;
633 compno = (s->ncomponents < 257)? bytestream2_get_byte(&s->g):
634 bytestream2_get_be16u(&s->g);
635 if (bytestream2_get_byte(&s->g)) {
636 av_log(s->avctx, AV_LOG_ERROR, "Invalid RGN header.\n");
637 return AVERROR_INVALIDDATA; // SRgn field value is 0
638 }
639 // SPrgn field
640 // Currently compno cannot be greater than 4.
641 // However, future implementation should support compno up to 65536
642 if (compno < s->ncomponents) {
643 int v;
644 if (s->curtileno == -1) {
645 v = bytestream2_get_byte(&s->g);
646 if (v > 30)
647 return AVERROR_PATCHWELCOME;
648 s->roi_shift[compno] = v;
649 } else {
650 if (s->tile[s->curtileno].tp_idx != 0)
651 return AVERROR_INVALIDDATA; // marker occurs only in first tile part of tile
652 v = bytestream2_get_byte(&s->g);
653 if (v > 30)
654 return AVERROR_PATCHWELCOME;
655 s->tile[s->curtileno].comp[compno].roi_shift = v;
656 }
657 return 0;
658 }
659 return AVERROR_INVALIDDATA;
660 }
661
662 /* Get common part for QCD and QCC segments. */
get_qcx(Jpeg2000DecoderContext * s,int n,Jpeg2000QuantStyle * q)663 static int get_qcx(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q)
664 {
665 int i, x;
666
667 if (bytestream2_get_bytes_left(&s->g) < 1)
668 return AVERROR_INVALIDDATA;
669
670 x = bytestream2_get_byteu(&s->g); // Sqcd
671
672 q->nguardbits = x >> 5;
673 q->quantsty = x & 0x1f;
674
675 if (q->quantsty == JPEG2000_QSTY_NONE) {
676 n -= 3;
677 if (bytestream2_get_bytes_left(&s->g) < n ||
678 n > JPEG2000_MAX_DECLEVELS*3)
679 return AVERROR_INVALIDDATA;
680 for (i = 0; i < n; i++)
681 q->expn[i] = bytestream2_get_byteu(&s->g) >> 3;
682 } else if (q->quantsty == JPEG2000_QSTY_SI) {
683 if (bytestream2_get_bytes_left(&s->g) < 2)
684 return AVERROR_INVALIDDATA;
685 x = bytestream2_get_be16u(&s->g);
686 q->expn[0] = x >> 11;
687 q->mant[0] = x & 0x7ff;
688 for (i = 1; i < JPEG2000_MAX_DECLEVELS * 3; i++) {
689 int curexpn = FFMAX(0, q->expn[0] - (i - 1) / 3);
690 q->expn[i] = curexpn;
691 q->mant[i] = q->mant[0];
692 }
693 } else {
694 n = (n - 3) >> 1;
695 if (bytestream2_get_bytes_left(&s->g) < 2 * n ||
696 n > JPEG2000_MAX_DECLEVELS*3)
697 return AVERROR_INVALIDDATA;
698 for (i = 0; i < n; i++) {
699 x = bytestream2_get_be16u(&s->g);
700 q->expn[i] = x >> 11;
701 q->mant[i] = x & 0x7ff;
702 }
703 }
704 return 0;
705 }
706
707 /* Get quantization parameters for a particular tile or a whole image. */
get_qcd(Jpeg2000DecoderContext * s,int n,Jpeg2000QuantStyle * q,uint8_t * properties)708 static int get_qcd(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q,
709 uint8_t *properties)
710 {
711 Jpeg2000QuantStyle tmp;
712 int compno, ret;
713
714 memset(&tmp, 0, sizeof(tmp));
715
716 if ((ret = get_qcx(s, n, &tmp)) < 0)
717 return ret;
718 for (compno = 0; compno < s->ncomponents; compno++)
719 if (!(properties[compno] & HAD_QCC))
720 memcpy(q + compno, &tmp, sizeof(tmp));
721 return 0;
722 }
723
724 /* Get quantization parameters for a component in the whole image
725 * on in a particular tile. */
get_qcc(Jpeg2000DecoderContext * s,int n,Jpeg2000QuantStyle * q,uint8_t * properties)726 static int get_qcc(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q,
727 uint8_t *properties)
728 {
729 int compno;
730
731 if (bytestream2_get_bytes_left(&s->g) < 1)
732 return AVERROR_INVALIDDATA;
733
734 compno = bytestream2_get_byteu(&s->g);
735
736 if (compno >= s->ncomponents) {
737 av_log(s->avctx, AV_LOG_ERROR,
738 "Invalid compno %d. There are %d components in the image.\n",
739 compno, s->ncomponents);
740 return AVERROR_INVALIDDATA;
741 }
742
743 properties[compno] |= HAD_QCC;
744 return get_qcx(s, n - 1, q + compno);
745 }
746
get_poc(Jpeg2000DecoderContext * s,int size,Jpeg2000POC * p)747 static int get_poc(Jpeg2000DecoderContext *s, int size, Jpeg2000POC *p)
748 {
749 int i;
750 int elem_size = s->ncomponents <= 257 ? 7 : 9;
751 Jpeg2000POC tmp = {{{0}}};
752
753 if (bytestream2_get_bytes_left(&s->g) < 5 || size < 2 + elem_size) {
754 av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for POC\n");
755 return AVERROR_INVALIDDATA;
756 }
757
758 if (elem_size > 7) {
759 avpriv_request_sample(s->avctx, "Fat POC not supported");
760 return AVERROR_PATCHWELCOME;
761 }
762
763 tmp.nb_poc = (size - 2) / elem_size;
764 if (tmp.nb_poc > MAX_POCS) {
765 avpriv_request_sample(s->avctx, "Too many POCs (%d)", tmp.nb_poc);
766 return AVERROR_PATCHWELCOME;
767 }
768
769 for (i = 0; i<tmp.nb_poc; i++) {
770 Jpeg2000POCEntry *e = &tmp.poc[i];
771 e->RSpoc = bytestream2_get_byteu(&s->g);
772 e->CSpoc = bytestream2_get_byteu(&s->g);
773 e->LYEpoc = bytestream2_get_be16u(&s->g);
774 e->REpoc = bytestream2_get_byteu(&s->g);
775 e->CEpoc = bytestream2_get_byteu(&s->g);
776 e->Ppoc = bytestream2_get_byteu(&s->g);
777 if (!e->CEpoc)
778 e->CEpoc = 256;
779 if (e->CEpoc > s->ncomponents)
780 e->CEpoc = s->ncomponents;
781 if ( e->RSpoc >= e->REpoc || e->REpoc > 33
782 || e->CSpoc >= e->CEpoc || e->CEpoc > s->ncomponents
783 || !e->LYEpoc) {
784 av_log(s->avctx, AV_LOG_ERROR, "POC Entry %d is invalid (%d, %d, %d, %d, %d, %d)\n", i,
785 e->RSpoc, e->CSpoc, e->LYEpoc, e->REpoc, e->CEpoc, e->Ppoc
786 );
787 return AVERROR_INVALIDDATA;
788 }
789 }
790
791 if (!p->nb_poc || p->is_default) {
792 *p = tmp;
793 } else {
794 if (p->nb_poc + tmp.nb_poc > MAX_POCS) {
795 av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for POC\n");
796 return AVERROR_INVALIDDATA;
797 }
798 memcpy(p->poc + p->nb_poc, tmp.poc, tmp.nb_poc * sizeof(tmp.poc[0]));
799 p->nb_poc += tmp.nb_poc;
800 }
801
802 p->is_default = 0;
803
804 return 0;
805 }
806
807
808 /* Get start of tile segment. */
get_sot(Jpeg2000DecoderContext * s,int n)809 static int get_sot(Jpeg2000DecoderContext *s, int n)
810 {
811 Jpeg2000TilePart *tp;
812 uint16_t Isot;
813 uint32_t Psot;
814 unsigned TPsot;
815
816 if (bytestream2_get_bytes_left(&s->g) < 8)
817 return AVERROR_INVALIDDATA;
818
819 s->curtileno = 0;
820 Isot = bytestream2_get_be16u(&s->g); // Isot
821 if (Isot >= s->numXtiles * s->numYtiles)
822 return AVERROR_INVALIDDATA;
823
824 s->curtileno = Isot;
825 Psot = bytestream2_get_be32u(&s->g); // Psot
826 TPsot = bytestream2_get_byteu(&s->g); // TPsot
827
828 /* Read TNSot but not used */
829 bytestream2_get_byteu(&s->g); // TNsot
830
831 if (!Psot)
832 Psot = bytestream2_get_bytes_left(&s->g) - 2 + n + 2;
833
834 if (Psot > bytestream2_get_bytes_left(&s->g) - 2 + n + 2) {
835 av_log(s->avctx, AV_LOG_ERROR, "Psot %"PRIu32" too big\n", Psot);
836 return AVERROR_INVALIDDATA;
837 }
838
839 if (TPsot >= FF_ARRAY_ELEMS(s->tile[Isot].tile_part)) {
840 avpriv_request_sample(s->avctx, "Too many tile parts");
841 return AVERROR_PATCHWELCOME;
842 }
843
844 s->tile[Isot].tp_idx = TPsot;
845 tp = s->tile[Isot].tile_part + TPsot;
846 tp->tile_index = Isot;
847 tp->tp_end = s->g.buffer + Psot - n - 2;
848
849 if (!TPsot) {
850 Jpeg2000Tile *tile = s->tile + s->curtileno;
851
852 /* copy defaults */
853 memcpy(tile->codsty, s->codsty, s->ncomponents * sizeof(Jpeg2000CodingStyle));
854 memcpy(tile->qntsty, s->qntsty, s->ncomponents * sizeof(Jpeg2000QuantStyle));
855 memcpy(&tile->poc , &s->poc , sizeof(tile->poc));
856 tile->poc.is_default = 1;
857 }
858
859 return 0;
860 }
861
read_crg(Jpeg2000DecoderContext * s,int n)862 static int read_crg(Jpeg2000DecoderContext *s, int n)
863 {
864 if (s->ncomponents*4 != n - 2) {
865 av_log(s->avctx, AV_LOG_ERROR, "Invalid CRG marker.\n");
866 return AVERROR_INVALIDDATA;
867 }
868 bytestream2_skip(&s->g, n - 2);
869 return 0;
870 }
871 /* Tile-part lengths: see ISO 15444-1:2002, section A.7.1
872 * Used to know the number of tile parts and lengths.
873 * There may be multiple TLMs in the header.
874 * TODO: The function is not used for tile-parts management, nor anywhere else.
875 * It can be useful to allocate memory for tile parts, before managing the SOT
876 * markers. Parsing the TLM header is needed to increment the input header
877 * buffer.
878 * This marker is mandatory for DCI. */
get_tlm(Jpeg2000DecoderContext * s,int n)879 static int get_tlm(Jpeg2000DecoderContext *s, int n)
880 {
881 uint8_t Stlm, ST, SP, tile_tlm, i;
882 bytestream2_get_byte(&s->g); /* Ztlm: skipped */
883 Stlm = bytestream2_get_byte(&s->g);
884
885 // too complex ? ST = ((Stlm >> 4) & 0x01) + ((Stlm >> 4) & 0x02);
886 ST = (Stlm >> 4) & 0x03;
887 if (ST == 0x03) {
888 av_log(s->avctx, AV_LOG_ERROR, "TLM marker contains invalid ST value.\n");
889 return AVERROR_INVALIDDATA;
890 }
891
892 SP = (Stlm >> 6) & 0x01;
893 tile_tlm = (n - 4) / ((SP + 1) * 2 + ST);
894 for (i = 0; i < tile_tlm; i++) {
895 switch (ST) {
896 case 0:
897 break;
898 case 1:
899 bytestream2_get_byte(&s->g);
900 break;
901 case 2:
902 bytestream2_get_be16(&s->g);
903 break;
904 case 3:
905 bytestream2_get_be32(&s->g);
906 break;
907 }
908 if (SP == 0) {
909 bytestream2_get_be16(&s->g);
910 } else {
911 bytestream2_get_be32(&s->g);
912 }
913 }
914 return 0;
915 }
916
get_plt(Jpeg2000DecoderContext * s,int n)917 static int get_plt(Jpeg2000DecoderContext *s, int n)
918 {
919 int i;
920 int v;
921
922 av_log(s->avctx, AV_LOG_DEBUG,
923 "PLT marker at pos 0x%X\n", bytestream2_tell(&s->g) - 4);
924
925 if (n < 4)
926 return AVERROR_INVALIDDATA;
927
928 /*Zplt =*/ bytestream2_get_byte(&s->g);
929
930 for (i = 0; i < n - 3; i++) {
931 v = bytestream2_get_byte(&s->g);
932 }
933 if (v & 0x80)
934 return AVERROR_INVALIDDATA;
935
936 return 0;
937 }
938
get_ppm(Jpeg2000DecoderContext * s,int n)939 static int get_ppm(Jpeg2000DecoderContext *s, int n)
940 {
941 void *new;
942
943 if (n < 3) {
944 av_log(s->avctx, AV_LOG_ERROR, "Invalid length for PPM data.\n");
945 return AVERROR_INVALIDDATA;
946 }
947 bytestream2_get_byte(&s->g); //Zppm is skipped and not used
948 new = av_realloc(s->packed_headers,
949 s->packed_headers_size + n - 3);
950 if (new) {
951 s->packed_headers = new;
952 } else
953 return AVERROR(ENOMEM);
954 s->has_ppm = 1;
955 memset(&s->packed_headers_stream, 0, sizeof(s->packed_headers_stream));
956 bytestream_get_buffer(&s->g.buffer, s->packed_headers + s->packed_headers_size,
957 n - 3);
958 s->packed_headers_size += n - 3;
959
960 return 0;
961 }
962
get_ppt(Jpeg2000DecoderContext * s,int n)963 static int get_ppt(Jpeg2000DecoderContext *s, int n)
964 {
965 Jpeg2000Tile *tile;
966 void *new;
967
968 if (n < 3) {
969 av_log(s->avctx, AV_LOG_ERROR, "Invalid length for PPT data.\n");
970 return AVERROR_INVALIDDATA;
971 }
972 if (s->curtileno < 0)
973 return AVERROR_INVALIDDATA;
974
975 tile = &s->tile[s->curtileno];
976 if (tile->tp_idx != 0) {
977 av_log(s->avctx, AV_LOG_ERROR,
978 "PPT marker can occur only on first tile part of a tile.\n");
979 return AVERROR_INVALIDDATA;
980 }
981
982 tile->has_ppt = 1; // this tile has a ppt marker
983 bytestream2_get_byte(&s->g); // Zppt is skipped and not used
984 new = av_realloc(tile->packed_headers,
985 tile->packed_headers_size + n - 3);
986 if (new) {
987 tile->packed_headers = new;
988 } else
989 return AVERROR(ENOMEM);
990 memset(&tile->packed_headers_stream, 0, sizeof(tile->packed_headers_stream));
991 memcpy(tile->packed_headers + tile->packed_headers_size,
992 s->g.buffer, n - 3);
993 tile->packed_headers_size += n - 3;
994 bytestream2_skip(&s->g, n - 3);
995
996 return 0;
997 }
998
init_tile(Jpeg2000DecoderContext * s,int tileno)999 static int init_tile(Jpeg2000DecoderContext *s, int tileno)
1000 {
1001 int compno;
1002 int tilex = tileno % s->numXtiles;
1003 int tiley = tileno / s->numXtiles;
1004 Jpeg2000Tile *tile = s->tile + tileno;
1005
1006 if (!tile->comp)
1007 return AVERROR(ENOMEM);
1008
1009 tile->coord[0][0] = av_clip(tilex * (int64_t)s->tile_width + s->tile_offset_x, s->image_offset_x, s->width);
1010 tile->coord[0][1] = av_clip((tilex + 1) * (int64_t)s->tile_width + s->tile_offset_x, s->image_offset_x, s->width);
1011 tile->coord[1][0] = av_clip(tiley * (int64_t)s->tile_height + s->tile_offset_y, s->image_offset_y, s->height);
1012 tile->coord[1][1] = av_clip((tiley + 1) * (int64_t)s->tile_height + s->tile_offset_y, s->image_offset_y, s->height);
1013
1014 for (compno = 0; compno < s->ncomponents; compno++) {
1015 Jpeg2000Component *comp = tile->comp + compno;
1016 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1017 Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
1018 int ret; // global bandno
1019
1020 comp->coord_o[0][0] = tile->coord[0][0];
1021 comp->coord_o[0][1] = tile->coord[0][1];
1022 comp->coord_o[1][0] = tile->coord[1][0];
1023 comp->coord_o[1][1] = tile->coord[1][1];
1024
1025 comp->coord_o[0][0] = ff_jpeg2000_ceildiv(comp->coord_o[0][0], s->cdx[compno]);
1026 comp->coord_o[0][1] = ff_jpeg2000_ceildiv(comp->coord_o[0][1], s->cdx[compno]);
1027 comp->coord_o[1][0] = ff_jpeg2000_ceildiv(comp->coord_o[1][0], s->cdy[compno]);
1028 comp->coord_o[1][1] = ff_jpeg2000_ceildiv(comp->coord_o[1][1], s->cdy[compno]);
1029
1030 comp->coord[0][0] = ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], s->reduction_factor);
1031 comp->coord[0][1] = ff_jpeg2000_ceildivpow2(comp->coord_o[0][1], s->reduction_factor);
1032 comp->coord[1][0] = ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], s->reduction_factor);
1033 comp->coord[1][1] = ff_jpeg2000_ceildivpow2(comp->coord_o[1][1], s->reduction_factor);
1034
1035 if (!comp->roi_shift)
1036 comp->roi_shift = s->roi_shift[compno];
1037 if (!codsty->init)
1038 return AVERROR_INVALIDDATA;
1039 if (ret = ff_jpeg2000_init_component(comp, codsty, qntsty,
1040 s->cbps[compno], s->cdx[compno],
1041 s->cdy[compno], s->avctx))
1042 return ret;
1043 }
1044 return 0;
1045 }
1046
1047 /* Read the number of coding passes. */
getnpasses(Jpeg2000DecoderContext * s)1048 static int getnpasses(Jpeg2000DecoderContext *s)
1049 {
1050 int num;
1051 if (!get_bits(s, 1))
1052 return 1;
1053 if (!get_bits(s, 1))
1054 return 2;
1055 if ((num = get_bits(s, 2)) != 3)
1056 return num < 0 ? num : 3 + num;
1057 if ((num = get_bits(s, 5)) != 31)
1058 return num < 0 ? num : 6 + num;
1059 num = get_bits(s, 7);
1060 return num < 0 ? num : 37 + num;
1061 }
1062
getlblockinc(Jpeg2000DecoderContext * s)1063 static int getlblockinc(Jpeg2000DecoderContext *s)
1064 {
1065 int res = 0, ret;
1066 while (ret = get_bits(s, 1)) {
1067 if (ret < 0)
1068 return ret;
1069 res++;
1070 }
1071 return res;
1072 }
1073
select_header(Jpeg2000DecoderContext * s,Jpeg2000Tile * tile,int * tp_index)1074 static inline void select_header(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile,
1075 int *tp_index)
1076 {
1077 s->g = tile->tile_part[*tp_index].header_tpg;
1078 if (bytestream2_get_bytes_left(&s->g) == 0 && s->bit_index == 8) {
1079 if (*tp_index < FF_ARRAY_ELEMS(tile->tile_part) - 1) {
1080 s->g = tile->tile_part[++(*tp_index)].tpg;
1081 }
1082 }
1083 }
1084
select_stream(Jpeg2000DecoderContext * s,Jpeg2000Tile * tile,int * tp_index,Jpeg2000CodingStyle * codsty)1085 static inline void select_stream(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile,
1086 int *tp_index, Jpeg2000CodingStyle *codsty)
1087 {
1088 s->g = tile->tile_part[*tp_index].tpg;
1089 if (bytestream2_get_bytes_left(&s->g) == 0 && s->bit_index == 8) {
1090 if (*tp_index < FF_ARRAY_ELEMS(tile->tile_part) - 1) {
1091 s->g = tile->tile_part[++(*tp_index)].tpg;
1092 }
1093 }
1094 if (codsty->csty & JPEG2000_CSTY_SOP) {
1095 if (bytestream2_peek_be32(&s->g) == JPEG2000_SOP_FIXED_BYTES)
1096 bytestream2_skip(&s->g, JPEG2000_SOP_BYTE_LENGTH);
1097 else
1098 av_log(s->avctx, AV_LOG_ERROR, "SOP marker not found. instead %X\n", bytestream2_peek_be32(&s->g));
1099 }
1100 }
1101
jpeg2000_decode_packet(Jpeg2000DecoderContext * s,Jpeg2000Tile * tile,int * tp_index,Jpeg2000CodingStyle * codsty,Jpeg2000ResLevel * rlevel,int precno,int layno,uint8_t * expn,int numgbits)1102 static int jpeg2000_decode_packet(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile, int *tp_index,
1103 Jpeg2000CodingStyle *codsty,
1104 Jpeg2000ResLevel *rlevel, int precno,
1105 int layno, uint8_t *expn, int numgbits)
1106 {
1107 int bandno, cblkno, ret, nb_code_blocks;
1108 int cwsno;
1109
1110 if (layno < rlevel->band[0].prec[precno].decoded_layers)
1111 return 0;
1112 rlevel->band[0].prec[precno].decoded_layers = layno + 1;
1113 // Select stream to read from
1114 if (s->has_ppm)
1115 select_header(s, tile, tp_index);
1116 else if (tile->has_ppt)
1117 s->g = tile->packed_headers_stream;
1118 else
1119 select_stream(s, tile, tp_index, codsty);
1120
1121 if (!(ret = get_bits(s, 1))) {
1122 jpeg2000_flush(s);
1123 goto skip_data;
1124 } else if (ret < 0)
1125 return ret;
1126
1127 for (bandno = 0; bandno < rlevel->nbands; bandno++) {
1128 Jpeg2000Band *band = rlevel->band + bandno;
1129 Jpeg2000Prec *prec = band->prec + precno;
1130
1131 if (band->coord[0][0] == band->coord[0][1] ||
1132 band->coord[1][0] == band->coord[1][1])
1133 continue;
1134 nb_code_blocks = prec->nb_codeblocks_height *
1135 prec->nb_codeblocks_width;
1136 for (cblkno = 0; cblkno < nb_code_blocks; cblkno++) {
1137 Jpeg2000Cblk *cblk = prec->cblk + cblkno;
1138 int incl, newpasses, llen;
1139 void *tmp;
1140
1141 if (cblk->npasses)
1142 incl = get_bits(s, 1);
1143 else
1144 incl = tag_tree_decode(s, prec->cblkincl + cblkno, layno + 1) == layno;
1145 if (!incl)
1146 continue;
1147 else if (incl < 0)
1148 return incl;
1149
1150 if (!cblk->npasses) {
1151 int v = expn[bandno] + numgbits - 1 -
1152 tag_tree_decode(s, prec->zerobits + cblkno, 100);
1153 if (v < 0 || v > 30) {
1154 av_log(s->avctx, AV_LOG_ERROR,
1155 "nonzerobits %d invalid or unsupported\n", v);
1156 return AVERROR_INVALIDDATA;
1157 }
1158 cblk->nonzerobits = v;
1159 }
1160 if ((newpasses = getnpasses(s)) < 0)
1161 return newpasses;
1162 av_assert2(newpasses > 0);
1163 if (cblk->npasses + newpasses >= JPEG2000_MAX_PASSES) {
1164 avpriv_request_sample(s->avctx, "Too many passes");
1165 return AVERROR_PATCHWELCOME;
1166 }
1167 if ((llen = getlblockinc(s)) < 0)
1168 return llen;
1169 if (cblk->lblock + llen + av_log2(newpasses) > 16) {
1170 avpriv_request_sample(s->avctx,
1171 "Block with length beyond 16 bits");
1172 return AVERROR_PATCHWELCOME;
1173 }
1174
1175 cblk->lblock += llen;
1176
1177 cblk->nb_lengthinc = 0;
1178 cblk->nb_terminationsinc = 0;
1179 av_free(cblk->lengthinc);
1180 cblk->lengthinc = av_mallocz_array(newpasses , sizeof(*cblk->lengthinc));
1181 if (!cblk->lengthinc)
1182 return AVERROR(ENOMEM);
1183 tmp = av_realloc_array(cblk->data_start, cblk->nb_terminations + newpasses + 1, sizeof(*cblk->data_start));
1184 if (!tmp)
1185 return AVERROR(ENOMEM);
1186 cblk->data_start = tmp;
1187 do {
1188 int newpasses1 = 0;
1189
1190 while (newpasses1 < newpasses) {
1191 newpasses1 ++;
1192 if (needs_termination(codsty->cblk_style, cblk->npasses + newpasses1 - 1)) {
1193 cblk->nb_terminationsinc ++;
1194 break;
1195 }
1196 }
1197
1198 if ((ret = get_bits(s, av_log2(newpasses1) + cblk->lblock)) < 0)
1199 return ret;
1200 if (ret > cblk->data_allocated) {
1201 size_t new_size = FFMAX(2*cblk->data_allocated, ret);
1202 void *new = av_realloc(cblk->data, new_size);
1203 if (new) {
1204 cblk->data = new;
1205 cblk->data_allocated = new_size;
1206 }
1207 }
1208 if (ret > cblk->data_allocated) {
1209 avpriv_request_sample(s->avctx,
1210 "Block with lengthinc greater than %"SIZE_SPECIFIER"",
1211 cblk->data_allocated);
1212 return AVERROR_PATCHWELCOME;
1213 }
1214 cblk->lengthinc[cblk->nb_lengthinc++] = ret;
1215 cblk->npasses += newpasses1;
1216 newpasses -= newpasses1;
1217 } while(newpasses);
1218 }
1219 }
1220 jpeg2000_flush(s);
1221
1222 if (codsty->csty & JPEG2000_CSTY_EPH) {
1223 if (bytestream2_peek_be16(&s->g) == JPEG2000_EPH)
1224 bytestream2_skip(&s->g, 2);
1225 else
1226 av_log(s->avctx, AV_LOG_ERROR, "EPH marker not found. instead %X\n", bytestream2_peek_be32(&s->g));
1227 }
1228
1229 // Save state of stream
1230 if (s->has_ppm) {
1231 tile->tile_part[*tp_index].header_tpg = s->g;
1232 select_stream(s, tile, tp_index, codsty);
1233 } else if (tile->has_ppt) {
1234 tile->packed_headers_stream = s->g;
1235 select_stream(s, tile, tp_index, codsty);
1236 }
1237 for (bandno = 0; bandno < rlevel->nbands; bandno++) {
1238 Jpeg2000Band *band = rlevel->band + bandno;
1239 Jpeg2000Prec *prec = band->prec + precno;
1240
1241 nb_code_blocks = prec->nb_codeblocks_height * prec->nb_codeblocks_width;
1242 for (cblkno = 0; cblkno < nb_code_blocks; cblkno++) {
1243 Jpeg2000Cblk *cblk = prec->cblk + cblkno;
1244 if (!cblk->nb_terminationsinc && !cblk->lengthinc)
1245 continue;
1246 for (cwsno = 0; cwsno < cblk->nb_lengthinc; cwsno ++) {
1247 if (cblk->data_allocated < cblk->length + cblk->lengthinc[cwsno] + 4) {
1248 size_t new_size = FFMAX(2*cblk->data_allocated, cblk->length + cblk->lengthinc[cwsno] + 4);
1249 void *new = av_realloc(cblk->data, new_size);
1250 if (new) {
1251 cblk->data = new;
1252 cblk->data_allocated = new_size;
1253 }
1254 }
1255 if ( bytestream2_get_bytes_left(&s->g) < cblk->lengthinc[cwsno]
1256 || cblk->data_allocated < cblk->length + cblk->lengthinc[cwsno] + 4
1257 ) {
1258 av_log(s->avctx, AV_LOG_ERROR,
1259 "Block length %"PRIu16" or lengthinc %d is too large, left %d\n",
1260 cblk->length, cblk->lengthinc[cwsno], bytestream2_get_bytes_left(&s->g));
1261 return AVERROR_INVALIDDATA;
1262 }
1263
1264 bytestream2_get_bufferu(&s->g, cblk->data + cblk->length, cblk->lengthinc[cwsno]);
1265 cblk->length += cblk->lengthinc[cwsno];
1266 cblk->lengthinc[cwsno] = 0;
1267 if (cblk->nb_terminationsinc) {
1268 cblk->nb_terminationsinc--;
1269 cblk->nb_terminations++;
1270 cblk->data[cblk->length++] = 0xFF;
1271 cblk->data[cblk->length++] = 0xFF;
1272 cblk->data_start[cblk->nb_terminations] = cblk->length;
1273 }
1274 }
1275 av_freep(&cblk->lengthinc);
1276 }
1277 }
1278 // Save state of stream
1279 tile->tile_part[*tp_index].tpg = s->g;
1280 return 0;
1281
1282 skip_data:
1283 if (codsty->csty & JPEG2000_CSTY_EPH) {
1284 if (bytestream2_peek_be16(&s->g) == JPEG2000_EPH)
1285 bytestream2_skip(&s->g, 2);
1286 else
1287 av_log(s->avctx, AV_LOG_ERROR, "EPH marker not found. instead %X\n", bytestream2_peek_be32(&s->g));
1288 }
1289 if (s->has_ppm) {
1290 tile->tile_part[*tp_index].header_tpg = s->g;
1291 select_stream(s, tile, tp_index, codsty);
1292 } else if (tile->has_ppt) {
1293 tile->packed_headers_stream = s->g;
1294 select_stream(s, tile, tp_index, codsty);
1295 }
1296 tile->tile_part[*tp_index].tpg = s->g;
1297 return 0;
1298 }
1299
jpeg2000_decode_packets_po_iteration(Jpeg2000DecoderContext * s,Jpeg2000Tile * tile,int RSpoc,int CSpoc,int LYEpoc,int REpoc,int CEpoc,int Ppoc,int * tp_index)1300 static int jpeg2000_decode_packets_po_iteration(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile,
1301 int RSpoc, int CSpoc,
1302 int LYEpoc, int REpoc, int CEpoc,
1303 int Ppoc, int *tp_index)
1304 {
1305 int ret = 0;
1306 int layno, reslevelno, compno, precno, ok_reslevel;
1307 int x, y;
1308 int step_x, step_y;
1309
1310 switch (Ppoc) {
1311 case JPEG2000_PGOD_RLCP:
1312 av_log(s->avctx, AV_LOG_DEBUG, "Progression order RLCP\n");
1313 ok_reslevel = 1;
1314 for (reslevelno = RSpoc; ok_reslevel && reslevelno < REpoc; reslevelno++) {
1315 ok_reslevel = 0;
1316 for (layno = 0; layno < LYEpoc; layno++) {
1317 for (compno = CSpoc; compno < CEpoc; compno++) {
1318 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1319 Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
1320 if (reslevelno < codsty->nreslevels) {
1321 Jpeg2000ResLevel *rlevel = tile->comp[compno].reslevel +
1322 reslevelno;
1323 ok_reslevel = 1;
1324 for (precno = 0; precno < rlevel->num_precincts_x * rlevel->num_precincts_y; precno++)
1325 if ((ret = jpeg2000_decode_packet(s, tile, tp_index,
1326 codsty, rlevel,
1327 precno, layno,
1328 qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1329 qntsty->nguardbits)) < 0)
1330 return ret;
1331 }
1332 }
1333 }
1334 }
1335 break;
1336
1337 case JPEG2000_PGOD_LRCP:
1338 av_log(s->avctx, AV_LOG_DEBUG, "Progression order LRCP\n");
1339 for (layno = 0; layno < LYEpoc; layno++) {
1340 ok_reslevel = 1;
1341 for (reslevelno = RSpoc; ok_reslevel && reslevelno < REpoc; reslevelno++) {
1342 ok_reslevel = 0;
1343 for (compno = CSpoc; compno < CEpoc; compno++) {
1344 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1345 Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
1346 if (reslevelno < codsty->nreslevels) {
1347 Jpeg2000ResLevel *rlevel = tile->comp[compno].reslevel +
1348 reslevelno;
1349 ok_reslevel = 1;
1350 for (precno = 0; precno < rlevel->num_precincts_x * rlevel->num_precincts_y; precno++)
1351 if ((ret = jpeg2000_decode_packet(s, tile, tp_index,
1352 codsty, rlevel,
1353 precno, layno,
1354 qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1355 qntsty->nguardbits)) < 0)
1356 return ret;
1357 }
1358 }
1359 }
1360 }
1361 break;
1362
1363 case JPEG2000_PGOD_CPRL:
1364 av_log(s->avctx, AV_LOG_DEBUG, "Progression order CPRL\n");
1365 for (compno = CSpoc; compno < CEpoc; compno++) {
1366 Jpeg2000Component *comp = tile->comp + compno;
1367 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1368 Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
1369 step_x = 32;
1370 step_y = 32;
1371
1372 if (RSpoc >= FFMIN(codsty->nreslevels, REpoc))
1373 continue;
1374
1375 for (reslevelno = RSpoc; reslevelno < FFMIN(codsty->nreslevels, REpoc); reslevelno++) {
1376 uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1377 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1378 step_x = FFMIN(step_x, rlevel->log2_prec_width + reducedresno);
1379 step_y = FFMIN(step_y, rlevel->log2_prec_height + reducedresno);
1380 }
1381 if (step_x >= 31 || step_y >= 31){
1382 avpriv_request_sample(s->avctx, "CPRL with large step");
1383 return AVERROR_PATCHWELCOME;
1384 }
1385 step_x = 1<<step_x;
1386 step_y = 1<<step_y;
1387
1388 for (y = tile->coord[1][0]; y < tile->coord[1][1]; y = (y/step_y + 1)*step_y) {
1389 for (x = tile->coord[0][0]; x < tile->coord[0][1]; x = (x/step_x + 1)*step_x) {
1390 for (reslevelno = RSpoc; reslevelno < FFMIN(codsty->nreslevels, REpoc); reslevelno++) {
1391 unsigned prcx, prcy;
1392 uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1393 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1394 int xc = x / s->cdx[compno];
1395 int yc = y / s->cdy[compno];
1396
1397 if (yc % (1LL << (rlevel->log2_prec_height + reducedresno)) && y != tile->coord[1][0]) //FIXME this is a subset of the check
1398 continue;
1399
1400 if (xc % (1LL << (rlevel->log2_prec_width + reducedresno)) && x != tile->coord[0][0]) //FIXME this is a subset of the check
1401 continue;
1402
1403 // check if a precinct exists
1404 prcx = ff_jpeg2000_ceildivpow2(xc, reducedresno) >> rlevel->log2_prec_width;
1405 prcy = ff_jpeg2000_ceildivpow2(yc, reducedresno) >> rlevel->log2_prec_height;
1406 prcx -= ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], reducedresno) >> rlevel->log2_prec_width;
1407 prcy -= ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], reducedresno) >> rlevel->log2_prec_height;
1408
1409 precno = prcx + rlevel->num_precincts_x * prcy;
1410
1411 if (prcx >= rlevel->num_precincts_x || prcy >= rlevel->num_precincts_y) {
1412 av_log(s->avctx, AV_LOG_WARNING, "prc %d %d outside limits %d %d\n",
1413 prcx, prcy, rlevel->num_precincts_x, rlevel->num_precincts_y);
1414 continue;
1415 }
1416
1417 for (layno = 0; layno < LYEpoc; layno++) {
1418 if ((ret = jpeg2000_decode_packet(s, tile, tp_index, codsty, rlevel,
1419 precno, layno,
1420 qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1421 qntsty->nguardbits)) < 0)
1422 return ret;
1423 }
1424 }
1425 }
1426 }
1427 }
1428 break;
1429
1430 case JPEG2000_PGOD_RPCL:
1431 av_log(s->avctx, AV_LOG_WARNING, "Progression order RPCL\n");
1432 ok_reslevel = 1;
1433 for (reslevelno = RSpoc; ok_reslevel && reslevelno < REpoc; reslevelno++) {
1434 ok_reslevel = 0;
1435 step_x = 30;
1436 step_y = 30;
1437 for (compno = CSpoc; compno < CEpoc; compno++) {
1438 Jpeg2000Component *comp = tile->comp + compno;
1439 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1440
1441 if (reslevelno < codsty->nreslevels) {
1442 uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1443 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1444 step_x = FFMIN(step_x, rlevel->log2_prec_width + reducedresno);
1445 step_y = FFMIN(step_y, rlevel->log2_prec_height + reducedresno);
1446 }
1447 }
1448 step_x = 1<<step_x;
1449 step_y = 1<<step_y;
1450
1451 for (y = tile->coord[1][0]; y < tile->coord[1][1]; y = (y/step_y + 1)*step_y) {
1452 for (x = tile->coord[0][0]; x < tile->coord[0][1]; x = (x/step_x + 1)*step_x) {
1453 for (compno = CSpoc; compno < CEpoc; compno++) {
1454 Jpeg2000Component *comp = tile->comp + compno;
1455 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1456 Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
1457 uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1458 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1459 unsigned prcx, prcy;
1460 int trx0, try0;
1461
1462 if (!s->cdx[compno] || !s->cdy[compno])
1463 return AVERROR_INVALIDDATA;
1464
1465 if (reslevelno >= codsty->nreslevels)
1466 continue;
1467
1468 trx0 = ff_jpeg2000_ceildiv(tile->coord[0][0], (int64_t)s->cdx[compno] << reducedresno);
1469 try0 = ff_jpeg2000_ceildiv(tile->coord[1][0], (int64_t)s->cdy[compno] << reducedresno);
1470
1471 if (!(y % ((uint64_t)s->cdy[compno] << (rlevel->log2_prec_height + reducedresno)) == 0 ||
1472 (y == tile->coord[1][0] && ((int64_t)try0 << reducedresno) % (1ULL << (reducedresno + rlevel->log2_prec_height)))))
1473 continue;
1474
1475 if (!(x % ((uint64_t)s->cdx[compno] << (rlevel->log2_prec_width + reducedresno)) == 0 ||
1476 (x == tile->coord[0][0] && ((int64_t)trx0 << reducedresno) % (1ULL << (reducedresno + rlevel->log2_prec_width)))))
1477 continue;
1478
1479 // check if a precinct exists
1480 prcx = ff_jpeg2000_ceildiv(x, (int64_t)s->cdx[compno] << reducedresno) >> rlevel->log2_prec_width;
1481 prcy = ff_jpeg2000_ceildiv(y, (int64_t)s->cdy[compno] << reducedresno) >> rlevel->log2_prec_height;
1482 prcx -= ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], reducedresno) >> rlevel->log2_prec_width;
1483 prcy -= ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], reducedresno) >> rlevel->log2_prec_height;
1484
1485 precno = prcx + rlevel->num_precincts_x * prcy;
1486
1487 ok_reslevel = 1;
1488 if (prcx >= rlevel->num_precincts_x || prcy >= rlevel->num_precincts_y) {
1489 av_log(s->avctx, AV_LOG_WARNING, "prc %d %d outside limits %d %d\n",
1490 prcx, prcy, rlevel->num_precincts_x, rlevel->num_precincts_y);
1491 continue;
1492 }
1493
1494 for (layno = 0; layno < LYEpoc; layno++) {
1495 if ((ret = jpeg2000_decode_packet(s, tile, tp_index,
1496 codsty, rlevel,
1497 precno, layno,
1498 qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1499 qntsty->nguardbits)) < 0)
1500 return ret;
1501 }
1502 }
1503 }
1504 }
1505 }
1506 break;
1507
1508 case JPEG2000_PGOD_PCRL:
1509 av_log(s->avctx, AV_LOG_WARNING, "Progression order PCRL\n");
1510 step_x = 32;
1511 step_y = 32;
1512 for (compno = CSpoc; compno < CEpoc; compno++) {
1513 Jpeg2000Component *comp = tile->comp + compno;
1514 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1515
1516 for (reslevelno = RSpoc; reslevelno < FFMIN(codsty->nreslevels, REpoc); reslevelno++) {
1517 uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1518 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1519 step_x = FFMIN(step_x, rlevel->log2_prec_width + reducedresno);
1520 step_y = FFMIN(step_y, rlevel->log2_prec_height + reducedresno);
1521 }
1522 }
1523 if (step_x >= 31 || step_y >= 31){
1524 avpriv_request_sample(s->avctx, "PCRL with large step");
1525 return AVERROR_PATCHWELCOME;
1526 }
1527 step_x = 1<<step_x;
1528 step_y = 1<<step_y;
1529
1530 for (y = tile->coord[1][0]; y < tile->coord[1][1]; y = (y/step_y + 1)*step_y) {
1531 for (x = tile->coord[0][0]; x < tile->coord[0][1]; x = (x/step_x + 1)*step_x) {
1532 for (compno = CSpoc; compno < CEpoc; compno++) {
1533 Jpeg2000Component *comp = tile->comp + compno;
1534 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1535 Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
1536
1537 if (!s->cdx[compno] || !s->cdy[compno])
1538 return AVERROR_INVALIDDATA;
1539
1540 for (reslevelno = RSpoc; reslevelno < FFMIN(codsty->nreslevels, REpoc); reslevelno++) {
1541 unsigned prcx, prcy;
1542 uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1543 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1544 int trx0, try0;
1545
1546 trx0 = ff_jpeg2000_ceildiv(tile->coord[0][0], (int64_t)s->cdx[compno] << reducedresno);
1547 try0 = ff_jpeg2000_ceildiv(tile->coord[1][0], (int64_t)s->cdy[compno] << reducedresno);
1548
1549 if (!(y % ((uint64_t)s->cdy[compno] << (rlevel->log2_prec_height + reducedresno)) == 0 ||
1550 (y == tile->coord[1][0] && ((int64_t)try0 << reducedresno) % (1ULL << (reducedresno + rlevel->log2_prec_height)))))
1551 continue;
1552
1553 if (!(x % ((uint64_t)s->cdx[compno] << (rlevel->log2_prec_width + reducedresno)) == 0 ||
1554 (x == tile->coord[0][0] && ((int64_t)trx0 << reducedresno) % (1ULL << (reducedresno + rlevel->log2_prec_width)))))
1555 continue;
1556
1557 // check if a precinct exists
1558 prcx = ff_jpeg2000_ceildiv(x, (int64_t)s->cdx[compno] << reducedresno) >> rlevel->log2_prec_width;
1559 prcy = ff_jpeg2000_ceildiv(y, (int64_t)s->cdy[compno] << reducedresno) >> rlevel->log2_prec_height;
1560 prcx -= ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], reducedresno) >> rlevel->log2_prec_width;
1561 prcy -= ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], reducedresno) >> rlevel->log2_prec_height;
1562
1563 precno = prcx + rlevel->num_precincts_x * prcy;
1564
1565 if (prcx >= rlevel->num_precincts_x || prcy >= rlevel->num_precincts_y) {
1566 av_log(s->avctx, AV_LOG_WARNING, "prc %d %d outside limits %d %d\n",
1567 prcx, prcy, rlevel->num_precincts_x, rlevel->num_precincts_y);
1568 continue;
1569 }
1570
1571 for (layno = 0; layno < LYEpoc; layno++) {
1572 if ((ret = jpeg2000_decode_packet(s, tile, tp_index, codsty, rlevel,
1573 precno, layno,
1574 qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1575 qntsty->nguardbits)) < 0)
1576 return ret;
1577 }
1578 }
1579 }
1580 }
1581 }
1582 break;
1583
1584 default:
1585 break;
1586 }
1587
1588 return ret;
1589 }
1590
jpeg2000_decode_packets(Jpeg2000DecoderContext * s,Jpeg2000Tile * tile)1591 static int jpeg2000_decode_packets(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
1592 {
1593 int ret = AVERROR_BUG;
1594 int i;
1595 int tp_index = 0;
1596
1597 s->bit_index = 8;
1598 if (tile->poc.nb_poc) {
1599 for (i=0; i<tile->poc.nb_poc; i++) {
1600 Jpeg2000POCEntry *e = &tile->poc.poc[i];
1601 ret = jpeg2000_decode_packets_po_iteration(s, tile,
1602 e->RSpoc, e->CSpoc,
1603 FFMIN(e->LYEpoc, tile->codsty[0].nlayers),
1604 e->REpoc,
1605 FFMIN(e->CEpoc, s->ncomponents),
1606 e->Ppoc, &tp_index
1607 );
1608 if (ret < 0)
1609 return ret;
1610 }
1611 } else {
1612 ret = jpeg2000_decode_packets_po_iteration(s, tile,
1613 0, 0,
1614 tile->codsty[0].nlayers,
1615 33,
1616 s->ncomponents,
1617 tile->codsty[0].prog_order,
1618 &tp_index
1619 );
1620 }
1621 /* EOC marker reached */
1622 bytestream2_skip(&s->g, 2);
1623
1624 return ret;
1625 }
1626
1627 /* TIER-1 routines */
decode_sigpass(Jpeg2000T1Context * t1,int width,int height,int bpno,int bandno,int vert_causal_ctx_csty_symbol)1628 static void decode_sigpass(Jpeg2000T1Context *t1, int width, int height,
1629 int bpno, int bandno,
1630 int vert_causal_ctx_csty_symbol)
1631 {
1632 int mask = 3 << (bpno - 1), y0, x, y;
1633
1634 for (y0 = 0; y0 < height; y0 += 4)
1635 for (x = 0; x < width; x++)
1636 for (y = y0; y < height && y < y0 + 4; y++) {
1637 int flags_mask = -1;
1638 if (vert_causal_ctx_csty_symbol && y == y0 + 3)
1639 flags_mask &= ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE | JPEG2000_T1_SGN_S);
1640 if ((t1->flags[(y+1) * t1->stride + x+1] & JPEG2000_T1_SIG_NB & flags_mask)
1641 && !(t1->flags[(y+1) * t1->stride + x+1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS))) {
1642 if (ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ff_jpeg2000_getsigctxno(t1->flags[(y+1) * t1->stride + x+1] & flags_mask, bandno))) {
1643 int xorbit, ctxno = ff_jpeg2000_getsgnctxno(t1->flags[(y+1) * t1->stride + x+1] & flags_mask, &xorbit);
1644 if (t1->mqc.raw)
1645 t1->data[(y) * t1->stride + x] = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ctxno) ? -mask : mask;
1646 else
1647 t1->data[(y) * t1->stride + x] = (ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ctxno) ^ xorbit) ?
1648 -mask : mask;
1649
1650 ff_jpeg2000_set_significance(t1, x, y,
1651 t1->data[(y) * t1->stride + x] < 0);
1652 }
1653 t1->flags[(y + 1) * t1->stride + x + 1] |= JPEG2000_T1_VIS;
1654 }
1655 }
1656 }
1657
decode_refpass(Jpeg2000T1Context * t1,int width,int height,int bpno,int vert_causal_ctx_csty_symbol)1658 static void decode_refpass(Jpeg2000T1Context *t1, int width, int height,
1659 int bpno, int vert_causal_ctx_csty_symbol)
1660 {
1661 int phalf, nhalf;
1662 int y0, x, y;
1663
1664 phalf = 1 << (bpno - 1);
1665 nhalf = -phalf;
1666
1667 for (y0 = 0; y0 < height; y0 += 4)
1668 for (x = 0; x < width; x++)
1669 for (y = y0; y < height && y < y0 + 4; y++)
1670 if ((t1->flags[(y + 1) * t1->stride + x + 1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS)) == JPEG2000_T1_SIG) {
1671 int flags_mask = (vert_causal_ctx_csty_symbol && y == y0 + 3) ?
1672 ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE | JPEG2000_T1_SGN_S) : -1;
1673 int ctxno = ff_jpeg2000_getrefctxno(t1->flags[(y + 1) * t1->stride + x + 1] & flags_mask);
1674 int r = ff_mqc_decode(&t1->mqc,
1675 t1->mqc.cx_states + ctxno)
1676 ? phalf : nhalf;
1677 t1->data[(y) * t1->stride + x] += t1->data[(y) * t1->stride + x] < 0 ? -r : r;
1678 t1->flags[(y + 1) * t1->stride + x + 1] |= JPEG2000_T1_REF;
1679 }
1680 }
1681
decode_clnpass(Jpeg2000DecoderContext * s,Jpeg2000T1Context * t1,int width,int height,int bpno,int bandno,int seg_symbols,int vert_causal_ctx_csty_symbol)1682 static void decode_clnpass(Jpeg2000DecoderContext *s, Jpeg2000T1Context *t1,
1683 int width, int height, int bpno, int bandno,
1684 int seg_symbols, int vert_causal_ctx_csty_symbol)
1685 {
1686 int mask = 3 << (bpno - 1), y0, x, y, runlen, dec;
1687
1688 for (y0 = 0; y0 < height; y0 += 4) {
1689 for (x = 0; x < width; x++) {
1690 int flags_mask = -1;
1691 if (vert_causal_ctx_csty_symbol)
1692 flags_mask &= ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE | JPEG2000_T1_SGN_S);
1693 if (y0 + 3 < height &&
1694 !((t1->flags[(y0 + 1) * t1->stride + x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
1695 (t1->flags[(y0 + 2) * t1->stride + x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
1696 (t1->flags[(y0 + 3) * t1->stride + x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
1697 (t1->flags[(y0 + 4) * t1->stride + x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG) & flags_mask))) {
1698 if (!ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_RL))
1699 continue;
1700 runlen = ff_mqc_decode(&t1->mqc,
1701 t1->mqc.cx_states + MQC_CX_UNI);
1702 runlen = (runlen << 1) | ff_mqc_decode(&t1->mqc,
1703 t1->mqc.cx_states +
1704 MQC_CX_UNI);
1705 dec = 1;
1706 } else {
1707 runlen = 0;
1708 dec = 0;
1709 }
1710
1711 for (y = y0 + runlen; y < y0 + 4 && y < height; y++) {
1712 int flags_mask = -1;
1713 if (vert_causal_ctx_csty_symbol && y == y0 + 3)
1714 flags_mask &= ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE | JPEG2000_T1_SGN_S);
1715 if (!dec) {
1716 if (!(t1->flags[(y+1) * t1->stride + x+1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS))) {
1717 dec = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ff_jpeg2000_getsigctxno(t1->flags[(y+1) * t1->stride + x+1] & flags_mask,
1718 bandno));
1719 }
1720 }
1721 if (dec) {
1722 int xorbit;
1723 int ctxno = ff_jpeg2000_getsgnctxno(t1->flags[(y + 1) * t1->stride + x + 1] & flags_mask,
1724 &xorbit);
1725 t1->data[(y) * t1->stride + x] = (ff_mqc_decode(&t1->mqc,
1726 t1->mqc.cx_states + ctxno) ^
1727 xorbit)
1728 ? -mask : mask;
1729 ff_jpeg2000_set_significance(t1, x, y, t1->data[(y) * t1->stride + x] < 0);
1730 }
1731 dec = 0;
1732 t1->flags[(y + 1) * t1->stride + x + 1] &= ~JPEG2000_T1_VIS;
1733 }
1734 }
1735 }
1736 if (seg_symbols) {
1737 int val;
1738 val = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1739 val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1740 val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1741 val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1742 if (val != 0xa)
1743 av_log(s->avctx, AV_LOG_ERROR,
1744 "Segmentation symbol value incorrect\n");
1745 }
1746 }
1747
decode_cblk(Jpeg2000DecoderContext * s,Jpeg2000CodingStyle * codsty,Jpeg2000T1Context * t1,Jpeg2000Cblk * cblk,int width,int height,int bandpos,uint8_t roi_shift)1748 static int decode_cblk(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *codsty,
1749 Jpeg2000T1Context *t1, Jpeg2000Cblk *cblk,
1750 int width, int height, int bandpos, uint8_t roi_shift)
1751 {
1752 int passno = cblk->npasses, pass_t = 2, bpno = cblk->nonzerobits - 1 + roi_shift;
1753 int pass_cnt = 0;
1754 int vert_causal_ctx_csty_symbol = codsty->cblk_style & JPEG2000_CBLK_VSC;
1755 int term_cnt = 0;
1756 int coder_type;
1757
1758 av_assert0(width <= 1024U && height <= 1024U);
1759 av_assert0(width*height <= 4096);
1760
1761 memset(t1->data, 0, t1->stride * height * sizeof(*t1->data));
1762
1763 /* If code-block contains no compressed data: nothing to do. */
1764 if (!cblk->length)
1765 return 0;
1766
1767 memset(t1->flags, 0, t1->stride * (height + 2) * sizeof(*t1->flags));
1768
1769 cblk->data[cblk->length] = 0xff;
1770 cblk->data[cblk->length+1] = 0xff;
1771 ff_mqc_initdec(&t1->mqc, cblk->data, 0, 1);
1772
1773 while (passno--) {
1774 if (bpno < 0 || bpno > 29) {
1775 av_log(s->avctx, AV_LOG_ERROR, "bpno became invalid\n");
1776 return AVERROR_INVALIDDATA;
1777 }
1778 switch(pass_t) {
1779 case 0:
1780 decode_sigpass(t1, width, height, bpno + 1, bandpos,
1781 vert_causal_ctx_csty_symbol);
1782 break;
1783 case 1:
1784 decode_refpass(t1, width, height, bpno + 1, vert_causal_ctx_csty_symbol);
1785 break;
1786 case 2:
1787 av_assert2(!t1->mqc.raw);
1788 decode_clnpass(s, t1, width, height, bpno + 1, bandpos,
1789 codsty->cblk_style & JPEG2000_CBLK_SEGSYM,
1790 vert_causal_ctx_csty_symbol);
1791 break;
1792 }
1793 if (codsty->cblk_style & JPEG2000_CBLK_RESET) // XXX no testcase for just this
1794 ff_mqc_init_contexts(&t1->mqc);
1795
1796 if (passno && (coder_type = needs_termination(codsty->cblk_style, pass_cnt))) {
1797 if (term_cnt >= cblk->nb_terminations) {
1798 av_log(s->avctx, AV_LOG_ERROR, "Missing needed termination \n");
1799 return AVERROR_INVALIDDATA;
1800 }
1801 if (FFABS(cblk->data + cblk->data_start[term_cnt + 1] - 2 - t1->mqc.bp) > 0) {
1802 av_log(s->avctx, AV_LOG_WARNING, "Mid mismatch %"PTRDIFF_SPECIFIER" in pass %d of %d\n",
1803 cblk->data + cblk->data_start[term_cnt + 1] - 2 - t1->mqc.bp,
1804 pass_cnt, cblk->npasses);
1805 }
1806
1807 ff_mqc_initdec(&t1->mqc, cblk->data + cblk->data_start[++term_cnt], coder_type == 2, 0);
1808 }
1809
1810 pass_t++;
1811 if (pass_t == 3) {
1812 bpno--;
1813 pass_t = 0;
1814 }
1815 pass_cnt ++;
1816 }
1817
1818 if (cblk->data + cblk->length - 2 > t1->mqc.bp) {
1819 av_log(s->avctx, AV_LOG_WARNING, "End mismatch %"PTRDIFF_SPECIFIER"\n",
1820 cblk->data + cblk->length - 2 - t1->mqc.bp);
1821 }
1822
1823 if (cblk->data + cblk->length < t1->mqc.bp) {
1824 av_log(s->avctx, AV_LOG_WARNING, "Synthetic End of Stream Marker Read.\n");
1825 }
1826
1827 return 1;
1828 }
1829
roi_shift_param(Jpeg2000Component * comp,int quan_parameter)1830 static inline int roi_shift_param(Jpeg2000Component *comp,
1831 int quan_parameter)
1832 {
1833 uint8_t roi_shift;
1834 int val;
1835 roi_shift = comp->roi_shift;
1836 val = (quan_parameter < 0)?-quan_parameter:quan_parameter;
1837
1838 if (val > (1 << roi_shift))
1839 return (quan_parameter < 0)?-(val >> roi_shift):(val >> roi_shift);
1840 return quan_parameter;
1841 }
1842
1843 /* TODO: Verify dequantization for lossless case
1844 * comp->data can be float or int
1845 * band->stepsize can be float or int
1846 * depending on the type of DWT transformation.
1847 * see ISO/IEC 15444-1:2002 A.6.1 */
1848
1849 /* Float dequantization of a codeblock.*/
dequantization_float(int x,int y,Jpeg2000Cblk * cblk,Jpeg2000Component * comp,Jpeg2000T1Context * t1,Jpeg2000Band * band)1850 static void dequantization_float(int x, int y, Jpeg2000Cblk *cblk,
1851 Jpeg2000Component *comp,
1852 Jpeg2000T1Context *t1, Jpeg2000Band *band)
1853 {
1854 int i, j;
1855 int w = cblk->coord[0][1] - cblk->coord[0][0];
1856 for (j = 0; j < (cblk->coord[1][1] - cblk->coord[1][0]); ++j) {
1857 float *datap = &comp->f_data[(comp->coord[0][1] - comp->coord[0][0]) * (y + j) + x];
1858 int *src = t1->data + j*t1->stride;
1859 for (i = 0; i < w; ++i)
1860 datap[i] = src[i] * band->f_stepsize;
1861 }
1862 }
1863
1864 /* Integer dequantization of a codeblock.*/
dequantization_int(int x,int y,Jpeg2000Cblk * cblk,Jpeg2000Component * comp,Jpeg2000T1Context * t1,Jpeg2000Band * band)1865 static void dequantization_int(int x, int y, Jpeg2000Cblk *cblk,
1866 Jpeg2000Component *comp,
1867 Jpeg2000T1Context *t1, Jpeg2000Band *band)
1868 {
1869 int i, j;
1870 int w = cblk->coord[0][1] - cblk->coord[0][0];
1871 for (j = 0; j < (cblk->coord[1][1] - cblk->coord[1][0]); ++j) {
1872 int32_t *datap = &comp->i_data[(comp->coord[0][1] - comp->coord[0][0]) * (y + j) + x];
1873 int *src = t1->data + j*t1->stride;
1874 if (band->i_stepsize == 32768) {
1875 for (i = 0; i < w; ++i)
1876 datap[i] = src[i] / 2;
1877 } else {
1878 // This should be VERY uncommon
1879 for (i = 0; i < w; ++i)
1880 datap[i] = (src[i] * (int64_t)band->i_stepsize) / 65536;
1881 }
1882 }
1883 }
1884
dequantization_int_97(int x,int y,Jpeg2000Cblk * cblk,Jpeg2000Component * comp,Jpeg2000T1Context * t1,Jpeg2000Band * band)1885 static void dequantization_int_97(int x, int y, Jpeg2000Cblk *cblk,
1886 Jpeg2000Component *comp,
1887 Jpeg2000T1Context *t1, Jpeg2000Band *band)
1888 {
1889 int i, j;
1890 int w = cblk->coord[0][1] - cblk->coord[0][0];
1891 for (j = 0; j < (cblk->coord[1][1] - cblk->coord[1][0]); ++j) {
1892 int32_t *datap = &comp->i_data[(comp->coord[0][1] - comp->coord[0][0]) * (y + j) + x];
1893 int *src = t1->data + j*t1->stride;
1894 for (i = 0; i < w; ++i)
1895 datap[i] = (src[i] * (int64_t)band->i_stepsize + (1<<15)) >> 16;
1896 }
1897 }
1898
mct_decode(Jpeg2000DecoderContext * s,Jpeg2000Tile * tile)1899 static inline void mct_decode(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
1900 {
1901 int i, csize = 1;
1902 void *src[3];
1903
1904 for (i = 1; i < 3; i++) {
1905 if (tile->codsty[0].transform != tile->codsty[i].transform) {
1906 av_log(s->avctx, AV_LOG_ERROR, "Transforms mismatch, MCT not supported\n");
1907 return;
1908 }
1909 if (memcmp(tile->comp[0].coord, tile->comp[i].coord, sizeof(tile->comp[0].coord))) {
1910 av_log(s->avctx, AV_LOG_ERROR, "Coords mismatch, MCT not supported\n");
1911 return;
1912 }
1913 }
1914
1915 for (i = 0; i < 3; i++)
1916 if (tile->codsty[0].transform == FF_DWT97)
1917 src[i] = tile->comp[i].f_data;
1918 else
1919 src[i] = tile->comp[i].i_data;
1920
1921 for (i = 0; i < 2; i++)
1922 csize *= tile->comp[0].coord[i][1] - tile->comp[0].coord[i][0];
1923
1924 s->dsp.mct_decode[tile->codsty[0].transform](src[0], src[1], src[2], csize);
1925 }
1926
roi_scale_cblk(Jpeg2000Cblk * cblk,Jpeg2000Component * comp,Jpeg2000T1Context * t1)1927 static inline void roi_scale_cblk(Jpeg2000Cblk *cblk,
1928 Jpeg2000Component *comp,
1929 Jpeg2000T1Context *t1)
1930 {
1931 int i, j;
1932 int w = cblk->coord[0][1] - cblk->coord[0][0];
1933 for (j = 0; j < (cblk->coord[1][1] - cblk->coord[1][0]); ++j) {
1934 int *src = t1->data + j*t1->stride;
1935 for (i = 0; i < w; ++i)
1936 src[i] = roi_shift_param(comp, src[i]);
1937 }
1938 }
1939
tile_codeblocks(Jpeg2000DecoderContext * s,Jpeg2000Tile * tile)1940 static inline void tile_codeblocks(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
1941 {
1942 Jpeg2000T1Context t1;
1943
1944 int compno, reslevelno, bandno;
1945
1946 /* Loop on tile components */
1947 for (compno = 0; compno < s->ncomponents; compno++) {
1948 Jpeg2000Component *comp = tile->comp + compno;
1949 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1950 int coded = 0;
1951
1952 t1.stride = (1<<codsty->log2_cblk_width) + 2;
1953
1954 /* Loop on resolution levels */
1955 for (reslevelno = 0; reslevelno < codsty->nreslevels2decode; reslevelno++) {
1956 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1957 /* Loop on bands */
1958 for (bandno = 0; bandno < rlevel->nbands; bandno++) {
1959 int nb_precincts, precno;
1960 Jpeg2000Band *band = rlevel->band + bandno;
1961 int cblkno = 0, bandpos;
1962
1963 bandpos = bandno + (reslevelno > 0);
1964
1965 if (band->coord[0][0] == band->coord[0][1] ||
1966 band->coord[1][0] == band->coord[1][1])
1967 continue;
1968
1969 nb_precincts = rlevel->num_precincts_x * rlevel->num_precincts_y;
1970 /* Loop on precincts */
1971 for (precno = 0; precno < nb_precincts; precno++) {
1972 Jpeg2000Prec *prec = band->prec + precno;
1973
1974 /* Loop on codeblocks */
1975 for (cblkno = 0;
1976 cblkno < prec->nb_codeblocks_width * prec->nb_codeblocks_height;
1977 cblkno++) {
1978 int x, y;
1979 Jpeg2000Cblk *cblk = prec->cblk + cblkno;
1980 int ret = decode_cblk(s, codsty, &t1, cblk,
1981 cblk->coord[0][1] - cblk->coord[0][0],
1982 cblk->coord[1][1] - cblk->coord[1][0],
1983 bandpos, comp->roi_shift);
1984 if (ret)
1985 coded = 1;
1986 else
1987 continue;
1988 x = cblk->coord[0][0] - band->coord[0][0];
1989 y = cblk->coord[1][0] - band->coord[1][0];
1990
1991 if (comp->roi_shift)
1992 roi_scale_cblk(cblk, comp, &t1);
1993 if (codsty->transform == FF_DWT97)
1994 dequantization_float(x, y, cblk, comp, &t1, band);
1995 else if (codsty->transform == FF_DWT97_INT)
1996 dequantization_int_97(x, y, cblk, comp, &t1, band);
1997 else
1998 dequantization_int(x, y, cblk, comp, &t1, band);
1999 } /* end cblk */
2000 } /*end prec */
2001 } /* end band */
2002 } /* end reslevel */
2003
2004 /* inverse DWT */
2005 if (coded)
2006 ff_dwt_decode(&comp->dwt, codsty->transform == FF_DWT97 ? (void*)comp->f_data : (void*)comp->i_data);
2007
2008 } /*end comp */
2009 }
2010
2011 #define WRITE_FRAME(D, PIXEL) \
2012 static inline void write_frame_ ## D(Jpeg2000DecoderContext * s, Jpeg2000Tile * tile, \
2013 AVFrame * picture, int precision) \
2014 { \
2015 const AVPixFmtDescriptor *pixdesc = av_pix_fmt_desc_get(s->avctx->pix_fmt); \
2016 int planar = !!(pixdesc->flags & AV_PIX_FMT_FLAG_PLANAR); \
2017 int pixelsize = planar ? 1 : pixdesc->nb_components; \
2018 \
2019 int compno; \
2020 int x, y; \
2021 \
2022 for (compno = 0; compno < s->ncomponents; compno++) { \
2023 Jpeg2000Component *comp = tile->comp + compno; \
2024 Jpeg2000CodingStyle *codsty = tile->codsty + compno; \
2025 PIXEL *line; \
2026 float *datap = comp->f_data; \
2027 int32_t *i_datap = comp->i_data; \
2028 int cbps = s->cbps[compno]; \
2029 int w = tile->comp[compno].coord[0][1] - \
2030 ff_jpeg2000_ceildiv(s->image_offset_x, s->cdx[compno]); \
2031 int h = tile->comp[compno].coord[1][1] - \
2032 ff_jpeg2000_ceildiv(s->image_offset_y, s->cdy[compno]); \
2033 int plane = 0; \
2034 \
2035 if (planar) \
2036 plane = s->cdef[compno] ? s->cdef[compno]-1 : (s->ncomponents-1); \
2037 \
2038 y = tile->comp[compno].coord[1][0] - \
2039 ff_jpeg2000_ceildiv(s->image_offset_y, s->cdy[compno]); \
2040 line = (PIXEL *)picture->data[plane] + y * (picture->linesize[plane] / sizeof(PIXEL));\
2041 for (; y < h; y++) { \
2042 PIXEL *dst; \
2043 \
2044 x = tile->comp[compno].coord[0][0] - \
2045 ff_jpeg2000_ceildiv(s->image_offset_x, s->cdx[compno]); \
2046 dst = line + x * pixelsize + compno*!planar; \
2047 \
2048 if (codsty->transform == FF_DWT97) { \
2049 for (; x < w; x++) { \
2050 int val = lrintf(*datap) + (1 << (cbps - 1)); \
2051 /* DC level shift and clip see ISO 15444-1:2002 G.1.2 */ \
2052 val = av_clip(val, 0, (1 << cbps) - 1); \
2053 *dst = val << (precision - cbps); \
2054 datap++; \
2055 dst += pixelsize; \
2056 } \
2057 } else { \
2058 for (; x < w; x++) { \
2059 int val = *i_datap + (1 << (cbps - 1)); \
2060 /* DC level shift and clip see ISO 15444-1:2002 G.1.2 */ \
2061 val = av_clip(val, 0, (1 << cbps) - 1); \
2062 *dst = val << (precision - cbps); \
2063 i_datap++; \
2064 dst += pixelsize; \
2065 } \
2066 } \
2067 line += picture->linesize[plane] / sizeof(PIXEL); \
2068 } \
2069 } \
2070 \
2071 }
2072
2073 WRITE_FRAME(8, uint8_t)
2074 WRITE_FRAME(16, uint16_t)
2075
2076 #undef WRITE_FRAME
2077
jpeg2000_decode_tile(AVCodecContext * avctx,void * td,int jobnr,int threadnr)2078 static int jpeg2000_decode_tile(AVCodecContext *avctx, void *td,
2079 int jobnr, int threadnr)
2080 {
2081 Jpeg2000DecoderContext *s = avctx->priv_data;
2082 AVFrame *picture = td;
2083 Jpeg2000Tile *tile = s->tile + jobnr;
2084 int x;
2085
2086 tile_codeblocks(s, tile);
2087
2088 /* inverse MCT transformation */
2089 if (tile->codsty[0].mct)
2090 mct_decode(s, tile);
2091
2092 for (x = 0; x < s->ncomponents; x++) {
2093 if (s->cdef[x] < 0) {
2094 for (x = 0; x < s->ncomponents; x++) {
2095 s->cdef[x] = x + 1;
2096 }
2097 if ((s->ncomponents & 1) == 0)
2098 s->cdef[s->ncomponents-1] = 0;
2099 break;
2100 }
2101 }
2102
2103 if (s->precision <= 8) {
2104 write_frame_8(s, tile, picture, 8);
2105 } else {
2106 int precision = picture->format == AV_PIX_FMT_XYZ12 ||
2107 picture->format == AV_PIX_FMT_RGB48 ||
2108 picture->format == AV_PIX_FMT_RGBA64 ||
2109 picture->format == AV_PIX_FMT_GRAY16 ? 16 : s->precision;
2110
2111 write_frame_16(s, tile, picture, precision);
2112 }
2113
2114 return 0;
2115 }
2116
jpeg2000_dec_cleanup(Jpeg2000DecoderContext * s)2117 static void jpeg2000_dec_cleanup(Jpeg2000DecoderContext *s)
2118 {
2119 int tileno, compno;
2120 for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++) {
2121 if (s->tile[tileno].comp) {
2122 for (compno = 0; compno < s->ncomponents; compno++) {
2123 Jpeg2000Component *comp = s->tile[tileno].comp + compno;
2124 Jpeg2000CodingStyle *codsty = s->tile[tileno].codsty + compno;
2125
2126 ff_jpeg2000_cleanup(comp, codsty);
2127 }
2128 av_freep(&s->tile[tileno].comp);
2129 av_freep(&s->tile[tileno].packed_headers);
2130 s->tile[tileno].packed_headers_size = 0;
2131 }
2132 }
2133 av_freep(&s->packed_headers);
2134 s->packed_headers_size = 0;
2135 memset(&s->packed_headers_stream, 0, sizeof(s->packed_headers_stream));
2136 av_freep(&s->tile);
2137 memset(s->codsty, 0, sizeof(s->codsty));
2138 memset(s->qntsty, 0, sizeof(s->qntsty));
2139 memset(s->properties, 0, sizeof(s->properties));
2140 memset(&s->poc , 0, sizeof(s->poc));
2141 s->numXtiles = s->numYtiles = 0;
2142 s->ncomponents = 0;
2143 }
2144
jpeg2000_read_main_headers(Jpeg2000DecoderContext * s)2145 static int jpeg2000_read_main_headers(Jpeg2000DecoderContext *s)
2146 {
2147 Jpeg2000CodingStyle *codsty = s->codsty;
2148 Jpeg2000QuantStyle *qntsty = s->qntsty;
2149 Jpeg2000POC *poc = &s->poc;
2150 uint8_t *properties = s->properties;
2151
2152 for (;;) {
2153 int len, ret = 0;
2154 uint16_t marker;
2155 int oldpos;
2156
2157 if (bytestream2_get_bytes_left(&s->g) < 2) {
2158 av_log(s->avctx, AV_LOG_ERROR, "Missing EOC\n");
2159 break;
2160 }
2161
2162 marker = bytestream2_get_be16u(&s->g);
2163 oldpos = bytestream2_tell(&s->g);
2164 if (marker >= 0xFF30 && marker <= 0xFF3F)
2165 continue;
2166 if (marker == JPEG2000_SOD) {
2167 Jpeg2000Tile *tile;
2168 Jpeg2000TilePart *tp;
2169
2170 if (!s->tile) {
2171 av_log(s->avctx, AV_LOG_ERROR, "Missing SIZ\n");
2172 return AVERROR_INVALIDDATA;
2173 }
2174 if (s->curtileno < 0) {
2175 av_log(s->avctx, AV_LOG_ERROR, "Missing SOT\n");
2176 return AVERROR_INVALIDDATA;
2177 }
2178
2179 tile = s->tile + s->curtileno;
2180 tp = tile->tile_part + tile->tp_idx;
2181 if (tp->tp_end < s->g.buffer) {
2182 av_log(s->avctx, AV_LOG_ERROR, "Invalid tpend\n");
2183 return AVERROR_INVALIDDATA;
2184 }
2185
2186 if (s->has_ppm) {
2187 uint32_t tp_header_size = bytestream2_get_be32(&s->packed_headers_stream);
2188 if (bytestream2_get_bytes_left(&s->packed_headers_stream) < tp_header_size)
2189 return AVERROR_INVALIDDATA;
2190 bytestream2_init(&tp->header_tpg, s->packed_headers_stream.buffer, tp_header_size);
2191 bytestream2_skip(&s->packed_headers_stream, tp_header_size);
2192 }
2193 if (tile->has_ppt && tile->tp_idx == 0) {
2194 bytestream2_init(&tile->packed_headers_stream, tile->packed_headers, tile->packed_headers_size);
2195 }
2196
2197 bytestream2_init(&tp->tpg, s->g.buffer, tp->tp_end - s->g.buffer);
2198 bytestream2_skip(&s->g, tp->tp_end - s->g.buffer);
2199
2200 continue;
2201 }
2202 if (marker == JPEG2000_EOC)
2203 break;
2204
2205 len = bytestream2_get_be16(&s->g);
2206 if (len < 2 || bytestream2_get_bytes_left(&s->g) < len - 2) {
2207 if (s->avctx->strict_std_compliance >= FF_COMPLIANCE_STRICT) {
2208 av_log(s->avctx, AV_LOG_ERROR, "Invalid len %d left=%d\n", len, bytestream2_get_bytes_left(&s->g));
2209 return AVERROR_INVALIDDATA;
2210 }
2211 av_log(s->avctx, AV_LOG_WARNING, "Missing EOC Marker.\n");
2212 break;
2213 }
2214
2215 switch (marker) {
2216 case JPEG2000_SIZ:
2217 if (s->ncomponents) {
2218 av_log(s->avctx, AV_LOG_ERROR, "Duplicate SIZ\n");
2219 return AVERROR_INVALIDDATA;
2220 }
2221 ret = get_siz(s);
2222 if (!s->tile)
2223 s->numXtiles = s->numYtiles = 0;
2224 break;
2225 case JPEG2000_COC:
2226 ret = get_coc(s, codsty, properties);
2227 break;
2228 case JPEG2000_COD:
2229 ret = get_cod(s, codsty, properties);
2230 break;
2231 case JPEG2000_RGN:
2232 ret = get_rgn(s, len);
2233 break;
2234 case JPEG2000_QCC:
2235 ret = get_qcc(s, len, qntsty, properties);
2236 break;
2237 case JPEG2000_QCD:
2238 ret = get_qcd(s, len, qntsty, properties);
2239 break;
2240 case JPEG2000_POC:
2241 ret = get_poc(s, len, poc);
2242 break;
2243 case JPEG2000_SOT:
2244 if (!s->in_tile_headers) {
2245 s->in_tile_headers = 1;
2246 if (s->has_ppm) {
2247 bytestream2_init(&s->packed_headers_stream, s->packed_headers, s->packed_headers_size);
2248 }
2249 }
2250 if (!(ret = get_sot(s, len))) {
2251 av_assert1(s->curtileno >= 0);
2252 codsty = s->tile[s->curtileno].codsty;
2253 qntsty = s->tile[s->curtileno].qntsty;
2254 poc = &s->tile[s->curtileno].poc;
2255 properties = s->tile[s->curtileno].properties;
2256 }
2257 break;
2258 case JPEG2000_PLM:
2259 // the PLM marker is ignored
2260 case JPEG2000_COM:
2261 // the comment is ignored
2262 bytestream2_skip(&s->g, len - 2);
2263 break;
2264 case JPEG2000_CRG:
2265 ret = read_crg(s, len);
2266 break;
2267 case JPEG2000_TLM:
2268 // Tile-part lengths
2269 ret = get_tlm(s, len);
2270 break;
2271 case JPEG2000_PLT:
2272 // Packet length, tile-part header
2273 ret = get_plt(s, len);
2274 break;
2275 case JPEG2000_PPM:
2276 // Packed headers, main header
2277 if (s->in_tile_headers) {
2278 av_log(s->avctx, AV_LOG_ERROR, "PPM Marker can only be in Main header\n");
2279 return AVERROR_INVALIDDATA;
2280 }
2281 ret = get_ppm(s, len);
2282 break;
2283 case JPEG2000_PPT:
2284 // Packed headers, tile-part header
2285 if (s->has_ppm) {
2286 av_log(s->avctx, AV_LOG_ERROR,
2287 "Cannot have both PPT and PPM marker.\n");
2288 return AVERROR_INVALIDDATA;
2289 }
2290
2291 ret = get_ppt(s, len);
2292 break;
2293 default:
2294 av_log(s->avctx, AV_LOG_ERROR,
2295 "unsupported marker 0x%.4"PRIX16" at pos 0x%X\n",
2296 marker, bytestream2_tell(&s->g) - 4);
2297 bytestream2_skip(&s->g, len - 2);
2298 break;
2299 }
2300 if (bytestream2_tell(&s->g) - oldpos != len || ret) {
2301 av_log(s->avctx, AV_LOG_ERROR,
2302 "error during processing marker segment %.4"PRIx16"\n",
2303 marker);
2304 return ret ? ret : -1;
2305 }
2306 }
2307 return 0;
2308 }
2309
2310 /* Read bit stream packets --> T2 operation. */
jpeg2000_read_bitstream_packets(Jpeg2000DecoderContext * s)2311 static int jpeg2000_read_bitstream_packets(Jpeg2000DecoderContext *s)
2312 {
2313 int ret = 0;
2314 int tileno;
2315
2316 for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++) {
2317 Jpeg2000Tile *tile = s->tile + tileno;
2318
2319 if ((ret = init_tile(s, tileno)) < 0)
2320 return ret;
2321
2322 if ((ret = jpeg2000_decode_packets(s, tile)) < 0)
2323 return ret;
2324 }
2325
2326 return 0;
2327 }
2328
jp2_find_codestream(Jpeg2000DecoderContext * s)2329 static int jp2_find_codestream(Jpeg2000DecoderContext *s)
2330 {
2331 uint32_t atom_size, atom, atom_end;
2332 int search_range = 10;
2333
2334 while (search_range
2335 &&
2336 bytestream2_get_bytes_left(&s->g) >= 8) {
2337 atom_size = bytestream2_get_be32u(&s->g);
2338 atom = bytestream2_get_be32u(&s->g);
2339 if (atom_size == 1) {
2340 if (bytestream2_get_be32u(&s->g)) {
2341 avpriv_request_sample(s->avctx, "Huge atom");
2342 return 0;
2343 }
2344 atom_size = bytestream2_get_be32u(&s->g);
2345 if (atom_size < 16 || (int64_t)bytestream2_tell(&s->g) + atom_size - 16 > INT_MAX)
2346 return AVERROR_INVALIDDATA;
2347 atom_end = bytestream2_tell(&s->g) + atom_size - 16;
2348 } else {
2349 if (atom_size < 8 || (int64_t)bytestream2_tell(&s->g) + atom_size - 8 > INT_MAX)
2350 return AVERROR_INVALIDDATA;
2351 atom_end = bytestream2_tell(&s->g) + atom_size - 8;
2352 }
2353
2354 if (atom == JP2_CODESTREAM)
2355 return 1;
2356
2357 if (bytestream2_get_bytes_left(&s->g) < atom_size || atom_end < atom_size)
2358 return 0;
2359
2360 if (atom == JP2_HEADER &&
2361 atom_size >= 16) {
2362 uint32_t atom2_size, atom2, atom2_end;
2363 do {
2364 if (bytestream2_get_bytes_left(&s->g) < 8)
2365 break;
2366 atom2_size = bytestream2_get_be32u(&s->g);
2367 atom2 = bytestream2_get_be32u(&s->g);
2368 atom2_end = bytestream2_tell(&s->g) + atom2_size - 8;
2369 if (atom2_size < 8 || atom2_end > atom_end || atom2_end < atom2_size)
2370 break;
2371 atom2_size -= 8;
2372 if (atom2 == JP2_CODESTREAM) {
2373 return 1;
2374 } else if (atom2 == MKBETAG('c','o','l','r') && atom2_size >= 7) {
2375 int method = bytestream2_get_byteu(&s->g);
2376 bytestream2_skipu(&s->g, 2);
2377 if (method == 1) {
2378 s->colour_space = bytestream2_get_be32u(&s->g);
2379 }
2380 } else if (atom2 == MKBETAG('p','c','l','r') && atom2_size >= 6) {
2381 int i, size, colour_count, colour_channels, colour_depth[3];
2382 colour_count = bytestream2_get_be16u(&s->g);
2383 colour_channels = bytestream2_get_byteu(&s->g);
2384 // FIXME: Do not ignore channel_sign
2385 colour_depth[0] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1;
2386 colour_depth[1] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1;
2387 colour_depth[2] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1;
2388 size = (colour_depth[0] + 7 >> 3) * colour_count +
2389 (colour_depth[1] + 7 >> 3) * colour_count +
2390 (colour_depth[2] + 7 >> 3) * colour_count;
2391 if (colour_count > AVPALETTE_COUNT ||
2392 colour_channels != 3 ||
2393 colour_depth[0] > 16 ||
2394 colour_depth[1] > 16 ||
2395 colour_depth[2] > 16 ||
2396 atom2_size < size) {
2397 avpriv_request_sample(s->avctx, "Unknown palette");
2398 bytestream2_seek(&s->g, atom2_end, SEEK_SET);
2399 continue;
2400 }
2401 s->pal8 = 1;
2402 for (i = 0; i < colour_count; i++) {
2403 uint32_t r, g, b;
2404 if (colour_depth[0] <= 8) {
2405 r = bytestream2_get_byteu(&s->g) << 8 - colour_depth[0];
2406 r |= r >> colour_depth[0];
2407 } else {
2408 r = bytestream2_get_be16u(&s->g) >> colour_depth[0] - 8;
2409 }
2410 if (colour_depth[1] <= 8) {
2411 g = bytestream2_get_byteu(&s->g) << 8 - colour_depth[1];
2412 g |= g >> colour_depth[1];
2413 } else {
2414 g = bytestream2_get_be16u(&s->g) >> colour_depth[1] - 8;
2415 }
2416 if (colour_depth[2] <= 8) {
2417 b = bytestream2_get_byteu(&s->g) << 8 - colour_depth[2];
2418 b |= b >> colour_depth[2];
2419 } else {
2420 b = bytestream2_get_be16u(&s->g) >> colour_depth[2] - 8;
2421 }
2422 s->palette[i] = 0xffu << 24 | r << 16 | g << 8 | b;
2423 }
2424 } else if (atom2 == MKBETAG('c','d','e','f') && atom2_size >= 2) {
2425 int n = bytestream2_get_be16u(&s->g);
2426 for (; n>0; n--) {
2427 int cn = bytestream2_get_be16(&s->g);
2428 int av_unused typ = bytestream2_get_be16(&s->g);
2429 int asoc = bytestream2_get_be16(&s->g);
2430 if (cn < 4 && asoc < 4)
2431 s->cdef[cn] = asoc;
2432 }
2433 } else if (atom2 == MKBETAG('r','e','s',' ') && atom2_size >= 18) {
2434 int64_t vnum, vden, hnum, hden, vexp, hexp;
2435 uint32_t resx;
2436 bytestream2_skip(&s->g, 4);
2437 resx = bytestream2_get_be32u(&s->g);
2438 if (resx != MKBETAG('r','e','s','c') && resx != MKBETAG('r','e','s','d')) {
2439 bytestream2_seek(&s->g, atom2_end, SEEK_SET);
2440 continue;
2441 }
2442 vnum = bytestream2_get_be16u(&s->g);
2443 vden = bytestream2_get_be16u(&s->g);
2444 hnum = bytestream2_get_be16u(&s->g);
2445 hden = bytestream2_get_be16u(&s->g);
2446 vexp = bytestream2_get_byteu(&s->g);
2447 hexp = bytestream2_get_byteu(&s->g);
2448 if (!vnum || !vden || !hnum || !hden) {
2449 bytestream2_seek(&s->g, atom2_end, SEEK_SET);
2450 av_log(s->avctx, AV_LOG_WARNING, "RES box invalid\n");
2451 continue;
2452 }
2453 if (vexp > hexp) {
2454 vexp -= hexp;
2455 hexp = 0;
2456 } else {
2457 hexp -= vexp;
2458 vexp = 0;
2459 }
2460 if ( INT64_MAX / (hnum * vden) > pow(10, hexp)
2461 && INT64_MAX / (vnum * hden) > pow(10, vexp))
2462 av_reduce(&s->sar.den, &s->sar.num,
2463 hnum * vden * pow(10, hexp),
2464 vnum * hden * pow(10, vexp),
2465 INT32_MAX);
2466 }
2467 bytestream2_seek(&s->g, atom2_end, SEEK_SET);
2468 } while (atom_end - atom2_end >= 8);
2469 } else {
2470 search_range--;
2471 }
2472 bytestream2_seek(&s->g, atom_end, SEEK_SET);
2473 }
2474
2475 return 0;
2476 }
2477
jpeg2000_init_static_data(void)2478 static av_cold void jpeg2000_init_static_data(void)
2479 {
2480 ff_jpeg2000_init_tier1_luts();
2481 ff_mqc_init_context_tables();
2482 }
2483
jpeg2000_decode_init(AVCodecContext * avctx)2484 static av_cold int jpeg2000_decode_init(AVCodecContext *avctx)
2485 {
2486 static AVOnce init_static_once = AV_ONCE_INIT;
2487 Jpeg2000DecoderContext *s = avctx->priv_data;
2488
2489 ff_thread_once(&init_static_once, jpeg2000_init_static_data);
2490 ff_jpeg2000dsp_init(&s->dsp);
2491
2492 return 0;
2493 }
2494
jpeg2000_decode_frame(AVCodecContext * avctx,void * data,int * got_frame,AVPacket * avpkt)2495 static int jpeg2000_decode_frame(AVCodecContext *avctx, void *data,
2496 int *got_frame, AVPacket *avpkt)
2497 {
2498 Jpeg2000DecoderContext *s = avctx->priv_data;
2499 ThreadFrame frame = { .f = data };
2500 AVFrame *picture = data;
2501 int ret;
2502
2503 s->avctx = avctx;
2504 bytestream2_init(&s->g, avpkt->data, avpkt->size);
2505 s->curtileno = -1;
2506 memset(s->cdef, -1, sizeof(s->cdef));
2507
2508 if (bytestream2_get_bytes_left(&s->g) < 2) {
2509 ret = AVERROR_INVALIDDATA;
2510 goto end;
2511 }
2512
2513 // check if the image is in jp2 format
2514 if (bytestream2_get_bytes_left(&s->g) >= 12 &&
2515 (bytestream2_get_be32u(&s->g) == 12) &&
2516 (bytestream2_get_be32u(&s->g) == JP2_SIG_TYPE) &&
2517 (bytestream2_get_be32u(&s->g) == JP2_SIG_VALUE)) {
2518 if (!jp2_find_codestream(s)) {
2519 av_log(avctx, AV_LOG_ERROR,
2520 "Could not find Jpeg2000 codestream atom.\n");
2521 ret = AVERROR_INVALIDDATA;
2522 goto end;
2523 }
2524 } else {
2525 bytestream2_seek(&s->g, 0, SEEK_SET);
2526 }
2527
2528 while (bytestream2_get_bytes_left(&s->g) >= 3 && bytestream2_peek_be16(&s->g) != JPEG2000_SOC)
2529 bytestream2_skip(&s->g, 1);
2530
2531 if (bytestream2_get_be16u(&s->g) != JPEG2000_SOC) {
2532 av_log(avctx, AV_LOG_ERROR, "SOC marker not present\n");
2533 ret = AVERROR_INVALIDDATA;
2534 goto end;
2535 }
2536 if (ret = jpeg2000_read_main_headers(s))
2537 goto end;
2538
2539 /* get picture buffer */
2540 if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
2541 goto end;
2542 picture->pict_type = AV_PICTURE_TYPE_I;
2543 picture->key_frame = 1;
2544
2545 if (ret = jpeg2000_read_bitstream_packets(s))
2546 goto end;
2547
2548 avctx->execute2(avctx, jpeg2000_decode_tile, picture, NULL, s->numXtiles * s->numYtiles);
2549
2550 jpeg2000_dec_cleanup(s);
2551
2552 *got_frame = 1;
2553
2554 if (s->avctx->pix_fmt == AV_PIX_FMT_PAL8)
2555 memcpy(picture->data[1], s->palette, 256 * sizeof(uint32_t));
2556 if (s->sar.num && s->sar.den)
2557 avctx->sample_aspect_ratio = s->sar;
2558 s->sar.num = s->sar.den = 0;
2559
2560 return bytestream2_tell(&s->g);
2561
2562 end:
2563 jpeg2000_dec_cleanup(s);
2564 return ret;
2565 }
2566
2567 #define OFFSET(x) offsetof(Jpeg2000DecoderContext, x)
2568 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
2569
2570 static const AVOption options[] = {
2571 { "lowres", "Lower the decoding resolution by a power of two",
2572 OFFSET(reduction_factor), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, JPEG2000_MAX_RESLEVELS - 1, VD },
2573 { NULL },
2574 };
2575
2576 static const AVClass jpeg2000_class = {
2577 .class_name = "jpeg2000",
2578 .item_name = av_default_item_name,
2579 .option = options,
2580 .version = LIBAVUTIL_VERSION_INT,
2581 };
2582
2583 AVCodec ff_jpeg2000_decoder = {
2584 .name = "jpeg2000",
2585 .long_name = NULL_IF_CONFIG_SMALL("JPEG 2000"),
2586 .type = AVMEDIA_TYPE_VIDEO,
2587 .id = AV_CODEC_ID_JPEG2000,
2588 .capabilities = AV_CODEC_CAP_SLICE_THREADS | AV_CODEC_CAP_FRAME_THREADS | AV_CODEC_CAP_DR1,
2589 .priv_data_size = sizeof(Jpeg2000DecoderContext),
2590 .init = jpeg2000_decode_init,
2591 .decode = jpeg2000_decode_frame,
2592 .priv_class = &jpeg2000_class,
2593 .max_lowres = 5,
2594 .profiles = NULL_IF_CONFIG_SMALL(ff_jpeg2000_profiles)
2595 };
2596