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 uint8_t get_plt(Jpeg2000DecoderContext *s, int n)
836 av_log(s->avctx, AV_LOG_DEBUG,
837 "PLT marker at pos 0x%X\n", bytestream2_tell(&s->g) - 4);
839 /*Zplt =*/ bytestream2_get_byte(&s->g);
841 for (i = 0; i < n - 3; i++) {
842 bytestream2_get_byte(&s->g);
848 static int init_tile(Jpeg2000DecoderContext *s, int tileno)
851 int tilex = tileno % s->numXtiles;
852 int tiley = tileno / s->numXtiles;
853 Jpeg2000Tile *tile = s->tile + tileno;
856 return AVERROR(ENOMEM);
858 tile->coord[0][0] = av_clip(tilex * (int64_t)s->tile_width + s->tile_offset_x, s->image_offset_x, s->width);
859 tile->coord[0][1] = av_clip((tilex + 1) * (int64_t)s->tile_width + s->tile_offset_x, s->image_offset_x, s->width);
860 tile->coord[1][0] = av_clip(tiley * (int64_t)s->tile_height + s->tile_offset_y, s->image_offset_y, s->height);
861 tile->coord[1][1] = av_clip((tiley + 1) * (int64_t)s->tile_height + s->tile_offset_y, s->image_offset_y, s->height);
863 for (compno = 0; compno < s->ncomponents; compno++) {
864 Jpeg2000Component *comp = tile->comp + compno;
865 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
866 Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
867 int ret; // global bandno
869 comp->coord_o[0][0] = tile->coord[0][0];
870 comp->coord_o[0][1] = tile->coord[0][1];
871 comp->coord_o[1][0] = tile->coord[1][0];
872 comp->coord_o[1][1] = tile->coord[1][1];
874 comp->coord_o[0][0] /= s->cdx[compno];
875 comp->coord_o[0][1] /= s->cdx[compno];
876 comp->coord_o[1][0] /= s->cdy[compno];
877 comp->coord_o[1][1] /= s->cdy[compno];
880 comp->coord[0][0] = ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], s->reduction_factor);
881 comp->coord[0][1] = ff_jpeg2000_ceildivpow2(comp->coord_o[0][1], s->reduction_factor);
882 comp->coord[1][0] = ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], s->reduction_factor);
883 comp->coord[1][1] = ff_jpeg2000_ceildivpow2(comp->coord_o[1][1], s->reduction_factor);
885 if (ret = ff_jpeg2000_init_component(comp, codsty, qntsty,
886 s->cbps[compno], s->cdx[compno],
887 s->cdy[compno], s->avctx))
893 /* Read the number of coding passes. */
894 static int getnpasses(Jpeg2000DecoderContext *s)
901 if ((num = get_bits(s, 2)) != 3)
902 return num < 0 ? num : 3 + num;
903 if ((num = get_bits(s, 5)) != 31)
904 return num < 0 ? num : 6 + num;
905 num = get_bits(s, 7);
906 return num < 0 ? num : 37 + num;
909 static int getlblockinc(Jpeg2000DecoderContext *s)
912 while (ret = get_bits(s, 1)) {
920 static int jpeg2000_decode_packet(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile, int *tp_index,
921 Jpeg2000CodingStyle *codsty,
922 Jpeg2000ResLevel *rlevel, int precno,
923 int layno, uint8_t *expn, int numgbits)
925 int bandno, cblkno, ret, nb_code_blocks;
928 if (layno < rlevel->band[0].prec[precno].decoded_layers)
930 rlevel->band[0].prec[precno].decoded_layers = layno + 1;
932 if (bytestream2_get_bytes_left(&s->g) == 0 && s->bit_index == 8) {
933 if (*tp_index < FF_ARRAY_ELEMS(tile->tile_part) - 1) {
934 s->g = tile->tile_part[++(*tp_index)].tpg;
938 if (bytestream2_peek_be32(&s->g) == JPEG2000_SOP_FIXED_BYTES)
939 bytestream2_skip(&s->g, JPEG2000_SOP_BYTE_LENGTH);
941 if (!(ret = get_bits(s, 1))) {
947 for (bandno = 0; bandno < rlevel->nbands; bandno++) {
948 Jpeg2000Band *band = rlevel->band + bandno;
949 Jpeg2000Prec *prec = band->prec + precno;
951 if (band->coord[0][0] == band->coord[0][1] ||
952 band->coord[1][0] == band->coord[1][1])
954 nb_code_blocks = prec->nb_codeblocks_height *
955 prec->nb_codeblocks_width;
956 for (cblkno = 0; cblkno < nb_code_blocks; cblkno++) {
957 Jpeg2000Cblk *cblk = prec->cblk + cblkno;
958 int incl, newpasses, llen;
962 incl = get_bits(s, 1);
964 incl = tag_tree_decode(s, prec->cblkincl + cblkno, layno + 1) == layno;
970 if (!cblk->npasses) {
971 int v = expn[bandno] + numgbits - 1 -
972 tag_tree_decode(s, prec->zerobits + cblkno, 100);
973 if (v < 0 || v > 30) {
974 av_log(s->avctx, AV_LOG_ERROR,
975 "nonzerobits %d invalid or unsupported\n", v);
976 return AVERROR_INVALIDDATA;
978 cblk->nonzerobits = v;
980 if ((newpasses = getnpasses(s)) < 0)
982 av_assert2(newpasses > 0);
983 if (cblk->npasses + newpasses >= JPEG2000_MAX_PASSES) {
984 avpriv_request_sample(s->avctx, "Too many passes");
985 return AVERROR_PATCHWELCOME;
987 if ((llen = getlblockinc(s)) < 0)
989 if (cblk->lblock + llen + av_log2(newpasses) > 16) {
990 avpriv_request_sample(s->avctx,
991 "Block with length beyond 16 bits");
992 return AVERROR_PATCHWELCOME;
995 cblk->lblock += llen;
997 cblk->nb_lengthinc = 0;
998 cblk->nb_terminationsinc = 0;
999 av_free(cblk->lengthinc);
1000 cblk->lengthinc = av_mallocz_array(newpasses , sizeof(*cblk->lengthinc));
1001 if (!cblk->lengthinc)
1002 return AVERROR(ENOMEM);
1003 tmp = av_realloc_array(cblk->data_start, cblk->nb_terminations + newpasses + 1, sizeof(*cblk->data_start));
1005 return AVERROR(ENOMEM);
1006 cblk->data_start = tmp;
1010 while (newpasses1 < newpasses) {
1012 if (needs_termination(codsty->cblk_style, cblk->npasses + newpasses1 - 1)) {
1013 cblk->nb_terminationsinc ++;
1018 if ((ret = get_bits(s, av_log2(newpasses1) + cblk->lblock)) < 0)
1020 if (ret > cblk->data_allocated) {
1021 size_t new_size = FFMAX(2*cblk->data_allocated, ret);
1022 void *new = av_realloc(cblk->data, new_size);
1025 cblk->data_allocated = new_size;
1028 if (ret > cblk->data_allocated) {
1029 avpriv_request_sample(s->avctx,
1030 "Block with lengthinc greater than %"SIZE_SPECIFIER"",
1031 cblk->data_allocated);
1032 return AVERROR_PATCHWELCOME;
1034 cblk->lengthinc[cblk->nb_lengthinc++] = ret;
1035 cblk->npasses += newpasses1;
1036 newpasses -= newpasses1;
1042 if (codsty->csty & JPEG2000_CSTY_EPH) {
1043 if (bytestream2_peek_be16(&s->g) == JPEG2000_EPH)
1044 bytestream2_skip(&s->g, 2);
1046 av_log(s->avctx, AV_LOG_ERROR, "EPH marker not found. instead %X\n", bytestream2_peek_be32(&s->g));
1049 for (bandno = 0; bandno < rlevel->nbands; bandno++) {
1050 Jpeg2000Band *band = rlevel->band + bandno;
1051 Jpeg2000Prec *prec = band->prec + precno;
1053 nb_code_blocks = prec->nb_codeblocks_height * prec->nb_codeblocks_width;
1054 for (cblkno = 0; cblkno < nb_code_blocks; cblkno++) {
1055 Jpeg2000Cblk *cblk = prec->cblk + cblkno;
1056 if (!cblk->nb_terminationsinc && !cblk->lengthinc)
1058 for (cwsno = 0; cwsno < cblk->nb_lengthinc; cwsno ++) {
1059 if (cblk->data_allocated < cblk->length + cblk->lengthinc[cwsno] + 4) {
1060 size_t new_size = FFMAX(2*cblk->data_allocated, cblk->length + cblk->lengthinc[cwsno] + 4);
1061 void *new = av_realloc(cblk->data, new_size);
1064 cblk->data_allocated = new_size;
1067 if ( bytestream2_get_bytes_left(&s->g) < cblk->lengthinc[cwsno]
1068 || cblk->data_allocated < cblk->length + cblk->lengthinc[cwsno] + 4
1070 av_log(s->avctx, AV_LOG_ERROR,
1071 "Block length %"PRIu16" or lengthinc %d is too large, left %d\n",
1072 cblk->length, cblk->lengthinc[cwsno], bytestream2_get_bytes_left(&s->g));
1073 return AVERROR_INVALIDDATA;
1076 bytestream2_get_bufferu(&s->g, cblk->data + cblk->length, cblk->lengthinc[cwsno]);
1077 cblk->length += cblk->lengthinc[cwsno];
1078 cblk->lengthinc[cwsno] = 0;
1079 if (cblk->nb_terminationsinc) {
1080 cblk->nb_terminationsinc--;
1081 cblk->nb_terminations++;
1082 cblk->data[cblk->length++] = 0xFF;
1083 cblk->data[cblk->length++] = 0xFF;
1084 cblk->data_start[cblk->nb_terminations] = cblk->length;
1087 av_freep(&cblk->lengthinc);
1093 static int jpeg2000_decode_packets_po_iteration(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile,
1094 int RSpoc, int CSpoc,
1095 int LYEpoc, int REpoc, int CEpoc,
1096 int Ppoc, int *tp_index)
1099 int layno, reslevelno, compno, precno, ok_reslevel;
1104 case JPEG2000_PGOD_RLCP:
1105 av_log(s->avctx, AV_LOG_DEBUG, "Progression order RLCP\n");
1107 for (reslevelno = RSpoc; ok_reslevel && reslevelno < REpoc; reslevelno++) {
1109 for (layno = 0; layno < LYEpoc; layno++) {
1110 for (compno = CSpoc; compno < CEpoc; compno++) {
1111 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1112 Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
1113 if (reslevelno < codsty->nreslevels) {
1114 Jpeg2000ResLevel *rlevel = tile->comp[compno].reslevel +
1117 for (precno = 0; precno < rlevel->num_precincts_x * rlevel->num_precincts_y; precno++)
1118 if ((ret = jpeg2000_decode_packet(s, tile, tp_index,
1121 qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1122 qntsty->nguardbits)) < 0)
1130 case JPEG2000_PGOD_LRCP:
1131 av_log(s->avctx, AV_LOG_DEBUG, "Progression order LRCP\n");
1132 for (layno = 0; layno < LYEpoc; layno++) {
1134 for (reslevelno = RSpoc; ok_reslevel && reslevelno < REpoc; reslevelno++) {
1136 for (compno = CSpoc; compno < CEpoc; compno++) {
1137 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1138 Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
1139 if (reslevelno < codsty->nreslevels) {
1140 Jpeg2000ResLevel *rlevel = tile->comp[compno].reslevel +
1143 for (precno = 0; precno < rlevel->num_precincts_x * rlevel->num_precincts_y; precno++)
1144 if ((ret = jpeg2000_decode_packet(s, tile, tp_index,
1147 qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1148 qntsty->nguardbits)) < 0)
1156 case JPEG2000_PGOD_CPRL:
1157 av_log(s->avctx, AV_LOG_DEBUG, "Progression order CPRL\n");
1158 for (compno = CSpoc; compno < CEpoc; compno++) {
1159 Jpeg2000Component *comp = tile->comp + compno;
1160 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1161 Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
1165 if (RSpoc > FFMIN(codsty->nreslevels, REpoc))
1168 for (reslevelno = RSpoc; reslevelno < FFMIN(codsty->nreslevels, REpoc); reslevelno++) {
1169 uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1170 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1171 step_x = FFMIN(step_x, rlevel->log2_prec_width + reducedresno);
1172 step_y = FFMIN(step_y, rlevel->log2_prec_height + reducedresno);
1174 av_assert0(step_x < 32 && step_y < 32);
1178 for (y = tile->coord[1][0]; y < tile->coord[1][1]; y = (y/step_y + 1)*step_y) {
1179 for (x = tile->coord[0][0]; x < tile->coord[0][1]; x = (x/step_x + 1)*step_x) {
1180 for (reslevelno = RSpoc; reslevelno < FFMIN(codsty->nreslevels, REpoc); reslevelno++) {
1181 unsigned prcx, prcy;
1182 uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1183 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1184 int xc = x / s->cdx[compno];
1185 int yc = y / s->cdy[compno];
1187 if (yc % (1LL << (rlevel->log2_prec_height + reducedresno)) && y != tile->coord[1][0]) //FIXME this is a subset of the check
1190 if (xc % (1LL << (rlevel->log2_prec_width + reducedresno)) && x != tile->coord[0][0]) //FIXME this is a subset of the check
1193 // check if a precinct exists
1194 prcx = ff_jpeg2000_ceildivpow2(xc, reducedresno) >> rlevel->log2_prec_width;
1195 prcy = ff_jpeg2000_ceildivpow2(yc, reducedresno) >> rlevel->log2_prec_height;
1196 prcx -= ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], reducedresno) >> rlevel->log2_prec_width;
1197 prcy -= ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], reducedresno) >> rlevel->log2_prec_height;
1199 precno = prcx + rlevel->num_precincts_x * prcy;
1201 if (prcx >= rlevel->num_precincts_x || prcy >= rlevel->num_precincts_y) {
1202 av_log(s->avctx, AV_LOG_WARNING, "prc %d %d outside limits %d %d\n",
1203 prcx, prcy, rlevel->num_precincts_x, rlevel->num_precincts_y);
1207 for (layno = 0; layno < LYEpoc; layno++) {
1208 if ((ret = jpeg2000_decode_packet(s, tile, tp_index, codsty, rlevel,
1210 qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1211 qntsty->nguardbits)) < 0)
1220 case JPEG2000_PGOD_RPCL:
1221 av_log(s->avctx, AV_LOG_WARNING, "Progression order RPCL\n");
1223 for (reslevelno = RSpoc; ok_reslevel && reslevelno < REpoc; reslevelno++) {
1227 for (compno = CSpoc; compno < CEpoc; compno++) {
1228 Jpeg2000Component *comp = tile->comp + compno;
1229 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1231 if (reslevelno < codsty->nreslevels) {
1232 uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1233 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1234 step_x = FFMIN(step_x, rlevel->log2_prec_width + reducedresno);
1235 step_y = FFMIN(step_y, rlevel->log2_prec_height + reducedresno);
1241 for (y = tile->coord[1][0]; y < tile->coord[1][1]; y = (y/step_y + 1)*step_y) {
1242 for (x = tile->coord[0][0]; x < tile->coord[0][1]; x = (x/step_x + 1)*step_x) {
1243 for (compno = CSpoc; compno < CEpoc; compno++) {
1244 Jpeg2000Component *comp = tile->comp + compno;
1245 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1246 Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
1247 uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1248 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1249 unsigned prcx, prcy;
1251 int xc = x / s->cdx[compno];
1252 int yc = y / s->cdy[compno];
1254 if (reslevelno >= codsty->nreslevels)
1257 if (yc % (1LL << (rlevel->log2_prec_height + reducedresno)) && y != tile->coord[1][0]) //FIXME this is a subset of the check
1260 if (xc % (1LL << (rlevel->log2_prec_width + reducedresno)) && x != tile->coord[0][0]) //FIXME this is a subset of the check
1263 // check if a precinct exists
1264 prcx = ff_jpeg2000_ceildivpow2(xc, reducedresno) >> rlevel->log2_prec_width;
1265 prcy = ff_jpeg2000_ceildivpow2(yc, reducedresno) >> rlevel->log2_prec_height;
1266 prcx -= ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], reducedresno) >> rlevel->log2_prec_width;
1267 prcy -= ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], reducedresno) >> rlevel->log2_prec_height;
1269 precno = prcx + rlevel->num_precincts_x * prcy;
1272 if (prcx >= rlevel->num_precincts_x || prcy >= rlevel->num_precincts_y) {
1273 av_log(s->avctx, AV_LOG_WARNING, "prc %d %d outside limits %d %d\n",
1274 prcx, prcy, rlevel->num_precincts_x, rlevel->num_precincts_y);
1278 for (layno = 0; layno < LYEpoc; layno++) {
1279 if ((ret = jpeg2000_decode_packet(s, tile, tp_index,
1282 qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1283 qntsty->nguardbits)) < 0)
1292 case JPEG2000_PGOD_PCRL:
1293 av_log(s->avctx, AV_LOG_WARNING, "Progression order PCRL\n");
1296 for (compno = CSpoc; compno < CEpoc; compno++) {
1297 Jpeg2000Component *comp = tile->comp + compno;
1298 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1300 for (reslevelno = RSpoc; reslevelno < FFMIN(codsty->nreslevels, REpoc); reslevelno++) {
1301 uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1302 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1303 step_x = FFMIN(step_x, rlevel->log2_prec_width + reducedresno);
1304 step_y = FFMIN(step_y, rlevel->log2_prec_height + reducedresno);
1307 if (step_x >= 31 || step_y >= 31){
1308 avpriv_request_sample(s->avctx, "PCRL with large step");
1309 return AVERROR_PATCHWELCOME;
1314 for (y = tile->coord[1][0]; y < tile->coord[1][1]; y = (y/step_y + 1)*step_y) {
1315 for (x = tile->coord[0][0]; x < tile->coord[0][1]; x = (x/step_x + 1)*step_x) {
1316 for (compno = CSpoc; compno < CEpoc; compno++) {
1317 Jpeg2000Component *comp = tile->comp + compno;
1318 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1319 Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
1320 int xc = x / s->cdx[compno];
1321 int yc = y / s->cdy[compno];
1323 for (reslevelno = RSpoc; reslevelno < FFMIN(codsty->nreslevels, REpoc); reslevelno++) {
1324 unsigned prcx, prcy;
1325 uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1326 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1328 if (yc % (1LL << (rlevel->log2_prec_height + reducedresno)) && y != tile->coord[1][0]) //FIXME this is a subset of the check
1331 if (xc % (1LL << (rlevel->log2_prec_width + reducedresno)) && x != tile->coord[0][0]) //FIXME this is a subset of the check
1334 // check if a precinct exists
1335 prcx = ff_jpeg2000_ceildivpow2(xc, reducedresno) >> rlevel->log2_prec_width;
1336 prcy = ff_jpeg2000_ceildivpow2(yc, reducedresno) >> rlevel->log2_prec_height;
1337 prcx -= ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], reducedresno) >> rlevel->log2_prec_width;
1338 prcy -= ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], reducedresno) >> rlevel->log2_prec_height;
1340 precno = prcx + rlevel->num_precincts_x * prcy;
1342 if (prcx >= rlevel->num_precincts_x || prcy >= rlevel->num_precincts_y) {
1343 av_log(s->avctx, AV_LOG_WARNING, "prc %d %d outside limits %d %d\n",
1344 prcx, prcy, rlevel->num_precincts_x, rlevel->num_precincts_y);
1348 for (layno = 0; layno < LYEpoc; layno++) {
1349 if ((ret = jpeg2000_decode_packet(s, tile, tp_index, codsty, rlevel,
1351 qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1352 qntsty->nguardbits)) < 0)
1368 static int jpeg2000_decode_packets(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
1370 int ret = AVERROR_BUG;
1375 if (tile->poc.nb_poc) {
1376 for (i=0; i<tile->poc.nb_poc; i++) {
1377 Jpeg2000POCEntry *e = &tile->poc.poc[i];
1378 ret = jpeg2000_decode_packets_po_iteration(s, tile,
1380 FFMIN(e->LYEpoc, tile->codsty[0].nlayers),
1382 FFMIN(e->CEpoc, s->ncomponents),
1389 ret = jpeg2000_decode_packets_po_iteration(s, tile,
1391 tile->codsty[0].nlayers,
1394 tile->codsty[0].prog_order,
1398 /* EOC marker reached */
1399 bytestream2_skip(&s->g, 2);
1404 /* TIER-1 routines */
1405 static void decode_sigpass(Jpeg2000T1Context *t1, int width, int height,
1406 int bpno, int bandno,
1407 int vert_causal_ctx_csty_symbol)
1409 int mask = 3 << (bpno - 1), y0, x, y;
1411 for (y0 = 0; y0 < height; y0 += 4)
1412 for (x = 0; x < width; x++)
1413 for (y = y0; y < height && y < y0 + 4; y++) {
1414 int flags_mask = -1;
1415 if (vert_causal_ctx_csty_symbol && y == y0 + 3)
1416 flags_mask &= ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE | JPEG2000_T1_SGN_S);
1417 if ((t1->flags[(y+1) * t1->stride + x+1] & JPEG2000_T1_SIG_NB & flags_mask)
1418 && !(t1->flags[(y+1) * t1->stride + x+1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS))) {
1419 if (ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ff_jpeg2000_getsigctxno(t1->flags[(y+1) * t1->stride + x+1] & flags_mask, bandno))) {
1420 int xorbit, ctxno = ff_jpeg2000_getsgnctxno(t1->flags[(y+1) * t1->stride + x+1] & flags_mask, &xorbit);
1422 t1->data[(y) * t1->stride + x] = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ctxno) ? -mask : mask;
1424 t1->data[(y) * t1->stride + x] = (ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ctxno) ^ xorbit) ?
1427 ff_jpeg2000_set_significance(t1, x, y,
1428 t1->data[(y) * t1->stride + x] < 0);
1430 t1->flags[(y + 1) * t1->stride + x + 1] |= JPEG2000_T1_VIS;
1435 static void decode_refpass(Jpeg2000T1Context *t1, int width, int height,
1436 int bpno, int vert_causal_ctx_csty_symbol)
1441 phalf = 1 << (bpno - 1);
1444 for (y0 = 0; y0 < height; y0 += 4)
1445 for (x = 0; x < width; x++)
1446 for (y = y0; y < height && y < y0 + 4; y++)
1447 if ((t1->flags[(y + 1) * t1->stride + x + 1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS)) == JPEG2000_T1_SIG) {
1448 int flags_mask = (vert_causal_ctx_csty_symbol && y == y0 + 3) ?
1449 ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE | JPEG2000_T1_SGN_S) : -1;
1450 int ctxno = ff_jpeg2000_getrefctxno(t1->flags[(y + 1) * t1->stride + x + 1] & flags_mask);
1451 int r = ff_mqc_decode(&t1->mqc,
1452 t1->mqc.cx_states + ctxno)
1454 t1->data[(y) * t1->stride + x] += t1->data[(y) * t1->stride + x] < 0 ? -r : r;
1455 t1->flags[(y + 1) * t1->stride + x + 1] |= JPEG2000_T1_REF;
1459 static void decode_clnpass(Jpeg2000DecoderContext *s, Jpeg2000T1Context *t1,
1460 int width, int height, int bpno, int bandno,
1461 int seg_symbols, int vert_causal_ctx_csty_symbol)
1463 int mask = 3 << (bpno - 1), y0, x, y, runlen, dec;
1465 for (y0 = 0; y0 < height; y0 += 4) {
1466 for (x = 0; x < width; x++) {
1467 int flags_mask = -1;
1468 if (vert_causal_ctx_csty_symbol)
1469 flags_mask &= ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE | JPEG2000_T1_SGN_S);
1470 if (y0 + 3 < height &&
1471 !((t1->flags[(y0 + 1) * t1->stride + x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
1472 (t1->flags[(y0 + 2) * t1->stride + x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
1473 (t1->flags[(y0 + 3) * t1->stride + x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
1474 (t1->flags[(y0 + 4) * t1->stride + x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG) & flags_mask))) {
1475 if (!ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_RL))
1477 runlen = ff_mqc_decode(&t1->mqc,
1478 t1->mqc.cx_states + MQC_CX_UNI);
1479 runlen = (runlen << 1) | ff_mqc_decode(&t1->mqc,
1488 for (y = y0 + runlen; y < y0 + 4 && y < height; y++) {
1489 int flags_mask = -1;
1490 if (vert_causal_ctx_csty_symbol && y == y0 + 3)
1491 flags_mask &= ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE | JPEG2000_T1_SGN_S);
1493 if (!(t1->flags[(y+1) * t1->stride + x+1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS))) {
1494 dec = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ff_jpeg2000_getsigctxno(t1->flags[(y+1) * t1->stride + x+1] & flags_mask,
1500 int ctxno = ff_jpeg2000_getsgnctxno(t1->flags[(y + 1) * t1->stride + x + 1] & flags_mask,
1502 t1->data[(y) * t1->stride + x] = (ff_mqc_decode(&t1->mqc,
1503 t1->mqc.cx_states + ctxno) ^
1506 ff_jpeg2000_set_significance(t1, x, y, t1->data[(y) * t1->stride + x] < 0);
1509 t1->flags[(y + 1) * t1->stride + x + 1] &= ~JPEG2000_T1_VIS;
1515 val = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1516 val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1517 val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1518 val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1520 av_log(s->avctx, AV_LOG_ERROR,
1521 "Segmentation symbol value incorrect\n");
1525 static int decode_cblk(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *codsty,
1526 Jpeg2000T1Context *t1, Jpeg2000Cblk *cblk,
1527 int width, int height, int bandpos)
1529 int passno = cblk->npasses, pass_t = 2, bpno = cblk->nonzerobits - 1;
1531 int vert_causal_ctx_csty_symbol = codsty->cblk_style & JPEG2000_CBLK_VSC;
1535 av_assert0(width <= 1024U && height <= 1024U);
1536 av_assert0(width*height <= 4096);
1538 memset(t1->data, 0, t1->stride * height * sizeof(*t1->data));
1540 /* If code-block contains no compressed data: nothing to do. */
1544 memset(t1->flags, 0, t1->stride * (height + 2) * sizeof(*t1->flags));
1546 cblk->data[cblk->length] = 0xff;
1547 cblk->data[cblk->length+1] = 0xff;
1548 ff_mqc_initdec(&t1->mqc, cblk->data, 0, 1);
1552 av_log(s->avctx, AV_LOG_ERROR, "bpno became negative\n");
1553 return AVERROR_INVALIDDATA;
1557 decode_sigpass(t1, width, height, bpno + 1, bandpos,
1558 vert_causal_ctx_csty_symbol);
1561 decode_refpass(t1, width, height, bpno + 1, vert_causal_ctx_csty_symbol);
1564 av_assert2(!t1->mqc.raw);
1565 decode_clnpass(s, t1, width, height, bpno + 1, bandpos,
1566 codsty->cblk_style & JPEG2000_CBLK_SEGSYM,
1567 vert_causal_ctx_csty_symbol);
1570 if (codsty->cblk_style & JPEG2000_CBLK_RESET) // XXX no testcase for just this
1571 ff_mqc_init_contexts(&t1->mqc);
1573 if (passno && (coder_type = needs_termination(codsty->cblk_style, pass_cnt))) {
1574 if (term_cnt >= cblk->nb_terminations) {
1575 av_log(s->avctx, AV_LOG_ERROR, "Missing needed termination \n");
1576 return AVERROR_INVALIDDATA;
1578 if (FFABS(cblk->data + cblk->data_start[term_cnt + 1] - 2 - t1->mqc.bp) > 0) {
1579 av_log(s->avctx, AV_LOG_WARNING, "Mid mismatch %"PTRDIFF_SPECIFIER" in pass %d of %d\n",
1580 cblk->data + cblk->data_start[term_cnt + 1] - 2 - t1->mqc.bp,
1581 pass_cnt, cblk->npasses);
1584 ff_mqc_initdec(&t1->mqc, cblk->data + cblk->data_start[++term_cnt], coder_type == 2, 0);
1595 if (cblk->data + cblk->length - 2*(term_cnt < cblk->nb_terminations) != t1->mqc.bp) {
1596 av_log(s->avctx, AV_LOG_WARNING, "End mismatch %"PTRDIFF_SPECIFIER"\n",
1597 cblk->data + cblk->length - 2*(term_cnt < cblk->nb_terminations) - t1->mqc.bp);
1603 /* TODO: Verify dequantization for lossless case
1604 * comp->data can be float or int
1605 * band->stepsize can be float or int
1606 * depending on the type of DWT transformation.
1607 * see ISO/IEC 15444-1:2002 A.6.1 */
1609 /* Float dequantization of a codeblock.*/
1610 static void dequantization_float(int x, int y, Jpeg2000Cblk *cblk,
1611 Jpeg2000Component *comp,
1612 Jpeg2000T1Context *t1, Jpeg2000Band *band)
1615 int w = cblk->coord[0][1] - cblk->coord[0][0];
1616 for (j = 0; j < (cblk->coord[1][1] - cblk->coord[1][0]); ++j) {
1617 float *datap = &comp->f_data[(comp->coord[0][1] - comp->coord[0][0]) * (y + j) + x];
1618 int *src = t1->data + j*t1->stride;
1619 for (i = 0; i < w; ++i)
1620 datap[i] = src[i] * band->f_stepsize;
1624 /* Integer dequantization of a codeblock.*/
1625 static void dequantization_int(int x, int y, Jpeg2000Cblk *cblk,
1626 Jpeg2000Component *comp,
1627 Jpeg2000T1Context *t1, Jpeg2000Band *band)
1630 int w = cblk->coord[0][1] - cblk->coord[0][0];
1631 for (j = 0; j < (cblk->coord[1][1] - cblk->coord[1][0]); ++j) {
1632 int32_t *datap = &comp->i_data[(comp->coord[0][1] - comp->coord[0][0]) * (y + j) + x];
1633 int *src = t1->data + j*t1->stride;
1634 if (band->i_stepsize == 32768) {
1635 for (i = 0; i < w; ++i)
1636 datap[i] = src[i] / 2;
1638 // This should be VERY uncommon
1639 for (i = 0; i < w; ++i)
1640 datap[i] = (src[i] * (int64_t)band->i_stepsize) / 65536;
1645 static void dequantization_int_97(int x, int y, Jpeg2000Cblk *cblk,
1646 Jpeg2000Component *comp,
1647 Jpeg2000T1Context *t1, Jpeg2000Band *band)
1650 int w = cblk->coord[0][1] - cblk->coord[0][0];
1651 for (j = 0; j < (cblk->coord[1][1] - cblk->coord[1][0]); ++j) {
1652 int32_t *datap = &comp->i_data[(comp->coord[0][1] - comp->coord[0][0]) * (y + j) + x];
1653 int *src = t1->data + j*t1->stride;
1654 for (i = 0; i < w; ++i)
1655 datap[i] = (src[i] * (int64_t)band->i_stepsize + (1<<15)) >> 16;
1659 static inline void mct_decode(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
1664 for (i = 1; i < 3; i++) {
1665 if (tile->codsty[0].transform != tile->codsty[i].transform) {
1666 av_log(s->avctx, AV_LOG_ERROR, "Transforms mismatch, MCT not supported\n");
1669 if (memcmp(tile->comp[0].coord, tile->comp[i].coord, sizeof(tile->comp[0].coord))) {
1670 av_log(s->avctx, AV_LOG_ERROR, "Coords mismatch, MCT not supported\n");
1675 for (i = 0; i < 3; i++)
1676 if (tile->codsty[0].transform == FF_DWT97)
1677 src[i] = tile->comp[i].f_data;
1679 src[i] = tile->comp[i].i_data;
1681 for (i = 0; i < 2; i++)
1682 csize *= tile->comp[0].coord[i][1] - tile->comp[0].coord[i][0];
1684 s->dsp.mct_decode[tile->codsty[0].transform](src[0], src[1], src[2], csize);
1687 static inline void tile_codeblocks(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
1689 Jpeg2000T1Context t1;
1691 int compno, reslevelno, bandno;
1693 /* Loop on tile components */
1694 for (compno = 0; compno < s->ncomponents; compno++) {
1695 Jpeg2000Component *comp = tile->comp + compno;
1696 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1698 t1.stride = (1<<codsty->log2_cblk_width) + 2;
1700 /* Loop on resolution levels */
1701 for (reslevelno = 0; reslevelno < codsty->nreslevels2decode; reslevelno++) {
1702 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1704 for (bandno = 0; bandno < rlevel->nbands; bandno++) {
1705 int nb_precincts, precno;
1706 Jpeg2000Band *band = rlevel->band + bandno;
1707 int cblkno = 0, bandpos;
1709 bandpos = bandno + (reslevelno > 0);
1711 if (band->coord[0][0] == band->coord[0][1] ||
1712 band->coord[1][0] == band->coord[1][1])
1715 nb_precincts = rlevel->num_precincts_x * rlevel->num_precincts_y;
1716 /* Loop on precincts */
1717 for (precno = 0; precno < nb_precincts; precno++) {
1718 Jpeg2000Prec *prec = band->prec + precno;
1720 /* Loop on codeblocks */
1722 cblkno < prec->nb_codeblocks_width * prec->nb_codeblocks_height;
1725 Jpeg2000Cblk *cblk = prec->cblk + cblkno;
1726 decode_cblk(s, codsty, &t1, cblk,
1727 cblk->coord[0][1] - cblk->coord[0][0],
1728 cblk->coord[1][1] - cblk->coord[1][0],
1731 x = cblk->coord[0][0] - band->coord[0][0];
1732 y = cblk->coord[1][0] - band->coord[1][0];
1734 if (codsty->transform == FF_DWT97)
1735 dequantization_float(x, y, cblk, comp, &t1, band);
1736 else if (codsty->transform == FF_DWT97_INT)
1737 dequantization_int_97(x, y, cblk, comp, &t1, band);
1739 dequantization_int(x, y, cblk, comp, &t1, band);
1743 } /* end reslevel */
1746 ff_dwt_decode(&comp->dwt, codsty->transform == FF_DWT97 ? (void*)comp->f_data : (void*)comp->i_data);
1750 #define WRITE_FRAME(D, PIXEL) \
1751 static inline void write_frame_ ## D(Jpeg2000DecoderContext * s, Jpeg2000Tile * tile, \
1752 AVFrame * picture, int precision) \
1754 const AVPixFmtDescriptor *pixdesc = av_pix_fmt_desc_get(s->avctx->pix_fmt); \
1755 int planar = !!(pixdesc->flags & AV_PIX_FMT_FLAG_PLANAR); \
1756 int pixelsize = planar ? 1 : pixdesc->nb_components; \
1761 for (compno = 0; compno < s->ncomponents; compno++) { \
1762 Jpeg2000Component *comp = tile->comp + compno; \
1763 Jpeg2000CodingStyle *codsty = tile->codsty + compno; \
1765 float *datap = comp->f_data; \
1766 int32_t *i_datap = comp->i_data; \
1767 int cbps = s->cbps[compno]; \
1768 int w = tile->comp[compno].coord[0][1] - s->image_offset_x; \
1772 plane = s->cdef[compno] ? s->cdef[compno]-1 : (s->ncomponents-1); \
1774 y = tile->comp[compno].coord[1][0] - s->image_offset_y / s->cdy[compno]; \
1775 line = (PIXEL *)picture->data[plane] + y * (picture->linesize[plane] / sizeof(PIXEL));\
1776 for (; y < tile->comp[compno].coord[1][1] - s->image_offset_y; y++) { \
1779 x = tile->comp[compno].coord[0][0] - s->image_offset_x / s->cdx[compno]; \
1780 dst = line + x * pixelsize + compno*!planar; \
1782 if (codsty->transform == FF_DWT97) { \
1783 for (; x < w; x++) { \
1784 int val = lrintf(*datap) + (1 << (cbps - 1)); \
1785 /* DC level shift and clip see ISO 15444-1:2002 G.1.2 */ \
1786 val = av_clip(val, 0, (1 << cbps) - 1); \
1787 *dst = val << (precision - cbps); \
1792 for (; x < w; x++) { \
1793 int val = *i_datap + (1 << (cbps - 1)); \
1794 /* DC level shift and clip see ISO 15444-1:2002 G.1.2 */ \
1795 val = av_clip(val, 0, (1 << cbps) - 1); \
1796 *dst = val << (precision - cbps); \
1801 line += picture->linesize[plane] / sizeof(PIXEL); \
1807 WRITE_FRAME(8, uint8_t)
1808 WRITE_FRAME(16, uint16_t)
1812 static int jpeg2000_decode_tile(AVCodecContext *avctx, void *td,
1813 int jobnr, int threadnr)
1815 Jpeg2000DecoderContext *s = avctx->priv_data;
1816 AVFrame *picture = td;
1817 Jpeg2000Tile *tile = s->tile + jobnr;
1820 tile_codeblocks(s, tile);
1822 /* inverse MCT transformation */
1823 if (tile->codsty[0].mct)
1824 mct_decode(s, tile);
1826 for (x = 0; x < s->ncomponents; x++) {
1827 if (s->cdef[x] < 0) {
1828 for (x = 0; x < s->ncomponents; x++) {
1831 if ((s->ncomponents & 1) == 0)
1832 s->cdef[s->ncomponents-1] = 0;
1837 if (s->precision <= 8) {
1838 write_frame_8(s, tile, picture, 8);
1840 int precision = picture->format == AV_PIX_FMT_XYZ12 ||
1841 picture->format == AV_PIX_FMT_RGB48 ||
1842 picture->format == AV_PIX_FMT_RGBA64 ||
1843 picture->format == AV_PIX_FMT_GRAY16 ? 16 : s->precision;
1845 write_frame_16(s, tile, picture, precision);
1851 static void jpeg2000_dec_cleanup(Jpeg2000DecoderContext *s)
1854 for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++) {
1855 if (s->tile[tileno].comp) {
1856 for (compno = 0; compno < s->ncomponents; compno++) {
1857 Jpeg2000Component *comp = s->tile[tileno].comp + compno;
1858 Jpeg2000CodingStyle *codsty = s->tile[tileno].codsty + compno;
1860 ff_jpeg2000_cleanup(comp, codsty);
1862 av_freep(&s->tile[tileno].comp);
1866 memset(s->codsty, 0, sizeof(s->codsty));
1867 memset(s->qntsty, 0, sizeof(s->qntsty));
1868 memset(s->properties, 0, sizeof(s->properties));
1869 memset(&s->poc , 0, sizeof(s->poc));
1870 s->numXtiles = s->numYtiles = 0;
1874 static int jpeg2000_read_main_headers(Jpeg2000DecoderContext *s)
1876 Jpeg2000CodingStyle *codsty = s->codsty;
1877 Jpeg2000QuantStyle *qntsty = s->qntsty;
1878 Jpeg2000POC *poc = &s->poc;
1879 uint8_t *properties = s->properties;
1886 if (bytestream2_get_bytes_left(&s->g) < 2) {
1887 av_log(s->avctx, AV_LOG_ERROR, "Missing EOC\n");
1891 marker = bytestream2_get_be16u(&s->g);
1892 oldpos = bytestream2_tell(&s->g);
1894 if (marker == JPEG2000_SOD) {
1896 Jpeg2000TilePart *tp;
1899 av_log(s->avctx, AV_LOG_ERROR, "Missing SIZ\n");
1900 return AVERROR_INVALIDDATA;
1902 if (s->curtileno < 0) {
1903 av_log(s->avctx, AV_LOG_ERROR, "Missing SOT\n");
1904 return AVERROR_INVALIDDATA;
1907 tile = s->tile + s->curtileno;
1908 tp = tile->tile_part + tile->tp_idx;
1909 if (tp->tp_end < s->g.buffer) {
1910 av_log(s->avctx, AV_LOG_ERROR, "Invalid tpend\n");
1911 return AVERROR_INVALIDDATA;
1913 bytestream2_init(&tp->tpg, s->g.buffer, tp->tp_end - s->g.buffer);
1914 bytestream2_skip(&s->g, tp->tp_end - s->g.buffer);
1918 if (marker == JPEG2000_EOC)
1921 len = bytestream2_get_be16(&s->g);
1922 if (len < 2 || bytestream2_get_bytes_left(&s->g) < len - 2) {
1923 av_log(s->avctx, AV_LOG_ERROR, "Invalid len %d left=%d\n", len, bytestream2_get_bytes_left(&s->g));
1924 return AVERROR_INVALIDDATA;
1929 if (s->ncomponents) {
1930 av_log(s->avctx, AV_LOG_ERROR, "Duplicate SIZ\n");
1931 return AVERROR_INVALIDDATA;
1935 s->numXtiles = s->numYtiles = 0;
1938 ret = get_coc(s, codsty, properties);
1941 ret = get_cod(s, codsty, properties);
1944 ret = get_qcc(s, len, qntsty, properties);
1947 ret = get_qcd(s, len, qntsty, properties);
1950 ret = get_poc(s, len, poc);
1953 if (!(ret = get_sot(s, len))) {
1954 av_assert1(s->curtileno >= 0);
1955 codsty = s->tile[s->curtileno].codsty;
1956 qntsty = s->tile[s->curtileno].qntsty;
1957 poc = &s->tile[s->curtileno].poc;
1958 properties = s->tile[s->curtileno].properties;
1962 // the PLM marker is ignored
1964 // the comment is ignored
1965 bytestream2_skip(&s->g, len - 2);
1968 // Tile-part lengths
1969 ret = get_tlm(s, len);
1972 // Packet length, tile-part header
1973 ret = get_plt(s, len);
1976 av_log(s->avctx, AV_LOG_ERROR,
1977 "unsupported marker 0x%.4"PRIX16" at pos 0x%X\n",
1978 marker, bytestream2_tell(&s->g) - 4);
1979 bytestream2_skip(&s->g, len - 2);
1982 if (bytestream2_tell(&s->g) - oldpos != len || ret) {
1983 av_log(s->avctx, AV_LOG_ERROR,
1984 "error during processing marker segment %.4"PRIx16"\n",
1986 return ret ? ret : -1;
1992 /* Read bit stream packets --> T2 operation. */
1993 static int jpeg2000_read_bitstream_packets(Jpeg2000DecoderContext *s)
1998 for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++) {
1999 Jpeg2000Tile *tile = s->tile + tileno;
2001 if ((ret = init_tile(s, tileno)) < 0)
2004 s->g = tile->tile_part[0].tpg;
2005 if ((ret = jpeg2000_decode_packets(s, tile)) < 0)
2012 static int jp2_find_codestream(Jpeg2000DecoderContext *s)
2014 uint32_t atom_size, atom, atom_end;
2015 int search_range = 10;
2019 bytestream2_get_bytes_left(&s->g) >= 8) {
2020 atom_size = bytestream2_get_be32u(&s->g);
2021 atom = bytestream2_get_be32u(&s->g);
2022 if (atom_size == 1) {
2023 if (bytestream2_get_be32u(&s->g)) {
2024 avpriv_request_sample(s->avctx, "Huge atom");
2027 atom_size = bytestream2_get_be32u(&s->g);
2028 atom_end = bytestream2_tell(&s->g) + atom_size - 16;
2030 atom_end = bytestream2_tell(&s->g) + atom_size - 8;
2033 if (atom == JP2_CODESTREAM)
2036 if (bytestream2_get_bytes_left(&s->g) < atom_size || atom_end < atom_size)
2039 if (atom == JP2_HEADER &&
2041 uint32_t atom2_size, atom2, atom2_end;
2043 atom2_size = bytestream2_get_be32u(&s->g);
2044 atom2 = bytestream2_get_be32u(&s->g);
2045 atom2_end = bytestream2_tell(&s->g) + atom2_size - 8;
2046 if (atom2_size < 8 || atom2_end > atom_end || atom2_end < atom2_size)
2049 if (atom2 == JP2_CODESTREAM) {
2051 } else if (atom2 == MKBETAG('c','o','l','r') && atom2_size >= 7) {
2052 int method = bytestream2_get_byteu(&s->g);
2053 bytestream2_skipu(&s->g, 2);
2055 s->colour_space = bytestream2_get_be32u(&s->g);
2057 } else if (atom2 == MKBETAG('p','c','l','r') && atom2_size >= 6) {
2058 int i, size, colour_count, colour_channels, colour_depth[3];
2059 colour_count = bytestream2_get_be16u(&s->g);
2060 colour_channels = bytestream2_get_byteu(&s->g);
2061 // FIXME: Do not ignore channel_sign
2062 colour_depth[0] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1;
2063 colour_depth[1] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1;
2064 colour_depth[2] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1;
2065 size = (colour_depth[0] + 7 >> 3) * colour_count +
2066 (colour_depth[1] + 7 >> 3) * colour_count +
2067 (colour_depth[2] + 7 >> 3) * colour_count;
2068 if (colour_count > AVPALETTE_COUNT ||
2069 colour_channels != 3 ||
2070 colour_depth[0] > 16 ||
2071 colour_depth[1] > 16 ||
2072 colour_depth[2] > 16 ||
2073 atom2_size < size) {
2074 avpriv_request_sample(s->avctx, "Unknown palette");
2075 bytestream2_seek(&s->g, atom2_end, SEEK_SET);
2079 for (i = 0; i < colour_count; i++) {
2081 if (colour_depth[0] <= 8) {
2082 r = bytestream2_get_byteu(&s->g) << 8 - colour_depth[0];
2083 r |= r >> colour_depth[0];
2085 r = bytestream2_get_be16u(&s->g) >> colour_depth[0] - 8;
2087 if (colour_depth[1] <= 8) {
2088 g = bytestream2_get_byteu(&s->g) << 8 - colour_depth[1];
2089 g |= g >> colour_depth[1];
2091 g = bytestream2_get_be16u(&s->g) >> colour_depth[1] - 8;
2093 if (colour_depth[2] <= 8) {
2094 b = bytestream2_get_byteu(&s->g) << 8 - colour_depth[2];
2095 b |= b >> colour_depth[2];
2097 b = bytestream2_get_be16u(&s->g) >> colour_depth[2] - 8;
2099 s->palette[i] = 0xffu << 24 | r << 16 | g << 8 | b;
2101 } else if (atom2 == MKBETAG('c','d','e','f') && atom2_size >= 2) {
2102 int n = bytestream2_get_be16u(&s->g);
2104 int cn = bytestream2_get_be16(&s->g);
2105 int av_unused typ = bytestream2_get_be16(&s->g);
2106 int asoc = bytestream2_get_be16(&s->g);
2107 if (cn < 4 && asoc < 4)
2110 } else if (atom2 == MKBETAG('r','e','s',' ') && atom2_size >= 18) {
2111 int64_t vnum, vden, hnum, hden, vexp, hexp;
2113 bytestream2_skip(&s->g, 4);
2114 resx = bytestream2_get_be32u(&s->g);
2115 if (resx != MKBETAG('r','e','s','c') && resx != MKBETAG('r','e','s','d')) {
2116 bytestream2_seek(&s->g, atom2_end, SEEK_SET);
2119 vnum = bytestream2_get_be16u(&s->g);
2120 vden = bytestream2_get_be16u(&s->g);
2121 hnum = bytestream2_get_be16u(&s->g);
2122 hden = bytestream2_get_be16u(&s->g);
2123 vexp = bytestream2_get_byteu(&s->g);
2124 hexp = bytestream2_get_byteu(&s->g);
2125 if (!vnum || !vden || !hnum || !hden) {
2126 bytestream2_seek(&s->g, atom2_end, SEEK_SET);
2127 av_log(s->avctx, AV_LOG_WARNING, "RES box invalid\n");
2137 if ( INT64_MAX / (hnum * vden) > pow(10, hexp)
2138 && INT64_MAX / (vnum * hden) > pow(10, vexp))
2139 av_reduce(&s->sar.den, &s->sar.num,
2140 hnum * vden * pow(10, hexp),
2141 vnum * hden * pow(10, vexp),
2144 bytestream2_seek(&s->g, atom2_end, SEEK_SET);
2145 } while (atom_end - atom2_end >= 8);
2149 bytestream2_seek(&s->g, atom_end, SEEK_SET);
2155 static av_cold void jpeg2000_init_static_data(void)
2157 ff_jpeg2000_init_tier1_luts();
2158 ff_mqc_init_context_tables();
2161 static av_cold int jpeg2000_decode_init(AVCodecContext *avctx)
2163 static AVOnce init_static_once = AV_ONCE_INIT;
2164 Jpeg2000DecoderContext *s = avctx->priv_data;
2166 ff_thread_once(&init_static_once, jpeg2000_init_static_data);
2167 ff_jpeg2000dsp_init(&s->dsp);
2172 static int jpeg2000_decode_frame(AVCodecContext *avctx, void *data,
2173 int *got_frame, AVPacket *avpkt)
2175 Jpeg2000DecoderContext *s = avctx->priv_data;
2176 ThreadFrame frame = { .f = data };
2177 AVFrame *picture = data;
2181 bytestream2_init(&s->g, avpkt->data, avpkt->size);
2183 memset(s->cdef, -1, sizeof(s->cdef));
2185 if (bytestream2_get_bytes_left(&s->g) < 2) {
2186 ret = AVERROR_INVALIDDATA;
2190 // check if the image is in jp2 format
2191 if (bytestream2_get_bytes_left(&s->g) >= 12 &&
2192 (bytestream2_get_be32u(&s->g) == 12) &&
2193 (bytestream2_get_be32u(&s->g) == JP2_SIG_TYPE) &&
2194 (bytestream2_get_be32u(&s->g) == JP2_SIG_VALUE)) {
2195 if (!jp2_find_codestream(s)) {
2196 av_log(avctx, AV_LOG_ERROR,
2197 "Could not find Jpeg2000 codestream atom.\n");
2198 ret = AVERROR_INVALIDDATA;
2202 bytestream2_seek(&s->g, 0, SEEK_SET);
2205 while (bytestream2_get_bytes_left(&s->g) >= 3 && bytestream2_peek_be16(&s->g) != JPEG2000_SOC)
2206 bytestream2_skip(&s->g, 1);
2208 if (bytestream2_get_be16u(&s->g) != JPEG2000_SOC) {
2209 av_log(avctx, AV_LOG_ERROR, "SOC marker not present\n");
2210 ret = AVERROR_INVALIDDATA;
2213 if (ret = jpeg2000_read_main_headers(s))
2216 /* get picture buffer */
2217 if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
2219 picture->pict_type = AV_PICTURE_TYPE_I;
2220 picture->key_frame = 1;
2222 if (ret = jpeg2000_read_bitstream_packets(s))
2225 avctx->execute2(avctx, jpeg2000_decode_tile, picture, NULL, s->numXtiles * s->numYtiles);
2227 jpeg2000_dec_cleanup(s);
2231 if (s->avctx->pix_fmt == AV_PIX_FMT_PAL8)
2232 memcpy(picture->data[1], s->palette, 256 * sizeof(uint32_t));
2233 if (s->sar.num && s->sar.den)
2234 avctx->sample_aspect_ratio = s->sar;
2235 s->sar.num = s->sar.den = 0;
2237 return bytestream2_tell(&s->g);
2240 jpeg2000_dec_cleanup(s);
2244 #define OFFSET(x) offsetof(Jpeg2000DecoderContext, x)
2245 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
2247 static const AVOption options[] = {
2248 { "lowres", "Lower the decoding resolution by a power of two",
2249 OFFSET(reduction_factor), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, JPEG2000_MAX_RESLEVELS - 1, VD },
2253 static const AVClass jpeg2000_class = {
2254 .class_name = "jpeg2000",
2255 .item_name = av_default_item_name,
2257 .version = LIBAVUTIL_VERSION_INT,
2260 AVCodec ff_jpeg2000_decoder = {
2262 .long_name = NULL_IF_CONFIG_SMALL("JPEG 2000"),
2263 .type = AVMEDIA_TYPE_VIDEO,
2264 .id = AV_CODEC_ID_JPEG2000,
2265 .capabilities = AV_CODEC_CAP_SLICE_THREADS | AV_CODEC_CAP_FRAME_THREADS | AV_CODEC_CAP_DR1,
2266 .priv_data_size = sizeof(Jpeg2000DecoderContext),
2267 .init = jpeg2000_decode_init,
2268 .decode = jpeg2000_decode_frame,
2269 .priv_class = &jpeg2000_class,
2271 .profiles = NULL_IF_CONFIG_SMALL(ff_jpeg2000_profiles)