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 & CODEC_FLAG_BITEXACT) && (c->transform == FF_DWT97))
471 c->transform = FF_DWT97_INT;
473 if (c->csty & JPEG2000_CSTY_PREC) {
475 for (i = 0; i < c->nreslevels; i++) {
476 byte = bytestream2_get_byte(&s->g);
477 c->log2_prec_widths[i] = byte & 0x0F; // precinct PPx
478 c->log2_prec_heights[i] = (byte >> 4) & 0x0F; // precinct PPy
480 if (c->log2_prec_widths[i] == 0 || c->log2_prec_heights[i] == 0) {
481 av_log(s->avctx, AV_LOG_ERROR, "PPx %d PPy %d invalid\n",
482 c->log2_prec_widths[i], c->log2_prec_heights[i]);
483 c->log2_prec_widths[i] = c->log2_prec_heights[i] = 1;
484 return AVERROR_INVALIDDATA;
488 memset(c->log2_prec_widths , 15, sizeof(c->log2_prec_widths ));
489 memset(c->log2_prec_heights, 15, sizeof(c->log2_prec_heights));
494 /* get coding parameters for a particular tile or whole image*/
495 static int get_cod(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c,
498 Jpeg2000CodingStyle tmp;
501 if (bytestream2_get_bytes_left(&s->g) < 5) {
502 av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for COD\n");
503 return AVERROR_INVALIDDATA;
506 tmp.csty = bytestream2_get_byteu(&s->g);
508 // get progression order
509 tmp.prog_order = bytestream2_get_byteu(&s->g);
511 tmp.nlayers = bytestream2_get_be16u(&s->g);
512 tmp.mct = bytestream2_get_byteu(&s->g); // multiple component transformation
514 if (tmp.mct && s->ncomponents < 3) {
515 av_log(s->avctx, AV_LOG_ERROR,
516 "MCT %"PRIu8" with too few components (%d)\n",
517 tmp.mct, s->ncomponents);
518 return AVERROR_INVALIDDATA;
521 if ((ret = get_cox(s, &tmp)) < 0)
524 for (compno = 0; compno < s->ncomponents; compno++)
525 if (!(properties[compno] & HAD_COC))
526 memcpy(c + compno, &tmp, sizeof(tmp));
530 /* Get coding parameters for a component in the whole image or a
531 * particular tile. */
532 static int get_coc(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c,
537 if (bytestream2_get_bytes_left(&s->g) < 2) {
538 av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for COC\n");
539 return AVERROR_INVALIDDATA;
542 compno = bytestream2_get_byteu(&s->g);
544 if (compno >= s->ncomponents) {
545 av_log(s->avctx, AV_LOG_ERROR,
546 "Invalid compno %d. There are %d components in the image.\n",
547 compno, s->ncomponents);
548 return AVERROR_INVALIDDATA;
552 c->csty = bytestream2_get_byteu(&s->g);
554 if ((ret = get_cox(s, c)) < 0)
557 properties[compno] |= HAD_COC;
561 /* Get common part for QCD and QCC segments. */
562 static int get_qcx(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q)
566 if (bytestream2_get_bytes_left(&s->g) < 1)
567 return AVERROR_INVALIDDATA;
569 x = bytestream2_get_byteu(&s->g); // Sqcd
571 q->nguardbits = x >> 5;
572 q->quantsty = x & 0x1f;
574 if (q->quantsty == JPEG2000_QSTY_NONE) {
576 if (bytestream2_get_bytes_left(&s->g) < n ||
577 n > JPEG2000_MAX_DECLEVELS*3)
578 return AVERROR_INVALIDDATA;
579 for (i = 0; i < n; i++)
580 q->expn[i] = bytestream2_get_byteu(&s->g) >> 3;
581 } else if (q->quantsty == JPEG2000_QSTY_SI) {
582 if (bytestream2_get_bytes_left(&s->g) < 2)
583 return AVERROR_INVALIDDATA;
584 x = bytestream2_get_be16u(&s->g);
585 q->expn[0] = x >> 11;
586 q->mant[0] = x & 0x7ff;
587 for (i = 1; i < JPEG2000_MAX_DECLEVELS * 3; i++) {
588 int curexpn = FFMAX(0, q->expn[0] - (i - 1) / 3);
589 q->expn[i] = curexpn;
590 q->mant[i] = q->mant[0];
594 if (bytestream2_get_bytes_left(&s->g) < 2 * n ||
595 n > JPEG2000_MAX_DECLEVELS*3)
596 return AVERROR_INVALIDDATA;
597 for (i = 0; i < n; i++) {
598 x = bytestream2_get_be16u(&s->g);
599 q->expn[i] = x >> 11;
600 q->mant[i] = x & 0x7ff;
606 /* Get quantization parameters for a particular tile or a whole image. */
607 static int get_qcd(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q,
610 Jpeg2000QuantStyle tmp;
613 memset(&tmp, 0, sizeof(tmp));
615 if ((ret = get_qcx(s, n, &tmp)) < 0)
617 for (compno = 0; compno < s->ncomponents; compno++)
618 if (!(properties[compno] & HAD_QCC))
619 memcpy(q + compno, &tmp, sizeof(tmp));
623 /* Get quantization parameters for a component in the whole image
624 * on in a particular tile. */
625 static int get_qcc(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q,
630 if (bytestream2_get_bytes_left(&s->g) < 1)
631 return AVERROR_INVALIDDATA;
633 compno = bytestream2_get_byteu(&s->g);
635 if (compno >= s->ncomponents) {
636 av_log(s->avctx, AV_LOG_ERROR,
637 "Invalid compno %d. There are %d components in the image.\n",
638 compno, s->ncomponents);
639 return AVERROR_INVALIDDATA;
642 properties[compno] |= HAD_QCC;
643 return get_qcx(s, n - 1, q + compno);
646 static int get_poc(Jpeg2000DecoderContext *s, int size, Jpeg2000POC *p)
649 int elem_size = s->ncomponents <= 257 ? 7 : 9;
650 Jpeg2000POC tmp = {{{0}}};
652 if (bytestream2_get_bytes_left(&s->g) < 5 || size < 2 + elem_size) {
653 av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for POC\n");
654 return AVERROR_INVALIDDATA;
658 avpriv_request_sample(s->avctx, "Fat POC not supported\n");
659 return AVERROR_PATCHWELCOME;
662 tmp.nb_poc = (size - 2) / elem_size;
663 if (tmp.nb_poc > MAX_POCS) {
664 avpriv_request_sample(s->avctx, "Too many POCs (%d)\n", tmp.nb_poc);
665 return AVERROR_PATCHWELCOME;
668 for (i = 0; i<tmp.nb_poc; i++) {
669 Jpeg2000POCEntry *e = &tmp.poc[i];
670 e->RSpoc = bytestream2_get_byteu(&s->g);
671 e->CSpoc = bytestream2_get_byteu(&s->g);
672 e->LYEpoc = bytestream2_get_be16u(&s->g);
673 e->REpoc = bytestream2_get_byteu(&s->g);
674 e->CEpoc = bytestream2_get_byteu(&s->g);
675 e->Ppoc = bytestream2_get_byteu(&s->g);
678 if (e->CEpoc > s->ncomponents)
679 e->CEpoc = s->ncomponents;
680 if ( e->RSpoc >= e->REpoc || e->REpoc > 33
681 || e->CSpoc >= e->CEpoc || e->CEpoc > s->ncomponents
683 av_log(s->avctx, AV_LOG_ERROR, "POC Entry %d is invalid (%d, %d, %d, %d, %d, %d)\n", i,
684 e->RSpoc, e->CSpoc, e->LYEpoc, e->REpoc, e->CEpoc, e->Ppoc
686 return AVERROR_INVALIDDATA;
690 if (!p->nb_poc || p->is_default) {
693 if (p->nb_poc + tmp.nb_poc > MAX_POCS) {
694 av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for POC\n");
695 return AVERROR_INVALIDDATA;
697 memcpy(p->poc + p->nb_poc, tmp.poc, tmp.nb_poc * sizeof(tmp.poc[0]));
698 p->nb_poc += tmp.nb_poc;
707 /* Get start of tile segment. */
708 static int get_sot(Jpeg2000DecoderContext *s, int n)
710 Jpeg2000TilePart *tp;
715 if (bytestream2_get_bytes_left(&s->g) < 8)
716 return AVERROR_INVALIDDATA;
719 Isot = bytestream2_get_be16u(&s->g); // Isot
720 if (Isot >= s->numXtiles * s->numYtiles)
721 return AVERROR_INVALIDDATA;
724 Psot = bytestream2_get_be32u(&s->g); // Psot
725 TPsot = bytestream2_get_byteu(&s->g); // TPsot
727 /* Read TNSot but not used */
728 bytestream2_get_byteu(&s->g); // TNsot
731 Psot = bytestream2_get_bytes_left(&s->g) + n + 2;
733 if (Psot > bytestream2_get_bytes_left(&s->g) + n + 2) {
734 av_log(s->avctx, AV_LOG_ERROR, "Psot %"PRIu32" too big\n", Psot);
735 return AVERROR_INVALIDDATA;
738 av_assert0(TPsot < FF_ARRAY_ELEMS(s->tile[Isot].tile_part));
740 s->tile[Isot].tp_idx = TPsot;
741 tp = s->tile[Isot].tile_part + TPsot;
742 tp->tile_index = Isot;
743 tp->tp_end = s->g.buffer + Psot - n - 2;
746 Jpeg2000Tile *tile = s->tile + s->curtileno;
749 memcpy(tile->codsty, s->codsty, s->ncomponents * sizeof(Jpeg2000CodingStyle));
750 memcpy(tile->qntsty, s->qntsty, s->ncomponents * sizeof(Jpeg2000QuantStyle));
751 memcpy(&tile->poc , &s->poc , sizeof(tile->poc));
752 tile->poc.is_default = 1;
758 /* Tile-part lengths: see ISO 15444-1:2002, section A.7.1
759 * Used to know the number of tile parts and lengths.
760 * There may be multiple TLMs in the header.
761 * TODO: The function is not used for tile-parts management, nor anywhere else.
762 * It can be useful to allocate memory for tile parts, before managing the SOT
763 * markers. Parsing the TLM header is needed to increment the input header
765 * This marker is mandatory for DCI. */
766 static uint8_t get_tlm(Jpeg2000DecoderContext *s, int n)
768 uint8_t Stlm, ST, SP, tile_tlm, i;
769 bytestream2_get_byte(&s->g); /* Ztlm: skipped */
770 Stlm = bytestream2_get_byte(&s->g);
772 // too complex ? ST = ((Stlm >> 4) & 0x01) + ((Stlm >> 4) & 0x02);
773 ST = (Stlm >> 4) & 0x03;
774 // TODO: Manage case of ST = 0b11 --> raise error
775 SP = (Stlm >> 6) & 0x01;
776 tile_tlm = (n - 4) / ((SP + 1) * 2 + ST);
777 for (i = 0; i < tile_tlm; i++) {
782 bytestream2_get_byte(&s->g);
785 bytestream2_get_be16(&s->g);
788 bytestream2_get_be32(&s->g);
792 bytestream2_get_be16(&s->g);
794 bytestream2_get_be32(&s->g);
800 static uint8_t get_plt(Jpeg2000DecoderContext *s, int n)
804 av_log(s->avctx, AV_LOG_DEBUG,
805 "PLT marker at pos 0x%X\n", bytestream2_tell(&s->g) - 4);
807 /*Zplt =*/ bytestream2_get_byte(&s->g);
809 for (i = 0; i < n - 3; i++) {
810 bytestream2_get_byte(&s->g);
816 static int init_tile(Jpeg2000DecoderContext *s, int tileno)
819 int tilex = tileno % s->numXtiles;
820 int tiley = tileno / s->numXtiles;
821 Jpeg2000Tile *tile = s->tile + tileno;
824 return AVERROR(ENOMEM);
826 tile->coord[0][0] = FFMAX(tilex * s->tile_width + s->tile_offset_x, s->image_offset_x);
827 tile->coord[0][1] = FFMIN((tilex + 1) * s->tile_width + s->tile_offset_x, s->width);
828 tile->coord[1][0] = FFMAX(tiley * s->tile_height + s->tile_offset_y, s->image_offset_y);
829 tile->coord[1][1] = FFMIN((tiley + 1) * s->tile_height + s->tile_offset_y, s->height);
831 for (compno = 0; compno < s->ncomponents; compno++) {
832 Jpeg2000Component *comp = tile->comp + compno;
833 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
834 Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
835 int ret; // global bandno
837 comp->coord_o[0][0] = tile->coord[0][0];
838 comp->coord_o[0][1] = tile->coord[0][1];
839 comp->coord_o[1][0] = tile->coord[1][0];
840 comp->coord_o[1][1] = tile->coord[1][1];
842 comp->coord_o[0][0] /= s->cdx[compno];
843 comp->coord_o[0][1] /= s->cdx[compno];
844 comp->coord_o[1][0] /= s->cdy[compno];
845 comp->coord_o[1][1] /= s->cdy[compno];
848 comp->coord[0][0] = ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], s->reduction_factor);
849 comp->coord[0][1] = ff_jpeg2000_ceildivpow2(comp->coord_o[0][1], s->reduction_factor);
850 comp->coord[1][0] = ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], s->reduction_factor);
851 comp->coord[1][1] = ff_jpeg2000_ceildivpow2(comp->coord_o[1][1], s->reduction_factor);
853 if (ret = ff_jpeg2000_init_component(comp, codsty, qntsty,
854 s->cbps[compno], s->cdx[compno],
855 s->cdy[compno], s->avctx))
861 /* Read the number of coding passes. */
862 static int getnpasses(Jpeg2000DecoderContext *s)
869 if ((num = get_bits(s, 2)) != 3)
870 return num < 0 ? num : 3 + num;
871 if ((num = get_bits(s, 5)) != 31)
872 return num < 0 ? num : 6 + num;
873 num = get_bits(s, 7);
874 return num < 0 ? num : 37 + num;
877 static int getlblockinc(Jpeg2000DecoderContext *s)
880 while (ret = get_bits(s, 1)) {
888 static int jpeg2000_decode_packet(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile, int *tp_index,
889 Jpeg2000CodingStyle *codsty,
890 Jpeg2000ResLevel *rlevel, int precno,
891 int layno, uint8_t *expn, int numgbits)
893 int bandno, cblkno, ret, nb_code_blocks;
896 if (layno < rlevel->band[0].prec[precno].decoded_layers)
898 rlevel->band[0].prec[precno].decoded_layers = layno + 1;
900 if (bytestream2_get_bytes_left(&s->g) == 0 && s->bit_index == 8) {
901 if (*tp_index < FF_ARRAY_ELEMS(tile->tile_part) - 1) {
902 s->g = tile->tile_part[++(*tp_index)].tpg;
906 if (bytestream2_peek_be32(&s->g) == JPEG2000_SOP_FIXED_BYTES)
907 bytestream2_skip(&s->g, JPEG2000_SOP_BYTE_LENGTH);
909 if (!(ret = get_bits(s, 1))) {
915 for (bandno = 0; bandno < rlevel->nbands; bandno++) {
916 Jpeg2000Band *band = rlevel->band + bandno;
917 Jpeg2000Prec *prec = band->prec + precno;
919 if (band->coord[0][0] == band->coord[0][1] ||
920 band->coord[1][0] == band->coord[1][1])
922 nb_code_blocks = prec->nb_codeblocks_height *
923 prec->nb_codeblocks_width;
924 for (cblkno = 0; cblkno < nb_code_blocks; cblkno++) {
925 Jpeg2000Cblk *cblk = prec->cblk + cblkno;
926 int incl, newpasses, llen;
929 incl = get_bits(s, 1);
931 incl = tag_tree_decode(s, prec->cblkincl + cblkno, layno + 1) == layno;
937 if (!cblk->npasses) {
938 int v = expn[bandno] + numgbits - 1 -
939 tag_tree_decode(s, prec->zerobits + cblkno, 100);
941 av_log(s->avctx, AV_LOG_ERROR,
942 "nonzerobits %d invalid\n", v);
943 return AVERROR_INVALIDDATA;
945 cblk->nonzerobits = v;
947 if ((newpasses = getnpasses(s)) < 0)
949 av_assert2(newpasses > 0);
950 if (cblk->npasses + newpasses >= JPEG2000_MAX_PASSES) {
951 avpriv_request_sample(s->avctx, "Too many passes\n");
952 return AVERROR_PATCHWELCOME;
954 if ((llen = getlblockinc(s)) < 0)
956 if (cblk->lblock + llen + av_log2(newpasses) > 16) {
957 avpriv_request_sample(s->avctx,
958 "Block with length beyond 16 bits\n");
959 return AVERROR_PATCHWELCOME;
962 cblk->lblock += llen;
964 cblk->nb_lengthinc = 0;
965 cblk->nb_terminationsinc = 0;
969 while (newpasses1 < newpasses) {
971 if (needs_termination(codsty->cblk_style, cblk->npasses + newpasses1 - 1)) {
972 cblk->nb_terminationsinc ++;
977 if ((ret = get_bits(s, av_log2(newpasses1) + cblk->lblock)) < 0)
979 if (ret > sizeof(cblk->data)) {
980 avpriv_request_sample(s->avctx,
981 "Block with lengthinc greater than %"SIZE_SPECIFIER"",
983 return AVERROR_PATCHWELCOME;
985 cblk->lengthinc[cblk->nb_lengthinc++] = ret;
986 cblk->npasses += newpasses1;
987 newpasses -= newpasses1;
993 if (codsty->csty & JPEG2000_CSTY_EPH) {
994 if (bytestream2_peek_be16(&s->g) == JPEG2000_EPH)
995 bytestream2_skip(&s->g, 2);
997 av_log(s->avctx, AV_LOG_ERROR, "EPH marker not found. instead %X\n", bytestream2_peek_be32(&s->g));
1000 for (bandno = 0; bandno < rlevel->nbands; bandno++) {
1001 Jpeg2000Band *band = rlevel->band + bandno;
1002 Jpeg2000Prec *prec = band->prec + precno;
1004 nb_code_blocks = prec->nb_codeblocks_height * prec->nb_codeblocks_width;
1005 for (cblkno = 0; cblkno < nb_code_blocks; cblkno++) {
1006 Jpeg2000Cblk *cblk = prec->cblk + cblkno;
1007 for (cwsno = 0; cwsno < cblk->nb_lengthinc; cwsno ++) {
1008 if ( bytestream2_get_bytes_left(&s->g) < cblk->lengthinc[cwsno]
1009 || sizeof(cblk->data) < cblk->length + cblk->lengthinc[cwsno] + 4
1011 av_log(s->avctx, AV_LOG_ERROR,
1012 "Block length %"PRIu16" or lengthinc %d is too large, left %d\n",
1013 cblk->length, cblk->lengthinc[cwsno], bytestream2_get_bytes_left(&s->g));
1014 return AVERROR_INVALIDDATA;
1017 bytestream2_get_bufferu(&s->g, cblk->data + cblk->length, cblk->lengthinc[cwsno]);
1018 cblk->length += cblk->lengthinc[cwsno];
1019 cblk->lengthinc[cwsno] = 0;
1020 if (cblk->nb_terminationsinc) {
1021 cblk->nb_terminationsinc--;
1022 cblk->nb_terminations++;
1023 cblk->data[cblk->length++] = 0xFF;
1024 cblk->data[cblk->length++] = 0xFF;
1025 cblk->data_start[cblk->nb_terminations] = cblk->length;
1033 static int jpeg2000_decode_packets_po_iteration(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile,
1034 int RSpoc, int CSpoc,
1035 int LYEpoc, int REpoc, int CEpoc,
1036 int Ppoc, int *tp_index)
1039 int layno, reslevelno, compno, precno, ok_reslevel;
1044 case JPEG2000_PGOD_RLCP:
1045 av_log(s->avctx, AV_LOG_DEBUG, "Progression order RLCP\n");
1047 for (reslevelno = RSpoc; ok_reslevel && reslevelno < REpoc; reslevelno++) {
1049 for (layno = 0; layno < LYEpoc; layno++) {
1050 for (compno = CSpoc; compno < CEpoc; compno++) {
1051 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1052 Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
1053 if (reslevelno < codsty->nreslevels) {
1054 Jpeg2000ResLevel *rlevel = tile->comp[compno].reslevel +
1057 for (precno = 0; precno < rlevel->num_precincts_x * rlevel->num_precincts_y; precno++)
1058 if ((ret = jpeg2000_decode_packet(s, tile, tp_index,
1061 qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1062 qntsty->nguardbits)) < 0)
1070 case JPEG2000_PGOD_LRCP:
1071 av_log(s->avctx, AV_LOG_DEBUG, "Progression order LRCP\n");
1072 for (layno = 0; layno < LYEpoc; layno++) {
1074 for (reslevelno = RSpoc; ok_reslevel && reslevelno < REpoc; reslevelno++) {
1076 for (compno = CSpoc; compno < CEpoc; compno++) {
1077 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1078 Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
1079 if (reslevelno < codsty->nreslevels) {
1080 Jpeg2000ResLevel *rlevel = tile->comp[compno].reslevel +
1083 for (precno = 0; precno < rlevel->num_precincts_x * rlevel->num_precincts_y; precno++)
1084 if ((ret = jpeg2000_decode_packet(s, tile, tp_index,
1087 qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1088 qntsty->nguardbits)) < 0)
1096 case JPEG2000_PGOD_CPRL:
1097 av_log(s->avctx, AV_LOG_DEBUG, "Progression order CPRL\n");
1098 for (compno = CSpoc; compno < CEpoc; compno++) {
1099 Jpeg2000Component *comp = tile->comp + compno;
1100 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1101 Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
1105 for (reslevelno = RSpoc; reslevelno < FFMIN(codsty->nreslevels, REpoc); reslevelno++) {
1106 uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1107 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1108 step_x = FFMIN(step_x, rlevel->log2_prec_width + reducedresno);
1109 step_y = FFMIN(step_y, rlevel->log2_prec_height + reducedresno);
1114 for (y = tile->coord[1][0]; y < tile->coord[1][1]; y = (y/step_y + 1)*step_y) {
1115 for (x = tile->coord[0][0]; x < tile->coord[0][1]; x = (x/step_x + 1)*step_x) {
1116 for (reslevelno = RSpoc; reslevelno < FFMIN(codsty->nreslevels, REpoc); reslevelno++) {
1117 unsigned prcx, prcy;
1118 uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1119 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1120 int xc = x / s->cdx[compno];
1121 int yc = y / s->cdy[compno];
1123 if (yc % (1 << (rlevel->log2_prec_height + reducedresno)) && y != tile->coord[1][0]) //FIXME this is a subset of the check
1126 if (xc % (1 << (rlevel->log2_prec_width + reducedresno)) && x != tile->coord[0][0]) //FIXME this is a subset of the check
1129 // check if a precinct exists
1130 prcx = ff_jpeg2000_ceildivpow2(xc, reducedresno) >> rlevel->log2_prec_width;
1131 prcy = ff_jpeg2000_ceildivpow2(yc, reducedresno) >> rlevel->log2_prec_height;
1132 prcx -= ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], reducedresno) >> rlevel->log2_prec_width;
1133 prcy -= ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], reducedresno) >> rlevel->log2_prec_height;
1135 precno = prcx + rlevel->num_precincts_x * prcy;
1137 if (prcx >= rlevel->num_precincts_x || prcy >= rlevel->num_precincts_y) {
1138 av_log(s->avctx, AV_LOG_WARNING, "prc %d %d outside limits %d %d\n",
1139 prcx, prcy, rlevel->num_precincts_x, rlevel->num_precincts_y);
1143 for (layno = 0; layno < LYEpoc; layno++) {
1144 if ((ret = jpeg2000_decode_packet(s, tile, tp_index, codsty, rlevel,
1146 qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1147 qntsty->nguardbits)) < 0)
1156 case JPEG2000_PGOD_RPCL:
1157 av_log(s->avctx, AV_LOG_WARNING, "Progression order RPCL\n");
1159 for (reslevelno = RSpoc; ok_reslevel && reslevelno < REpoc; reslevelno++) {
1163 for (compno = CSpoc; compno < CEpoc; compno++) {
1164 Jpeg2000Component *comp = tile->comp + compno;
1165 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1167 if (reslevelno < codsty->nreslevels) {
1168 uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1169 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1170 step_x = FFMIN(step_x, rlevel->log2_prec_width + reducedresno);
1171 step_y = FFMIN(step_y, rlevel->log2_prec_height + reducedresno);
1177 for (y = tile->coord[1][0]; y < tile->coord[1][1]; y = (y/step_y + 1)*step_y) {
1178 for (x = tile->coord[0][0]; x < tile->coord[0][1]; x = (x/step_x + 1)*step_x) {
1179 for (compno = CSpoc; compno < CEpoc; compno++) {
1180 Jpeg2000Component *comp = tile->comp + compno;
1181 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1182 Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
1183 uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1184 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1185 unsigned prcx, prcy;
1187 int xc = x / s->cdx[compno];
1188 int yc = y / s->cdy[compno];
1190 if (reslevelno >= codsty->nreslevels)
1193 if (yc % (1 << (rlevel->log2_prec_height + reducedresno)) && y != tile->coord[1][0]) //FIXME this is a subset of the check
1196 if (xc % (1 << (rlevel->log2_prec_width + reducedresno)) && x != tile->coord[0][0]) //FIXME this is a subset of the check
1199 // check if a precinct exists
1200 prcx = ff_jpeg2000_ceildivpow2(xc, reducedresno) >> rlevel->log2_prec_width;
1201 prcy = ff_jpeg2000_ceildivpow2(yc, reducedresno) >> rlevel->log2_prec_height;
1202 prcx -= ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], reducedresno) >> rlevel->log2_prec_width;
1203 prcy -= ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], reducedresno) >> rlevel->log2_prec_height;
1205 precno = prcx + rlevel->num_precincts_x * prcy;
1208 if (prcx >= rlevel->num_precincts_x || prcy >= rlevel->num_precincts_y) {
1209 av_log(s->avctx, AV_LOG_WARNING, "prc %d %d outside limits %d %d\n",
1210 prcx, prcy, rlevel->num_precincts_x, rlevel->num_precincts_y);
1214 for (layno = 0; layno < LYEpoc; layno++) {
1215 if ((ret = jpeg2000_decode_packet(s, tile, tp_index,
1218 qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1219 qntsty->nguardbits)) < 0)
1228 case JPEG2000_PGOD_PCRL:
1229 av_log(s->avctx, AV_LOG_WARNING, "Progression order PCRL\n");
1232 for (compno = CSpoc; compno < CEpoc; compno++) {
1233 Jpeg2000Component *comp = tile->comp + compno;
1234 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1235 Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
1237 for (reslevelno = RSpoc; reslevelno < FFMIN(codsty->nreslevels, REpoc); reslevelno++) {
1238 uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1239 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1240 step_x = FFMIN(step_x, rlevel->log2_prec_width + reducedresno);
1241 step_y = FFMIN(step_y, rlevel->log2_prec_height + reducedresno);
1247 for (y = tile->coord[1][0]; y < tile->coord[1][1]; y = (y/step_y + 1)*step_y) {
1248 for (x = tile->coord[0][0]; x < tile->coord[0][1]; x = (x/step_x + 1)*step_x) {
1249 for (compno = CSpoc; compno < CEpoc; compno++) {
1250 Jpeg2000Component *comp = tile->comp + compno;
1251 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1252 Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
1253 int xc = x / s->cdx[compno];
1254 int yc = y / s->cdy[compno];
1256 for (reslevelno = RSpoc; reslevelno < FFMIN(codsty->nreslevels, REpoc); reslevelno++) {
1257 unsigned prcx, prcy;
1258 uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1259 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1261 if (yc % (1 << (rlevel->log2_prec_height + reducedresno)) && y != tile->coord[1][0]) //FIXME this is a subset of the check
1264 if (xc % (1 << (rlevel->log2_prec_width + reducedresno)) && x != tile->coord[0][0]) //FIXME this is a subset of the check
1267 // check if a precinct exists
1268 prcx = ff_jpeg2000_ceildivpow2(xc, reducedresno) >> rlevel->log2_prec_width;
1269 prcy = ff_jpeg2000_ceildivpow2(yc, reducedresno) >> rlevel->log2_prec_height;
1270 prcx -= ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], reducedresno) >> rlevel->log2_prec_width;
1271 prcy -= ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], reducedresno) >> rlevel->log2_prec_height;
1273 precno = prcx + rlevel->num_precincts_x * prcy;
1275 if (prcx >= rlevel->num_precincts_x || prcy >= rlevel->num_precincts_y) {
1276 av_log(s->avctx, AV_LOG_WARNING, "prc %d %d outside limits %d %d\n",
1277 prcx, prcy, rlevel->num_precincts_x, rlevel->num_precincts_y);
1281 for (layno = 0; layno < LYEpoc; layno++) {
1282 if ((ret = jpeg2000_decode_packet(s, tile, tp_index, codsty, rlevel,
1284 qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1285 qntsty->nguardbits)) < 0)
1301 static int jpeg2000_decode_packets(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
1307 if (tile->poc.nb_poc) {
1308 for (i=0; i<tile->poc.nb_poc; i++) {
1309 Jpeg2000POCEntry *e = &tile->poc.poc[i];
1310 ret = jpeg2000_decode_packets_po_iteration(s, tile,
1312 FFMIN(e->LYEpoc, tile->codsty[0].nlayers),
1314 FFMIN(e->CEpoc, s->ncomponents),
1321 ret = jpeg2000_decode_packets_po_iteration(s, tile,
1323 tile->codsty[0].nlayers,
1326 tile->codsty[0].prog_order,
1330 /* EOC marker reached */
1331 bytestream2_skip(&s->g, 2);
1336 /* TIER-1 routines */
1337 static void decode_sigpass(Jpeg2000T1Context *t1, int width, int height,
1338 int bpno, int bandno,
1339 int vert_causal_ctx_csty_symbol)
1341 int mask = 3 << (bpno - 1), y0, x, y;
1343 for (y0 = 0; y0 < height; y0 += 4)
1344 for (x = 0; x < width; x++)
1345 for (y = y0; y < height && y < y0 + 4; y++) {
1346 int flags_mask = -1;
1347 if (vert_causal_ctx_csty_symbol && y == y0 + 3)
1348 flags_mask &= ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE | JPEG2000_T1_SGN_S);
1349 if ((t1->flags[(y+1) * t1->stride + x+1] & JPEG2000_T1_SIG_NB & flags_mask)
1350 && !(t1->flags[(y+1) * t1->stride + x+1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS))) {
1351 if (ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ff_jpeg2000_getsigctxno(t1->flags[(y+1) * t1->stride + x+1] & flags_mask, bandno))) {
1352 int xorbit, ctxno = ff_jpeg2000_getsgnctxno(t1->flags[(y+1) * t1->stride + x+1] & flags_mask, &xorbit);
1354 t1->data[(y) * t1->stride + x] = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ctxno) ? -mask : mask;
1356 t1->data[(y) * t1->stride + x] = (ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ctxno) ^ xorbit) ?
1359 ff_jpeg2000_set_significance(t1, x, y,
1360 t1->data[(y) * t1->stride + x] < 0);
1362 t1->flags[(y + 1) * t1->stride + x + 1] |= JPEG2000_T1_VIS;
1367 static void decode_refpass(Jpeg2000T1Context *t1, int width, int height,
1368 int bpno, int vert_causal_ctx_csty_symbol)
1373 phalf = 1 << (bpno - 1);
1376 for (y0 = 0; y0 < height; y0 += 4)
1377 for (x = 0; x < width; x++)
1378 for (y = y0; y < height && y < y0 + 4; y++)
1379 if ((t1->flags[(y + 1) * t1->stride + x + 1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS)) == JPEG2000_T1_SIG) {
1380 int flags_mask = (vert_causal_ctx_csty_symbol && y == y0 + 3) ?
1381 ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE | JPEG2000_T1_SGN_S) : -1;
1382 int ctxno = ff_jpeg2000_getrefctxno(t1->flags[(y + 1) * t1->stride + x + 1] & flags_mask);
1383 int r = ff_mqc_decode(&t1->mqc,
1384 t1->mqc.cx_states + ctxno)
1386 t1->data[(y) * t1->stride + x] += t1->data[(y) * t1->stride + x] < 0 ? -r : r;
1387 t1->flags[(y + 1) * t1->stride + x + 1] |= JPEG2000_T1_REF;
1391 static void decode_clnpass(Jpeg2000DecoderContext *s, Jpeg2000T1Context *t1,
1392 int width, int height, int bpno, int bandno,
1393 int seg_symbols, int vert_causal_ctx_csty_symbol)
1395 int mask = 3 << (bpno - 1), y0, x, y, runlen, dec;
1397 for (y0 = 0; y0 < height; y0 += 4) {
1398 for (x = 0; x < width; x++) {
1399 int flags_mask = -1;
1400 if (vert_causal_ctx_csty_symbol)
1401 flags_mask &= ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE | JPEG2000_T1_SGN_S);
1402 if (y0 + 3 < height &&
1403 !((t1->flags[(y0 + 1) * t1->stride + x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
1404 (t1->flags[(y0 + 2) * t1->stride + x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
1405 (t1->flags[(y0 + 3) * t1->stride + x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
1406 (t1->flags[(y0 + 4) * t1->stride + x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG) & flags_mask))) {
1407 if (!ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_RL))
1409 runlen = ff_mqc_decode(&t1->mqc,
1410 t1->mqc.cx_states + MQC_CX_UNI);
1411 runlen = (runlen << 1) | ff_mqc_decode(&t1->mqc,
1420 for (y = y0 + runlen; y < y0 + 4 && y < height; y++) {
1421 int flags_mask = -1;
1422 if (vert_causal_ctx_csty_symbol && y == y0 + 3)
1423 flags_mask &= ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE | JPEG2000_T1_SGN_S);
1425 if (!(t1->flags[(y+1) * t1->stride + x+1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS))) {
1426 dec = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ff_jpeg2000_getsigctxno(t1->flags[(y+1) * t1->stride + x+1] & flags_mask,
1432 int ctxno = ff_jpeg2000_getsgnctxno(t1->flags[(y + 1) * t1->stride + x + 1] & flags_mask,
1434 t1->data[(y) * t1->stride + x] = (ff_mqc_decode(&t1->mqc,
1435 t1->mqc.cx_states + ctxno) ^
1438 ff_jpeg2000_set_significance(t1, x, y, t1->data[(y) * t1->stride + x] < 0);
1441 t1->flags[(y + 1) * t1->stride + x + 1] &= ~JPEG2000_T1_VIS;
1447 val = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1448 val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1449 val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1450 val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1452 av_log(s->avctx, AV_LOG_ERROR,
1453 "Segmentation symbol value incorrect\n");
1457 static int decode_cblk(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *codsty,
1458 Jpeg2000T1Context *t1, Jpeg2000Cblk *cblk,
1459 int width, int height, int bandpos)
1461 int passno = cblk->npasses, pass_t = 2, bpno = cblk->nonzerobits - 1, y;
1463 int vert_causal_ctx_csty_symbol = codsty->cblk_style & JPEG2000_CBLK_VSC;
1467 av_assert0(width <= 1024U && height <= 1024U);
1468 av_assert0(width*height <= 4096);
1470 memset(t1->data, 0, t1->stride * height * sizeof(*t1->data));
1472 /* If code-block contains no compressed data: nothing to do. */
1476 memset(t1->flags, 0, t1->stride * (height + 2) * sizeof(*t1->flags));
1478 cblk->data[cblk->length] = 0xff;
1479 cblk->data[cblk->length+1] = 0xff;
1480 ff_mqc_initdec(&t1->mqc, cblk->data, 0, 1);
1485 decode_sigpass(t1, width, height, bpno + 1, bandpos,
1486 vert_causal_ctx_csty_symbol);
1489 decode_refpass(t1, width, height, bpno + 1, vert_causal_ctx_csty_symbol);
1492 av_assert2(!t1->mqc.raw);
1493 decode_clnpass(s, t1, width, height, bpno + 1, bandpos,
1494 codsty->cblk_style & JPEG2000_CBLK_SEGSYM,
1495 vert_causal_ctx_csty_symbol);
1498 if (codsty->cblk_style & JPEG2000_CBLK_RESET) // XXX no testcase for just this
1499 ff_mqc_init_contexts(&t1->mqc);
1501 if (passno && (coder_type = needs_termination(codsty->cblk_style, pass_cnt))) {
1502 if (term_cnt >= cblk->nb_terminations) {
1503 av_log(s->avctx, AV_LOG_ERROR, "Missing needed termination \n");
1504 return AVERROR_INVALIDDATA;
1506 if (FFABS(cblk->data + cblk->data_start[term_cnt + 1] - 2 - t1->mqc.bp) > 0) {
1507 av_log(s->avctx, AV_LOG_WARNING, "Mid mismatch %"PTRDIFF_SPECIFIER" in pass %d of %d\n",
1508 cblk->data + cblk->data_start[term_cnt + 1] - 2 - t1->mqc.bp,
1509 pass_cnt, cblk->npasses);
1512 ff_mqc_initdec(&t1->mqc, cblk->data + cblk->data_start[++term_cnt], coder_type == 2, 0);
1523 if (cblk->data + cblk->length - 2*(term_cnt < cblk->nb_terminations) != t1->mqc.bp) {
1524 av_log(s->avctx, AV_LOG_WARNING, "End mismatch %"PTRDIFF_SPECIFIER"\n",
1525 cblk->data + cblk->length - 2*(term_cnt < cblk->nb_terminations) - t1->mqc.bp);
1531 /* TODO: Verify dequantization for lossless case
1532 * comp->data can be float or int
1533 * band->stepsize can be float or int
1534 * depending on the type of DWT transformation.
1535 * see ISO/IEC 15444-1:2002 A.6.1 */
1537 /* Float dequantization of a codeblock.*/
1538 static void dequantization_float(int x, int y, Jpeg2000Cblk *cblk,
1539 Jpeg2000Component *comp,
1540 Jpeg2000T1Context *t1, Jpeg2000Band *band)
1543 int w = cblk->coord[0][1] - cblk->coord[0][0];
1544 for (j = 0; j < (cblk->coord[1][1] - cblk->coord[1][0]); ++j) {
1545 float *datap = &comp->f_data[(comp->coord[0][1] - comp->coord[0][0]) * (y + j) + x];
1546 int *src = t1->data + j*t1->stride;
1547 for (i = 0; i < w; ++i)
1548 datap[i] = src[i] * band->f_stepsize;
1552 /* Integer dequantization of a codeblock.*/
1553 static void dequantization_int(int x, int y, Jpeg2000Cblk *cblk,
1554 Jpeg2000Component *comp,
1555 Jpeg2000T1Context *t1, Jpeg2000Band *band)
1558 int w = cblk->coord[0][1] - cblk->coord[0][0];
1559 for (j = 0; j < (cblk->coord[1][1] - cblk->coord[1][0]); ++j) {
1560 int32_t *datap = &comp->i_data[(comp->coord[0][1] - comp->coord[0][0]) * (y + j) + x];
1561 int *src = t1->data + j*t1->stride;
1562 if (band->i_stepsize == 32768) {
1563 for (i = 0; i < w; ++i)
1564 datap[i] = src[i] / 2;
1566 // This should be VERY uncommon
1567 for (i = 0; i < w; ++i)
1568 datap[i] = (src[i] * (int64_t)band->i_stepsize) / 65536;
1573 static void dequantization_int_97(int x, int y, Jpeg2000Cblk *cblk,
1574 Jpeg2000Component *comp,
1575 Jpeg2000T1Context *t1, Jpeg2000Band *band)
1578 int w = cblk->coord[0][1] - cblk->coord[0][0];
1579 for (j = 0; j < (cblk->coord[1][1] - cblk->coord[1][0]); ++j) {
1580 int32_t *datap = &comp->i_data[(comp->coord[0][1] - comp->coord[0][0]) * (y + j) + x];
1581 int *src = t1->data + j*t1->stride;
1582 for (i = 0; i < w; ++i)
1583 datap[i] = (src[i] * (int64_t)band->i_stepsize + (1<<15)) >> 16;
1587 static inline void mct_decode(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
1592 for (i = 1; i < 3; i++) {
1593 if (tile->codsty[0].transform != tile->codsty[i].transform) {
1594 av_log(s->avctx, AV_LOG_ERROR, "Transforms mismatch, MCT not supported\n");
1597 if (memcmp(tile->comp[0].coord, tile->comp[i].coord, sizeof(tile->comp[0].coord))) {
1598 av_log(s->avctx, AV_LOG_ERROR, "Coords mismatch, MCT not supported\n");
1603 for (i = 0; i < 3; i++)
1604 if (tile->codsty[0].transform == FF_DWT97)
1605 src[i] = tile->comp[i].f_data;
1607 src[i] = tile->comp[i].i_data;
1609 for (i = 0; i < 2; i++)
1610 csize *= tile->comp[0].coord[i][1] - tile->comp[0].coord[i][0];
1612 s->dsp.mct_decode[tile->codsty[0].transform](src[0], src[1], src[2], csize);
1615 static int jpeg2000_decode_tile(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile,
1618 const AVPixFmtDescriptor *pixdesc = av_pix_fmt_desc_get(s->avctx->pix_fmt);
1619 int compno, reslevelno, bandno;
1621 int planar = !!(pixdesc->flags & AV_PIX_FMT_FLAG_PLANAR);
1622 int pixelsize = planar ? 1 : pixdesc->nb_components;
1625 Jpeg2000T1Context t1;
1627 /* Loop on tile components */
1628 for (compno = 0; compno < s->ncomponents; compno++) {
1629 Jpeg2000Component *comp = tile->comp + compno;
1630 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1632 t1.stride = (1<<codsty->log2_cblk_width) + 2;
1634 /* Loop on resolution levels */
1635 for (reslevelno = 0; reslevelno < codsty->nreslevels2decode; reslevelno++) {
1636 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1638 for (bandno = 0; bandno < rlevel->nbands; bandno++) {
1639 int nb_precincts, precno;
1640 Jpeg2000Band *band = rlevel->band + bandno;
1641 int cblkno = 0, bandpos;
1643 bandpos = bandno + (reslevelno > 0);
1645 if (band->coord[0][0] == band->coord[0][1] ||
1646 band->coord[1][0] == band->coord[1][1])
1649 nb_precincts = rlevel->num_precincts_x * rlevel->num_precincts_y;
1650 /* Loop on precincts */
1651 for (precno = 0; precno < nb_precincts; precno++) {
1652 Jpeg2000Prec *prec = band->prec + precno;
1654 /* Loop on codeblocks */
1655 for (cblkno = 0; cblkno < prec->nb_codeblocks_width * prec->nb_codeblocks_height; cblkno++) {
1657 Jpeg2000Cblk *cblk = prec->cblk + cblkno;
1658 decode_cblk(s, codsty, &t1, cblk,
1659 cblk->coord[0][1] - cblk->coord[0][0],
1660 cblk->coord[1][1] - cblk->coord[1][0],
1663 x = cblk->coord[0][0] - band->coord[0][0];
1664 y = cblk->coord[1][0] - band->coord[1][0];
1666 if (codsty->transform == FF_DWT97)
1667 dequantization_float(x, y, cblk, comp, &t1, band);
1668 else if (codsty->transform == FF_DWT97_INT)
1669 dequantization_int_97(x, y, cblk, comp, &t1, band);
1671 dequantization_int(x, y, cblk, comp, &t1, band);
1675 } /* end reslevel */
1678 ff_dwt_decode(&comp->dwt, codsty->transform == FF_DWT97 ? (void*)comp->f_data : (void*)comp->i_data);
1681 /* inverse MCT transformation */
1682 if (tile->codsty[0].mct)
1683 mct_decode(s, tile);
1685 if (s->cdef[0] < 0) {
1686 for (x = 0; x < s->ncomponents; x++)
1688 if ((s->ncomponents & 1) == 0)
1689 s->cdef[s->ncomponents-1] = 0;
1692 if (s->precision <= 8) {
1693 for (compno = 0; compno < s->ncomponents; compno++) {
1694 Jpeg2000Component *comp = tile->comp + compno;
1695 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1696 float *datap = comp->f_data;
1697 int32_t *i_datap = comp->i_data;
1698 int cbps = s->cbps[compno];
1699 int w = tile->comp[compno].coord[0][1] - s->image_offset_x;
1703 plane = s->cdef[compno] ? s->cdef[compno]-1 : (s->ncomponents-1);
1706 y = tile->comp[compno].coord[1][0] - s->image_offset_y;
1707 line = picture->data[plane] + y / s->cdy[compno] * picture->linesize[plane];
1708 for (; y < tile->comp[compno].coord[1][1] - s->image_offset_y; y ++) {
1711 x = tile->comp[compno].coord[0][0] - s->image_offset_x;
1712 dst = line + x / s->cdx[compno] * pixelsize + compno*!planar;
1714 if (codsty->transform == FF_DWT97) {
1715 for (; x < w; x ++) {
1716 int val = lrintf(*datap) + (1 << (cbps - 1));
1717 /* DC level shift and clip see ISO 15444-1:2002 G.1.2 */
1718 val = av_clip(val, 0, (1 << cbps) - 1);
1719 *dst = val << (8 - cbps);
1724 for (; x < w; x ++) {
1725 int val = *i_datap + (1 << (cbps - 1));
1726 /* DC level shift and clip see ISO 15444-1:2002 G.1.2 */
1727 val = av_clip(val, 0, (1 << cbps) - 1);
1728 *dst = val << (8 - cbps);
1733 line += picture->linesize[plane];
1737 int precision = picture->format == AV_PIX_FMT_XYZ12 ||
1738 picture->format == AV_PIX_FMT_RGB48 ||
1739 picture->format == AV_PIX_FMT_RGBA64 ||
1740 picture->format == AV_PIX_FMT_GRAY16 ? 16 : s->precision;
1742 for (compno = 0; compno < s->ncomponents; compno++) {
1743 Jpeg2000Component *comp = tile->comp + compno;
1744 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1745 float *datap = comp->f_data;
1746 int32_t *i_datap = comp->i_data;
1748 int cbps = s->cbps[compno];
1749 int w = tile->comp[compno].coord[0][1] - s->image_offset_x;
1753 plane = s->cdef[compno] ? s->cdef[compno]-1 : (s->ncomponents-1);
1755 y = tile->comp[compno].coord[1][0] - s->image_offset_y;
1756 linel = (uint16_t *)picture->data[plane] + y / s->cdy[compno] * (picture->linesize[plane] >> 1);
1757 for (; y < tile->comp[compno].coord[1][1] - s->image_offset_y; y ++) {
1760 x = tile->comp[compno].coord[0][0] - s->image_offset_x;
1761 dst = linel + (x / s->cdx[compno] * pixelsize + compno*!planar);
1762 if (codsty->transform == FF_DWT97) {
1763 for (; x < w; x ++) {
1764 int val = lrintf(*datap) + (1 << (cbps - 1));
1765 /* DC level shift and clip see ISO 15444-1:2002 G.1.2 */
1766 val = av_clip(val, 0, (1 << cbps) - 1);
1767 /* align 12 bit values in little-endian mode */
1768 *dst = val << (precision - cbps);
1773 for (; x < w; x ++) {
1774 int val = *i_datap + (1 << (cbps - 1));
1775 /* DC level shift and clip see ISO 15444-1:2002 G.1.2 */
1776 val = av_clip(val, 0, (1 << cbps) - 1);
1777 /* align 12 bit values in little-endian mode */
1778 *dst = val << (precision - cbps);
1783 linel += picture->linesize[plane] >> 1;
1791 static void jpeg2000_dec_cleanup(Jpeg2000DecoderContext *s)
1794 for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++) {
1795 if (s->tile[tileno].comp) {
1796 for (compno = 0; compno < s->ncomponents; compno++) {
1797 Jpeg2000Component *comp = s->tile[tileno].comp + compno;
1798 Jpeg2000CodingStyle *codsty = s->tile[tileno].codsty + compno;
1800 ff_jpeg2000_cleanup(comp, codsty);
1802 av_freep(&s->tile[tileno].comp);
1806 memset(s->codsty, 0, sizeof(s->codsty));
1807 memset(s->qntsty, 0, sizeof(s->qntsty));
1808 memset(&s->poc , 0, sizeof(s->poc));
1809 s->numXtiles = s->numYtiles = 0;
1812 static int jpeg2000_read_main_headers(Jpeg2000DecoderContext *s)
1814 Jpeg2000CodingStyle *codsty = s->codsty;
1815 Jpeg2000QuantStyle *qntsty = s->qntsty;
1816 Jpeg2000POC *poc = &s->poc;
1817 uint8_t *properties = s->properties;
1824 if (bytestream2_get_bytes_left(&s->g) < 2) {
1825 av_log(s->avctx, AV_LOG_ERROR, "Missing EOC\n");
1829 marker = bytestream2_get_be16u(&s->g);
1830 oldpos = bytestream2_tell(&s->g);
1832 if (marker == JPEG2000_SOD) {
1834 Jpeg2000TilePart *tp;
1837 av_log(s->avctx, AV_LOG_ERROR, "Missing SIZ\n");
1838 return AVERROR_INVALIDDATA;
1840 if (s->curtileno < 0) {
1841 av_log(s->avctx, AV_LOG_ERROR, "Missing SOT\n");
1842 return AVERROR_INVALIDDATA;
1845 tile = s->tile + s->curtileno;
1846 tp = tile->tile_part + tile->tp_idx;
1847 if (tp->tp_end < s->g.buffer) {
1848 av_log(s->avctx, AV_LOG_ERROR, "Invalid tpend\n");
1849 return AVERROR_INVALIDDATA;
1851 bytestream2_init(&tp->tpg, s->g.buffer, tp->tp_end - s->g.buffer);
1852 bytestream2_skip(&s->g, tp->tp_end - s->g.buffer);
1856 if (marker == JPEG2000_EOC)
1859 len = bytestream2_get_be16(&s->g);
1860 if (len < 2 || bytestream2_get_bytes_left(&s->g) < len - 2) {
1861 av_log(s->avctx, AV_LOG_ERROR, "Invalid len %d left=%d\n", len, bytestream2_get_bytes_left(&s->g));
1862 return AVERROR_INVALIDDATA;
1869 s->numXtiles = s->numYtiles = 0;
1872 ret = get_coc(s, codsty, properties);
1875 ret = get_cod(s, codsty, properties);
1878 ret = get_qcc(s, len, qntsty, properties);
1881 ret = get_qcd(s, len, qntsty, properties);
1884 ret = get_poc(s, len, poc);
1887 if (!(ret = get_sot(s, len))) {
1888 av_assert1(s->curtileno >= 0);
1889 codsty = s->tile[s->curtileno].codsty;
1890 qntsty = s->tile[s->curtileno].qntsty;
1891 poc = &s->tile[s->curtileno].poc;
1892 properties = s->tile[s->curtileno].properties;
1896 // the comment is ignored
1897 bytestream2_skip(&s->g, len - 2);
1900 // Tile-part lengths
1901 ret = get_tlm(s, len);
1904 // Packet length, tile-part header
1905 ret = get_plt(s, len);
1908 av_log(s->avctx, AV_LOG_ERROR,
1909 "unsupported marker 0x%.4"PRIX16" at pos 0x%X\n",
1910 marker, bytestream2_tell(&s->g) - 4);
1911 bytestream2_skip(&s->g, len - 2);
1914 if (bytestream2_tell(&s->g) - oldpos != len || ret) {
1915 av_log(s->avctx, AV_LOG_ERROR,
1916 "error during processing marker segment %.4"PRIx16"\n",
1918 return ret ? ret : -1;
1924 /* Read bit stream packets --> T2 operation. */
1925 static int jpeg2000_read_bitstream_packets(Jpeg2000DecoderContext *s)
1930 for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++) {
1931 Jpeg2000Tile *tile = s->tile + tileno;
1933 if ((ret = init_tile(s, tileno)) < 0)
1936 s->g = tile->tile_part[0].tpg;
1937 if ((ret = jpeg2000_decode_packets(s, tile)) < 0)
1944 static int jp2_find_codestream(Jpeg2000DecoderContext *s)
1946 uint32_t atom_size, atom, atom_end;
1947 int search_range = 10;
1951 bytestream2_get_bytes_left(&s->g) >= 8) {
1952 atom_size = bytestream2_get_be32u(&s->g);
1953 atom = bytestream2_get_be32u(&s->g);
1954 atom_end = bytestream2_tell(&s->g) + atom_size - 8;
1956 if (atom == JP2_CODESTREAM)
1959 if (bytestream2_get_bytes_left(&s->g) < atom_size || atom_end < atom_size)
1962 if (atom == JP2_HEADER &&
1964 uint32_t atom2_size, atom2, atom2_end;
1966 atom2_size = bytestream2_get_be32u(&s->g);
1967 atom2 = bytestream2_get_be32u(&s->g);
1968 atom2_end = bytestream2_tell(&s->g) + atom2_size - 8;
1969 if (atom2_size < 8 || atom2_end > atom_end || atom2_end < atom2_size)
1971 if (atom2 == JP2_CODESTREAM) {
1973 } else if (atom2 == MKBETAG('c','o','l','r') && atom2_size >= 7) {
1974 int method = bytestream2_get_byteu(&s->g);
1975 bytestream2_skipu(&s->g, 2);
1977 s->colour_space = bytestream2_get_be32u(&s->g);
1979 } else if (atom2 == MKBETAG('p','c','l','r') && atom2_size >= 6) {
1980 int i, size, colour_count, colour_channels, colour_depth[3];
1982 colour_count = bytestream2_get_be16u(&s->g);
1983 colour_channels = bytestream2_get_byteu(&s->g);
1984 // FIXME: Do not ignore channel_sign
1985 colour_depth[0] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1;
1986 colour_depth[1] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1;
1987 colour_depth[2] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1;
1988 size = (colour_depth[0] + 7 >> 3) * colour_count +
1989 (colour_depth[1] + 7 >> 3) * colour_count +
1990 (colour_depth[2] + 7 >> 3) * colour_count;
1991 if (colour_count > 256 ||
1992 colour_channels != 3 ||
1993 colour_depth[0] > 16 ||
1994 colour_depth[1] > 16 ||
1995 colour_depth[2] > 16 ||
1996 atom2_size < size) {
1997 avpriv_request_sample(s->avctx, "Unknown palette");
1998 bytestream2_seek(&s->g, atom2_end, SEEK_SET);
2002 for (i = 0; i < colour_count; i++) {
2003 if (colour_depth[0] <= 8) {
2004 r = bytestream2_get_byteu(&s->g) << 8 - colour_depth[0];
2005 r |= r >> colour_depth[0];
2007 r = bytestream2_get_be16u(&s->g) >> colour_depth[0] - 8;
2009 if (colour_depth[1] <= 8) {
2010 g = bytestream2_get_byteu(&s->g) << 8 - colour_depth[1];
2011 r |= r >> colour_depth[1];
2013 g = bytestream2_get_be16u(&s->g) >> colour_depth[1] - 8;
2015 if (colour_depth[2] <= 8) {
2016 b = bytestream2_get_byteu(&s->g) << 8 - colour_depth[2];
2017 r |= r >> colour_depth[2];
2019 b = bytestream2_get_be16u(&s->g) >> colour_depth[2] - 8;
2021 s->palette[i] = 0xffu << 24 | r << 16 | g << 8 | b;
2023 } else if (atom2 == MKBETAG('c','d','e','f') && atom2_size >= 2) {
2024 int n = bytestream2_get_be16u(&s->g);
2026 int cn = bytestream2_get_be16(&s->g);
2027 int av_unused typ = bytestream2_get_be16(&s->g);
2028 int asoc = bytestream2_get_be16(&s->g);
2029 if (cn < 4 && asoc < 4)
2033 bytestream2_seek(&s->g, atom2_end, SEEK_SET);
2034 } while (atom_end - atom2_end >= 8);
2038 bytestream2_seek(&s->g, atom_end, SEEK_SET);
2044 static av_cold int jpeg2000_decode_init(AVCodecContext *avctx)
2046 Jpeg2000DecoderContext *s = avctx->priv_data;
2048 ff_jpeg2000dsp_init(&s->dsp);
2053 static int jpeg2000_decode_frame(AVCodecContext *avctx, void *data,
2054 int *got_frame, AVPacket *avpkt)
2056 Jpeg2000DecoderContext *s = avctx->priv_data;
2057 ThreadFrame frame = { .f = data };
2058 AVFrame *picture = data;
2062 bytestream2_init(&s->g, avpkt->data, avpkt->size);
2064 memset(s->cdef, -1, sizeof(s->cdef));
2066 if (bytestream2_get_bytes_left(&s->g) < 2) {
2067 ret = AVERROR_INVALIDDATA;
2071 // check if the image is in jp2 format
2072 if (bytestream2_get_bytes_left(&s->g) >= 12 &&
2073 (bytestream2_get_be32u(&s->g) == 12) &&
2074 (bytestream2_get_be32u(&s->g) == JP2_SIG_TYPE) &&
2075 (bytestream2_get_be32u(&s->g) == JP2_SIG_VALUE)) {
2076 if (!jp2_find_codestream(s)) {
2077 av_log(avctx, AV_LOG_ERROR,
2078 "Could not find Jpeg2000 codestream atom.\n");
2079 ret = AVERROR_INVALIDDATA;
2083 bytestream2_seek(&s->g, 0, SEEK_SET);
2086 while (bytestream2_get_bytes_left(&s->g) >= 3 && bytestream2_peek_be16(&s->g) != JPEG2000_SOC)
2087 bytestream2_skip(&s->g, 1);
2089 if (bytestream2_get_be16u(&s->g) != JPEG2000_SOC) {
2090 av_log(avctx, AV_LOG_ERROR, "SOC marker not present\n");
2091 ret = AVERROR_INVALIDDATA;
2094 if (ret = jpeg2000_read_main_headers(s))
2097 /* get picture buffer */
2098 if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
2100 picture->pict_type = AV_PICTURE_TYPE_I;
2101 picture->key_frame = 1;
2103 if (ret = jpeg2000_read_bitstream_packets(s))
2106 for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++)
2107 if (ret = jpeg2000_decode_tile(s, s->tile + tileno, picture))
2110 jpeg2000_dec_cleanup(s);
2114 if (s->avctx->pix_fmt == AV_PIX_FMT_PAL8)
2115 memcpy(picture->data[1], s->palette, 256 * sizeof(uint32_t));
2117 return bytestream2_tell(&s->g);
2120 jpeg2000_dec_cleanup(s);
2124 static av_cold void jpeg2000_init_static_data(AVCodec *codec)
2126 ff_jpeg2000_init_tier1_luts();
2127 ff_mqc_init_context_tables();
2130 #define OFFSET(x) offsetof(Jpeg2000DecoderContext, x)
2131 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
2133 static const AVOption options[] = {
2134 { "lowres", "Lower the decoding resolution by a power of two",
2135 OFFSET(reduction_factor), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, JPEG2000_MAX_RESLEVELS - 1, VD },
2139 static const AVProfile profiles[] = {
2140 { FF_PROFILE_JPEG2000_CSTREAM_RESTRICTION_0, "JPEG 2000 codestream restriction 0" },
2141 { FF_PROFILE_JPEG2000_CSTREAM_RESTRICTION_1, "JPEG 2000 codestream restriction 1" },
2142 { FF_PROFILE_JPEG2000_CSTREAM_NO_RESTRICTION, "JPEG 2000 no codestream restrictions" },
2143 { FF_PROFILE_JPEG2000_DCINEMA_2K, "JPEG 2000 digital cinema 2K" },
2144 { FF_PROFILE_JPEG2000_DCINEMA_4K, "JPEG 2000 digital cinema 4K" },
2145 { FF_PROFILE_UNKNOWN },
2148 static const AVClass jpeg2000_class = {
2149 .class_name = "jpeg2000",
2150 .item_name = av_default_item_name,
2152 .version = LIBAVUTIL_VERSION_INT,
2155 AVCodec ff_jpeg2000_decoder = {
2157 .long_name = NULL_IF_CONFIG_SMALL("JPEG 2000"),
2158 .type = AVMEDIA_TYPE_VIDEO,
2159 .id = AV_CODEC_ID_JPEG2000,
2160 .capabilities = CODEC_CAP_FRAME_THREADS,
2161 .priv_data_size = sizeof(Jpeg2000DecoderContext),
2162 .init_static_data = jpeg2000_init_static_data,
2163 .init = jpeg2000_decode_init,
2164 .decode = jpeg2000_decode_frame,
2165 .priv_class = &jpeg2000_class,
2167 .profiles = NULL_IF_CONFIG_SMALL(profiles)