2 * JPEG 2000 image decoder
3 * Copyright (c) 2007 Kamil Nowosad
4 * Copyright (c) 2013 Nicolas Bertrand <nicoinattendu@gmail.com>
6 * This file is part of FFmpeg.
8 * FFmpeg is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
13 * FFmpeg is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with FFmpeg; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
25 * JPEG 2000 image decoder
31 #include "libavutil/attributes.h"
32 #include "libavutil/avassert.h"
33 #include "libavutil/common.h"
34 #include "libavutil/imgutils.h"
35 #include "libavutil/opt.h"
36 #include "libavutil/pixdesc.h"
37 #include "libavutil/thread.h"
39 #include "bytestream.h"
43 #include "jpeg2000dsp.h"
46 #define JP2_SIG_TYPE 0x6A502020
47 #define JP2_SIG_VALUE 0x0D0A870A
48 #define JP2_CODESTREAM 0x6A703263
49 #define JP2_HEADER 0x6A703268
56 typedef struct Jpeg2000POCEntry {
65 typedef struct Jpeg2000POC {
66 Jpeg2000POCEntry poc[MAX_POCS];
71 typedef struct Jpeg2000TilePart {
72 uint8_t tile_index; // Tile index who refers the tile-part
73 const uint8_t *tp_end;
74 GetByteContext tpg; // bit stream in tile-part
77 /* RMK: For JPEG2000 DCINEMA 3 tile-parts in a tile
78 * one per component, so tile_part elements have a size of 3 */
79 typedef struct Jpeg2000Tile {
80 Jpeg2000Component *comp;
81 uint8_t properties[4];
82 Jpeg2000CodingStyle codsty[4];
83 Jpeg2000QuantStyle qntsty[4];
85 Jpeg2000TilePart tile_part[32];
86 uint8_t has_ppt; // whether this tile has a ppt marker
87 uint8_t *packed_headers; // contains packed headers. Used only along with PPT marker
88 int packed_headers_size; // size in bytes of the packed headers
89 GetByteContext packed_headers_stream; // byte context corresponding to packed headers
90 uint16_t tp_idx; // Tile-part index
91 int coord[2][2]; // border coordinates {{x0, x1}, {y0, y1}}
94 typedef struct Jpeg2000DecoderContext {
96 AVCodecContext *avctx;
100 int image_offset_x, image_offset_y;
101 int tile_offset_x, tile_offset_y;
102 uint8_t cbps[4]; // bits per sample in particular components
103 uint8_t sgnd[4]; // if a component is signed
104 uint8_t properties[4];
109 uint32_t palette[256];
112 int tile_width, tile_height;
113 unsigned numXtiles, numYtiles;
117 Jpeg2000CodingStyle codsty[4];
118 Jpeg2000QuantStyle qntsty[4];
126 Jpeg2000DSPContext dsp;
128 /*options parameters*/
129 int reduction_factor;
130 } Jpeg2000DecoderContext;
132 /* get_bits functions for JPEG2000 packet bitstream
133 * It is a get_bit function with a bit-stuffing routine. If the value of the
134 * byte is 0xFF, the next byte includes an extra zero bit stuffed into the MSB.
135 * cf. ISO-15444-1:2002 / B.10.1 Bit-stuffing routine */
136 static int get_bits(Jpeg2000DecoderContext *s, int n)
142 if (s->bit_index == 0) {
143 s->bit_index = 7 + (bytestream2_get_byte(&s->g) != 0xFFu);
146 res |= (bytestream2_peek_byte(&s->g) >> s->bit_index) & 1;
151 static void jpeg2000_flush(Jpeg2000DecoderContext *s)
153 if (bytestream2_get_byte(&s->g) == 0xff)
154 bytestream2_skip(&s->g, 1);
158 /* decode the value stored in node */
159 static int tag_tree_decode(Jpeg2000DecoderContext *s, Jpeg2000TgtNode *node,
162 Jpeg2000TgtNode *stack[30];
163 int sp = -1, curval = 0;
166 av_log(s->avctx, AV_LOG_ERROR, "missing node\n");
167 return AVERROR_INVALIDDATA;
170 while (node && !node->vis) {
178 curval = stack[sp]->val;
180 while (curval < threshold && sp >= 0) {
181 if (curval < stack[sp]->val)
182 curval = stack[sp]->val;
183 while (curval < threshold) {
185 if ((ret = get_bits(s, 1)) > 0) {
193 stack[sp]->val = curval;
199 static int pix_fmt_match(enum AVPixelFormat pix_fmt, int components,
200 int bpc, uint32_t log2_chroma_wh, int pal8)
203 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
207 if (desc->nb_components != components) {
211 switch (components) {
213 match = match && desc->comp[3].depth >= bpc &&
214 (log2_chroma_wh >> 14 & 3) == 0 &&
215 (log2_chroma_wh >> 12 & 3) == 0;
217 match = match && desc->comp[2].depth >= bpc &&
218 (log2_chroma_wh >> 10 & 3) == desc->log2_chroma_w &&
219 (log2_chroma_wh >> 8 & 3) == desc->log2_chroma_h;
221 match = match && desc->comp[1].depth >= bpc &&
222 (log2_chroma_wh >> 6 & 3) == desc->log2_chroma_w &&
223 (log2_chroma_wh >> 4 & 3) == desc->log2_chroma_h;
226 match = match && desc->comp[0].depth >= bpc &&
227 (log2_chroma_wh >> 2 & 3) == 0 &&
228 (log2_chroma_wh & 3) == 0 &&
229 (desc->flags & AV_PIX_FMT_FLAG_PAL) == pal8 * AV_PIX_FMT_FLAG_PAL;
234 // pix_fmts with lower bpp have to be listed before
235 // similar pix_fmts with higher bpp.
236 #define RGB_PIXEL_FORMATS AV_PIX_FMT_PAL8,AV_PIX_FMT_RGB24,AV_PIX_FMT_RGBA,AV_PIX_FMT_RGB48,AV_PIX_FMT_RGBA64
237 #define GRAY_PIXEL_FORMATS AV_PIX_FMT_GRAY8,AV_PIX_FMT_GRAY8A,AV_PIX_FMT_GRAY16,AV_PIX_FMT_YA16
238 #define YUV_PIXEL_FORMATS AV_PIX_FMT_YUV410P,AV_PIX_FMT_YUV411P,AV_PIX_FMT_YUVA420P, \
239 AV_PIX_FMT_YUV420P,AV_PIX_FMT_YUV422P,AV_PIX_FMT_YUVA422P, \
240 AV_PIX_FMT_YUV440P,AV_PIX_FMT_YUV444P,AV_PIX_FMT_YUVA444P, \
241 AV_PIX_FMT_YUV420P9,AV_PIX_FMT_YUV422P9,AV_PIX_FMT_YUV444P9, \
242 AV_PIX_FMT_YUVA420P9,AV_PIX_FMT_YUVA422P9,AV_PIX_FMT_YUVA444P9, \
243 AV_PIX_FMT_YUV420P10,AV_PIX_FMT_YUV422P10,AV_PIX_FMT_YUV444P10, \
244 AV_PIX_FMT_YUVA420P10,AV_PIX_FMT_YUVA422P10,AV_PIX_FMT_YUVA444P10, \
245 AV_PIX_FMT_YUV420P12,AV_PIX_FMT_YUV422P12,AV_PIX_FMT_YUV444P12, \
246 AV_PIX_FMT_YUV420P14,AV_PIX_FMT_YUV422P14,AV_PIX_FMT_YUV444P14, \
247 AV_PIX_FMT_YUV420P16,AV_PIX_FMT_YUV422P16,AV_PIX_FMT_YUV444P16, \
248 AV_PIX_FMT_YUVA420P16,AV_PIX_FMT_YUVA422P16,AV_PIX_FMT_YUVA444P16
249 #define XYZ_PIXEL_FORMATS AV_PIX_FMT_XYZ12
251 static const enum AVPixelFormat rgb_pix_fmts[] = {RGB_PIXEL_FORMATS};
252 static const enum AVPixelFormat gray_pix_fmts[] = {GRAY_PIXEL_FORMATS};
253 static const enum AVPixelFormat yuv_pix_fmts[] = {YUV_PIXEL_FORMATS};
254 static const enum AVPixelFormat xyz_pix_fmts[] = {XYZ_PIXEL_FORMATS,
256 static const enum AVPixelFormat all_pix_fmts[] = {RGB_PIXEL_FORMATS,
261 /* marker segments */
262 /* get sizes and offsets of image, tiles; number of components */
263 static int get_siz(Jpeg2000DecoderContext *s)
267 uint32_t log2_chroma_wh = 0;
268 const enum AVPixelFormat *possible_fmts = NULL;
269 int possible_fmts_nb = 0;
272 if (bytestream2_get_bytes_left(&s->g) < 36) {
273 av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for SIZ\n");
274 return AVERROR_INVALIDDATA;
277 s->avctx->profile = bytestream2_get_be16u(&s->g); // Rsiz
278 s->width = bytestream2_get_be32u(&s->g); // Width
279 s->height = bytestream2_get_be32u(&s->g); // Height
280 s->image_offset_x = bytestream2_get_be32u(&s->g); // X0Siz
281 s->image_offset_y = bytestream2_get_be32u(&s->g); // Y0Siz
282 s->tile_width = bytestream2_get_be32u(&s->g); // XTSiz
283 s->tile_height = bytestream2_get_be32u(&s->g); // YTSiz
284 s->tile_offset_x = bytestream2_get_be32u(&s->g); // XT0Siz
285 s->tile_offset_y = bytestream2_get_be32u(&s->g); // YT0Siz
286 ncomponents = bytestream2_get_be16u(&s->g); // CSiz
288 if (s->image_offset_x || s->image_offset_y) {
289 avpriv_request_sample(s->avctx, "Support for image offsets");
290 return AVERROR_PATCHWELCOME;
292 if (av_image_check_size2(s->width, s->height, s->avctx->max_pixels, AV_PIX_FMT_NONE, 0, s->avctx)) {
293 avpriv_request_sample(s->avctx, "Large Dimensions");
294 return AVERROR_PATCHWELCOME;
297 if (ncomponents <= 0) {
298 av_log(s->avctx, AV_LOG_ERROR, "Invalid number of components: %d\n",
300 return AVERROR_INVALIDDATA;
303 if (ncomponents > 4) {
304 avpriv_request_sample(s->avctx, "Support for %d components",
306 return AVERROR_PATCHWELCOME;
309 if (s->tile_offset_x < 0 || s->tile_offset_y < 0 ||
310 s->image_offset_x < s->tile_offset_x ||
311 s->image_offset_y < s->tile_offset_y ||
312 s->tile_width + (int64_t)s->tile_offset_x <= s->image_offset_x ||
313 s->tile_height + (int64_t)s->tile_offset_y <= s->image_offset_y
315 av_log(s->avctx, AV_LOG_ERROR, "Tile offsets are invalid\n");
316 return AVERROR_INVALIDDATA;
319 s->ncomponents = ncomponents;
321 if (s->tile_width <= 0 || s->tile_height <= 0) {
322 av_log(s->avctx, AV_LOG_ERROR, "Invalid tile dimension %dx%d.\n",
323 s->tile_width, s->tile_height);
324 return AVERROR_INVALIDDATA;
327 if (bytestream2_get_bytes_left(&s->g) < 3 * s->ncomponents) {
328 av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for %d components in SIZ\n", s->ncomponents);
329 return AVERROR_INVALIDDATA;
332 for (i = 0; i < s->ncomponents; i++) { // Ssiz_i XRsiz_i, YRsiz_i
333 uint8_t x = bytestream2_get_byteu(&s->g);
334 s->cbps[i] = (x & 0x7f) + 1;
335 s->precision = FFMAX(s->cbps[i], s->precision);
336 s->sgnd[i] = !!(x & 0x80);
337 s->cdx[i] = bytestream2_get_byteu(&s->g);
338 s->cdy[i] = bytestream2_get_byteu(&s->g);
339 if ( !s->cdx[i] || s->cdx[i] == 3 || s->cdx[i] > 4
340 || !s->cdy[i] || s->cdy[i] == 3 || s->cdy[i] > 4) {
341 av_log(s->avctx, AV_LOG_ERROR, "Invalid sample separation %d/%d\n", s->cdx[i], s->cdy[i]);
342 return AVERROR_INVALIDDATA;
344 log2_chroma_wh |= s->cdy[i] >> 1 << i * 4 | s->cdx[i] >> 1 << i * 4 + 2;
347 s->numXtiles = ff_jpeg2000_ceildiv(s->width - s->tile_offset_x, s->tile_width);
348 s->numYtiles = ff_jpeg2000_ceildiv(s->height - s->tile_offset_y, s->tile_height);
350 // There must be at least a SOT and SOD per tile, their minimum size is 14
351 if (s->numXtiles * (uint64_t)s->numYtiles > INT_MAX/sizeof(*s->tile) ||
352 s->numXtiles * s->numYtiles * 14LL > bytestream2_size(&s->g)
354 s->numXtiles = s->numYtiles = 0;
355 return AVERROR(EINVAL);
358 s->tile = av_mallocz_array(s->numXtiles * s->numYtiles, sizeof(*s->tile));
360 s->numXtiles = s->numYtiles = 0;
361 return AVERROR(ENOMEM);
364 for (i = 0; i < s->numXtiles * s->numYtiles; i++) {
365 Jpeg2000Tile *tile = s->tile + i;
367 tile->comp = av_mallocz(s->ncomponents * sizeof(*tile->comp));
369 return AVERROR(ENOMEM);
372 /* compute image size with reduction factor */
373 ret = ff_set_dimensions(s->avctx,
374 ff_jpeg2000_ceildivpow2(s->width - s->image_offset_x,
375 s->reduction_factor),
376 ff_jpeg2000_ceildivpow2(s->height - s->image_offset_y,
377 s->reduction_factor));
381 if (s->avctx->profile == FF_PROFILE_JPEG2000_DCINEMA_2K ||
382 s->avctx->profile == FF_PROFILE_JPEG2000_DCINEMA_4K) {
383 possible_fmts = xyz_pix_fmts;
384 possible_fmts_nb = FF_ARRAY_ELEMS(xyz_pix_fmts);
386 switch (s->colour_space) {
388 possible_fmts = rgb_pix_fmts;
389 possible_fmts_nb = FF_ARRAY_ELEMS(rgb_pix_fmts);
392 possible_fmts = gray_pix_fmts;
393 possible_fmts_nb = FF_ARRAY_ELEMS(gray_pix_fmts);
396 possible_fmts = yuv_pix_fmts;
397 possible_fmts_nb = FF_ARRAY_ELEMS(yuv_pix_fmts);
400 possible_fmts = all_pix_fmts;
401 possible_fmts_nb = FF_ARRAY_ELEMS(all_pix_fmts);
405 if ( s->avctx->pix_fmt != AV_PIX_FMT_NONE
406 && !pix_fmt_match(s->avctx->pix_fmt, ncomponents, s->precision, log2_chroma_wh, s->pal8))
407 s->avctx->pix_fmt = AV_PIX_FMT_NONE;
408 if (s->avctx->pix_fmt == AV_PIX_FMT_NONE)
409 for (i = 0; i < possible_fmts_nb; ++i) {
410 if (pix_fmt_match(possible_fmts[i], ncomponents, s->precision, log2_chroma_wh, s->pal8)) {
411 s->avctx->pix_fmt = possible_fmts[i];
416 if (i == possible_fmts_nb) {
417 if (ncomponents == 4 &&
418 s->cdy[0] == 1 && s->cdx[0] == 1 &&
419 s->cdy[1] == 1 && s->cdx[1] == 1 &&
420 s->cdy[2] == s->cdy[3] && s->cdx[2] == s->cdx[3]) {
421 if (s->precision == 8 && s->cdy[2] == 2 && s->cdx[2] == 2 && !s->pal8) {
422 s->avctx->pix_fmt = AV_PIX_FMT_YUVA420P;
433 if (i == possible_fmts_nb) {
434 av_log(s->avctx, AV_LOG_ERROR,
435 "Unknown pix_fmt, profile: %d, colour_space: %d, "
436 "components: %d, precision: %d\n"
437 "cdx[0]: %d, cdy[0]: %d\n"
438 "cdx[1]: %d, cdy[1]: %d\n"
439 "cdx[2]: %d, cdy[2]: %d\n"
440 "cdx[3]: %d, cdy[3]: %d\n",
441 s->avctx->profile, s->colour_space, ncomponents, s->precision,
444 ncomponents > 1 ? s->cdx[1] : 0,
445 ncomponents > 1 ? s->cdy[1] : 0,
446 ncomponents > 2 ? s->cdx[2] : 0,
447 ncomponents > 2 ? s->cdy[2] : 0,
448 ncomponents > 3 ? s->cdx[3] : 0,
449 ncomponents > 3 ? s->cdy[3] : 0);
450 return AVERROR_PATCHWELCOME;
452 s->avctx->bits_per_raw_sample = s->precision;
456 /* get common part for COD and COC segments */
457 static int get_cox(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c)
461 if (bytestream2_get_bytes_left(&s->g) < 5) {
462 av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for COX\n");
463 return AVERROR_INVALIDDATA;
466 /* nreslevels = number of resolution levels
467 = number of decomposition level +1 */
468 c->nreslevels = bytestream2_get_byteu(&s->g) + 1;
469 if (c->nreslevels >= JPEG2000_MAX_RESLEVELS) {
470 av_log(s->avctx, AV_LOG_ERROR, "nreslevels %d is invalid\n", c->nreslevels);
471 return AVERROR_INVALIDDATA;
474 if (c->nreslevels <= s->reduction_factor) {
475 /* we are forced to update reduction_factor as its requested value is
476 not compatible with this bitstream, and as we might have used it
477 already in setup earlier we have to fail this frame until
478 reinitialization is implemented */
479 av_log(s->avctx, AV_LOG_ERROR, "reduction_factor too large for this bitstream, max is %d\n", c->nreslevels - 1);
480 s->reduction_factor = c->nreslevels - 1;
481 return AVERROR(EINVAL);
484 /* compute number of resolution levels to decode */
485 c->nreslevels2decode = c->nreslevels - s->reduction_factor;
487 c->log2_cblk_width = (bytestream2_get_byteu(&s->g) & 15) + 2; // cblk width
488 c->log2_cblk_height = (bytestream2_get_byteu(&s->g) & 15) + 2; // cblk height
490 if (c->log2_cblk_width > 10 || c->log2_cblk_height > 10 ||
491 c->log2_cblk_width + c->log2_cblk_height > 12) {
492 av_log(s->avctx, AV_LOG_ERROR, "cblk size invalid\n");
493 return AVERROR_INVALIDDATA;
496 c->cblk_style = bytestream2_get_byteu(&s->g);
497 if (c->cblk_style != 0) { // cblk style
498 av_log(s->avctx, AV_LOG_WARNING, "extra cblk styles %X\n", c->cblk_style);
499 if (c->cblk_style & JPEG2000_CBLK_BYPASS)
500 av_log(s->avctx, AV_LOG_WARNING, "Selective arithmetic coding bypass\n");
502 c->transform = bytestream2_get_byteu(&s->g); // DWT transformation type
503 /* set integer 9/7 DWT in case of BITEXACT flag */
504 if ((s->avctx->flags & AV_CODEC_FLAG_BITEXACT) && (c->transform == FF_DWT97))
505 c->transform = FF_DWT97_INT;
506 else if (c->transform == FF_DWT53) {
507 s->avctx->properties |= FF_CODEC_PROPERTY_LOSSLESS;
510 if (c->csty & JPEG2000_CSTY_PREC) {
512 for (i = 0; i < c->nreslevels; i++) {
513 byte = bytestream2_get_byte(&s->g);
514 c->log2_prec_widths[i] = byte & 0x0F; // precinct PPx
515 c->log2_prec_heights[i] = (byte >> 4) & 0x0F; // precinct PPy
517 if (c->log2_prec_widths[i] == 0 || c->log2_prec_heights[i] == 0) {
518 av_log(s->avctx, AV_LOG_ERROR, "PPx %d PPy %d invalid\n",
519 c->log2_prec_widths[i], c->log2_prec_heights[i]);
520 c->log2_prec_widths[i] = c->log2_prec_heights[i] = 1;
521 return AVERROR_INVALIDDATA;
525 memset(c->log2_prec_widths , 15, sizeof(c->log2_prec_widths ));
526 memset(c->log2_prec_heights, 15, sizeof(c->log2_prec_heights));
531 /* get coding parameters for a particular tile or whole image*/
532 static int get_cod(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c,
535 Jpeg2000CodingStyle tmp;
538 if (bytestream2_get_bytes_left(&s->g) < 5) {
539 av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for COD\n");
540 return AVERROR_INVALIDDATA;
543 tmp.csty = bytestream2_get_byteu(&s->g);
545 // get progression order
546 tmp.prog_order = bytestream2_get_byteu(&s->g);
548 tmp.nlayers = bytestream2_get_be16u(&s->g);
549 tmp.mct = bytestream2_get_byteu(&s->g); // multiple component transformation
551 if (tmp.mct && s->ncomponents < 3) {
552 av_log(s->avctx, AV_LOG_ERROR,
553 "MCT %"PRIu8" with too few components (%d)\n",
554 tmp.mct, s->ncomponents);
555 return AVERROR_INVALIDDATA;
558 if ((ret = get_cox(s, &tmp)) < 0)
561 for (compno = 0; compno < s->ncomponents; compno++)
562 if (!(properties[compno] & HAD_COC))
563 memcpy(c + compno, &tmp, sizeof(tmp));
567 /* Get coding parameters for a component in the whole image or a
568 * particular tile. */
569 static int get_coc(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c,
575 if (bytestream2_get_bytes_left(&s->g) < 2) {
576 av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for COC\n");
577 return AVERROR_INVALIDDATA;
580 compno = bytestream2_get_byteu(&s->g);
582 if (compno >= s->ncomponents) {
583 av_log(s->avctx, AV_LOG_ERROR,
584 "Invalid compno %d. There are %d components in the image.\n",
585 compno, s->ncomponents);
586 return AVERROR_INVALIDDATA;
590 has_eph = c->csty & JPEG2000_CSTY_EPH;
591 c->csty = bytestream2_get_byteu(&s->g);
592 c->csty |= has_eph; //do not override eph present bits from COD
594 if ((ret = get_cox(s, c)) < 0)
597 properties[compno] |= HAD_COC;
601 /* Get common part for QCD and QCC segments. */
602 static int get_qcx(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q)
606 if (bytestream2_get_bytes_left(&s->g) < 1)
607 return AVERROR_INVALIDDATA;
609 x = bytestream2_get_byteu(&s->g); // Sqcd
611 q->nguardbits = x >> 5;
612 q->quantsty = x & 0x1f;
614 if (q->quantsty == JPEG2000_QSTY_NONE) {
616 if (bytestream2_get_bytes_left(&s->g) < n ||
617 n > JPEG2000_MAX_DECLEVELS*3)
618 return AVERROR_INVALIDDATA;
619 for (i = 0; i < n; i++)
620 q->expn[i] = bytestream2_get_byteu(&s->g) >> 3;
621 } else if (q->quantsty == JPEG2000_QSTY_SI) {
622 if (bytestream2_get_bytes_left(&s->g) < 2)
623 return AVERROR_INVALIDDATA;
624 x = bytestream2_get_be16u(&s->g);
625 q->expn[0] = x >> 11;
626 q->mant[0] = x & 0x7ff;
627 for (i = 1; i < JPEG2000_MAX_DECLEVELS * 3; i++) {
628 int curexpn = FFMAX(0, q->expn[0] - (i - 1) / 3);
629 q->expn[i] = curexpn;
630 q->mant[i] = q->mant[0];
634 if (bytestream2_get_bytes_left(&s->g) < 2 * n ||
635 n > JPEG2000_MAX_DECLEVELS*3)
636 return AVERROR_INVALIDDATA;
637 for (i = 0; i < n; i++) {
638 x = bytestream2_get_be16u(&s->g);
639 q->expn[i] = x >> 11;
640 q->mant[i] = x & 0x7ff;
646 /* Get quantization parameters for a particular tile or a whole image. */
647 static int get_qcd(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q,
650 Jpeg2000QuantStyle tmp;
653 memset(&tmp, 0, sizeof(tmp));
655 if ((ret = get_qcx(s, n, &tmp)) < 0)
657 for (compno = 0; compno < s->ncomponents; compno++)
658 if (!(properties[compno] & HAD_QCC))
659 memcpy(q + compno, &tmp, sizeof(tmp));
663 /* Get quantization parameters for a component in the whole image
664 * on in a particular tile. */
665 static int get_qcc(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q,
670 if (bytestream2_get_bytes_left(&s->g) < 1)
671 return AVERROR_INVALIDDATA;
673 compno = bytestream2_get_byteu(&s->g);
675 if (compno >= s->ncomponents) {
676 av_log(s->avctx, AV_LOG_ERROR,
677 "Invalid compno %d. There are %d components in the image.\n",
678 compno, s->ncomponents);
679 return AVERROR_INVALIDDATA;
682 properties[compno] |= HAD_QCC;
683 return get_qcx(s, n - 1, q + compno);
686 static int get_poc(Jpeg2000DecoderContext *s, int size, Jpeg2000POC *p)
689 int elem_size = s->ncomponents <= 257 ? 7 : 9;
690 Jpeg2000POC tmp = {{{0}}};
692 if (bytestream2_get_bytes_left(&s->g) < 5 || size < 2 + elem_size) {
693 av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for POC\n");
694 return AVERROR_INVALIDDATA;
698 avpriv_request_sample(s->avctx, "Fat POC not supported");
699 return AVERROR_PATCHWELCOME;
702 tmp.nb_poc = (size - 2) / elem_size;
703 if (tmp.nb_poc > MAX_POCS) {
704 avpriv_request_sample(s->avctx, "Too many POCs (%d)", tmp.nb_poc);
705 return AVERROR_PATCHWELCOME;
708 for (i = 0; i<tmp.nb_poc; i++) {
709 Jpeg2000POCEntry *e = &tmp.poc[i];
710 e->RSpoc = bytestream2_get_byteu(&s->g);
711 e->CSpoc = bytestream2_get_byteu(&s->g);
712 e->LYEpoc = bytestream2_get_be16u(&s->g);
713 e->REpoc = bytestream2_get_byteu(&s->g);
714 e->CEpoc = bytestream2_get_byteu(&s->g);
715 e->Ppoc = bytestream2_get_byteu(&s->g);
718 if (e->CEpoc > s->ncomponents)
719 e->CEpoc = s->ncomponents;
720 if ( e->RSpoc >= e->REpoc || e->REpoc > 33
721 || e->CSpoc >= e->CEpoc || e->CEpoc > s->ncomponents
723 av_log(s->avctx, AV_LOG_ERROR, "POC Entry %d is invalid (%d, %d, %d, %d, %d, %d)\n", i,
724 e->RSpoc, e->CSpoc, e->LYEpoc, e->REpoc, e->CEpoc, e->Ppoc
726 return AVERROR_INVALIDDATA;
730 if (!p->nb_poc || p->is_default) {
733 if (p->nb_poc + tmp.nb_poc > MAX_POCS) {
734 av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for POC\n");
735 return AVERROR_INVALIDDATA;
737 memcpy(p->poc + p->nb_poc, tmp.poc, tmp.nb_poc * sizeof(tmp.poc[0]));
738 p->nb_poc += tmp.nb_poc;
747 /* Get start of tile segment. */
748 static int get_sot(Jpeg2000DecoderContext *s, int n)
750 Jpeg2000TilePart *tp;
755 if (bytestream2_get_bytes_left(&s->g) < 8)
756 return AVERROR_INVALIDDATA;
759 Isot = bytestream2_get_be16u(&s->g); // Isot
760 if (Isot >= s->numXtiles * s->numYtiles)
761 return AVERROR_INVALIDDATA;
764 Psot = bytestream2_get_be32u(&s->g); // Psot
765 TPsot = bytestream2_get_byteu(&s->g); // TPsot
767 /* Read TNSot but not used */
768 bytestream2_get_byteu(&s->g); // TNsot
771 Psot = bytestream2_get_bytes_left(&s->g) - 2 + n + 2;
773 if (Psot > bytestream2_get_bytes_left(&s->g) - 2 + n + 2) {
774 av_log(s->avctx, AV_LOG_ERROR, "Psot %"PRIu32" too big\n", Psot);
775 return AVERROR_INVALIDDATA;
778 if (TPsot >= FF_ARRAY_ELEMS(s->tile[Isot].tile_part)) {
779 avpriv_request_sample(s->avctx, "Too many tile parts");
780 return AVERROR_PATCHWELCOME;
783 s->tile[Isot].tp_idx = TPsot;
784 tp = s->tile[Isot].tile_part + TPsot;
785 tp->tile_index = Isot;
786 tp->tp_end = s->g.buffer + Psot - n - 2;
789 Jpeg2000Tile *tile = s->tile + s->curtileno;
792 memcpy(tile->codsty, s->codsty, s->ncomponents * sizeof(Jpeg2000CodingStyle));
793 memcpy(tile->qntsty, s->qntsty, s->ncomponents * sizeof(Jpeg2000QuantStyle));
794 memcpy(&tile->poc , &s->poc , sizeof(tile->poc));
795 tile->poc.is_default = 1;
801 static int read_crg(Jpeg2000DecoderContext *s, int n)
803 if (s->ncomponents*4 != n - 2) {
804 av_log(s->avctx, AV_LOG_ERROR, "Invalid CRG marker.\n");
805 return AVERROR_INVALIDDATA;
807 bytestream2_skip(&s->g, n - 2);
810 /* Tile-part lengths: see ISO 15444-1:2002, section A.7.1
811 * Used to know the number of tile parts and lengths.
812 * There may be multiple TLMs in the header.
813 * TODO: The function is not used for tile-parts management, nor anywhere else.
814 * It can be useful to allocate memory for tile parts, before managing the SOT
815 * markers. Parsing the TLM header is needed to increment the input header
817 * This marker is mandatory for DCI. */
818 static int get_tlm(Jpeg2000DecoderContext *s, int n)
820 uint8_t Stlm, ST, SP, tile_tlm, i;
821 bytestream2_get_byte(&s->g); /* Ztlm: skipped */
822 Stlm = bytestream2_get_byte(&s->g);
824 // too complex ? ST = ((Stlm >> 4) & 0x01) + ((Stlm >> 4) & 0x02);
825 ST = (Stlm >> 4) & 0x03;
827 av_log(s->avctx, AV_LOG_ERROR, "TLM marker contains invalid ST value.\n");
828 return AVERROR_INVALIDDATA;
831 SP = (Stlm >> 6) & 0x01;
832 tile_tlm = (n - 4) / ((SP + 1) * 2 + ST);
833 for (i = 0; i < tile_tlm; i++) {
838 bytestream2_get_byte(&s->g);
841 bytestream2_get_be16(&s->g);
844 bytestream2_get_be32(&s->g);
848 bytestream2_get_be16(&s->g);
850 bytestream2_get_be32(&s->g);
856 static int get_plt(Jpeg2000DecoderContext *s, int n)
861 av_log(s->avctx, AV_LOG_DEBUG,
862 "PLT marker at pos 0x%X\n", bytestream2_tell(&s->g) - 4);
865 return AVERROR_INVALIDDATA;
867 /*Zplt =*/ bytestream2_get_byte(&s->g);
869 for (i = 0; i < n - 3; i++) {
870 v = bytestream2_get_byte(&s->g);
873 return AVERROR_INVALIDDATA;
878 static int get_ppt(Jpeg2000DecoderContext *s, int n)
884 av_log(s->avctx, AV_LOG_ERROR, "Invalid length for PPT data.\n");
885 return AVERROR_INVALIDDATA;
887 if (s->curtileno < 0)
888 return AVERROR_INVALIDDATA;
890 tile = &s->tile[s->curtileno];
891 if (tile->tp_idx != 0) {
892 av_log(s->avctx, AV_LOG_ERROR,
893 "PPT marker can occur only on first tile part of a tile.\n");
894 return AVERROR_INVALIDDATA;
897 tile->has_ppt = 1; // this tile has a ppt marker
898 bytestream2_get_byte(&s->g); // Zppt is skipped and not used
899 new = av_realloc(tile->packed_headers,
900 tile->packed_headers_size + n - 3);
902 tile->packed_headers = new;
904 return AVERROR(ENOMEM);
905 memcpy(tile->packed_headers + tile->packed_headers_size,
907 tile->packed_headers_size += n - 3;
908 bytestream2_skip(&s->g, n - 3);
913 static int init_tile(Jpeg2000DecoderContext *s, int tileno)
916 int tilex = tileno % s->numXtiles;
917 int tiley = tileno / s->numXtiles;
918 Jpeg2000Tile *tile = s->tile + tileno;
921 return AVERROR(ENOMEM);
923 tile->coord[0][0] = av_clip(tilex * (int64_t)s->tile_width + s->tile_offset_x, s->image_offset_x, s->width);
924 tile->coord[0][1] = av_clip((tilex + 1) * (int64_t)s->tile_width + s->tile_offset_x, s->image_offset_x, s->width);
925 tile->coord[1][0] = av_clip(tiley * (int64_t)s->tile_height + s->tile_offset_y, s->image_offset_y, s->height);
926 tile->coord[1][1] = av_clip((tiley + 1) * (int64_t)s->tile_height + s->tile_offset_y, s->image_offset_y, s->height);
928 for (compno = 0; compno < s->ncomponents; compno++) {
929 Jpeg2000Component *comp = tile->comp + compno;
930 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
931 Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
932 int ret; // global bandno
934 comp->coord_o[0][0] = tile->coord[0][0];
935 comp->coord_o[0][1] = tile->coord[0][1];
936 comp->coord_o[1][0] = tile->coord[1][0];
937 comp->coord_o[1][1] = tile->coord[1][1];
939 comp->coord_o[0][0] /= s->cdx[compno];
940 comp->coord_o[0][1] /= s->cdx[compno];
941 comp->coord_o[1][0] /= s->cdy[compno];
942 comp->coord_o[1][1] /= s->cdy[compno];
945 comp->coord[0][0] = ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], s->reduction_factor);
946 comp->coord[0][1] = ff_jpeg2000_ceildivpow2(comp->coord_o[0][1], s->reduction_factor);
947 comp->coord[1][0] = ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], s->reduction_factor);
948 comp->coord[1][1] = ff_jpeg2000_ceildivpow2(comp->coord_o[1][1], s->reduction_factor);
950 if (ret = ff_jpeg2000_init_component(comp, codsty, qntsty,
951 s->cbps[compno], s->cdx[compno],
952 s->cdy[compno], s->avctx))
958 /* Read the number of coding passes. */
959 static int getnpasses(Jpeg2000DecoderContext *s)
966 if ((num = get_bits(s, 2)) != 3)
967 return num < 0 ? num : 3 + num;
968 if ((num = get_bits(s, 5)) != 31)
969 return num < 0 ? num : 6 + num;
970 num = get_bits(s, 7);
971 return num < 0 ? num : 37 + num;
974 static int getlblockinc(Jpeg2000DecoderContext *s)
977 while (ret = get_bits(s, 1)) {
985 static inline void select_stream(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile,
988 s->g = tile->tile_part[*tp_index].tpg;
989 if (bytestream2_get_bytes_left(&s->g) == 0 && s->bit_index == 8) {
990 if (*tp_index < FF_ARRAY_ELEMS(tile->tile_part) - 1) {
991 s->g = tile->tile_part[++(*tp_index)].tpg;
994 if (bytestream2_peek_be32(&s->g) == JPEG2000_SOP_FIXED_BYTES)
995 bytestream2_skip(&s->g, JPEG2000_SOP_BYTE_LENGTH);
998 static int jpeg2000_decode_packet(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile, int *tp_index,
999 Jpeg2000CodingStyle *codsty,
1000 Jpeg2000ResLevel *rlevel, int precno,
1001 int layno, uint8_t *expn, int numgbits)
1003 int bandno, cblkno, ret, nb_code_blocks;
1006 if (layno < rlevel->band[0].prec[precno].decoded_layers)
1008 rlevel->band[0].prec[precno].decoded_layers = layno + 1;
1009 // Select stream to read from
1011 s->g = tile->packed_headers_stream;
1013 select_stream(s, tile, tp_index);
1015 if (!(ret = get_bits(s, 1))) {
1021 for (bandno = 0; bandno < rlevel->nbands; bandno++) {
1022 Jpeg2000Band *band = rlevel->band + bandno;
1023 Jpeg2000Prec *prec = band->prec + precno;
1025 if (band->coord[0][0] == band->coord[0][1] ||
1026 band->coord[1][0] == band->coord[1][1])
1028 nb_code_blocks = prec->nb_codeblocks_height *
1029 prec->nb_codeblocks_width;
1030 for (cblkno = 0; cblkno < nb_code_blocks; cblkno++) {
1031 Jpeg2000Cblk *cblk = prec->cblk + cblkno;
1032 int incl, newpasses, llen;
1036 incl = get_bits(s, 1);
1038 incl = tag_tree_decode(s, prec->cblkincl + cblkno, layno + 1) == layno;
1044 if (!cblk->npasses) {
1045 int v = expn[bandno] + numgbits - 1 -
1046 tag_tree_decode(s, prec->zerobits + cblkno, 100);
1047 if (v < 0 || v > 30) {
1048 av_log(s->avctx, AV_LOG_ERROR,
1049 "nonzerobits %d invalid or unsupported\n", v);
1050 return AVERROR_INVALIDDATA;
1052 cblk->nonzerobits = v;
1054 if ((newpasses = getnpasses(s)) < 0)
1056 av_assert2(newpasses > 0);
1057 if (cblk->npasses + newpasses >= JPEG2000_MAX_PASSES) {
1058 avpriv_request_sample(s->avctx, "Too many passes");
1059 return AVERROR_PATCHWELCOME;
1061 if ((llen = getlblockinc(s)) < 0)
1063 if (cblk->lblock + llen + av_log2(newpasses) > 16) {
1064 avpriv_request_sample(s->avctx,
1065 "Block with length beyond 16 bits");
1066 return AVERROR_PATCHWELCOME;
1069 cblk->lblock += llen;
1071 cblk->nb_lengthinc = 0;
1072 cblk->nb_terminationsinc = 0;
1073 av_free(cblk->lengthinc);
1074 cblk->lengthinc = av_mallocz_array(newpasses , sizeof(*cblk->lengthinc));
1075 if (!cblk->lengthinc)
1076 return AVERROR(ENOMEM);
1077 tmp = av_realloc_array(cblk->data_start, cblk->nb_terminations + newpasses + 1, sizeof(*cblk->data_start));
1079 return AVERROR(ENOMEM);
1080 cblk->data_start = tmp;
1084 while (newpasses1 < newpasses) {
1086 if (needs_termination(codsty->cblk_style, cblk->npasses + newpasses1 - 1)) {
1087 cblk->nb_terminationsinc ++;
1092 if ((ret = get_bits(s, av_log2(newpasses1) + cblk->lblock)) < 0)
1094 if (ret > cblk->data_allocated) {
1095 size_t new_size = FFMAX(2*cblk->data_allocated, ret);
1096 void *new = av_realloc(cblk->data, new_size);
1099 cblk->data_allocated = new_size;
1102 if (ret > cblk->data_allocated) {
1103 avpriv_request_sample(s->avctx,
1104 "Block with lengthinc greater than %"SIZE_SPECIFIER"",
1105 cblk->data_allocated);
1106 return AVERROR_PATCHWELCOME;
1108 cblk->lengthinc[cblk->nb_lengthinc++] = ret;
1109 cblk->npasses += newpasses1;
1110 newpasses -= newpasses1;
1116 if (codsty->csty & JPEG2000_CSTY_EPH) {
1117 if (bytestream2_peek_be16(&s->g) == JPEG2000_EPH)
1118 bytestream2_skip(&s->g, 2);
1120 av_log(s->avctx, AV_LOG_ERROR, "EPH marker not found. instead %X\n", bytestream2_peek_be32(&s->g));
1123 // Save state of stream
1124 if (tile->has_ppt) {
1125 tile->packed_headers_stream = s->g;
1126 select_stream(s, tile, tp_index);
1128 for (bandno = 0; bandno < rlevel->nbands; bandno++) {
1129 Jpeg2000Band *band = rlevel->band + bandno;
1130 Jpeg2000Prec *prec = band->prec + precno;
1132 nb_code_blocks = prec->nb_codeblocks_height * prec->nb_codeblocks_width;
1133 for (cblkno = 0; cblkno < nb_code_blocks; cblkno++) {
1134 Jpeg2000Cblk *cblk = prec->cblk + cblkno;
1135 if (!cblk->nb_terminationsinc && !cblk->lengthinc)
1137 for (cwsno = 0; cwsno < cblk->nb_lengthinc; cwsno ++) {
1138 if (cblk->data_allocated < cblk->length + cblk->lengthinc[cwsno] + 4) {
1139 size_t new_size = FFMAX(2*cblk->data_allocated, cblk->length + cblk->lengthinc[cwsno] + 4);
1140 void *new = av_realloc(cblk->data, new_size);
1143 cblk->data_allocated = new_size;
1146 if ( bytestream2_get_bytes_left(&s->g) < cblk->lengthinc[cwsno]
1147 || cblk->data_allocated < cblk->length + cblk->lengthinc[cwsno] + 4
1149 av_log(s->avctx, AV_LOG_ERROR,
1150 "Block length %"PRIu16" or lengthinc %d is too large, left %d\n",
1151 cblk->length, cblk->lengthinc[cwsno], bytestream2_get_bytes_left(&s->g));
1152 return AVERROR_INVALIDDATA;
1155 bytestream2_get_bufferu(&s->g, cblk->data + cblk->length, cblk->lengthinc[cwsno]);
1156 cblk->length += cblk->lengthinc[cwsno];
1157 cblk->lengthinc[cwsno] = 0;
1158 if (cblk->nb_terminationsinc) {
1159 cblk->nb_terminationsinc--;
1160 cblk->nb_terminations++;
1161 cblk->data[cblk->length++] = 0xFF;
1162 cblk->data[cblk->length++] = 0xFF;
1163 cblk->data_start[cblk->nb_terminations] = cblk->length;
1166 av_freep(&cblk->lengthinc);
1169 // Save state of stream
1170 tile->tile_part[*tp_index].tpg = s->g;
1175 tile->packed_headers_stream = s->g;
1177 tile->tile_part[*tp_index].tpg = s->g;
1181 static int jpeg2000_decode_packets_po_iteration(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile,
1182 int RSpoc, int CSpoc,
1183 int LYEpoc, int REpoc, int CEpoc,
1184 int Ppoc, int *tp_index)
1187 int layno, reslevelno, compno, precno, ok_reslevel;
1192 case JPEG2000_PGOD_RLCP:
1193 av_log(s->avctx, AV_LOG_DEBUG, "Progression order RLCP\n");
1195 for (reslevelno = RSpoc; ok_reslevel && reslevelno < REpoc; reslevelno++) {
1197 for (layno = 0; layno < LYEpoc; layno++) {
1198 for (compno = CSpoc; compno < CEpoc; compno++) {
1199 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1200 Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
1201 if (reslevelno < codsty->nreslevels) {
1202 Jpeg2000ResLevel *rlevel = tile->comp[compno].reslevel +
1205 for (precno = 0; precno < rlevel->num_precincts_x * rlevel->num_precincts_y; precno++)
1206 if ((ret = jpeg2000_decode_packet(s, tile, tp_index,
1209 qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1210 qntsty->nguardbits)) < 0)
1218 case JPEG2000_PGOD_LRCP:
1219 av_log(s->avctx, AV_LOG_DEBUG, "Progression order LRCP\n");
1220 for (layno = 0; layno < LYEpoc; layno++) {
1222 for (reslevelno = RSpoc; ok_reslevel && reslevelno < REpoc; reslevelno++) {
1224 for (compno = CSpoc; compno < CEpoc; compno++) {
1225 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1226 Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
1227 if (reslevelno < codsty->nreslevels) {
1228 Jpeg2000ResLevel *rlevel = tile->comp[compno].reslevel +
1231 for (precno = 0; precno < rlevel->num_precincts_x * rlevel->num_precincts_y; precno++)
1232 if ((ret = jpeg2000_decode_packet(s, tile, tp_index,
1235 qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1236 qntsty->nguardbits)) < 0)
1244 case JPEG2000_PGOD_CPRL:
1245 av_log(s->avctx, AV_LOG_DEBUG, "Progression order CPRL\n");
1246 for (compno = CSpoc; compno < CEpoc; compno++) {
1247 Jpeg2000Component *comp = tile->comp + compno;
1248 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1249 Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
1253 if (RSpoc >= FFMIN(codsty->nreslevels, REpoc))
1256 for (reslevelno = RSpoc; reslevelno < FFMIN(codsty->nreslevels, REpoc); reslevelno++) {
1257 uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1258 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1259 step_x = FFMIN(step_x, rlevel->log2_prec_width + reducedresno);
1260 step_y = FFMIN(step_y, rlevel->log2_prec_height + reducedresno);
1262 if (step_x >= 31 || step_y >= 31){
1263 avpriv_request_sample(s->avctx, "CPRL with large step");
1264 return AVERROR_PATCHWELCOME;
1269 for (y = tile->coord[1][0]; y < tile->coord[1][1]; y = (y/step_y + 1)*step_y) {
1270 for (x = tile->coord[0][0]; x < tile->coord[0][1]; x = (x/step_x + 1)*step_x) {
1271 for (reslevelno = RSpoc; reslevelno < FFMIN(codsty->nreslevels, REpoc); reslevelno++) {
1272 unsigned prcx, prcy;
1273 uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1274 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1275 int xc = x / s->cdx[compno];
1276 int yc = y / s->cdy[compno];
1278 if (yc % (1LL << (rlevel->log2_prec_height + reducedresno)) && y != tile->coord[1][0]) //FIXME this is a subset of the check
1281 if (xc % (1LL << (rlevel->log2_prec_width + reducedresno)) && x != tile->coord[0][0]) //FIXME this is a subset of the check
1284 // check if a precinct exists
1285 prcx = ff_jpeg2000_ceildivpow2(xc, reducedresno) >> rlevel->log2_prec_width;
1286 prcy = ff_jpeg2000_ceildivpow2(yc, reducedresno) >> rlevel->log2_prec_height;
1287 prcx -= ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], reducedresno) >> rlevel->log2_prec_width;
1288 prcy -= ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], reducedresno) >> rlevel->log2_prec_height;
1290 precno = prcx + rlevel->num_precincts_x * prcy;
1292 if (prcx >= rlevel->num_precincts_x || prcy >= rlevel->num_precincts_y) {
1293 av_log(s->avctx, AV_LOG_WARNING, "prc %d %d outside limits %d %d\n",
1294 prcx, prcy, rlevel->num_precincts_x, rlevel->num_precincts_y);
1298 for (layno = 0; layno < LYEpoc; layno++) {
1299 if ((ret = jpeg2000_decode_packet(s, tile, tp_index, codsty, rlevel,
1301 qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1302 qntsty->nguardbits)) < 0)
1311 case JPEG2000_PGOD_RPCL:
1312 av_log(s->avctx, AV_LOG_WARNING, "Progression order RPCL\n");
1314 for (reslevelno = RSpoc; ok_reslevel && reslevelno < REpoc; reslevelno++) {
1318 for (compno = CSpoc; compno < CEpoc; compno++) {
1319 Jpeg2000Component *comp = tile->comp + compno;
1320 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1322 if (reslevelno < codsty->nreslevels) {
1323 uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1324 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1325 step_x = FFMIN(step_x, rlevel->log2_prec_width + reducedresno);
1326 step_y = FFMIN(step_y, rlevel->log2_prec_height + reducedresno);
1332 for (y = tile->coord[1][0]; y < tile->coord[1][1]; y = (y/step_y + 1)*step_y) {
1333 for (x = tile->coord[0][0]; x < tile->coord[0][1]; x = (x/step_x + 1)*step_x) {
1334 for (compno = CSpoc; compno < CEpoc; compno++) {
1335 Jpeg2000Component *comp = tile->comp + compno;
1336 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1337 Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
1338 uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1339 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1340 unsigned prcx, prcy;
1342 int xc = x / s->cdx[compno];
1343 int yc = y / s->cdy[compno];
1345 if (reslevelno >= codsty->nreslevels)
1348 if (yc % (1LL << (rlevel->log2_prec_height + reducedresno)) && y != tile->coord[1][0]) //FIXME this is a subset of the check
1351 if (xc % (1LL << (rlevel->log2_prec_width + reducedresno)) && x != tile->coord[0][0]) //FIXME this is a subset of the check
1354 // check if a precinct exists
1355 prcx = ff_jpeg2000_ceildivpow2(xc, reducedresno) >> rlevel->log2_prec_width;
1356 prcy = ff_jpeg2000_ceildivpow2(yc, reducedresno) >> rlevel->log2_prec_height;
1357 prcx -= ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], reducedresno) >> rlevel->log2_prec_width;
1358 prcy -= ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], reducedresno) >> rlevel->log2_prec_height;
1360 precno = prcx + rlevel->num_precincts_x * prcy;
1363 if (prcx >= rlevel->num_precincts_x || prcy >= rlevel->num_precincts_y) {
1364 av_log(s->avctx, AV_LOG_WARNING, "prc %d %d outside limits %d %d\n",
1365 prcx, prcy, rlevel->num_precincts_x, rlevel->num_precincts_y);
1369 for (layno = 0; layno < LYEpoc; layno++) {
1370 if ((ret = jpeg2000_decode_packet(s, tile, tp_index,
1373 qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1374 qntsty->nguardbits)) < 0)
1383 case JPEG2000_PGOD_PCRL:
1384 av_log(s->avctx, AV_LOG_WARNING, "Progression order PCRL\n");
1387 for (compno = CSpoc; compno < CEpoc; compno++) {
1388 Jpeg2000Component *comp = tile->comp + compno;
1389 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1391 for (reslevelno = RSpoc; reslevelno < FFMIN(codsty->nreslevels, REpoc); reslevelno++) {
1392 uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1393 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1394 step_x = FFMIN(step_x, rlevel->log2_prec_width + reducedresno);
1395 step_y = FFMIN(step_y, rlevel->log2_prec_height + reducedresno);
1398 if (step_x >= 31 || step_y >= 31){
1399 avpriv_request_sample(s->avctx, "PCRL with large step");
1400 return AVERROR_PATCHWELCOME;
1405 for (y = tile->coord[1][0]; y < tile->coord[1][1]; y = (y/step_y + 1)*step_y) {
1406 for (x = tile->coord[0][0]; x < tile->coord[0][1]; x = (x/step_x + 1)*step_x) {
1407 for (compno = CSpoc; compno < CEpoc; compno++) {
1408 Jpeg2000Component *comp = tile->comp + compno;
1409 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1410 Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
1411 int xc = x / s->cdx[compno];
1412 int yc = y / s->cdy[compno];
1414 for (reslevelno = RSpoc; reslevelno < FFMIN(codsty->nreslevels, REpoc); reslevelno++) {
1415 unsigned prcx, prcy;
1416 uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1417 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1419 if (yc % (1LL << (rlevel->log2_prec_height + reducedresno)) && y != tile->coord[1][0]) //FIXME this is a subset of the check
1422 if (xc % (1LL << (rlevel->log2_prec_width + reducedresno)) && x != tile->coord[0][0]) //FIXME this is a subset of the check
1425 // check if a precinct exists
1426 prcx = ff_jpeg2000_ceildivpow2(xc, reducedresno) >> rlevel->log2_prec_width;
1427 prcy = ff_jpeg2000_ceildivpow2(yc, reducedresno) >> rlevel->log2_prec_height;
1428 prcx -= ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], reducedresno) >> rlevel->log2_prec_width;
1429 prcy -= ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], reducedresno) >> rlevel->log2_prec_height;
1431 precno = prcx + rlevel->num_precincts_x * prcy;
1433 if (prcx >= rlevel->num_precincts_x || prcy >= rlevel->num_precincts_y) {
1434 av_log(s->avctx, AV_LOG_WARNING, "prc %d %d outside limits %d %d\n",
1435 prcx, prcy, rlevel->num_precincts_x, rlevel->num_precincts_y);
1439 for (layno = 0; layno < LYEpoc; layno++) {
1440 if ((ret = jpeg2000_decode_packet(s, tile, tp_index, codsty, rlevel,
1442 qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1443 qntsty->nguardbits)) < 0)
1459 static int jpeg2000_decode_packets(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
1461 int ret = AVERROR_BUG;
1466 if (tile->poc.nb_poc) {
1467 for (i=0; i<tile->poc.nb_poc; i++) {
1468 Jpeg2000POCEntry *e = &tile->poc.poc[i];
1469 ret = jpeg2000_decode_packets_po_iteration(s, tile,
1471 FFMIN(e->LYEpoc, tile->codsty[0].nlayers),
1473 FFMIN(e->CEpoc, s->ncomponents),
1480 ret = jpeg2000_decode_packets_po_iteration(s, tile,
1482 tile->codsty[0].nlayers,
1485 tile->codsty[0].prog_order,
1489 /* EOC marker reached */
1490 bytestream2_skip(&s->g, 2);
1495 /* TIER-1 routines */
1496 static void decode_sigpass(Jpeg2000T1Context *t1, int width, int height,
1497 int bpno, int bandno,
1498 int vert_causal_ctx_csty_symbol)
1500 int mask = 3 << (bpno - 1), y0, x, y;
1502 for (y0 = 0; y0 < height; y0 += 4)
1503 for (x = 0; x < width; x++)
1504 for (y = y0; y < height && y < y0 + 4; y++) {
1505 int flags_mask = -1;
1506 if (vert_causal_ctx_csty_symbol && y == y0 + 3)
1507 flags_mask &= ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE | JPEG2000_T1_SGN_S);
1508 if ((t1->flags[(y+1) * t1->stride + x+1] & JPEG2000_T1_SIG_NB & flags_mask)
1509 && !(t1->flags[(y+1) * t1->stride + x+1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS))) {
1510 if (ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ff_jpeg2000_getsigctxno(t1->flags[(y+1) * t1->stride + x+1] & flags_mask, bandno))) {
1511 int xorbit, ctxno = ff_jpeg2000_getsgnctxno(t1->flags[(y+1) * t1->stride + x+1] & flags_mask, &xorbit);
1513 t1->data[(y) * t1->stride + x] = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ctxno) ? -mask : mask;
1515 t1->data[(y) * t1->stride + x] = (ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ctxno) ^ xorbit) ?
1518 ff_jpeg2000_set_significance(t1, x, y,
1519 t1->data[(y) * t1->stride + x] < 0);
1521 t1->flags[(y + 1) * t1->stride + x + 1] |= JPEG2000_T1_VIS;
1526 static void decode_refpass(Jpeg2000T1Context *t1, int width, int height,
1527 int bpno, int vert_causal_ctx_csty_symbol)
1532 phalf = 1 << (bpno - 1);
1535 for (y0 = 0; y0 < height; y0 += 4)
1536 for (x = 0; x < width; x++)
1537 for (y = y0; y < height && y < y0 + 4; y++)
1538 if ((t1->flags[(y + 1) * t1->stride + x + 1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS)) == JPEG2000_T1_SIG) {
1539 int flags_mask = (vert_causal_ctx_csty_symbol && y == y0 + 3) ?
1540 ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE | JPEG2000_T1_SGN_S) : -1;
1541 int ctxno = ff_jpeg2000_getrefctxno(t1->flags[(y + 1) * t1->stride + x + 1] & flags_mask);
1542 int r = ff_mqc_decode(&t1->mqc,
1543 t1->mqc.cx_states + ctxno)
1545 t1->data[(y) * t1->stride + x] += t1->data[(y) * t1->stride + x] < 0 ? -r : r;
1546 t1->flags[(y + 1) * t1->stride + x + 1] |= JPEG2000_T1_REF;
1550 static void decode_clnpass(Jpeg2000DecoderContext *s, Jpeg2000T1Context *t1,
1551 int width, int height, int bpno, int bandno,
1552 int seg_symbols, int vert_causal_ctx_csty_symbol)
1554 int mask = 3 << (bpno - 1), y0, x, y, runlen, dec;
1556 for (y0 = 0; y0 < height; y0 += 4) {
1557 for (x = 0; x < width; x++) {
1558 int flags_mask = -1;
1559 if (vert_causal_ctx_csty_symbol)
1560 flags_mask &= ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE | JPEG2000_T1_SGN_S);
1561 if (y0 + 3 < height &&
1562 !((t1->flags[(y0 + 1) * t1->stride + x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
1563 (t1->flags[(y0 + 2) * t1->stride + x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
1564 (t1->flags[(y0 + 3) * t1->stride + x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
1565 (t1->flags[(y0 + 4) * t1->stride + x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG) & flags_mask))) {
1566 if (!ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_RL))
1568 runlen = ff_mqc_decode(&t1->mqc,
1569 t1->mqc.cx_states + MQC_CX_UNI);
1570 runlen = (runlen << 1) | ff_mqc_decode(&t1->mqc,
1579 for (y = y0 + runlen; y < y0 + 4 && y < height; y++) {
1580 int flags_mask = -1;
1581 if (vert_causal_ctx_csty_symbol && y == y0 + 3)
1582 flags_mask &= ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE | JPEG2000_T1_SGN_S);
1584 if (!(t1->flags[(y+1) * t1->stride + x+1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS))) {
1585 dec = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ff_jpeg2000_getsigctxno(t1->flags[(y+1) * t1->stride + x+1] & flags_mask,
1591 int ctxno = ff_jpeg2000_getsgnctxno(t1->flags[(y + 1) * t1->stride + x + 1] & flags_mask,
1593 t1->data[(y) * t1->stride + x] = (ff_mqc_decode(&t1->mqc,
1594 t1->mqc.cx_states + ctxno) ^
1597 ff_jpeg2000_set_significance(t1, x, y, t1->data[(y) * t1->stride + x] < 0);
1600 t1->flags[(y + 1) * t1->stride + x + 1] &= ~JPEG2000_T1_VIS;
1606 val = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1607 val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1608 val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1609 val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1611 av_log(s->avctx, AV_LOG_ERROR,
1612 "Segmentation symbol value incorrect\n");
1616 static int decode_cblk(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *codsty,
1617 Jpeg2000T1Context *t1, Jpeg2000Cblk *cblk,
1618 int width, int height, int bandpos)
1620 int passno = cblk->npasses, pass_t = 2, bpno = cblk->nonzerobits - 1;
1622 int vert_causal_ctx_csty_symbol = codsty->cblk_style & JPEG2000_CBLK_VSC;
1626 av_assert0(width <= 1024U && height <= 1024U);
1627 av_assert0(width*height <= 4096);
1629 memset(t1->data, 0, t1->stride * height * sizeof(*t1->data));
1631 /* If code-block contains no compressed data: nothing to do. */
1635 memset(t1->flags, 0, t1->stride * (height + 2) * sizeof(*t1->flags));
1637 cblk->data[cblk->length] = 0xff;
1638 cblk->data[cblk->length+1] = 0xff;
1639 ff_mqc_initdec(&t1->mqc, cblk->data, 0, 1);
1643 av_log(s->avctx, AV_LOG_ERROR, "bpno became negative\n");
1644 return AVERROR_INVALIDDATA;
1648 decode_sigpass(t1, width, height, bpno + 1, bandpos,
1649 vert_causal_ctx_csty_symbol);
1652 decode_refpass(t1, width, height, bpno + 1, vert_causal_ctx_csty_symbol);
1655 av_assert2(!t1->mqc.raw);
1656 decode_clnpass(s, t1, width, height, bpno + 1, bandpos,
1657 codsty->cblk_style & JPEG2000_CBLK_SEGSYM,
1658 vert_causal_ctx_csty_symbol);
1661 if (codsty->cblk_style & JPEG2000_CBLK_RESET) // XXX no testcase for just this
1662 ff_mqc_init_contexts(&t1->mqc);
1664 if (passno && (coder_type = needs_termination(codsty->cblk_style, pass_cnt))) {
1665 if (term_cnt >= cblk->nb_terminations) {
1666 av_log(s->avctx, AV_LOG_ERROR, "Missing needed termination \n");
1667 return AVERROR_INVALIDDATA;
1669 if (FFABS(cblk->data + cblk->data_start[term_cnt + 1] - 2 - t1->mqc.bp) > 0) {
1670 av_log(s->avctx, AV_LOG_WARNING, "Mid mismatch %"PTRDIFF_SPECIFIER" in pass %d of %d\n",
1671 cblk->data + cblk->data_start[term_cnt + 1] - 2 - t1->mqc.bp,
1672 pass_cnt, cblk->npasses);
1675 ff_mqc_initdec(&t1->mqc, cblk->data + cblk->data_start[++term_cnt], coder_type == 2, 0);
1686 if (cblk->data + cblk->length - 2*(term_cnt < cblk->nb_terminations) != t1->mqc.bp) {
1687 av_log(s->avctx, AV_LOG_WARNING, "End mismatch %"PTRDIFF_SPECIFIER"\n",
1688 cblk->data + cblk->length - 2*(term_cnt < cblk->nb_terminations) - t1->mqc.bp);
1694 /* TODO: Verify dequantization for lossless case
1695 * comp->data can be float or int
1696 * band->stepsize can be float or int
1697 * depending on the type of DWT transformation.
1698 * see ISO/IEC 15444-1:2002 A.6.1 */
1700 /* Float dequantization of a codeblock.*/
1701 static void dequantization_float(int x, int y, Jpeg2000Cblk *cblk,
1702 Jpeg2000Component *comp,
1703 Jpeg2000T1Context *t1, Jpeg2000Band *band)
1706 int w = cblk->coord[0][1] - cblk->coord[0][0];
1707 for (j = 0; j < (cblk->coord[1][1] - cblk->coord[1][0]); ++j) {
1708 float *datap = &comp->f_data[(comp->coord[0][1] - comp->coord[0][0]) * (y + j) + x];
1709 int *src = t1->data + j*t1->stride;
1710 for (i = 0; i < w; ++i)
1711 datap[i] = src[i] * band->f_stepsize;
1715 /* Integer dequantization of a codeblock.*/
1716 static void dequantization_int(int x, int y, Jpeg2000Cblk *cblk,
1717 Jpeg2000Component *comp,
1718 Jpeg2000T1Context *t1, Jpeg2000Band *band)
1721 int w = cblk->coord[0][1] - cblk->coord[0][0];
1722 for (j = 0; j < (cblk->coord[1][1] - cblk->coord[1][0]); ++j) {
1723 int32_t *datap = &comp->i_data[(comp->coord[0][1] - comp->coord[0][0]) * (y + j) + x];
1724 int *src = t1->data + j*t1->stride;
1725 if (band->i_stepsize == 32768) {
1726 for (i = 0; i < w; ++i)
1727 datap[i] = src[i] / 2;
1729 // This should be VERY uncommon
1730 for (i = 0; i < w; ++i)
1731 datap[i] = (src[i] * (int64_t)band->i_stepsize) / 65536;
1736 static void dequantization_int_97(int x, int y, Jpeg2000Cblk *cblk,
1737 Jpeg2000Component *comp,
1738 Jpeg2000T1Context *t1, Jpeg2000Band *band)
1741 int w = cblk->coord[0][1] - cblk->coord[0][0];
1742 for (j = 0; j < (cblk->coord[1][1] - cblk->coord[1][0]); ++j) {
1743 int32_t *datap = &comp->i_data[(comp->coord[0][1] - comp->coord[0][0]) * (y + j) + x];
1744 int *src = t1->data + j*t1->stride;
1745 for (i = 0; i < w; ++i)
1746 datap[i] = (src[i] * (int64_t)band->i_stepsize + (1<<15)) >> 16;
1750 static inline void mct_decode(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
1755 for (i = 1; i < 3; i++) {
1756 if (tile->codsty[0].transform != tile->codsty[i].transform) {
1757 av_log(s->avctx, AV_LOG_ERROR, "Transforms mismatch, MCT not supported\n");
1760 if (memcmp(tile->comp[0].coord, tile->comp[i].coord, sizeof(tile->comp[0].coord))) {
1761 av_log(s->avctx, AV_LOG_ERROR, "Coords mismatch, MCT not supported\n");
1766 for (i = 0; i < 3; i++)
1767 if (tile->codsty[0].transform == FF_DWT97)
1768 src[i] = tile->comp[i].f_data;
1770 src[i] = tile->comp[i].i_data;
1772 for (i = 0; i < 2; i++)
1773 csize *= tile->comp[0].coord[i][1] - tile->comp[0].coord[i][0];
1775 s->dsp.mct_decode[tile->codsty[0].transform](src[0], src[1], src[2], csize);
1778 static inline void tile_codeblocks(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
1780 Jpeg2000T1Context t1;
1782 int compno, reslevelno, bandno;
1784 /* Loop on tile components */
1785 for (compno = 0; compno < s->ncomponents; compno++) {
1786 Jpeg2000Component *comp = tile->comp + compno;
1787 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1790 t1.stride = (1<<codsty->log2_cblk_width) + 2;
1792 /* Loop on resolution levels */
1793 for (reslevelno = 0; reslevelno < codsty->nreslevels2decode; reslevelno++) {
1794 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1796 for (bandno = 0; bandno < rlevel->nbands; bandno++) {
1797 int nb_precincts, precno;
1798 Jpeg2000Band *band = rlevel->band + bandno;
1799 int cblkno = 0, bandpos;
1801 bandpos = bandno + (reslevelno > 0);
1803 if (band->coord[0][0] == band->coord[0][1] ||
1804 band->coord[1][0] == band->coord[1][1])
1807 nb_precincts = rlevel->num_precincts_x * rlevel->num_precincts_y;
1808 /* Loop on precincts */
1809 for (precno = 0; precno < nb_precincts; precno++) {
1810 Jpeg2000Prec *prec = band->prec + precno;
1812 /* Loop on codeblocks */
1814 cblkno < prec->nb_codeblocks_width * prec->nb_codeblocks_height;
1817 Jpeg2000Cblk *cblk = prec->cblk + cblkno;
1818 int ret = decode_cblk(s, codsty, &t1, cblk,
1819 cblk->coord[0][1] - cblk->coord[0][0],
1820 cblk->coord[1][1] - cblk->coord[1][0],
1826 x = cblk->coord[0][0] - band->coord[0][0];
1827 y = cblk->coord[1][0] - band->coord[1][0];
1829 if (codsty->transform == FF_DWT97)
1830 dequantization_float(x, y, cblk, comp, &t1, band);
1831 else if (codsty->transform == FF_DWT97_INT)
1832 dequantization_int_97(x, y, cblk, comp, &t1, band);
1834 dequantization_int(x, y, cblk, comp, &t1, band);
1838 } /* end reslevel */
1842 ff_dwt_decode(&comp->dwt, codsty->transform == FF_DWT97 ? (void*)comp->f_data : (void*)comp->i_data);
1847 #define WRITE_FRAME(D, PIXEL) \
1848 static inline void write_frame_ ## D(Jpeg2000DecoderContext * s, Jpeg2000Tile * tile, \
1849 AVFrame * picture, int precision) \
1851 const AVPixFmtDescriptor *pixdesc = av_pix_fmt_desc_get(s->avctx->pix_fmt); \
1852 int planar = !!(pixdesc->flags & AV_PIX_FMT_FLAG_PLANAR); \
1853 int pixelsize = planar ? 1 : pixdesc->nb_components; \
1858 for (compno = 0; compno < s->ncomponents; compno++) { \
1859 Jpeg2000Component *comp = tile->comp + compno; \
1860 Jpeg2000CodingStyle *codsty = tile->codsty + compno; \
1862 float *datap = comp->f_data; \
1863 int32_t *i_datap = comp->i_data; \
1864 int cbps = s->cbps[compno]; \
1865 int w = tile->comp[compno].coord[0][1] - s->image_offset_x; \
1869 plane = s->cdef[compno] ? s->cdef[compno]-1 : (s->ncomponents-1); \
1871 y = tile->comp[compno].coord[1][0] - s->image_offset_y / s->cdy[compno]; \
1872 line = (PIXEL *)picture->data[plane] + y * (picture->linesize[plane] / sizeof(PIXEL));\
1873 for (; y < tile->comp[compno].coord[1][1] - s->image_offset_y; y++) { \
1876 x = tile->comp[compno].coord[0][0] - s->image_offset_x / s->cdx[compno]; \
1877 dst = line + x * pixelsize + compno*!planar; \
1879 if (codsty->transform == FF_DWT97) { \
1880 for (; x < w; x++) { \
1881 int val = lrintf(*datap) + (1 << (cbps - 1)); \
1882 /* DC level shift and clip see ISO 15444-1:2002 G.1.2 */ \
1883 val = av_clip(val, 0, (1 << cbps) - 1); \
1884 *dst = val << (precision - cbps); \
1889 for (; x < w; x++) { \
1890 int val = *i_datap + (1 << (cbps - 1)); \
1891 /* DC level shift and clip see ISO 15444-1:2002 G.1.2 */ \
1892 val = av_clip(val, 0, (1 << cbps) - 1); \
1893 *dst = val << (precision - cbps); \
1898 line += picture->linesize[plane] / sizeof(PIXEL); \
1904 WRITE_FRAME(8, uint8_t)
1905 WRITE_FRAME(16, uint16_t)
1909 static int jpeg2000_decode_tile(AVCodecContext *avctx, void *td,
1910 int jobnr, int threadnr)
1912 Jpeg2000DecoderContext *s = avctx->priv_data;
1913 AVFrame *picture = td;
1914 Jpeg2000Tile *tile = s->tile + jobnr;
1917 tile_codeblocks(s, tile);
1919 /* inverse MCT transformation */
1920 if (tile->codsty[0].mct)
1921 mct_decode(s, tile);
1923 for (x = 0; x < s->ncomponents; x++) {
1924 if (s->cdef[x] < 0) {
1925 for (x = 0; x < s->ncomponents; x++) {
1928 if ((s->ncomponents & 1) == 0)
1929 s->cdef[s->ncomponents-1] = 0;
1934 if (s->precision <= 8) {
1935 write_frame_8(s, tile, picture, 8);
1937 int precision = picture->format == AV_PIX_FMT_XYZ12 ||
1938 picture->format == AV_PIX_FMT_RGB48 ||
1939 picture->format == AV_PIX_FMT_RGBA64 ||
1940 picture->format == AV_PIX_FMT_GRAY16 ? 16 : s->precision;
1942 write_frame_16(s, tile, picture, precision);
1948 static void jpeg2000_dec_cleanup(Jpeg2000DecoderContext *s)
1951 for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++) {
1952 if (s->tile[tileno].comp) {
1953 for (compno = 0; compno < s->ncomponents; compno++) {
1954 Jpeg2000Component *comp = s->tile[tileno].comp + compno;
1955 Jpeg2000CodingStyle *codsty = s->tile[tileno].codsty + compno;
1957 ff_jpeg2000_cleanup(comp, codsty);
1959 av_freep(&s->tile[tileno].comp);
1963 memset(s->codsty, 0, sizeof(s->codsty));
1964 memset(s->qntsty, 0, sizeof(s->qntsty));
1965 memset(s->properties, 0, sizeof(s->properties));
1966 memset(&s->poc , 0, sizeof(s->poc));
1967 s->numXtiles = s->numYtiles = 0;
1971 static int jpeg2000_read_main_headers(Jpeg2000DecoderContext *s)
1973 Jpeg2000CodingStyle *codsty = s->codsty;
1974 Jpeg2000QuantStyle *qntsty = s->qntsty;
1975 Jpeg2000POC *poc = &s->poc;
1976 uint8_t *properties = s->properties;
1983 if (bytestream2_get_bytes_left(&s->g) < 2) {
1984 av_log(s->avctx, AV_LOG_ERROR, "Missing EOC\n");
1988 marker = bytestream2_get_be16u(&s->g);
1989 oldpos = bytestream2_tell(&s->g);
1991 if (marker == JPEG2000_SOD) {
1993 Jpeg2000TilePart *tp;
1996 av_log(s->avctx, AV_LOG_ERROR, "Missing SIZ\n");
1997 return AVERROR_INVALIDDATA;
1999 if (s->curtileno < 0) {
2000 av_log(s->avctx, AV_LOG_ERROR, "Missing SOT\n");
2001 return AVERROR_INVALIDDATA;
2004 tile = s->tile + s->curtileno;
2005 tp = tile->tile_part + tile->tp_idx;
2006 if (tp->tp_end < s->g.buffer) {
2007 av_log(s->avctx, AV_LOG_ERROR, "Invalid tpend\n");
2008 return AVERROR_INVALIDDATA;
2011 if (tile->has_ppt && tile->tp_idx == 0) {
2012 bytestream2_init(&tile->packed_headers_stream, tile->packed_headers, tile->packed_headers_size);
2015 bytestream2_init(&tp->tpg, s->g.buffer, tp->tp_end - s->g.buffer);
2016 bytestream2_skip(&s->g, tp->tp_end - s->g.buffer);
2020 if (marker == JPEG2000_EOC)
2023 len = bytestream2_get_be16(&s->g);
2024 if (len < 2 || bytestream2_get_bytes_left(&s->g) < len - 2) {
2025 if (s->avctx->strict_std_compliance >= FF_COMPLIANCE_STRICT) {
2026 av_log(s->avctx, AV_LOG_ERROR, "Invalid len %d left=%d\n", len, bytestream2_get_bytes_left(&s->g));
2027 return AVERROR_INVALIDDATA;
2029 av_log(s->avctx, AV_LOG_WARNING, "Missing EOC Marker.\n");
2035 if (s->ncomponents) {
2036 av_log(s->avctx, AV_LOG_ERROR, "Duplicate SIZ\n");
2037 return AVERROR_INVALIDDATA;
2041 s->numXtiles = s->numYtiles = 0;
2044 ret = get_coc(s, codsty, properties);
2047 ret = get_cod(s, codsty, properties);
2050 ret = get_qcc(s, len, qntsty, properties);
2053 ret = get_qcd(s, len, qntsty, properties);
2056 ret = get_poc(s, len, poc);
2059 if (!(ret = get_sot(s, len))) {
2060 av_assert1(s->curtileno >= 0);
2061 codsty = s->tile[s->curtileno].codsty;
2062 qntsty = s->tile[s->curtileno].qntsty;
2063 poc = &s->tile[s->curtileno].poc;
2064 properties = s->tile[s->curtileno].properties;
2068 // the PLM marker is ignored
2070 // the comment is ignored
2071 bytestream2_skip(&s->g, len - 2);
2074 ret = read_crg(s, len);
2077 // Tile-part lengths
2078 ret = get_tlm(s, len);
2081 // Packet length, tile-part header
2082 ret = get_plt(s, len);
2085 // Packed headers, tile-part header
2086 ret = get_ppt(s, len);
2089 av_log(s->avctx, AV_LOG_ERROR,
2090 "unsupported marker 0x%.4"PRIX16" at pos 0x%X\n",
2091 marker, bytestream2_tell(&s->g) - 4);
2092 bytestream2_skip(&s->g, len - 2);
2095 if (bytestream2_tell(&s->g) - oldpos != len || ret) {
2096 av_log(s->avctx, AV_LOG_ERROR,
2097 "error during processing marker segment %.4"PRIx16"\n",
2099 return ret ? ret : -1;
2105 /* Read bit stream packets --> T2 operation. */
2106 static int jpeg2000_read_bitstream_packets(Jpeg2000DecoderContext *s)
2111 for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++) {
2112 Jpeg2000Tile *tile = s->tile + tileno;
2114 if ((ret = init_tile(s, tileno)) < 0)
2117 if ((ret = jpeg2000_decode_packets(s, tile)) < 0)
2124 static int jp2_find_codestream(Jpeg2000DecoderContext *s)
2126 uint32_t atom_size, atom, atom_end;
2127 int search_range = 10;
2131 bytestream2_get_bytes_left(&s->g) >= 8) {
2132 atom_size = bytestream2_get_be32u(&s->g);
2133 atom = bytestream2_get_be32u(&s->g);
2134 if (atom_size == 1) {
2135 if (bytestream2_get_be32u(&s->g)) {
2136 avpriv_request_sample(s->avctx, "Huge atom");
2139 atom_size = bytestream2_get_be32u(&s->g);
2140 atom_end = bytestream2_tell(&s->g) + atom_size - 16;
2142 atom_end = bytestream2_tell(&s->g) + atom_size - 8;
2145 if (atom == JP2_CODESTREAM)
2148 if (bytestream2_get_bytes_left(&s->g) < atom_size || atom_end < atom_size)
2151 if (atom == JP2_HEADER &&
2153 uint32_t atom2_size, atom2, atom2_end;
2155 atom2_size = bytestream2_get_be32u(&s->g);
2156 atom2 = bytestream2_get_be32u(&s->g);
2157 atom2_end = bytestream2_tell(&s->g) + atom2_size - 8;
2158 if (atom2_size < 8 || atom2_end > atom_end || atom2_end < atom2_size)
2161 if (atom2 == JP2_CODESTREAM) {
2163 } else if (atom2 == MKBETAG('c','o','l','r') && atom2_size >= 7) {
2164 int method = bytestream2_get_byteu(&s->g);
2165 bytestream2_skipu(&s->g, 2);
2167 s->colour_space = bytestream2_get_be32u(&s->g);
2169 } else if (atom2 == MKBETAG('p','c','l','r') && atom2_size >= 6) {
2170 int i, size, colour_count, colour_channels, colour_depth[3];
2171 colour_count = bytestream2_get_be16u(&s->g);
2172 colour_channels = bytestream2_get_byteu(&s->g);
2173 // FIXME: Do not ignore channel_sign
2174 colour_depth[0] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1;
2175 colour_depth[1] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1;
2176 colour_depth[2] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1;
2177 size = (colour_depth[0] + 7 >> 3) * colour_count +
2178 (colour_depth[1] + 7 >> 3) * colour_count +
2179 (colour_depth[2] + 7 >> 3) * colour_count;
2180 if (colour_count > AVPALETTE_COUNT ||
2181 colour_channels != 3 ||
2182 colour_depth[0] > 16 ||
2183 colour_depth[1] > 16 ||
2184 colour_depth[2] > 16 ||
2185 atom2_size < size) {
2186 avpriv_request_sample(s->avctx, "Unknown palette");
2187 bytestream2_seek(&s->g, atom2_end, SEEK_SET);
2191 for (i = 0; i < colour_count; i++) {
2193 if (colour_depth[0] <= 8) {
2194 r = bytestream2_get_byteu(&s->g) << 8 - colour_depth[0];
2195 r |= r >> colour_depth[0];
2197 r = bytestream2_get_be16u(&s->g) >> colour_depth[0] - 8;
2199 if (colour_depth[1] <= 8) {
2200 g = bytestream2_get_byteu(&s->g) << 8 - colour_depth[1];
2201 g |= g >> colour_depth[1];
2203 g = bytestream2_get_be16u(&s->g) >> colour_depth[1] - 8;
2205 if (colour_depth[2] <= 8) {
2206 b = bytestream2_get_byteu(&s->g) << 8 - colour_depth[2];
2207 b |= b >> colour_depth[2];
2209 b = bytestream2_get_be16u(&s->g) >> colour_depth[2] - 8;
2211 s->palette[i] = 0xffu << 24 | r << 16 | g << 8 | b;
2213 } else if (atom2 == MKBETAG('c','d','e','f') && atom2_size >= 2) {
2214 int n = bytestream2_get_be16u(&s->g);
2216 int cn = bytestream2_get_be16(&s->g);
2217 int av_unused typ = bytestream2_get_be16(&s->g);
2218 int asoc = bytestream2_get_be16(&s->g);
2219 if (cn < 4 && asoc < 4)
2222 } else if (atom2 == MKBETAG('r','e','s',' ') && atom2_size >= 18) {
2223 int64_t vnum, vden, hnum, hden, vexp, hexp;
2225 bytestream2_skip(&s->g, 4);
2226 resx = bytestream2_get_be32u(&s->g);
2227 if (resx != MKBETAG('r','e','s','c') && resx != MKBETAG('r','e','s','d')) {
2228 bytestream2_seek(&s->g, atom2_end, SEEK_SET);
2231 vnum = bytestream2_get_be16u(&s->g);
2232 vden = bytestream2_get_be16u(&s->g);
2233 hnum = bytestream2_get_be16u(&s->g);
2234 hden = bytestream2_get_be16u(&s->g);
2235 vexp = bytestream2_get_byteu(&s->g);
2236 hexp = bytestream2_get_byteu(&s->g);
2237 if (!vnum || !vden || !hnum || !hden) {
2238 bytestream2_seek(&s->g, atom2_end, SEEK_SET);
2239 av_log(s->avctx, AV_LOG_WARNING, "RES box invalid\n");
2249 if ( INT64_MAX / (hnum * vden) > pow(10, hexp)
2250 && INT64_MAX / (vnum * hden) > pow(10, vexp))
2251 av_reduce(&s->sar.den, &s->sar.num,
2252 hnum * vden * pow(10, hexp),
2253 vnum * hden * pow(10, vexp),
2256 bytestream2_seek(&s->g, atom2_end, SEEK_SET);
2257 } while (atom_end - atom2_end >= 8);
2261 bytestream2_seek(&s->g, atom_end, SEEK_SET);
2267 static av_cold void jpeg2000_init_static_data(void)
2269 ff_jpeg2000_init_tier1_luts();
2270 ff_mqc_init_context_tables();
2273 static av_cold int jpeg2000_decode_init(AVCodecContext *avctx)
2275 static AVOnce init_static_once = AV_ONCE_INIT;
2276 Jpeg2000DecoderContext *s = avctx->priv_data;
2278 ff_thread_once(&init_static_once, jpeg2000_init_static_data);
2279 ff_jpeg2000dsp_init(&s->dsp);
2284 static int jpeg2000_decode_frame(AVCodecContext *avctx, void *data,
2285 int *got_frame, AVPacket *avpkt)
2287 Jpeg2000DecoderContext *s = avctx->priv_data;
2288 ThreadFrame frame = { .f = data };
2289 AVFrame *picture = data;
2293 bytestream2_init(&s->g, avpkt->data, avpkt->size);
2295 memset(s->cdef, -1, sizeof(s->cdef));
2297 if (bytestream2_get_bytes_left(&s->g) < 2) {
2298 ret = AVERROR_INVALIDDATA;
2302 // check if the image is in jp2 format
2303 if (bytestream2_get_bytes_left(&s->g) >= 12 &&
2304 (bytestream2_get_be32u(&s->g) == 12) &&
2305 (bytestream2_get_be32u(&s->g) == JP2_SIG_TYPE) &&
2306 (bytestream2_get_be32u(&s->g) == JP2_SIG_VALUE)) {
2307 if (!jp2_find_codestream(s)) {
2308 av_log(avctx, AV_LOG_ERROR,
2309 "Could not find Jpeg2000 codestream atom.\n");
2310 ret = AVERROR_INVALIDDATA;
2314 bytestream2_seek(&s->g, 0, SEEK_SET);
2317 while (bytestream2_get_bytes_left(&s->g) >= 3 && bytestream2_peek_be16(&s->g) != JPEG2000_SOC)
2318 bytestream2_skip(&s->g, 1);
2320 if (bytestream2_get_be16u(&s->g) != JPEG2000_SOC) {
2321 av_log(avctx, AV_LOG_ERROR, "SOC marker not present\n");
2322 ret = AVERROR_INVALIDDATA;
2325 if (ret = jpeg2000_read_main_headers(s))
2328 /* get picture buffer */
2329 if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
2331 picture->pict_type = AV_PICTURE_TYPE_I;
2332 picture->key_frame = 1;
2334 if (ret = jpeg2000_read_bitstream_packets(s))
2337 avctx->execute2(avctx, jpeg2000_decode_tile, picture, NULL, s->numXtiles * s->numYtiles);
2339 jpeg2000_dec_cleanup(s);
2343 if (s->avctx->pix_fmt == AV_PIX_FMT_PAL8)
2344 memcpy(picture->data[1], s->palette, 256 * sizeof(uint32_t));
2345 if (s->sar.num && s->sar.den)
2346 avctx->sample_aspect_ratio = s->sar;
2347 s->sar.num = s->sar.den = 0;
2349 return bytestream2_tell(&s->g);
2352 jpeg2000_dec_cleanup(s);
2356 #define OFFSET(x) offsetof(Jpeg2000DecoderContext, x)
2357 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
2359 static const AVOption options[] = {
2360 { "lowres", "Lower the decoding resolution by a power of two",
2361 OFFSET(reduction_factor), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, JPEG2000_MAX_RESLEVELS - 1, VD },
2365 static const AVClass jpeg2000_class = {
2366 .class_name = "jpeg2000",
2367 .item_name = av_default_item_name,
2369 .version = LIBAVUTIL_VERSION_INT,
2372 AVCodec ff_jpeg2000_decoder = {
2374 .long_name = NULL_IF_CONFIG_SMALL("JPEG 2000"),
2375 .type = AVMEDIA_TYPE_VIDEO,
2376 .id = AV_CODEC_ID_JPEG2000,
2377 .capabilities = AV_CODEC_CAP_SLICE_THREADS | AV_CODEC_CAP_FRAME_THREADS | AV_CODEC_CAP_DR1,
2378 .priv_data_size = sizeof(Jpeg2000DecoderContext),
2379 .init = jpeg2000_decode_init,
2380 .decode = jpeg2000_decode_frame,
2381 .priv_class = &jpeg2000_class,
2383 .profiles = NULL_IF_CONFIG_SMALL(ff_jpeg2000_profiles)