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
30 #include "libavutil/attributes.h"
31 #include "libavutil/avassert.h"
32 #include "libavutil/common.h"
33 #include "libavutil/opt.h"
34 #include "libavutil/pixdesc.h"
36 #include "bytestream.h"
40 #include "jpeg2000dsp.h"
42 #define JP2_SIG_TYPE 0x6A502020
43 #define JP2_SIG_VALUE 0x0D0A870A
44 #define JP2_CODESTREAM 0x6A703263
45 #define JP2_HEADER 0x6A703268
52 typedef struct Jpeg2000POCEntry {
61 typedef struct Jpeg2000POC {
62 Jpeg2000POCEntry poc[MAX_POCS];
67 typedef struct Jpeg2000TilePart {
68 uint8_t tile_index; // Tile index who refers the tile-part
69 const uint8_t *tp_end;
70 GetByteContext tpg; // bit stream in tile-part
73 /* RMK: For JPEG2000 DCINEMA 3 tile-parts in a tile
74 * one per component, so tile_part elements have a size of 3 */
75 typedef struct Jpeg2000Tile {
76 Jpeg2000Component *comp;
77 uint8_t properties[4];
78 Jpeg2000CodingStyle codsty[4];
79 Jpeg2000QuantStyle qntsty[4];
81 Jpeg2000TilePart tile_part[256];
82 uint16_t tp_idx; // Tile-part index
83 int coord[2][2]; // border coordinates {{x0, x1}, {y0, y1}}
86 typedef struct Jpeg2000DecoderContext {
88 AVCodecContext *avctx;
92 int image_offset_x, image_offset_y;
93 int tile_offset_x, tile_offset_y;
94 uint8_t cbps[4]; // bits per sample in particular components
95 uint8_t sgnd[4]; // if a component is signed
96 uint8_t properties[4];
101 uint32_t palette[256];
104 int tile_width, tile_height;
105 unsigned numXtiles, numYtiles;
108 Jpeg2000CodingStyle codsty[4];
109 Jpeg2000QuantStyle qntsty[4];
117 Jpeg2000DSPContext dsp;
119 /*options parameters*/
120 int reduction_factor;
121 } Jpeg2000DecoderContext;
123 /* get_bits functions for JPEG2000 packet bitstream
124 * It is a get_bit function with a bit-stuffing routine. If the value of the
125 * byte is 0xFF, the next byte includes an extra zero bit stuffed into the MSB.
126 * cf. ISO-15444-1:2002 / B.10.1 Bit-stuffing routine */
127 static int get_bits(Jpeg2000DecoderContext *s, int n)
133 if (s->bit_index == 0) {
134 s->bit_index = 7 + (bytestream2_get_byte(&s->g) != 0xFFu);
137 res |= (bytestream2_peek_byte(&s->g) >> s->bit_index) & 1;
142 static void jpeg2000_flush(Jpeg2000DecoderContext *s)
144 if (bytestream2_get_byte(&s->g) == 0xff)
145 bytestream2_skip(&s->g, 1);
149 /* decode the value stored in node */
150 static int tag_tree_decode(Jpeg2000DecoderContext *s, Jpeg2000TgtNode *node,
153 Jpeg2000TgtNode *stack[30];
154 int sp = -1, curval = 0;
157 av_log(s->avctx, AV_LOG_ERROR, "missing node\n");
158 return AVERROR_INVALIDDATA;
161 while (node && !node->vis) {
169 curval = stack[sp]->val;
171 while (curval < threshold && sp >= 0) {
172 if (curval < stack[sp]->val)
173 curval = stack[sp]->val;
174 while (curval < threshold) {
176 if ((ret = get_bits(s, 1)) > 0) {
184 stack[sp]->val = curval;
190 static int pix_fmt_match(enum AVPixelFormat pix_fmt, int components,
191 int bpc, uint32_t log2_chroma_wh, int pal8)
194 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
198 if (desc->nb_components != components) {
202 switch (components) {
204 match = match && desc->comp[3].depth_minus1 + 1 >= bpc &&
205 (log2_chroma_wh >> 14 & 3) == 0 &&
206 (log2_chroma_wh >> 12 & 3) == 0;
208 match = match && desc->comp[2].depth_minus1 + 1 >= bpc &&
209 (log2_chroma_wh >> 10 & 3) == desc->log2_chroma_w &&
210 (log2_chroma_wh >> 8 & 3) == desc->log2_chroma_h;
212 match = match && desc->comp[1].depth_minus1 + 1 >= bpc &&
213 (log2_chroma_wh >> 6 & 3) == desc->log2_chroma_w &&
214 (log2_chroma_wh >> 4 & 3) == desc->log2_chroma_h;
217 match = match && desc->comp[0].depth_minus1 + 1 >= bpc &&
218 (log2_chroma_wh >> 2 & 3) == 0 &&
219 (log2_chroma_wh & 3) == 0 &&
220 (desc->flags & AV_PIX_FMT_FLAG_PAL) == pal8 * AV_PIX_FMT_FLAG_PAL;
225 // pix_fmts with lower bpp have to be listed before
226 // similar pix_fmts with higher bpp.
227 #define RGB_PIXEL_FORMATS AV_PIX_FMT_PAL8,AV_PIX_FMT_RGB24,AV_PIX_FMT_RGBA,AV_PIX_FMT_RGB48,AV_PIX_FMT_RGBA64
228 #define GRAY_PIXEL_FORMATS AV_PIX_FMT_GRAY8,AV_PIX_FMT_GRAY8A,AV_PIX_FMT_GRAY16,AV_PIX_FMT_YA16
229 #define YUV_PIXEL_FORMATS AV_PIX_FMT_YUV410P,AV_PIX_FMT_YUV411P,AV_PIX_FMT_YUVA420P, \
230 AV_PIX_FMT_YUV420P,AV_PIX_FMT_YUV422P,AV_PIX_FMT_YUVA422P, \
231 AV_PIX_FMT_YUV440P,AV_PIX_FMT_YUV444P,AV_PIX_FMT_YUVA444P, \
232 AV_PIX_FMT_YUV420P9,AV_PIX_FMT_YUV422P9,AV_PIX_FMT_YUV444P9, \
233 AV_PIX_FMT_YUVA420P9,AV_PIX_FMT_YUVA422P9,AV_PIX_FMT_YUVA444P9, \
234 AV_PIX_FMT_YUV420P10,AV_PIX_FMT_YUV422P10,AV_PIX_FMT_YUV444P10, \
235 AV_PIX_FMT_YUVA420P10,AV_PIX_FMT_YUVA422P10,AV_PIX_FMT_YUVA444P10, \
236 AV_PIX_FMT_YUV420P12,AV_PIX_FMT_YUV422P12,AV_PIX_FMT_YUV444P12, \
237 AV_PIX_FMT_YUV420P14,AV_PIX_FMT_YUV422P14,AV_PIX_FMT_YUV444P14, \
238 AV_PIX_FMT_YUV420P16,AV_PIX_FMT_YUV422P16,AV_PIX_FMT_YUV444P16, \
239 AV_PIX_FMT_YUVA420P16,AV_PIX_FMT_YUVA422P16,AV_PIX_FMT_YUVA444P16
240 #define XYZ_PIXEL_FORMATS AV_PIX_FMT_XYZ12
242 static const enum AVPixelFormat rgb_pix_fmts[] = {RGB_PIXEL_FORMATS};
243 static const enum AVPixelFormat gray_pix_fmts[] = {GRAY_PIXEL_FORMATS};
244 static const enum AVPixelFormat yuv_pix_fmts[] = {YUV_PIXEL_FORMATS};
245 static const enum AVPixelFormat xyz_pix_fmts[] = {XYZ_PIXEL_FORMATS,
247 static const enum AVPixelFormat all_pix_fmts[] = {RGB_PIXEL_FORMATS,
252 /* marker segments */
253 /* get sizes and offsets of image, tiles; number of components */
254 static int get_siz(Jpeg2000DecoderContext *s)
258 uint32_t log2_chroma_wh = 0;
259 const enum AVPixelFormat *possible_fmts = NULL;
260 int possible_fmts_nb = 0;
262 if (bytestream2_get_bytes_left(&s->g) < 36) {
263 av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for SIZ\n");
264 return AVERROR_INVALIDDATA;
267 s->avctx->profile = bytestream2_get_be16u(&s->g); // Rsiz
268 s->width = bytestream2_get_be32u(&s->g); // Width
269 s->height = bytestream2_get_be32u(&s->g); // Height
270 s->image_offset_x = bytestream2_get_be32u(&s->g); // X0Siz
271 s->image_offset_y = bytestream2_get_be32u(&s->g); // Y0Siz
272 s->tile_width = bytestream2_get_be32u(&s->g); // XTSiz
273 s->tile_height = bytestream2_get_be32u(&s->g); // YTSiz
274 s->tile_offset_x = bytestream2_get_be32u(&s->g); // XT0Siz
275 s->tile_offset_y = bytestream2_get_be32u(&s->g); // YT0Siz
276 ncomponents = bytestream2_get_be16u(&s->g); // CSiz
278 if (s->image_offset_x || s->image_offset_y) {
279 avpriv_request_sample(s->avctx, "Support for image offsets");
280 return AVERROR_PATCHWELCOME;
283 if (ncomponents <= 0) {
284 av_log(s->avctx, AV_LOG_ERROR, "Invalid number of components: %d\n",
286 return AVERROR_INVALIDDATA;
289 if (ncomponents > 4) {
290 avpriv_request_sample(s->avctx, "Support for %d components",
292 return AVERROR_PATCHWELCOME;
295 s->ncomponents = ncomponents;
297 if (s->tile_width <= 0 || s->tile_height <= 0) {
298 av_log(s->avctx, AV_LOG_ERROR, "Invalid tile dimension %dx%d.\n",
299 s->tile_width, s->tile_height);
300 return AVERROR_INVALIDDATA;
303 if (bytestream2_get_bytes_left(&s->g) < 3 * s->ncomponents) {
304 av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for %d components in SIZ\n", s->ncomponents);
305 return AVERROR_INVALIDDATA;
308 for (i = 0; i < s->ncomponents; i++) { // Ssiz_i XRsiz_i, YRsiz_i
309 uint8_t x = bytestream2_get_byteu(&s->g);
310 s->cbps[i] = (x & 0x7f) + 1;
311 s->precision = FFMAX(s->cbps[i], s->precision);
312 s->sgnd[i] = !!(x & 0x80);
313 s->cdx[i] = bytestream2_get_byteu(&s->g);
314 s->cdy[i] = bytestream2_get_byteu(&s->g);
315 if ( !s->cdx[i] || s->cdx[i] == 3 || s->cdx[i] > 4
316 || !s->cdy[i] || s->cdy[i] == 3 || s->cdy[i] > 4) {
317 av_log(s->avctx, AV_LOG_ERROR, "Invalid sample separation %d/%d\n", s->cdx[i], s->cdy[i]);
318 return AVERROR_INVALIDDATA;
320 log2_chroma_wh |= s->cdy[i] >> 1 << i * 4 | s->cdx[i] >> 1 << i * 4 + 2;
323 s->numXtiles = ff_jpeg2000_ceildiv(s->width - s->tile_offset_x, s->tile_width);
324 s->numYtiles = ff_jpeg2000_ceildiv(s->height - s->tile_offset_y, s->tile_height);
326 if (s->numXtiles * (uint64_t)s->numYtiles > INT_MAX/sizeof(*s->tile)) {
327 s->numXtiles = s->numYtiles = 0;
328 return AVERROR(EINVAL);
331 s->tile = av_mallocz_array(s->numXtiles * s->numYtiles, sizeof(*s->tile));
333 s->numXtiles = s->numYtiles = 0;
334 return AVERROR(ENOMEM);
337 for (i = 0; i < s->numXtiles * s->numYtiles; i++) {
338 Jpeg2000Tile *tile = s->tile + i;
340 tile->comp = av_mallocz(s->ncomponents * sizeof(*tile->comp));
342 return AVERROR(ENOMEM);
345 /* compute image size with reduction factor */
346 s->avctx->width = ff_jpeg2000_ceildivpow2(s->width - s->image_offset_x,
347 s->reduction_factor);
348 s->avctx->height = ff_jpeg2000_ceildivpow2(s->height - s->image_offset_y,
349 s->reduction_factor);
351 if (s->avctx->profile == FF_PROFILE_JPEG2000_DCINEMA_2K ||
352 s->avctx->profile == FF_PROFILE_JPEG2000_DCINEMA_4K) {
353 possible_fmts = xyz_pix_fmts;
354 possible_fmts_nb = FF_ARRAY_ELEMS(xyz_pix_fmts);
356 switch (s->colour_space) {
358 possible_fmts = rgb_pix_fmts;
359 possible_fmts_nb = FF_ARRAY_ELEMS(rgb_pix_fmts);
362 possible_fmts = gray_pix_fmts;
363 possible_fmts_nb = FF_ARRAY_ELEMS(gray_pix_fmts);
366 possible_fmts = yuv_pix_fmts;
367 possible_fmts_nb = FF_ARRAY_ELEMS(yuv_pix_fmts);
370 possible_fmts = all_pix_fmts;
371 possible_fmts_nb = FF_ARRAY_ELEMS(all_pix_fmts);
375 for (i = 0; i < possible_fmts_nb; ++i) {
376 if (pix_fmt_match(possible_fmts[i], ncomponents, s->precision, log2_chroma_wh, s->pal8)) {
377 s->avctx->pix_fmt = possible_fmts[i];
382 if (i == possible_fmts_nb) {
383 if (ncomponents == 4 &&
384 s->cdy[0] == 1 && s->cdx[0] == 1 &&
385 s->cdy[1] == 1 && s->cdx[1] == 1 &&
386 s->cdy[2] == s->cdy[3] && s->cdx[2] == s->cdx[3]) {
387 if (s->precision == 8 && s->cdy[2] == 2 && s->cdx[2] == 2 && !s->pal8) {
388 s->avctx->pix_fmt = AV_PIX_FMT_YUVA420P;
399 if (i == possible_fmts_nb) {
400 av_log(s->avctx, AV_LOG_ERROR,
401 "Unknown pix_fmt, profile: %d, colour_space: %d, "
402 "components: %d, precision: %d\n"
403 "cdx[0]: %d, cdy[0]: %d\n"
404 "cdx[1]: %d, cdy[1]: %d\n"
405 "cdx[2]: %d, cdy[2]: %d\n"
406 "cdx[3]: %d, cdy[3]: %d\n",
407 s->avctx->profile, s->colour_space, ncomponents, s->precision,
410 ncomponents > 1 ? s->cdx[1] : 0,
411 ncomponents > 1 ? s->cdy[1] : 0,
412 ncomponents > 2 ? s->cdx[2] : 0,
413 ncomponents > 2 ? s->cdy[2] : 0,
414 ncomponents > 3 ? s->cdx[3] : 0,
415 ncomponents > 3 ? s->cdy[3] : 0);
416 return AVERROR_PATCHWELCOME;
418 s->avctx->bits_per_raw_sample = s->precision;
422 /* get common part for COD and COC segments */
423 static int get_cox(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c)
427 if (bytestream2_get_bytes_left(&s->g) < 5) {
428 av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for COX\n");
429 return AVERROR_INVALIDDATA;
432 /* nreslevels = number of resolution levels
433 = number of decomposition level +1 */
434 c->nreslevels = bytestream2_get_byteu(&s->g) + 1;
435 if (c->nreslevels >= JPEG2000_MAX_RESLEVELS) {
436 av_log(s->avctx, AV_LOG_ERROR, "nreslevels %d is invalid\n", c->nreslevels);
437 return AVERROR_INVALIDDATA;
440 if (c->nreslevels <= s->reduction_factor) {
441 /* we are forced to update reduction_factor as its requested value is
442 not compatible with this bitstream, and as we might have used it
443 already in setup earlier we have to fail this frame until
444 reinitialization is implemented */
445 av_log(s->avctx, AV_LOG_ERROR, "reduction_factor too large for this bitstream, max is %d\n", c->nreslevels - 1);
446 s->reduction_factor = c->nreslevels - 1;
447 return AVERROR(EINVAL);
450 /* compute number of resolution levels to decode */
451 c->nreslevels2decode = c->nreslevels - s->reduction_factor;
453 c->log2_cblk_width = (bytestream2_get_byteu(&s->g) & 15) + 2; // cblk width
454 c->log2_cblk_height = (bytestream2_get_byteu(&s->g) & 15) + 2; // cblk height
456 if (c->log2_cblk_width > 10 || c->log2_cblk_height > 10 ||
457 c->log2_cblk_width + c->log2_cblk_height > 12) {
458 av_log(s->avctx, AV_LOG_ERROR, "cblk size invalid\n");
459 return AVERROR_INVALIDDATA;
462 c->cblk_style = bytestream2_get_byteu(&s->g);
463 if (c->cblk_style != 0) { // cblk style
464 av_log(s->avctx, AV_LOG_WARNING, "extra cblk styles %X\n", c->cblk_style);
465 if (c->cblk_style & JPEG2000_CBLK_BYPASS)
466 av_log(s->avctx, AV_LOG_WARNING, "Selective arithmetic coding bypass\n");
468 c->transform = bytestream2_get_byteu(&s->g); // DWT transformation type
469 /* set integer 9/7 DWT in case of BITEXACT flag */
470 if ((s->avctx->flags & AV_CODEC_FLAG_BITEXACT) && (c->transform == FF_DWT97))
471 c->transform = FF_DWT97_INT;
472 else if (c->transform == FF_DWT53) {
473 s->avctx->properties |= FF_CODEC_PROPERTY_LOSSLESS;
476 if (c->csty & JPEG2000_CSTY_PREC) {
478 for (i = 0; i < c->nreslevels; i++) {
479 byte = bytestream2_get_byte(&s->g);
480 c->log2_prec_widths[i] = byte & 0x0F; // precinct PPx
481 c->log2_prec_heights[i] = (byte >> 4) & 0x0F; // precinct PPy
483 if (c->log2_prec_widths[i] == 0 || c->log2_prec_heights[i] == 0) {
484 av_log(s->avctx, AV_LOG_ERROR, "PPx %d PPy %d invalid\n",
485 c->log2_prec_widths[i], c->log2_prec_heights[i]);
486 c->log2_prec_widths[i] = c->log2_prec_heights[i] = 1;
487 return AVERROR_INVALIDDATA;
491 memset(c->log2_prec_widths , 15, sizeof(c->log2_prec_widths ));
492 memset(c->log2_prec_heights, 15, sizeof(c->log2_prec_heights));
497 /* get coding parameters for a particular tile or whole image*/
498 static int get_cod(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c,
501 Jpeg2000CodingStyle tmp;
504 if (bytestream2_get_bytes_left(&s->g) < 5) {
505 av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for COD\n");
506 return AVERROR_INVALIDDATA;
509 tmp.csty = bytestream2_get_byteu(&s->g);
511 // get progression order
512 tmp.prog_order = bytestream2_get_byteu(&s->g);
514 tmp.nlayers = bytestream2_get_be16u(&s->g);
515 tmp.mct = bytestream2_get_byteu(&s->g); // multiple component transformation
517 if (tmp.mct && s->ncomponents < 3) {
518 av_log(s->avctx, AV_LOG_ERROR,
519 "MCT %"PRIu8" with too few components (%d)\n",
520 tmp.mct, s->ncomponents);
521 return AVERROR_INVALIDDATA;
524 if ((ret = get_cox(s, &tmp)) < 0)
527 for (compno = 0; compno < s->ncomponents; compno++)
528 if (!(properties[compno] & HAD_COC))
529 memcpy(c + compno, &tmp, sizeof(tmp));
533 /* Get coding parameters for a component in the whole image or a
534 * particular tile. */
535 static int get_coc(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c,
540 if (bytestream2_get_bytes_left(&s->g) < 2) {
541 av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for COC\n");
542 return AVERROR_INVALIDDATA;
545 compno = bytestream2_get_byteu(&s->g);
547 if (compno >= s->ncomponents) {
548 av_log(s->avctx, AV_LOG_ERROR,
549 "Invalid compno %d. There are %d components in the image.\n",
550 compno, s->ncomponents);
551 return AVERROR_INVALIDDATA;
555 c->csty = bytestream2_get_byteu(&s->g);
557 if ((ret = get_cox(s, c)) < 0)
560 properties[compno] |= HAD_COC;
564 /* Get common part for QCD and QCC segments. */
565 static int get_qcx(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q)
569 if (bytestream2_get_bytes_left(&s->g) < 1)
570 return AVERROR_INVALIDDATA;
572 x = bytestream2_get_byteu(&s->g); // Sqcd
574 q->nguardbits = x >> 5;
575 q->quantsty = x & 0x1f;
577 if (q->quantsty == JPEG2000_QSTY_NONE) {
579 if (bytestream2_get_bytes_left(&s->g) < n ||
580 n > JPEG2000_MAX_DECLEVELS*3)
581 return AVERROR_INVALIDDATA;
582 for (i = 0; i < n; i++)
583 q->expn[i] = bytestream2_get_byteu(&s->g) >> 3;
584 } else if (q->quantsty == JPEG2000_QSTY_SI) {
585 if (bytestream2_get_bytes_left(&s->g) < 2)
586 return AVERROR_INVALIDDATA;
587 x = bytestream2_get_be16u(&s->g);
588 q->expn[0] = x >> 11;
589 q->mant[0] = x & 0x7ff;
590 for (i = 1; i < JPEG2000_MAX_DECLEVELS * 3; i++) {
591 int curexpn = FFMAX(0, q->expn[0] - (i - 1) / 3);
592 q->expn[i] = curexpn;
593 q->mant[i] = q->mant[0];
597 if (bytestream2_get_bytes_left(&s->g) < 2 * n ||
598 n > JPEG2000_MAX_DECLEVELS*3)
599 return AVERROR_INVALIDDATA;
600 for (i = 0; i < n; i++) {
601 x = bytestream2_get_be16u(&s->g);
602 q->expn[i] = x >> 11;
603 q->mant[i] = x & 0x7ff;
609 /* Get quantization parameters for a particular tile or a whole image. */
610 static int get_qcd(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q,
613 Jpeg2000QuantStyle tmp;
616 memset(&tmp, 0, sizeof(tmp));
618 if ((ret = get_qcx(s, n, &tmp)) < 0)
620 for (compno = 0; compno < s->ncomponents; compno++)
621 if (!(properties[compno] & HAD_QCC))
622 memcpy(q + compno, &tmp, sizeof(tmp));
626 /* Get quantization parameters for a component in the whole image
627 * on in a particular tile. */
628 static int get_qcc(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q,
633 if (bytestream2_get_bytes_left(&s->g) < 1)
634 return AVERROR_INVALIDDATA;
636 compno = bytestream2_get_byteu(&s->g);
638 if (compno >= s->ncomponents) {
639 av_log(s->avctx, AV_LOG_ERROR,
640 "Invalid compno %d. There are %d components in the image.\n",
641 compno, s->ncomponents);
642 return AVERROR_INVALIDDATA;
645 properties[compno] |= HAD_QCC;
646 return get_qcx(s, n - 1, q + compno);
649 static int get_poc(Jpeg2000DecoderContext *s, int size, Jpeg2000POC *p)
652 int elem_size = s->ncomponents <= 257 ? 7 : 9;
653 Jpeg2000POC tmp = {{{0}}};
655 if (bytestream2_get_bytes_left(&s->g) < 5 || size < 2 + elem_size) {
656 av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for POC\n");
657 return AVERROR_INVALIDDATA;
661 avpriv_request_sample(s->avctx, "Fat POC not supported");
662 return AVERROR_PATCHWELCOME;
665 tmp.nb_poc = (size - 2) / elem_size;
666 if (tmp.nb_poc > MAX_POCS) {
667 avpriv_request_sample(s->avctx, "Too many POCs (%d)", tmp.nb_poc);
668 return AVERROR_PATCHWELCOME;
671 for (i = 0; i<tmp.nb_poc; i++) {
672 Jpeg2000POCEntry *e = &tmp.poc[i];
673 e->RSpoc = bytestream2_get_byteu(&s->g);
674 e->CSpoc = bytestream2_get_byteu(&s->g);
675 e->LYEpoc = bytestream2_get_be16u(&s->g);
676 e->REpoc = bytestream2_get_byteu(&s->g);
677 e->CEpoc = bytestream2_get_byteu(&s->g);
678 e->Ppoc = bytestream2_get_byteu(&s->g);
681 if (e->CEpoc > s->ncomponents)
682 e->CEpoc = s->ncomponents;
683 if ( e->RSpoc >= e->REpoc || e->REpoc > 33
684 || e->CSpoc >= e->CEpoc || e->CEpoc > s->ncomponents
686 av_log(s->avctx, AV_LOG_ERROR, "POC Entry %d is invalid (%d, %d, %d, %d, %d, %d)\n", i,
687 e->RSpoc, e->CSpoc, e->LYEpoc, e->REpoc, e->CEpoc, e->Ppoc
689 return AVERROR_INVALIDDATA;
693 if (!p->nb_poc || p->is_default) {
696 if (p->nb_poc + tmp.nb_poc > MAX_POCS) {
697 av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for POC\n");
698 return AVERROR_INVALIDDATA;
700 memcpy(p->poc + p->nb_poc, tmp.poc, tmp.nb_poc * sizeof(tmp.poc[0]));
701 p->nb_poc += tmp.nb_poc;
710 /* Get start of tile segment. */
711 static int get_sot(Jpeg2000DecoderContext *s, int n)
713 Jpeg2000TilePart *tp;
718 if (bytestream2_get_bytes_left(&s->g) < 8)
719 return AVERROR_INVALIDDATA;
722 Isot = bytestream2_get_be16u(&s->g); // Isot
723 if (Isot >= s->numXtiles * s->numYtiles)
724 return AVERROR_INVALIDDATA;
727 Psot = bytestream2_get_be32u(&s->g); // Psot
728 TPsot = bytestream2_get_byteu(&s->g); // TPsot
730 /* Read TNSot but not used */
731 bytestream2_get_byteu(&s->g); // TNsot
734 Psot = bytestream2_get_bytes_left(&s->g) + n + 2;
736 if (Psot > bytestream2_get_bytes_left(&s->g) + n + 2) {
737 av_log(s->avctx, AV_LOG_ERROR, "Psot %"PRIu32" too big\n", Psot);
738 return AVERROR_INVALIDDATA;
741 av_assert0(TPsot < FF_ARRAY_ELEMS(s->tile[Isot].tile_part));
743 s->tile[Isot].tp_idx = TPsot;
744 tp = s->tile[Isot].tile_part + TPsot;
745 tp->tile_index = Isot;
746 tp->tp_end = s->g.buffer + Psot - n - 2;
749 Jpeg2000Tile *tile = s->tile + s->curtileno;
752 memcpy(tile->codsty, s->codsty, s->ncomponents * sizeof(Jpeg2000CodingStyle));
753 memcpy(tile->qntsty, s->qntsty, s->ncomponents * sizeof(Jpeg2000QuantStyle));
754 memcpy(&tile->poc , &s->poc , sizeof(tile->poc));
755 tile->poc.is_default = 1;
761 /* Tile-part lengths: see ISO 15444-1:2002, section A.7.1
762 * Used to know the number of tile parts and lengths.
763 * There may be multiple TLMs in the header.
764 * TODO: The function is not used for tile-parts management, nor anywhere else.
765 * It can be useful to allocate memory for tile parts, before managing the SOT
766 * markers. Parsing the TLM header is needed to increment the input header
768 * This marker is mandatory for DCI. */
769 static uint8_t get_tlm(Jpeg2000DecoderContext *s, int n)
771 uint8_t Stlm, ST, SP, tile_tlm, i;
772 bytestream2_get_byte(&s->g); /* Ztlm: skipped */
773 Stlm = bytestream2_get_byte(&s->g);
775 // too complex ? ST = ((Stlm >> 4) & 0x01) + ((Stlm >> 4) & 0x02);
776 ST = (Stlm >> 4) & 0x03;
777 // TODO: Manage case of ST = 0b11 --> raise error
778 SP = (Stlm >> 6) & 0x01;
779 tile_tlm = (n - 4) / ((SP + 1) * 2 + ST);
780 for (i = 0; i < tile_tlm; i++) {
785 bytestream2_get_byte(&s->g);
788 bytestream2_get_be16(&s->g);
791 bytestream2_get_be32(&s->g);
795 bytestream2_get_be16(&s->g);
797 bytestream2_get_be32(&s->g);
803 static uint8_t get_plt(Jpeg2000DecoderContext *s, int n)
807 av_log(s->avctx, AV_LOG_DEBUG,
808 "PLT marker at pos 0x%X\n", bytestream2_tell(&s->g) - 4);
810 /*Zplt =*/ bytestream2_get_byte(&s->g);
812 for (i = 0; i < n - 3; i++) {
813 bytestream2_get_byte(&s->g);
819 static int init_tile(Jpeg2000DecoderContext *s, int tileno)
822 int tilex = tileno % s->numXtiles;
823 int tiley = tileno / s->numXtiles;
824 Jpeg2000Tile *tile = s->tile + tileno;
827 return AVERROR(ENOMEM);
829 tile->coord[0][0] = FFMAX(tilex * s->tile_width + s->tile_offset_x, s->image_offset_x);
830 tile->coord[0][1] = FFMIN((tilex + 1) * s->tile_width + s->tile_offset_x, s->width);
831 tile->coord[1][0] = FFMAX(tiley * s->tile_height + s->tile_offset_y, s->image_offset_y);
832 tile->coord[1][1] = FFMIN((tiley + 1) * s->tile_height + s->tile_offset_y, s->height);
834 for (compno = 0; compno < s->ncomponents; compno++) {
835 Jpeg2000Component *comp = tile->comp + compno;
836 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
837 Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
838 int ret; // global bandno
840 comp->coord_o[0][0] = tile->coord[0][0];
841 comp->coord_o[0][1] = tile->coord[0][1];
842 comp->coord_o[1][0] = tile->coord[1][0];
843 comp->coord_o[1][1] = tile->coord[1][1];
845 comp->coord_o[0][0] /= s->cdx[compno];
846 comp->coord_o[0][1] /= s->cdx[compno];
847 comp->coord_o[1][0] /= s->cdy[compno];
848 comp->coord_o[1][1] /= s->cdy[compno];
851 comp->coord[0][0] = ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], s->reduction_factor);
852 comp->coord[0][1] = ff_jpeg2000_ceildivpow2(comp->coord_o[0][1], s->reduction_factor);
853 comp->coord[1][0] = ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], s->reduction_factor);
854 comp->coord[1][1] = ff_jpeg2000_ceildivpow2(comp->coord_o[1][1], s->reduction_factor);
856 if (ret = ff_jpeg2000_init_component(comp, codsty, qntsty,
857 s->cbps[compno], s->cdx[compno],
858 s->cdy[compno], s->avctx))
864 /* Read the number of coding passes. */
865 static int getnpasses(Jpeg2000DecoderContext *s)
872 if ((num = get_bits(s, 2)) != 3)
873 return num < 0 ? num : 3 + num;
874 if ((num = get_bits(s, 5)) != 31)
875 return num < 0 ? num : 6 + num;
876 num = get_bits(s, 7);
877 return num < 0 ? num : 37 + num;
880 static int getlblockinc(Jpeg2000DecoderContext *s)
883 while (ret = get_bits(s, 1)) {
891 static int jpeg2000_decode_packet(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile, int *tp_index,
892 Jpeg2000CodingStyle *codsty,
893 Jpeg2000ResLevel *rlevel, int precno,
894 int layno, uint8_t *expn, int numgbits)
896 int bandno, cblkno, ret, nb_code_blocks;
899 if (layno < rlevel->band[0].prec[precno].decoded_layers)
901 rlevel->band[0].prec[precno].decoded_layers = layno + 1;
903 if (bytestream2_get_bytes_left(&s->g) == 0 && s->bit_index == 8) {
904 if (*tp_index < FF_ARRAY_ELEMS(tile->tile_part) - 1) {
905 s->g = tile->tile_part[++(*tp_index)].tpg;
909 if (bytestream2_peek_be32(&s->g) == JPEG2000_SOP_FIXED_BYTES)
910 bytestream2_skip(&s->g, JPEG2000_SOP_BYTE_LENGTH);
912 if (!(ret = get_bits(s, 1))) {
918 for (bandno = 0; bandno < rlevel->nbands; bandno++) {
919 Jpeg2000Band *band = rlevel->band + bandno;
920 Jpeg2000Prec *prec = band->prec + precno;
922 if (band->coord[0][0] == band->coord[0][1] ||
923 band->coord[1][0] == band->coord[1][1])
925 nb_code_blocks = prec->nb_codeblocks_height *
926 prec->nb_codeblocks_width;
927 for (cblkno = 0; cblkno < nb_code_blocks; cblkno++) {
928 Jpeg2000Cblk *cblk = prec->cblk + cblkno;
929 int incl, newpasses, llen;
932 incl = get_bits(s, 1);
934 incl = tag_tree_decode(s, prec->cblkincl + cblkno, layno + 1) == layno;
940 if (!cblk->npasses) {
941 int v = expn[bandno] + numgbits - 1 -
942 tag_tree_decode(s, prec->zerobits + cblkno, 100);
944 av_log(s->avctx, AV_LOG_ERROR,
945 "nonzerobits %d invalid\n", v);
946 return AVERROR_INVALIDDATA;
948 cblk->nonzerobits = v;
950 if ((newpasses = getnpasses(s)) < 0)
952 av_assert2(newpasses > 0);
953 if (cblk->npasses + newpasses >= JPEG2000_MAX_PASSES) {
954 avpriv_request_sample(s->avctx, "Too many passes");
955 return AVERROR_PATCHWELCOME;
957 if ((llen = getlblockinc(s)) < 0)
959 if (cblk->lblock + llen + av_log2(newpasses) > 16) {
960 avpriv_request_sample(s->avctx,
961 "Block with length beyond 16 bits");
962 return AVERROR_PATCHWELCOME;
965 cblk->lblock += llen;
967 cblk->nb_lengthinc = 0;
968 cblk->nb_terminationsinc = 0;
972 while (newpasses1 < newpasses) {
974 if (needs_termination(codsty->cblk_style, cblk->npasses + newpasses1 - 1)) {
975 cblk->nb_terminationsinc ++;
980 if ((ret = get_bits(s, av_log2(newpasses1) + cblk->lblock)) < 0)
982 if (ret > sizeof(cblk->data)) {
983 avpriv_request_sample(s->avctx,
984 "Block with lengthinc greater than %"SIZE_SPECIFIER"",
986 return AVERROR_PATCHWELCOME;
988 cblk->lengthinc[cblk->nb_lengthinc++] = ret;
989 cblk->npasses += newpasses1;
990 newpasses -= newpasses1;
996 if (codsty->csty & JPEG2000_CSTY_EPH) {
997 if (bytestream2_peek_be16(&s->g) == JPEG2000_EPH)
998 bytestream2_skip(&s->g, 2);
1000 av_log(s->avctx, AV_LOG_ERROR, "EPH marker not found. instead %X\n", bytestream2_peek_be32(&s->g));
1003 for (bandno = 0; bandno < rlevel->nbands; bandno++) {
1004 Jpeg2000Band *band = rlevel->band + bandno;
1005 Jpeg2000Prec *prec = band->prec + precno;
1007 nb_code_blocks = prec->nb_codeblocks_height * prec->nb_codeblocks_width;
1008 for (cblkno = 0; cblkno < nb_code_blocks; cblkno++) {
1009 Jpeg2000Cblk *cblk = prec->cblk + cblkno;
1010 for (cwsno = 0; cwsno < cblk->nb_lengthinc; cwsno ++) {
1011 if ( bytestream2_get_bytes_left(&s->g) < cblk->lengthinc[cwsno]
1012 || sizeof(cblk->data) < cblk->length + cblk->lengthinc[cwsno] + 4
1014 av_log(s->avctx, AV_LOG_ERROR,
1015 "Block length %"PRIu16" or lengthinc %d is too large, left %d\n",
1016 cblk->length, cblk->lengthinc[cwsno], bytestream2_get_bytes_left(&s->g));
1017 return AVERROR_INVALIDDATA;
1020 bytestream2_get_bufferu(&s->g, cblk->data + cblk->length, cblk->lengthinc[cwsno]);
1021 cblk->length += cblk->lengthinc[cwsno];
1022 cblk->lengthinc[cwsno] = 0;
1023 if (cblk->nb_terminationsinc) {
1024 cblk->nb_terminationsinc--;
1025 cblk->nb_terminations++;
1026 cblk->data[cblk->length++] = 0xFF;
1027 cblk->data[cblk->length++] = 0xFF;
1028 cblk->data_start[cblk->nb_terminations] = cblk->length;
1036 static int jpeg2000_decode_packets_po_iteration(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile,
1037 int RSpoc, int CSpoc,
1038 int LYEpoc, int REpoc, int CEpoc,
1039 int Ppoc, int *tp_index)
1042 int layno, reslevelno, compno, precno, ok_reslevel;
1047 case JPEG2000_PGOD_RLCP:
1048 av_log(s->avctx, AV_LOG_DEBUG, "Progression order RLCP\n");
1050 for (reslevelno = RSpoc; ok_reslevel && reslevelno < REpoc; reslevelno++) {
1052 for (layno = 0; layno < LYEpoc; layno++) {
1053 for (compno = CSpoc; compno < CEpoc; compno++) {
1054 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1055 Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
1056 if (reslevelno < codsty->nreslevels) {
1057 Jpeg2000ResLevel *rlevel = tile->comp[compno].reslevel +
1060 for (precno = 0; precno < rlevel->num_precincts_x * rlevel->num_precincts_y; precno++)
1061 if ((ret = jpeg2000_decode_packet(s, tile, tp_index,
1064 qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1065 qntsty->nguardbits)) < 0)
1073 case JPEG2000_PGOD_LRCP:
1074 av_log(s->avctx, AV_LOG_DEBUG, "Progression order LRCP\n");
1075 for (layno = 0; layno < LYEpoc; layno++) {
1077 for (reslevelno = RSpoc; ok_reslevel && reslevelno < REpoc; reslevelno++) {
1079 for (compno = CSpoc; compno < CEpoc; compno++) {
1080 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1081 Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
1082 if (reslevelno < codsty->nreslevels) {
1083 Jpeg2000ResLevel *rlevel = tile->comp[compno].reslevel +
1086 for (precno = 0; precno < rlevel->num_precincts_x * rlevel->num_precincts_y; precno++)
1087 if ((ret = jpeg2000_decode_packet(s, tile, tp_index,
1090 qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1091 qntsty->nguardbits)) < 0)
1099 case JPEG2000_PGOD_CPRL:
1100 av_log(s->avctx, AV_LOG_DEBUG, "Progression order CPRL\n");
1101 for (compno = CSpoc; compno < CEpoc; compno++) {
1102 Jpeg2000Component *comp = tile->comp + compno;
1103 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1104 Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
1108 for (reslevelno = RSpoc; reslevelno < FFMIN(codsty->nreslevels, REpoc); reslevelno++) {
1109 uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1110 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1111 step_x = FFMIN(step_x, rlevel->log2_prec_width + reducedresno);
1112 step_y = FFMIN(step_y, rlevel->log2_prec_height + reducedresno);
1114 av_assert0(step_x < 32 && step_y < 32);
1118 for (y = tile->coord[1][0]; y < tile->coord[1][1]; y = (y/step_y + 1)*step_y) {
1119 for (x = tile->coord[0][0]; x < tile->coord[0][1]; x = (x/step_x + 1)*step_x) {
1120 for (reslevelno = RSpoc; reslevelno < FFMIN(codsty->nreslevels, REpoc); reslevelno++) {
1121 unsigned prcx, prcy;
1122 uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1123 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1124 int xc = x / s->cdx[compno];
1125 int yc = y / s->cdy[compno];
1127 if (yc % (1 << (rlevel->log2_prec_height + reducedresno)) && y != tile->coord[1][0]) //FIXME this is a subset of the check
1130 if (xc % (1 << (rlevel->log2_prec_width + reducedresno)) && x != tile->coord[0][0]) //FIXME this is a subset of the check
1133 // check if a precinct exists
1134 prcx = ff_jpeg2000_ceildivpow2(xc, reducedresno) >> rlevel->log2_prec_width;
1135 prcy = ff_jpeg2000_ceildivpow2(yc, reducedresno) >> rlevel->log2_prec_height;
1136 prcx -= ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], reducedresno) >> rlevel->log2_prec_width;
1137 prcy -= ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], reducedresno) >> rlevel->log2_prec_height;
1139 precno = prcx + rlevel->num_precincts_x * prcy;
1141 if (prcx >= rlevel->num_precincts_x || prcy >= rlevel->num_precincts_y) {
1142 av_log(s->avctx, AV_LOG_WARNING, "prc %d %d outside limits %d %d\n",
1143 prcx, prcy, rlevel->num_precincts_x, rlevel->num_precincts_y);
1147 for (layno = 0; layno < LYEpoc; layno++) {
1148 if ((ret = jpeg2000_decode_packet(s, tile, tp_index, codsty, rlevel,
1150 qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1151 qntsty->nguardbits)) < 0)
1160 case JPEG2000_PGOD_RPCL:
1161 av_log(s->avctx, AV_LOG_WARNING, "Progression order RPCL\n");
1163 for (reslevelno = RSpoc; ok_reslevel && reslevelno < REpoc; reslevelno++) {
1167 for (compno = CSpoc; compno < CEpoc; compno++) {
1168 Jpeg2000Component *comp = tile->comp + compno;
1169 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1171 if (reslevelno < codsty->nreslevels) {
1172 uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1173 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1174 step_x = FFMIN(step_x, rlevel->log2_prec_width + reducedresno);
1175 step_y = FFMIN(step_y, rlevel->log2_prec_height + reducedresno);
1181 for (y = tile->coord[1][0]; y < tile->coord[1][1]; y = (y/step_y + 1)*step_y) {
1182 for (x = tile->coord[0][0]; x < tile->coord[0][1]; x = (x/step_x + 1)*step_x) {
1183 for (compno = CSpoc; compno < CEpoc; compno++) {
1184 Jpeg2000Component *comp = tile->comp + compno;
1185 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1186 Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
1187 uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1188 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1189 unsigned prcx, prcy;
1191 int xc = x / s->cdx[compno];
1192 int yc = y / s->cdy[compno];
1194 if (reslevelno >= codsty->nreslevels)
1197 if (yc % (1 << (rlevel->log2_prec_height + reducedresno)) && y != tile->coord[1][0]) //FIXME this is a subset of the check
1200 if (xc % (1 << (rlevel->log2_prec_width + reducedresno)) && x != tile->coord[0][0]) //FIXME this is a subset of the check
1203 // check if a precinct exists
1204 prcx = ff_jpeg2000_ceildivpow2(xc, reducedresno) >> rlevel->log2_prec_width;
1205 prcy = ff_jpeg2000_ceildivpow2(yc, reducedresno) >> rlevel->log2_prec_height;
1206 prcx -= ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], reducedresno) >> rlevel->log2_prec_width;
1207 prcy -= ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], reducedresno) >> rlevel->log2_prec_height;
1209 precno = prcx + rlevel->num_precincts_x * prcy;
1212 if (prcx >= rlevel->num_precincts_x || prcy >= rlevel->num_precincts_y) {
1213 av_log(s->avctx, AV_LOG_WARNING, "prc %d %d outside limits %d %d\n",
1214 prcx, prcy, rlevel->num_precincts_x, rlevel->num_precincts_y);
1218 for (layno = 0; layno < LYEpoc; layno++) {
1219 if ((ret = jpeg2000_decode_packet(s, tile, tp_index,
1222 qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1223 qntsty->nguardbits)) < 0)
1232 case JPEG2000_PGOD_PCRL:
1233 av_log(s->avctx, AV_LOG_WARNING, "Progression order PCRL\n");
1236 for (compno = CSpoc; compno < CEpoc; compno++) {
1237 Jpeg2000Component *comp = tile->comp + compno;
1238 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1240 for (reslevelno = RSpoc; reslevelno < FFMIN(codsty->nreslevels, REpoc); reslevelno++) {
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 int xc = x / s->cdx[compno];
1257 int yc = y / s->cdy[compno];
1259 for (reslevelno = RSpoc; reslevelno < FFMIN(codsty->nreslevels, REpoc); reslevelno++) {
1260 unsigned prcx, prcy;
1261 uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1262 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1264 if (yc % (1 << (rlevel->log2_prec_height + reducedresno)) && y != tile->coord[1][0]) //FIXME this is a subset of the check
1267 if (xc % (1 << (rlevel->log2_prec_width + reducedresno)) && x != tile->coord[0][0]) //FIXME this is a subset of the check
1270 // check if a precinct exists
1271 prcx = ff_jpeg2000_ceildivpow2(xc, reducedresno) >> rlevel->log2_prec_width;
1272 prcy = ff_jpeg2000_ceildivpow2(yc, reducedresno) >> rlevel->log2_prec_height;
1273 prcx -= ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], reducedresno) >> rlevel->log2_prec_width;
1274 prcy -= ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], reducedresno) >> rlevel->log2_prec_height;
1276 precno = prcx + rlevel->num_precincts_x * prcy;
1278 if (prcx >= rlevel->num_precincts_x || prcy >= rlevel->num_precincts_y) {
1279 av_log(s->avctx, AV_LOG_WARNING, "prc %d %d outside limits %d %d\n",
1280 prcx, prcy, rlevel->num_precincts_x, rlevel->num_precincts_y);
1284 for (layno = 0; layno < LYEpoc; layno++) {
1285 if ((ret = jpeg2000_decode_packet(s, tile, tp_index, codsty, rlevel,
1287 qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1288 qntsty->nguardbits)) < 0)
1304 static int jpeg2000_decode_packets(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
1306 int ret = AVERROR_BUG;
1311 if (tile->poc.nb_poc) {
1312 for (i=0; i<tile->poc.nb_poc; i++) {
1313 Jpeg2000POCEntry *e = &tile->poc.poc[i];
1314 ret = jpeg2000_decode_packets_po_iteration(s, tile,
1316 FFMIN(e->LYEpoc, tile->codsty[0].nlayers),
1318 FFMIN(e->CEpoc, s->ncomponents),
1325 ret = jpeg2000_decode_packets_po_iteration(s, tile,
1327 tile->codsty[0].nlayers,
1330 tile->codsty[0].prog_order,
1334 /* EOC marker reached */
1335 bytestream2_skip(&s->g, 2);
1340 /* TIER-1 routines */
1341 static void decode_sigpass(Jpeg2000T1Context *t1, int width, int height,
1342 int bpno, int bandno,
1343 int vert_causal_ctx_csty_symbol)
1345 int mask = 3 << (bpno - 1), y0, x, y;
1347 for (y0 = 0; y0 < height; y0 += 4)
1348 for (x = 0; x < width; x++)
1349 for (y = y0; y < height && y < y0 + 4; y++) {
1350 int flags_mask = -1;
1351 if (vert_causal_ctx_csty_symbol && y == y0 + 3)
1352 flags_mask &= ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE | JPEG2000_T1_SGN_S);
1353 if ((t1->flags[(y+1) * t1->stride + x+1] & JPEG2000_T1_SIG_NB & flags_mask)
1354 && !(t1->flags[(y+1) * t1->stride + x+1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS))) {
1355 if (ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ff_jpeg2000_getsigctxno(t1->flags[(y+1) * t1->stride + x+1] & flags_mask, bandno))) {
1356 int xorbit, ctxno = ff_jpeg2000_getsgnctxno(t1->flags[(y+1) * t1->stride + x+1] & flags_mask, &xorbit);
1358 t1->data[(y) * t1->stride + x] = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ctxno) ? -mask : mask;
1360 t1->data[(y) * t1->stride + x] = (ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ctxno) ^ xorbit) ?
1363 ff_jpeg2000_set_significance(t1, x, y,
1364 t1->data[(y) * t1->stride + x] < 0);
1366 t1->flags[(y + 1) * t1->stride + x + 1] |= JPEG2000_T1_VIS;
1371 static void decode_refpass(Jpeg2000T1Context *t1, int width, int height,
1372 int bpno, int vert_causal_ctx_csty_symbol)
1377 phalf = 1 << (bpno - 1);
1380 for (y0 = 0; y0 < height; y0 += 4)
1381 for (x = 0; x < width; x++)
1382 for (y = y0; y < height && y < y0 + 4; y++)
1383 if ((t1->flags[(y + 1) * t1->stride + x + 1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS)) == JPEG2000_T1_SIG) {
1384 int flags_mask = (vert_causal_ctx_csty_symbol && y == y0 + 3) ?
1385 ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE | JPEG2000_T1_SGN_S) : -1;
1386 int ctxno = ff_jpeg2000_getrefctxno(t1->flags[(y + 1) * t1->stride + x + 1] & flags_mask);
1387 int r = ff_mqc_decode(&t1->mqc,
1388 t1->mqc.cx_states + ctxno)
1390 t1->data[(y) * t1->stride + x] += t1->data[(y) * t1->stride + x] < 0 ? -r : r;
1391 t1->flags[(y + 1) * t1->stride + x + 1] |= JPEG2000_T1_REF;
1395 static void decode_clnpass(Jpeg2000DecoderContext *s, Jpeg2000T1Context *t1,
1396 int width, int height, int bpno, int bandno,
1397 int seg_symbols, int vert_causal_ctx_csty_symbol)
1399 int mask = 3 << (bpno - 1), y0, x, y, runlen, dec;
1401 for (y0 = 0; y0 < height; y0 += 4) {
1402 for (x = 0; x < width; x++) {
1403 int flags_mask = -1;
1404 if (vert_causal_ctx_csty_symbol)
1405 flags_mask &= ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE | JPEG2000_T1_SGN_S);
1406 if (y0 + 3 < height &&
1407 !((t1->flags[(y0 + 1) * t1->stride + x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
1408 (t1->flags[(y0 + 2) * t1->stride + x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
1409 (t1->flags[(y0 + 3) * t1->stride + x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
1410 (t1->flags[(y0 + 4) * t1->stride + x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG) & flags_mask))) {
1411 if (!ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_RL))
1413 runlen = ff_mqc_decode(&t1->mqc,
1414 t1->mqc.cx_states + MQC_CX_UNI);
1415 runlen = (runlen << 1) | ff_mqc_decode(&t1->mqc,
1424 for (y = y0 + runlen; y < y0 + 4 && y < height; y++) {
1425 int flags_mask = -1;
1426 if (vert_causal_ctx_csty_symbol && y == y0 + 3)
1427 flags_mask &= ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE | JPEG2000_T1_SGN_S);
1429 if (!(t1->flags[(y+1) * t1->stride + x+1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS))) {
1430 dec = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ff_jpeg2000_getsigctxno(t1->flags[(y+1) * t1->stride + x+1] & flags_mask,
1436 int ctxno = ff_jpeg2000_getsgnctxno(t1->flags[(y + 1) * t1->stride + x + 1] & flags_mask,
1438 t1->data[(y) * t1->stride + x] = (ff_mqc_decode(&t1->mqc,
1439 t1->mqc.cx_states + ctxno) ^
1442 ff_jpeg2000_set_significance(t1, x, y, t1->data[(y) * t1->stride + x] < 0);
1445 t1->flags[(y + 1) * t1->stride + x + 1] &= ~JPEG2000_T1_VIS;
1451 val = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1452 val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1453 val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1454 val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1456 av_log(s->avctx, AV_LOG_ERROR,
1457 "Segmentation symbol value incorrect\n");
1461 static int decode_cblk(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *codsty,
1462 Jpeg2000T1Context *t1, Jpeg2000Cblk *cblk,
1463 int width, int height, int bandpos)
1465 int passno = cblk->npasses, pass_t = 2, bpno = cblk->nonzerobits - 1;
1467 int vert_causal_ctx_csty_symbol = codsty->cblk_style & JPEG2000_CBLK_VSC;
1471 av_assert0(width <= 1024U && height <= 1024U);
1472 av_assert0(width*height <= 4096);
1474 memset(t1->data, 0, t1->stride * height * sizeof(*t1->data));
1476 /* If code-block contains no compressed data: nothing to do. */
1480 memset(t1->flags, 0, t1->stride * (height + 2) * sizeof(*t1->flags));
1482 cblk->data[cblk->length] = 0xff;
1483 cblk->data[cblk->length+1] = 0xff;
1484 ff_mqc_initdec(&t1->mqc, cblk->data, 0, 1);
1489 decode_sigpass(t1, width, height, bpno + 1, bandpos,
1490 vert_causal_ctx_csty_symbol);
1493 decode_refpass(t1, width, height, bpno + 1, vert_causal_ctx_csty_symbol);
1496 av_assert2(!t1->mqc.raw);
1497 decode_clnpass(s, t1, width, height, bpno + 1, bandpos,
1498 codsty->cblk_style & JPEG2000_CBLK_SEGSYM,
1499 vert_causal_ctx_csty_symbol);
1502 if (codsty->cblk_style & JPEG2000_CBLK_RESET) // XXX no testcase for just this
1503 ff_mqc_init_contexts(&t1->mqc);
1505 if (passno && (coder_type = needs_termination(codsty->cblk_style, pass_cnt))) {
1506 if (term_cnt >= cblk->nb_terminations) {
1507 av_log(s->avctx, AV_LOG_ERROR, "Missing needed termination \n");
1508 return AVERROR_INVALIDDATA;
1510 if (FFABS(cblk->data + cblk->data_start[term_cnt + 1] - 2 - t1->mqc.bp) > 0) {
1511 av_log(s->avctx, AV_LOG_WARNING, "Mid mismatch %"PTRDIFF_SPECIFIER" in pass %d of %d\n",
1512 cblk->data + cblk->data_start[term_cnt + 1] - 2 - t1->mqc.bp,
1513 pass_cnt, cblk->npasses);
1516 ff_mqc_initdec(&t1->mqc, cblk->data + cblk->data_start[++term_cnt], coder_type == 2, 0);
1527 if (cblk->data + cblk->length - 2*(term_cnt < cblk->nb_terminations) != t1->mqc.bp) {
1528 av_log(s->avctx, AV_LOG_WARNING, "End mismatch %"PTRDIFF_SPECIFIER"\n",
1529 cblk->data + cblk->length - 2*(term_cnt < cblk->nb_terminations) - t1->mqc.bp);
1535 /* TODO: Verify dequantization for lossless case
1536 * comp->data can be float or int
1537 * band->stepsize can be float or int
1538 * depending on the type of DWT transformation.
1539 * see ISO/IEC 15444-1:2002 A.6.1 */
1541 /* Float dequantization of a codeblock.*/
1542 static void dequantization_float(int x, int y, Jpeg2000Cblk *cblk,
1543 Jpeg2000Component *comp,
1544 Jpeg2000T1Context *t1, Jpeg2000Band *band)
1547 int w = cblk->coord[0][1] - cblk->coord[0][0];
1548 for (j = 0; j < (cblk->coord[1][1] - cblk->coord[1][0]); ++j) {
1549 float *datap = &comp->f_data[(comp->coord[0][1] - comp->coord[0][0]) * (y + j) + x];
1550 int *src = t1->data + j*t1->stride;
1551 for (i = 0; i < w; ++i)
1552 datap[i] = src[i] * band->f_stepsize;
1556 /* Integer dequantization of a codeblock.*/
1557 static void dequantization_int(int x, int y, Jpeg2000Cblk *cblk,
1558 Jpeg2000Component *comp,
1559 Jpeg2000T1Context *t1, Jpeg2000Band *band)
1562 int w = cblk->coord[0][1] - cblk->coord[0][0];
1563 for (j = 0; j < (cblk->coord[1][1] - cblk->coord[1][0]); ++j) {
1564 int32_t *datap = &comp->i_data[(comp->coord[0][1] - comp->coord[0][0]) * (y + j) + x];
1565 int *src = t1->data + j*t1->stride;
1566 if (band->i_stepsize == 32768) {
1567 for (i = 0; i < w; ++i)
1568 datap[i] = src[i] / 2;
1570 // This should be VERY uncommon
1571 for (i = 0; i < w; ++i)
1572 datap[i] = (src[i] * (int64_t)band->i_stepsize) / 65536;
1577 static void dequantization_int_97(int x, int y, Jpeg2000Cblk *cblk,
1578 Jpeg2000Component *comp,
1579 Jpeg2000T1Context *t1, Jpeg2000Band *band)
1582 int w = cblk->coord[0][1] - cblk->coord[0][0];
1583 for (j = 0; j < (cblk->coord[1][1] - cblk->coord[1][0]); ++j) {
1584 int32_t *datap = &comp->i_data[(comp->coord[0][1] - comp->coord[0][0]) * (y + j) + x];
1585 int *src = t1->data + j*t1->stride;
1586 for (i = 0; i < w; ++i)
1587 datap[i] = (src[i] * (int64_t)band->i_stepsize + (1<<15)) >> 16;
1591 static inline void mct_decode(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
1596 for (i = 1; i < 3; i++) {
1597 if (tile->codsty[0].transform != tile->codsty[i].transform) {
1598 av_log(s->avctx, AV_LOG_ERROR, "Transforms mismatch, MCT not supported\n");
1601 if (memcmp(tile->comp[0].coord, tile->comp[i].coord, sizeof(tile->comp[0].coord))) {
1602 av_log(s->avctx, AV_LOG_ERROR, "Coords mismatch, MCT not supported\n");
1607 for (i = 0; i < 3; i++)
1608 if (tile->codsty[0].transform == FF_DWT97)
1609 src[i] = tile->comp[i].f_data;
1611 src[i] = tile->comp[i].i_data;
1613 for (i = 0; i < 2; i++)
1614 csize *= tile->comp[0].coord[i][1] - tile->comp[0].coord[i][0];
1616 s->dsp.mct_decode[tile->codsty[0].transform](src[0], src[1], src[2], csize);
1619 static int jpeg2000_decode_tile(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile,
1622 const AVPixFmtDescriptor *pixdesc = av_pix_fmt_desc_get(s->avctx->pix_fmt);
1623 int compno, reslevelno, bandno;
1625 int planar = !!(pixdesc->flags & AV_PIX_FMT_FLAG_PLANAR);
1626 int pixelsize = planar ? 1 : pixdesc->nb_components;
1629 Jpeg2000T1Context t1;
1631 /* Loop on tile components */
1632 for (compno = 0; compno < s->ncomponents; compno++) {
1633 Jpeg2000Component *comp = tile->comp + compno;
1634 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1636 t1.stride = (1<<codsty->log2_cblk_width) + 2;
1638 /* Loop on resolution levels */
1639 for (reslevelno = 0; reslevelno < codsty->nreslevels2decode; reslevelno++) {
1640 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1642 for (bandno = 0; bandno < rlevel->nbands; bandno++) {
1643 int nb_precincts, precno;
1644 Jpeg2000Band *band = rlevel->band + bandno;
1645 int cblkno = 0, bandpos;
1647 bandpos = bandno + (reslevelno > 0);
1649 if (band->coord[0][0] == band->coord[0][1] ||
1650 band->coord[1][0] == band->coord[1][1])
1653 nb_precincts = rlevel->num_precincts_x * rlevel->num_precincts_y;
1654 /* Loop on precincts */
1655 for (precno = 0; precno < nb_precincts; precno++) {
1656 Jpeg2000Prec *prec = band->prec + precno;
1658 /* Loop on codeblocks */
1659 for (cblkno = 0; cblkno < prec->nb_codeblocks_width * prec->nb_codeblocks_height; cblkno++) {
1661 Jpeg2000Cblk *cblk = prec->cblk + cblkno;
1662 decode_cblk(s, codsty, &t1, cblk,
1663 cblk->coord[0][1] - cblk->coord[0][0],
1664 cblk->coord[1][1] - cblk->coord[1][0],
1667 x = cblk->coord[0][0] - band->coord[0][0];
1668 y = cblk->coord[1][0] - band->coord[1][0];
1670 if (codsty->transform == FF_DWT97)
1671 dequantization_float(x, y, cblk, comp, &t1, band);
1672 else if (codsty->transform == FF_DWT97_INT)
1673 dequantization_int_97(x, y, cblk, comp, &t1, band);
1675 dequantization_int(x, y, cblk, comp, &t1, band);
1679 } /* end reslevel */
1682 ff_dwt_decode(&comp->dwt, codsty->transform == FF_DWT97 ? (void*)comp->f_data : (void*)comp->i_data);
1685 /* inverse MCT transformation */
1686 if (tile->codsty[0].mct)
1687 mct_decode(s, tile);
1689 if (s->cdef[0] < 0) {
1690 for (x = 0; x < s->ncomponents; x++)
1692 if ((s->ncomponents & 1) == 0)
1693 s->cdef[s->ncomponents-1] = 0;
1696 if (s->precision <= 8) {
1697 for (compno = 0; compno < s->ncomponents; compno++) {
1698 Jpeg2000Component *comp = tile->comp + compno;
1699 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1700 float *datap = comp->f_data;
1701 int32_t *i_datap = comp->i_data;
1702 int cbps = s->cbps[compno];
1703 int w = tile->comp[compno].coord[0][1] - s->image_offset_x;
1707 plane = s->cdef[compno] ? s->cdef[compno]-1 : (s->ncomponents-1);
1710 y = tile->comp[compno].coord[1][0] - s->image_offset_y / s->cdy[compno];
1711 line = picture->data[plane] + y * picture->linesize[plane];
1712 for (; y < tile->comp[compno].coord[1][1] - s->image_offset_y; y ++) {
1715 x = tile->comp[compno].coord[0][0] - s->image_offset_x / s->cdx[compno];
1716 dst = line + x * pixelsize + compno*!planar;
1718 if (codsty->transform == FF_DWT97) {
1719 for (; x < w; x ++) {
1720 int val = lrintf(*datap) + (1 << (cbps - 1));
1721 /* DC level shift and clip see ISO 15444-1:2002 G.1.2 */
1722 val = av_clip(val, 0, (1 << cbps) - 1);
1723 *dst = val << (8 - cbps);
1728 for (; x < w; x ++) {
1729 int val = *i_datap + (1 << (cbps - 1));
1730 /* DC level shift and clip see ISO 15444-1:2002 G.1.2 */
1731 val = av_clip(val, 0, (1 << cbps) - 1);
1732 *dst = val << (8 - cbps);
1737 line += picture->linesize[plane];
1741 int precision = picture->format == AV_PIX_FMT_XYZ12 ||
1742 picture->format == AV_PIX_FMT_RGB48 ||
1743 picture->format == AV_PIX_FMT_RGBA64 ||
1744 picture->format == AV_PIX_FMT_GRAY16 ? 16 : s->precision;
1746 for (compno = 0; compno < s->ncomponents; compno++) {
1747 Jpeg2000Component *comp = tile->comp + compno;
1748 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1749 float *datap = comp->f_data;
1750 int32_t *i_datap = comp->i_data;
1752 int cbps = s->cbps[compno];
1753 int w = tile->comp[compno].coord[0][1] - s->image_offset_x;
1757 plane = s->cdef[compno] ? s->cdef[compno]-1 : (s->ncomponents-1);
1759 y = tile->comp[compno].coord[1][0] - s->image_offset_y / s->cdy[compno];
1760 linel = (uint16_t *)picture->data[plane] + y * (picture->linesize[plane] >> 1);
1761 for (; y < tile->comp[compno].coord[1][1] - s->image_offset_y; y ++) {
1764 x = tile->comp[compno].coord[0][0] - s->image_offset_x / s->cdx[compno];
1765 dst = linel + (x * pixelsize + compno*!planar);
1766 if (codsty->transform == FF_DWT97) {
1767 for (; x < w; x ++) {
1768 int val = lrintf(*datap) + (1 << (cbps - 1));
1769 /* DC level shift and clip see ISO 15444-1:2002 G.1.2 */
1770 val = av_clip(val, 0, (1 << cbps) - 1);
1771 /* align 12 bit values in little-endian mode */
1772 *dst = val << (precision - cbps);
1777 for (; x < w; x ++) {
1778 int val = *i_datap + (1 << (cbps - 1));
1779 /* DC level shift and clip see ISO 15444-1:2002 G.1.2 */
1780 val = av_clip(val, 0, (1 << cbps) - 1);
1781 /* align 12 bit values in little-endian mode */
1782 *dst = val << (precision - cbps);
1787 linel += picture->linesize[plane] >> 1;
1795 static void jpeg2000_dec_cleanup(Jpeg2000DecoderContext *s)
1798 for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++) {
1799 if (s->tile[tileno].comp) {
1800 for (compno = 0; compno < s->ncomponents; compno++) {
1801 Jpeg2000Component *comp = s->tile[tileno].comp + compno;
1802 Jpeg2000CodingStyle *codsty = s->tile[tileno].codsty + compno;
1804 ff_jpeg2000_cleanup(comp, codsty);
1806 av_freep(&s->tile[tileno].comp);
1810 memset(s->codsty, 0, sizeof(s->codsty));
1811 memset(s->qntsty, 0, sizeof(s->qntsty));
1812 memset(&s->poc , 0, sizeof(s->poc));
1813 s->numXtiles = s->numYtiles = 0;
1816 static int jpeg2000_read_main_headers(Jpeg2000DecoderContext *s)
1818 Jpeg2000CodingStyle *codsty = s->codsty;
1819 Jpeg2000QuantStyle *qntsty = s->qntsty;
1820 Jpeg2000POC *poc = &s->poc;
1821 uint8_t *properties = s->properties;
1828 if (bytestream2_get_bytes_left(&s->g) < 2) {
1829 av_log(s->avctx, AV_LOG_ERROR, "Missing EOC\n");
1833 marker = bytestream2_get_be16u(&s->g);
1834 oldpos = bytestream2_tell(&s->g);
1836 if (marker == JPEG2000_SOD) {
1838 Jpeg2000TilePart *tp;
1841 av_log(s->avctx, AV_LOG_ERROR, "Missing SIZ\n");
1842 return AVERROR_INVALIDDATA;
1844 if (s->curtileno < 0) {
1845 av_log(s->avctx, AV_LOG_ERROR, "Missing SOT\n");
1846 return AVERROR_INVALIDDATA;
1849 tile = s->tile + s->curtileno;
1850 tp = tile->tile_part + tile->tp_idx;
1851 if (tp->tp_end < s->g.buffer) {
1852 av_log(s->avctx, AV_LOG_ERROR, "Invalid tpend\n");
1853 return AVERROR_INVALIDDATA;
1855 bytestream2_init(&tp->tpg, s->g.buffer, tp->tp_end - s->g.buffer);
1856 bytestream2_skip(&s->g, tp->tp_end - s->g.buffer);
1860 if (marker == JPEG2000_EOC)
1863 len = bytestream2_get_be16(&s->g);
1864 if (len < 2 || bytestream2_get_bytes_left(&s->g) < len - 2) {
1865 av_log(s->avctx, AV_LOG_ERROR, "Invalid len %d left=%d\n", len, bytestream2_get_bytes_left(&s->g));
1866 return AVERROR_INVALIDDATA;
1873 s->numXtiles = s->numYtiles = 0;
1876 ret = get_coc(s, codsty, properties);
1879 ret = get_cod(s, codsty, properties);
1882 ret = get_qcc(s, len, qntsty, properties);
1885 ret = get_qcd(s, len, qntsty, properties);
1888 ret = get_poc(s, len, poc);
1891 if (!(ret = get_sot(s, len))) {
1892 av_assert1(s->curtileno >= 0);
1893 codsty = s->tile[s->curtileno].codsty;
1894 qntsty = s->tile[s->curtileno].qntsty;
1895 poc = &s->tile[s->curtileno].poc;
1896 properties = s->tile[s->curtileno].properties;
1900 // the comment is ignored
1901 bytestream2_skip(&s->g, len - 2);
1904 // Tile-part lengths
1905 ret = get_tlm(s, len);
1908 // Packet length, tile-part header
1909 ret = get_plt(s, len);
1912 av_log(s->avctx, AV_LOG_ERROR,
1913 "unsupported marker 0x%.4"PRIX16" at pos 0x%X\n",
1914 marker, bytestream2_tell(&s->g) - 4);
1915 bytestream2_skip(&s->g, len - 2);
1918 if (bytestream2_tell(&s->g) - oldpos != len || ret) {
1919 av_log(s->avctx, AV_LOG_ERROR,
1920 "error during processing marker segment %.4"PRIx16"\n",
1922 return ret ? ret : -1;
1928 /* Read bit stream packets --> T2 operation. */
1929 static int jpeg2000_read_bitstream_packets(Jpeg2000DecoderContext *s)
1934 for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++) {
1935 Jpeg2000Tile *tile = s->tile + tileno;
1937 if ((ret = init_tile(s, tileno)) < 0)
1940 s->g = tile->tile_part[0].tpg;
1941 if ((ret = jpeg2000_decode_packets(s, tile)) < 0)
1948 static int jp2_find_codestream(Jpeg2000DecoderContext *s)
1950 uint32_t atom_size, atom, atom_end;
1951 int search_range = 10;
1955 bytestream2_get_bytes_left(&s->g) >= 8) {
1956 atom_size = bytestream2_get_be32u(&s->g);
1957 atom = bytestream2_get_be32u(&s->g);
1958 atom_end = bytestream2_tell(&s->g) + atom_size - 8;
1960 if (atom == JP2_CODESTREAM)
1963 if (bytestream2_get_bytes_left(&s->g) < atom_size || atom_end < atom_size)
1966 if (atom == JP2_HEADER &&
1968 uint32_t atom2_size, atom2, atom2_end;
1970 atom2_size = bytestream2_get_be32u(&s->g);
1971 atom2 = bytestream2_get_be32u(&s->g);
1972 atom2_end = bytestream2_tell(&s->g) + atom2_size - 8;
1973 if (atom2_size < 8 || atom2_end > atom_end || atom2_end < atom2_size)
1975 if (atom2 == JP2_CODESTREAM) {
1977 } else if (atom2 == MKBETAG('c','o','l','r') && atom2_size >= 7) {
1978 int method = bytestream2_get_byteu(&s->g);
1979 bytestream2_skipu(&s->g, 2);
1981 s->colour_space = bytestream2_get_be32u(&s->g);
1983 } else if (atom2 == MKBETAG('p','c','l','r') && atom2_size >= 6) {
1984 int i, size, colour_count, colour_channels, colour_depth[3];
1986 colour_count = bytestream2_get_be16u(&s->g);
1987 colour_channels = bytestream2_get_byteu(&s->g);
1988 // FIXME: Do not ignore channel_sign
1989 colour_depth[0] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1;
1990 colour_depth[1] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1;
1991 colour_depth[2] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1;
1992 size = (colour_depth[0] + 7 >> 3) * colour_count +
1993 (colour_depth[1] + 7 >> 3) * colour_count +
1994 (colour_depth[2] + 7 >> 3) * colour_count;
1995 if (colour_count > 256 ||
1996 colour_channels != 3 ||
1997 colour_depth[0] > 16 ||
1998 colour_depth[1] > 16 ||
1999 colour_depth[2] > 16 ||
2000 atom2_size < size) {
2001 avpriv_request_sample(s->avctx, "Unknown palette");
2002 bytestream2_seek(&s->g, atom2_end, SEEK_SET);
2006 for (i = 0; i < colour_count; i++) {
2007 if (colour_depth[0] <= 8) {
2008 r = bytestream2_get_byteu(&s->g) << 8 - colour_depth[0];
2009 r |= r >> colour_depth[0];
2011 r = bytestream2_get_be16u(&s->g) >> colour_depth[0] - 8;
2013 if (colour_depth[1] <= 8) {
2014 g = bytestream2_get_byteu(&s->g) << 8 - colour_depth[1];
2015 r |= r >> colour_depth[1];
2017 g = bytestream2_get_be16u(&s->g) >> colour_depth[1] - 8;
2019 if (colour_depth[2] <= 8) {
2020 b = bytestream2_get_byteu(&s->g) << 8 - colour_depth[2];
2021 r |= r >> colour_depth[2];
2023 b = bytestream2_get_be16u(&s->g) >> colour_depth[2] - 8;
2025 s->palette[i] = 0xffu << 24 | r << 16 | g << 8 | b;
2027 } else if (atom2 == MKBETAG('c','d','e','f') && atom2_size >= 2) {
2028 int n = bytestream2_get_be16u(&s->g);
2030 int cn = bytestream2_get_be16(&s->g);
2031 int av_unused typ = bytestream2_get_be16(&s->g);
2032 int asoc = bytestream2_get_be16(&s->g);
2033 if (cn < 4 && asoc < 4)
2037 bytestream2_seek(&s->g, atom2_end, SEEK_SET);
2038 } while (atom_end - atom2_end >= 8);
2042 bytestream2_seek(&s->g, atom_end, SEEK_SET);
2048 static av_cold int jpeg2000_decode_init(AVCodecContext *avctx)
2050 Jpeg2000DecoderContext *s = avctx->priv_data;
2052 ff_jpeg2000dsp_init(&s->dsp);
2057 static int jpeg2000_decode_frame(AVCodecContext *avctx, void *data,
2058 int *got_frame, AVPacket *avpkt)
2060 Jpeg2000DecoderContext *s = avctx->priv_data;
2061 ThreadFrame frame = { .f = data };
2062 AVFrame *picture = data;
2066 bytestream2_init(&s->g, avpkt->data, avpkt->size);
2068 memset(s->cdef, -1, sizeof(s->cdef));
2070 if (bytestream2_get_bytes_left(&s->g) < 2) {
2071 ret = AVERROR_INVALIDDATA;
2075 // check if the image is in jp2 format
2076 if (bytestream2_get_bytes_left(&s->g) >= 12 &&
2077 (bytestream2_get_be32u(&s->g) == 12) &&
2078 (bytestream2_get_be32u(&s->g) == JP2_SIG_TYPE) &&
2079 (bytestream2_get_be32u(&s->g) == JP2_SIG_VALUE)) {
2080 if (!jp2_find_codestream(s)) {
2081 av_log(avctx, AV_LOG_ERROR,
2082 "Could not find Jpeg2000 codestream atom.\n");
2083 ret = AVERROR_INVALIDDATA;
2087 bytestream2_seek(&s->g, 0, SEEK_SET);
2090 while (bytestream2_get_bytes_left(&s->g) >= 3 && bytestream2_peek_be16(&s->g) != JPEG2000_SOC)
2091 bytestream2_skip(&s->g, 1);
2093 if (bytestream2_get_be16u(&s->g) != JPEG2000_SOC) {
2094 av_log(avctx, AV_LOG_ERROR, "SOC marker not present\n");
2095 ret = AVERROR_INVALIDDATA;
2098 if (ret = jpeg2000_read_main_headers(s))
2101 /* get picture buffer */
2102 if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
2104 picture->pict_type = AV_PICTURE_TYPE_I;
2105 picture->key_frame = 1;
2107 if (ret = jpeg2000_read_bitstream_packets(s))
2110 for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++)
2111 if (ret = jpeg2000_decode_tile(s, s->tile + tileno, picture))
2114 jpeg2000_dec_cleanup(s);
2118 if (s->avctx->pix_fmt == AV_PIX_FMT_PAL8)
2119 memcpy(picture->data[1], s->palette, 256 * sizeof(uint32_t));
2121 return bytestream2_tell(&s->g);
2124 jpeg2000_dec_cleanup(s);
2128 static av_cold void jpeg2000_init_static_data(AVCodec *codec)
2130 ff_jpeg2000_init_tier1_luts();
2131 ff_mqc_init_context_tables();
2134 #define OFFSET(x) offsetof(Jpeg2000DecoderContext, x)
2135 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
2137 static const AVOption options[] = {
2138 { "lowres", "Lower the decoding resolution by a power of two",
2139 OFFSET(reduction_factor), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, JPEG2000_MAX_RESLEVELS - 1, VD },
2143 static const AVProfile profiles[] = {
2144 { FF_PROFILE_JPEG2000_CSTREAM_RESTRICTION_0, "JPEG 2000 codestream restriction 0" },
2145 { FF_PROFILE_JPEG2000_CSTREAM_RESTRICTION_1, "JPEG 2000 codestream restriction 1" },
2146 { FF_PROFILE_JPEG2000_CSTREAM_NO_RESTRICTION, "JPEG 2000 no codestream restrictions" },
2147 { FF_PROFILE_JPEG2000_DCINEMA_2K, "JPEG 2000 digital cinema 2K" },
2148 { FF_PROFILE_JPEG2000_DCINEMA_4K, "JPEG 2000 digital cinema 4K" },
2149 { FF_PROFILE_UNKNOWN },
2152 static const AVClass jpeg2000_class = {
2153 .class_name = "jpeg2000",
2154 .item_name = av_default_item_name,
2156 .version = LIBAVUTIL_VERSION_INT,
2159 AVCodec ff_jpeg2000_decoder = {
2161 .long_name = NULL_IF_CONFIG_SMALL("JPEG 2000"),
2162 .type = AVMEDIA_TYPE_VIDEO,
2163 .id = AV_CODEC_ID_JPEG2000,
2164 .capabilities = AV_CODEC_CAP_FRAME_THREADS | AV_CODEC_CAP_DR1,
2165 .priv_data_size = sizeof(Jpeg2000DecoderContext),
2166 .init_static_data = jpeg2000_init_static_data,
2167 .init = jpeg2000_decode_init,
2168 .decode = jpeg2000_decode_frame,
2169 .priv_class = &jpeg2000_class,
2171 .profiles = NULL_IF_CONFIG_SMALL(profiles)