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 >= bpc &&
205 (log2_chroma_wh >> 14 & 3) == 0 &&
206 (log2_chroma_wh >> 12 & 3) == 0;
208 match = match && desc->comp[2].depth >= 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 >= 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 >= 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);
1247 if (step_x >= 31 || step_y >= 31){
1248 avpriv_request_sample(s->avctx, "PCRL with large step");
1249 return AVERROR_PATCHWELCOME;
1254 for (y = tile->coord[1][0]; y < tile->coord[1][1]; y = (y/step_y + 1)*step_y) {
1255 for (x = tile->coord[0][0]; x < tile->coord[0][1]; x = (x/step_x + 1)*step_x) {
1256 for (compno = CSpoc; compno < CEpoc; compno++) {
1257 Jpeg2000Component *comp = tile->comp + compno;
1258 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1259 Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
1260 int xc = x / s->cdx[compno];
1261 int yc = y / s->cdy[compno];
1263 for (reslevelno = RSpoc; reslevelno < FFMIN(codsty->nreslevels, REpoc); reslevelno++) {
1264 unsigned prcx, prcy;
1265 uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1266 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1268 if (yc % (1 << (rlevel->log2_prec_height + reducedresno)) && y != tile->coord[1][0]) //FIXME this is a subset of the check
1271 if (xc % (1 << (rlevel->log2_prec_width + reducedresno)) && x != tile->coord[0][0]) //FIXME this is a subset of the check
1274 // check if a precinct exists
1275 prcx = ff_jpeg2000_ceildivpow2(xc, reducedresno) >> rlevel->log2_prec_width;
1276 prcy = ff_jpeg2000_ceildivpow2(yc, reducedresno) >> rlevel->log2_prec_height;
1277 prcx -= ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], reducedresno) >> rlevel->log2_prec_width;
1278 prcy -= ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], reducedresno) >> rlevel->log2_prec_height;
1280 precno = prcx + rlevel->num_precincts_x * prcy;
1282 if (prcx >= rlevel->num_precincts_x || prcy >= rlevel->num_precincts_y) {
1283 av_log(s->avctx, AV_LOG_WARNING, "prc %d %d outside limits %d %d\n",
1284 prcx, prcy, rlevel->num_precincts_x, rlevel->num_precincts_y);
1288 for (layno = 0; layno < LYEpoc; layno++) {
1289 if ((ret = jpeg2000_decode_packet(s, tile, tp_index, codsty, rlevel,
1291 qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1292 qntsty->nguardbits)) < 0)
1308 static int jpeg2000_decode_packets(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
1310 int ret = AVERROR_BUG;
1315 if (tile->poc.nb_poc) {
1316 for (i=0; i<tile->poc.nb_poc; i++) {
1317 Jpeg2000POCEntry *e = &tile->poc.poc[i];
1318 ret = jpeg2000_decode_packets_po_iteration(s, tile,
1320 FFMIN(e->LYEpoc, tile->codsty[0].nlayers),
1322 FFMIN(e->CEpoc, s->ncomponents),
1329 ret = jpeg2000_decode_packets_po_iteration(s, tile,
1331 tile->codsty[0].nlayers,
1334 tile->codsty[0].prog_order,
1338 /* EOC marker reached */
1339 bytestream2_skip(&s->g, 2);
1344 /* TIER-1 routines */
1345 static void decode_sigpass(Jpeg2000T1Context *t1, int width, int height,
1346 int bpno, int bandno,
1347 int vert_causal_ctx_csty_symbol)
1349 int mask = 3 << (bpno - 1), y0, x, y;
1351 for (y0 = 0; y0 < height; y0 += 4)
1352 for (x = 0; x < width; x++)
1353 for (y = y0; y < height && y < y0 + 4; y++) {
1354 int flags_mask = -1;
1355 if (vert_causal_ctx_csty_symbol && y == y0 + 3)
1356 flags_mask &= ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE | JPEG2000_T1_SGN_S);
1357 if ((t1->flags[(y+1) * t1->stride + x+1] & JPEG2000_T1_SIG_NB & flags_mask)
1358 && !(t1->flags[(y+1) * t1->stride + x+1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS))) {
1359 if (ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ff_jpeg2000_getsigctxno(t1->flags[(y+1) * t1->stride + x+1] & flags_mask, bandno))) {
1360 int xorbit, ctxno = ff_jpeg2000_getsgnctxno(t1->flags[(y+1) * t1->stride + x+1] & flags_mask, &xorbit);
1362 t1->data[(y) * t1->stride + x] = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ctxno) ? -mask : mask;
1364 t1->data[(y) * t1->stride + x] = (ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ctxno) ^ xorbit) ?
1367 ff_jpeg2000_set_significance(t1, x, y,
1368 t1->data[(y) * t1->stride + x] < 0);
1370 t1->flags[(y + 1) * t1->stride + x + 1] |= JPEG2000_T1_VIS;
1375 static void decode_refpass(Jpeg2000T1Context *t1, int width, int height,
1376 int bpno, int vert_causal_ctx_csty_symbol)
1381 phalf = 1 << (bpno - 1);
1384 for (y0 = 0; y0 < height; y0 += 4)
1385 for (x = 0; x < width; x++)
1386 for (y = y0; y < height && y < y0 + 4; y++)
1387 if ((t1->flags[(y + 1) * t1->stride + x + 1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS)) == JPEG2000_T1_SIG) {
1388 int flags_mask = (vert_causal_ctx_csty_symbol && y == y0 + 3) ?
1389 ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE | JPEG2000_T1_SGN_S) : -1;
1390 int ctxno = ff_jpeg2000_getrefctxno(t1->flags[(y + 1) * t1->stride + x + 1] & flags_mask);
1391 int r = ff_mqc_decode(&t1->mqc,
1392 t1->mqc.cx_states + ctxno)
1394 t1->data[(y) * t1->stride + x] += t1->data[(y) * t1->stride + x] < 0 ? -r : r;
1395 t1->flags[(y + 1) * t1->stride + x + 1] |= JPEG2000_T1_REF;
1399 static void decode_clnpass(Jpeg2000DecoderContext *s, Jpeg2000T1Context *t1,
1400 int width, int height, int bpno, int bandno,
1401 int seg_symbols, int vert_causal_ctx_csty_symbol)
1403 int mask = 3 << (bpno - 1), y0, x, y, runlen, dec;
1405 for (y0 = 0; y0 < height; y0 += 4) {
1406 for (x = 0; x < width; x++) {
1407 int flags_mask = -1;
1408 if (vert_causal_ctx_csty_symbol)
1409 flags_mask &= ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE | JPEG2000_T1_SGN_S);
1410 if (y0 + 3 < height &&
1411 !((t1->flags[(y0 + 1) * t1->stride + x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
1412 (t1->flags[(y0 + 2) * t1->stride + x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
1413 (t1->flags[(y0 + 3) * t1->stride + x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
1414 (t1->flags[(y0 + 4) * t1->stride + x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG) & flags_mask))) {
1415 if (!ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_RL))
1417 runlen = ff_mqc_decode(&t1->mqc,
1418 t1->mqc.cx_states + MQC_CX_UNI);
1419 runlen = (runlen << 1) | ff_mqc_decode(&t1->mqc,
1428 for (y = y0 + runlen; y < y0 + 4 && y < height; y++) {
1429 int flags_mask = -1;
1430 if (vert_causal_ctx_csty_symbol && y == y0 + 3)
1431 flags_mask &= ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE | JPEG2000_T1_SGN_S);
1433 if (!(t1->flags[(y+1) * t1->stride + x+1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS))) {
1434 dec = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ff_jpeg2000_getsigctxno(t1->flags[(y+1) * t1->stride + x+1] & flags_mask,
1440 int ctxno = ff_jpeg2000_getsgnctxno(t1->flags[(y + 1) * t1->stride + x + 1] & flags_mask,
1442 t1->data[(y) * t1->stride + x] = (ff_mqc_decode(&t1->mqc,
1443 t1->mqc.cx_states + ctxno) ^
1446 ff_jpeg2000_set_significance(t1, x, y, t1->data[(y) * t1->stride + x] < 0);
1449 t1->flags[(y + 1) * t1->stride + x + 1] &= ~JPEG2000_T1_VIS;
1455 val = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1456 val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1457 val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1458 val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1460 av_log(s->avctx, AV_LOG_ERROR,
1461 "Segmentation symbol value incorrect\n");
1465 static int decode_cblk(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *codsty,
1466 Jpeg2000T1Context *t1, Jpeg2000Cblk *cblk,
1467 int width, int height, int bandpos)
1469 int passno = cblk->npasses, pass_t = 2, bpno = cblk->nonzerobits - 1;
1471 int vert_causal_ctx_csty_symbol = codsty->cblk_style & JPEG2000_CBLK_VSC;
1475 av_assert0(width <= 1024U && height <= 1024U);
1476 av_assert0(width*height <= 4096);
1478 memset(t1->data, 0, t1->stride * height * sizeof(*t1->data));
1480 /* If code-block contains no compressed data: nothing to do. */
1484 memset(t1->flags, 0, t1->stride * (height + 2) * sizeof(*t1->flags));
1486 cblk->data[cblk->length] = 0xff;
1487 cblk->data[cblk->length+1] = 0xff;
1488 ff_mqc_initdec(&t1->mqc, cblk->data, 0, 1);
1493 decode_sigpass(t1, width, height, bpno + 1, bandpos,
1494 vert_causal_ctx_csty_symbol);
1497 decode_refpass(t1, width, height, bpno + 1, vert_causal_ctx_csty_symbol);
1500 av_assert2(!t1->mqc.raw);
1501 decode_clnpass(s, t1, width, height, bpno + 1, bandpos,
1502 codsty->cblk_style & JPEG2000_CBLK_SEGSYM,
1503 vert_causal_ctx_csty_symbol);
1506 if (codsty->cblk_style & JPEG2000_CBLK_RESET) // XXX no testcase for just this
1507 ff_mqc_init_contexts(&t1->mqc);
1509 if (passno && (coder_type = needs_termination(codsty->cblk_style, pass_cnt))) {
1510 if (term_cnt >= cblk->nb_terminations) {
1511 av_log(s->avctx, AV_LOG_ERROR, "Missing needed termination \n");
1512 return AVERROR_INVALIDDATA;
1514 if (FFABS(cblk->data + cblk->data_start[term_cnt + 1] - 2 - t1->mqc.bp) > 0) {
1515 av_log(s->avctx, AV_LOG_WARNING, "Mid mismatch %"PTRDIFF_SPECIFIER" in pass %d of %d\n",
1516 cblk->data + cblk->data_start[term_cnt + 1] - 2 - t1->mqc.bp,
1517 pass_cnt, cblk->npasses);
1520 ff_mqc_initdec(&t1->mqc, cblk->data + cblk->data_start[++term_cnt], coder_type == 2, 0);
1531 if (cblk->data + cblk->length - 2*(term_cnt < cblk->nb_terminations) != t1->mqc.bp) {
1532 av_log(s->avctx, AV_LOG_WARNING, "End mismatch %"PTRDIFF_SPECIFIER"\n",
1533 cblk->data + cblk->length - 2*(term_cnt < cblk->nb_terminations) - t1->mqc.bp);
1539 /* TODO: Verify dequantization for lossless case
1540 * comp->data can be float or int
1541 * band->stepsize can be float or int
1542 * depending on the type of DWT transformation.
1543 * see ISO/IEC 15444-1:2002 A.6.1 */
1545 /* Float dequantization of a codeblock.*/
1546 static void dequantization_float(int x, int y, Jpeg2000Cblk *cblk,
1547 Jpeg2000Component *comp,
1548 Jpeg2000T1Context *t1, Jpeg2000Band *band)
1551 int w = cblk->coord[0][1] - cblk->coord[0][0];
1552 for (j = 0; j < (cblk->coord[1][1] - cblk->coord[1][0]); ++j) {
1553 float *datap = &comp->f_data[(comp->coord[0][1] - comp->coord[0][0]) * (y + j) + x];
1554 int *src = t1->data + j*t1->stride;
1555 for (i = 0; i < w; ++i)
1556 datap[i] = src[i] * band->f_stepsize;
1560 /* Integer dequantization of a codeblock.*/
1561 static void dequantization_int(int x, int y, Jpeg2000Cblk *cblk,
1562 Jpeg2000Component *comp,
1563 Jpeg2000T1Context *t1, Jpeg2000Band *band)
1566 int w = cblk->coord[0][1] - cblk->coord[0][0];
1567 for (j = 0; j < (cblk->coord[1][1] - cblk->coord[1][0]); ++j) {
1568 int32_t *datap = &comp->i_data[(comp->coord[0][1] - comp->coord[0][0]) * (y + j) + x];
1569 int *src = t1->data + j*t1->stride;
1570 if (band->i_stepsize == 32768) {
1571 for (i = 0; i < w; ++i)
1572 datap[i] = src[i] / 2;
1574 // This should be VERY uncommon
1575 for (i = 0; i < w; ++i)
1576 datap[i] = (src[i] * (int64_t)band->i_stepsize) / 65536;
1581 static void dequantization_int_97(int x, int y, Jpeg2000Cblk *cblk,
1582 Jpeg2000Component *comp,
1583 Jpeg2000T1Context *t1, Jpeg2000Band *band)
1586 int w = cblk->coord[0][1] - cblk->coord[0][0];
1587 for (j = 0; j < (cblk->coord[1][1] - cblk->coord[1][0]); ++j) {
1588 int32_t *datap = &comp->i_data[(comp->coord[0][1] - comp->coord[0][0]) * (y + j) + x];
1589 int *src = t1->data + j*t1->stride;
1590 for (i = 0; i < w; ++i)
1591 datap[i] = (src[i] * (int64_t)band->i_stepsize + (1<<15)) >> 16;
1595 static inline void mct_decode(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
1600 for (i = 1; i < 3; i++) {
1601 if (tile->codsty[0].transform != tile->codsty[i].transform) {
1602 av_log(s->avctx, AV_LOG_ERROR, "Transforms mismatch, MCT not supported\n");
1605 if (memcmp(tile->comp[0].coord, tile->comp[i].coord, sizeof(tile->comp[0].coord))) {
1606 av_log(s->avctx, AV_LOG_ERROR, "Coords mismatch, MCT not supported\n");
1611 for (i = 0; i < 3; i++)
1612 if (tile->codsty[0].transform == FF_DWT97)
1613 src[i] = tile->comp[i].f_data;
1615 src[i] = tile->comp[i].i_data;
1617 for (i = 0; i < 2; i++)
1618 csize *= tile->comp[0].coord[i][1] - tile->comp[0].coord[i][0];
1620 s->dsp.mct_decode[tile->codsty[0].transform](src[0], src[1], src[2], csize);
1623 static inline void tile_codeblocks(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
1625 Jpeg2000T1Context t1;
1627 int compno, reslevelno, bandno;
1629 /* Loop on tile components */
1630 for (compno = 0; compno < s->ncomponents; compno++) {
1631 Jpeg2000Component *comp = tile->comp + compno;
1632 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1634 t1.stride = (1<<codsty->log2_cblk_width) + 2;
1636 /* Loop on resolution levels */
1637 for (reslevelno = 0; reslevelno < codsty->nreslevels2decode; reslevelno++) {
1638 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1640 for (bandno = 0; bandno < rlevel->nbands; bandno++) {
1641 int nb_precincts, precno;
1642 Jpeg2000Band *band = rlevel->band + bandno;
1643 int cblkno = 0, bandpos;
1645 bandpos = bandno + (reslevelno > 0);
1647 if (band->coord[0][0] == band->coord[0][1] ||
1648 band->coord[1][0] == band->coord[1][1])
1651 nb_precincts = rlevel->num_precincts_x * rlevel->num_precincts_y;
1652 /* Loop on precincts */
1653 for (precno = 0; precno < nb_precincts; precno++) {
1654 Jpeg2000Prec *prec = band->prec + precno;
1656 /* Loop on codeblocks */
1658 cblkno < prec->nb_codeblocks_width * prec->nb_codeblocks_height;
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);
1686 #define WRITE_FRAME(D, PIXEL) \
1687 static inline void write_frame_ ## D(Jpeg2000DecoderContext * s, Jpeg2000Tile * tile, \
1688 AVFrame * picture, int precision) \
1690 const AVPixFmtDescriptor *pixdesc = av_pix_fmt_desc_get(s->avctx->pix_fmt); \
1691 int planar = !!(pixdesc->flags & AV_PIX_FMT_FLAG_PLANAR); \
1692 int pixelsize = planar ? 1 : pixdesc->nb_components; \
1697 for (compno = 0; compno < s->ncomponents; compno++) { \
1698 Jpeg2000Component *comp = tile->comp + compno; \
1699 Jpeg2000CodingStyle *codsty = tile->codsty + compno; \
1701 float *datap = comp->f_data; \
1702 int32_t *i_datap = comp->i_data; \
1703 int cbps = s->cbps[compno]; \
1704 int w = tile->comp[compno].coord[0][1] - s->image_offset_x; \
1708 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 = (PIXEL *)picture->data[plane] + y * (picture->linesize[plane] / sizeof(PIXEL));\
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 << (precision - 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 << (precision - cbps); \
1737 line += picture->linesize[plane] / sizeof(PIXEL); \
1743 WRITE_FRAME(8, uint8_t)
1744 WRITE_FRAME(16, uint16_t)
1748 static int jpeg2000_decode_tile(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile,
1753 tile_codeblocks(s, tile);
1755 /* inverse MCT transformation */
1756 if (tile->codsty[0].mct)
1757 mct_decode(s, tile);
1759 if (s->cdef[0] < 0) {
1760 for (x = 0; x < s->ncomponents; x++)
1762 if ((s->ncomponents & 1) == 0)
1763 s->cdef[s->ncomponents-1] = 0;
1766 if (s->precision <= 8) {
1767 write_frame_8(s, tile, picture, 8);
1769 int precision = picture->format == AV_PIX_FMT_XYZ12 ||
1770 picture->format == AV_PIX_FMT_RGB48 ||
1771 picture->format == AV_PIX_FMT_RGBA64 ||
1772 picture->format == AV_PIX_FMT_GRAY16 ? 16 : s->precision;
1774 write_frame_16(s, tile, picture, precision);
1780 static void jpeg2000_dec_cleanup(Jpeg2000DecoderContext *s)
1783 for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++) {
1784 if (s->tile[tileno].comp) {
1785 for (compno = 0; compno < s->ncomponents; compno++) {
1786 Jpeg2000Component *comp = s->tile[tileno].comp + compno;
1787 Jpeg2000CodingStyle *codsty = s->tile[tileno].codsty + compno;
1789 ff_jpeg2000_cleanup(comp, codsty);
1791 av_freep(&s->tile[tileno].comp);
1795 memset(s->codsty, 0, sizeof(s->codsty));
1796 memset(s->qntsty, 0, sizeof(s->qntsty));
1797 memset(s->properties, 0, sizeof(s->properties));
1798 memset(&s->poc , 0, sizeof(s->poc));
1799 s->numXtiles = s->numYtiles = 0;
1802 static int jpeg2000_read_main_headers(Jpeg2000DecoderContext *s)
1804 Jpeg2000CodingStyle *codsty = s->codsty;
1805 Jpeg2000QuantStyle *qntsty = s->qntsty;
1806 Jpeg2000POC *poc = &s->poc;
1807 uint8_t *properties = s->properties;
1814 if (bytestream2_get_bytes_left(&s->g) < 2) {
1815 av_log(s->avctx, AV_LOG_ERROR, "Missing EOC\n");
1819 marker = bytestream2_get_be16u(&s->g);
1820 oldpos = bytestream2_tell(&s->g);
1822 if (marker == JPEG2000_SOD) {
1824 Jpeg2000TilePart *tp;
1827 av_log(s->avctx, AV_LOG_ERROR, "Missing SIZ\n");
1828 return AVERROR_INVALIDDATA;
1830 if (s->curtileno < 0) {
1831 av_log(s->avctx, AV_LOG_ERROR, "Missing SOT\n");
1832 return AVERROR_INVALIDDATA;
1835 tile = s->tile + s->curtileno;
1836 tp = tile->tile_part + tile->tp_idx;
1837 if (tp->tp_end < s->g.buffer) {
1838 av_log(s->avctx, AV_LOG_ERROR, "Invalid tpend\n");
1839 return AVERROR_INVALIDDATA;
1841 bytestream2_init(&tp->tpg, s->g.buffer, tp->tp_end - s->g.buffer);
1842 bytestream2_skip(&s->g, tp->tp_end - s->g.buffer);
1846 if (marker == JPEG2000_EOC)
1849 len = bytestream2_get_be16(&s->g);
1850 if (len < 2 || bytestream2_get_bytes_left(&s->g) < len - 2) {
1851 av_log(s->avctx, AV_LOG_ERROR, "Invalid len %d left=%d\n", len, bytestream2_get_bytes_left(&s->g));
1852 return AVERROR_INVALIDDATA;
1859 s->numXtiles = s->numYtiles = 0;
1862 ret = get_coc(s, codsty, properties);
1865 ret = get_cod(s, codsty, properties);
1868 ret = get_qcc(s, len, qntsty, properties);
1871 ret = get_qcd(s, len, qntsty, properties);
1874 ret = get_poc(s, len, poc);
1877 if (!(ret = get_sot(s, len))) {
1878 av_assert1(s->curtileno >= 0);
1879 codsty = s->tile[s->curtileno].codsty;
1880 qntsty = s->tile[s->curtileno].qntsty;
1881 poc = &s->tile[s->curtileno].poc;
1882 properties = s->tile[s->curtileno].properties;
1886 // the PLM marker is ignored
1888 // the comment is ignored
1889 bytestream2_skip(&s->g, len - 2);
1892 // Tile-part lengths
1893 ret = get_tlm(s, len);
1896 // Packet length, tile-part header
1897 ret = get_plt(s, len);
1900 av_log(s->avctx, AV_LOG_ERROR,
1901 "unsupported marker 0x%.4"PRIX16" at pos 0x%X\n",
1902 marker, bytestream2_tell(&s->g) - 4);
1903 bytestream2_skip(&s->g, len - 2);
1906 if (bytestream2_tell(&s->g) - oldpos != len || ret) {
1907 av_log(s->avctx, AV_LOG_ERROR,
1908 "error during processing marker segment %.4"PRIx16"\n",
1910 return ret ? ret : -1;
1916 /* Read bit stream packets --> T2 operation. */
1917 static int jpeg2000_read_bitstream_packets(Jpeg2000DecoderContext *s)
1922 for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++) {
1923 Jpeg2000Tile *tile = s->tile + tileno;
1925 if ((ret = init_tile(s, tileno)) < 0)
1928 s->g = tile->tile_part[0].tpg;
1929 if ((ret = jpeg2000_decode_packets(s, tile)) < 0)
1936 static int jp2_find_codestream(Jpeg2000DecoderContext *s)
1938 uint32_t atom_size, atom, atom_end;
1939 int search_range = 10;
1943 bytestream2_get_bytes_left(&s->g) >= 8) {
1944 atom_size = bytestream2_get_be32u(&s->g);
1945 atom = bytestream2_get_be32u(&s->g);
1946 atom_end = bytestream2_tell(&s->g) + atom_size - 8;
1948 if (atom == JP2_CODESTREAM)
1951 if (bytestream2_get_bytes_left(&s->g) < atom_size || atom_end < atom_size)
1954 if (atom == JP2_HEADER &&
1956 uint32_t atom2_size, atom2, atom2_end;
1958 atom2_size = bytestream2_get_be32u(&s->g);
1959 atom2 = bytestream2_get_be32u(&s->g);
1960 atom2_end = bytestream2_tell(&s->g) + atom2_size - 8;
1961 if (atom2_size < 8 || atom2_end > atom_end || atom2_end < atom2_size)
1963 if (atom2 == JP2_CODESTREAM) {
1965 } else if (atom2 == MKBETAG('c','o','l','r') && atom2_size >= 7) {
1966 int method = bytestream2_get_byteu(&s->g);
1967 bytestream2_skipu(&s->g, 2);
1969 s->colour_space = bytestream2_get_be32u(&s->g);
1971 } else if (atom2 == MKBETAG('p','c','l','r') && atom2_size >= 6) {
1972 int i, size, colour_count, colour_channels, colour_depth[3];
1974 colour_count = bytestream2_get_be16u(&s->g);
1975 colour_channels = bytestream2_get_byteu(&s->g);
1976 // FIXME: Do not ignore channel_sign
1977 colour_depth[0] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1;
1978 colour_depth[1] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1;
1979 colour_depth[2] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1;
1980 size = (colour_depth[0] + 7 >> 3) * colour_count +
1981 (colour_depth[1] + 7 >> 3) * colour_count +
1982 (colour_depth[2] + 7 >> 3) * colour_count;
1983 if (colour_count > 256 ||
1984 colour_channels != 3 ||
1985 colour_depth[0] > 16 ||
1986 colour_depth[1] > 16 ||
1987 colour_depth[2] > 16 ||
1988 atom2_size < size) {
1989 avpriv_request_sample(s->avctx, "Unknown palette");
1990 bytestream2_seek(&s->g, atom2_end, SEEK_SET);
1994 for (i = 0; i < colour_count; i++) {
1995 if (colour_depth[0] <= 8) {
1996 r = bytestream2_get_byteu(&s->g) << 8 - colour_depth[0];
1997 r |= r >> colour_depth[0];
1999 r = bytestream2_get_be16u(&s->g) >> colour_depth[0] - 8;
2001 if (colour_depth[1] <= 8) {
2002 g = bytestream2_get_byteu(&s->g) << 8 - colour_depth[1];
2003 r |= r >> colour_depth[1];
2005 g = bytestream2_get_be16u(&s->g) >> colour_depth[1] - 8;
2007 if (colour_depth[2] <= 8) {
2008 b = bytestream2_get_byteu(&s->g) << 8 - colour_depth[2];
2009 r |= r >> colour_depth[2];
2011 b = bytestream2_get_be16u(&s->g) >> colour_depth[2] - 8;
2013 s->palette[i] = 0xffu << 24 | r << 16 | g << 8 | b;
2015 } else if (atom2 == MKBETAG('c','d','e','f') && atom2_size >= 2) {
2016 int n = bytestream2_get_be16u(&s->g);
2018 int cn = bytestream2_get_be16(&s->g);
2019 int av_unused typ = bytestream2_get_be16(&s->g);
2020 int asoc = bytestream2_get_be16(&s->g);
2021 if (cn < 4 && asoc < 4)
2025 bytestream2_seek(&s->g, atom2_end, SEEK_SET);
2026 } while (atom_end - atom2_end >= 8);
2030 bytestream2_seek(&s->g, atom_end, SEEK_SET);
2036 static av_cold int jpeg2000_decode_init(AVCodecContext *avctx)
2038 Jpeg2000DecoderContext *s = avctx->priv_data;
2040 ff_jpeg2000dsp_init(&s->dsp);
2045 static int jpeg2000_decode_frame(AVCodecContext *avctx, void *data,
2046 int *got_frame, AVPacket *avpkt)
2048 Jpeg2000DecoderContext *s = avctx->priv_data;
2049 ThreadFrame frame = { .f = data };
2050 AVFrame *picture = data;
2054 bytestream2_init(&s->g, avpkt->data, avpkt->size);
2056 memset(s->cdef, -1, sizeof(s->cdef));
2058 if (bytestream2_get_bytes_left(&s->g) < 2) {
2059 ret = AVERROR_INVALIDDATA;
2063 // check if the image is in jp2 format
2064 if (bytestream2_get_bytes_left(&s->g) >= 12 &&
2065 (bytestream2_get_be32u(&s->g) == 12) &&
2066 (bytestream2_get_be32u(&s->g) == JP2_SIG_TYPE) &&
2067 (bytestream2_get_be32u(&s->g) == JP2_SIG_VALUE)) {
2068 if (!jp2_find_codestream(s)) {
2069 av_log(avctx, AV_LOG_ERROR,
2070 "Could not find Jpeg2000 codestream atom.\n");
2071 ret = AVERROR_INVALIDDATA;
2075 bytestream2_seek(&s->g, 0, SEEK_SET);
2078 while (bytestream2_get_bytes_left(&s->g) >= 3 && bytestream2_peek_be16(&s->g) != JPEG2000_SOC)
2079 bytestream2_skip(&s->g, 1);
2081 if (bytestream2_get_be16u(&s->g) != JPEG2000_SOC) {
2082 av_log(avctx, AV_LOG_ERROR, "SOC marker not present\n");
2083 ret = AVERROR_INVALIDDATA;
2086 if (ret = jpeg2000_read_main_headers(s))
2089 /* get picture buffer */
2090 if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
2092 picture->pict_type = AV_PICTURE_TYPE_I;
2093 picture->key_frame = 1;
2095 if (ret = jpeg2000_read_bitstream_packets(s))
2098 for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++)
2099 if (ret = jpeg2000_decode_tile(s, s->tile + tileno, picture))
2102 jpeg2000_dec_cleanup(s);
2106 if (s->avctx->pix_fmt == AV_PIX_FMT_PAL8)
2107 memcpy(picture->data[1], s->palette, 256 * sizeof(uint32_t));
2109 return bytestream2_tell(&s->g);
2112 jpeg2000_dec_cleanup(s);
2116 static av_cold void jpeg2000_init_static_data(AVCodec *codec)
2118 ff_jpeg2000_init_tier1_luts();
2119 ff_mqc_init_context_tables();
2122 #define OFFSET(x) offsetof(Jpeg2000DecoderContext, x)
2123 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
2125 static const AVOption options[] = {
2126 { "lowres", "Lower the decoding resolution by a power of two",
2127 OFFSET(reduction_factor), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, JPEG2000_MAX_RESLEVELS - 1, VD },
2131 static const AVProfile profiles[] = {
2132 { FF_PROFILE_JPEG2000_CSTREAM_RESTRICTION_0, "JPEG 2000 codestream restriction 0" },
2133 { FF_PROFILE_JPEG2000_CSTREAM_RESTRICTION_1, "JPEG 2000 codestream restriction 1" },
2134 { FF_PROFILE_JPEG2000_CSTREAM_NO_RESTRICTION, "JPEG 2000 no codestream restrictions" },
2135 { FF_PROFILE_JPEG2000_DCINEMA_2K, "JPEG 2000 digital cinema 2K" },
2136 { FF_PROFILE_JPEG2000_DCINEMA_4K, "JPEG 2000 digital cinema 4K" },
2137 { FF_PROFILE_UNKNOWN },
2140 static const AVClass jpeg2000_class = {
2141 .class_name = "jpeg2000",
2142 .item_name = av_default_item_name,
2144 .version = LIBAVUTIL_VERSION_INT,
2147 AVCodec ff_jpeg2000_decoder = {
2149 .long_name = NULL_IF_CONFIG_SMALL("JPEG 2000"),
2150 .type = AVMEDIA_TYPE_VIDEO,
2151 .id = AV_CODEC_ID_JPEG2000,
2152 .capabilities = AV_CODEC_CAP_FRAME_THREADS | AV_CODEC_CAP_DR1,
2153 .priv_data_size = sizeof(Jpeg2000DecoderContext),
2154 .init_static_data = jpeg2000_init_static_data,
2155 .init = jpeg2000_decode_init,
2156 .decode = jpeg2000_decode_frame,
2157 .priv_class = &jpeg2000_class,
2159 .profiles = NULL_IF_CONFIG_SMALL(profiles)