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/imgutils.h"
34 #include "libavutil/opt.h"
35 #include "libavutil/pixdesc.h"
37 #include "bytestream.h"
41 #include "jpeg2000dsp.h"
44 #define JP2_SIG_TYPE 0x6A502020
45 #define JP2_SIG_VALUE 0x0D0A870A
46 #define JP2_CODESTREAM 0x6A703263
47 #define JP2_HEADER 0x6A703268
54 typedef struct Jpeg2000POCEntry {
63 typedef struct Jpeg2000POC {
64 Jpeg2000POCEntry poc[MAX_POCS];
69 typedef struct Jpeg2000TilePart {
70 uint8_t tile_index; // Tile index who refers the tile-part
71 const uint8_t *tp_end;
72 GetByteContext tpg; // bit stream in tile-part
75 /* RMK: For JPEG2000 DCINEMA 3 tile-parts in a tile
76 * one per component, so tile_part elements have a size of 3 */
77 typedef struct Jpeg2000Tile {
78 Jpeg2000Component *comp;
79 uint8_t properties[4];
80 Jpeg2000CodingStyle codsty[4];
81 Jpeg2000QuantStyle qntsty[4];
83 Jpeg2000TilePart tile_part[256];
84 uint16_t tp_idx; // Tile-part index
85 int coord[2][2]; // border coordinates {{x0, x1}, {y0, y1}}
88 typedef struct Jpeg2000DecoderContext {
90 AVCodecContext *avctx;
94 int image_offset_x, image_offset_y;
95 int tile_offset_x, tile_offset_y;
96 uint8_t cbps[4]; // bits per sample in particular components
97 uint8_t sgnd[4]; // if a component is signed
98 uint8_t properties[4];
103 uint32_t palette[256];
106 int tile_width, tile_height;
107 unsigned numXtiles, numYtiles;
110 Jpeg2000CodingStyle codsty[4];
111 Jpeg2000QuantStyle qntsty[4];
119 Jpeg2000DSPContext dsp;
121 /*options parameters*/
122 int reduction_factor;
123 } Jpeg2000DecoderContext;
125 /* get_bits functions for JPEG2000 packet bitstream
126 * It is a get_bit function with a bit-stuffing routine. If the value of the
127 * byte is 0xFF, the next byte includes an extra zero bit stuffed into the MSB.
128 * cf. ISO-15444-1:2002 / B.10.1 Bit-stuffing routine */
129 static int get_bits(Jpeg2000DecoderContext *s, int n)
135 if (s->bit_index == 0) {
136 s->bit_index = 7 + (bytestream2_get_byte(&s->g) != 0xFFu);
139 res |= (bytestream2_peek_byte(&s->g) >> s->bit_index) & 1;
144 static void jpeg2000_flush(Jpeg2000DecoderContext *s)
146 if (bytestream2_get_byte(&s->g) == 0xff)
147 bytestream2_skip(&s->g, 1);
151 /* decode the value stored in node */
152 static int tag_tree_decode(Jpeg2000DecoderContext *s, Jpeg2000TgtNode *node,
155 Jpeg2000TgtNode *stack[30];
156 int sp = -1, curval = 0;
159 av_log(s->avctx, AV_LOG_ERROR, "missing node\n");
160 return AVERROR_INVALIDDATA;
163 while (node && !node->vis) {
171 curval = stack[sp]->val;
173 while (curval < threshold && sp >= 0) {
174 if (curval < stack[sp]->val)
175 curval = stack[sp]->val;
176 while (curval < threshold) {
178 if ((ret = get_bits(s, 1)) > 0) {
186 stack[sp]->val = curval;
192 static int pix_fmt_match(enum AVPixelFormat pix_fmt, int components,
193 int bpc, uint32_t log2_chroma_wh, int pal8)
196 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
200 if (desc->nb_components != components) {
204 switch (components) {
206 match = match && desc->comp[3].depth >= bpc &&
207 (log2_chroma_wh >> 14 & 3) == 0 &&
208 (log2_chroma_wh >> 12 & 3) == 0;
210 match = match && desc->comp[2].depth >= bpc &&
211 (log2_chroma_wh >> 10 & 3) == desc->log2_chroma_w &&
212 (log2_chroma_wh >> 8 & 3) == desc->log2_chroma_h;
214 match = match && desc->comp[1].depth >= bpc &&
215 (log2_chroma_wh >> 6 & 3) == desc->log2_chroma_w &&
216 (log2_chroma_wh >> 4 & 3) == desc->log2_chroma_h;
219 match = match && desc->comp[0].depth >= bpc &&
220 (log2_chroma_wh >> 2 & 3) == 0 &&
221 (log2_chroma_wh & 3) == 0 &&
222 (desc->flags & AV_PIX_FMT_FLAG_PAL) == pal8 * AV_PIX_FMT_FLAG_PAL;
227 // pix_fmts with lower bpp have to be listed before
228 // similar pix_fmts with higher bpp.
229 #define RGB_PIXEL_FORMATS AV_PIX_FMT_PAL8,AV_PIX_FMT_RGB24,AV_PIX_FMT_RGBA,AV_PIX_FMT_RGB48,AV_PIX_FMT_RGBA64
230 #define GRAY_PIXEL_FORMATS AV_PIX_FMT_GRAY8,AV_PIX_FMT_GRAY8A,AV_PIX_FMT_GRAY16,AV_PIX_FMT_YA16
231 #define YUV_PIXEL_FORMATS AV_PIX_FMT_YUV410P,AV_PIX_FMT_YUV411P,AV_PIX_FMT_YUVA420P, \
232 AV_PIX_FMT_YUV420P,AV_PIX_FMT_YUV422P,AV_PIX_FMT_YUVA422P, \
233 AV_PIX_FMT_YUV440P,AV_PIX_FMT_YUV444P,AV_PIX_FMT_YUVA444P, \
234 AV_PIX_FMT_YUV420P9,AV_PIX_FMT_YUV422P9,AV_PIX_FMT_YUV444P9, \
235 AV_PIX_FMT_YUVA420P9,AV_PIX_FMT_YUVA422P9,AV_PIX_FMT_YUVA444P9, \
236 AV_PIX_FMT_YUV420P10,AV_PIX_FMT_YUV422P10,AV_PIX_FMT_YUV444P10, \
237 AV_PIX_FMT_YUVA420P10,AV_PIX_FMT_YUVA422P10,AV_PIX_FMT_YUVA444P10, \
238 AV_PIX_FMT_YUV420P12,AV_PIX_FMT_YUV422P12,AV_PIX_FMT_YUV444P12, \
239 AV_PIX_FMT_YUV420P14,AV_PIX_FMT_YUV422P14,AV_PIX_FMT_YUV444P14, \
240 AV_PIX_FMT_YUV420P16,AV_PIX_FMT_YUV422P16,AV_PIX_FMT_YUV444P16, \
241 AV_PIX_FMT_YUVA420P16,AV_PIX_FMT_YUVA422P16,AV_PIX_FMT_YUVA444P16
242 #define XYZ_PIXEL_FORMATS AV_PIX_FMT_XYZ12
244 static const enum AVPixelFormat rgb_pix_fmts[] = {RGB_PIXEL_FORMATS};
245 static const enum AVPixelFormat gray_pix_fmts[] = {GRAY_PIXEL_FORMATS};
246 static const enum AVPixelFormat yuv_pix_fmts[] = {YUV_PIXEL_FORMATS};
247 static const enum AVPixelFormat xyz_pix_fmts[] = {XYZ_PIXEL_FORMATS,
249 static const enum AVPixelFormat all_pix_fmts[] = {RGB_PIXEL_FORMATS,
254 /* marker segments */
255 /* get sizes and offsets of image, tiles; number of components */
256 static int get_siz(Jpeg2000DecoderContext *s)
260 uint32_t log2_chroma_wh = 0;
261 const enum AVPixelFormat *possible_fmts = NULL;
262 int possible_fmts_nb = 0;
265 if (bytestream2_get_bytes_left(&s->g) < 36) {
266 av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for SIZ\n");
267 return AVERROR_INVALIDDATA;
270 s->avctx->profile = bytestream2_get_be16u(&s->g); // Rsiz
271 s->width = bytestream2_get_be32u(&s->g); // Width
272 s->height = bytestream2_get_be32u(&s->g); // Height
273 s->image_offset_x = bytestream2_get_be32u(&s->g); // X0Siz
274 s->image_offset_y = bytestream2_get_be32u(&s->g); // Y0Siz
275 s->tile_width = bytestream2_get_be32u(&s->g); // XTSiz
276 s->tile_height = bytestream2_get_be32u(&s->g); // YTSiz
277 s->tile_offset_x = bytestream2_get_be32u(&s->g); // XT0Siz
278 s->tile_offset_y = bytestream2_get_be32u(&s->g); // YT0Siz
279 ncomponents = bytestream2_get_be16u(&s->g); // CSiz
281 if (s->image_offset_x || s->image_offset_y) {
282 avpriv_request_sample(s->avctx, "Support for image offsets");
283 return AVERROR_PATCHWELCOME;
285 if (av_image_check_size(s->width, s->height, 0, s->avctx)) {
286 avpriv_request_sample(s->avctx, "Large Dimensions");
287 return AVERROR_PATCHWELCOME;
290 if (ncomponents <= 0) {
291 av_log(s->avctx, AV_LOG_ERROR, "Invalid number of components: %d\n",
293 return AVERROR_INVALIDDATA;
296 if (ncomponents > 4) {
297 avpriv_request_sample(s->avctx, "Support for %d components",
299 return AVERROR_PATCHWELCOME;
302 if (s->tile_offset_x < 0 || s->tile_offset_y < 0 ||
303 s->image_offset_x < s->tile_offset_x ||
304 s->image_offset_y < s->tile_offset_y ||
305 s->tile_width + (int64_t)s->tile_offset_x <= s->image_offset_x ||
306 s->tile_height + (int64_t)s->tile_offset_y <= s->image_offset_y
308 av_log(s->avctx, AV_LOG_ERROR, "Tile offsets are invalid\n");
309 return AVERROR_INVALIDDATA;
312 s->ncomponents = ncomponents;
314 if (s->tile_width <= 0 || s->tile_height <= 0) {
315 av_log(s->avctx, AV_LOG_ERROR, "Invalid tile dimension %dx%d.\n",
316 s->tile_width, s->tile_height);
317 return AVERROR_INVALIDDATA;
320 if (bytestream2_get_bytes_left(&s->g) < 3 * s->ncomponents) {
321 av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for %d components in SIZ\n", s->ncomponents);
322 return AVERROR_INVALIDDATA;
325 for (i = 0; i < s->ncomponents; i++) { // Ssiz_i XRsiz_i, YRsiz_i
326 uint8_t x = bytestream2_get_byteu(&s->g);
327 s->cbps[i] = (x & 0x7f) + 1;
328 s->precision = FFMAX(s->cbps[i], s->precision);
329 s->sgnd[i] = !!(x & 0x80);
330 s->cdx[i] = bytestream2_get_byteu(&s->g);
331 s->cdy[i] = bytestream2_get_byteu(&s->g);
332 if ( !s->cdx[i] || s->cdx[i] == 3 || s->cdx[i] > 4
333 || !s->cdy[i] || s->cdy[i] == 3 || s->cdy[i] > 4) {
334 av_log(s->avctx, AV_LOG_ERROR, "Invalid sample separation %d/%d\n", s->cdx[i], s->cdy[i]);
335 return AVERROR_INVALIDDATA;
337 log2_chroma_wh |= s->cdy[i] >> 1 << i * 4 | s->cdx[i] >> 1 << i * 4 + 2;
340 s->numXtiles = ff_jpeg2000_ceildiv(s->width - s->tile_offset_x, s->tile_width);
341 s->numYtiles = ff_jpeg2000_ceildiv(s->height - s->tile_offset_y, s->tile_height);
343 if (s->numXtiles * (uint64_t)s->numYtiles > INT_MAX/sizeof(*s->tile)) {
344 s->numXtiles = s->numYtiles = 0;
345 return AVERROR(EINVAL);
348 s->tile = av_mallocz_array(s->numXtiles * s->numYtiles, sizeof(*s->tile));
350 s->numXtiles = s->numYtiles = 0;
351 return AVERROR(ENOMEM);
354 for (i = 0; i < s->numXtiles * s->numYtiles; i++) {
355 Jpeg2000Tile *tile = s->tile + i;
357 tile->comp = av_mallocz(s->ncomponents * sizeof(*tile->comp));
359 return AVERROR(ENOMEM);
362 /* compute image size with reduction factor */
363 ret = ff_set_dimensions(s->avctx,
364 ff_jpeg2000_ceildivpow2(s->width - s->image_offset_x,
365 s->reduction_factor),
366 ff_jpeg2000_ceildivpow2(s->height - s->image_offset_y,
367 s->reduction_factor));
371 if (s->avctx->profile == FF_PROFILE_JPEG2000_DCINEMA_2K ||
372 s->avctx->profile == FF_PROFILE_JPEG2000_DCINEMA_4K) {
373 possible_fmts = xyz_pix_fmts;
374 possible_fmts_nb = FF_ARRAY_ELEMS(xyz_pix_fmts);
376 switch (s->colour_space) {
378 possible_fmts = rgb_pix_fmts;
379 possible_fmts_nb = FF_ARRAY_ELEMS(rgb_pix_fmts);
382 possible_fmts = gray_pix_fmts;
383 possible_fmts_nb = FF_ARRAY_ELEMS(gray_pix_fmts);
386 possible_fmts = yuv_pix_fmts;
387 possible_fmts_nb = FF_ARRAY_ELEMS(yuv_pix_fmts);
390 possible_fmts = all_pix_fmts;
391 possible_fmts_nb = FF_ARRAY_ELEMS(all_pix_fmts);
395 for (i = 0; i < possible_fmts_nb; ++i) {
396 if (pix_fmt_match(possible_fmts[i], ncomponents, s->precision, log2_chroma_wh, s->pal8)) {
397 s->avctx->pix_fmt = possible_fmts[i];
402 if (i == possible_fmts_nb) {
403 if (ncomponents == 4 &&
404 s->cdy[0] == 1 && s->cdx[0] == 1 &&
405 s->cdy[1] == 1 && s->cdx[1] == 1 &&
406 s->cdy[2] == s->cdy[3] && s->cdx[2] == s->cdx[3]) {
407 if (s->precision == 8 && s->cdy[2] == 2 && s->cdx[2] == 2 && !s->pal8) {
408 s->avctx->pix_fmt = AV_PIX_FMT_YUVA420P;
419 if (i == possible_fmts_nb) {
420 av_log(s->avctx, AV_LOG_ERROR,
421 "Unknown pix_fmt, profile: %d, colour_space: %d, "
422 "components: %d, precision: %d\n"
423 "cdx[0]: %d, cdy[0]: %d\n"
424 "cdx[1]: %d, cdy[1]: %d\n"
425 "cdx[2]: %d, cdy[2]: %d\n"
426 "cdx[3]: %d, cdy[3]: %d\n",
427 s->avctx->profile, s->colour_space, ncomponents, s->precision,
430 ncomponents > 1 ? s->cdx[1] : 0,
431 ncomponents > 1 ? s->cdy[1] : 0,
432 ncomponents > 2 ? s->cdx[2] : 0,
433 ncomponents > 2 ? s->cdy[2] : 0,
434 ncomponents > 3 ? s->cdx[3] : 0,
435 ncomponents > 3 ? s->cdy[3] : 0);
436 return AVERROR_PATCHWELCOME;
438 s->avctx->bits_per_raw_sample = s->precision;
442 /* get common part for COD and COC segments */
443 static int get_cox(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c)
447 if (bytestream2_get_bytes_left(&s->g) < 5) {
448 av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for COX\n");
449 return AVERROR_INVALIDDATA;
452 /* nreslevels = number of resolution levels
453 = number of decomposition level +1 */
454 c->nreslevels = bytestream2_get_byteu(&s->g) + 1;
455 if (c->nreslevels >= JPEG2000_MAX_RESLEVELS) {
456 av_log(s->avctx, AV_LOG_ERROR, "nreslevels %d is invalid\n", c->nreslevels);
457 return AVERROR_INVALIDDATA;
460 if (c->nreslevels <= s->reduction_factor) {
461 /* we are forced to update reduction_factor as its requested value is
462 not compatible with this bitstream, and as we might have used it
463 already in setup earlier we have to fail this frame until
464 reinitialization is implemented */
465 av_log(s->avctx, AV_LOG_ERROR, "reduction_factor too large for this bitstream, max is %d\n", c->nreslevels - 1);
466 s->reduction_factor = c->nreslevels - 1;
467 return AVERROR(EINVAL);
470 /* compute number of resolution levels to decode */
471 c->nreslevels2decode = c->nreslevels - s->reduction_factor;
473 c->log2_cblk_width = (bytestream2_get_byteu(&s->g) & 15) + 2; // cblk width
474 c->log2_cblk_height = (bytestream2_get_byteu(&s->g) & 15) + 2; // cblk height
476 if (c->log2_cblk_width > 10 || c->log2_cblk_height > 10 ||
477 c->log2_cblk_width + c->log2_cblk_height > 12) {
478 av_log(s->avctx, AV_LOG_ERROR, "cblk size invalid\n");
479 return AVERROR_INVALIDDATA;
482 c->cblk_style = bytestream2_get_byteu(&s->g);
483 if (c->cblk_style != 0) { // cblk style
484 av_log(s->avctx, AV_LOG_WARNING, "extra cblk styles %X\n", c->cblk_style);
485 if (c->cblk_style & JPEG2000_CBLK_BYPASS)
486 av_log(s->avctx, AV_LOG_WARNING, "Selective arithmetic coding bypass\n");
488 c->transform = bytestream2_get_byteu(&s->g); // DWT transformation type
489 /* set integer 9/7 DWT in case of BITEXACT flag */
490 if ((s->avctx->flags & AV_CODEC_FLAG_BITEXACT) && (c->transform == FF_DWT97))
491 c->transform = FF_DWT97_INT;
492 else if (c->transform == FF_DWT53) {
493 s->avctx->properties |= FF_CODEC_PROPERTY_LOSSLESS;
496 if (c->csty & JPEG2000_CSTY_PREC) {
498 for (i = 0; i < c->nreslevels; i++) {
499 byte = bytestream2_get_byte(&s->g);
500 c->log2_prec_widths[i] = byte & 0x0F; // precinct PPx
501 c->log2_prec_heights[i] = (byte >> 4) & 0x0F; // precinct PPy
503 if (c->log2_prec_widths[i] == 0 || c->log2_prec_heights[i] == 0) {
504 av_log(s->avctx, AV_LOG_ERROR, "PPx %d PPy %d invalid\n",
505 c->log2_prec_widths[i], c->log2_prec_heights[i]);
506 c->log2_prec_widths[i] = c->log2_prec_heights[i] = 1;
507 return AVERROR_INVALIDDATA;
511 memset(c->log2_prec_widths , 15, sizeof(c->log2_prec_widths ));
512 memset(c->log2_prec_heights, 15, sizeof(c->log2_prec_heights));
517 /* get coding parameters for a particular tile or whole image*/
518 static int get_cod(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c,
521 Jpeg2000CodingStyle tmp;
524 if (bytestream2_get_bytes_left(&s->g) < 5) {
525 av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for COD\n");
526 return AVERROR_INVALIDDATA;
529 tmp.csty = bytestream2_get_byteu(&s->g);
531 // get progression order
532 tmp.prog_order = bytestream2_get_byteu(&s->g);
534 tmp.nlayers = bytestream2_get_be16u(&s->g);
535 tmp.mct = bytestream2_get_byteu(&s->g); // multiple component transformation
537 if (tmp.mct && s->ncomponents < 3) {
538 av_log(s->avctx, AV_LOG_ERROR,
539 "MCT %"PRIu8" with too few components (%d)\n",
540 tmp.mct, s->ncomponents);
541 return AVERROR_INVALIDDATA;
544 if ((ret = get_cox(s, &tmp)) < 0)
547 for (compno = 0; compno < s->ncomponents; compno++)
548 if (!(properties[compno] & HAD_COC))
549 memcpy(c + compno, &tmp, sizeof(tmp));
553 /* Get coding parameters for a component in the whole image or a
554 * particular tile. */
555 static int get_coc(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c,
560 if (bytestream2_get_bytes_left(&s->g) < 2) {
561 av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for COC\n");
562 return AVERROR_INVALIDDATA;
565 compno = bytestream2_get_byteu(&s->g);
567 if (compno >= s->ncomponents) {
568 av_log(s->avctx, AV_LOG_ERROR,
569 "Invalid compno %d. There are %d components in the image.\n",
570 compno, s->ncomponents);
571 return AVERROR_INVALIDDATA;
575 c->csty = bytestream2_get_byteu(&s->g);
577 if ((ret = get_cox(s, c)) < 0)
580 properties[compno] |= HAD_COC;
584 /* Get common part for QCD and QCC segments. */
585 static int get_qcx(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q)
589 if (bytestream2_get_bytes_left(&s->g) < 1)
590 return AVERROR_INVALIDDATA;
592 x = bytestream2_get_byteu(&s->g); // Sqcd
594 q->nguardbits = x >> 5;
595 q->quantsty = x & 0x1f;
597 if (q->quantsty == JPEG2000_QSTY_NONE) {
599 if (bytestream2_get_bytes_left(&s->g) < n ||
600 n > JPEG2000_MAX_DECLEVELS*3)
601 return AVERROR_INVALIDDATA;
602 for (i = 0; i < n; i++)
603 q->expn[i] = bytestream2_get_byteu(&s->g) >> 3;
604 } else if (q->quantsty == JPEG2000_QSTY_SI) {
605 if (bytestream2_get_bytes_left(&s->g) < 2)
606 return AVERROR_INVALIDDATA;
607 x = bytestream2_get_be16u(&s->g);
608 q->expn[0] = x >> 11;
609 q->mant[0] = x & 0x7ff;
610 for (i = 1; i < JPEG2000_MAX_DECLEVELS * 3; i++) {
611 int curexpn = FFMAX(0, q->expn[0] - (i - 1) / 3);
612 q->expn[i] = curexpn;
613 q->mant[i] = q->mant[0];
617 if (bytestream2_get_bytes_left(&s->g) < 2 * n ||
618 n > JPEG2000_MAX_DECLEVELS*3)
619 return AVERROR_INVALIDDATA;
620 for (i = 0; i < n; i++) {
621 x = bytestream2_get_be16u(&s->g);
622 q->expn[i] = x >> 11;
623 q->mant[i] = x & 0x7ff;
629 /* Get quantization parameters for a particular tile or a whole image. */
630 static int get_qcd(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q,
633 Jpeg2000QuantStyle tmp;
636 memset(&tmp, 0, sizeof(tmp));
638 if ((ret = get_qcx(s, n, &tmp)) < 0)
640 for (compno = 0; compno < s->ncomponents; compno++)
641 if (!(properties[compno] & HAD_QCC))
642 memcpy(q + compno, &tmp, sizeof(tmp));
646 /* Get quantization parameters for a component in the whole image
647 * on in a particular tile. */
648 static int get_qcc(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q,
653 if (bytestream2_get_bytes_left(&s->g) < 1)
654 return AVERROR_INVALIDDATA;
656 compno = bytestream2_get_byteu(&s->g);
658 if (compno >= s->ncomponents) {
659 av_log(s->avctx, AV_LOG_ERROR,
660 "Invalid compno %d. There are %d components in the image.\n",
661 compno, s->ncomponents);
662 return AVERROR_INVALIDDATA;
665 properties[compno] |= HAD_QCC;
666 return get_qcx(s, n - 1, q + compno);
669 static int get_poc(Jpeg2000DecoderContext *s, int size, Jpeg2000POC *p)
672 int elem_size = s->ncomponents <= 257 ? 7 : 9;
673 Jpeg2000POC tmp = {{{0}}};
675 if (bytestream2_get_bytes_left(&s->g) < 5 || size < 2 + elem_size) {
676 av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for POC\n");
677 return AVERROR_INVALIDDATA;
681 avpriv_request_sample(s->avctx, "Fat POC not supported");
682 return AVERROR_PATCHWELCOME;
685 tmp.nb_poc = (size - 2) / elem_size;
686 if (tmp.nb_poc > MAX_POCS) {
687 avpriv_request_sample(s->avctx, "Too many POCs (%d)", tmp.nb_poc);
688 return AVERROR_PATCHWELCOME;
691 for (i = 0; i<tmp.nb_poc; i++) {
692 Jpeg2000POCEntry *e = &tmp.poc[i];
693 e->RSpoc = bytestream2_get_byteu(&s->g);
694 e->CSpoc = bytestream2_get_byteu(&s->g);
695 e->LYEpoc = bytestream2_get_be16u(&s->g);
696 e->REpoc = bytestream2_get_byteu(&s->g);
697 e->CEpoc = bytestream2_get_byteu(&s->g);
698 e->Ppoc = bytestream2_get_byteu(&s->g);
701 if (e->CEpoc > s->ncomponents)
702 e->CEpoc = s->ncomponents;
703 if ( e->RSpoc >= e->REpoc || e->REpoc > 33
704 || e->CSpoc >= e->CEpoc || e->CEpoc > s->ncomponents
706 av_log(s->avctx, AV_LOG_ERROR, "POC Entry %d is invalid (%d, %d, %d, %d, %d, %d)\n", i,
707 e->RSpoc, e->CSpoc, e->LYEpoc, e->REpoc, e->CEpoc, e->Ppoc
709 return AVERROR_INVALIDDATA;
713 if (!p->nb_poc || p->is_default) {
716 if (p->nb_poc + tmp.nb_poc > MAX_POCS) {
717 av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for POC\n");
718 return AVERROR_INVALIDDATA;
720 memcpy(p->poc + p->nb_poc, tmp.poc, tmp.nb_poc * sizeof(tmp.poc[0]));
721 p->nb_poc += tmp.nb_poc;
730 /* Get start of tile segment. */
731 static int get_sot(Jpeg2000DecoderContext *s, int n)
733 Jpeg2000TilePart *tp;
738 if (bytestream2_get_bytes_left(&s->g) < 8)
739 return AVERROR_INVALIDDATA;
742 Isot = bytestream2_get_be16u(&s->g); // Isot
743 if (Isot >= s->numXtiles * s->numYtiles)
744 return AVERROR_INVALIDDATA;
747 Psot = bytestream2_get_be32u(&s->g); // Psot
748 TPsot = bytestream2_get_byteu(&s->g); // TPsot
750 /* Read TNSot but not used */
751 bytestream2_get_byteu(&s->g); // TNsot
754 Psot = bytestream2_get_bytes_left(&s->g) - 2 + n + 2;
756 if (Psot > bytestream2_get_bytes_left(&s->g) - 2 + n + 2) {
757 av_log(s->avctx, AV_LOG_ERROR, "Psot %"PRIu32" too big\n", Psot);
758 return AVERROR_INVALIDDATA;
761 av_assert0(TPsot < FF_ARRAY_ELEMS(s->tile[Isot].tile_part));
763 s->tile[Isot].tp_idx = TPsot;
764 tp = s->tile[Isot].tile_part + TPsot;
765 tp->tile_index = Isot;
766 tp->tp_end = s->g.buffer + Psot - n - 2;
769 Jpeg2000Tile *tile = s->tile + s->curtileno;
772 memcpy(tile->codsty, s->codsty, s->ncomponents * sizeof(Jpeg2000CodingStyle));
773 memcpy(tile->qntsty, s->qntsty, s->ncomponents * sizeof(Jpeg2000QuantStyle));
774 memcpy(&tile->poc , &s->poc , sizeof(tile->poc));
775 tile->poc.is_default = 1;
781 /* Tile-part lengths: see ISO 15444-1:2002, section A.7.1
782 * Used to know the number of tile parts and lengths.
783 * There may be multiple TLMs in the header.
784 * TODO: The function is not used for tile-parts management, nor anywhere else.
785 * It can be useful to allocate memory for tile parts, before managing the SOT
786 * markers. Parsing the TLM header is needed to increment the input header
788 * This marker is mandatory for DCI. */
789 static uint8_t get_tlm(Jpeg2000DecoderContext *s, int n)
791 uint8_t Stlm, ST, SP, tile_tlm, i;
792 bytestream2_get_byte(&s->g); /* Ztlm: skipped */
793 Stlm = bytestream2_get_byte(&s->g);
795 // too complex ? ST = ((Stlm >> 4) & 0x01) + ((Stlm >> 4) & 0x02);
796 ST = (Stlm >> 4) & 0x03;
797 // TODO: Manage case of ST = 0b11 --> raise error
798 SP = (Stlm >> 6) & 0x01;
799 tile_tlm = (n - 4) / ((SP + 1) * 2 + ST);
800 for (i = 0; i < tile_tlm; i++) {
805 bytestream2_get_byte(&s->g);
808 bytestream2_get_be16(&s->g);
811 bytestream2_get_be32(&s->g);
815 bytestream2_get_be16(&s->g);
817 bytestream2_get_be32(&s->g);
823 static uint8_t get_plt(Jpeg2000DecoderContext *s, int n)
827 av_log(s->avctx, AV_LOG_DEBUG,
828 "PLT marker at pos 0x%X\n", bytestream2_tell(&s->g) - 4);
830 /*Zplt =*/ bytestream2_get_byte(&s->g);
832 for (i = 0; i < n - 3; i++) {
833 bytestream2_get_byte(&s->g);
839 static int init_tile(Jpeg2000DecoderContext *s, int tileno)
842 int tilex = tileno % s->numXtiles;
843 int tiley = tileno / s->numXtiles;
844 Jpeg2000Tile *tile = s->tile + tileno;
847 return AVERROR(ENOMEM);
849 tile->coord[0][0] = av_clip(tilex * (int64_t)s->tile_width + s->tile_offset_x, s->image_offset_x, s->width);
850 tile->coord[0][1] = av_clip((tilex + 1) * (int64_t)s->tile_width + s->tile_offset_x, s->image_offset_x, s->width);
851 tile->coord[1][0] = av_clip(tiley * (int64_t)s->tile_height + s->tile_offset_y, s->image_offset_y, s->height);
852 tile->coord[1][1] = av_clip((tiley + 1) * (int64_t)s->tile_height + s->tile_offset_y, s->image_offset_y, s->height);
854 for (compno = 0; compno < s->ncomponents; compno++) {
855 Jpeg2000Component *comp = tile->comp + compno;
856 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
857 Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
858 int ret; // global bandno
860 comp->coord_o[0][0] = tile->coord[0][0];
861 comp->coord_o[0][1] = tile->coord[0][1];
862 comp->coord_o[1][0] = tile->coord[1][0];
863 comp->coord_o[1][1] = tile->coord[1][1];
865 comp->coord_o[0][0] /= s->cdx[compno];
866 comp->coord_o[0][1] /= s->cdx[compno];
867 comp->coord_o[1][0] /= s->cdy[compno];
868 comp->coord_o[1][1] /= s->cdy[compno];
871 comp->coord[0][0] = ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], s->reduction_factor);
872 comp->coord[0][1] = ff_jpeg2000_ceildivpow2(comp->coord_o[0][1], s->reduction_factor);
873 comp->coord[1][0] = ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], s->reduction_factor);
874 comp->coord[1][1] = ff_jpeg2000_ceildivpow2(comp->coord_o[1][1], s->reduction_factor);
876 if (ret = ff_jpeg2000_init_component(comp, codsty, qntsty,
877 s->cbps[compno], s->cdx[compno],
878 s->cdy[compno], s->avctx))
884 /* Read the number of coding passes. */
885 static int getnpasses(Jpeg2000DecoderContext *s)
892 if ((num = get_bits(s, 2)) != 3)
893 return num < 0 ? num : 3 + num;
894 if ((num = get_bits(s, 5)) != 31)
895 return num < 0 ? num : 6 + num;
896 num = get_bits(s, 7);
897 return num < 0 ? num : 37 + num;
900 static int getlblockinc(Jpeg2000DecoderContext *s)
903 while (ret = get_bits(s, 1)) {
911 static int jpeg2000_decode_packet(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile, int *tp_index,
912 Jpeg2000CodingStyle *codsty,
913 Jpeg2000ResLevel *rlevel, int precno,
914 int layno, uint8_t *expn, int numgbits)
916 int bandno, cblkno, ret, nb_code_blocks;
919 if (layno < rlevel->band[0].prec[precno].decoded_layers)
921 rlevel->band[0].prec[precno].decoded_layers = layno + 1;
923 if (bytestream2_get_bytes_left(&s->g) == 0 && s->bit_index == 8) {
924 if (*tp_index < FF_ARRAY_ELEMS(tile->tile_part) - 1) {
925 s->g = tile->tile_part[++(*tp_index)].tpg;
929 if (bytestream2_peek_be32(&s->g) == JPEG2000_SOP_FIXED_BYTES)
930 bytestream2_skip(&s->g, JPEG2000_SOP_BYTE_LENGTH);
932 if (!(ret = get_bits(s, 1))) {
938 for (bandno = 0; bandno < rlevel->nbands; bandno++) {
939 Jpeg2000Band *band = rlevel->band + bandno;
940 Jpeg2000Prec *prec = band->prec + precno;
942 if (band->coord[0][0] == band->coord[0][1] ||
943 band->coord[1][0] == band->coord[1][1])
945 nb_code_blocks = prec->nb_codeblocks_height *
946 prec->nb_codeblocks_width;
947 for (cblkno = 0; cblkno < nb_code_blocks; cblkno++) {
948 Jpeg2000Cblk *cblk = prec->cblk + cblkno;
949 int incl, newpasses, llen;
952 incl = get_bits(s, 1);
954 incl = tag_tree_decode(s, prec->cblkincl + cblkno, layno + 1) == layno;
960 if (!cblk->npasses) {
961 int v = expn[bandno] + numgbits - 1 -
962 tag_tree_decode(s, prec->zerobits + cblkno, 100);
963 if (v < 0 || v > 30) {
964 av_log(s->avctx, AV_LOG_ERROR,
965 "nonzerobits %d invalid or unsupported\n", v);
966 return AVERROR_INVALIDDATA;
968 cblk->nonzerobits = v;
970 if ((newpasses = getnpasses(s)) < 0)
972 av_assert2(newpasses > 0);
973 if (cblk->npasses + newpasses >= JPEG2000_MAX_PASSES) {
974 avpriv_request_sample(s->avctx, "Too many passes");
975 return AVERROR_PATCHWELCOME;
977 if ((llen = getlblockinc(s)) < 0)
979 if (cblk->lblock + llen + av_log2(newpasses) > 16) {
980 avpriv_request_sample(s->avctx,
981 "Block with length beyond 16 bits");
982 return AVERROR_PATCHWELCOME;
985 cblk->lblock += llen;
987 cblk->nb_lengthinc = 0;
988 cblk->nb_terminationsinc = 0;
992 while (newpasses1 < newpasses) {
994 if (needs_termination(codsty->cblk_style, cblk->npasses + newpasses1 - 1)) {
995 cblk->nb_terminationsinc ++;
1000 if ((ret = get_bits(s, av_log2(newpasses1) + cblk->lblock)) < 0)
1002 if (ret > sizeof(cblk->data)) {
1003 avpriv_request_sample(s->avctx,
1004 "Block with lengthinc greater than %"SIZE_SPECIFIER"",
1005 sizeof(cblk->data));
1006 return AVERROR_PATCHWELCOME;
1008 cblk->lengthinc[cblk->nb_lengthinc++] = ret;
1009 cblk->npasses += newpasses1;
1010 newpasses -= newpasses1;
1016 if (codsty->csty & JPEG2000_CSTY_EPH) {
1017 if (bytestream2_peek_be16(&s->g) == JPEG2000_EPH)
1018 bytestream2_skip(&s->g, 2);
1020 av_log(s->avctx, AV_LOG_ERROR, "EPH marker not found. instead %X\n", bytestream2_peek_be32(&s->g));
1023 for (bandno = 0; bandno < rlevel->nbands; bandno++) {
1024 Jpeg2000Band *band = rlevel->band + bandno;
1025 Jpeg2000Prec *prec = band->prec + precno;
1027 nb_code_blocks = prec->nb_codeblocks_height * prec->nb_codeblocks_width;
1028 for (cblkno = 0; cblkno < nb_code_blocks; cblkno++) {
1029 Jpeg2000Cblk *cblk = prec->cblk + cblkno;
1030 for (cwsno = 0; cwsno < cblk->nb_lengthinc; cwsno ++) {
1031 if ( bytestream2_get_bytes_left(&s->g) < cblk->lengthinc[cwsno]
1032 || sizeof(cblk->data) < cblk->length + cblk->lengthinc[cwsno] + 4
1034 av_log(s->avctx, AV_LOG_ERROR,
1035 "Block length %"PRIu16" or lengthinc %d is too large, left %d\n",
1036 cblk->length, cblk->lengthinc[cwsno], bytestream2_get_bytes_left(&s->g));
1037 return AVERROR_INVALIDDATA;
1040 bytestream2_get_bufferu(&s->g, cblk->data + cblk->length, cblk->lengthinc[cwsno]);
1041 cblk->length += cblk->lengthinc[cwsno];
1042 cblk->lengthinc[cwsno] = 0;
1043 if (cblk->nb_terminationsinc) {
1044 cblk->nb_terminationsinc--;
1045 cblk->nb_terminations++;
1046 cblk->data[cblk->length++] = 0xFF;
1047 cblk->data[cblk->length++] = 0xFF;
1048 cblk->data_start[cblk->nb_terminations] = cblk->length;
1056 static int jpeg2000_decode_packets_po_iteration(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile,
1057 int RSpoc, int CSpoc,
1058 int LYEpoc, int REpoc, int CEpoc,
1059 int Ppoc, int *tp_index)
1062 int layno, reslevelno, compno, precno, ok_reslevel;
1067 case JPEG2000_PGOD_RLCP:
1068 av_log(s->avctx, AV_LOG_DEBUG, "Progression order RLCP\n");
1070 for (reslevelno = RSpoc; ok_reslevel && reslevelno < REpoc; reslevelno++) {
1072 for (layno = 0; layno < LYEpoc; layno++) {
1073 for (compno = CSpoc; compno < CEpoc; compno++) {
1074 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1075 Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
1076 if (reslevelno < codsty->nreslevels) {
1077 Jpeg2000ResLevel *rlevel = tile->comp[compno].reslevel +
1080 for (precno = 0; precno < rlevel->num_precincts_x * rlevel->num_precincts_y; precno++)
1081 if ((ret = jpeg2000_decode_packet(s, tile, tp_index,
1084 qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1085 qntsty->nguardbits)) < 0)
1093 case JPEG2000_PGOD_LRCP:
1094 av_log(s->avctx, AV_LOG_DEBUG, "Progression order LRCP\n");
1095 for (layno = 0; layno < LYEpoc; layno++) {
1097 for (reslevelno = RSpoc; ok_reslevel && reslevelno < REpoc; reslevelno++) {
1099 for (compno = CSpoc; compno < CEpoc; compno++) {
1100 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1101 Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
1102 if (reslevelno < codsty->nreslevels) {
1103 Jpeg2000ResLevel *rlevel = tile->comp[compno].reslevel +
1106 for (precno = 0; precno < rlevel->num_precincts_x * rlevel->num_precincts_y; precno++)
1107 if ((ret = jpeg2000_decode_packet(s, tile, tp_index,
1110 qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1111 qntsty->nguardbits)) < 0)
1119 case JPEG2000_PGOD_CPRL:
1120 av_log(s->avctx, AV_LOG_DEBUG, "Progression order CPRL\n");
1121 for (compno = CSpoc; compno < CEpoc; compno++) {
1122 Jpeg2000Component *comp = tile->comp + compno;
1123 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1124 Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
1128 for (reslevelno = RSpoc; reslevelno < FFMIN(codsty->nreslevels, REpoc); reslevelno++) {
1129 uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1130 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1131 step_x = FFMIN(step_x, rlevel->log2_prec_width + reducedresno);
1132 step_y = FFMIN(step_y, rlevel->log2_prec_height + reducedresno);
1134 av_assert0(step_x < 32 && step_y < 32);
1138 for (y = tile->coord[1][0]; y < tile->coord[1][1]; y = (y/step_y + 1)*step_y) {
1139 for (x = tile->coord[0][0]; x < tile->coord[0][1]; x = (x/step_x + 1)*step_x) {
1140 for (reslevelno = RSpoc; reslevelno < FFMIN(codsty->nreslevels, REpoc); reslevelno++) {
1141 unsigned prcx, prcy;
1142 uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1143 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1144 int xc = x / s->cdx[compno];
1145 int yc = y / s->cdy[compno];
1147 if (yc % (1 << (rlevel->log2_prec_height + reducedresno)) && y != tile->coord[1][0]) //FIXME this is a subset of the check
1150 if (xc % (1 << (rlevel->log2_prec_width + reducedresno)) && x != tile->coord[0][0]) //FIXME this is a subset of the check
1153 // check if a precinct exists
1154 prcx = ff_jpeg2000_ceildivpow2(xc, reducedresno) >> rlevel->log2_prec_width;
1155 prcy = ff_jpeg2000_ceildivpow2(yc, reducedresno) >> rlevel->log2_prec_height;
1156 prcx -= ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], reducedresno) >> rlevel->log2_prec_width;
1157 prcy -= ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], reducedresno) >> rlevel->log2_prec_height;
1159 precno = prcx + rlevel->num_precincts_x * prcy;
1161 if (prcx >= rlevel->num_precincts_x || prcy >= rlevel->num_precincts_y) {
1162 av_log(s->avctx, AV_LOG_WARNING, "prc %d %d outside limits %d %d\n",
1163 prcx, prcy, rlevel->num_precincts_x, rlevel->num_precincts_y);
1167 for (layno = 0; layno < LYEpoc; layno++) {
1168 if ((ret = jpeg2000_decode_packet(s, tile, tp_index, codsty, rlevel,
1170 qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1171 qntsty->nguardbits)) < 0)
1180 case JPEG2000_PGOD_RPCL:
1181 av_log(s->avctx, AV_LOG_WARNING, "Progression order RPCL\n");
1183 for (reslevelno = RSpoc; ok_reslevel && reslevelno < REpoc; reslevelno++) {
1187 for (compno = CSpoc; compno < CEpoc; compno++) {
1188 Jpeg2000Component *comp = tile->comp + compno;
1189 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1191 if (reslevelno < codsty->nreslevels) {
1192 uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1193 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1194 step_x = FFMIN(step_x, rlevel->log2_prec_width + reducedresno);
1195 step_y = FFMIN(step_y, rlevel->log2_prec_height + reducedresno);
1201 for (y = tile->coord[1][0]; y < tile->coord[1][1]; y = (y/step_y + 1)*step_y) {
1202 for (x = tile->coord[0][0]; x < tile->coord[0][1]; x = (x/step_x + 1)*step_x) {
1203 for (compno = CSpoc; compno < CEpoc; compno++) {
1204 Jpeg2000Component *comp = tile->comp + compno;
1205 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1206 Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
1207 uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1208 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1209 unsigned prcx, prcy;
1211 int xc = x / s->cdx[compno];
1212 int yc = y / s->cdy[compno];
1214 if (reslevelno >= codsty->nreslevels)
1217 if (yc % (1 << (rlevel->log2_prec_height + reducedresno)) && y != tile->coord[1][0]) //FIXME this is a subset of the check
1220 if (xc % (1 << (rlevel->log2_prec_width + reducedresno)) && x != tile->coord[0][0]) //FIXME this is a subset of the check
1223 // check if a precinct exists
1224 prcx = ff_jpeg2000_ceildivpow2(xc, reducedresno) >> rlevel->log2_prec_width;
1225 prcy = ff_jpeg2000_ceildivpow2(yc, reducedresno) >> rlevel->log2_prec_height;
1226 prcx -= ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], reducedresno) >> rlevel->log2_prec_width;
1227 prcy -= ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], reducedresno) >> rlevel->log2_prec_height;
1229 precno = prcx + rlevel->num_precincts_x * prcy;
1232 if (prcx >= rlevel->num_precincts_x || prcy >= rlevel->num_precincts_y) {
1233 av_log(s->avctx, AV_LOG_WARNING, "prc %d %d outside limits %d %d\n",
1234 prcx, prcy, rlevel->num_precincts_x, rlevel->num_precincts_y);
1238 for (layno = 0; layno < LYEpoc; layno++) {
1239 if ((ret = jpeg2000_decode_packet(s, tile, tp_index,
1242 qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1243 qntsty->nguardbits)) < 0)
1252 case JPEG2000_PGOD_PCRL:
1253 av_log(s->avctx, AV_LOG_WARNING, "Progression order PCRL\n");
1256 for (compno = CSpoc; compno < CEpoc; compno++) {
1257 Jpeg2000Component *comp = tile->comp + compno;
1258 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1260 for (reslevelno = RSpoc; reslevelno < FFMIN(codsty->nreslevels, REpoc); reslevelno++) {
1261 uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1262 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1263 step_x = FFMIN(step_x, rlevel->log2_prec_width + reducedresno);
1264 step_y = FFMIN(step_y, rlevel->log2_prec_height + reducedresno);
1267 if (step_x >= 31 || step_y >= 31){
1268 avpriv_request_sample(s->avctx, "PCRL with large step");
1269 return AVERROR_PATCHWELCOME;
1274 for (y = tile->coord[1][0]; y < tile->coord[1][1]; y = (y/step_y + 1)*step_y) {
1275 for (x = tile->coord[0][0]; x < tile->coord[0][1]; x = (x/step_x + 1)*step_x) {
1276 for (compno = CSpoc; compno < CEpoc; compno++) {
1277 Jpeg2000Component *comp = tile->comp + compno;
1278 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1279 Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
1280 int xc = x / s->cdx[compno];
1281 int yc = y / s->cdy[compno];
1283 for (reslevelno = RSpoc; reslevelno < FFMIN(codsty->nreslevels, REpoc); reslevelno++) {
1284 unsigned prcx, prcy;
1285 uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1286 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1288 if (yc % (1 << (rlevel->log2_prec_height + reducedresno)) && y != tile->coord[1][0]) //FIXME this is a subset of the check
1291 if (xc % (1 << (rlevel->log2_prec_width + reducedresno)) && x != tile->coord[0][0]) //FIXME this is a subset of the check
1294 // check if a precinct exists
1295 prcx = ff_jpeg2000_ceildivpow2(xc, reducedresno) >> rlevel->log2_prec_width;
1296 prcy = ff_jpeg2000_ceildivpow2(yc, reducedresno) >> rlevel->log2_prec_height;
1297 prcx -= ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], reducedresno) >> rlevel->log2_prec_width;
1298 prcy -= ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], reducedresno) >> rlevel->log2_prec_height;
1300 precno = prcx + rlevel->num_precincts_x * prcy;
1302 if (prcx >= rlevel->num_precincts_x || prcy >= rlevel->num_precincts_y) {
1303 av_log(s->avctx, AV_LOG_WARNING, "prc %d %d outside limits %d %d\n",
1304 prcx, prcy, rlevel->num_precincts_x, rlevel->num_precincts_y);
1308 for (layno = 0; layno < LYEpoc; layno++) {
1309 if ((ret = jpeg2000_decode_packet(s, tile, tp_index, codsty, rlevel,
1311 qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1312 qntsty->nguardbits)) < 0)
1328 static int jpeg2000_decode_packets(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
1330 int ret = AVERROR_BUG;
1335 if (tile->poc.nb_poc) {
1336 for (i=0; i<tile->poc.nb_poc; i++) {
1337 Jpeg2000POCEntry *e = &tile->poc.poc[i];
1338 ret = jpeg2000_decode_packets_po_iteration(s, tile,
1340 FFMIN(e->LYEpoc, tile->codsty[0].nlayers),
1342 FFMIN(e->CEpoc, s->ncomponents),
1349 ret = jpeg2000_decode_packets_po_iteration(s, tile,
1351 tile->codsty[0].nlayers,
1354 tile->codsty[0].prog_order,
1358 /* EOC marker reached */
1359 bytestream2_skip(&s->g, 2);
1364 /* TIER-1 routines */
1365 static void decode_sigpass(Jpeg2000T1Context *t1, int width, int height,
1366 int bpno, int bandno,
1367 int vert_causal_ctx_csty_symbol)
1369 int mask = 3 << (bpno - 1), y0, x, y;
1371 for (y0 = 0; y0 < height; y0 += 4)
1372 for (x = 0; x < width; x++)
1373 for (y = y0; y < height && y < y0 + 4; y++) {
1374 int flags_mask = -1;
1375 if (vert_causal_ctx_csty_symbol && y == y0 + 3)
1376 flags_mask &= ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE | JPEG2000_T1_SGN_S);
1377 if ((t1->flags[(y+1) * t1->stride + x+1] & JPEG2000_T1_SIG_NB & flags_mask)
1378 && !(t1->flags[(y+1) * t1->stride + x+1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS))) {
1379 if (ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ff_jpeg2000_getsigctxno(t1->flags[(y+1) * t1->stride + x+1] & flags_mask, bandno))) {
1380 int xorbit, ctxno = ff_jpeg2000_getsgnctxno(t1->flags[(y+1) * t1->stride + x+1] & flags_mask, &xorbit);
1382 t1->data[(y) * t1->stride + x] = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ctxno) ? -mask : mask;
1384 t1->data[(y) * t1->stride + x] = (ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ctxno) ^ xorbit) ?
1387 ff_jpeg2000_set_significance(t1, x, y,
1388 t1->data[(y) * t1->stride + x] < 0);
1390 t1->flags[(y + 1) * t1->stride + x + 1] |= JPEG2000_T1_VIS;
1395 static void decode_refpass(Jpeg2000T1Context *t1, int width, int height,
1396 int bpno, int vert_causal_ctx_csty_symbol)
1401 phalf = 1 << (bpno - 1);
1404 for (y0 = 0; y0 < height; y0 += 4)
1405 for (x = 0; x < width; x++)
1406 for (y = y0; y < height && y < y0 + 4; y++)
1407 if ((t1->flags[(y + 1) * t1->stride + x + 1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS)) == JPEG2000_T1_SIG) {
1408 int flags_mask = (vert_causal_ctx_csty_symbol && y == y0 + 3) ?
1409 ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE | JPEG2000_T1_SGN_S) : -1;
1410 int ctxno = ff_jpeg2000_getrefctxno(t1->flags[(y + 1) * t1->stride + x + 1] & flags_mask);
1411 int r = ff_mqc_decode(&t1->mqc,
1412 t1->mqc.cx_states + ctxno)
1414 t1->data[(y) * t1->stride + x] += t1->data[(y) * t1->stride + x] < 0 ? -r : r;
1415 t1->flags[(y + 1) * t1->stride + x + 1] |= JPEG2000_T1_REF;
1419 static void decode_clnpass(Jpeg2000DecoderContext *s, Jpeg2000T1Context *t1,
1420 int width, int height, int bpno, int bandno,
1421 int seg_symbols, int vert_causal_ctx_csty_symbol)
1423 int mask = 3 << (bpno - 1), y0, x, y, runlen, dec;
1425 for (y0 = 0; y0 < height; y0 += 4) {
1426 for (x = 0; x < width; x++) {
1427 int flags_mask = -1;
1428 if (vert_causal_ctx_csty_symbol)
1429 flags_mask &= ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE | JPEG2000_T1_SGN_S);
1430 if (y0 + 3 < height &&
1431 !((t1->flags[(y0 + 1) * t1->stride + x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
1432 (t1->flags[(y0 + 2) * t1->stride + x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
1433 (t1->flags[(y0 + 3) * t1->stride + x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
1434 (t1->flags[(y0 + 4) * t1->stride + x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG) & flags_mask))) {
1435 if (!ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_RL))
1437 runlen = ff_mqc_decode(&t1->mqc,
1438 t1->mqc.cx_states + MQC_CX_UNI);
1439 runlen = (runlen << 1) | ff_mqc_decode(&t1->mqc,
1448 for (y = y0 + runlen; y < y0 + 4 && y < height; y++) {
1449 int flags_mask = -1;
1450 if (vert_causal_ctx_csty_symbol && y == y0 + 3)
1451 flags_mask &= ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE | JPEG2000_T1_SGN_S);
1453 if (!(t1->flags[(y+1) * t1->stride + x+1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS))) {
1454 dec = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ff_jpeg2000_getsigctxno(t1->flags[(y+1) * t1->stride + x+1] & flags_mask,
1460 int ctxno = ff_jpeg2000_getsgnctxno(t1->flags[(y + 1) * t1->stride + x + 1] & flags_mask,
1462 t1->data[(y) * t1->stride + x] = (ff_mqc_decode(&t1->mqc,
1463 t1->mqc.cx_states + ctxno) ^
1466 ff_jpeg2000_set_significance(t1, x, y, t1->data[(y) * t1->stride + x] < 0);
1469 t1->flags[(y + 1) * t1->stride + x + 1] &= ~JPEG2000_T1_VIS;
1475 val = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1476 val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1477 val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1478 val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1480 av_log(s->avctx, AV_LOG_ERROR,
1481 "Segmentation symbol value incorrect\n");
1485 static int decode_cblk(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *codsty,
1486 Jpeg2000T1Context *t1, Jpeg2000Cblk *cblk,
1487 int width, int height, int bandpos)
1489 int passno = cblk->npasses, pass_t = 2, bpno = cblk->nonzerobits - 1;
1491 int vert_causal_ctx_csty_symbol = codsty->cblk_style & JPEG2000_CBLK_VSC;
1495 av_assert0(width <= 1024U && height <= 1024U);
1496 av_assert0(width*height <= 4096);
1498 memset(t1->data, 0, t1->stride * height * sizeof(*t1->data));
1500 /* If code-block contains no compressed data: nothing to do. */
1504 memset(t1->flags, 0, t1->stride * (height + 2) * sizeof(*t1->flags));
1506 cblk->data[cblk->length] = 0xff;
1507 cblk->data[cblk->length+1] = 0xff;
1508 ff_mqc_initdec(&t1->mqc, cblk->data, 0, 1);
1512 av_log(s->avctx, AV_LOG_ERROR, "bpno became negative\n");
1513 return AVERROR_INVALIDDATA;
1517 decode_sigpass(t1, width, height, bpno + 1, bandpos,
1518 vert_causal_ctx_csty_symbol);
1521 decode_refpass(t1, width, height, bpno + 1, vert_causal_ctx_csty_symbol);
1524 av_assert2(!t1->mqc.raw);
1525 decode_clnpass(s, t1, width, height, bpno + 1, bandpos,
1526 codsty->cblk_style & JPEG2000_CBLK_SEGSYM,
1527 vert_causal_ctx_csty_symbol);
1530 if (codsty->cblk_style & JPEG2000_CBLK_RESET) // XXX no testcase for just this
1531 ff_mqc_init_contexts(&t1->mqc);
1533 if (passno && (coder_type = needs_termination(codsty->cblk_style, pass_cnt))) {
1534 if (term_cnt >= cblk->nb_terminations) {
1535 av_log(s->avctx, AV_LOG_ERROR, "Missing needed termination \n");
1536 return AVERROR_INVALIDDATA;
1538 if (FFABS(cblk->data + cblk->data_start[term_cnt + 1] - 2 - t1->mqc.bp) > 0) {
1539 av_log(s->avctx, AV_LOG_WARNING, "Mid mismatch %"PTRDIFF_SPECIFIER" in pass %d of %d\n",
1540 cblk->data + cblk->data_start[term_cnt + 1] - 2 - t1->mqc.bp,
1541 pass_cnt, cblk->npasses);
1544 ff_mqc_initdec(&t1->mqc, cblk->data + cblk->data_start[++term_cnt], coder_type == 2, 0);
1555 if (cblk->data + cblk->length - 2*(term_cnt < cblk->nb_terminations) != t1->mqc.bp) {
1556 av_log(s->avctx, AV_LOG_WARNING, "End mismatch %"PTRDIFF_SPECIFIER"\n",
1557 cblk->data + cblk->length - 2*(term_cnt < cblk->nb_terminations) - t1->mqc.bp);
1563 /* TODO: Verify dequantization for lossless case
1564 * comp->data can be float or int
1565 * band->stepsize can be float or int
1566 * depending on the type of DWT transformation.
1567 * see ISO/IEC 15444-1:2002 A.6.1 */
1569 /* Float dequantization of a codeblock.*/
1570 static void dequantization_float(int x, int y, Jpeg2000Cblk *cblk,
1571 Jpeg2000Component *comp,
1572 Jpeg2000T1Context *t1, Jpeg2000Band *band)
1575 int w = cblk->coord[0][1] - cblk->coord[0][0];
1576 for (j = 0; j < (cblk->coord[1][1] - cblk->coord[1][0]); ++j) {
1577 float *datap = &comp->f_data[(comp->coord[0][1] - comp->coord[0][0]) * (y + j) + x];
1578 int *src = t1->data + j*t1->stride;
1579 for (i = 0; i < w; ++i)
1580 datap[i] = src[i] * band->f_stepsize;
1584 /* Integer dequantization of a codeblock.*/
1585 static void dequantization_int(int x, int y, Jpeg2000Cblk *cblk,
1586 Jpeg2000Component *comp,
1587 Jpeg2000T1Context *t1, Jpeg2000Band *band)
1590 int w = cblk->coord[0][1] - cblk->coord[0][0];
1591 for (j = 0; j < (cblk->coord[1][1] - cblk->coord[1][0]); ++j) {
1592 int32_t *datap = &comp->i_data[(comp->coord[0][1] - comp->coord[0][0]) * (y + j) + x];
1593 int *src = t1->data + j*t1->stride;
1594 if (band->i_stepsize == 32768) {
1595 for (i = 0; i < w; ++i)
1596 datap[i] = src[i] / 2;
1598 // This should be VERY uncommon
1599 for (i = 0; i < w; ++i)
1600 datap[i] = (src[i] * (int64_t)band->i_stepsize) / 65536;
1605 static void dequantization_int_97(int x, int y, Jpeg2000Cblk *cblk,
1606 Jpeg2000Component *comp,
1607 Jpeg2000T1Context *t1, Jpeg2000Band *band)
1610 int w = cblk->coord[0][1] - cblk->coord[0][0];
1611 for (j = 0; j < (cblk->coord[1][1] - cblk->coord[1][0]); ++j) {
1612 int32_t *datap = &comp->i_data[(comp->coord[0][1] - comp->coord[0][0]) * (y + j) + x];
1613 int *src = t1->data + j*t1->stride;
1614 for (i = 0; i < w; ++i)
1615 datap[i] = (src[i] * (int64_t)band->i_stepsize + (1<<15)) >> 16;
1619 static inline void mct_decode(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
1624 for (i = 1; i < 3; i++) {
1625 if (tile->codsty[0].transform != tile->codsty[i].transform) {
1626 av_log(s->avctx, AV_LOG_ERROR, "Transforms mismatch, MCT not supported\n");
1629 if (memcmp(tile->comp[0].coord, tile->comp[i].coord, sizeof(tile->comp[0].coord))) {
1630 av_log(s->avctx, AV_LOG_ERROR, "Coords mismatch, MCT not supported\n");
1635 for (i = 0; i < 3; i++)
1636 if (tile->codsty[0].transform == FF_DWT97)
1637 src[i] = tile->comp[i].f_data;
1639 src[i] = tile->comp[i].i_data;
1641 for (i = 0; i < 2; i++)
1642 csize *= tile->comp[0].coord[i][1] - tile->comp[0].coord[i][0];
1644 s->dsp.mct_decode[tile->codsty[0].transform](src[0], src[1], src[2], csize);
1647 static inline void tile_codeblocks(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
1649 Jpeg2000T1Context t1;
1651 int compno, reslevelno, bandno;
1653 /* Loop on tile components */
1654 for (compno = 0; compno < s->ncomponents; compno++) {
1655 Jpeg2000Component *comp = tile->comp + compno;
1656 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1658 t1.stride = (1<<codsty->log2_cblk_width) + 2;
1660 /* Loop on resolution levels */
1661 for (reslevelno = 0; reslevelno < codsty->nreslevels2decode; reslevelno++) {
1662 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1664 for (bandno = 0; bandno < rlevel->nbands; bandno++) {
1665 int nb_precincts, precno;
1666 Jpeg2000Band *band = rlevel->band + bandno;
1667 int cblkno = 0, bandpos;
1669 bandpos = bandno + (reslevelno > 0);
1671 if (band->coord[0][0] == band->coord[0][1] ||
1672 band->coord[1][0] == band->coord[1][1])
1675 nb_precincts = rlevel->num_precincts_x * rlevel->num_precincts_y;
1676 /* Loop on precincts */
1677 for (precno = 0; precno < nb_precincts; precno++) {
1678 Jpeg2000Prec *prec = band->prec + precno;
1680 /* Loop on codeblocks */
1682 cblkno < prec->nb_codeblocks_width * prec->nb_codeblocks_height;
1685 Jpeg2000Cblk *cblk = prec->cblk + cblkno;
1686 decode_cblk(s, codsty, &t1, cblk,
1687 cblk->coord[0][1] - cblk->coord[0][0],
1688 cblk->coord[1][1] - cblk->coord[1][0],
1691 x = cblk->coord[0][0] - band->coord[0][0];
1692 y = cblk->coord[1][0] - band->coord[1][0];
1694 if (codsty->transform == FF_DWT97)
1695 dequantization_float(x, y, cblk, comp, &t1, band);
1696 else if (codsty->transform == FF_DWT97_INT)
1697 dequantization_int_97(x, y, cblk, comp, &t1, band);
1699 dequantization_int(x, y, cblk, comp, &t1, band);
1703 } /* end reslevel */
1706 ff_dwt_decode(&comp->dwt, codsty->transform == FF_DWT97 ? (void*)comp->f_data : (void*)comp->i_data);
1710 #define WRITE_FRAME(D, PIXEL) \
1711 static inline void write_frame_ ## D(Jpeg2000DecoderContext * s, Jpeg2000Tile * tile, \
1712 AVFrame * picture, int precision) \
1714 const AVPixFmtDescriptor *pixdesc = av_pix_fmt_desc_get(s->avctx->pix_fmt); \
1715 int planar = !!(pixdesc->flags & AV_PIX_FMT_FLAG_PLANAR); \
1716 int pixelsize = planar ? 1 : pixdesc->nb_components; \
1721 for (compno = 0; compno < s->ncomponents; compno++) { \
1722 Jpeg2000Component *comp = tile->comp + compno; \
1723 Jpeg2000CodingStyle *codsty = tile->codsty + compno; \
1725 float *datap = comp->f_data; \
1726 int32_t *i_datap = comp->i_data; \
1727 int cbps = s->cbps[compno]; \
1728 int w = tile->comp[compno].coord[0][1] - s->image_offset_x; \
1732 plane = s->cdef[compno] ? s->cdef[compno]-1 : (s->ncomponents-1); \
1734 y = tile->comp[compno].coord[1][0] - s->image_offset_y / s->cdy[compno]; \
1735 line = (PIXEL *)picture->data[plane] + y * (picture->linesize[plane] / sizeof(PIXEL));\
1736 for (; y < tile->comp[compno].coord[1][1] - s->image_offset_y; y++) { \
1739 x = tile->comp[compno].coord[0][0] - s->image_offset_x / s->cdx[compno]; \
1740 dst = line + x * pixelsize + compno*!planar; \
1742 if (codsty->transform == FF_DWT97) { \
1743 for (; x < w; x++) { \
1744 int val = lrintf(*datap) + (1 << (cbps - 1)); \
1745 /* DC level shift and clip see ISO 15444-1:2002 G.1.2 */ \
1746 val = av_clip(val, 0, (1 << cbps) - 1); \
1747 *dst = val << (precision - cbps); \
1752 for (; x < w; x++) { \
1753 int val = *i_datap + (1 << (cbps - 1)); \
1754 /* DC level shift and clip see ISO 15444-1:2002 G.1.2 */ \
1755 val = av_clip(val, 0, (1 << cbps) - 1); \
1756 *dst = val << (precision - cbps); \
1761 line += picture->linesize[plane] / sizeof(PIXEL); \
1767 WRITE_FRAME(8, uint8_t)
1768 WRITE_FRAME(16, uint16_t)
1772 static int jpeg2000_decode_tile(AVCodecContext *avctx, void *td,
1773 int jobnr, int threadnr)
1775 Jpeg2000DecoderContext *s = avctx->priv_data;
1776 AVFrame *picture = td;
1777 Jpeg2000Tile *tile = s->tile + jobnr;
1780 tile_codeblocks(s, tile);
1782 /* inverse MCT transformation */
1783 if (tile->codsty[0].mct)
1784 mct_decode(s, tile);
1786 for (x = 0; x < s->ncomponents; x++) {
1787 if (s->cdef[x] < 0) {
1788 for (x = 0; x < s->ncomponents; x++) {
1791 if ((s->ncomponents & 1) == 0)
1792 s->cdef[s->ncomponents-1] = 0;
1797 if (s->precision <= 8) {
1798 write_frame_8(s, tile, picture, 8);
1800 int precision = picture->format == AV_PIX_FMT_XYZ12 ||
1801 picture->format == AV_PIX_FMT_RGB48 ||
1802 picture->format == AV_PIX_FMT_RGBA64 ||
1803 picture->format == AV_PIX_FMT_GRAY16 ? 16 : s->precision;
1805 write_frame_16(s, tile, picture, precision);
1811 static void jpeg2000_dec_cleanup(Jpeg2000DecoderContext *s)
1814 for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++) {
1815 if (s->tile[tileno].comp) {
1816 for (compno = 0; compno < s->ncomponents; compno++) {
1817 Jpeg2000Component *comp = s->tile[tileno].comp + compno;
1818 Jpeg2000CodingStyle *codsty = s->tile[tileno].codsty + compno;
1820 ff_jpeg2000_cleanup(comp, codsty);
1822 av_freep(&s->tile[tileno].comp);
1826 memset(s->codsty, 0, sizeof(s->codsty));
1827 memset(s->qntsty, 0, sizeof(s->qntsty));
1828 memset(s->properties, 0, sizeof(s->properties));
1829 memset(&s->poc , 0, sizeof(s->poc));
1830 s->numXtiles = s->numYtiles = 0;
1834 static int jpeg2000_read_main_headers(Jpeg2000DecoderContext *s)
1836 Jpeg2000CodingStyle *codsty = s->codsty;
1837 Jpeg2000QuantStyle *qntsty = s->qntsty;
1838 Jpeg2000POC *poc = &s->poc;
1839 uint8_t *properties = s->properties;
1846 if (bytestream2_get_bytes_left(&s->g) < 2) {
1847 av_log(s->avctx, AV_LOG_ERROR, "Missing EOC\n");
1851 marker = bytestream2_get_be16u(&s->g);
1852 oldpos = bytestream2_tell(&s->g);
1854 if (marker == JPEG2000_SOD) {
1856 Jpeg2000TilePart *tp;
1859 av_log(s->avctx, AV_LOG_ERROR, "Missing SIZ\n");
1860 return AVERROR_INVALIDDATA;
1862 if (s->curtileno < 0) {
1863 av_log(s->avctx, AV_LOG_ERROR, "Missing SOT\n");
1864 return AVERROR_INVALIDDATA;
1867 tile = s->tile + s->curtileno;
1868 tp = tile->tile_part + tile->tp_idx;
1869 if (tp->tp_end < s->g.buffer) {
1870 av_log(s->avctx, AV_LOG_ERROR, "Invalid tpend\n");
1871 return AVERROR_INVALIDDATA;
1873 bytestream2_init(&tp->tpg, s->g.buffer, tp->tp_end - s->g.buffer);
1874 bytestream2_skip(&s->g, tp->tp_end - s->g.buffer);
1878 if (marker == JPEG2000_EOC)
1881 len = bytestream2_get_be16(&s->g);
1882 if (len < 2 || bytestream2_get_bytes_left(&s->g) < len - 2) {
1883 av_log(s->avctx, AV_LOG_ERROR, "Invalid len %d left=%d\n", len, bytestream2_get_bytes_left(&s->g));
1884 return AVERROR_INVALIDDATA;
1889 if (s->ncomponents) {
1890 av_log(s->avctx, AV_LOG_ERROR, "Duplicate SIZ\n");
1891 return AVERROR_INVALIDDATA;
1895 s->numXtiles = s->numYtiles = 0;
1898 ret = get_coc(s, codsty, properties);
1901 ret = get_cod(s, codsty, properties);
1904 ret = get_qcc(s, len, qntsty, properties);
1907 ret = get_qcd(s, len, qntsty, properties);
1910 ret = get_poc(s, len, poc);
1913 if (!(ret = get_sot(s, len))) {
1914 av_assert1(s->curtileno >= 0);
1915 codsty = s->tile[s->curtileno].codsty;
1916 qntsty = s->tile[s->curtileno].qntsty;
1917 poc = &s->tile[s->curtileno].poc;
1918 properties = s->tile[s->curtileno].properties;
1922 // the PLM marker is ignored
1924 // the comment is ignored
1925 bytestream2_skip(&s->g, len - 2);
1928 // Tile-part lengths
1929 ret = get_tlm(s, len);
1932 // Packet length, tile-part header
1933 ret = get_plt(s, len);
1936 av_log(s->avctx, AV_LOG_ERROR,
1937 "unsupported marker 0x%.4"PRIX16" at pos 0x%X\n",
1938 marker, bytestream2_tell(&s->g) - 4);
1939 bytestream2_skip(&s->g, len - 2);
1942 if (bytestream2_tell(&s->g) - oldpos != len || ret) {
1943 av_log(s->avctx, AV_LOG_ERROR,
1944 "error during processing marker segment %.4"PRIx16"\n",
1946 return ret ? ret : -1;
1952 /* Read bit stream packets --> T2 operation. */
1953 static int jpeg2000_read_bitstream_packets(Jpeg2000DecoderContext *s)
1958 for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++) {
1959 Jpeg2000Tile *tile = s->tile + tileno;
1961 if ((ret = init_tile(s, tileno)) < 0)
1964 s->g = tile->tile_part[0].tpg;
1965 if ((ret = jpeg2000_decode_packets(s, tile)) < 0)
1972 static int jp2_find_codestream(Jpeg2000DecoderContext *s)
1974 uint32_t atom_size, atom, atom_end;
1975 int search_range = 10;
1979 bytestream2_get_bytes_left(&s->g) >= 8) {
1980 atom_size = bytestream2_get_be32u(&s->g);
1981 atom = bytestream2_get_be32u(&s->g);
1982 atom_end = bytestream2_tell(&s->g) + atom_size - 8;
1984 if (atom == JP2_CODESTREAM)
1987 if (bytestream2_get_bytes_left(&s->g) < atom_size || atom_end < atom_size)
1990 if (atom == JP2_HEADER &&
1992 uint32_t atom2_size, atom2, atom2_end;
1994 atom2_size = bytestream2_get_be32u(&s->g);
1995 atom2 = bytestream2_get_be32u(&s->g);
1996 atom2_end = bytestream2_tell(&s->g) + atom2_size - 8;
1997 if (atom2_size < 8 || atom2_end > atom_end || atom2_end < atom2_size)
2000 if (atom2 == JP2_CODESTREAM) {
2002 } else if (atom2 == MKBETAG('c','o','l','r') && atom2_size >= 7) {
2003 int method = bytestream2_get_byteu(&s->g);
2004 bytestream2_skipu(&s->g, 2);
2006 s->colour_space = bytestream2_get_be32u(&s->g);
2008 } else if (atom2 == MKBETAG('p','c','l','r') && atom2_size >= 6) {
2009 int i, size, colour_count, colour_channels, colour_depth[3];
2011 colour_count = bytestream2_get_be16u(&s->g);
2012 colour_channels = bytestream2_get_byteu(&s->g);
2013 // FIXME: Do not ignore channel_sign
2014 colour_depth[0] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1;
2015 colour_depth[1] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1;
2016 colour_depth[2] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1;
2017 size = (colour_depth[0] + 7 >> 3) * colour_count +
2018 (colour_depth[1] + 7 >> 3) * colour_count +
2019 (colour_depth[2] + 7 >> 3) * colour_count;
2020 if (colour_count > 256 ||
2021 colour_channels != 3 ||
2022 colour_depth[0] > 16 ||
2023 colour_depth[1] > 16 ||
2024 colour_depth[2] > 16 ||
2025 atom2_size < size) {
2026 avpriv_request_sample(s->avctx, "Unknown palette");
2027 bytestream2_seek(&s->g, atom2_end, SEEK_SET);
2031 for (i = 0; i < colour_count; i++) {
2032 if (colour_depth[0] <= 8) {
2033 r = bytestream2_get_byteu(&s->g) << 8 - colour_depth[0];
2034 r |= r >> colour_depth[0];
2036 r = bytestream2_get_be16u(&s->g) >> colour_depth[0] - 8;
2038 if (colour_depth[1] <= 8) {
2039 g = bytestream2_get_byteu(&s->g) << 8 - colour_depth[1];
2040 r |= r >> colour_depth[1];
2042 g = bytestream2_get_be16u(&s->g) >> colour_depth[1] - 8;
2044 if (colour_depth[2] <= 8) {
2045 b = bytestream2_get_byteu(&s->g) << 8 - colour_depth[2];
2046 r |= r >> colour_depth[2];
2048 b = bytestream2_get_be16u(&s->g) >> colour_depth[2] - 8;
2050 s->palette[i] = 0xffu << 24 | r << 16 | g << 8 | b;
2052 } else if (atom2 == MKBETAG('c','d','e','f') && atom2_size >= 2) {
2053 int n = bytestream2_get_be16u(&s->g);
2055 int cn = bytestream2_get_be16(&s->g);
2056 int av_unused typ = bytestream2_get_be16(&s->g);
2057 int asoc = bytestream2_get_be16(&s->g);
2058 if (cn < 4 && asoc < 4)
2062 bytestream2_seek(&s->g, atom2_end, SEEK_SET);
2063 } while (atom_end - atom2_end >= 8);
2067 bytestream2_seek(&s->g, atom_end, SEEK_SET);
2073 static av_cold int jpeg2000_decode_init(AVCodecContext *avctx)
2075 Jpeg2000DecoderContext *s = avctx->priv_data;
2077 ff_jpeg2000dsp_init(&s->dsp);
2082 static int jpeg2000_decode_frame(AVCodecContext *avctx, void *data,
2083 int *got_frame, AVPacket *avpkt)
2085 Jpeg2000DecoderContext *s = avctx->priv_data;
2086 ThreadFrame frame = { .f = data };
2087 AVFrame *picture = data;
2091 bytestream2_init(&s->g, avpkt->data, avpkt->size);
2093 memset(s->cdef, -1, sizeof(s->cdef));
2095 if (bytestream2_get_bytes_left(&s->g) < 2) {
2096 ret = AVERROR_INVALIDDATA;
2100 // check if the image is in jp2 format
2101 if (bytestream2_get_bytes_left(&s->g) >= 12 &&
2102 (bytestream2_get_be32u(&s->g) == 12) &&
2103 (bytestream2_get_be32u(&s->g) == JP2_SIG_TYPE) &&
2104 (bytestream2_get_be32u(&s->g) == JP2_SIG_VALUE)) {
2105 if (!jp2_find_codestream(s)) {
2106 av_log(avctx, AV_LOG_ERROR,
2107 "Could not find Jpeg2000 codestream atom.\n");
2108 ret = AVERROR_INVALIDDATA;
2112 bytestream2_seek(&s->g, 0, SEEK_SET);
2115 while (bytestream2_get_bytes_left(&s->g) >= 3 && bytestream2_peek_be16(&s->g) != JPEG2000_SOC)
2116 bytestream2_skip(&s->g, 1);
2118 if (bytestream2_get_be16u(&s->g) != JPEG2000_SOC) {
2119 av_log(avctx, AV_LOG_ERROR, "SOC marker not present\n");
2120 ret = AVERROR_INVALIDDATA;
2123 if (ret = jpeg2000_read_main_headers(s))
2126 /* get picture buffer */
2127 if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
2129 picture->pict_type = AV_PICTURE_TYPE_I;
2130 picture->key_frame = 1;
2132 if (ret = jpeg2000_read_bitstream_packets(s))
2135 avctx->execute2(avctx, jpeg2000_decode_tile, picture, NULL, s->numXtiles * s->numYtiles);
2137 jpeg2000_dec_cleanup(s);
2141 if (s->avctx->pix_fmt == AV_PIX_FMT_PAL8)
2142 memcpy(picture->data[1], s->palette, 256 * sizeof(uint32_t));
2144 return bytestream2_tell(&s->g);
2147 jpeg2000_dec_cleanup(s);
2151 static av_cold void jpeg2000_init_static_data(AVCodec *codec)
2153 ff_jpeg2000_init_tier1_luts();
2154 ff_mqc_init_context_tables();
2157 #define OFFSET(x) offsetof(Jpeg2000DecoderContext, x)
2158 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
2160 static const AVOption options[] = {
2161 { "lowres", "Lower the decoding resolution by a power of two",
2162 OFFSET(reduction_factor), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, JPEG2000_MAX_RESLEVELS - 1, VD },
2166 static const AVClass jpeg2000_class = {
2167 .class_name = "jpeg2000",
2168 .item_name = av_default_item_name,
2170 .version = LIBAVUTIL_VERSION_INT,
2173 AVCodec ff_jpeg2000_decoder = {
2175 .long_name = NULL_IF_CONFIG_SMALL("JPEG 2000"),
2176 .type = AVMEDIA_TYPE_VIDEO,
2177 .id = AV_CODEC_ID_JPEG2000,
2178 .capabilities = AV_CODEC_CAP_SLICE_THREADS | AV_CODEC_CAP_FRAME_THREADS | AV_CODEC_CAP_DR1,
2179 .priv_data_size = sizeof(Jpeg2000DecoderContext),
2180 .init_static_data = jpeg2000_init_static_data,
2181 .init = jpeg2000_decode_init,
2182 .decode = jpeg2000_decode_frame,
2183 .priv_class = &jpeg2000_class,
2185 .profiles = NULL_IF_CONFIG_SMALL(ff_jpeg2000_profiles)