2 * JPEG 2000 image decoder
3 * Copyright (c) 2007 Kamil Nowosad
4 * Copyright (c) 2013 Nicolas Bertrand <nicoinattendu@gmail.com>
6 * This file is part of FFmpeg.
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.
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.
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
25 * JPEG 2000 image decoder
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"
39 #include "bytestream.h"
43 #include "jpeg2000dsp.h"
46 #define JP2_SIG_TYPE 0x6A502020
47 #define JP2_SIG_VALUE 0x0D0A870A
48 #define JP2_CODESTREAM 0x6A703263
49 #define JP2_HEADER 0x6A703268
56 typedef struct Jpeg2000POCEntry {
65 typedef struct Jpeg2000POC {
66 Jpeg2000POCEntry poc[MAX_POCS];
71 typedef struct Jpeg2000TilePart {
72 uint8_t tile_index; // Tile index who refers the tile-part
73 const uint8_t *tp_end;
74 GetByteContext tpg; // bit stream in tile-part
77 /* RMK: For JPEG2000 DCINEMA 3 tile-parts in a tile
78 * one per component, so tile_part elements have a size of 3 */
79 typedef struct Jpeg2000Tile {
80 Jpeg2000Component *comp;
81 uint8_t properties[4];
82 Jpeg2000CodingStyle codsty[4];
83 Jpeg2000QuantStyle qntsty[4];
85 Jpeg2000TilePart tile_part[32];
86 uint16_t tp_idx; // Tile-part index
87 int coord[2][2]; // border coordinates {{x0, x1}, {y0, y1}}
90 typedef struct Jpeg2000DecoderContext {
92 AVCodecContext *avctx;
96 int image_offset_x, image_offset_y;
97 int tile_offset_x, tile_offset_y;
98 uint8_t cbps[4]; // bits per sample in particular components
99 uint8_t sgnd[4]; // if a component is signed
100 uint8_t properties[4];
105 uint32_t palette[256];
108 int tile_width, tile_height;
109 unsigned numXtiles, numYtiles;
113 Jpeg2000CodingStyle codsty[4];
114 Jpeg2000QuantStyle qntsty[4];
122 Jpeg2000DSPContext dsp;
124 /*options parameters*/
125 int reduction_factor;
126 } Jpeg2000DecoderContext;
128 /* get_bits functions for JPEG2000 packet bitstream
129 * It is a get_bit function with a bit-stuffing routine. If the value of the
130 * byte is 0xFF, the next byte includes an extra zero bit stuffed into the MSB.
131 * cf. ISO-15444-1:2002 / B.10.1 Bit-stuffing routine */
132 static int get_bits(Jpeg2000DecoderContext *s, int n)
138 if (s->bit_index == 0) {
139 s->bit_index = 7 + (bytestream2_get_byte(&s->g) != 0xFFu);
142 res |= (bytestream2_peek_byte(&s->g) >> s->bit_index) & 1;
147 static void jpeg2000_flush(Jpeg2000DecoderContext *s)
149 if (bytestream2_get_byte(&s->g) == 0xff)
150 bytestream2_skip(&s->g, 1);
154 /* decode the value stored in node */
155 static int tag_tree_decode(Jpeg2000DecoderContext *s, Jpeg2000TgtNode *node,
158 Jpeg2000TgtNode *stack[30];
159 int sp = -1, curval = 0;
162 av_log(s->avctx, AV_LOG_ERROR, "missing node\n");
163 return AVERROR_INVALIDDATA;
166 while (node && !node->vis) {
174 curval = stack[sp]->val;
176 while (curval < threshold && sp >= 0) {
177 if (curval < stack[sp]->val)
178 curval = stack[sp]->val;
179 while (curval < threshold) {
181 if ((ret = get_bits(s, 1)) > 0) {
189 stack[sp]->val = curval;
195 static int pix_fmt_match(enum AVPixelFormat pix_fmt, int components,
196 int bpc, uint32_t log2_chroma_wh, int pal8)
199 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
203 if (desc->nb_components != components) {
207 switch (components) {
209 match = match && desc->comp[3].depth >= bpc &&
210 (log2_chroma_wh >> 14 & 3) == 0 &&
211 (log2_chroma_wh >> 12 & 3) == 0;
213 match = match && desc->comp[2].depth >= bpc &&
214 (log2_chroma_wh >> 10 & 3) == desc->log2_chroma_w &&
215 (log2_chroma_wh >> 8 & 3) == desc->log2_chroma_h;
217 match = match && desc->comp[1].depth >= bpc &&
218 (log2_chroma_wh >> 6 & 3) == desc->log2_chroma_w &&
219 (log2_chroma_wh >> 4 & 3) == desc->log2_chroma_h;
222 match = match && desc->comp[0].depth >= bpc &&
223 (log2_chroma_wh >> 2 & 3) == 0 &&
224 (log2_chroma_wh & 3) == 0 &&
225 (desc->flags & AV_PIX_FMT_FLAG_PAL) == pal8 * AV_PIX_FMT_FLAG_PAL;
230 // pix_fmts with lower bpp have to be listed before
231 // similar pix_fmts with higher bpp.
232 #define RGB_PIXEL_FORMATS AV_PIX_FMT_PAL8,AV_PIX_FMT_RGB24,AV_PIX_FMT_RGBA,AV_PIX_FMT_RGB48,AV_PIX_FMT_RGBA64
233 #define GRAY_PIXEL_FORMATS AV_PIX_FMT_GRAY8,AV_PIX_FMT_GRAY8A,AV_PIX_FMT_GRAY16,AV_PIX_FMT_YA16
234 #define YUV_PIXEL_FORMATS AV_PIX_FMT_YUV410P,AV_PIX_FMT_YUV411P,AV_PIX_FMT_YUVA420P, \
235 AV_PIX_FMT_YUV420P,AV_PIX_FMT_YUV422P,AV_PIX_FMT_YUVA422P, \
236 AV_PIX_FMT_YUV440P,AV_PIX_FMT_YUV444P,AV_PIX_FMT_YUVA444P, \
237 AV_PIX_FMT_YUV420P9,AV_PIX_FMT_YUV422P9,AV_PIX_FMT_YUV444P9, \
238 AV_PIX_FMT_YUVA420P9,AV_PIX_FMT_YUVA422P9,AV_PIX_FMT_YUVA444P9, \
239 AV_PIX_FMT_YUV420P10,AV_PIX_FMT_YUV422P10,AV_PIX_FMT_YUV444P10, \
240 AV_PIX_FMT_YUVA420P10,AV_PIX_FMT_YUVA422P10,AV_PIX_FMT_YUVA444P10, \
241 AV_PIX_FMT_YUV420P12,AV_PIX_FMT_YUV422P12,AV_PIX_FMT_YUV444P12, \
242 AV_PIX_FMT_YUV420P14,AV_PIX_FMT_YUV422P14,AV_PIX_FMT_YUV444P14, \
243 AV_PIX_FMT_YUV420P16,AV_PIX_FMT_YUV422P16,AV_PIX_FMT_YUV444P16, \
244 AV_PIX_FMT_YUVA420P16,AV_PIX_FMT_YUVA422P16,AV_PIX_FMT_YUVA444P16
245 #define XYZ_PIXEL_FORMATS AV_PIX_FMT_XYZ12
247 static const enum AVPixelFormat rgb_pix_fmts[] = {RGB_PIXEL_FORMATS};
248 static const enum AVPixelFormat gray_pix_fmts[] = {GRAY_PIXEL_FORMATS};
249 static const enum AVPixelFormat yuv_pix_fmts[] = {YUV_PIXEL_FORMATS};
250 static const enum AVPixelFormat xyz_pix_fmts[] = {XYZ_PIXEL_FORMATS,
252 static const enum AVPixelFormat all_pix_fmts[] = {RGB_PIXEL_FORMATS,
257 /* marker segments */
258 /* get sizes and offsets of image, tiles; number of components */
259 static int get_siz(Jpeg2000DecoderContext *s)
263 uint32_t log2_chroma_wh = 0;
264 const enum AVPixelFormat *possible_fmts = NULL;
265 int possible_fmts_nb = 0;
268 if (bytestream2_get_bytes_left(&s->g) < 36) {
269 av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for SIZ\n");
270 return AVERROR_INVALIDDATA;
273 s->avctx->profile = bytestream2_get_be16u(&s->g); // Rsiz
274 s->width = bytestream2_get_be32u(&s->g); // Width
275 s->height = bytestream2_get_be32u(&s->g); // Height
276 s->image_offset_x = bytestream2_get_be32u(&s->g); // X0Siz
277 s->image_offset_y = bytestream2_get_be32u(&s->g); // Y0Siz
278 s->tile_width = bytestream2_get_be32u(&s->g); // XTSiz
279 s->tile_height = bytestream2_get_be32u(&s->g); // YTSiz
280 s->tile_offset_x = bytestream2_get_be32u(&s->g); // XT0Siz
281 s->tile_offset_y = bytestream2_get_be32u(&s->g); // YT0Siz
282 ncomponents = bytestream2_get_be16u(&s->g); // CSiz
284 if (s->image_offset_x || s->image_offset_y) {
285 avpriv_request_sample(s->avctx, "Support for image offsets");
286 return AVERROR_PATCHWELCOME;
288 if (av_image_check_size2(s->width, s->height, s->avctx->max_pixels, AV_PIX_FMT_NONE, 0, s->avctx)) {
289 avpriv_request_sample(s->avctx, "Large Dimensions");
290 return AVERROR_PATCHWELCOME;
293 if (ncomponents <= 0) {
294 av_log(s->avctx, AV_LOG_ERROR, "Invalid number of components: %d\n",
296 return AVERROR_INVALIDDATA;
299 if (ncomponents > 4) {
300 avpriv_request_sample(s->avctx, "Support for %d components",
302 return AVERROR_PATCHWELCOME;
305 if (s->tile_offset_x < 0 || s->tile_offset_y < 0 ||
306 s->image_offset_x < s->tile_offset_x ||
307 s->image_offset_y < s->tile_offset_y ||
308 s->tile_width + (int64_t)s->tile_offset_x <= s->image_offset_x ||
309 s->tile_height + (int64_t)s->tile_offset_y <= s->image_offset_y
311 av_log(s->avctx, AV_LOG_ERROR, "Tile offsets are invalid\n");
312 return AVERROR_INVALIDDATA;
315 s->ncomponents = ncomponents;
317 if (s->tile_width <= 0 || s->tile_height <= 0) {
318 av_log(s->avctx, AV_LOG_ERROR, "Invalid tile dimension %dx%d.\n",
319 s->tile_width, s->tile_height);
320 return AVERROR_INVALIDDATA;
323 if (bytestream2_get_bytes_left(&s->g) < 3 * s->ncomponents) {
324 av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for %d components in SIZ\n", s->ncomponents);
325 return AVERROR_INVALIDDATA;
328 for (i = 0; i < s->ncomponents; i++) { // Ssiz_i XRsiz_i, YRsiz_i
329 uint8_t x = bytestream2_get_byteu(&s->g);
330 s->cbps[i] = (x & 0x7f) + 1;
331 s->precision = FFMAX(s->cbps[i], s->precision);
332 s->sgnd[i] = !!(x & 0x80);
333 s->cdx[i] = bytestream2_get_byteu(&s->g);
334 s->cdy[i] = bytestream2_get_byteu(&s->g);
335 if ( !s->cdx[i] || s->cdx[i] == 3 || s->cdx[i] > 4
336 || !s->cdy[i] || s->cdy[i] == 3 || s->cdy[i] > 4) {
337 av_log(s->avctx, AV_LOG_ERROR, "Invalid sample separation %d/%d\n", s->cdx[i], s->cdy[i]);
338 return AVERROR_INVALIDDATA;
340 log2_chroma_wh |= s->cdy[i] >> 1 << i * 4 | s->cdx[i] >> 1 << i * 4 + 2;
343 s->numXtiles = ff_jpeg2000_ceildiv(s->width - s->tile_offset_x, s->tile_width);
344 s->numYtiles = ff_jpeg2000_ceildiv(s->height - s->tile_offset_y, s->tile_height);
346 // There must be at least a SOT and SOD per tile, their minimum size is 14
347 if (s->numXtiles * (uint64_t)s->numYtiles > INT_MAX/sizeof(*s->tile) ||
348 s->numXtiles * s->numYtiles * 14LL > bytestream2_size(&s->g)
350 s->numXtiles = s->numYtiles = 0;
351 return AVERROR(EINVAL);
354 s->tile = av_mallocz_array(s->numXtiles * s->numYtiles, sizeof(*s->tile));
356 s->numXtiles = s->numYtiles = 0;
357 return AVERROR(ENOMEM);
360 for (i = 0; i < s->numXtiles * s->numYtiles; i++) {
361 Jpeg2000Tile *tile = s->tile + i;
363 tile->comp = av_mallocz(s->ncomponents * sizeof(*tile->comp));
365 return AVERROR(ENOMEM);
368 /* compute image size with reduction factor */
369 ret = ff_set_dimensions(s->avctx,
370 ff_jpeg2000_ceildivpow2(s->width - s->image_offset_x,
371 s->reduction_factor),
372 ff_jpeg2000_ceildivpow2(s->height - s->image_offset_y,
373 s->reduction_factor));
377 if (s->avctx->profile == FF_PROFILE_JPEG2000_DCINEMA_2K ||
378 s->avctx->profile == FF_PROFILE_JPEG2000_DCINEMA_4K) {
379 possible_fmts = xyz_pix_fmts;
380 possible_fmts_nb = FF_ARRAY_ELEMS(xyz_pix_fmts);
382 switch (s->colour_space) {
384 possible_fmts = rgb_pix_fmts;
385 possible_fmts_nb = FF_ARRAY_ELEMS(rgb_pix_fmts);
388 possible_fmts = gray_pix_fmts;
389 possible_fmts_nb = FF_ARRAY_ELEMS(gray_pix_fmts);
392 possible_fmts = yuv_pix_fmts;
393 possible_fmts_nb = FF_ARRAY_ELEMS(yuv_pix_fmts);
396 possible_fmts = all_pix_fmts;
397 possible_fmts_nb = FF_ARRAY_ELEMS(all_pix_fmts);
401 for (i = 0; i < possible_fmts_nb; ++i) {
402 if (pix_fmt_match(possible_fmts[i], ncomponents, s->precision, log2_chroma_wh, s->pal8)) {
403 s->avctx->pix_fmt = possible_fmts[i];
408 if (i == possible_fmts_nb) {
409 if (ncomponents == 4 &&
410 s->cdy[0] == 1 && s->cdx[0] == 1 &&
411 s->cdy[1] == 1 && s->cdx[1] == 1 &&
412 s->cdy[2] == s->cdy[3] && s->cdx[2] == s->cdx[3]) {
413 if (s->precision == 8 && s->cdy[2] == 2 && s->cdx[2] == 2 && !s->pal8) {
414 s->avctx->pix_fmt = AV_PIX_FMT_YUVA420P;
425 if (i == possible_fmts_nb) {
426 av_log(s->avctx, AV_LOG_ERROR,
427 "Unknown pix_fmt, profile: %d, colour_space: %d, "
428 "components: %d, precision: %d\n"
429 "cdx[0]: %d, cdy[0]: %d\n"
430 "cdx[1]: %d, cdy[1]: %d\n"
431 "cdx[2]: %d, cdy[2]: %d\n"
432 "cdx[3]: %d, cdy[3]: %d\n",
433 s->avctx->profile, s->colour_space, ncomponents, s->precision,
436 ncomponents > 1 ? s->cdx[1] : 0,
437 ncomponents > 1 ? s->cdy[1] : 0,
438 ncomponents > 2 ? s->cdx[2] : 0,
439 ncomponents > 2 ? s->cdy[2] : 0,
440 ncomponents > 3 ? s->cdx[3] : 0,
441 ncomponents > 3 ? s->cdy[3] : 0);
442 return AVERROR_PATCHWELCOME;
444 s->avctx->bits_per_raw_sample = s->precision;
448 /* get common part for COD and COC segments */
449 static int get_cox(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c)
453 if (bytestream2_get_bytes_left(&s->g) < 5) {
454 av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for COX\n");
455 return AVERROR_INVALIDDATA;
458 /* nreslevels = number of resolution levels
459 = number of decomposition level +1 */
460 c->nreslevels = bytestream2_get_byteu(&s->g) + 1;
461 if (c->nreslevels >= JPEG2000_MAX_RESLEVELS) {
462 av_log(s->avctx, AV_LOG_ERROR, "nreslevels %d is invalid\n", c->nreslevels);
463 return AVERROR_INVALIDDATA;
466 if (c->nreslevels <= s->reduction_factor) {
467 /* we are forced to update reduction_factor as its requested value is
468 not compatible with this bitstream, and as we might have used it
469 already in setup earlier we have to fail this frame until
470 reinitialization is implemented */
471 av_log(s->avctx, AV_LOG_ERROR, "reduction_factor too large for this bitstream, max is %d\n", c->nreslevels - 1);
472 s->reduction_factor = c->nreslevels - 1;
473 return AVERROR(EINVAL);
476 /* compute number of resolution levels to decode */
477 c->nreslevels2decode = c->nreslevels - s->reduction_factor;
479 c->log2_cblk_width = (bytestream2_get_byteu(&s->g) & 15) + 2; // cblk width
480 c->log2_cblk_height = (bytestream2_get_byteu(&s->g) & 15) + 2; // cblk height
482 if (c->log2_cblk_width > 10 || c->log2_cblk_height > 10 ||
483 c->log2_cblk_width + c->log2_cblk_height > 12) {
484 av_log(s->avctx, AV_LOG_ERROR, "cblk size invalid\n");
485 return AVERROR_INVALIDDATA;
488 c->cblk_style = bytestream2_get_byteu(&s->g);
489 if (c->cblk_style != 0) { // cblk style
490 av_log(s->avctx, AV_LOG_WARNING, "extra cblk styles %X\n", c->cblk_style);
491 if (c->cblk_style & JPEG2000_CBLK_BYPASS)
492 av_log(s->avctx, AV_LOG_WARNING, "Selective arithmetic coding bypass\n");
494 c->transform = bytestream2_get_byteu(&s->g); // DWT transformation type
495 /* set integer 9/7 DWT in case of BITEXACT flag */
496 if ((s->avctx->flags & AV_CODEC_FLAG_BITEXACT) && (c->transform == FF_DWT97))
497 c->transform = FF_DWT97_INT;
498 else if (c->transform == FF_DWT53) {
499 s->avctx->properties |= FF_CODEC_PROPERTY_LOSSLESS;
502 if (c->csty & JPEG2000_CSTY_PREC) {
504 for (i = 0; i < c->nreslevels; i++) {
505 byte = bytestream2_get_byte(&s->g);
506 c->log2_prec_widths[i] = byte & 0x0F; // precinct PPx
507 c->log2_prec_heights[i] = (byte >> 4) & 0x0F; // precinct PPy
509 if (c->log2_prec_widths[i] == 0 || c->log2_prec_heights[i] == 0) {
510 av_log(s->avctx, AV_LOG_ERROR, "PPx %d PPy %d invalid\n",
511 c->log2_prec_widths[i], c->log2_prec_heights[i]);
512 c->log2_prec_widths[i] = c->log2_prec_heights[i] = 1;
513 return AVERROR_INVALIDDATA;
517 memset(c->log2_prec_widths , 15, sizeof(c->log2_prec_widths ));
518 memset(c->log2_prec_heights, 15, sizeof(c->log2_prec_heights));
523 /* get coding parameters for a particular tile or whole image*/
524 static int get_cod(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c,
527 Jpeg2000CodingStyle tmp;
530 if (bytestream2_get_bytes_left(&s->g) < 5) {
531 av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for COD\n");
532 return AVERROR_INVALIDDATA;
535 tmp.csty = bytestream2_get_byteu(&s->g);
537 // get progression order
538 tmp.prog_order = bytestream2_get_byteu(&s->g);
540 tmp.nlayers = bytestream2_get_be16u(&s->g);
541 tmp.mct = bytestream2_get_byteu(&s->g); // multiple component transformation
543 if (tmp.mct && s->ncomponents < 3) {
544 av_log(s->avctx, AV_LOG_ERROR,
545 "MCT %"PRIu8" with too few components (%d)\n",
546 tmp.mct, s->ncomponents);
547 return AVERROR_INVALIDDATA;
550 if ((ret = get_cox(s, &tmp)) < 0)
553 for (compno = 0; compno < s->ncomponents; compno++)
554 if (!(properties[compno] & HAD_COC))
555 memcpy(c + compno, &tmp, sizeof(tmp));
559 /* Get coding parameters for a component in the whole image or a
560 * particular tile. */
561 static int get_coc(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c,
566 if (bytestream2_get_bytes_left(&s->g) < 2) {
567 av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for COC\n");
568 return AVERROR_INVALIDDATA;
571 compno = bytestream2_get_byteu(&s->g);
573 if (compno >= s->ncomponents) {
574 av_log(s->avctx, AV_LOG_ERROR,
575 "Invalid compno %d. There are %d components in the image.\n",
576 compno, s->ncomponents);
577 return AVERROR_INVALIDDATA;
581 c->csty = bytestream2_get_byteu(&s->g);
583 if ((ret = get_cox(s, c)) < 0)
586 properties[compno] |= HAD_COC;
590 /* Get common part for QCD and QCC segments. */
591 static int get_qcx(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q)
595 if (bytestream2_get_bytes_left(&s->g) < 1)
596 return AVERROR_INVALIDDATA;
598 x = bytestream2_get_byteu(&s->g); // Sqcd
600 q->nguardbits = x >> 5;
601 q->quantsty = x & 0x1f;
603 if (q->quantsty == JPEG2000_QSTY_NONE) {
605 if (bytestream2_get_bytes_left(&s->g) < n ||
606 n > JPEG2000_MAX_DECLEVELS*3)
607 return AVERROR_INVALIDDATA;
608 for (i = 0; i < n; i++)
609 q->expn[i] = bytestream2_get_byteu(&s->g) >> 3;
610 } else if (q->quantsty == JPEG2000_QSTY_SI) {
611 if (bytestream2_get_bytes_left(&s->g) < 2)
612 return AVERROR_INVALIDDATA;
613 x = bytestream2_get_be16u(&s->g);
614 q->expn[0] = x >> 11;
615 q->mant[0] = x & 0x7ff;
616 for (i = 1; i < JPEG2000_MAX_DECLEVELS * 3; i++) {
617 int curexpn = FFMAX(0, q->expn[0] - (i - 1) / 3);
618 q->expn[i] = curexpn;
619 q->mant[i] = q->mant[0];
623 if (bytestream2_get_bytes_left(&s->g) < 2 * n ||
624 n > JPEG2000_MAX_DECLEVELS*3)
625 return AVERROR_INVALIDDATA;
626 for (i = 0; i < n; i++) {
627 x = bytestream2_get_be16u(&s->g);
628 q->expn[i] = x >> 11;
629 q->mant[i] = x & 0x7ff;
635 /* Get quantization parameters for a particular tile or a whole image. */
636 static int get_qcd(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q,
639 Jpeg2000QuantStyle tmp;
642 memset(&tmp, 0, sizeof(tmp));
644 if ((ret = get_qcx(s, n, &tmp)) < 0)
646 for (compno = 0; compno < s->ncomponents; compno++)
647 if (!(properties[compno] & HAD_QCC))
648 memcpy(q + compno, &tmp, sizeof(tmp));
652 /* Get quantization parameters for a component in the whole image
653 * on in a particular tile. */
654 static int get_qcc(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q,
659 if (bytestream2_get_bytes_left(&s->g) < 1)
660 return AVERROR_INVALIDDATA;
662 compno = bytestream2_get_byteu(&s->g);
664 if (compno >= s->ncomponents) {
665 av_log(s->avctx, AV_LOG_ERROR,
666 "Invalid compno %d. There are %d components in the image.\n",
667 compno, s->ncomponents);
668 return AVERROR_INVALIDDATA;
671 properties[compno] |= HAD_QCC;
672 return get_qcx(s, n - 1, q + compno);
675 static int get_poc(Jpeg2000DecoderContext *s, int size, Jpeg2000POC *p)
678 int elem_size = s->ncomponents <= 257 ? 7 : 9;
679 Jpeg2000POC tmp = {{{0}}};
681 if (bytestream2_get_bytes_left(&s->g) < 5 || size < 2 + elem_size) {
682 av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for POC\n");
683 return AVERROR_INVALIDDATA;
687 avpriv_request_sample(s->avctx, "Fat POC not supported");
688 return AVERROR_PATCHWELCOME;
691 tmp.nb_poc = (size - 2) / elem_size;
692 if (tmp.nb_poc > MAX_POCS) {
693 avpriv_request_sample(s->avctx, "Too many POCs (%d)", tmp.nb_poc);
694 return AVERROR_PATCHWELCOME;
697 for (i = 0; i<tmp.nb_poc; i++) {
698 Jpeg2000POCEntry *e = &tmp.poc[i];
699 e->RSpoc = bytestream2_get_byteu(&s->g);
700 e->CSpoc = bytestream2_get_byteu(&s->g);
701 e->LYEpoc = bytestream2_get_be16u(&s->g);
702 e->REpoc = bytestream2_get_byteu(&s->g);
703 e->CEpoc = bytestream2_get_byteu(&s->g);
704 e->Ppoc = bytestream2_get_byteu(&s->g);
707 if (e->CEpoc > s->ncomponents)
708 e->CEpoc = s->ncomponents;
709 if ( e->RSpoc >= e->REpoc || e->REpoc > 33
710 || e->CSpoc >= e->CEpoc || e->CEpoc > s->ncomponents
712 av_log(s->avctx, AV_LOG_ERROR, "POC Entry %d is invalid (%d, %d, %d, %d, %d, %d)\n", i,
713 e->RSpoc, e->CSpoc, e->LYEpoc, e->REpoc, e->CEpoc, e->Ppoc
715 return AVERROR_INVALIDDATA;
719 if (!p->nb_poc || p->is_default) {
722 if (p->nb_poc + tmp.nb_poc > MAX_POCS) {
723 av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for POC\n");
724 return AVERROR_INVALIDDATA;
726 memcpy(p->poc + p->nb_poc, tmp.poc, tmp.nb_poc * sizeof(tmp.poc[0]));
727 p->nb_poc += tmp.nb_poc;
736 /* Get start of tile segment. */
737 static int get_sot(Jpeg2000DecoderContext *s, int n)
739 Jpeg2000TilePart *tp;
744 if (bytestream2_get_bytes_left(&s->g) < 8)
745 return AVERROR_INVALIDDATA;
748 Isot = bytestream2_get_be16u(&s->g); // Isot
749 if (Isot >= s->numXtiles * s->numYtiles)
750 return AVERROR_INVALIDDATA;
753 Psot = bytestream2_get_be32u(&s->g); // Psot
754 TPsot = bytestream2_get_byteu(&s->g); // TPsot
756 /* Read TNSot but not used */
757 bytestream2_get_byteu(&s->g); // TNsot
760 Psot = bytestream2_get_bytes_left(&s->g) - 2 + n + 2;
762 if (Psot > bytestream2_get_bytes_left(&s->g) - 2 + n + 2) {
763 av_log(s->avctx, AV_LOG_ERROR, "Psot %"PRIu32" too big\n", Psot);
764 return AVERROR_INVALIDDATA;
767 if (TPsot >= FF_ARRAY_ELEMS(s->tile[Isot].tile_part)) {
768 avpriv_request_sample(s->avctx, "Too many tile parts");
769 return AVERROR_PATCHWELCOME;
772 s->tile[Isot].tp_idx = TPsot;
773 tp = s->tile[Isot].tile_part + TPsot;
774 tp->tile_index = Isot;
775 tp->tp_end = s->g.buffer + Psot - n - 2;
778 Jpeg2000Tile *tile = s->tile + s->curtileno;
781 memcpy(tile->codsty, s->codsty, s->ncomponents * sizeof(Jpeg2000CodingStyle));
782 memcpy(tile->qntsty, s->qntsty, s->ncomponents * sizeof(Jpeg2000QuantStyle));
783 memcpy(&tile->poc , &s->poc , sizeof(tile->poc));
784 tile->poc.is_default = 1;
790 /* Tile-part lengths: see ISO 15444-1:2002, section A.7.1
791 * Used to know the number of tile parts and lengths.
792 * There may be multiple TLMs in the header.
793 * TODO: The function is not used for tile-parts management, nor anywhere else.
794 * It can be useful to allocate memory for tile parts, before managing the SOT
795 * markers. Parsing the TLM header is needed to increment the input header
797 * This marker is mandatory for DCI. */
798 static uint8_t get_tlm(Jpeg2000DecoderContext *s, int n)
800 uint8_t Stlm, ST, SP, tile_tlm, i;
801 bytestream2_get_byte(&s->g); /* Ztlm: skipped */
802 Stlm = bytestream2_get_byte(&s->g);
804 // too complex ? ST = ((Stlm >> 4) & 0x01) + ((Stlm >> 4) & 0x02);
805 ST = (Stlm >> 4) & 0x03;
806 // TODO: Manage case of ST = 0b11 --> raise error
807 SP = (Stlm >> 6) & 0x01;
808 tile_tlm = (n - 4) / ((SP + 1) * 2 + ST);
809 for (i = 0; i < tile_tlm; i++) {
814 bytestream2_get_byte(&s->g);
817 bytestream2_get_be16(&s->g);
820 bytestream2_get_be32(&s->g);
824 bytestream2_get_be16(&s->g);
826 bytestream2_get_be32(&s->g);
832 static int get_plt(Jpeg2000DecoderContext *s, int n)
837 av_log(s->avctx, AV_LOG_DEBUG,
838 "PLT marker at pos 0x%X\n", bytestream2_tell(&s->g) - 4);
841 return AVERROR_INVALIDDATA;
843 /*Zplt =*/ bytestream2_get_byte(&s->g);
845 for (i = 0; i < n - 3; i++) {
846 v = bytestream2_get_byte(&s->g);
849 return AVERROR_INVALIDDATA;
854 static int init_tile(Jpeg2000DecoderContext *s, int tileno)
857 int tilex = tileno % s->numXtiles;
858 int tiley = tileno / s->numXtiles;
859 Jpeg2000Tile *tile = s->tile + tileno;
862 return AVERROR(ENOMEM);
864 tile->coord[0][0] = av_clip(tilex * (int64_t)s->tile_width + s->tile_offset_x, s->image_offset_x, s->width);
865 tile->coord[0][1] = av_clip((tilex + 1) * (int64_t)s->tile_width + s->tile_offset_x, s->image_offset_x, s->width);
866 tile->coord[1][0] = av_clip(tiley * (int64_t)s->tile_height + s->tile_offset_y, s->image_offset_y, s->height);
867 tile->coord[1][1] = av_clip((tiley + 1) * (int64_t)s->tile_height + s->tile_offset_y, s->image_offset_y, s->height);
869 for (compno = 0; compno < s->ncomponents; compno++) {
870 Jpeg2000Component *comp = tile->comp + compno;
871 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
872 Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
873 int ret; // global bandno
875 comp->coord_o[0][0] = tile->coord[0][0];
876 comp->coord_o[0][1] = tile->coord[0][1];
877 comp->coord_o[1][0] = tile->coord[1][0];
878 comp->coord_o[1][1] = tile->coord[1][1];
880 comp->coord_o[0][0] /= s->cdx[compno];
881 comp->coord_o[0][1] /= s->cdx[compno];
882 comp->coord_o[1][0] /= s->cdy[compno];
883 comp->coord_o[1][1] /= s->cdy[compno];
886 comp->coord[0][0] = ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], s->reduction_factor);
887 comp->coord[0][1] = ff_jpeg2000_ceildivpow2(comp->coord_o[0][1], s->reduction_factor);
888 comp->coord[1][0] = ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], s->reduction_factor);
889 comp->coord[1][1] = ff_jpeg2000_ceildivpow2(comp->coord_o[1][1], s->reduction_factor);
891 if (ret = ff_jpeg2000_init_component(comp, codsty, qntsty,
892 s->cbps[compno], s->cdx[compno],
893 s->cdy[compno], s->avctx))
899 /* Read the number of coding passes. */
900 static int getnpasses(Jpeg2000DecoderContext *s)
907 if ((num = get_bits(s, 2)) != 3)
908 return num < 0 ? num : 3 + num;
909 if ((num = get_bits(s, 5)) != 31)
910 return num < 0 ? num : 6 + num;
911 num = get_bits(s, 7);
912 return num < 0 ? num : 37 + num;
915 static int getlblockinc(Jpeg2000DecoderContext *s)
918 while (ret = get_bits(s, 1)) {
926 static int jpeg2000_decode_packet(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile, int *tp_index,
927 Jpeg2000CodingStyle *codsty,
928 Jpeg2000ResLevel *rlevel, int precno,
929 int layno, uint8_t *expn, int numgbits)
931 int bandno, cblkno, ret, nb_code_blocks;
934 if (layno < rlevel->band[0].prec[precno].decoded_layers)
936 rlevel->band[0].prec[precno].decoded_layers = layno + 1;
938 if (bytestream2_get_bytes_left(&s->g) == 0 && s->bit_index == 8) {
939 if (*tp_index < FF_ARRAY_ELEMS(tile->tile_part) - 1) {
940 s->g = tile->tile_part[++(*tp_index)].tpg;
944 if (bytestream2_peek_be32(&s->g) == JPEG2000_SOP_FIXED_BYTES)
945 bytestream2_skip(&s->g, JPEG2000_SOP_BYTE_LENGTH);
947 if (!(ret = get_bits(s, 1))) {
953 for (bandno = 0; bandno < rlevel->nbands; bandno++) {
954 Jpeg2000Band *band = rlevel->band + bandno;
955 Jpeg2000Prec *prec = band->prec + precno;
957 if (band->coord[0][0] == band->coord[0][1] ||
958 band->coord[1][0] == band->coord[1][1])
960 nb_code_blocks = prec->nb_codeblocks_height *
961 prec->nb_codeblocks_width;
962 for (cblkno = 0; cblkno < nb_code_blocks; cblkno++) {
963 Jpeg2000Cblk *cblk = prec->cblk + cblkno;
964 int incl, newpasses, llen;
968 incl = get_bits(s, 1);
970 incl = tag_tree_decode(s, prec->cblkincl + cblkno, layno + 1) == layno;
976 if (!cblk->npasses) {
977 int v = expn[bandno] + numgbits - 1 -
978 tag_tree_decode(s, prec->zerobits + cblkno, 100);
979 if (v < 0 || v > 30) {
980 av_log(s->avctx, AV_LOG_ERROR,
981 "nonzerobits %d invalid or unsupported\n", v);
982 return AVERROR_INVALIDDATA;
984 cblk->nonzerobits = v;
986 if ((newpasses = getnpasses(s)) < 0)
988 av_assert2(newpasses > 0);
989 if (cblk->npasses + newpasses >= JPEG2000_MAX_PASSES) {
990 avpriv_request_sample(s->avctx, "Too many passes");
991 return AVERROR_PATCHWELCOME;
993 if ((llen = getlblockinc(s)) < 0)
995 if (cblk->lblock + llen + av_log2(newpasses) > 16) {
996 avpriv_request_sample(s->avctx,
997 "Block with length beyond 16 bits");
998 return AVERROR_PATCHWELCOME;
1001 cblk->lblock += llen;
1003 cblk->nb_lengthinc = 0;
1004 cblk->nb_terminationsinc = 0;
1005 av_free(cblk->lengthinc);
1006 cblk->lengthinc = av_mallocz_array(newpasses , sizeof(*cblk->lengthinc));
1007 if (!cblk->lengthinc)
1008 return AVERROR(ENOMEM);
1009 tmp = av_realloc_array(cblk->data_start, cblk->nb_terminations + newpasses + 1, sizeof(*cblk->data_start));
1011 return AVERROR(ENOMEM);
1012 cblk->data_start = tmp;
1016 while (newpasses1 < newpasses) {
1018 if (needs_termination(codsty->cblk_style, cblk->npasses + newpasses1 - 1)) {
1019 cblk->nb_terminationsinc ++;
1024 if ((ret = get_bits(s, av_log2(newpasses1) + cblk->lblock)) < 0)
1026 if (ret > cblk->data_allocated) {
1027 size_t new_size = FFMAX(2*cblk->data_allocated, ret);
1028 void *new = av_realloc(cblk->data, new_size);
1031 cblk->data_allocated = new_size;
1034 if (ret > cblk->data_allocated) {
1035 avpriv_request_sample(s->avctx,
1036 "Block with lengthinc greater than %"SIZE_SPECIFIER"",
1037 cblk->data_allocated);
1038 return AVERROR_PATCHWELCOME;
1040 cblk->lengthinc[cblk->nb_lengthinc++] = ret;
1041 cblk->npasses += newpasses1;
1042 newpasses -= newpasses1;
1048 if (codsty->csty & JPEG2000_CSTY_EPH) {
1049 if (bytestream2_peek_be16(&s->g) == JPEG2000_EPH)
1050 bytestream2_skip(&s->g, 2);
1052 av_log(s->avctx, AV_LOG_ERROR, "EPH marker not found. instead %X\n", bytestream2_peek_be32(&s->g));
1055 for (bandno = 0; bandno < rlevel->nbands; bandno++) {
1056 Jpeg2000Band *band = rlevel->band + bandno;
1057 Jpeg2000Prec *prec = band->prec + precno;
1059 nb_code_blocks = prec->nb_codeblocks_height * prec->nb_codeblocks_width;
1060 for (cblkno = 0; cblkno < nb_code_blocks; cblkno++) {
1061 Jpeg2000Cblk *cblk = prec->cblk + cblkno;
1062 if (!cblk->nb_terminationsinc && !cblk->lengthinc)
1064 for (cwsno = 0; cwsno < cblk->nb_lengthinc; cwsno ++) {
1065 if (cblk->data_allocated < cblk->length + cblk->lengthinc[cwsno] + 4) {
1066 size_t new_size = FFMAX(2*cblk->data_allocated, cblk->length + cblk->lengthinc[cwsno] + 4);
1067 void *new = av_realloc(cblk->data, new_size);
1070 cblk->data_allocated = new_size;
1073 if ( bytestream2_get_bytes_left(&s->g) < cblk->lengthinc[cwsno]
1074 || cblk->data_allocated < cblk->length + cblk->lengthinc[cwsno] + 4
1076 av_log(s->avctx, AV_LOG_ERROR,
1077 "Block length %"PRIu16" or lengthinc %d is too large, left %d\n",
1078 cblk->length, cblk->lengthinc[cwsno], bytestream2_get_bytes_left(&s->g));
1079 return AVERROR_INVALIDDATA;
1082 bytestream2_get_bufferu(&s->g, cblk->data + cblk->length, cblk->lengthinc[cwsno]);
1083 cblk->length += cblk->lengthinc[cwsno];
1084 cblk->lengthinc[cwsno] = 0;
1085 if (cblk->nb_terminationsinc) {
1086 cblk->nb_terminationsinc--;
1087 cblk->nb_terminations++;
1088 cblk->data[cblk->length++] = 0xFF;
1089 cblk->data[cblk->length++] = 0xFF;
1090 cblk->data_start[cblk->nb_terminations] = cblk->length;
1093 av_freep(&cblk->lengthinc);
1099 static int jpeg2000_decode_packets_po_iteration(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile,
1100 int RSpoc, int CSpoc,
1101 int LYEpoc, int REpoc, int CEpoc,
1102 int Ppoc, int *tp_index)
1105 int layno, reslevelno, compno, precno, ok_reslevel;
1110 case JPEG2000_PGOD_RLCP:
1111 av_log(s->avctx, AV_LOG_DEBUG, "Progression order RLCP\n");
1113 for (reslevelno = RSpoc; ok_reslevel && reslevelno < REpoc; reslevelno++) {
1115 for (layno = 0; layno < LYEpoc; layno++) {
1116 for (compno = CSpoc; compno < CEpoc; compno++) {
1117 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1118 Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
1119 if (reslevelno < codsty->nreslevels) {
1120 Jpeg2000ResLevel *rlevel = tile->comp[compno].reslevel +
1123 for (precno = 0; precno < rlevel->num_precincts_x * rlevel->num_precincts_y; precno++)
1124 if ((ret = jpeg2000_decode_packet(s, tile, tp_index,
1127 qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1128 qntsty->nguardbits)) < 0)
1136 case JPEG2000_PGOD_LRCP:
1137 av_log(s->avctx, AV_LOG_DEBUG, "Progression order LRCP\n");
1138 for (layno = 0; layno < LYEpoc; layno++) {
1140 for (reslevelno = RSpoc; ok_reslevel && reslevelno < REpoc; reslevelno++) {
1142 for (compno = CSpoc; compno < CEpoc; compno++) {
1143 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1144 Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
1145 if (reslevelno < codsty->nreslevels) {
1146 Jpeg2000ResLevel *rlevel = tile->comp[compno].reslevel +
1149 for (precno = 0; precno < rlevel->num_precincts_x * rlevel->num_precincts_y; precno++)
1150 if ((ret = jpeg2000_decode_packet(s, tile, tp_index,
1153 qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1154 qntsty->nguardbits)) < 0)
1162 case JPEG2000_PGOD_CPRL:
1163 av_log(s->avctx, AV_LOG_DEBUG, "Progression order CPRL\n");
1164 for (compno = CSpoc; compno < CEpoc; compno++) {
1165 Jpeg2000Component *comp = tile->comp + compno;
1166 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1167 Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
1171 if (RSpoc >= FFMIN(codsty->nreslevels, REpoc))
1174 for (reslevelno = RSpoc; reslevelno < FFMIN(codsty->nreslevels, REpoc); reslevelno++) {
1175 uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1176 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1177 step_x = FFMIN(step_x, rlevel->log2_prec_width + reducedresno);
1178 step_y = FFMIN(step_y, rlevel->log2_prec_height + reducedresno);
1180 if (step_x >= 31 || step_y >= 31){
1181 avpriv_request_sample(s->avctx, "CPRL with large step");
1182 return AVERROR_PATCHWELCOME;
1187 for (y = tile->coord[1][0]; y < tile->coord[1][1]; y = (y/step_y + 1)*step_y) {
1188 for (x = tile->coord[0][0]; x < tile->coord[0][1]; x = (x/step_x + 1)*step_x) {
1189 for (reslevelno = RSpoc; reslevelno < FFMIN(codsty->nreslevels, REpoc); reslevelno++) {
1190 unsigned prcx, prcy;
1191 uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1192 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1193 int xc = x / s->cdx[compno];
1194 int yc = y / s->cdy[compno];
1196 if (yc % (1LL << (rlevel->log2_prec_height + reducedresno)) && y != tile->coord[1][0]) //FIXME this is a subset of the check
1199 if (xc % (1LL << (rlevel->log2_prec_width + reducedresno)) && x != tile->coord[0][0]) //FIXME this is a subset of the check
1202 // check if a precinct exists
1203 prcx = ff_jpeg2000_ceildivpow2(xc, reducedresno) >> rlevel->log2_prec_width;
1204 prcy = ff_jpeg2000_ceildivpow2(yc, reducedresno) >> rlevel->log2_prec_height;
1205 prcx -= ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], reducedresno) >> rlevel->log2_prec_width;
1206 prcy -= ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], reducedresno) >> rlevel->log2_prec_height;
1208 precno = prcx + rlevel->num_precincts_x * prcy;
1210 if (prcx >= rlevel->num_precincts_x || prcy >= rlevel->num_precincts_y) {
1211 av_log(s->avctx, AV_LOG_WARNING, "prc %d %d outside limits %d %d\n",
1212 prcx, prcy, rlevel->num_precincts_x, rlevel->num_precincts_y);
1216 for (layno = 0; layno < LYEpoc; layno++) {
1217 if ((ret = jpeg2000_decode_packet(s, tile, tp_index, codsty, rlevel,
1219 qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1220 qntsty->nguardbits)) < 0)
1229 case JPEG2000_PGOD_RPCL:
1230 av_log(s->avctx, AV_LOG_WARNING, "Progression order RPCL\n");
1232 for (reslevelno = RSpoc; ok_reslevel && reslevelno < REpoc; reslevelno++) {
1236 for (compno = CSpoc; compno < CEpoc; compno++) {
1237 Jpeg2000Component *comp = tile->comp + compno;
1238 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1240 if (reslevelno < codsty->nreslevels) {
1241 uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1242 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1243 step_x = FFMIN(step_x, rlevel->log2_prec_width + reducedresno);
1244 step_y = FFMIN(step_y, rlevel->log2_prec_height + reducedresno);
1250 for (y = tile->coord[1][0]; y < tile->coord[1][1]; y = (y/step_y + 1)*step_y) {
1251 for (x = tile->coord[0][0]; x < tile->coord[0][1]; x = (x/step_x + 1)*step_x) {
1252 for (compno = CSpoc; compno < CEpoc; compno++) {
1253 Jpeg2000Component *comp = tile->comp + compno;
1254 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1255 Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
1256 uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1257 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1258 unsigned prcx, prcy;
1260 int xc = x / s->cdx[compno];
1261 int yc = y / s->cdy[compno];
1263 if (reslevelno >= codsty->nreslevels)
1266 if (yc % (1LL << (rlevel->log2_prec_height + reducedresno)) && y != tile->coord[1][0]) //FIXME this is a subset of the check
1269 if (xc % (1LL << (rlevel->log2_prec_width + reducedresno)) && x != tile->coord[0][0]) //FIXME this is a subset of the check
1272 // check if a precinct exists
1273 prcx = ff_jpeg2000_ceildivpow2(xc, reducedresno) >> rlevel->log2_prec_width;
1274 prcy = ff_jpeg2000_ceildivpow2(yc, reducedresno) >> rlevel->log2_prec_height;
1275 prcx -= ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], reducedresno) >> rlevel->log2_prec_width;
1276 prcy -= ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], reducedresno) >> rlevel->log2_prec_height;
1278 precno = prcx + rlevel->num_precincts_x * prcy;
1281 if (prcx >= rlevel->num_precincts_x || prcy >= rlevel->num_precincts_y) {
1282 av_log(s->avctx, AV_LOG_WARNING, "prc %d %d outside limits %d %d\n",
1283 prcx, prcy, rlevel->num_precincts_x, rlevel->num_precincts_y);
1287 for (layno = 0; layno < LYEpoc; layno++) {
1288 if ((ret = jpeg2000_decode_packet(s, tile, tp_index,
1291 qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1292 qntsty->nguardbits)) < 0)
1301 case JPEG2000_PGOD_PCRL:
1302 av_log(s->avctx, AV_LOG_WARNING, "Progression order PCRL\n");
1305 for (compno = CSpoc; compno < CEpoc; compno++) {
1306 Jpeg2000Component *comp = tile->comp + compno;
1307 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1309 for (reslevelno = RSpoc; reslevelno < FFMIN(codsty->nreslevels, REpoc); reslevelno++) {
1310 uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1311 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1312 step_x = FFMIN(step_x, rlevel->log2_prec_width + reducedresno);
1313 step_y = FFMIN(step_y, rlevel->log2_prec_height + reducedresno);
1316 if (step_x >= 31 || step_y >= 31){
1317 avpriv_request_sample(s->avctx, "PCRL with large step");
1318 return AVERROR_PATCHWELCOME;
1323 for (y = tile->coord[1][0]; y < tile->coord[1][1]; y = (y/step_y + 1)*step_y) {
1324 for (x = tile->coord[0][0]; x < tile->coord[0][1]; x = (x/step_x + 1)*step_x) {
1325 for (compno = CSpoc; compno < CEpoc; compno++) {
1326 Jpeg2000Component *comp = tile->comp + compno;
1327 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1328 Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
1329 int xc = x / s->cdx[compno];
1330 int yc = y / s->cdy[compno];
1332 for (reslevelno = RSpoc; reslevelno < FFMIN(codsty->nreslevels, REpoc); reslevelno++) {
1333 unsigned prcx, prcy;
1334 uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1335 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1337 if (yc % (1LL << (rlevel->log2_prec_height + reducedresno)) && y != tile->coord[1][0]) //FIXME this is a subset of the check
1340 if (xc % (1LL << (rlevel->log2_prec_width + reducedresno)) && x != tile->coord[0][0]) //FIXME this is a subset of the check
1343 // check if a precinct exists
1344 prcx = ff_jpeg2000_ceildivpow2(xc, reducedresno) >> rlevel->log2_prec_width;
1345 prcy = ff_jpeg2000_ceildivpow2(yc, reducedresno) >> rlevel->log2_prec_height;
1346 prcx -= ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], reducedresno) >> rlevel->log2_prec_width;
1347 prcy -= ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], reducedresno) >> rlevel->log2_prec_height;
1349 precno = prcx + rlevel->num_precincts_x * prcy;
1351 if (prcx >= rlevel->num_precincts_x || prcy >= rlevel->num_precincts_y) {
1352 av_log(s->avctx, AV_LOG_WARNING, "prc %d %d outside limits %d %d\n",
1353 prcx, prcy, rlevel->num_precincts_x, rlevel->num_precincts_y);
1357 for (layno = 0; layno < LYEpoc; layno++) {
1358 if ((ret = jpeg2000_decode_packet(s, tile, tp_index, codsty, rlevel,
1360 qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1361 qntsty->nguardbits)) < 0)
1377 static int jpeg2000_decode_packets(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
1379 int ret = AVERROR_BUG;
1384 if (tile->poc.nb_poc) {
1385 for (i=0; i<tile->poc.nb_poc; i++) {
1386 Jpeg2000POCEntry *e = &tile->poc.poc[i];
1387 ret = jpeg2000_decode_packets_po_iteration(s, tile,
1389 FFMIN(e->LYEpoc, tile->codsty[0].nlayers),
1391 FFMIN(e->CEpoc, s->ncomponents),
1398 ret = jpeg2000_decode_packets_po_iteration(s, tile,
1400 tile->codsty[0].nlayers,
1403 tile->codsty[0].prog_order,
1407 /* EOC marker reached */
1408 bytestream2_skip(&s->g, 2);
1413 /* TIER-1 routines */
1414 static void decode_sigpass(Jpeg2000T1Context *t1, int width, int height,
1415 int bpno, int bandno,
1416 int vert_causal_ctx_csty_symbol)
1418 int mask = 3 << (bpno - 1), y0, x, y;
1420 for (y0 = 0; y0 < height; y0 += 4)
1421 for (x = 0; x < width; x++)
1422 for (y = y0; y < height && y < y0 + 4; y++) {
1423 int flags_mask = -1;
1424 if (vert_causal_ctx_csty_symbol && y == y0 + 3)
1425 flags_mask &= ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE | JPEG2000_T1_SGN_S);
1426 if ((t1->flags[(y+1) * t1->stride + x+1] & JPEG2000_T1_SIG_NB & flags_mask)
1427 && !(t1->flags[(y+1) * t1->stride + x+1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS))) {
1428 if (ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ff_jpeg2000_getsigctxno(t1->flags[(y+1) * t1->stride + x+1] & flags_mask, bandno))) {
1429 int xorbit, ctxno = ff_jpeg2000_getsgnctxno(t1->flags[(y+1) * t1->stride + x+1] & flags_mask, &xorbit);
1431 t1->data[(y) * t1->stride + x] = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ctxno) ? -mask : mask;
1433 t1->data[(y) * t1->stride + x] = (ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ctxno) ^ xorbit) ?
1436 ff_jpeg2000_set_significance(t1, x, y,
1437 t1->data[(y) * t1->stride + x] < 0);
1439 t1->flags[(y + 1) * t1->stride + x + 1] |= JPEG2000_T1_VIS;
1444 static void decode_refpass(Jpeg2000T1Context *t1, int width, int height,
1445 int bpno, int vert_causal_ctx_csty_symbol)
1450 phalf = 1 << (bpno - 1);
1453 for (y0 = 0; y0 < height; y0 += 4)
1454 for (x = 0; x < width; x++)
1455 for (y = y0; y < height && y < y0 + 4; y++)
1456 if ((t1->flags[(y + 1) * t1->stride + x + 1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS)) == JPEG2000_T1_SIG) {
1457 int flags_mask = (vert_causal_ctx_csty_symbol && y == y0 + 3) ?
1458 ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE | JPEG2000_T1_SGN_S) : -1;
1459 int ctxno = ff_jpeg2000_getrefctxno(t1->flags[(y + 1) * t1->stride + x + 1] & flags_mask);
1460 int r = ff_mqc_decode(&t1->mqc,
1461 t1->mqc.cx_states + ctxno)
1463 t1->data[(y) * t1->stride + x] += t1->data[(y) * t1->stride + x] < 0 ? -r : r;
1464 t1->flags[(y + 1) * t1->stride + x + 1] |= JPEG2000_T1_REF;
1468 static void decode_clnpass(Jpeg2000DecoderContext *s, Jpeg2000T1Context *t1,
1469 int width, int height, int bpno, int bandno,
1470 int seg_symbols, int vert_causal_ctx_csty_symbol)
1472 int mask = 3 << (bpno - 1), y0, x, y, runlen, dec;
1474 for (y0 = 0; y0 < height; y0 += 4) {
1475 for (x = 0; x < width; x++) {
1476 int flags_mask = -1;
1477 if (vert_causal_ctx_csty_symbol)
1478 flags_mask &= ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE | JPEG2000_T1_SGN_S);
1479 if (y0 + 3 < height &&
1480 !((t1->flags[(y0 + 1) * t1->stride + x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
1481 (t1->flags[(y0 + 2) * t1->stride + x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
1482 (t1->flags[(y0 + 3) * t1->stride + x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
1483 (t1->flags[(y0 + 4) * t1->stride + x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG) & flags_mask))) {
1484 if (!ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_RL))
1486 runlen = ff_mqc_decode(&t1->mqc,
1487 t1->mqc.cx_states + MQC_CX_UNI);
1488 runlen = (runlen << 1) | ff_mqc_decode(&t1->mqc,
1497 for (y = y0 + runlen; y < y0 + 4 && y < height; y++) {
1498 int flags_mask = -1;
1499 if (vert_causal_ctx_csty_symbol && y == y0 + 3)
1500 flags_mask &= ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE | JPEG2000_T1_SGN_S);
1502 if (!(t1->flags[(y+1) * t1->stride + x+1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS))) {
1503 dec = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ff_jpeg2000_getsigctxno(t1->flags[(y+1) * t1->stride + x+1] & flags_mask,
1509 int ctxno = ff_jpeg2000_getsgnctxno(t1->flags[(y + 1) * t1->stride + x + 1] & flags_mask,
1511 t1->data[(y) * t1->stride + x] = (ff_mqc_decode(&t1->mqc,
1512 t1->mqc.cx_states + ctxno) ^
1515 ff_jpeg2000_set_significance(t1, x, y, t1->data[(y) * t1->stride + x] < 0);
1518 t1->flags[(y + 1) * t1->stride + x + 1] &= ~JPEG2000_T1_VIS;
1524 val = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1525 val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1526 val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1527 val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1529 av_log(s->avctx, AV_LOG_ERROR,
1530 "Segmentation symbol value incorrect\n");
1534 static int decode_cblk(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *codsty,
1535 Jpeg2000T1Context *t1, Jpeg2000Cblk *cblk,
1536 int width, int height, int bandpos)
1538 int passno = cblk->npasses, pass_t = 2, bpno = cblk->nonzerobits - 1;
1540 int vert_causal_ctx_csty_symbol = codsty->cblk_style & JPEG2000_CBLK_VSC;
1544 av_assert0(width <= 1024U && height <= 1024U);
1545 av_assert0(width*height <= 4096);
1547 memset(t1->data, 0, t1->stride * height * sizeof(*t1->data));
1549 /* If code-block contains no compressed data: nothing to do. */
1553 memset(t1->flags, 0, t1->stride * (height + 2) * sizeof(*t1->flags));
1555 cblk->data[cblk->length] = 0xff;
1556 cblk->data[cblk->length+1] = 0xff;
1557 ff_mqc_initdec(&t1->mqc, cblk->data, 0, 1);
1561 av_log(s->avctx, AV_LOG_ERROR, "bpno became negative\n");
1562 return AVERROR_INVALIDDATA;
1566 decode_sigpass(t1, width, height, bpno + 1, bandpos,
1567 vert_causal_ctx_csty_symbol);
1570 decode_refpass(t1, width, height, bpno + 1, vert_causal_ctx_csty_symbol);
1573 av_assert2(!t1->mqc.raw);
1574 decode_clnpass(s, t1, width, height, bpno + 1, bandpos,
1575 codsty->cblk_style & JPEG2000_CBLK_SEGSYM,
1576 vert_causal_ctx_csty_symbol);
1579 if (codsty->cblk_style & JPEG2000_CBLK_RESET) // XXX no testcase for just this
1580 ff_mqc_init_contexts(&t1->mqc);
1582 if (passno && (coder_type = needs_termination(codsty->cblk_style, pass_cnt))) {
1583 if (term_cnt >= cblk->nb_terminations) {
1584 av_log(s->avctx, AV_LOG_ERROR, "Missing needed termination \n");
1585 return AVERROR_INVALIDDATA;
1587 if (FFABS(cblk->data + cblk->data_start[term_cnt + 1] - 2 - t1->mqc.bp) > 0) {
1588 av_log(s->avctx, AV_LOG_WARNING, "Mid mismatch %"PTRDIFF_SPECIFIER" in pass %d of %d\n",
1589 cblk->data + cblk->data_start[term_cnt + 1] - 2 - t1->mqc.bp,
1590 pass_cnt, cblk->npasses);
1593 ff_mqc_initdec(&t1->mqc, cblk->data + cblk->data_start[++term_cnt], coder_type == 2, 0);
1604 if (cblk->data + cblk->length - 2*(term_cnt < cblk->nb_terminations) != t1->mqc.bp) {
1605 av_log(s->avctx, AV_LOG_WARNING, "End mismatch %"PTRDIFF_SPECIFIER"\n",
1606 cblk->data + cblk->length - 2*(term_cnt < cblk->nb_terminations) - t1->mqc.bp);
1612 /* TODO: Verify dequantization for lossless case
1613 * comp->data can be float or int
1614 * band->stepsize can be float or int
1615 * depending on the type of DWT transformation.
1616 * see ISO/IEC 15444-1:2002 A.6.1 */
1618 /* Float dequantization of a codeblock.*/
1619 static void dequantization_float(int x, int y, Jpeg2000Cblk *cblk,
1620 Jpeg2000Component *comp,
1621 Jpeg2000T1Context *t1, Jpeg2000Band *band)
1624 int w = cblk->coord[0][1] - cblk->coord[0][0];
1625 for (j = 0; j < (cblk->coord[1][1] - cblk->coord[1][0]); ++j) {
1626 float *datap = &comp->f_data[(comp->coord[0][1] - comp->coord[0][0]) * (y + j) + x];
1627 int *src = t1->data + j*t1->stride;
1628 for (i = 0; i < w; ++i)
1629 datap[i] = src[i] * band->f_stepsize;
1633 /* Integer dequantization of a codeblock.*/
1634 static void dequantization_int(int x, int y, Jpeg2000Cblk *cblk,
1635 Jpeg2000Component *comp,
1636 Jpeg2000T1Context *t1, Jpeg2000Band *band)
1639 int w = cblk->coord[0][1] - cblk->coord[0][0];
1640 for (j = 0; j < (cblk->coord[1][1] - cblk->coord[1][0]); ++j) {
1641 int32_t *datap = &comp->i_data[(comp->coord[0][1] - comp->coord[0][0]) * (y + j) + x];
1642 int *src = t1->data + j*t1->stride;
1643 if (band->i_stepsize == 32768) {
1644 for (i = 0; i < w; ++i)
1645 datap[i] = src[i] / 2;
1647 // This should be VERY uncommon
1648 for (i = 0; i < w; ++i)
1649 datap[i] = (src[i] * (int64_t)band->i_stepsize) / 65536;
1654 static void dequantization_int_97(int x, int y, Jpeg2000Cblk *cblk,
1655 Jpeg2000Component *comp,
1656 Jpeg2000T1Context *t1, Jpeg2000Band *band)
1659 int w = cblk->coord[0][1] - cblk->coord[0][0];
1660 for (j = 0; j < (cblk->coord[1][1] - cblk->coord[1][0]); ++j) {
1661 int32_t *datap = &comp->i_data[(comp->coord[0][1] - comp->coord[0][0]) * (y + j) + x];
1662 int *src = t1->data + j*t1->stride;
1663 for (i = 0; i < w; ++i)
1664 datap[i] = (src[i] * (int64_t)band->i_stepsize + (1<<15)) >> 16;
1668 static inline void mct_decode(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
1673 for (i = 1; i < 3; i++) {
1674 if (tile->codsty[0].transform != tile->codsty[i].transform) {
1675 av_log(s->avctx, AV_LOG_ERROR, "Transforms mismatch, MCT not supported\n");
1678 if (memcmp(tile->comp[0].coord, tile->comp[i].coord, sizeof(tile->comp[0].coord))) {
1679 av_log(s->avctx, AV_LOG_ERROR, "Coords mismatch, MCT not supported\n");
1684 for (i = 0; i < 3; i++)
1685 if (tile->codsty[0].transform == FF_DWT97)
1686 src[i] = tile->comp[i].f_data;
1688 src[i] = tile->comp[i].i_data;
1690 for (i = 0; i < 2; i++)
1691 csize *= tile->comp[0].coord[i][1] - tile->comp[0].coord[i][0];
1693 s->dsp.mct_decode[tile->codsty[0].transform](src[0], src[1], src[2], csize);
1696 static inline void tile_codeblocks(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
1698 Jpeg2000T1Context t1;
1700 int compno, reslevelno, bandno;
1702 /* Loop on tile components */
1703 for (compno = 0; compno < s->ncomponents; compno++) {
1704 Jpeg2000Component *comp = tile->comp + compno;
1705 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1708 t1.stride = (1<<codsty->log2_cblk_width) + 2;
1710 /* Loop on resolution levels */
1711 for (reslevelno = 0; reslevelno < codsty->nreslevels2decode; reslevelno++) {
1712 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1714 for (bandno = 0; bandno < rlevel->nbands; bandno++) {
1715 int nb_precincts, precno;
1716 Jpeg2000Band *band = rlevel->band + bandno;
1717 int cblkno = 0, bandpos;
1719 bandpos = bandno + (reslevelno > 0);
1721 if (band->coord[0][0] == band->coord[0][1] ||
1722 band->coord[1][0] == band->coord[1][1])
1725 nb_precincts = rlevel->num_precincts_x * rlevel->num_precincts_y;
1726 /* Loop on precincts */
1727 for (precno = 0; precno < nb_precincts; precno++) {
1728 Jpeg2000Prec *prec = band->prec + precno;
1730 /* Loop on codeblocks */
1732 cblkno < prec->nb_codeblocks_width * prec->nb_codeblocks_height;
1735 Jpeg2000Cblk *cblk = prec->cblk + cblkno;
1736 int ret = decode_cblk(s, codsty, &t1, cblk,
1737 cblk->coord[0][1] - cblk->coord[0][0],
1738 cblk->coord[1][1] - cblk->coord[1][0],
1744 x = cblk->coord[0][0] - band->coord[0][0];
1745 y = cblk->coord[1][0] - band->coord[1][0];
1747 if (codsty->transform == FF_DWT97)
1748 dequantization_float(x, y, cblk, comp, &t1, band);
1749 else if (codsty->transform == FF_DWT97_INT)
1750 dequantization_int_97(x, y, cblk, comp, &t1, band);
1752 dequantization_int(x, y, cblk, comp, &t1, band);
1756 } /* end reslevel */
1760 ff_dwt_decode(&comp->dwt, codsty->transform == FF_DWT97 ? (void*)comp->f_data : (void*)comp->i_data);
1765 #define WRITE_FRAME(D, PIXEL) \
1766 static inline void write_frame_ ## D(Jpeg2000DecoderContext * s, Jpeg2000Tile * tile, \
1767 AVFrame * picture, int precision) \
1769 const AVPixFmtDescriptor *pixdesc = av_pix_fmt_desc_get(s->avctx->pix_fmt); \
1770 int planar = !!(pixdesc->flags & AV_PIX_FMT_FLAG_PLANAR); \
1771 int pixelsize = planar ? 1 : pixdesc->nb_components; \
1776 for (compno = 0; compno < s->ncomponents; compno++) { \
1777 Jpeg2000Component *comp = tile->comp + compno; \
1778 Jpeg2000CodingStyle *codsty = tile->codsty + compno; \
1780 float *datap = comp->f_data; \
1781 int32_t *i_datap = comp->i_data; \
1782 int cbps = s->cbps[compno]; \
1783 int w = tile->comp[compno].coord[0][1] - s->image_offset_x; \
1787 plane = s->cdef[compno] ? s->cdef[compno]-1 : (s->ncomponents-1); \
1789 y = tile->comp[compno].coord[1][0] - s->image_offset_y / s->cdy[compno]; \
1790 line = (PIXEL *)picture->data[plane] + y * (picture->linesize[plane] / sizeof(PIXEL));\
1791 for (; y < tile->comp[compno].coord[1][1] - s->image_offset_y; y++) { \
1794 x = tile->comp[compno].coord[0][0] - s->image_offset_x / s->cdx[compno]; \
1795 dst = line + x * pixelsize + compno*!planar; \
1797 if (codsty->transform == FF_DWT97) { \
1798 for (; x < w; x++) { \
1799 int val = lrintf(*datap) + (1 << (cbps - 1)); \
1800 /* DC level shift and clip see ISO 15444-1:2002 G.1.2 */ \
1801 val = av_clip(val, 0, (1 << cbps) - 1); \
1802 *dst = val << (precision - cbps); \
1807 for (; x < w; x++) { \
1808 int val = *i_datap + (1 << (cbps - 1)); \
1809 /* DC level shift and clip see ISO 15444-1:2002 G.1.2 */ \
1810 val = av_clip(val, 0, (1 << cbps) - 1); \
1811 *dst = val << (precision - cbps); \
1816 line += picture->linesize[plane] / sizeof(PIXEL); \
1822 WRITE_FRAME(8, uint8_t)
1823 WRITE_FRAME(16, uint16_t)
1827 static int jpeg2000_decode_tile(AVCodecContext *avctx, void *td,
1828 int jobnr, int threadnr)
1830 Jpeg2000DecoderContext *s = avctx->priv_data;
1831 AVFrame *picture = td;
1832 Jpeg2000Tile *tile = s->tile + jobnr;
1835 tile_codeblocks(s, tile);
1837 /* inverse MCT transformation */
1838 if (tile->codsty[0].mct)
1839 mct_decode(s, tile);
1841 for (x = 0; x < s->ncomponents; x++) {
1842 if (s->cdef[x] < 0) {
1843 for (x = 0; x < s->ncomponents; x++) {
1846 if ((s->ncomponents & 1) == 0)
1847 s->cdef[s->ncomponents-1] = 0;
1852 if (s->precision <= 8) {
1853 write_frame_8(s, tile, picture, 8);
1855 int precision = picture->format == AV_PIX_FMT_XYZ12 ||
1856 picture->format == AV_PIX_FMT_RGB48 ||
1857 picture->format == AV_PIX_FMT_RGBA64 ||
1858 picture->format == AV_PIX_FMT_GRAY16 ? 16 : s->precision;
1860 write_frame_16(s, tile, picture, precision);
1866 static void jpeg2000_dec_cleanup(Jpeg2000DecoderContext *s)
1869 for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++) {
1870 if (s->tile[tileno].comp) {
1871 for (compno = 0; compno < s->ncomponents; compno++) {
1872 Jpeg2000Component *comp = s->tile[tileno].comp + compno;
1873 Jpeg2000CodingStyle *codsty = s->tile[tileno].codsty + compno;
1875 ff_jpeg2000_cleanup(comp, codsty);
1877 av_freep(&s->tile[tileno].comp);
1881 memset(s->codsty, 0, sizeof(s->codsty));
1882 memset(s->qntsty, 0, sizeof(s->qntsty));
1883 memset(s->properties, 0, sizeof(s->properties));
1884 memset(&s->poc , 0, sizeof(s->poc));
1885 s->numXtiles = s->numYtiles = 0;
1889 static int jpeg2000_read_main_headers(Jpeg2000DecoderContext *s)
1891 Jpeg2000CodingStyle *codsty = s->codsty;
1892 Jpeg2000QuantStyle *qntsty = s->qntsty;
1893 Jpeg2000POC *poc = &s->poc;
1894 uint8_t *properties = s->properties;
1901 if (bytestream2_get_bytes_left(&s->g) < 2) {
1902 av_log(s->avctx, AV_LOG_ERROR, "Missing EOC\n");
1906 marker = bytestream2_get_be16u(&s->g);
1907 oldpos = bytestream2_tell(&s->g);
1909 if (marker == JPEG2000_SOD) {
1911 Jpeg2000TilePart *tp;
1914 av_log(s->avctx, AV_LOG_ERROR, "Missing SIZ\n");
1915 return AVERROR_INVALIDDATA;
1917 if (s->curtileno < 0) {
1918 av_log(s->avctx, AV_LOG_ERROR, "Missing SOT\n");
1919 return AVERROR_INVALIDDATA;
1922 tile = s->tile + s->curtileno;
1923 tp = tile->tile_part + tile->tp_idx;
1924 if (tp->tp_end < s->g.buffer) {
1925 av_log(s->avctx, AV_LOG_ERROR, "Invalid tpend\n");
1926 return AVERROR_INVALIDDATA;
1928 bytestream2_init(&tp->tpg, s->g.buffer, tp->tp_end - s->g.buffer);
1929 bytestream2_skip(&s->g, tp->tp_end - s->g.buffer);
1933 if (marker == JPEG2000_EOC)
1936 len = bytestream2_get_be16(&s->g);
1937 if (len < 2 || bytestream2_get_bytes_left(&s->g) < len - 2) {
1938 av_log(s->avctx, AV_LOG_ERROR, "Invalid len %d left=%d\n", len, bytestream2_get_bytes_left(&s->g));
1939 return AVERROR_INVALIDDATA;
1944 if (s->ncomponents) {
1945 av_log(s->avctx, AV_LOG_ERROR, "Duplicate SIZ\n");
1946 return AVERROR_INVALIDDATA;
1950 s->numXtiles = s->numYtiles = 0;
1953 ret = get_coc(s, codsty, properties);
1956 ret = get_cod(s, codsty, properties);
1959 ret = get_qcc(s, len, qntsty, properties);
1962 ret = get_qcd(s, len, qntsty, properties);
1965 ret = get_poc(s, len, poc);
1968 if (!(ret = get_sot(s, len))) {
1969 av_assert1(s->curtileno >= 0);
1970 codsty = s->tile[s->curtileno].codsty;
1971 qntsty = s->tile[s->curtileno].qntsty;
1972 poc = &s->tile[s->curtileno].poc;
1973 properties = s->tile[s->curtileno].properties;
1977 // the PLM marker is ignored
1979 // the comment is ignored
1980 bytestream2_skip(&s->g, len - 2);
1983 // Tile-part lengths
1984 ret = get_tlm(s, len);
1987 // Packet length, tile-part header
1988 ret = get_plt(s, len);
1991 av_log(s->avctx, AV_LOG_ERROR,
1992 "unsupported marker 0x%.4"PRIX16" at pos 0x%X\n",
1993 marker, bytestream2_tell(&s->g) - 4);
1994 bytestream2_skip(&s->g, len - 2);
1997 if (bytestream2_tell(&s->g) - oldpos != len || ret) {
1998 av_log(s->avctx, AV_LOG_ERROR,
1999 "error during processing marker segment %.4"PRIx16"\n",
2001 return ret ? ret : -1;
2007 /* Read bit stream packets --> T2 operation. */
2008 static int jpeg2000_read_bitstream_packets(Jpeg2000DecoderContext *s)
2013 for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++) {
2014 Jpeg2000Tile *tile = s->tile + tileno;
2016 if ((ret = init_tile(s, tileno)) < 0)
2019 s->g = tile->tile_part[0].tpg;
2020 if ((ret = jpeg2000_decode_packets(s, tile)) < 0)
2027 static int jp2_find_codestream(Jpeg2000DecoderContext *s)
2029 uint32_t atom_size, atom, atom_end;
2030 int search_range = 10;
2034 bytestream2_get_bytes_left(&s->g) >= 8) {
2035 atom_size = bytestream2_get_be32u(&s->g);
2036 atom = bytestream2_get_be32u(&s->g);
2037 if (atom_size == 1) {
2038 if (bytestream2_get_be32u(&s->g)) {
2039 avpriv_request_sample(s->avctx, "Huge atom");
2042 atom_size = bytestream2_get_be32u(&s->g);
2043 atom_end = bytestream2_tell(&s->g) + atom_size - 16;
2045 atom_end = bytestream2_tell(&s->g) + atom_size - 8;
2048 if (atom == JP2_CODESTREAM)
2051 if (bytestream2_get_bytes_left(&s->g) < atom_size || atom_end < atom_size)
2054 if (atom == JP2_HEADER &&
2056 uint32_t atom2_size, atom2, atom2_end;
2058 atom2_size = bytestream2_get_be32u(&s->g);
2059 atom2 = bytestream2_get_be32u(&s->g);
2060 atom2_end = bytestream2_tell(&s->g) + atom2_size - 8;
2061 if (atom2_size < 8 || atom2_end > atom_end || atom2_end < atom2_size)
2064 if (atom2 == JP2_CODESTREAM) {
2066 } else if (atom2 == MKBETAG('c','o','l','r') && atom2_size >= 7) {
2067 int method = bytestream2_get_byteu(&s->g);
2068 bytestream2_skipu(&s->g, 2);
2070 s->colour_space = bytestream2_get_be32u(&s->g);
2072 } else if (atom2 == MKBETAG('p','c','l','r') && atom2_size >= 6) {
2073 int i, size, colour_count, colour_channels, colour_depth[3];
2074 colour_count = bytestream2_get_be16u(&s->g);
2075 colour_channels = bytestream2_get_byteu(&s->g);
2076 // FIXME: Do not ignore channel_sign
2077 colour_depth[0] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1;
2078 colour_depth[1] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1;
2079 colour_depth[2] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1;
2080 size = (colour_depth[0] + 7 >> 3) * colour_count +
2081 (colour_depth[1] + 7 >> 3) * colour_count +
2082 (colour_depth[2] + 7 >> 3) * colour_count;
2083 if (colour_count > AVPALETTE_COUNT ||
2084 colour_channels != 3 ||
2085 colour_depth[0] > 16 ||
2086 colour_depth[1] > 16 ||
2087 colour_depth[2] > 16 ||
2088 atom2_size < size) {
2089 avpriv_request_sample(s->avctx, "Unknown palette");
2090 bytestream2_seek(&s->g, atom2_end, SEEK_SET);
2094 for (i = 0; i < colour_count; i++) {
2096 if (colour_depth[0] <= 8) {
2097 r = bytestream2_get_byteu(&s->g) << 8 - colour_depth[0];
2098 r |= r >> colour_depth[0];
2100 r = bytestream2_get_be16u(&s->g) >> colour_depth[0] - 8;
2102 if (colour_depth[1] <= 8) {
2103 g = bytestream2_get_byteu(&s->g) << 8 - colour_depth[1];
2104 g |= g >> colour_depth[1];
2106 g = bytestream2_get_be16u(&s->g) >> colour_depth[1] - 8;
2108 if (colour_depth[2] <= 8) {
2109 b = bytestream2_get_byteu(&s->g) << 8 - colour_depth[2];
2110 b |= b >> colour_depth[2];
2112 b = bytestream2_get_be16u(&s->g) >> colour_depth[2] - 8;
2114 s->palette[i] = 0xffu << 24 | r << 16 | g << 8 | b;
2116 } else if (atom2 == MKBETAG('c','d','e','f') && atom2_size >= 2) {
2117 int n = bytestream2_get_be16u(&s->g);
2119 int cn = bytestream2_get_be16(&s->g);
2120 int av_unused typ = bytestream2_get_be16(&s->g);
2121 int asoc = bytestream2_get_be16(&s->g);
2122 if (cn < 4 && asoc < 4)
2125 } else if (atom2 == MKBETAG('r','e','s',' ') && atom2_size >= 18) {
2126 int64_t vnum, vden, hnum, hden, vexp, hexp;
2128 bytestream2_skip(&s->g, 4);
2129 resx = bytestream2_get_be32u(&s->g);
2130 if (resx != MKBETAG('r','e','s','c') && resx != MKBETAG('r','e','s','d')) {
2131 bytestream2_seek(&s->g, atom2_end, SEEK_SET);
2134 vnum = bytestream2_get_be16u(&s->g);
2135 vden = bytestream2_get_be16u(&s->g);
2136 hnum = bytestream2_get_be16u(&s->g);
2137 hden = bytestream2_get_be16u(&s->g);
2138 vexp = bytestream2_get_byteu(&s->g);
2139 hexp = bytestream2_get_byteu(&s->g);
2140 if (!vnum || !vden || !hnum || !hden) {
2141 bytestream2_seek(&s->g, atom2_end, SEEK_SET);
2142 av_log(s->avctx, AV_LOG_WARNING, "RES box invalid\n");
2152 if ( INT64_MAX / (hnum * vden) > pow(10, hexp)
2153 && INT64_MAX / (vnum * hden) > pow(10, vexp))
2154 av_reduce(&s->sar.den, &s->sar.num,
2155 hnum * vden * pow(10, hexp),
2156 vnum * hden * pow(10, vexp),
2159 bytestream2_seek(&s->g, atom2_end, SEEK_SET);
2160 } while (atom_end - atom2_end >= 8);
2164 bytestream2_seek(&s->g, atom_end, SEEK_SET);
2170 static av_cold void jpeg2000_init_static_data(void)
2172 ff_jpeg2000_init_tier1_luts();
2173 ff_mqc_init_context_tables();
2176 static av_cold int jpeg2000_decode_init(AVCodecContext *avctx)
2178 static AVOnce init_static_once = AV_ONCE_INIT;
2179 Jpeg2000DecoderContext *s = avctx->priv_data;
2181 ff_thread_once(&init_static_once, jpeg2000_init_static_data);
2182 ff_jpeg2000dsp_init(&s->dsp);
2187 static int jpeg2000_decode_frame(AVCodecContext *avctx, void *data,
2188 int *got_frame, AVPacket *avpkt)
2190 Jpeg2000DecoderContext *s = avctx->priv_data;
2191 ThreadFrame frame = { .f = data };
2192 AVFrame *picture = data;
2196 bytestream2_init(&s->g, avpkt->data, avpkt->size);
2198 memset(s->cdef, -1, sizeof(s->cdef));
2200 if (bytestream2_get_bytes_left(&s->g) < 2) {
2201 ret = AVERROR_INVALIDDATA;
2205 // check if the image is in jp2 format
2206 if (bytestream2_get_bytes_left(&s->g) >= 12 &&
2207 (bytestream2_get_be32u(&s->g) == 12) &&
2208 (bytestream2_get_be32u(&s->g) == JP2_SIG_TYPE) &&
2209 (bytestream2_get_be32u(&s->g) == JP2_SIG_VALUE)) {
2210 if (!jp2_find_codestream(s)) {
2211 av_log(avctx, AV_LOG_ERROR,
2212 "Could not find Jpeg2000 codestream atom.\n");
2213 ret = AVERROR_INVALIDDATA;
2217 bytestream2_seek(&s->g, 0, SEEK_SET);
2220 while (bytestream2_get_bytes_left(&s->g) >= 3 && bytestream2_peek_be16(&s->g) != JPEG2000_SOC)
2221 bytestream2_skip(&s->g, 1);
2223 if (bytestream2_get_be16u(&s->g) != JPEG2000_SOC) {
2224 av_log(avctx, AV_LOG_ERROR, "SOC marker not present\n");
2225 ret = AVERROR_INVALIDDATA;
2228 if (ret = jpeg2000_read_main_headers(s))
2231 /* get picture buffer */
2232 if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
2234 picture->pict_type = AV_PICTURE_TYPE_I;
2235 picture->key_frame = 1;
2237 if (ret = jpeg2000_read_bitstream_packets(s))
2240 avctx->execute2(avctx, jpeg2000_decode_tile, picture, NULL, s->numXtiles * s->numYtiles);
2242 jpeg2000_dec_cleanup(s);
2246 if (s->avctx->pix_fmt == AV_PIX_FMT_PAL8)
2247 memcpy(picture->data[1], s->palette, 256 * sizeof(uint32_t));
2248 if (s->sar.num && s->sar.den)
2249 avctx->sample_aspect_ratio = s->sar;
2250 s->sar.num = s->sar.den = 0;
2252 return bytestream2_tell(&s->g);
2255 jpeg2000_dec_cleanup(s);
2259 #define OFFSET(x) offsetof(Jpeg2000DecoderContext, x)
2260 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
2262 static const AVOption options[] = {
2263 { "lowres", "Lower the decoding resolution by a power of two",
2264 OFFSET(reduction_factor), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, JPEG2000_MAX_RESLEVELS - 1, VD },
2268 static const AVClass jpeg2000_class = {
2269 .class_name = "jpeg2000",
2270 .item_name = av_default_item_name,
2272 .version = LIBAVUTIL_VERSION_INT,
2275 AVCodec ff_jpeg2000_decoder = {
2277 .long_name = NULL_IF_CONFIG_SMALL("JPEG 2000"),
2278 .type = AVMEDIA_TYPE_VIDEO,
2279 .id = AV_CODEC_ID_JPEG2000,
2280 .capabilities = AV_CODEC_CAP_SLICE_THREADS | AV_CODEC_CAP_FRAME_THREADS | AV_CODEC_CAP_DR1,
2281 .priv_data_size = sizeof(Jpeg2000DecoderContext),
2282 .init = jpeg2000_decode_init,
2283 .decode = jpeg2000_decode_frame,
2284 .priv_class = &jpeg2000_class,
2286 .profiles = NULL_IF_CONFIG_SMALL(ff_jpeg2000_profiles)