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 header_tpg; // bit stream of header if PPM header is used
75 GetByteContext tpg; // bit stream in tile-part
78 /* RMK: For JPEG2000 DCINEMA 3 tile-parts in a tile
79 * one per component, so tile_part elements have a size of 3 */
80 typedef struct Jpeg2000Tile {
81 Jpeg2000Component *comp;
82 uint8_t properties[4];
83 Jpeg2000CodingStyle codsty[4];
84 Jpeg2000QuantStyle qntsty[4];
86 Jpeg2000TilePart tile_part[32];
87 uint8_t has_ppt; // whether this tile has a ppt marker
88 uint8_t *packed_headers; // contains packed headers. Used only along with PPT marker
89 int packed_headers_size; // size in bytes of the packed headers
90 GetByteContext packed_headers_stream; // byte context corresponding to packed headers
91 uint16_t tp_idx; // Tile-part index
92 int coord[2][2]; // border coordinates {{x0, x1}, {y0, y1}}
95 typedef struct Jpeg2000DecoderContext {
97 AVCodecContext *avctx;
101 int image_offset_x, image_offset_y;
102 int tile_offset_x, tile_offset_y;
103 uint8_t cbps[4]; // bits per sample in particular components
104 uint8_t sgnd[4]; // if a component is signed
105 uint8_t properties[4];
108 uint8_t *packed_headers; // contains packed headers. Used only along with PPM marker
109 int packed_headers_size;
110 GetByteContext packed_headers_stream;
111 uint8_t in_tile_headers;
117 uint32_t palette[256];
120 int tile_width, tile_height;
121 unsigned numXtiles, numYtiles;
125 Jpeg2000CodingStyle codsty[4];
126 Jpeg2000QuantStyle qntsty[4];
128 uint8_t roi_shift[4];
135 Jpeg2000DSPContext dsp;
137 /*options parameters*/
138 int reduction_factor;
139 } Jpeg2000DecoderContext;
141 /* get_bits functions for JPEG2000 packet bitstream
142 * It is a get_bit function with a bit-stuffing routine. If the value of the
143 * byte is 0xFF, the next byte includes an extra zero bit stuffed into the MSB.
144 * cf. ISO-15444-1:2002 / B.10.1 Bit-stuffing routine */
145 static int get_bits(Jpeg2000DecoderContext *s, int n)
151 if (s->bit_index == 0) {
152 s->bit_index = 7 + (bytestream2_get_byte(&s->g) != 0xFFu);
155 res |= (bytestream2_peek_byte(&s->g) >> s->bit_index) & 1;
160 static void jpeg2000_flush(Jpeg2000DecoderContext *s)
162 if (bytestream2_get_byte(&s->g) == 0xff)
163 bytestream2_skip(&s->g, 1);
167 /* decode the value stored in node */
168 static int tag_tree_decode(Jpeg2000DecoderContext *s, Jpeg2000TgtNode *node,
171 Jpeg2000TgtNode *stack[30];
172 int sp = -1, curval = 0;
175 av_log(s->avctx, AV_LOG_ERROR, "missing node\n");
176 return AVERROR_INVALIDDATA;
179 while (node && !node->vis) {
187 curval = stack[sp]->val;
189 while (curval < threshold && sp >= 0) {
190 if (curval < stack[sp]->val)
191 curval = stack[sp]->val;
192 while (curval < threshold) {
194 if ((ret = get_bits(s, 1)) > 0) {
202 stack[sp]->val = curval;
208 static int pix_fmt_match(enum AVPixelFormat pix_fmt, int components,
209 int bpc, uint32_t log2_chroma_wh, int pal8)
212 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
216 if (desc->nb_components != components) {
220 switch (components) {
222 match = match && desc->comp[3].depth >= bpc &&
223 (log2_chroma_wh >> 14 & 3) == 0 &&
224 (log2_chroma_wh >> 12 & 3) == 0;
226 match = match && desc->comp[2].depth >= bpc &&
227 (log2_chroma_wh >> 10 & 3) == desc->log2_chroma_w &&
228 (log2_chroma_wh >> 8 & 3) == desc->log2_chroma_h;
230 match = match && desc->comp[1].depth >= bpc &&
231 (log2_chroma_wh >> 6 & 3) == desc->log2_chroma_w &&
232 (log2_chroma_wh >> 4 & 3) == desc->log2_chroma_h;
235 match = match && desc->comp[0].depth >= bpc &&
236 (log2_chroma_wh >> 2 & 3) == 0 &&
237 (log2_chroma_wh & 3) == 0 &&
238 (desc->flags & AV_PIX_FMT_FLAG_PAL) == pal8 * AV_PIX_FMT_FLAG_PAL;
243 // pix_fmts with lower bpp have to be listed before
244 // similar pix_fmts with higher bpp.
245 #define RGB_PIXEL_FORMATS AV_PIX_FMT_PAL8,AV_PIX_FMT_RGB24,AV_PIX_FMT_RGBA,AV_PIX_FMT_RGB48,AV_PIX_FMT_RGBA64
246 #define GRAY_PIXEL_FORMATS AV_PIX_FMT_GRAY8,AV_PIX_FMT_GRAY8A,AV_PIX_FMT_GRAY16,AV_PIX_FMT_YA16
247 #define YUV_PIXEL_FORMATS AV_PIX_FMT_YUV410P,AV_PIX_FMT_YUV411P,AV_PIX_FMT_YUVA420P, \
248 AV_PIX_FMT_YUV420P,AV_PIX_FMT_YUV422P,AV_PIX_FMT_YUVA422P, \
249 AV_PIX_FMT_YUV440P,AV_PIX_FMT_YUV444P,AV_PIX_FMT_YUVA444P, \
250 AV_PIX_FMT_YUV420P9,AV_PIX_FMT_YUV422P9,AV_PIX_FMT_YUV444P9, \
251 AV_PIX_FMT_YUVA420P9,AV_PIX_FMT_YUVA422P9,AV_PIX_FMT_YUVA444P9, \
252 AV_PIX_FMT_YUV420P10,AV_PIX_FMT_YUV422P10,AV_PIX_FMT_YUV444P10, \
253 AV_PIX_FMT_YUVA420P10,AV_PIX_FMT_YUVA422P10,AV_PIX_FMT_YUVA444P10, \
254 AV_PIX_FMT_YUV420P12,AV_PIX_FMT_YUV422P12,AV_PIX_FMT_YUV444P12, \
255 AV_PIX_FMT_YUV420P14,AV_PIX_FMT_YUV422P14,AV_PIX_FMT_YUV444P14, \
256 AV_PIX_FMT_YUV420P16,AV_PIX_FMT_YUV422P16,AV_PIX_FMT_YUV444P16, \
257 AV_PIX_FMT_YUVA420P16,AV_PIX_FMT_YUVA422P16,AV_PIX_FMT_YUVA444P16
258 #define XYZ_PIXEL_FORMATS AV_PIX_FMT_XYZ12
260 static const enum AVPixelFormat rgb_pix_fmts[] = {RGB_PIXEL_FORMATS};
261 static const enum AVPixelFormat gray_pix_fmts[] = {GRAY_PIXEL_FORMATS};
262 static const enum AVPixelFormat yuv_pix_fmts[] = {YUV_PIXEL_FORMATS};
263 static const enum AVPixelFormat xyz_pix_fmts[] = {XYZ_PIXEL_FORMATS,
265 static const enum AVPixelFormat all_pix_fmts[] = {RGB_PIXEL_FORMATS,
270 /* marker segments */
271 /* get sizes and offsets of image, tiles; number of components */
272 static int get_siz(Jpeg2000DecoderContext *s)
276 uint32_t log2_chroma_wh = 0;
277 const enum AVPixelFormat *possible_fmts = NULL;
278 int possible_fmts_nb = 0;
280 int o_dimx, o_dimy; //original image dimensions.
283 if (bytestream2_get_bytes_left(&s->g) < 36) {
284 av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for SIZ\n");
285 return AVERROR_INVALIDDATA;
288 s->avctx->profile = bytestream2_get_be16u(&s->g); // Rsiz
289 s->width = bytestream2_get_be32u(&s->g); // Width
290 s->height = bytestream2_get_be32u(&s->g); // Height
291 s->image_offset_x = bytestream2_get_be32u(&s->g); // X0Siz
292 s->image_offset_y = bytestream2_get_be32u(&s->g); // Y0Siz
293 s->tile_width = bytestream2_get_be32u(&s->g); // XTSiz
294 s->tile_height = bytestream2_get_be32u(&s->g); // YTSiz
295 s->tile_offset_x = bytestream2_get_be32u(&s->g); // XT0Siz
296 s->tile_offset_y = bytestream2_get_be32u(&s->g); // YT0Siz
297 ncomponents = bytestream2_get_be16u(&s->g); // CSiz
299 if (av_image_check_size2(s->width, s->height, s->avctx->max_pixels, AV_PIX_FMT_NONE, 0, s->avctx)) {
300 avpriv_request_sample(s->avctx, "Large Dimensions");
301 return AVERROR_PATCHWELCOME;
304 if (ncomponents <= 0) {
305 av_log(s->avctx, AV_LOG_ERROR, "Invalid number of components: %d\n",
307 return AVERROR_INVALIDDATA;
310 if (ncomponents > 4) {
311 avpriv_request_sample(s->avctx, "Support for %d components",
313 return AVERROR_PATCHWELCOME;
316 if (s->tile_offset_x < 0 || s->tile_offset_y < 0 ||
317 s->image_offset_x < s->tile_offset_x ||
318 s->image_offset_y < s->tile_offset_y ||
319 s->tile_width + (int64_t)s->tile_offset_x <= s->image_offset_x ||
320 s->tile_height + (int64_t)s->tile_offset_y <= s->image_offset_y
322 av_log(s->avctx, AV_LOG_ERROR, "Tile offsets are invalid\n");
323 return AVERROR_INVALIDDATA;
326 s->ncomponents = ncomponents;
328 if (s->tile_width <= 0 || s->tile_height <= 0) {
329 av_log(s->avctx, AV_LOG_ERROR, "Invalid tile dimension %dx%d.\n",
330 s->tile_width, s->tile_height);
331 return AVERROR_INVALIDDATA;
334 if (bytestream2_get_bytes_left(&s->g) < 3 * s->ncomponents) {
335 av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for %d components in SIZ\n", s->ncomponents);
336 return AVERROR_INVALIDDATA;
339 for (i = 0; i < s->ncomponents; i++) { // Ssiz_i XRsiz_i, YRsiz_i
340 uint8_t x = bytestream2_get_byteu(&s->g);
341 s->cbps[i] = (x & 0x7f) + 1;
342 s->precision = FFMAX(s->cbps[i], s->precision);
343 s->sgnd[i] = !!(x & 0x80);
344 s->cdx[i] = bytestream2_get_byteu(&s->g);
345 s->cdy[i] = bytestream2_get_byteu(&s->g);
346 if ( !s->cdx[i] || s->cdx[i] == 3 || s->cdx[i] > 4
347 || !s->cdy[i] || s->cdy[i] == 3 || s->cdy[i] > 4) {
348 av_log(s->avctx, AV_LOG_ERROR, "Invalid sample separation %d/%d\n", s->cdx[i], s->cdy[i]);
349 return AVERROR_INVALIDDATA;
351 log2_chroma_wh |= s->cdy[i] >> 1 << i * 4 | s->cdx[i] >> 1 << i * 4 + 2;
354 s->numXtiles = ff_jpeg2000_ceildiv(s->width - s->tile_offset_x, s->tile_width);
355 s->numYtiles = ff_jpeg2000_ceildiv(s->height - s->tile_offset_y, s->tile_height);
357 // There must be at least a SOT and SOD per tile, their minimum size is 14
358 if (s->numXtiles * (uint64_t)s->numYtiles > INT_MAX/sizeof(*s->tile) ||
359 s->numXtiles * s->numYtiles * 14LL > bytestream2_size(&s->g)
361 s->numXtiles = s->numYtiles = 0;
362 return AVERROR(EINVAL);
365 s->tile = av_mallocz_array(s->numXtiles * s->numYtiles, sizeof(*s->tile));
367 s->numXtiles = s->numYtiles = 0;
368 return AVERROR(ENOMEM);
371 for (i = 0; i < s->numXtiles * s->numYtiles; i++) {
372 Jpeg2000Tile *tile = s->tile + i;
374 tile->comp = av_mallocz(s->ncomponents * sizeof(*tile->comp));
376 return AVERROR(ENOMEM);
379 /* compute image size with reduction factor */
380 o_dimx = ff_jpeg2000_ceildivpow2(s->width - s->image_offset_x,
381 s->reduction_factor);
382 o_dimy = ff_jpeg2000_ceildivpow2(s->height - s->image_offset_y,
383 s->reduction_factor);
384 dimx = ff_jpeg2000_ceildiv(o_dimx, s->cdx[0]);
385 dimy = ff_jpeg2000_ceildiv(o_dimy, s->cdy[0]);
386 for (i = 1; i < s->ncomponents; i++) {
387 dimx = FFMAX(dimx, ff_jpeg2000_ceildiv(o_dimx, s->cdx[i]));
388 dimy = FFMAX(dimy, ff_jpeg2000_ceildiv(o_dimy, s->cdy[i]));
391 ret = ff_set_dimensions(s->avctx, dimx, dimy);
395 if (s->avctx->profile == FF_PROFILE_JPEG2000_DCINEMA_2K ||
396 s->avctx->profile == FF_PROFILE_JPEG2000_DCINEMA_4K) {
397 possible_fmts = xyz_pix_fmts;
398 possible_fmts_nb = FF_ARRAY_ELEMS(xyz_pix_fmts);
400 switch (s->colour_space) {
402 possible_fmts = rgb_pix_fmts;
403 possible_fmts_nb = FF_ARRAY_ELEMS(rgb_pix_fmts);
406 possible_fmts = gray_pix_fmts;
407 possible_fmts_nb = FF_ARRAY_ELEMS(gray_pix_fmts);
410 possible_fmts = yuv_pix_fmts;
411 possible_fmts_nb = FF_ARRAY_ELEMS(yuv_pix_fmts);
414 possible_fmts = all_pix_fmts;
415 possible_fmts_nb = FF_ARRAY_ELEMS(all_pix_fmts);
419 if ( s->avctx->pix_fmt != AV_PIX_FMT_NONE
420 && !pix_fmt_match(s->avctx->pix_fmt, ncomponents, s->precision, log2_chroma_wh, s->pal8))
421 s->avctx->pix_fmt = AV_PIX_FMT_NONE;
422 if (s->avctx->pix_fmt == AV_PIX_FMT_NONE)
423 for (i = 0; i < possible_fmts_nb; ++i) {
424 if (pix_fmt_match(possible_fmts[i], ncomponents, s->precision, log2_chroma_wh, s->pal8)) {
425 s->avctx->pix_fmt = possible_fmts[i];
430 if (i == possible_fmts_nb) {
431 if (ncomponents == 4 &&
432 s->cdy[0] == 1 && s->cdx[0] == 1 &&
433 s->cdy[1] == 1 && s->cdx[1] == 1 &&
434 s->cdy[2] == s->cdy[3] && s->cdx[2] == s->cdx[3]) {
435 if (s->precision == 8 && s->cdy[2] == 2 && s->cdx[2] == 2 && !s->pal8) {
436 s->avctx->pix_fmt = AV_PIX_FMT_YUVA420P;
443 } else if (ncomponents == 3 && s->precision == 8 &&
444 s->cdx[0] == s->cdx[1] && s->cdx[0] == s->cdx[2] &&
445 s->cdy[0] == s->cdy[1] && s->cdy[0] == s->cdy[2]) {
446 s->avctx->pix_fmt = AV_PIX_FMT_RGB24;
448 } else if (ncomponents == 2 && s->precision == 8 &&
449 s->cdx[0] == s->cdx[1] && s->cdy[0] == s->cdy[1]) {
450 s->avctx->pix_fmt = AV_PIX_FMT_YA8;
452 } else if (ncomponents == 1 && s->precision == 8) {
453 s->avctx->pix_fmt = AV_PIX_FMT_GRAY8;
459 if (i == possible_fmts_nb) {
460 av_log(s->avctx, AV_LOG_ERROR,
461 "Unknown pix_fmt, profile: %d, colour_space: %d, "
462 "components: %d, precision: %d\n"
463 "cdx[0]: %d, cdy[0]: %d\n"
464 "cdx[1]: %d, cdy[1]: %d\n"
465 "cdx[2]: %d, cdy[2]: %d\n"
466 "cdx[3]: %d, cdy[3]: %d\n",
467 s->avctx->profile, s->colour_space, ncomponents, s->precision,
470 ncomponents > 1 ? s->cdx[1] : 0,
471 ncomponents > 1 ? s->cdy[1] : 0,
472 ncomponents > 2 ? s->cdx[2] : 0,
473 ncomponents > 2 ? s->cdy[2] : 0,
474 ncomponents > 3 ? s->cdx[3] : 0,
475 ncomponents > 3 ? s->cdy[3] : 0);
476 return AVERROR_PATCHWELCOME;
478 s->avctx->bits_per_raw_sample = s->precision;
482 /* get common part for COD and COC segments */
483 static int get_cox(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c)
487 if (bytestream2_get_bytes_left(&s->g) < 5) {
488 av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for COX\n");
489 return AVERROR_INVALIDDATA;
492 /* nreslevels = number of resolution levels
493 = number of decomposition level +1 */
494 c->nreslevels = bytestream2_get_byteu(&s->g) + 1;
495 if (c->nreslevels >= JPEG2000_MAX_RESLEVELS) {
496 av_log(s->avctx, AV_LOG_ERROR, "nreslevels %d is invalid\n", c->nreslevels);
497 return AVERROR_INVALIDDATA;
500 if (c->nreslevels <= s->reduction_factor) {
501 /* we are forced to update reduction_factor as its requested value is
502 not compatible with this bitstream, and as we might have used it
503 already in setup earlier we have to fail this frame until
504 reinitialization is implemented */
505 av_log(s->avctx, AV_LOG_ERROR, "reduction_factor too large for this bitstream, max is %d\n", c->nreslevels - 1);
506 s->reduction_factor = c->nreslevels - 1;
507 return AVERROR(EINVAL);
510 /* compute number of resolution levels to decode */
511 c->nreslevels2decode = c->nreslevels - s->reduction_factor;
513 c->log2_cblk_width = (bytestream2_get_byteu(&s->g) & 15) + 2; // cblk width
514 c->log2_cblk_height = (bytestream2_get_byteu(&s->g) & 15) + 2; // cblk height
516 if (c->log2_cblk_width > 10 || c->log2_cblk_height > 10 ||
517 c->log2_cblk_width + c->log2_cblk_height > 12) {
518 av_log(s->avctx, AV_LOG_ERROR, "cblk size invalid\n");
519 return AVERROR_INVALIDDATA;
522 c->cblk_style = bytestream2_get_byteu(&s->g);
523 if (c->cblk_style != 0) { // cblk style
524 av_log(s->avctx, AV_LOG_WARNING, "extra cblk styles %X\n", c->cblk_style);
525 if (c->cblk_style & JPEG2000_CBLK_BYPASS)
526 av_log(s->avctx, AV_LOG_WARNING, "Selective arithmetic coding bypass\n");
528 c->transform = bytestream2_get_byteu(&s->g); // DWT transformation type
529 /* set integer 9/7 DWT in case of BITEXACT flag */
530 if ((s->avctx->flags & AV_CODEC_FLAG_BITEXACT) && (c->transform == FF_DWT97))
531 c->transform = FF_DWT97_INT;
532 else if (c->transform == FF_DWT53) {
533 s->avctx->properties |= FF_CODEC_PROPERTY_LOSSLESS;
536 if (c->csty & JPEG2000_CSTY_PREC) {
538 for (i = 0; i < c->nreslevels; i++) {
539 byte = bytestream2_get_byte(&s->g);
540 c->log2_prec_widths[i] = byte & 0x0F; // precinct PPx
541 c->log2_prec_heights[i] = (byte >> 4) & 0x0F; // precinct PPy
543 if (c->log2_prec_widths[i] == 0 || c->log2_prec_heights[i] == 0) {
544 av_log(s->avctx, AV_LOG_ERROR, "PPx %d PPy %d invalid\n",
545 c->log2_prec_widths[i], c->log2_prec_heights[i]);
546 c->log2_prec_widths[i] = c->log2_prec_heights[i] = 1;
547 return AVERROR_INVALIDDATA;
551 memset(c->log2_prec_widths , 15, sizeof(c->log2_prec_widths ));
552 memset(c->log2_prec_heights, 15, sizeof(c->log2_prec_heights));
557 /* get coding parameters for a particular tile or whole image*/
558 static int get_cod(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c,
561 Jpeg2000CodingStyle tmp;
564 if (bytestream2_get_bytes_left(&s->g) < 5) {
565 av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for COD\n");
566 return AVERROR_INVALIDDATA;
569 tmp.csty = bytestream2_get_byteu(&s->g);
571 // get progression order
572 tmp.prog_order = bytestream2_get_byteu(&s->g);
574 tmp.nlayers = bytestream2_get_be16u(&s->g);
575 tmp.mct = bytestream2_get_byteu(&s->g); // multiple component transformation
577 if (tmp.mct && s->ncomponents < 3) {
578 av_log(s->avctx, AV_LOG_ERROR,
579 "MCT %"PRIu8" with too few components (%d)\n",
580 tmp.mct, s->ncomponents);
581 return AVERROR_INVALIDDATA;
584 if ((ret = get_cox(s, &tmp)) < 0)
587 for (compno = 0; compno < s->ncomponents; compno++)
588 if (!(properties[compno] & HAD_COC))
589 memcpy(c + compno, &tmp, sizeof(tmp));
593 /* Get coding parameters for a component in the whole image or a
594 * particular tile. */
595 static int get_coc(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c,
599 uint8_t has_eph, has_sop;
601 if (bytestream2_get_bytes_left(&s->g) < 2) {
602 av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for COC\n");
603 return AVERROR_INVALIDDATA;
606 compno = bytestream2_get_byteu(&s->g);
608 if (compno >= s->ncomponents) {
609 av_log(s->avctx, AV_LOG_ERROR,
610 "Invalid compno %d. There are %d components in the image.\n",
611 compno, s->ncomponents);
612 return AVERROR_INVALIDDATA;
616 has_eph = c->csty & JPEG2000_CSTY_EPH;
617 has_sop = c->csty & JPEG2000_CSTY_SOP;
618 c->csty = bytestream2_get_byteu(&s->g);
619 c->csty |= has_eph; //do not override eph present bits from COD
620 c->csty |= has_sop; //do not override sop present bits from COD
622 if ((ret = get_cox(s, c)) < 0)
625 properties[compno] |= HAD_COC;
630 static int get_rgn(Jpeg2000DecoderContext *s, int n)
633 compno = (s->ncomponents < 257)? bytestream2_get_byte(&s->g):
634 bytestream2_get_be16u(&s->g);
635 if (bytestream2_get_byte(&s->g)) {
636 av_log(s->avctx, AV_LOG_ERROR, "Invalid RGN header.\n");
637 return AVERROR_INVALIDDATA; // SRgn field value is 0
640 // Currently compno cannot be greater than 4.
641 // However, future implementation should support compno up to 65536
642 if (compno < s->ncomponents) {
644 if (s->curtileno == -1) {
645 v = bytestream2_get_byte(&s->g);
647 return AVERROR_PATCHWELCOME;
648 s->roi_shift[compno] = v;
650 if (s->tile[s->curtileno].tp_idx != 0)
651 return AVERROR_INVALIDDATA; // marker occurs only in first tile part of tile
652 v = bytestream2_get_byte(&s->g);
654 return AVERROR_PATCHWELCOME;
655 s->tile[s->curtileno].comp[compno].roi_shift = v;
659 return AVERROR_INVALIDDATA;
662 /* Get common part for QCD and QCC segments. */
663 static int get_qcx(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q)
667 if (bytestream2_get_bytes_left(&s->g) < 1)
668 return AVERROR_INVALIDDATA;
670 x = bytestream2_get_byteu(&s->g); // Sqcd
672 q->nguardbits = x >> 5;
673 q->quantsty = x & 0x1f;
675 if (q->quantsty == JPEG2000_QSTY_NONE) {
677 if (bytestream2_get_bytes_left(&s->g) < n ||
678 n > JPEG2000_MAX_DECLEVELS*3)
679 return AVERROR_INVALIDDATA;
680 for (i = 0; i < n; i++)
681 q->expn[i] = bytestream2_get_byteu(&s->g) >> 3;
682 } else if (q->quantsty == JPEG2000_QSTY_SI) {
683 if (bytestream2_get_bytes_left(&s->g) < 2)
684 return AVERROR_INVALIDDATA;
685 x = bytestream2_get_be16u(&s->g);
686 q->expn[0] = x >> 11;
687 q->mant[0] = x & 0x7ff;
688 for (i = 1; i < JPEG2000_MAX_DECLEVELS * 3; i++) {
689 int curexpn = FFMAX(0, q->expn[0] - (i - 1) / 3);
690 q->expn[i] = curexpn;
691 q->mant[i] = q->mant[0];
695 if (bytestream2_get_bytes_left(&s->g) < 2 * n ||
696 n > JPEG2000_MAX_DECLEVELS*3)
697 return AVERROR_INVALIDDATA;
698 for (i = 0; i < n; i++) {
699 x = bytestream2_get_be16u(&s->g);
700 q->expn[i] = x >> 11;
701 q->mant[i] = x & 0x7ff;
707 /* Get quantization parameters for a particular tile or a whole image. */
708 static int get_qcd(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q,
711 Jpeg2000QuantStyle tmp;
714 memset(&tmp, 0, sizeof(tmp));
716 if ((ret = get_qcx(s, n, &tmp)) < 0)
718 for (compno = 0; compno < s->ncomponents; compno++)
719 if (!(properties[compno] & HAD_QCC))
720 memcpy(q + compno, &tmp, sizeof(tmp));
724 /* Get quantization parameters for a component in the whole image
725 * on in a particular tile. */
726 static int get_qcc(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q,
731 if (bytestream2_get_bytes_left(&s->g) < 1)
732 return AVERROR_INVALIDDATA;
734 compno = bytestream2_get_byteu(&s->g);
736 if (compno >= s->ncomponents) {
737 av_log(s->avctx, AV_LOG_ERROR,
738 "Invalid compno %d. There are %d components in the image.\n",
739 compno, s->ncomponents);
740 return AVERROR_INVALIDDATA;
743 properties[compno] |= HAD_QCC;
744 return get_qcx(s, n - 1, q + compno);
747 static int get_poc(Jpeg2000DecoderContext *s, int size, Jpeg2000POC *p)
750 int elem_size = s->ncomponents <= 257 ? 7 : 9;
751 Jpeg2000POC tmp = {{{0}}};
753 if (bytestream2_get_bytes_left(&s->g) < 5 || size < 2 + elem_size) {
754 av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for POC\n");
755 return AVERROR_INVALIDDATA;
759 avpriv_request_sample(s->avctx, "Fat POC not supported");
760 return AVERROR_PATCHWELCOME;
763 tmp.nb_poc = (size - 2) / elem_size;
764 if (tmp.nb_poc > MAX_POCS) {
765 avpriv_request_sample(s->avctx, "Too many POCs (%d)", tmp.nb_poc);
766 return AVERROR_PATCHWELCOME;
769 for (i = 0; i<tmp.nb_poc; i++) {
770 Jpeg2000POCEntry *e = &tmp.poc[i];
771 e->RSpoc = bytestream2_get_byteu(&s->g);
772 e->CSpoc = bytestream2_get_byteu(&s->g);
773 e->LYEpoc = bytestream2_get_be16u(&s->g);
774 e->REpoc = bytestream2_get_byteu(&s->g);
775 e->CEpoc = bytestream2_get_byteu(&s->g);
776 e->Ppoc = bytestream2_get_byteu(&s->g);
779 if (e->CEpoc > s->ncomponents)
780 e->CEpoc = s->ncomponents;
781 if ( e->RSpoc >= e->REpoc || e->REpoc > 33
782 || e->CSpoc >= e->CEpoc || e->CEpoc > s->ncomponents
784 av_log(s->avctx, AV_LOG_ERROR, "POC Entry %d is invalid (%d, %d, %d, %d, %d, %d)\n", i,
785 e->RSpoc, e->CSpoc, e->LYEpoc, e->REpoc, e->CEpoc, e->Ppoc
787 return AVERROR_INVALIDDATA;
791 if (!p->nb_poc || p->is_default) {
794 if (p->nb_poc + tmp.nb_poc > MAX_POCS) {
795 av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for POC\n");
796 return AVERROR_INVALIDDATA;
798 memcpy(p->poc + p->nb_poc, tmp.poc, tmp.nb_poc * sizeof(tmp.poc[0]));
799 p->nb_poc += tmp.nb_poc;
808 /* Get start of tile segment. */
809 static int get_sot(Jpeg2000DecoderContext *s, int n)
811 Jpeg2000TilePart *tp;
816 if (bytestream2_get_bytes_left(&s->g) < 8)
817 return AVERROR_INVALIDDATA;
820 Isot = bytestream2_get_be16u(&s->g); // Isot
821 if (Isot >= s->numXtiles * s->numYtiles)
822 return AVERROR_INVALIDDATA;
825 Psot = bytestream2_get_be32u(&s->g); // Psot
826 TPsot = bytestream2_get_byteu(&s->g); // TPsot
828 /* Read TNSot but not used */
829 bytestream2_get_byteu(&s->g); // TNsot
832 Psot = bytestream2_get_bytes_left(&s->g) - 2 + n + 2;
834 if (Psot > bytestream2_get_bytes_left(&s->g) - 2 + n + 2) {
835 av_log(s->avctx, AV_LOG_ERROR, "Psot %"PRIu32" too big\n", Psot);
836 return AVERROR_INVALIDDATA;
839 if (TPsot >= FF_ARRAY_ELEMS(s->tile[Isot].tile_part)) {
840 avpriv_request_sample(s->avctx, "Too many tile parts");
841 return AVERROR_PATCHWELCOME;
844 s->tile[Isot].tp_idx = TPsot;
845 tp = s->tile[Isot].tile_part + TPsot;
846 tp->tile_index = Isot;
847 tp->tp_end = s->g.buffer + Psot - n - 2;
850 Jpeg2000Tile *tile = s->tile + s->curtileno;
853 memcpy(tile->codsty, s->codsty, s->ncomponents * sizeof(Jpeg2000CodingStyle));
854 memcpy(tile->qntsty, s->qntsty, s->ncomponents * sizeof(Jpeg2000QuantStyle));
855 memcpy(&tile->poc , &s->poc , sizeof(tile->poc));
856 tile->poc.is_default = 1;
862 static int read_crg(Jpeg2000DecoderContext *s, int n)
864 if (s->ncomponents*4 != n - 2) {
865 av_log(s->avctx, AV_LOG_ERROR, "Invalid CRG marker.\n");
866 return AVERROR_INVALIDDATA;
868 bytestream2_skip(&s->g, n - 2);
871 /* Tile-part lengths: see ISO 15444-1:2002, section A.7.1
872 * Used to know the number of tile parts and lengths.
873 * There may be multiple TLMs in the header.
874 * TODO: The function is not used for tile-parts management, nor anywhere else.
875 * It can be useful to allocate memory for tile parts, before managing the SOT
876 * markers. Parsing the TLM header is needed to increment the input header
878 * This marker is mandatory for DCI. */
879 static int get_tlm(Jpeg2000DecoderContext *s, int n)
881 uint8_t Stlm, ST, SP, tile_tlm, i;
882 bytestream2_get_byte(&s->g); /* Ztlm: skipped */
883 Stlm = bytestream2_get_byte(&s->g);
885 // too complex ? ST = ((Stlm >> 4) & 0x01) + ((Stlm >> 4) & 0x02);
886 ST = (Stlm >> 4) & 0x03;
888 av_log(s->avctx, AV_LOG_ERROR, "TLM marker contains invalid ST value.\n");
889 return AVERROR_INVALIDDATA;
892 SP = (Stlm >> 6) & 0x01;
893 tile_tlm = (n - 4) / ((SP + 1) * 2 + ST);
894 for (i = 0; i < tile_tlm; i++) {
899 bytestream2_get_byte(&s->g);
902 bytestream2_get_be16(&s->g);
905 bytestream2_get_be32(&s->g);
909 bytestream2_get_be16(&s->g);
911 bytestream2_get_be32(&s->g);
917 static int get_plt(Jpeg2000DecoderContext *s, int n)
922 av_log(s->avctx, AV_LOG_DEBUG,
923 "PLT marker at pos 0x%X\n", bytestream2_tell(&s->g) - 4);
926 return AVERROR_INVALIDDATA;
928 /*Zplt =*/ bytestream2_get_byte(&s->g);
930 for (i = 0; i < n - 3; i++) {
931 v = bytestream2_get_byte(&s->g);
934 return AVERROR_INVALIDDATA;
939 static int get_ppm(Jpeg2000DecoderContext *s, int n)
944 av_log(s->avctx, AV_LOG_ERROR, "Invalid length for PPM data.\n");
945 return AVERROR_INVALIDDATA;
947 bytestream2_get_byte(&s->g); //Zppm is skipped and not used
948 new = av_realloc(s->packed_headers,
949 s->packed_headers_size + n - 3);
951 s->packed_headers = new;
953 return AVERROR(ENOMEM);
955 memset(&s->packed_headers_stream, 0, sizeof(s->packed_headers_stream));
956 bytestream_get_buffer(&s->g.buffer, s->packed_headers + s->packed_headers_size,
958 s->packed_headers_size += n - 3;
963 static int get_ppt(Jpeg2000DecoderContext *s, int n)
969 av_log(s->avctx, AV_LOG_ERROR, "Invalid length for PPT data.\n");
970 return AVERROR_INVALIDDATA;
972 if (s->curtileno < 0)
973 return AVERROR_INVALIDDATA;
975 tile = &s->tile[s->curtileno];
976 if (tile->tp_idx != 0) {
977 av_log(s->avctx, AV_LOG_ERROR,
978 "PPT marker can occur only on first tile part of a tile.\n");
979 return AVERROR_INVALIDDATA;
982 tile->has_ppt = 1; // this tile has a ppt marker
983 bytestream2_get_byte(&s->g); // Zppt is skipped and not used
984 new = av_realloc(tile->packed_headers,
985 tile->packed_headers_size + n - 3);
987 tile->packed_headers = new;
989 return AVERROR(ENOMEM);
990 memset(&tile->packed_headers_stream, 0, sizeof(tile->packed_headers_stream));
991 memcpy(tile->packed_headers + tile->packed_headers_size,
993 tile->packed_headers_size += n - 3;
994 bytestream2_skip(&s->g, n - 3);
999 static int init_tile(Jpeg2000DecoderContext *s, int tileno)
1002 int tilex = tileno % s->numXtiles;
1003 int tiley = tileno / s->numXtiles;
1004 Jpeg2000Tile *tile = s->tile + tileno;
1007 return AVERROR(ENOMEM);
1009 tile->coord[0][0] = av_clip(tilex * (int64_t)s->tile_width + s->tile_offset_x, s->image_offset_x, s->width);
1010 tile->coord[0][1] = av_clip((tilex + 1) * (int64_t)s->tile_width + s->tile_offset_x, s->image_offset_x, s->width);
1011 tile->coord[1][0] = av_clip(tiley * (int64_t)s->tile_height + s->tile_offset_y, s->image_offset_y, s->height);
1012 tile->coord[1][1] = av_clip((tiley + 1) * (int64_t)s->tile_height + s->tile_offset_y, s->image_offset_y, s->height);
1014 for (compno = 0; compno < s->ncomponents; compno++) {
1015 Jpeg2000Component *comp = tile->comp + compno;
1016 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1017 Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
1018 int ret; // global bandno
1020 comp->coord_o[0][0] = tile->coord[0][0];
1021 comp->coord_o[0][1] = tile->coord[0][1];
1022 comp->coord_o[1][0] = tile->coord[1][0];
1023 comp->coord_o[1][1] = tile->coord[1][1];
1025 comp->coord_o[0][0] = ff_jpeg2000_ceildiv(comp->coord_o[0][0], s->cdx[compno]);
1026 comp->coord_o[0][1] = ff_jpeg2000_ceildiv(comp->coord_o[0][1], s->cdx[compno]);
1027 comp->coord_o[1][0] = ff_jpeg2000_ceildiv(comp->coord_o[1][0], s->cdy[compno]);
1028 comp->coord_o[1][1] = ff_jpeg2000_ceildiv(comp->coord_o[1][1], s->cdy[compno]);
1030 comp->coord[0][0] = ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], s->reduction_factor);
1031 comp->coord[0][1] = ff_jpeg2000_ceildivpow2(comp->coord_o[0][1], s->reduction_factor);
1032 comp->coord[1][0] = ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], s->reduction_factor);
1033 comp->coord[1][1] = ff_jpeg2000_ceildivpow2(comp->coord_o[1][1], s->reduction_factor);
1035 if (!comp->roi_shift)
1036 comp->roi_shift = s->roi_shift[compno];
1038 return AVERROR_INVALIDDATA;
1039 if (ret = ff_jpeg2000_init_component(comp, codsty, qntsty,
1040 s->cbps[compno], s->cdx[compno],
1041 s->cdy[compno], s->avctx))
1047 /* Read the number of coding passes. */
1048 static int getnpasses(Jpeg2000DecoderContext *s)
1051 if (!get_bits(s, 1))
1053 if (!get_bits(s, 1))
1055 if ((num = get_bits(s, 2)) != 3)
1056 return num < 0 ? num : 3 + num;
1057 if ((num = get_bits(s, 5)) != 31)
1058 return num < 0 ? num : 6 + num;
1059 num = get_bits(s, 7);
1060 return num < 0 ? num : 37 + num;
1063 static int getlblockinc(Jpeg2000DecoderContext *s)
1066 while (ret = get_bits(s, 1)) {
1074 static inline void select_header(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile,
1077 s->g = tile->tile_part[*tp_index].header_tpg;
1078 if (bytestream2_get_bytes_left(&s->g) == 0 && s->bit_index == 8) {
1079 if (*tp_index < FF_ARRAY_ELEMS(tile->tile_part) - 1) {
1080 s->g = tile->tile_part[++(*tp_index)].tpg;
1085 static inline void select_stream(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile,
1086 int *tp_index, Jpeg2000CodingStyle *codsty)
1088 s->g = tile->tile_part[*tp_index].tpg;
1089 if (bytestream2_get_bytes_left(&s->g) == 0 && s->bit_index == 8) {
1090 if (*tp_index < FF_ARRAY_ELEMS(tile->tile_part) - 1) {
1091 s->g = tile->tile_part[++(*tp_index)].tpg;
1094 if (codsty->csty & JPEG2000_CSTY_SOP) {
1095 if (bytestream2_peek_be32(&s->g) == JPEG2000_SOP_FIXED_BYTES)
1096 bytestream2_skip(&s->g, JPEG2000_SOP_BYTE_LENGTH);
1098 av_log(s->avctx, AV_LOG_ERROR, "SOP marker not found. instead %X\n", bytestream2_peek_be32(&s->g));
1102 static int jpeg2000_decode_packet(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile, int *tp_index,
1103 Jpeg2000CodingStyle *codsty,
1104 Jpeg2000ResLevel *rlevel, int precno,
1105 int layno, uint8_t *expn, int numgbits)
1107 int bandno, cblkno, ret, nb_code_blocks;
1110 if (layno < rlevel->band[0].prec[precno].decoded_layers)
1112 rlevel->band[0].prec[precno].decoded_layers = layno + 1;
1113 // Select stream to read from
1115 select_header(s, tile, tp_index);
1116 else if (tile->has_ppt)
1117 s->g = tile->packed_headers_stream;
1119 select_stream(s, tile, tp_index, codsty);
1121 if (!(ret = get_bits(s, 1))) {
1127 for (bandno = 0; bandno < rlevel->nbands; bandno++) {
1128 Jpeg2000Band *band = rlevel->band + bandno;
1129 Jpeg2000Prec *prec = band->prec + precno;
1131 if (band->coord[0][0] == band->coord[0][1] ||
1132 band->coord[1][0] == band->coord[1][1])
1134 nb_code_blocks = prec->nb_codeblocks_height *
1135 prec->nb_codeblocks_width;
1136 for (cblkno = 0; cblkno < nb_code_blocks; cblkno++) {
1137 Jpeg2000Cblk *cblk = prec->cblk + cblkno;
1138 int incl, newpasses, llen;
1142 incl = get_bits(s, 1);
1144 incl = tag_tree_decode(s, prec->cblkincl + cblkno, layno + 1) == layno;
1150 if (!cblk->npasses) {
1151 int v = expn[bandno] + numgbits - 1 -
1152 tag_tree_decode(s, prec->zerobits + cblkno, 100);
1153 if (v < 0 || v > 30) {
1154 av_log(s->avctx, AV_LOG_ERROR,
1155 "nonzerobits %d invalid or unsupported\n", v);
1156 return AVERROR_INVALIDDATA;
1158 cblk->nonzerobits = v;
1160 if ((newpasses = getnpasses(s)) < 0)
1162 av_assert2(newpasses > 0);
1163 if (cblk->npasses + newpasses >= JPEG2000_MAX_PASSES) {
1164 avpriv_request_sample(s->avctx, "Too many passes");
1165 return AVERROR_PATCHWELCOME;
1167 if ((llen = getlblockinc(s)) < 0)
1169 if (cblk->lblock + llen + av_log2(newpasses) > 16) {
1170 avpriv_request_sample(s->avctx,
1171 "Block with length beyond 16 bits");
1172 return AVERROR_PATCHWELCOME;
1175 cblk->lblock += llen;
1177 cblk->nb_lengthinc = 0;
1178 cblk->nb_terminationsinc = 0;
1179 av_free(cblk->lengthinc);
1180 cblk->lengthinc = av_mallocz_array(newpasses , sizeof(*cblk->lengthinc));
1181 if (!cblk->lengthinc)
1182 return AVERROR(ENOMEM);
1183 tmp = av_realloc_array(cblk->data_start, cblk->nb_terminations + newpasses + 1, sizeof(*cblk->data_start));
1185 return AVERROR(ENOMEM);
1186 cblk->data_start = tmp;
1190 while (newpasses1 < newpasses) {
1192 if (needs_termination(codsty->cblk_style, cblk->npasses + newpasses1 - 1)) {
1193 cblk->nb_terminationsinc ++;
1198 if ((ret = get_bits(s, av_log2(newpasses1) + cblk->lblock)) < 0)
1200 if (ret > cblk->data_allocated) {
1201 size_t new_size = FFMAX(2*cblk->data_allocated, ret);
1202 void *new = av_realloc(cblk->data, new_size);
1205 cblk->data_allocated = new_size;
1208 if (ret > cblk->data_allocated) {
1209 avpriv_request_sample(s->avctx,
1210 "Block with lengthinc greater than %"SIZE_SPECIFIER"",
1211 cblk->data_allocated);
1212 return AVERROR_PATCHWELCOME;
1214 cblk->lengthinc[cblk->nb_lengthinc++] = ret;
1215 cblk->npasses += newpasses1;
1216 newpasses -= newpasses1;
1222 if (codsty->csty & JPEG2000_CSTY_EPH) {
1223 if (bytestream2_peek_be16(&s->g) == JPEG2000_EPH)
1224 bytestream2_skip(&s->g, 2);
1226 av_log(s->avctx, AV_LOG_ERROR, "EPH marker not found. instead %X\n", bytestream2_peek_be32(&s->g));
1229 // Save state of stream
1231 tile->tile_part[*tp_index].header_tpg = s->g;
1232 select_stream(s, tile, tp_index, codsty);
1233 } else if (tile->has_ppt) {
1234 tile->packed_headers_stream = s->g;
1235 select_stream(s, tile, tp_index, codsty);
1237 for (bandno = 0; bandno < rlevel->nbands; bandno++) {
1238 Jpeg2000Band *band = rlevel->band + bandno;
1239 Jpeg2000Prec *prec = band->prec + precno;
1241 nb_code_blocks = prec->nb_codeblocks_height * prec->nb_codeblocks_width;
1242 for (cblkno = 0; cblkno < nb_code_blocks; cblkno++) {
1243 Jpeg2000Cblk *cblk = prec->cblk + cblkno;
1244 if (!cblk->nb_terminationsinc && !cblk->lengthinc)
1246 for (cwsno = 0; cwsno < cblk->nb_lengthinc; cwsno ++) {
1247 if (cblk->data_allocated < cblk->length + cblk->lengthinc[cwsno] + 4) {
1248 size_t new_size = FFMAX(2*cblk->data_allocated, cblk->length + cblk->lengthinc[cwsno] + 4);
1249 void *new = av_realloc(cblk->data, new_size);
1252 cblk->data_allocated = new_size;
1255 if ( bytestream2_get_bytes_left(&s->g) < cblk->lengthinc[cwsno]
1256 || cblk->data_allocated < cblk->length + cblk->lengthinc[cwsno] + 4
1258 av_log(s->avctx, AV_LOG_ERROR,
1259 "Block length %"PRIu16" or lengthinc %d is too large, left %d\n",
1260 cblk->length, cblk->lengthinc[cwsno], bytestream2_get_bytes_left(&s->g));
1261 return AVERROR_INVALIDDATA;
1264 bytestream2_get_bufferu(&s->g, cblk->data + cblk->length, cblk->lengthinc[cwsno]);
1265 cblk->length += cblk->lengthinc[cwsno];
1266 cblk->lengthinc[cwsno] = 0;
1267 if (cblk->nb_terminationsinc) {
1268 cblk->nb_terminationsinc--;
1269 cblk->nb_terminations++;
1270 cblk->data[cblk->length++] = 0xFF;
1271 cblk->data[cblk->length++] = 0xFF;
1272 cblk->data_start[cblk->nb_terminations] = cblk->length;
1275 av_freep(&cblk->lengthinc);
1278 // Save state of stream
1279 tile->tile_part[*tp_index].tpg = s->g;
1283 if (codsty->csty & JPEG2000_CSTY_EPH) {
1284 if (bytestream2_peek_be16(&s->g) == JPEG2000_EPH)
1285 bytestream2_skip(&s->g, 2);
1287 av_log(s->avctx, AV_LOG_ERROR, "EPH marker not found. instead %X\n", bytestream2_peek_be32(&s->g));
1290 tile->tile_part[*tp_index].header_tpg = s->g;
1291 select_stream(s, tile, tp_index, codsty);
1292 } else if (tile->has_ppt) {
1293 tile->packed_headers_stream = s->g;
1294 select_stream(s, tile, tp_index, codsty);
1296 tile->tile_part[*tp_index].tpg = s->g;
1300 static int jpeg2000_decode_packets_po_iteration(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile,
1301 int RSpoc, int CSpoc,
1302 int LYEpoc, int REpoc, int CEpoc,
1303 int Ppoc, int *tp_index)
1306 int layno, reslevelno, compno, precno, ok_reslevel;
1311 case JPEG2000_PGOD_RLCP:
1312 av_log(s->avctx, AV_LOG_DEBUG, "Progression order RLCP\n");
1314 for (reslevelno = RSpoc; ok_reslevel && reslevelno < REpoc; reslevelno++) {
1316 for (layno = 0; layno < LYEpoc; layno++) {
1317 for (compno = CSpoc; compno < CEpoc; compno++) {
1318 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1319 Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
1320 if (reslevelno < codsty->nreslevels) {
1321 Jpeg2000ResLevel *rlevel = tile->comp[compno].reslevel +
1324 for (precno = 0; precno < rlevel->num_precincts_x * rlevel->num_precincts_y; precno++)
1325 if ((ret = jpeg2000_decode_packet(s, tile, tp_index,
1328 qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1329 qntsty->nguardbits)) < 0)
1337 case JPEG2000_PGOD_LRCP:
1338 av_log(s->avctx, AV_LOG_DEBUG, "Progression order LRCP\n");
1339 for (layno = 0; layno < LYEpoc; layno++) {
1341 for (reslevelno = RSpoc; ok_reslevel && reslevelno < REpoc; reslevelno++) {
1343 for (compno = CSpoc; compno < CEpoc; compno++) {
1344 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1345 Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
1346 if (reslevelno < codsty->nreslevels) {
1347 Jpeg2000ResLevel *rlevel = tile->comp[compno].reslevel +
1350 for (precno = 0; precno < rlevel->num_precincts_x * rlevel->num_precincts_y; precno++)
1351 if ((ret = jpeg2000_decode_packet(s, tile, tp_index,
1354 qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1355 qntsty->nguardbits)) < 0)
1363 case JPEG2000_PGOD_CPRL:
1364 av_log(s->avctx, AV_LOG_DEBUG, "Progression order CPRL\n");
1365 for (compno = CSpoc; compno < CEpoc; compno++) {
1366 Jpeg2000Component *comp = tile->comp + compno;
1367 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1368 Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
1372 if (RSpoc >= FFMIN(codsty->nreslevels, REpoc))
1375 for (reslevelno = RSpoc; reslevelno < FFMIN(codsty->nreslevels, REpoc); reslevelno++) {
1376 uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1377 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1378 step_x = FFMIN(step_x, rlevel->log2_prec_width + reducedresno);
1379 step_y = FFMIN(step_y, rlevel->log2_prec_height + reducedresno);
1381 if (step_x >= 31 || step_y >= 31){
1382 avpriv_request_sample(s->avctx, "CPRL with large step");
1383 return AVERROR_PATCHWELCOME;
1388 for (y = tile->coord[1][0]; y < tile->coord[1][1]; y = (y/step_y + 1)*step_y) {
1389 for (x = tile->coord[0][0]; x < tile->coord[0][1]; x = (x/step_x + 1)*step_x) {
1390 for (reslevelno = RSpoc; reslevelno < FFMIN(codsty->nreslevels, REpoc); reslevelno++) {
1391 unsigned prcx, prcy;
1392 uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1393 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1394 int xc = x / s->cdx[compno];
1395 int yc = y / s->cdy[compno];
1397 if (yc % (1LL << (rlevel->log2_prec_height + reducedresno)) && y != tile->coord[1][0]) //FIXME this is a subset of the check
1400 if (xc % (1LL << (rlevel->log2_prec_width + reducedresno)) && x != tile->coord[0][0]) //FIXME this is a subset of the check
1403 // check if a precinct exists
1404 prcx = ff_jpeg2000_ceildivpow2(xc, reducedresno) >> rlevel->log2_prec_width;
1405 prcy = ff_jpeg2000_ceildivpow2(yc, reducedresno) >> rlevel->log2_prec_height;
1406 prcx -= ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], reducedresno) >> rlevel->log2_prec_width;
1407 prcy -= ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], reducedresno) >> rlevel->log2_prec_height;
1409 precno = prcx + rlevel->num_precincts_x * prcy;
1411 if (prcx >= rlevel->num_precincts_x || prcy >= rlevel->num_precincts_y) {
1412 av_log(s->avctx, AV_LOG_WARNING, "prc %d %d outside limits %d %d\n",
1413 prcx, prcy, rlevel->num_precincts_x, rlevel->num_precincts_y);
1417 for (layno = 0; layno < LYEpoc; layno++) {
1418 if ((ret = jpeg2000_decode_packet(s, tile, tp_index, codsty, rlevel,
1420 qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1421 qntsty->nguardbits)) < 0)
1430 case JPEG2000_PGOD_RPCL:
1431 av_log(s->avctx, AV_LOG_WARNING, "Progression order RPCL\n");
1433 for (reslevelno = RSpoc; ok_reslevel && reslevelno < REpoc; reslevelno++) {
1437 for (compno = CSpoc; compno < CEpoc; compno++) {
1438 Jpeg2000Component *comp = tile->comp + compno;
1439 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1441 if (reslevelno < codsty->nreslevels) {
1442 uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1443 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1444 step_x = FFMIN(step_x, rlevel->log2_prec_width + reducedresno);
1445 step_y = FFMIN(step_y, rlevel->log2_prec_height + reducedresno);
1451 for (y = tile->coord[1][0]; y < tile->coord[1][1]; y = (y/step_y + 1)*step_y) {
1452 for (x = tile->coord[0][0]; x < tile->coord[0][1]; x = (x/step_x + 1)*step_x) {
1453 for (compno = CSpoc; compno < CEpoc; compno++) {
1454 Jpeg2000Component *comp = tile->comp + compno;
1455 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1456 Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
1457 uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1458 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1459 unsigned prcx, prcy;
1462 if (!s->cdx[compno] || !s->cdy[compno])
1463 return AVERROR_INVALIDDATA;
1465 if (reslevelno >= codsty->nreslevels)
1468 trx0 = ff_jpeg2000_ceildiv(tile->coord[0][0], (int64_t)s->cdx[compno] << reducedresno);
1469 try0 = ff_jpeg2000_ceildiv(tile->coord[1][0], (int64_t)s->cdy[compno] << reducedresno);
1471 if (!(y % ((uint64_t)s->cdy[compno] << (rlevel->log2_prec_height + reducedresno)) == 0 ||
1472 (y == tile->coord[1][0] && ((int64_t)try0 << reducedresno) % (1ULL << (reducedresno + rlevel->log2_prec_height)))))
1475 if (!(x % ((uint64_t)s->cdx[compno] << (rlevel->log2_prec_width + reducedresno)) == 0 ||
1476 (x == tile->coord[0][0] && ((int64_t)trx0 << reducedresno) % (1ULL << (reducedresno + rlevel->log2_prec_width)))))
1479 // check if a precinct exists
1480 prcx = ff_jpeg2000_ceildiv(x, (int64_t)s->cdx[compno] << reducedresno) >> rlevel->log2_prec_width;
1481 prcy = ff_jpeg2000_ceildiv(y, (int64_t)s->cdy[compno] << reducedresno) >> rlevel->log2_prec_height;
1482 prcx -= ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], reducedresno) >> rlevel->log2_prec_width;
1483 prcy -= ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], reducedresno) >> rlevel->log2_prec_height;
1485 precno = prcx + rlevel->num_precincts_x * prcy;
1488 if (prcx >= rlevel->num_precincts_x || prcy >= rlevel->num_precincts_y) {
1489 av_log(s->avctx, AV_LOG_WARNING, "prc %d %d outside limits %d %d\n",
1490 prcx, prcy, rlevel->num_precincts_x, rlevel->num_precincts_y);
1494 for (layno = 0; layno < LYEpoc; layno++) {
1495 if ((ret = jpeg2000_decode_packet(s, tile, tp_index,
1498 qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1499 qntsty->nguardbits)) < 0)
1508 case JPEG2000_PGOD_PCRL:
1509 av_log(s->avctx, AV_LOG_WARNING, "Progression order PCRL\n");
1512 for (compno = CSpoc; compno < CEpoc; compno++) {
1513 Jpeg2000Component *comp = tile->comp + compno;
1514 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1516 for (reslevelno = RSpoc; reslevelno < FFMIN(codsty->nreslevels, REpoc); reslevelno++) {
1517 uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1518 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1519 step_x = FFMIN(step_x, rlevel->log2_prec_width + reducedresno);
1520 step_y = FFMIN(step_y, rlevel->log2_prec_height + reducedresno);
1523 if (step_x >= 31 || step_y >= 31){
1524 avpriv_request_sample(s->avctx, "PCRL with large step");
1525 return AVERROR_PATCHWELCOME;
1530 for (y = tile->coord[1][0]; y < tile->coord[1][1]; y = (y/step_y + 1)*step_y) {
1531 for (x = tile->coord[0][0]; x < tile->coord[0][1]; x = (x/step_x + 1)*step_x) {
1532 for (compno = CSpoc; compno < CEpoc; compno++) {
1533 Jpeg2000Component *comp = tile->comp + compno;
1534 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1535 Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
1537 if (!s->cdx[compno] || !s->cdy[compno])
1538 return AVERROR_INVALIDDATA;
1540 for (reslevelno = RSpoc; reslevelno < FFMIN(codsty->nreslevels, REpoc); reslevelno++) {
1541 unsigned prcx, prcy;
1542 uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1543 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1546 trx0 = ff_jpeg2000_ceildiv(tile->coord[0][0], (int64_t)s->cdx[compno] << reducedresno);
1547 try0 = ff_jpeg2000_ceildiv(tile->coord[1][0], (int64_t)s->cdy[compno] << reducedresno);
1549 if (!(y % ((uint64_t)s->cdy[compno] << (rlevel->log2_prec_height + reducedresno)) == 0 ||
1550 (y == tile->coord[1][0] && ((int64_t)try0 << reducedresno) % (1ULL << (reducedresno + rlevel->log2_prec_height)))))
1553 if (!(x % ((uint64_t)s->cdx[compno] << (rlevel->log2_prec_width + reducedresno)) == 0 ||
1554 (x == tile->coord[0][0] && ((int64_t)trx0 << reducedresno) % (1ULL << (reducedresno + rlevel->log2_prec_width)))))
1557 // check if a precinct exists
1558 prcx = ff_jpeg2000_ceildiv(x, (int64_t)s->cdx[compno] << reducedresno) >> rlevel->log2_prec_width;
1559 prcy = ff_jpeg2000_ceildiv(y, (int64_t)s->cdy[compno] << reducedresno) >> rlevel->log2_prec_height;
1560 prcx -= ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], reducedresno) >> rlevel->log2_prec_width;
1561 prcy -= ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], reducedresno) >> rlevel->log2_prec_height;
1563 precno = prcx + rlevel->num_precincts_x * prcy;
1565 if (prcx >= rlevel->num_precincts_x || prcy >= rlevel->num_precincts_y) {
1566 av_log(s->avctx, AV_LOG_WARNING, "prc %d %d outside limits %d %d\n",
1567 prcx, prcy, rlevel->num_precincts_x, rlevel->num_precincts_y);
1571 for (layno = 0; layno < LYEpoc; layno++) {
1572 if ((ret = jpeg2000_decode_packet(s, tile, tp_index, codsty, rlevel,
1574 qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1575 qntsty->nguardbits)) < 0)
1591 static int jpeg2000_decode_packets(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
1593 int ret = AVERROR_BUG;
1598 if (tile->poc.nb_poc) {
1599 for (i=0; i<tile->poc.nb_poc; i++) {
1600 Jpeg2000POCEntry *e = &tile->poc.poc[i];
1601 ret = jpeg2000_decode_packets_po_iteration(s, tile,
1603 FFMIN(e->LYEpoc, tile->codsty[0].nlayers),
1605 FFMIN(e->CEpoc, s->ncomponents),
1612 ret = jpeg2000_decode_packets_po_iteration(s, tile,
1614 tile->codsty[0].nlayers,
1617 tile->codsty[0].prog_order,
1621 /* EOC marker reached */
1622 bytestream2_skip(&s->g, 2);
1627 /* TIER-1 routines */
1628 static void decode_sigpass(Jpeg2000T1Context *t1, int width, int height,
1629 int bpno, int bandno,
1630 int vert_causal_ctx_csty_symbol)
1632 int mask = 3 << (bpno - 1), y0, x, y;
1634 for (y0 = 0; y0 < height; y0 += 4)
1635 for (x = 0; x < width; x++)
1636 for (y = y0; y < height && y < y0 + 4; y++) {
1637 int flags_mask = -1;
1638 if (vert_causal_ctx_csty_symbol && y == y0 + 3)
1639 flags_mask &= ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE | JPEG2000_T1_SGN_S);
1640 if ((t1->flags[(y+1) * t1->stride + x+1] & JPEG2000_T1_SIG_NB & flags_mask)
1641 && !(t1->flags[(y+1) * t1->stride + x+1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS))) {
1642 if (ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ff_jpeg2000_getsigctxno(t1->flags[(y+1) * t1->stride + x+1] & flags_mask, bandno))) {
1643 int xorbit, ctxno = ff_jpeg2000_getsgnctxno(t1->flags[(y+1) * t1->stride + x+1] & flags_mask, &xorbit);
1645 t1->data[(y) * t1->stride + x] = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ctxno) ? -mask : mask;
1647 t1->data[(y) * t1->stride + x] = (ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ctxno) ^ xorbit) ?
1650 ff_jpeg2000_set_significance(t1, x, y,
1651 t1->data[(y) * t1->stride + x] < 0);
1653 t1->flags[(y + 1) * t1->stride + x + 1] |= JPEG2000_T1_VIS;
1658 static void decode_refpass(Jpeg2000T1Context *t1, int width, int height,
1659 int bpno, int vert_causal_ctx_csty_symbol)
1664 phalf = 1 << (bpno - 1);
1667 for (y0 = 0; y0 < height; y0 += 4)
1668 for (x = 0; x < width; x++)
1669 for (y = y0; y < height && y < y0 + 4; y++)
1670 if ((t1->flags[(y + 1) * t1->stride + x + 1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS)) == JPEG2000_T1_SIG) {
1671 int flags_mask = (vert_causal_ctx_csty_symbol && y == y0 + 3) ?
1672 ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE | JPEG2000_T1_SGN_S) : -1;
1673 int ctxno = ff_jpeg2000_getrefctxno(t1->flags[(y + 1) * t1->stride + x + 1] & flags_mask);
1674 int r = ff_mqc_decode(&t1->mqc,
1675 t1->mqc.cx_states + ctxno)
1677 t1->data[(y) * t1->stride + x] += t1->data[(y) * t1->stride + x] < 0 ? -r : r;
1678 t1->flags[(y + 1) * t1->stride + x + 1] |= JPEG2000_T1_REF;
1682 static void decode_clnpass(Jpeg2000DecoderContext *s, Jpeg2000T1Context *t1,
1683 int width, int height, int bpno, int bandno,
1684 int seg_symbols, int vert_causal_ctx_csty_symbol)
1686 int mask = 3 << (bpno - 1), y0, x, y, runlen, dec;
1688 for (y0 = 0; y0 < height; y0 += 4) {
1689 for (x = 0; x < width; x++) {
1690 int flags_mask = -1;
1691 if (vert_causal_ctx_csty_symbol)
1692 flags_mask &= ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE | JPEG2000_T1_SGN_S);
1693 if (y0 + 3 < height &&
1694 !((t1->flags[(y0 + 1) * t1->stride + x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
1695 (t1->flags[(y0 + 2) * t1->stride + x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
1696 (t1->flags[(y0 + 3) * t1->stride + x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
1697 (t1->flags[(y0 + 4) * t1->stride + x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG) & flags_mask))) {
1698 if (!ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_RL))
1700 runlen = ff_mqc_decode(&t1->mqc,
1701 t1->mqc.cx_states + MQC_CX_UNI);
1702 runlen = (runlen << 1) | ff_mqc_decode(&t1->mqc,
1711 for (y = y0 + runlen; y < y0 + 4 && y < height; y++) {
1712 int flags_mask = -1;
1713 if (vert_causal_ctx_csty_symbol && y == y0 + 3)
1714 flags_mask &= ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE | JPEG2000_T1_SGN_S);
1716 if (!(t1->flags[(y+1) * t1->stride + x+1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS))) {
1717 dec = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ff_jpeg2000_getsigctxno(t1->flags[(y+1) * t1->stride + x+1] & flags_mask,
1723 int ctxno = ff_jpeg2000_getsgnctxno(t1->flags[(y + 1) * t1->stride + x + 1] & flags_mask,
1725 t1->data[(y) * t1->stride + x] = (ff_mqc_decode(&t1->mqc,
1726 t1->mqc.cx_states + ctxno) ^
1729 ff_jpeg2000_set_significance(t1, x, y, t1->data[(y) * t1->stride + x] < 0);
1732 t1->flags[(y + 1) * t1->stride + x + 1] &= ~JPEG2000_T1_VIS;
1738 val = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1739 val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1740 val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1741 val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1743 av_log(s->avctx, AV_LOG_ERROR,
1744 "Segmentation symbol value incorrect\n");
1748 static int decode_cblk(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *codsty,
1749 Jpeg2000T1Context *t1, Jpeg2000Cblk *cblk,
1750 int width, int height, int bandpos, uint8_t roi_shift)
1752 int passno = cblk->npasses, pass_t = 2, bpno = cblk->nonzerobits - 1 + roi_shift;
1754 int vert_causal_ctx_csty_symbol = codsty->cblk_style & JPEG2000_CBLK_VSC;
1758 av_assert0(width <= 1024U && height <= 1024U);
1759 av_assert0(width*height <= 4096);
1761 memset(t1->data, 0, t1->stride * height * sizeof(*t1->data));
1763 /* If code-block contains no compressed data: nothing to do. */
1767 memset(t1->flags, 0, t1->stride * (height + 2) * sizeof(*t1->flags));
1769 cblk->data[cblk->length] = 0xff;
1770 cblk->data[cblk->length+1] = 0xff;
1771 ff_mqc_initdec(&t1->mqc, cblk->data, 0, 1);
1774 if (bpno < 0 || bpno > 29) {
1775 av_log(s->avctx, AV_LOG_ERROR, "bpno became invalid\n");
1776 return AVERROR_INVALIDDATA;
1780 decode_sigpass(t1, width, height, bpno + 1, bandpos,
1781 vert_causal_ctx_csty_symbol);
1784 decode_refpass(t1, width, height, bpno + 1, vert_causal_ctx_csty_symbol);
1787 av_assert2(!t1->mqc.raw);
1788 decode_clnpass(s, t1, width, height, bpno + 1, bandpos,
1789 codsty->cblk_style & JPEG2000_CBLK_SEGSYM,
1790 vert_causal_ctx_csty_symbol);
1793 if (codsty->cblk_style & JPEG2000_CBLK_RESET) // XXX no testcase for just this
1794 ff_mqc_init_contexts(&t1->mqc);
1796 if (passno && (coder_type = needs_termination(codsty->cblk_style, pass_cnt))) {
1797 if (term_cnt >= cblk->nb_terminations) {
1798 av_log(s->avctx, AV_LOG_ERROR, "Missing needed termination \n");
1799 return AVERROR_INVALIDDATA;
1801 if (FFABS(cblk->data + cblk->data_start[term_cnt + 1] - 2 - t1->mqc.bp) > 0) {
1802 av_log(s->avctx, AV_LOG_WARNING, "Mid mismatch %"PTRDIFF_SPECIFIER" in pass %d of %d\n",
1803 cblk->data + cblk->data_start[term_cnt + 1] - 2 - t1->mqc.bp,
1804 pass_cnt, cblk->npasses);
1807 ff_mqc_initdec(&t1->mqc, cblk->data + cblk->data_start[++term_cnt], coder_type == 2, 0);
1818 if (cblk->data + cblk->length - 2 > t1->mqc.bp) {
1819 av_log(s->avctx, AV_LOG_WARNING, "End mismatch %"PTRDIFF_SPECIFIER"\n",
1820 cblk->data + cblk->length - 2 - t1->mqc.bp);
1823 if (cblk->data + cblk->length < t1->mqc.bp) {
1824 av_log(s->avctx, AV_LOG_WARNING, "Synthetic End of Stream Marker Read.\n");
1830 static inline int roi_shift_param(Jpeg2000Component *comp,
1835 roi_shift = comp->roi_shift;
1836 val = (quan_parameter < 0)?-quan_parameter:quan_parameter;
1838 if (val > (1 << roi_shift))
1839 return (quan_parameter < 0)?-(val >> roi_shift):(val >> roi_shift);
1840 return quan_parameter;
1843 /* TODO: Verify dequantization for lossless case
1844 * comp->data can be float or int
1845 * band->stepsize can be float or int
1846 * depending on the type of DWT transformation.
1847 * see ISO/IEC 15444-1:2002 A.6.1 */
1849 /* Float dequantization of a codeblock.*/
1850 static void dequantization_float(int x, int y, Jpeg2000Cblk *cblk,
1851 Jpeg2000Component *comp,
1852 Jpeg2000T1Context *t1, Jpeg2000Band *band)
1855 int w = cblk->coord[0][1] - cblk->coord[0][0];
1856 for (j = 0; j < (cblk->coord[1][1] - cblk->coord[1][0]); ++j) {
1857 float *datap = &comp->f_data[(comp->coord[0][1] - comp->coord[0][0]) * (y + j) + x];
1858 int *src = t1->data + j*t1->stride;
1859 for (i = 0; i < w; ++i)
1860 datap[i] = src[i] * band->f_stepsize;
1864 /* Integer dequantization of a codeblock.*/
1865 static void dequantization_int(int x, int y, Jpeg2000Cblk *cblk,
1866 Jpeg2000Component *comp,
1867 Jpeg2000T1Context *t1, Jpeg2000Band *band)
1870 int w = cblk->coord[0][1] - cblk->coord[0][0];
1871 for (j = 0; j < (cblk->coord[1][1] - cblk->coord[1][0]); ++j) {
1872 int32_t *datap = &comp->i_data[(comp->coord[0][1] - comp->coord[0][0]) * (y + j) + x];
1873 int *src = t1->data + j*t1->stride;
1874 if (band->i_stepsize == 32768) {
1875 for (i = 0; i < w; ++i)
1876 datap[i] = src[i] / 2;
1878 // This should be VERY uncommon
1879 for (i = 0; i < w; ++i)
1880 datap[i] = (src[i] * (int64_t)band->i_stepsize) / 65536;
1885 static void dequantization_int_97(int x, int y, Jpeg2000Cblk *cblk,
1886 Jpeg2000Component *comp,
1887 Jpeg2000T1Context *t1, Jpeg2000Band *band)
1890 int w = cblk->coord[0][1] - cblk->coord[0][0];
1891 for (j = 0; j < (cblk->coord[1][1] - cblk->coord[1][0]); ++j) {
1892 int32_t *datap = &comp->i_data[(comp->coord[0][1] - comp->coord[0][0]) * (y + j) + x];
1893 int *src = t1->data + j*t1->stride;
1894 for (i = 0; i < w; ++i)
1895 datap[i] = (src[i] * (int64_t)band->i_stepsize + (1<<15)) >> 16;
1899 static inline void mct_decode(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
1904 for (i = 1; i < 3; i++) {
1905 if (tile->codsty[0].transform != tile->codsty[i].transform) {
1906 av_log(s->avctx, AV_LOG_ERROR, "Transforms mismatch, MCT not supported\n");
1909 if (memcmp(tile->comp[0].coord, tile->comp[i].coord, sizeof(tile->comp[0].coord))) {
1910 av_log(s->avctx, AV_LOG_ERROR, "Coords mismatch, MCT not supported\n");
1915 for (i = 0; i < 3; i++)
1916 if (tile->codsty[0].transform == FF_DWT97)
1917 src[i] = tile->comp[i].f_data;
1919 src[i] = tile->comp[i].i_data;
1921 for (i = 0; i < 2; i++)
1922 csize *= tile->comp[0].coord[i][1] - tile->comp[0].coord[i][0];
1924 s->dsp.mct_decode[tile->codsty[0].transform](src[0], src[1], src[2], csize);
1927 static inline void roi_scale_cblk(Jpeg2000Cblk *cblk,
1928 Jpeg2000Component *comp,
1929 Jpeg2000T1Context *t1)
1932 int w = cblk->coord[0][1] - cblk->coord[0][0];
1933 for (j = 0; j < (cblk->coord[1][1] - cblk->coord[1][0]); ++j) {
1934 int *src = t1->data + j*t1->stride;
1935 for (i = 0; i < w; ++i)
1936 src[i] = roi_shift_param(comp, src[i]);
1940 static inline void tile_codeblocks(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
1942 Jpeg2000T1Context t1;
1944 int compno, reslevelno, bandno;
1946 /* Loop on tile components */
1947 for (compno = 0; compno < s->ncomponents; compno++) {
1948 Jpeg2000Component *comp = tile->comp + compno;
1949 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1952 t1.stride = (1<<codsty->log2_cblk_width) + 2;
1954 /* Loop on resolution levels */
1955 for (reslevelno = 0; reslevelno < codsty->nreslevels2decode; reslevelno++) {
1956 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1958 for (bandno = 0; bandno < rlevel->nbands; bandno++) {
1959 int nb_precincts, precno;
1960 Jpeg2000Band *band = rlevel->band + bandno;
1961 int cblkno = 0, bandpos;
1963 bandpos = bandno + (reslevelno > 0);
1965 if (band->coord[0][0] == band->coord[0][1] ||
1966 band->coord[1][0] == band->coord[1][1])
1969 nb_precincts = rlevel->num_precincts_x * rlevel->num_precincts_y;
1970 /* Loop on precincts */
1971 for (precno = 0; precno < nb_precincts; precno++) {
1972 Jpeg2000Prec *prec = band->prec + precno;
1974 /* Loop on codeblocks */
1976 cblkno < prec->nb_codeblocks_width * prec->nb_codeblocks_height;
1979 Jpeg2000Cblk *cblk = prec->cblk + cblkno;
1980 int ret = decode_cblk(s, codsty, &t1, cblk,
1981 cblk->coord[0][1] - cblk->coord[0][0],
1982 cblk->coord[1][1] - cblk->coord[1][0],
1983 bandpos, comp->roi_shift);
1988 x = cblk->coord[0][0] - band->coord[0][0];
1989 y = cblk->coord[1][0] - band->coord[1][0];
1991 if (comp->roi_shift)
1992 roi_scale_cblk(cblk, comp, &t1);
1993 if (codsty->transform == FF_DWT97)
1994 dequantization_float(x, y, cblk, comp, &t1, band);
1995 else if (codsty->transform == FF_DWT97_INT)
1996 dequantization_int_97(x, y, cblk, comp, &t1, band);
1998 dequantization_int(x, y, cblk, comp, &t1, band);
2002 } /* end reslevel */
2006 ff_dwt_decode(&comp->dwt, codsty->transform == FF_DWT97 ? (void*)comp->f_data : (void*)comp->i_data);
2011 #define WRITE_FRAME(D, PIXEL) \
2012 static inline void write_frame_ ## D(Jpeg2000DecoderContext * s, Jpeg2000Tile * tile, \
2013 AVFrame * picture, int precision) \
2015 const AVPixFmtDescriptor *pixdesc = av_pix_fmt_desc_get(s->avctx->pix_fmt); \
2016 int planar = !!(pixdesc->flags & AV_PIX_FMT_FLAG_PLANAR); \
2017 int pixelsize = planar ? 1 : pixdesc->nb_components; \
2022 for (compno = 0; compno < s->ncomponents; compno++) { \
2023 Jpeg2000Component *comp = tile->comp + compno; \
2024 Jpeg2000CodingStyle *codsty = tile->codsty + compno; \
2026 float *datap = comp->f_data; \
2027 int32_t *i_datap = comp->i_data; \
2028 int cbps = s->cbps[compno]; \
2029 int w = tile->comp[compno].coord[0][1] - \
2030 ff_jpeg2000_ceildiv(s->image_offset_x, s->cdx[compno]); \
2031 int h = tile->comp[compno].coord[1][1] - \
2032 ff_jpeg2000_ceildiv(s->image_offset_y, s->cdy[compno]); \
2036 plane = s->cdef[compno] ? s->cdef[compno]-1 : (s->ncomponents-1); \
2038 y = tile->comp[compno].coord[1][0] - \
2039 ff_jpeg2000_ceildiv(s->image_offset_y, s->cdy[compno]); \
2040 line = (PIXEL *)picture->data[plane] + y * (picture->linesize[plane] / sizeof(PIXEL));\
2041 for (; y < h; y++) { \
2044 x = tile->comp[compno].coord[0][0] - \
2045 ff_jpeg2000_ceildiv(s->image_offset_x, s->cdx[compno]); \
2046 dst = line + x * pixelsize + compno*!planar; \
2048 if (codsty->transform == FF_DWT97) { \
2049 for (; x < w; x++) { \
2050 int val = lrintf(*datap) + (1 << (cbps - 1)); \
2051 /* DC level shift and clip see ISO 15444-1:2002 G.1.2 */ \
2052 val = av_clip(val, 0, (1 << cbps) - 1); \
2053 *dst = val << (precision - cbps); \
2058 for (; x < w; x++) { \
2059 int val = *i_datap + (1 << (cbps - 1)); \
2060 /* DC level shift and clip see ISO 15444-1:2002 G.1.2 */ \
2061 val = av_clip(val, 0, (1 << cbps) - 1); \
2062 *dst = val << (precision - cbps); \
2067 line += picture->linesize[plane] / sizeof(PIXEL); \
2073 WRITE_FRAME(8, uint8_t)
2074 WRITE_FRAME(16, uint16_t)
2078 static int jpeg2000_decode_tile(AVCodecContext *avctx, void *td,
2079 int jobnr, int threadnr)
2081 Jpeg2000DecoderContext *s = avctx->priv_data;
2082 AVFrame *picture = td;
2083 Jpeg2000Tile *tile = s->tile + jobnr;
2086 tile_codeblocks(s, tile);
2088 /* inverse MCT transformation */
2089 if (tile->codsty[0].mct)
2090 mct_decode(s, tile);
2092 for (x = 0; x < s->ncomponents; x++) {
2093 if (s->cdef[x] < 0) {
2094 for (x = 0; x < s->ncomponents; x++) {
2097 if ((s->ncomponents & 1) == 0)
2098 s->cdef[s->ncomponents-1] = 0;
2103 if (s->precision <= 8) {
2104 write_frame_8(s, tile, picture, 8);
2106 int precision = picture->format == AV_PIX_FMT_XYZ12 ||
2107 picture->format == AV_PIX_FMT_RGB48 ||
2108 picture->format == AV_PIX_FMT_RGBA64 ||
2109 picture->format == AV_PIX_FMT_GRAY16 ? 16 : s->precision;
2111 write_frame_16(s, tile, picture, precision);
2117 static void jpeg2000_dec_cleanup(Jpeg2000DecoderContext *s)
2120 for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++) {
2121 if (s->tile[tileno].comp) {
2122 for (compno = 0; compno < s->ncomponents; compno++) {
2123 Jpeg2000Component *comp = s->tile[tileno].comp + compno;
2124 Jpeg2000CodingStyle *codsty = s->tile[tileno].codsty + compno;
2126 ff_jpeg2000_cleanup(comp, codsty);
2128 av_freep(&s->tile[tileno].comp);
2129 av_freep(&s->tile[tileno].packed_headers);
2130 s->tile[tileno].packed_headers_size = 0;
2133 av_freep(&s->packed_headers);
2134 s->packed_headers_size = 0;
2135 memset(&s->packed_headers_stream, 0, sizeof(s->packed_headers_stream));
2137 memset(s->codsty, 0, sizeof(s->codsty));
2138 memset(s->qntsty, 0, sizeof(s->qntsty));
2139 memset(s->properties, 0, sizeof(s->properties));
2140 memset(&s->poc , 0, sizeof(s->poc));
2141 s->numXtiles = s->numYtiles = 0;
2145 static int jpeg2000_read_main_headers(Jpeg2000DecoderContext *s)
2147 Jpeg2000CodingStyle *codsty = s->codsty;
2148 Jpeg2000QuantStyle *qntsty = s->qntsty;
2149 Jpeg2000POC *poc = &s->poc;
2150 uint8_t *properties = s->properties;
2157 if (bytestream2_get_bytes_left(&s->g) < 2) {
2158 av_log(s->avctx, AV_LOG_ERROR, "Missing EOC\n");
2162 marker = bytestream2_get_be16u(&s->g);
2163 oldpos = bytestream2_tell(&s->g);
2164 if (marker >= 0xFF30 && marker <= 0xFF3F)
2166 if (marker == JPEG2000_SOD) {
2168 Jpeg2000TilePart *tp;
2171 av_log(s->avctx, AV_LOG_ERROR, "Missing SIZ\n");
2172 return AVERROR_INVALIDDATA;
2174 if (s->curtileno < 0) {
2175 av_log(s->avctx, AV_LOG_ERROR, "Missing SOT\n");
2176 return AVERROR_INVALIDDATA;
2179 tile = s->tile + s->curtileno;
2180 tp = tile->tile_part + tile->tp_idx;
2181 if (tp->tp_end < s->g.buffer) {
2182 av_log(s->avctx, AV_LOG_ERROR, "Invalid tpend\n");
2183 return AVERROR_INVALIDDATA;
2187 uint32_t tp_header_size = bytestream2_get_be32(&s->packed_headers_stream);
2188 if (bytestream2_get_bytes_left(&s->packed_headers_stream) < tp_header_size)
2189 return AVERROR_INVALIDDATA;
2190 bytestream2_init(&tp->header_tpg, s->packed_headers_stream.buffer, tp_header_size);
2191 bytestream2_skip(&s->packed_headers_stream, tp_header_size);
2193 if (tile->has_ppt && tile->tp_idx == 0) {
2194 bytestream2_init(&tile->packed_headers_stream, tile->packed_headers, tile->packed_headers_size);
2197 bytestream2_init(&tp->tpg, s->g.buffer, tp->tp_end - s->g.buffer);
2198 bytestream2_skip(&s->g, tp->tp_end - s->g.buffer);
2202 if (marker == JPEG2000_EOC)
2205 len = bytestream2_get_be16(&s->g);
2206 if (len < 2 || bytestream2_get_bytes_left(&s->g) < len - 2) {
2207 if (s->avctx->strict_std_compliance >= FF_COMPLIANCE_STRICT) {
2208 av_log(s->avctx, AV_LOG_ERROR, "Invalid len %d left=%d\n", len, bytestream2_get_bytes_left(&s->g));
2209 return AVERROR_INVALIDDATA;
2211 av_log(s->avctx, AV_LOG_WARNING, "Missing EOC Marker.\n");
2217 if (s->ncomponents) {
2218 av_log(s->avctx, AV_LOG_ERROR, "Duplicate SIZ\n");
2219 return AVERROR_INVALIDDATA;
2223 s->numXtiles = s->numYtiles = 0;
2226 ret = get_coc(s, codsty, properties);
2229 ret = get_cod(s, codsty, properties);
2232 ret = get_rgn(s, len);
2235 ret = get_qcc(s, len, qntsty, properties);
2238 ret = get_qcd(s, len, qntsty, properties);
2241 ret = get_poc(s, len, poc);
2244 if (!s->in_tile_headers) {
2245 s->in_tile_headers = 1;
2247 bytestream2_init(&s->packed_headers_stream, s->packed_headers, s->packed_headers_size);
2250 if (!(ret = get_sot(s, len))) {
2251 av_assert1(s->curtileno >= 0);
2252 codsty = s->tile[s->curtileno].codsty;
2253 qntsty = s->tile[s->curtileno].qntsty;
2254 poc = &s->tile[s->curtileno].poc;
2255 properties = s->tile[s->curtileno].properties;
2259 // the PLM marker is ignored
2261 // the comment is ignored
2262 bytestream2_skip(&s->g, len - 2);
2265 ret = read_crg(s, len);
2268 // Tile-part lengths
2269 ret = get_tlm(s, len);
2272 // Packet length, tile-part header
2273 ret = get_plt(s, len);
2276 // Packed headers, main header
2277 if (s->in_tile_headers) {
2278 av_log(s->avctx, AV_LOG_ERROR, "PPM Marker can only be in Main header\n");
2279 return AVERROR_INVALIDDATA;
2281 ret = get_ppm(s, len);
2284 // Packed headers, tile-part header
2286 av_log(s->avctx, AV_LOG_ERROR,
2287 "Cannot have both PPT and PPM marker.\n");
2288 return AVERROR_INVALIDDATA;
2291 ret = get_ppt(s, len);
2294 av_log(s->avctx, AV_LOG_ERROR,
2295 "unsupported marker 0x%.4"PRIX16" at pos 0x%X\n",
2296 marker, bytestream2_tell(&s->g) - 4);
2297 bytestream2_skip(&s->g, len - 2);
2300 if (bytestream2_tell(&s->g) - oldpos != len || ret) {
2301 av_log(s->avctx, AV_LOG_ERROR,
2302 "error during processing marker segment %.4"PRIx16"\n",
2304 return ret ? ret : -1;
2310 /* Read bit stream packets --> T2 operation. */
2311 static int jpeg2000_read_bitstream_packets(Jpeg2000DecoderContext *s)
2316 for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++) {
2317 Jpeg2000Tile *tile = s->tile + tileno;
2319 if ((ret = init_tile(s, tileno)) < 0)
2322 if ((ret = jpeg2000_decode_packets(s, tile)) < 0)
2329 static int jp2_find_codestream(Jpeg2000DecoderContext *s)
2331 uint32_t atom_size, atom, atom_end;
2332 int search_range = 10;
2336 bytestream2_get_bytes_left(&s->g) >= 8) {
2337 atom_size = bytestream2_get_be32u(&s->g);
2338 atom = bytestream2_get_be32u(&s->g);
2339 if (atom_size == 1) {
2340 if (bytestream2_get_be32u(&s->g)) {
2341 avpriv_request_sample(s->avctx, "Huge atom");
2344 atom_size = bytestream2_get_be32u(&s->g);
2345 atom_end = bytestream2_tell(&s->g) + atom_size - 16;
2347 atom_end = bytestream2_tell(&s->g) + atom_size - 8;
2350 if (atom == JP2_CODESTREAM)
2353 if (bytestream2_get_bytes_left(&s->g) < atom_size || atom_end < atom_size)
2356 if (atom == JP2_HEADER &&
2358 uint32_t atom2_size, atom2, atom2_end;
2360 atom2_size = bytestream2_get_be32u(&s->g);
2361 atom2 = bytestream2_get_be32u(&s->g);
2362 atom2_end = bytestream2_tell(&s->g) + atom2_size - 8;
2363 if (atom2_size < 8 || atom2_end > atom_end || atom2_end < atom2_size)
2366 if (atom2 == JP2_CODESTREAM) {
2368 } else if (atom2 == MKBETAG('c','o','l','r') && atom2_size >= 7) {
2369 int method = bytestream2_get_byteu(&s->g);
2370 bytestream2_skipu(&s->g, 2);
2372 s->colour_space = bytestream2_get_be32u(&s->g);
2374 } else if (atom2 == MKBETAG('p','c','l','r') && atom2_size >= 6) {
2375 int i, size, colour_count, colour_channels, colour_depth[3];
2376 colour_count = bytestream2_get_be16u(&s->g);
2377 colour_channels = bytestream2_get_byteu(&s->g);
2378 // FIXME: Do not ignore channel_sign
2379 colour_depth[0] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1;
2380 colour_depth[1] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1;
2381 colour_depth[2] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1;
2382 size = (colour_depth[0] + 7 >> 3) * colour_count +
2383 (colour_depth[1] + 7 >> 3) * colour_count +
2384 (colour_depth[2] + 7 >> 3) * colour_count;
2385 if (colour_count > AVPALETTE_COUNT ||
2386 colour_channels != 3 ||
2387 colour_depth[0] > 16 ||
2388 colour_depth[1] > 16 ||
2389 colour_depth[2] > 16 ||
2390 atom2_size < size) {
2391 avpriv_request_sample(s->avctx, "Unknown palette");
2392 bytestream2_seek(&s->g, atom2_end, SEEK_SET);
2396 for (i = 0; i < colour_count; i++) {
2398 if (colour_depth[0] <= 8) {
2399 r = bytestream2_get_byteu(&s->g) << 8 - colour_depth[0];
2400 r |= r >> colour_depth[0];
2402 r = bytestream2_get_be16u(&s->g) >> colour_depth[0] - 8;
2404 if (colour_depth[1] <= 8) {
2405 g = bytestream2_get_byteu(&s->g) << 8 - colour_depth[1];
2406 g |= g >> colour_depth[1];
2408 g = bytestream2_get_be16u(&s->g) >> colour_depth[1] - 8;
2410 if (colour_depth[2] <= 8) {
2411 b = bytestream2_get_byteu(&s->g) << 8 - colour_depth[2];
2412 b |= b >> colour_depth[2];
2414 b = bytestream2_get_be16u(&s->g) >> colour_depth[2] - 8;
2416 s->palette[i] = 0xffu << 24 | r << 16 | g << 8 | b;
2418 } else if (atom2 == MKBETAG('c','d','e','f') && atom2_size >= 2) {
2419 int n = bytestream2_get_be16u(&s->g);
2421 int cn = bytestream2_get_be16(&s->g);
2422 int av_unused typ = bytestream2_get_be16(&s->g);
2423 int asoc = bytestream2_get_be16(&s->g);
2424 if (cn < 4 && asoc < 4)
2427 } else if (atom2 == MKBETAG('r','e','s',' ') && atom2_size >= 18) {
2428 int64_t vnum, vden, hnum, hden, vexp, hexp;
2430 bytestream2_skip(&s->g, 4);
2431 resx = bytestream2_get_be32u(&s->g);
2432 if (resx != MKBETAG('r','e','s','c') && resx != MKBETAG('r','e','s','d')) {
2433 bytestream2_seek(&s->g, atom2_end, SEEK_SET);
2436 vnum = bytestream2_get_be16u(&s->g);
2437 vden = bytestream2_get_be16u(&s->g);
2438 hnum = bytestream2_get_be16u(&s->g);
2439 hden = bytestream2_get_be16u(&s->g);
2440 vexp = bytestream2_get_byteu(&s->g);
2441 hexp = bytestream2_get_byteu(&s->g);
2442 if (!vnum || !vden || !hnum || !hden) {
2443 bytestream2_seek(&s->g, atom2_end, SEEK_SET);
2444 av_log(s->avctx, AV_LOG_WARNING, "RES box invalid\n");
2454 if ( INT64_MAX / (hnum * vden) > pow(10, hexp)
2455 && INT64_MAX / (vnum * hden) > pow(10, vexp))
2456 av_reduce(&s->sar.den, &s->sar.num,
2457 hnum * vden * pow(10, hexp),
2458 vnum * hden * pow(10, vexp),
2461 bytestream2_seek(&s->g, atom2_end, SEEK_SET);
2462 } while (atom_end - atom2_end >= 8);
2466 bytestream2_seek(&s->g, atom_end, SEEK_SET);
2472 static av_cold void jpeg2000_init_static_data(void)
2474 ff_jpeg2000_init_tier1_luts();
2475 ff_mqc_init_context_tables();
2478 static av_cold int jpeg2000_decode_init(AVCodecContext *avctx)
2480 static AVOnce init_static_once = AV_ONCE_INIT;
2481 Jpeg2000DecoderContext *s = avctx->priv_data;
2483 ff_thread_once(&init_static_once, jpeg2000_init_static_data);
2484 ff_jpeg2000dsp_init(&s->dsp);
2489 static int jpeg2000_decode_frame(AVCodecContext *avctx, void *data,
2490 int *got_frame, AVPacket *avpkt)
2492 Jpeg2000DecoderContext *s = avctx->priv_data;
2493 ThreadFrame frame = { .f = data };
2494 AVFrame *picture = data;
2498 bytestream2_init(&s->g, avpkt->data, avpkt->size);
2500 memset(s->cdef, -1, sizeof(s->cdef));
2502 if (bytestream2_get_bytes_left(&s->g) < 2) {
2503 ret = AVERROR_INVALIDDATA;
2507 // check if the image is in jp2 format
2508 if (bytestream2_get_bytes_left(&s->g) >= 12 &&
2509 (bytestream2_get_be32u(&s->g) == 12) &&
2510 (bytestream2_get_be32u(&s->g) == JP2_SIG_TYPE) &&
2511 (bytestream2_get_be32u(&s->g) == JP2_SIG_VALUE)) {
2512 if (!jp2_find_codestream(s)) {
2513 av_log(avctx, AV_LOG_ERROR,
2514 "Could not find Jpeg2000 codestream atom.\n");
2515 ret = AVERROR_INVALIDDATA;
2519 bytestream2_seek(&s->g, 0, SEEK_SET);
2522 while (bytestream2_get_bytes_left(&s->g) >= 3 && bytestream2_peek_be16(&s->g) != JPEG2000_SOC)
2523 bytestream2_skip(&s->g, 1);
2525 if (bytestream2_get_be16u(&s->g) != JPEG2000_SOC) {
2526 av_log(avctx, AV_LOG_ERROR, "SOC marker not present\n");
2527 ret = AVERROR_INVALIDDATA;
2530 if (ret = jpeg2000_read_main_headers(s))
2533 /* get picture buffer */
2534 if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
2536 picture->pict_type = AV_PICTURE_TYPE_I;
2537 picture->key_frame = 1;
2539 if (ret = jpeg2000_read_bitstream_packets(s))
2542 avctx->execute2(avctx, jpeg2000_decode_tile, picture, NULL, s->numXtiles * s->numYtiles);
2544 jpeg2000_dec_cleanup(s);
2548 if (s->avctx->pix_fmt == AV_PIX_FMT_PAL8)
2549 memcpy(picture->data[1], s->palette, 256 * sizeof(uint32_t));
2550 if (s->sar.num && s->sar.den)
2551 avctx->sample_aspect_ratio = s->sar;
2552 s->sar.num = s->sar.den = 0;
2554 return bytestream2_tell(&s->g);
2557 jpeg2000_dec_cleanup(s);
2561 #define OFFSET(x) offsetof(Jpeg2000DecoderContext, x)
2562 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
2564 static const AVOption options[] = {
2565 { "lowres", "Lower the decoding resolution by a power of two",
2566 OFFSET(reduction_factor), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, JPEG2000_MAX_RESLEVELS - 1, VD },
2570 static const AVClass jpeg2000_class = {
2571 .class_name = "jpeg2000",
2572 .item_name = av_default_item_name,
2574 .version = LIBAVUTIL_VERSION_INT,
2577 AVCodec ff_jpeg2000_decoder = {
2579 .long_name = NULL_IF_CONFIG_SMALL("JPEG 2000"),
2580 .type = AVMEDIA_TYPE_VIDEO,
2581 .id = AV_CODEC_ID_JPEG2000,
2582 .capabilities = AV_CODEC_CAP_SLICE_THREADS | AV_CODEC_CAP_FRAME_THREADS | AV_CODEC_CAP_DR1,
2583 .priv_data_size = sizeof(Jpeg2000DecoderContext),
2584 .init = jpeg2000_decode_init,
2585 .decode = jpeg2000_decode_frame,
2586 .priv_class = &jpeg2000_class,
2588 .profiles = NULL_IF_CONFIG_SMALL(ff_jpeg2000_profiles)