2 * JPEG 2000 image decoder
3 * Copyright (c) 2007 Kamil Nowosad
4 * Copyright (c) 2013 Nicolas Bertrand <nicoinattendu@gmail.com>
6 * This file is part of FFmpeg.
8 * FFmpeg is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
13 * FFmpeg is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with FFmpeg; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
25 * JPEG 2000 image decoder
30 #include "libavutil/attributes.h"
31 #include "libavutil/avassert.h"
32 #include "libavutil/common.h"
33 #include "libavutil/imgutils.h"
34 #include "libavutil/opt.h"
35 #include "libavutil/pixdesc.h"
37 #include "bytestream.h"
41 #include "jpeg2000dsp.h"
44 #define JP2_SIG_TYPE 0x6A502020
45 #define JP2_SIG_VALUE 0x0D0A870A
46 #define JP2_CODESTREAM 0x6A703263
47 #define JP2_HEADER 0x6A703268
54 typedef struct Jpeg2000POCEntry {
63 typedef struct Jpeg2000POC {
64 Jpeg2000POCEntry poc[MAX_POCS];
69 typedef struct Jpeg2000TilePart {
70 uint8_t tile_index; // Tile index who refers the tile-part
71 const uint8_t *tp_end;
72 GetByteContext tpg; // bit stream in tile-part
75 /* RMK: For JPEG2000 DCINEMA 3 tile-parts in a tile
76 * one per component, so tile_part elements have a size of 3 */
77 typedef struct Jpeg2000Tile {
78 Jpeg2000Component *comp;
79 uint8_t properties[4];
80 Jpeg2000CodingStyle codsty[4];
81 Jpeg2000QuantStyle qntsty[4];
83 Jpeg2000TilePart tile_part[256];
84 uint16_t tp_idx; // Tile-part index
85 int coord[2][2]; // border coordinates {{x0, x1}, {y0, y1}}
88 typedef struct Jpeg2000DecoderContext {
90 AVCodecContext *avctx;
94 int image_offset_x, image_offset_y;
95 int tile_offset_x, tile_offset_y;
96 uint8_t cbps[4]; // bits per sample in particular components
97 uint8_t sgnd[4]; // if a component is signed
98 uint8_t properties[4];
103 uint32_t palette[256];
106 int tile_width, tile_height;
107 unsigned numXtiles, numYtiles;
110 Jpeg2000CodingStyle codsty[4];
111 Jpeg2000QuantStyle qntsty[4];
119 Jpeg2000DSPContext dsp;
121 /*options parameters*/
122 int reduction_factor;
123 } Jpeg2000DecoderContext;
125 /* get_bits functions for JPEG2000 packet bitstream
126 * It is a get_bit function with a bit-stuffing routine. If the value of the
127 * byte is 0xFF, the next byte includes an extra zero bit stuffed into the MSB.
128 * cf. ISO-15444-1:2002 / B.10.1 Bit-stuffing routine */
129 static int get_bits(Jpeg2000DecoderContext *s, int n)
135 if (s->bit_index == 0) {
136 s->bit_index = 7 + (bytestream2_get_byte(&s->g) != 0xFFu);
139 res |= (bytestream2_peek_byte(&s->g) >> s->bit_index) & 1;
144 static void jpeg2000_flush(Jpeg2000DecoderContext *s)
146 if (bytestream2_get_byte(&s->g) == 0xff)
147 bytestream2_skip(&s->g, 1);
151 /* decode the value stored in node */
152 static int tag_tree_decode(Jpeg2000DecoderContext *s, Jpeg2000TgtNode *node,
155 Jpeg2000TgtNode *stack[30];
156 int sp = -1, curval = 0;
159 av_log(s->avctx, AV_LOG_ERROR, "missing node\n");
160 return AVERROR_INVALIDDATA;
163 while (node && !node->vis) {
171 curval = stack[sp]->val;
173 while (curval < threshold && sp >= 0) {
174 if (curval < stack[sp]->val)
175 curval = stack[sp]->val;
176 while (curval < threshold) {
178 if ((ret = get_bits(s, 1)) > 0) {
186 stack[sp]->val = curval;
192 static int pix_fmt_match(enum AVPixelFormat pix_fmt, int components,
193 int bpc, uint32_t log2_chroma_wh, int pal8)
196 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
200 if (desc->nb_components != components) {
204 switch (components) {
206 match = match && desc->comp[3].depth >= bpc &&
207 (log2_chroma_wh >> 14 & 3) == 0 &&
208 (log2_chroma_wh >> 12 & 3) == 0;
210 match = match && desc->comp[2].depth >= bpc &&
211 (log2_chroma_wh >> 10 & 3) == desc->log2_chroma_w &&
212 (log2_chroma_wh >> 8 & 3) == desc->log2_chroma_h;
214 match = match && desc->comp[1].depth >= bpc &&
215 (log2_chroma_wh >> 6 & 3) == desc->log2_chroma_w &&
216 (log2_chroma_wh >> 4 & 3) == desc->log2_chroma_h;
219 match = match && desc->comp[0].depth >= bpc &&
220 (log2_chroma_wh >> 2 & 3) == 0 &&
221 (log2_chroma_wh & 3) == 0 &&
222 (desc->flags & AV_PIX_FMT_FLAG_PAL) == pal8 * AV_PIX_FMT_FLAG_PAL;
227 // pix_fmts with lower bpp have to be listed before
228 // similar pix_fmts with higher bpp.
229 #define RGB_PIXEL_FORMATS AV_PIX_FMT_PAL8,AV_PIX_FMT_RGB24,AV_PIX_FMT_RGBA,AV_PIX_FMT_RGB48,AV_PIX_FMT_RGBA64
230 #define GRAY_PIXEL_FORMATS AV_PIX_FMT_GRAY8,AV_PIX_FMT_GRAY8A,AV_PIX_FMT_GRAY16,AV_PIX_FMT_YA16
231 #define YUV_PIXEL_FORMATS AV_PIX_FMT_YUV410P,AV_PIX_FMT_YUV411P,AV_PIX_FMT_YUVA420P, \
232 AV_PIX_FMT_YUV420P,AV_PIX_FMT_YUV422P,AV_PIX_FMT_YUVA422P, \
233 AV_PIX_FMT_YUV440P,AV_PIX_FMT_YUV444P,AV_PIX_FMT_YUVA444P, \
234 AV_PIX_FMT_YUV420P9,AV_PIX_FMT_YUV422P9,AV_PIX_FMT_YUV444P9, \
235 AV_PIX_FMT_YUVA420P9,AV_PIX_FMT_YUVA422P9,AV_PIX_FMT_YUVA444P9, \
236 AV_PIX_FMT_YUV420P10,AV_PIX_FMT_YUV422P10,AV_PIX_FMT_YUV444P10, \
237 AV_PIX_FMT_YUVA420P10,AV_PIX_FMT_YUVA422P10,AV_PIX_FMT_YUVA444P10, \
238 AV_PIX_FMT_YUV420P12,AV_PIX_FMT_YUV422P12,AV_PIX_FMT_YUV444P12, \
239 AV_PIX_FMT_YUV420P14,AV_PIX_FMT_YUV422P14,AV_PIX_FMT_YUV444P14, \
240 AV_PIX_FMT_YUV420P16,AV_PIX_FMT_YUV422P16,AV_PIX_FMT_YUV444P16, \
241 AV_PIX_FMT_YUVA420P16,AV_PIX_FMT_YUVA422P16,AV_PIX_FMT_YUVA444P16
242 #define XYZ_PIXEL_FORMATS AV_PIX_FMT_XYZ12
244 static const enum AVPixelFormat rgb_pix_fmts[] = {RGB_PIXEL_FORMATS};
245 static const enum AVPixelFormat gray_pix_fmts[] = {GRAY_PIXEL_FORMATS};
246 static const enum AVPixelFormat yuv_pix_fmts[] = {YUV_PIXEL_FORMATS};
247 static const enum AVPixelFormat xyz_pix_fmts[] = {XYZ_PIXEL_FORMATS,
249 static const enum AVPixelFormat all_pix_fmts[] = {RGB_PIXEL_FORMATS,
254 /* marker segments */
255 /* get sizes and offsets of image, tiles; number of components */
256 static int get_siz(Jpeg2000DecoderContext *s)
260 uint32_t log2_chroma_wh = 0;
261 const enum AVPixelFormat *possible_fmts = NULL;
262 int possible_fmts_nb = 0;
264 if (bytestream2_get_bytes_left(&s->g) < 36) {
265 av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for SIZ\n");
266 return AVERROR_INVALIDDATA;
269 s->avctx->profile = bytestream2_get_be16u(&s->g); // Rsiz
270 s->width = bytestream2_get_be32u(&s->g); // Width
271 s->height = bytestream2_get_be32u(&s->g); // Height
272 s->image_offset_x = bytestream2_get_be32u(&s->g); // X0Siz
273 s->image_offset_y = bytestream2_get_be32u(&s->g); // Y0Siz
274 s->tile_width = bytestream2_get_be32u(&s->g); // XTSiz
275 s->tile_height = bytestream2_get_be32u(&s->g); // YTSiz
276 s->tile_offset_x = bytestream2_get_be32u(&s->g); // XT0Siz
277 s->tile_offset_y = bytestream2_get_be32u(&s->g); // YT0Siz
278 ncomponents = bytestream2_get_be16u(&s->g); // CSiz
280 if (s->image_offset_x || s->image_offset_y) {
281 avpriv_request_sample(s->avctx, "Support for image offsets");
282 return AVERROR_PATCHWELCOME;
284 if (av_image_check_size(s->width, s->height, 0, s->avctx)) {
285 avpriv_request_sample(s->avctx, "Large Dimensions");
286 return AVERROR_PATCHWELCOME;
289 if (ncomponents <= 0) {
290 av_log(s->avctx, AV_LOG_ERROR, "Invalid number of components: %d\n",
292 return AVERROR_INVALIDDATA;
295 if (ncomponents > 4) {
296 avpriv_request_sample(s->avctx, "Support for %d components",
298 return AVERROR_PATCHWELCOME;
301 s->ncomponents = ncomponents;
303 if (s->tile_width <= 0 || s->tile_height <= 0) {
304 av_log(s->avctx, AV_LOG_ERROR, "Invalid tile dimension %dx%d.\n",
305 s->tile_width, s->tile_height);
306 return AVERROR_INVALIDDATA;
309 if (bytestream2_get_bytes_left(&s->g) < 3 * s->ncomponents) {
310 av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for %d components in SIZ\n", s->ncomponents);
311 return AVERROR_INVALIDDATA;
314 for (i = 0; i < s->ncomponents; i++) { // Ssiz_i XRsiz_i, YRsiz_i
315 uint8_t x = bytestream2_get_byteu(&s->g);
316 s->cbps[i] = (x & 0x7f) + 1;
317 s->precision = FFMAX(s->cbps[i], s->precision);
318 s->sgnd[i] = !!(x & 0x80);
319 s->cdx[i] = bytestream2_get_byteu(&s->g);
320 s->cdy[i] = bytestream2_get_byteu(&s->g);
321 if ( !s->cdx[i] || s->cdx[i] == 3 || s->cdx[i] > 4
322 || !s->cdy[i] || s->cdy[i] == 3 || s->cdy[i] > 4) {
323 av_log(s->avctx, AV_LOG_ERROR, "Invalid sample separation %d/%d\n", s->cdx[i], s->cdy[i]);
324 return AVERROR_INVALIDDATA;
326 log2_chroma_wh |= s->cdy[i] >> 1 << i * 4 | s->cdx[i] >> 1 << i * 4 + 2;
329 s->numXtiles = ff_jpeg2000_ceildiv(s->width - s->tile_offset_x, s->tile_width);
330 s->numYtiles = ff_jpeg2000_ceildiv(s->height - s->tile_offset_y, s->tile_height);
332 if (s->numXtiles * (uint64_t)s->numYtiles > INT_MAX/sizeof(*s->tile)) {
333 s->numXtiles = s->numYtiles = 0;
334 return AVERROR(EINVAL);
337 s->tile = av_mallocz_array(s->numXtiles * s->numYtiles, sizeof(*s->tile));
339 s->numXtiles = s->numYtiles = 0;
340 return AVERROR(ENOMEM);
343 for (i = 0; i < s->numXtiles * s->numYtiles; i++) {
344 Jpeg2000Tile *tile = s->tile + i;
346 tile->comp = av_mallocz(s->ncomponents * sizeof(*tile->comp));
348 return AVERROR(ENOMEM);
351 /* compute image size with reduction factor */
352 s->avctx->width = ff_jpeg2000_ceildivpow2(s->width - s->image_offset_x,
353 s->reduction_factor);
354 s->avctx->height = ff_jpeg2000_ceildivpow2(s->height - s->image_offset_y,
355 s->reduction_factor);
357 if (s->avctx->profile == FF_PROFILE_JPEG2000_DCINEMA_2K ||
358 s->avctx->profile == FF_PROFILE_JPEG2000_DCINEMA_4K) {
359 possible_fmts = xyz_pix_fmts;
360 possible_fmts_nb = FF_ARRAY_ELEMS(xyz_pix_fmts);
362 switch (s->colour_space) {
364 possible_fmts = rgb_pix_fmts;
365 possible_fmts_nb = FF_ARRAY_ELEMS(rgb_pix_fmts);
368 possible_fmts = gray_pix_fmts;
369 possible_fmts_nb = FF_ARRAY_ELEMS(gray_pix_fmts);
372 possible_fmts = yuv_pix_fmts;
373 possible_fmts_nb = FF_ARRAY_ELEMS(yuv_pix_fmts);
376 possible_fmts = all_pix_fmts;
377 possible_fmts_nb = FF_ARRAY_ELEMS(all_pix_fmts);
381 for (i = 0; i < possible_fmts_nb; ++i) {
382 if (pix_fmt_match(possible_fmts[i], ncomponents, s->precision, log2_chroma_wh, s->pal8)) {
383 s->avctx->pix_fmt = possible_fmts[i];
388 if (i == possible_fmts_nb) {
389 if (ncomponents == 4 &&
390 s->cdy[0] == 1 && s->cdx[0] == 1 &&
391 s->cdy[1] == 1 && s->cdx[1] == 1 &&
392 s->cdy[2] == s->cdy[3] && s->cdx[2] == s->cdx[3]) {
393 if (s->precision == 8 && s->cdy[2] == 2 && s->cdx[2] == 2 && !s->pal8) {
394 s->avctx->pix_fmt = AV_PIX_FMT_YUVA420P;
405 if (i == possible_fmts_nb) {
406 av_log(s->avctx, AV_LOG_ERROR,
407 "Unknown pix_fmt, profile: %d, colour_space: %d, "
408 "components: %d, precision: %d\n"
409 "cdx[0]: %d, cdy[0]: %d\n"
410 "cdx[1]: %d, cdy[1]: %d\n"
411 "cdx[2]: %d, cdy[2]: %d\n"
412 "cdx[3]: %d, cdy[3]: %d\n",
413 s->avctx->profile, s->colour_space, ncomponents, s->precision,
416 ncomponents > 1 ? s->cdx[1] : 0,
417 ncomponents > 1 ? s->cdy[1] : 0,
418 ncomponents > 2 ? s->cdx[2] : 0,
419 ncomponents > 2 ? s->cdy[2] : 0,
420 ncomponents > 3 ? s->cdx[3] : 0,
421 ncomponents > 3 ? s->cdy[3] : 0);
422 return AVERROR_PATCHWELCOME;
424 s->avctx->bits_per_raw_sample = s->precision;
428 /* get common part for COD and COC segments */
429 static int get_cox(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c)
433 if (bytestream2_get_bytes_left(&s->g) < 5) {
434 av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for COX\n");
435 return AVERROR_INVALIDDATA;
438 /* nreslevels = number of resolution levels
439 = number of decomposition level +1 */
440 c->nreslevels = bytestream2_get_byteu(&s->g) + 1;
441 if (c->nreslevels >= JPEG2000_MAX_RESLEVELS) {
442 av_log(s->avctx, AV_LOG_ERROR, "nreslevels %d is invalid\n", c->nreslevels);
443 return AVERROR_INVALIDDATA;
446 if (c->nreslevels <= s->reduction_factor) {
447 /* we are forced to update reduction_factor as its requested value is
448 not compatible with this bitstream, and as we might have used it
449 already in setup earlier we have to fail this frame until
450 reinitialization is implemented */
451 av_log(s->avctx, AV_LOG_ERROR, "reduction_factor too large for this bitstream, max is %d\n", c->nreslevels - 1);
452 s->reduction_factor = c->nreslevels - 1;
453 return AVERROR(EINVAL);
456 /* compute number of resolution levels to decode */
457 c->nreslevels2decode = c->nreslevels - s->reduction_factor;
459 c->log2_cblk_width = (bytestream2_get_byteu(&s->g) & 15) + 2; // cblk width
460 c->log2_cblk_height = (bytestream2_get_byteu(&s->g) & 15) + 2; // cblk height
462 if (c->log2_cblk_width > 10 || c->log2_cblk_height > 10 ||
463 c->log2_cblk_width + c->log2_cblk_height > 12) {
464 av_log(s->avctx, AV_LOG_ERROR, "cblk size invalid\n");
465 return AVERROR_INVALIDDATA;
468 c->cblk_style = bytestream2_get_byteu(&s->g);
469 if (c->cblk_style != 0) { // cblk style
470 av_log(s->avctx, AV_LOG_WARNING, "extra cblk styles %X\n", c->cblk_style);
471 if (c->cblk_style & JPEG2000_CBLK_BYPASS)
472 av_log(s->avctx, AV_LOG_WARNING, "Selective arithmetic coding bypass\n");
474 c->transform = bytestream2_get_byteu(&s->g); // DWT transformation type
475 /* set integer 9/7 DWT in case of BITEXACT flag */
476 if ((s->avctx->flags & AV_CODEC_FLAG_BITEXACT) && (c->transform == FF_DWT97))
477 c->transform = FF_DWT97_INT;
478 else if (c->transform == FF_DWT53) {
479 s->avctx->properties |= FF_CODEC_PROPERTY_LOSSLESS;
482 if (c->csty & JPEG2000_CSTY_PREC) {
484 for (i = 0; i < c->nreslevels; i++) {
485 byte = bytestream2_get_byte(&s->g);
486 c->log2_prec_widths[i] = byte & 0x0F; // precinct PPx
487 c->log2_prec_heights[i] = (byte >> 4) & 0x0F; // precinct PPy
489 if (c->log2_prec_widths[i] == 0 || c->log2_prec_heights[i] == 0) {
490 av_log(s->avctx, AV_LOG_ERROR, "PPx %d PPy %d invalid\n",
491 c->log2_prec_widths[i], c->log2_prec_heights[i]);
492 c->log2_prec_widths[i] = c->log2_prec_heights[i] = 1;
493 return AVERROR_INVALIDDATA;
497 memset(c->log2_prec_widths , 15, sizeof(c->log2_prec_widths ));
498 memset(c->log2_prec_heights, 15, sizeof(c->log2_prec_heights));
503 /* get coding parameters for a particular tile or whole image*/
504 static int get_cod(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c,
507 Jpeg2000CodingStyle tmp;
510 if (bytestream2_get_bytes_left(&s->g) < 5) {
511 av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for COD\n");
512 return AVERROR_INVALIDDATA;
515 tmp.csty = bytestream2_get_byteu(&s->g);
517 // get progression order
518 tmp.prog_order = bytestream2_get_byteu(&s->g);
520 tmp.nlayers = bytestream2_get_be16u(&s->g);
521 tmp.mct = bytestream2_get_byteu(&s->g); // multiple component transformation
523 if (tmp.mct && s->ncomponents < 3) {
524 av_log(s->avctx, AV_LOG_ERROR,
525 "MCT %"PRIu8" with too few components (%d)\n",
526 tmp.mct, s->ncomponents);
527 return AVERROR_INVALIDDATA;
530 if ((ret = get_cox(s, &tmp)) < 0)
533 for (compno = 0; compno < s->ncomponents; compno++)
534 if (!(properties[compno] & HAD_COC))
535 memcpy(c + compno, &tmp, sizeof(tmp));
539 /* Get coding parameters for a component in the whole image or a
540 * particular tile. */
541 static int get_coc(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c,
546 if (bytestream2_get_bytes_left(&s->g) < 2) {
547 av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for COC\n");
548 return AVERROR_INVALIDDATA;
551 compno = bytestream2_get_byteu(&s->g);
553 if (compno >= s->ncomponents) {
554 av_log(s->avctx, AV_LOG_ERROR,
555 "Invalid compno %d. There are %d components in the image.\n",
556 compno, s->ncomponents);
557 return AVERROR_INVALIDDATA;
561 c->csty = bytestream2_get_byteu(&s->g);
563 if ((ret = get_cox(s, c)) < 0)
566 properties[compno] |= HAD_COC;
570 /* Get common part for QCD and QCC segments. */
571 static int get_qcx(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q)
575 if (bytestream2_get_bytes_left(&s->g) < 1)
576 return AVERROR_INVALIDDATA;
578 x = bytestream2_get_byteu(&s->g); // Sqcd
580 q->nguardbits = x >> 5;
581 q->quantsty = x & 0x1f;
583 if (q->quantsty == JPEG2000_QSTY_NONE) {
585 if (bytestream2_get_bytes_left(&s->g) < n ||
586 n > JPEG2000_MAX_DECLEVELS*3)
587 return AVERROR_INVALIDDATA;
588 for (i = 0; i < n; i++)
589 q->expn[i] = bytestream2_get_byteu(&s->g) >> 3;
590 } else if (q->quantsty == JPEG2000_QSTY_SI) {
591 if (bytestream2_get_bytes_left(&s->g) < 2)
592 return AVERROR_INVALIDDATA;
593 x = bytestream2_get_be16u(&s->g);
594 q->expn[0] = x >> 11;
595 q->mant[0] = x & 0x7ff;
596 for (i = 1; i < JPEG2000_MAX_DECLEVELS * 3; i++) {
597 int curexpn = FFMAX(0, q->expn[0] - (i - 1) / 3);
598 q->expn[i] = curexpn;
599 q->mant[i] = q->mant[0];
603 if (bytestream2_get_bytes_left(&s->g) < 2 * n ||
604 n > JPEG2000_MAX_DECLEVELS*3)
605 return AVERROR_INVALIDDATA;
606 for (i = 0; i < n; i++) {
607 x = bytestream2_get_be16u(&s->g);
608 q->expn[i] = x >> 11;
609 q->mant[i] = x & 0x7ff;
615 /* Get quantization parameters for a particular tile or a whole image. */
616 static int get_qcd(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q,
619 Jpeg2000QuantStyle tmp;
622 memset(&tmp, 0, sizeof(tmp));
624 if ((ret = get_qcx(s, n, &tmp)) < 0)
626 for (compno = 0; compno < s->ncomponents; compno++)
627 if (!(properties[compno] & HAD_QCC))
628 memcpy(q + compno, &tmp, sizeof(tmp));
632 /* Get quantization parameters for a component in the whole image
633 * on in a particular tile. */
634 static int get_qcc(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q,
639 if (bytestream2_get_bytes_left(&s->g) < 1)
640 return AVERROR_INVALIDDATA;
642 compno = bytestream2_get_byteu(&s->g);
644 if (compno >= s->ncomponents) {
645 av_log(s->avctx, AV_LOG_ERROR,
646 "Invalid compno %d. There are %d components in the image.\n",
647 compno, s->ncomponents);
648 return AVERROR_INVALIDDATA;
651 properties[compno] |= HAD_QCC;
652 return get_qcx(s, n - 1, q + compno);
655 static int get_poc(Jpeg2000DecoderContext *s, int size, Jpeg2000POC *p)
658 int elem_size = s->ncomponents <= 257 ? 7 : 9;
659 Jpeg2000POC tmp = {{{0}}};
661 if (bytestream2_get_bytes_left(&s->g) < 5 || size < 2 + elem_size) {
662 av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for POC\n");
663 return AVERROR_INVALIDDATA;
667 avpriv_request_sample(s->avctx, "Fat POC not supported");
668 return AVERROR_PATCHWELCOME;
671 tmp.nb_poc = (size - 2) / elem_size;
672 if (tmp.nb_poc > MAX_POCS) {
673 avpriv_request_sample(s->avctx, "Too many POCs (%d)", tmp.nb_poc);
674 return AVERROR_PATCHWELCOME;
677 for (i = 0; i<tmp.nb_poc; i++) {
678 Jpeg2000POCEntry *e = &tmp.poc[i];
679 e->RSpoc = bytestream2_get_byteu(&s->g);
680 e->CSpoc = bytestream2_get_byteu(&s->g);
681 e->LYEpoc = bytestream2_get_be16u(&s->g);
682 e->REpoc = bytestream2_get_byteu(&s->g);
683 e->CEpoc = bytestream2_get_byteu(&s->g);
684 e->Ppoc = bytestream2_get_byteu(&s->g);
687 if (e->CEpoc > s->ncomponents)
688 e->CEpoc = s->ncomponents;
689 if ( e->RSpoc >= e->REpoc || e->REpoc > 33
690 || e->CSpoc >= e->CEpoc || e->CEpoc > s->ncomponents
692 av_log(s->avctx, AV_LOG_ERROR, "POC Entry %d is invalid (%d, %d, %d, %d, %d, %d)\n", i,
693 e->RSpoc, e->CSpoc, e->LYEpoc, e->REpoc, e->CEpoc, e->Ppoc
695 return AVERROR_INVALIDDATA;
699 if (!p->nb_poc || p->is_default) {
702 if (p->nb_poc + tmp.nb_poc > MAX_POCS) {
703 av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for POC\n");
704 return AVERROR_INVALIDDATA;
706 memcpy(p->poc + p->nb_poc, tmp.poc, tmp.nb_poc * sizeof(tmp.poc[0]));
707 p->nb_poc += tmp.nb_poc;
716 /* Get start of tile segment. */
717 static int get_sot(Jpeg2000DecoderContext *s, int n)
719 Jpeg2000TilePart *tp;
724 if (bytestream2_get_bytes_left(&s->g) < 8)
725 return AVERROR_INVALIDDATA;
728 Isot = bytestream2_get_be16u(&s->g); // Isot
729 if (Isot >= s->numXtiles * s->numYtiles)
730 return AVERROR_INVALIDDATA;
733 Psot = bytestream2_get_be32u(&s->g); // Psot
734 TPsot = bytestream2_get_byteu(&s->g); // TPsot
736 /* Read TNSot but not used */
737 bytestream2_get_byteu(&s->g); // TNsot
740 Psot = bytestream2_get_bytes_left(&s->g) + n + 2;
742 if (Psot > bytestream2_get_bytes_left(&s->g) + n + 2) {
743 av_log(s->avctx, AV_LOG_ERROR, "Psot %"PRIu32" too big\n", Psot);
744 return AVERROR_INVALIDDATA;
747 av_assert0(TPsot < FF_ARRAY_ELEMS(s->tile[Isot].tile_part));
749 s->tile[Isot].tp_idx = TPsot;
750 tp = s->tile[Isot].tile_part + TPsot;
751 tp->tile_index = Isot;
752 tp->tp_end = s->g.buffer + Psot - n - 2;
755 Jpeg2000Tile *tile = s->tile + s->curtileno;
758 memcpy(tile->codsty, s->codsty, s->ncomponents * sizeof(Jpeg2000CodingStyle));
759 memcpy(tile->qntsty, s->qntsty, s->ncomponents * sizeof(Jpeg2000QuantStyle));
760 memcpy(&tile->poc , &s->poc , sizeof(tile->poc));
761 tile->poc.is_default = 1;
767 /* Tile-part lengths: see ISO 15444-1:2002, section A.7.1
768 * Used to know the number of tile parts and lengths.
769 * There may be multiple TLMs in the header.
770 * TODO: The function is not used for tile-parts management, nor anywhere else.
771 * It can be useful to allocate memory for tile parts, before managing the SOT
772 * markers. Parsing the TLM header is needed to increment the input header
774 * This marker is mandatory for DCI. */
775 static uint8_t get_tlm(Jpeg2000DecoderContext *s, int n)
777 uint8_t Stlm, ST, SP, tile_tlm, i;
778 bytestream2_get_byte(&s->g); /* Ztlm: skipped */
779 Stlm = bytestream2_get_byte(&s->g);
781 // too complex ? ST = ((Stlm >> 4) & 0x01) + ((Stlm >> 4) & 0x02);
782 ST = (Stlm >> 4) & 0x03;
783 // TODO: Manage case of ST = 0b11 --> raise error
784 SP = (Stlm >> 6) & 0x01;
785 tile_tlm = (n - 4) / ((SP + 1) * 2 + ST);
786 for (i = 0; i < tile_tlm; i++) {
791 bytestream2_get_byte(&s->g);
794 bytestream2_get_be16(&s->g);
797 bytestream2_get_be32(&s->g);
801 bytestream2_get_be16(&s->g);
803 bytestream2_get_be32(&s->g);
809 static uint8_t get_plt(Jpeg2000DecoderContext *s, int n)
813 av_log(s->avctx, AV_LOG_DEBUG,
814 "PLT marker at pos 0x%X\n", bytestream2_tell(&s->g) - 4);
816 /*Zplt =*/ bytestream2_get_byte(&s->g);
818 for (i = 0; i < n - 3; i++) {
819 bytestream2_get_byte(&s->g);
825 static int init_tile(Jpeg2000DecoderContext *s, int tileno)
828 int tilex = tileno % s->numXtiles;
829 int tiley = tileno / s->numXtiles;
830 Jpeg2000Tile *tile = s->tile + tileno;
833 return AVERROR(ENOMEM);
835 tile->coord[0][0] = av_clip(tilex * (int64_t)s->tile_width + s->tile_offset_x, s->image_offset_x, s->width);
836 tile->coord[0][1] = av_clip((tilex + 1) * (int64_t)s->tile_width + s->tile_offset_x, s->image_offset_x, s->width);
837 tile->coord[1][0] = av_clip(tiley * (int64_t)s->tile_height + s->tile_offset_y, s->image_offset_y, s->height);
838 tile->coord[1][1] = av_clip((tiley + 1) * (int64_t)s->tile_height + s->tile_offset_y, s->image_offset_y, s->height);
840 for (compno = 0; compno < s->ncomponents; compno++) {
841 Jpeg2000Component *comp = tile->comp + compno;
842 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
843 Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
844 int ret; // global bandno
846 comp->coord_o[0][0] = tile->coord[0][0];
847 comp->coord_o[0][1] = tile->coord[0][1];
848 comp->coord_o[1][0] = tile->coord[1][0];
849 comp->coord_o[1][1] = tile->coord[1][1];
851 comp->coord_o[0][0] /= s->cdx[compno];
852 comp->coord_o[0][1] /= s->cdx[compno];
853 comp->coord_o[1][0] /= s->cdy[compno];
854 comp->coord_o[1][1] /= s->cdy[compno];
857 comp->coord[0][0] = ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], s->reduction_factor);
858 comp->coord[0][1] = ff_jpeg2000_ceildivpow2(comp->coord_o[0][1], s->reduction_factor);
859 comp->coord[1][0] = ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], s->reduction_factor);
860 comp->coord[1][1] = ff_jpeg2000_ceildivpow2(comp->coord_o[1][1], s->reduction_factor);
862 if (ret = ff_jpeg2000_init_component(comp, codsty, qntsty,
863 s->cbps[compno], s->cdx[compno],
864 s->cdy[compno], s->avctx))
870 /* Read the number of coding passes. */
871 static int getnpasses(Jpeg2000DecoderContext *s)
878 if ((num = get_bits(s, 2)) != 3)
879 return num < 0 ? num : 3 + num;
880 if ((num = get_bits(s, 5)) != 31)
881 return num < 0 ? num : 6 + num;
882 num = get_bits(s, 7);
883 return num < 0 ? num : 37 + num;
886 static int getlblockinc(Jpeg2000DecoderContext *s)
889 while (ret = get_bits(s, 1)) {
897 static int jpeg2000_decode_packet(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile, int *tp_index,
898 Jpeg2000CodingStyle *codsty,
899 Jpeg2000ResLevel *rlevel, int precno,
900 int layno, uint8_t *expn, int numgbits)
902 int bandno, cblkno, ret, nb_code_blocks;
905 if (layno < rlevel->band[0].prec[precno].decoded_layers)
907 rlevel->band[0].prec[precno].decoded_layers = layno + 1;
909 if (bytestream2_get_bytes_left(&s->g) == 0 && s->bit_index == 8) {
910 if (*tp_index < FF_ARRAY_ELEMS(tile->tile_part) - 1) {
911 s->g = tile->tile_part[++(*tp_index)].tpg;
915 if (bytestream2_peek_be32(&s->g) == JPEG2000_SOP_FIXED_BYTES)
916 bytestream2_skip(&s->g, JPEG2000_SOP_BYTE_LENGTH);
918 if (!(ret = get_bits(s, 1))) {
924 for (bandno = 0; bandno < rlevel->nbands; bandno++) {
925 Jpeg2000Band *band = rlevel->band + bandno;
926 Jpeg2000Prec *prec = band->prec + precno;
928 if (band->coord[0][0] == band->coord[0][1] ||
929 band->coord[1][0] == band->coord[1][1])
931 nb_code_blocks = prec->nb_codeblocks_height *
932 prec->nb_codeblocks_width;
933 for (cblkno = 0; cblkno < nb_code_blocks; cblkno++) {
934 Jpeg2000Cblk *cblk = prec->cblk + cblkno;
935 int incl, newpasses, llen;
938 incl = get_bits(s, 1);
940 incl = tag_tree_decode(s, prec->cblkincl + cblkno, layno + 1) == layno;
946 if (!cblk->npasses) {
947 int v = expn[bandno] + numgbits - 1 -
948 tag_tree_decode(s, prec->zerobits + cblkno, 100);
950 av_log(s->avctx, AV_LOG_ERROR,
951 "nonzerobits %d invalid\n", v);
952 return AVERROR_INVALIDDATA;
954 cblk->nonzerobits = v;
956 if ((newpasses = getnpasses(s)) < 0)
958 av_assert2(newpasses > 0);
959 if (cblk->npasses + newpasses >= JPEG2000_MAX_PASSES) {
960 avpriv_request_sample(s->avctx, "Too many passes");
961 return AVERROR_PATCHWELCOME;
963 if ((llen = getlblockinc(s)) < 0)
965 if (cblk->lblock + llen + av_log2(newpasses) > 16) {
966 avpriv_request_sample(s->avctx,
967 "Block with length beyond 16 bits");
968 return AVERROR_PATCHWELCOME;
971 cblk->lblock += llen;
973 cblk->nb_lengthinc = 0;
974 cblk->nb_terminationsinc = 0;
978 while (newpasses1 < newpasses) {
980 if (needs_termination(codsty->cblk_style, cblk->npasses + newpasses1 - 1)) {
981 cblk->nb_terminationsinc ++;
986 if ((ret = get_bits(s, av_log2(newpasses1) + cblk->lblock)) < 0)
988 if (ret > sizeof(cblk->data)) {
989 avpriv_request_sample(s->avctx,
990 "Block with lengthinc greater than %"SIZE_SPECIFIER"",
992 return AVERROR_PATCHWELCOME;
994 cblk->lengthinc[cblk->nb_lengthinc++] = ret;
995 cblk->npasses += newpasses1;
996 newpasses -= newpasses1;
1002 if (codsty->csty & JPEG2000_CSTY_EPH) {
1003 if (bytestream2_peek_be16(&s->g) == JPEG2000_EPH)
1004 bytestream2_skip(&s->g, 2);
1006 av_log(s->avctx, AV_LOG_ERROR, "EPH marker not found. instead %X\n", bytestream2_peek_be32(&s->g));
1009 for (bandno = 0; bandno < rlevel->nbands; bandno++) {
1010 Jpeg2000Band *band = rlevel->band + bandno;
1011 Jpeg2000Prec *prec = band->prec + precno;
1013 nb_code_blocks = prec->nb_codeblocks_height * prec->nb_codeblocks_width;
1014 for (cblkno = 0; cblkno < nb_code_blocks; cblkno++) {
1015 Jpeg2000Cblk *cblk = prec->cblk + cblkno;
1016 for (cwsno = 0; cwsno < cblk->nb_lengthinc; cwsno ++) {
1017 if ( bytestream2_get_bytes_left(&s->g) < cblk->lengthinc[cwsno]
1018 || sizeof(cblk->data) < cblk->length + cblk->lengthinc[cwsno] + 4
1020 av_log(s->avctx, AV_LOG_ERROR,
1021 "Block length %"PRIu16" or lengthinc %d is too large, left %d\n",
1022 cblk->length, cblk->lengthinc[cwsno], bytestream2_get_bytes_left(&s->g));
1023 return AVERROR_INVALIDDATA;
1026 bytestream2_get_bufferu(&s->g, cblk->data + cblk->length, cblk->lengthinc[cwsno]);
1027 cblk->length += cblk->lengthinc[cwsno];
1028 cblk->lengthinc[cwsno] = 0;
1029 if (cblk->nb_terminationsinc) {
1030 cblk->nb_terminationsinc--;
1031 cblk->nb_terminations++;
1032 cblk->data[cblk->length++] = 0xFF;
1033 cblk->data[cblk->length++] = 0xFF;
1034 cblk->data_start[cblk->nb_terminations] = cblk->length;
1042 static int jpeg2000_decode_packets_po_iteration(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile,
1043 int RSpoc, int CSpoc,
1044 int LYEpoc, int REpoc, int CEpoc,
1045 int Ppoc, int *tp_index)
1048 int layno, reslevelno, compno, precno, ok_reslevel;
1053 case JPEG2000_PGOD_RLCP:
1054 av_log(s->avctx, AV_LOG_DEBUG, "Progression order RLCP\n");
1056 for (reslevelno = RSpoc; ok_reslevel && reslevelno < REpoc; reslevelno++) {
1058 for (layno = 0; layno < LYEpoc; layno++) {
1059 for (compno = CSpoc; compno < CEpoc; compno++) {
1060 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1061 Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
1062 if (reslevelno < codsty->nreslevels) {
1063 Jpeg2000ResLevel *rlevel = tile->comp[compno].reslevel +
1066 for (precno = 0; precno < rlevel->num_precincts_x * rlevel->num_precincts_y; precno++)
1067 if ((ret = jpeg2000_decode_packet(s, tile, tp_index,
1070 qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1071 qntsty->nguardbits)) < 0)
1079 case JPEG2000_PGOD_LRCP:
1080 av_log(s->avctx, AV_LOG_DEBUG, "Progression order LRCP\n");
1081 for (layno = 0; layno < LYEpoc; layno++) {
1083 for (reslevelno = RSpoc; ok_reslevel && reslevelno < REpoc; reslevelno++) {
1085 for (compno = CSpoc; compno < CEpoc; compno++) {
1086 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1087 Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
1088 if (reslevelno < codsty->nreslevels) {
1089 Jpeg2000ResLevel *rlevel = tile->comp[compno].reslevel +
1092 for (precno = 0; precno < rlevel->num_precincts_x * rlevel->num_precincts_y; precno++)
1093 if ((ret = jpeg2000_decode_packet(s, tile, tp_index,
1096 qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1097 qntsty->nguardbits)) < 0)
1105 case JPEG2000_PGOD_CPRL:
1106 av_log(s->avctx, AV_LOG_DEBUG, "Progression order CPRL\n");
1107 for (compno = CSpoc; compno < CEpoc; compno++) {
1108 Jpeg2000Component *comp = tile->comp + compno;
1109 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1110 Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
1114 for (reslevelno = RSpoc; reslevelno < FFMIN(codsty->nreslevels, REpoc); reslevelno++) {
1115 uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1116 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1117 step_x = FFMIN(step_x, rlevel->log2_prec_width + reducedresno);
1118 step_y = FFMIN(step_y, rlevel->log2_prec_height + reducedresno);
1120 av_assert0(step_x < 32 && step_y < 32);
1124 for (y = tile->coord[1][0]; y < tile->coord[1][1]; y = (y/step_y + 1)*step_y) {
1125 for (x = tile->coord[0][0]; x < tile->coord[0][1]; x = (x/step_x + 1)*step_x) {
1126 for (reslevelno = RSpoc; reslevelno < FFMIN(codsty->nreslevels, REpoc); reslevelno++) {
1127 unsigned prcx, prcy;
1128 uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1129 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1130 int xc = x / s->cdx[compno];
1131 int yc = y / s->cdy[compno];
1133 if (yc % (1 << (rlevel->log2_prec_height + reducedresno)) && y != tile->coord[1][0]) //FIXME this is a subset of the check
1136 if (xc % (1 << (rlevel->log2_prec_width + reducedresno)) && x != tile->coord[0][0]) //FIXME this is a subset of the check
1139 // check if a precinct exists
1140 prcx = ff_jpeg2000_ceildivpow2(xc, reducedresno) >> rlevel->log2_prec_width;
1141 prcy = ff_jpeg2000_ceildivpow2(yc, reducedresno) >> rlevel->log2_prec_height;
1142 prcx -= ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], reducedresno) >> rlevel->log2_prec_width;
1143 prcy -= ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], reducedresno) >> rlevel->log2_prec_height;
1145 precno = prcx + rlevel->num_precincts_x * prcy;
1147 if (prcx >= rlevel->num_precincts_x || prcy >= rlevel->num_precincts_y) {
1148 av_log(s->avctx, AV_LOG_WARNING, "prc %d %d outside limits %d %d\n",
1149 prcx, prcy, rlevel->num_precincts_x, rlevel->num_precincts_y);
1153 for (layno = 0; layno < LYEpoc; layno++) {
1154 if ((ret = jpeg2000_decode_packet(s, tile, tp_index, codsty, rlevel,
1156 qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1157 qntsty->nguardbits)) < 0)
1166 case JPEG2000_PGOD_RPCL:
1167 av_log(s->avctx, AV_LOG_WARNING, "Progression order RPCL\n");
1169 for (reslevelno = RSpoc; ok_reslevel && reslevelno < REpoc; reslevelno++) {
1173 for (compno = CSpoc; compno < CEpoc; compno++) {
1174 Jpeg2000Component *comp = tile->comp + compno;
1175 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1177 if (reslevelno < codsty->nreslevels) {
1178 uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1179 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1180 step_x = FFMIN(step_x, rlevel->log2_prec_width + reducedresno);
1181 step_y = FFMIN(step_y, rlevel->log2_prec_height + reducedresno);
1187 for (y = tile->coord[1][0]; y < tile->coord[1][1]; y = (y/step_y + 1)*step_y) {
1188 for (x = tile->coord[0][0]; x < tile->coord[0][1]; x = (x/step_x + 1)*step_x) {
1189 for (compno = CSpoc; compno < CEpoc; compno++) {
1190 Jpeg2000Component *comp = tile->comp + compno;
1191 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1192 Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
1193 uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1194 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1195 unsigned prcx, prcy;
1197 int xc = x / s->cdx[compno];
1198 int yc = y / s->cdy[compno];
1200 if (reslevelno >= codsty->nreslevels)
1203 if (yc % (1 << (rlevel->log2_prec_height + reducedresno)) && y != tile->coord[1][0]) //FIXME this is a subset of the check
1206 if (xc % (1 << (rlevel->log2_prec_width + reducedresno)) && x != tile->coord[0][0]) //FIXME this is a subset of the check
1209 // check if a precinct exists
1210 prcx = ff_jpeg2000_ceildivpow2(xc, reducedresno) >> rlevel->log2_prec_width;
1211 prcy = ff_jpeg2000_ceildivpow2(yc, reducedresno) >> rlevel->log2_prec_height;
1212 prcx -= ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], reducedresno) >> rlevel->log2_prec_width;
1213 prcy -= ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], reducedresno) >> rlevel->log2_prec_height;
1215 precno = prcx + rlevel->num_precincts_x * prcy;
1218 if (prcx >= rlevel->num_precincts_x || prcy >= rlevel->num_precincts_y) {
1219 av_log(s->avctx, AV_LOG_WARNING, "prc %d %d outside limits %d %d\n",
1220 prcx, prcy, rlevel->num_precincts_x, rlevel->num_precincts_y);
1224 for (layno = 0; layno < LYEpoc; layno++) {
1225 if ((ret = jpeg2000_decode_packet(s, tile, tp_index,
1228 qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1229 qntsty->nguardbits)) < 0)
1238 case JPEG2000_PGOD_PCRL:
1239 av_log(s->avctx, AV_LOG_WARNING, "Progression order PCRL\n");
1242 for (compno = CSpoc; compno < CEpoc; compno++) {
1243 Jpeg2000Component *comp = tile->comp + compno;
1244 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1246 for (reslevelno = RSpoc; reslevelno < FFMIN(codsty->nreslevels, REpoc); reslevelno++) {
1247 uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1248 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1249 step_x = FFMIN(step_x, rlevel->log2_prec_width + reducedresno);
1250 step_y = FFMIN(step_y, rlevel->log2_prec_height + reducedresno);
1253 if (step_x >= 31 || step_y >= 31){
1254 avpriv_request_sample(s->avctx, "PCRL with large step");
1255 return AVERROR_PATCHWELCOME;
1260 for (y = tile->coord[1][0]; y < tile->coord[1][1]; y = (y/step_y + 1)*step_y) {
1261 for (x = tile->coord[0][0]; x < tile->coord[0][1]; x = (x/step_x + 1)*step_x) {
1262 for (compno = CSpoc; compno < CEpoc; compno++) {
1263 Jpeg2000Component *comp = tile->comp + compno;
1264 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1265 Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
1266 int xc = x / s->cdx[compno];
1267 int yc = y / s->cdy[compno];
1269 for (reslevelno = RSpoc; reslevelno < FFMIN(codsty->nreslevels, REpoc); reslevelno++) {
1270 unsigned prcx, prcy;
1271 uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1272 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1274 if (yc % (1 << (rlevel->log2_prec_height + reducedresno)) && y != tile->coord[1][0]) //FIXME this is a subset of the check
1277 if (xc % (1 << (rlevel->log2_prec_width + reducedresno)) && x != tile->coord[0][0]) //FIXME this is a subset of the check
1280 // check if a precinct exists
1281 prcx = ff_jpeg2000_ceildivpow2(xc, reducedresno) >> rlevel->log2_prec_width;
1282 prcy = ff_jpeg2000_ceildivpow2(yc, reducedresno) >> rlevel->log2_prec_height;
1283 prcx -= ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], reducedresno) >> rlevel->log2_prec_width;
1284 prcy -= ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], reducedresno) >> rlevel->log2_prec_height;
1286 precno = prcx + rlevel->num_precincts_x * prcy;
1288 if (prcx >= rlevel->num_precincts_x || prcy >= rlevel->num_precincts_y) {
1289 av_log(s->avctx, AV_LOG_WARNING, "prc %d %d outside limits %d %d\n",
1290 prcx, prcy, rlevel->num_precincts_x, rlevel->num_precincts_y);
1294 for (layno = 0; layno < LYEpoc; layno++) {
1295 if ((ret = jpeg2000_decode_packet(s, tile, tp_index, codsty, rlevel,
1297 qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1298 qntsty->nguardbits)) < 0)
1314 static int jpeg2000_decode_packets(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
1316 int ret = AVERROR_BUG;
1321 if (tile->poc.nb_poc) {
1322 for (i=0; i<tile->poc.nb_poc; i++) {
1323 Jpeg2000POCEntry *e = &tile->poc.poc[i];
1324 ret = jpeg2000_decode_packets_po_iteration(s, tile,
1326 FFMIN(e->LYEpoc, tile->codsty[0].nlayers),
1328 FFMIN(e->CEpoc, s->ncomponents),
1335 ret = jpeg2000_decode_packets_po_iteration(s, tile,
1337 tile->codsty[0].nlayers,
1340 tile->codsty[0].prog_order,
1344 /* EOC marker reached */
1345 bytestream2_skip(&s->g, 2);
1350 /* TIER-1 routines */
1351 static void decode_sigpass(Jpeg2000T1Context *t1, int width, int height,
1352 int bpno, int bandno,
1353 int vert_causal_ctx_csty_symbol)
1355 int mask = 3 << (bpno - 1), y0, x, y;
1357 for (y0 = 0; y0 < height; y0 += 4)
1358 for (x = 0; x < width; x++)
1359 for (y = y0; y < height && y < y0 + 4; y++) {
1360 int flags_mask = -1;
1361 if (vert_causal_ctx_csty_symbol && y == y0 + 3)
1362 flags_mask &= ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE | JPEG2000_T1_SGN_S);
1363 if ((t1->flags[(y+1) * t1->stride + x+1] & JPEG2000_T1_SIG_NB & flags_mask)
1364 && !(t1->flags[(y+1) * t1->stride + x+1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS))) {
1365 if (ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ff_jpeg2000_getsigctxno(t1->flags[(y+1) * t1->stride + x+1] & flags_mask, bandno))) {
1366 int xorbit, ctxno = ff_jpeg2000_getsgnctxno(t1->flags[(y+1) * t1->stride + x+1] & flags_mask, &xorbit);
1368 t1->data[(y) * t1->stride + x] = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ctxno) ? -mask : mask;
1370 t1->data[(y) * t1->stride + x] = (ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ctxno) ^ xorbit) ?
1373 ff_jpeg2000_set_significance(t1, x, y,
1374 t1->data[(y) * t1->stride + x] < 0);
1376 t1->flags[(y + 1) * t1->stride + x + 1] |= JPEG2000_T1_VIS;
1381 static void decode_refpass(Jpeg2000T1Context *t1, int width, int height,
1382 int bpno, int vert_causal_ctx_csty_symbol)
1387 phalf = 1 << (bpno - 1);
1390 for (y0 = 0; y0 < height; y0 += 4)
1391 for (x = 0; x < width; x++)
1392 for (y = y0; y < height && y < y0 + 4; y++)
1393 if ((t1->flags[(y + 1) * t1->stride + x + 1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS)) == JPEG2000_T1_SIG) {
1394 int flags_mask = (vert_causal_ctx_csty_symbol && y == y0 + 3) ?
1395 ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE | JPEG2000_T1_SGN_S) : -1;
1396 int ctxno = ff_jpeg2000_getrefctxno(t1->flags[(y + 1) * t1->stride + x + 1] & flags_mask);
1397 int r = ff_mqc_decode(&t1->mqc,
1398 t1->mqc.cx_states + ctxno)
1400 t1->data[(y) * t1->stride + x] += t1->data[(y) * t1->stride + x] < 0 ? -r : r;
1401 t1->flags[(y + 1) * t1->stride + x + 1] |= JPEG2000_T1_REF;
1405 static void decode_clnpass(Jpeg2000DecoderContext *s, Jpeg2000T1Context *t1,
1406 int width, int height, int bpno, int bandno,
1407 int seg_symbols, int vert_causal_ctx_csty_symbol)
1409 int mask = 3 << (bpno - 1), y0, x, y, runlen, dec;
1411 for (y0 = 0; y0 < height; y0 += 4) {
1412 for (x = 0; x < width; x++) {
1413 int flags_mask = -1;
1414 if (vert_causal_ctx_csty_symbol)
1415 flags_mask &= ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE | JPEG2000_T1_SGN_S);
1416 if (y0 + 3 < height &&
1417 !((t1->flags[(y0 + 1) * t1->stride + x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
1418 (t1->flags[(y0 + 2) * t1->stride + x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
1419 (t1->flags[(y0 + 3) * t1->stride + x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
1420 (t1->flags[(y0 + 4) * t1->stride + x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG) & flags_mask))) {
1421 if (!ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_RL))
1423 runlen = ff_mqc_decode(&t1->mqc,
1424 t1->mqc.cx_states + MQC_CX_UNI);
1425 runlen = (runlen << 1) | ff_mqc_decode(&t1->mqc,
1434 for (y = y0 + runlen; y < y0 + 4 && y < height; y++) {
1435 int flags_mask = -1;
1436 if (vert_causal_ctx_csty_symbol && y == y0 + 3)
1437 flags_mask &= ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE | JPEG2000_T1_SGN_S);
1439 if (!(t1->flags[(y+1) * t1->stride + x+1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS))) {
1440 dec = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ff_jpeg2000_getsigctxno(t1->flags[(y+1) * t1->stride + x+1] & flags_mask,
1446 int ctxno = ff_jpeg2000_getsgnctxno(t1->flags[(y + 1) * t1->stride + x + 1] & flags_mask,
1448 t1->data[(y) * t1->stride + x] = (ff_mqc_decode(&t1->mqc,
1449 t1->mqc.cx_states + ctxno) ^
1452 ff_jpeg2000_set_significance(t1, x, y, t1->data[(y) * t1->stride + x] < 0);
1455 t1->flags[(y + 1) * t1->stride + x + 1] &= ~JPEG2000_T1_VIS;
1461 val = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1462 val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1463 val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1464 val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1466 av_log(s->avctx, AV_LOG_ERROR,
1467 "Segmentation symbol value incorrect\n");
1471 static int decode_cblk(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *codsty,
1472 Jpeg2000T1Context *t1, Jpeg2000Cblk *cblk,
1473 int width, int height, int bandpos)
1475 int passno = cblk->npasses, pass_t = 2, bpno = cblk->nonzerobits - 1;
1477 int vert_causal_ctx_csty_symbol = codsty->cblk_style & JPEG2000_CBLK_VSC;
1481 av_assert0(width <= 1024U && height <= 1024U);
1482 av_assert0(width*height <= 4096);
1484 memset(t1->data, 0, t1->stride * height * sizeof(*t1->data));
1486 /* If code-block contains no compressed data: nothing to do. */
1490 memset(t1->flags, 0, t1->stride * (height + 2) * sizeof(*t1->flags));
1492 cblk->data[cblk->length] = 0xff;
1493 cblk->data[cblk->length+1] = 0xff;
1494 ff_mqc_initdec(&t1->mqc, cblk->data, 0, 1);
1498 av_log(s->avctx, AV_LOG_ERROR, "bpno became negative\n");
1499 return AVERROR_INVALIDDATA;
1503 decode_sigpass(t1, width, height, bpno + 1, bandpos,
1504 vert_causal_ctx_csty_symbol);
1507 decode_refpass(t1, width, height, bpno + 1, vert_causal_ctx_csty_symbol);
1510 av_assert2(!t1->mqc.raw);
1511 decode_clnpass(s, t1, width, height, bpno + 1, bandpos,
1512 codsty->cblk_style & JPEG2000_CBLK_SEGSYM,
1513 vert_causal_ctx_csty_symbol);
1516 if (codsty->cblk_style & JPEG2000_CBLK_RESET) // XXX no testcase for just this
1517 ff_mqc_init_contexts(&t1->mqc);
1519 if (passno && (coder_type = needs_termination(codsty->cblk_style, pass_cnt))) {
1520 if (term_cnt >= cblk->nb_terminations) {
1521 av_log(s->avctx, AV_LOG_ERROR, "Missing needed termination \n");
1522 return AVERROR_INVALIDDATA;
1524 if (FFABS(cblk->data + cblk->data_start[term_cnt + 1] - 2 - t1->mqc.bp) > 0) {
1525 av_log(s->avctx, AV_LOG_WARNING, "Mid mismatch %"PTRDIFF_SPECIFIER" in pass %d of %d\n",
1526 cblk->data + cblk->data_start[term_cnt + 1] - 2 - t1->mqc.bp,
1527 pass_cnt, cblk->npasses);
1530 ff_mqc_initdec(&t1->mqc, cblk->data + cblk->data_start[++term_cnt], coder_type == 2, 0);
1541 if (cblk->data + cblk->length - 2*(term_cnt < cblk->nb_terminations) != t1->mqc.bp) {
1542 av_log(s->avctx, AV_LOG_WARNING, "End mismatch %"PTRDIFF_SPECIFIER"\n",
1543 cblk->data + cblk->length - 2*(term_cnt < cblk->nb_terminations) - t1->mqc.bp);
1549 /* TODO: Verify dequantization for lossless case
1550 * comp->data can be float or int
1551 * band->stepsize can be float or int
1552 * depending on the type of DWT transformation.
1553 * see ISO/IEC 15444-1:2002 A.6.1 */
1555 /* Float dequantization of a codeblock.*/
1556 static void dequantization_float(int x, int y, Jpeg2000Cblk *cblk,
1557 Jpeg2000Component *comp,
1558 Jpeg2000T1Context *t1, Jpeg2000Band *band)
1561 int w = cblk->coord[0][1] - cblk->coord[0][0];
1562 for (j = 0; j < (cblk->coord[1][1] - cblk->coord[1][0]); ++j) {
1563 float *datap = &comp->f_data[(comp->coord[0][1] - comp->coord[0][0]) * (y + j) + x];
1564 int *src = t1->data + j*t1->stride;
1565 for (i = 0; i < w; ++i)
1566 datap[i] = src[i] * band->f_stepsize;
1570 /* Integer dequantization of a codeblock.*/
1571 static void dequantization_int(int x, int y, Jpeg2000Cblk *cblk,
1572 Jpeg2000Component *comp,
1573 Jpeg2000T1Context *t1, Jpeg2000Band *band)
1576 int w = cblk->coord[0][1] - cblk->coord[0][0];
1577 for (j = 0; j < (cblk->coord[1][1] - cblk->coord[1][0]); ++j) {
1578 int32_t *datap = &comp->i_data[(comp->coord[0][1] - comp->coord[0][0]) * (y + j) + x];
1579 int *src = t1->data + j*t1->stride;
1580 if (band->i_stepsize == 32768) {
1581 for (i = 0; i < w; ++i)
1582 datap[i] = src[i] / 2;
1584 // This should be VERY uncommon
1585 for (i = 0; i < w; ++i)
1586 datap[i] = (src[i] * (int64_t)band->i_stepsize) / 65536;
1591 static void dequantization_int_97(int x, int y, Jpeg2000Cblk *cblk,
1592 Jpeg2000Component *comp,
1593 Jpeg2000T1Context *t1, Jpeg2000Band *band)
1596 int w = cblk->coord[0][1] - cblk->coord[0][0];
1597 for (j = 0; j < (cblk->coord[1][1] - cblk->coord[1][0]); ++j) {
1598 int32_t *datap = &comp->i_data[(comp->coord[0][1] - comp->coord[0][0]) * (y + j) + x];
1599 int *src = t1->data + j*t1->stride;
1600 for (i = 0; i < w; ++i)
1601 datap[i] = (src[i] * (int64_t)band->i_stepsize + (1<<15)) >> 16;
1605 static inline void mct_decode(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
1610 for (i = 1; i < 3; i++) {
1611 if (tile->codsty[0].transform != tile->codsty[i].transform) {
1612 av_log(s->avctx, AV_LOG_ERROR, "Transforms mismatch, MCT not supported\n");
1615 if (memcmp(tile->comp[0].coord, tile->comp[i].coord, sizeof(tile->comp[0].coord))) {
1616 av_log(s->avctx, AV_LOG_ERROR, "Coords mismatch, MCT not supported\n");
1621 for (i = 0; i < 3; i++)
1622 if (tile->codsty[0].transform == FF_DWT97)
1623 src[i] = tile->comp[i].f_data;
1625 src[i] = tile->comp[i].i_data;
1627 for (i = 0; i < 2; i++)
1628 csize *= tile->comp[0].coord[i][1] - tile->comp[0].coord[i][0];
1630 s->dsp.mct_decode[tile->codsty[0].transform](src[0], src[1], src[2], csize);
1633 static inline void tile_codeblocks(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
1635 Jpeg2000T1Context t1;
1637 int compno, reslevelno, bandno;
1639 /* Loop on tile components */
1640 for (compno = 0; compno < s->ncomponents; compno++) {
1641 Jpeg2000Component *comp = tile->comp + compno;
1642 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1644 t1.stride = (1<<codsty->log2_cblk_width) + 2;
1646 /* Loop on resolution levels */
1647 for (reslevelno = 0; reslevelno < codsty->nreslevels2decode; reslevelno++) {
1648 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1650 for (bandno = 0; bandno < rlevel->nbands; bandno++) {
1651 int nb_precincts, precno;
1652 Jpeg2000Band *band = rlevel->band + bandno;
1653 int cblkno = 0, bandpos;
1655 bandpos = bandno + (reslevelno > 0);
1657 if (band->coord[0][0] == band->coord[0][1] ||
1658 band->coord[1][0] == band->coord[1][1])
1661 nb_precincts = rlevel->num_precincts_x * rlevel->num_precincts_y;
1662 /* Loop on precincts */
1663 for (precno = 0; precno < nb_precincts; precno++) {
1664 Jpeg2000Prec *prec = band->prec + precno;
1666 /* Loop on codeblocks */
1668 cblkno < prec->nb_codeblocks_width * prec->nb_codeblocks_height;
1671 Jpeg2000Cblk *cblk = prec->cblk + cblkno;
1672 decode_cblk(s, codsty, &t1, cblk,
1673 cblk->coord[0][1] - cblk->coord[0][0],
1674 cblk->coord[1][1] - cblk->coord[1][0],
1677 x = cblk->coord[0][0] - band->coord[0][0];
1678 y = cblk->coord[1][0] - band->coord[1][0];
1680 if (codsty->transform == FF_DWT97)
1681 dequantization_float(x, y, cblk, comp, &t1, band);
1682 else if (codsty->transform == FF_DWT97_INT)
1683 dequantization_int_97(x, y, cblk, comp, &t1, band);
1685 dequantization_int(x, y, cblk, comp, &t1, band);
1689 } /* end reslevel */
1692 ff_dwt_decode(&comp->dwt, codsty->transform == FF_DWT97 ? (void*)comp->f_data : (void*)comp->i_data);
1696 #define WRITE_FRAME(D, PIXEL) \
1697 static inline void write_frame_ ## D(Jpeg2000DecoderContext * s, Jpeg2000Tile * tile, \
1698 AVFrame * picture, int precision) \
1700 const AVPixFmtDescriptor *pixdesc = av_pix_fmt_desc_get(s->avctx->pix_fmt); \
1701 int planar = !!(pixdesc->flags & AV_PIX_FMT_FLAG_PLANAR); \
1702 int pixelsize = planar ? 1 : pixdesc->nb_components; \
1707 for (compno = 0; compno < s->ncomponents; compno++) { \
1708 Jpeg2000Component *comp = tile->comp + compno; \
1709 Jpeg2000CodingStyle *codsty = tile->codsty + compno; \
1711 float *datap = comp->f_data; \
1712 int32_t *i_datap = comp->i_data; \
1713 int cbps = s->cbps[compno]; \
1714 int w = tile->comp[compno].coord[0][1] - s->image_offset_x; \
1718 plane = s->cdef[compno] ? s->cdef[compno]-1 : (s->ncomponents-1); \
1720 y = tile->comp[compno].coord[1][0] - s->image_offset_y / s->cdy[compno]; \
1721 line = (PIXEL *)picture->data[plane] + y * (picture->linesize[plane] / sizeof(PIXEL));\
1722 for (; y < tile->comp[compno].coord[1][1] - s->image_offset_y; y++) { \
1725 x = tile->comp[compno].coord[0][0] - s->image_offset_x / s->cdx[compno]; \
1726 dst = line + x * pixelsize + compno*!planar; \
1728 if (codsty->transform == FF_DWT97) { \
1729 for (; x < w; x++) { \
1730 int val = lrintf(*datap) + (1 << (cbps - 1)); \
1731 /* DC level shift and clip see ISO 15444-1:2002 G.1.2 */ \
1732 val = av_clip(val, 0, (1 << cbps) - 1); \
1733 *dst = val << (precision - cbps); \
1738 for (; x < w; x++) { \
1739 int val = *i_datap + (1 << (cbps - 1)); \
1740 /* DC level shift and clip see ISO 15444-1:2002 G.1.2 */ \
1741 val = av_clip(val, 0, (1 << cbps) - 1); \
1742 *dst = val << (precision - cbps); \
1747 line += picture->linesize[plane] / sizeof(PIXEL); \
1753 WRITE_FRAME(8, uint8_t)
1754 WRITE_FRAME(16, uint16_t)
1758 static int jpeg2000_decode_tile(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile,
1763 tile_codeblocks(s, tile);
1765 /* inverse MCT transformation */
1766 if (tile->codsty[0].mct)
1767 mct_decode(s, tile);
1769 for (x = 0; x < s->ncomponents; x++) {
1770 if (s->cdef[x] < 0) {
1771 for (x = 0; x < s->ncomponents; x++) {
1774 if ((s->ncomponents & 1) == 0)
1775 s->cdef[s->ncomponents-1] = 0;
1780 if (s->precision <= 8) {
1781 write_frame_8(s, tile, picture, 8);
1783 int precision = picture->format == AV_PIX_FMT_XYZ12 ||
1784 picture->format == AV_PIX_FMT_RGB48 ||
1785 picture->format == AV_PIX_FMT_RGBA64 ||
1786 picture->format == AV_PIX_FMT_GRAY16 ? 16 : s->precision;
1788 write_frame_16(s, tile, picture, precision);
1794 static void jpeg2000_dec_cleanup(Jpeg2000DecoderContext *s)
1797 for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++) {
1798 if (s->tile[tileno].comp) {
1799 for (compno = 0; compno < s->ncomponents; compno++) {
1800 Jpeg2000Component *comp = s->tile[tileno].comp + compno;
1801 Jpeg2000CodingStyle *codsty = s->tile[tileno].codsty + compno;
1803 ff_jpeg2000_cleanup(comp, codsty);
1805 av_freep(&s->tile[tileno].comp);
1809 memset(s->codsty, 0, sizeof(s->codsty));
1810 memset(s->qntsty, 0, sizeof(s->qntsty));
1811 memset(s->properties, 0, sizeof(s->properties));
1812 memset(&s->poc , 0, sizeof(s->poc));
1813 s->numXtiles = s->numYtiles = 0;
1817 static int jpeg2000_read_main_headers(Jpeg2000DecoderContext *s)
1819 Jpeg2000CodingStyle *codsty = s->codsty;
1820 Jpeg2000QuantStyle *qntsty = s->qntsty;
1821 Jpeg2000POC *poc = &s->poc;
1822 uint8_t *properties = s->properties;
1829 if (bytestream2_get_bytes_left(&s->g) < 2) {
1830 av_log(s->avctx, AV_LOG_ERROR, "Missing EOC\n");
1834 marker = bytestream2_get_be16u(&s->g);
1835 oldpos = bytestream2_tell(&s->g);
1837 if (marker == JPEG2000_SOD) {
1839 Jpeg2000TilePart *tp;
1842 av_log(s->avctx, AV_LOG_ERROR, "Missing SIZ\n");
1843 return AVERROR_INVALIDDATA;
1845 if (s->curtileno < 0) {
1846 av_log(s->avctx, AV_LOG_ERROR, "Missing SOT\n");
1847 return AVERROR_INVALIDDATA;
1850 tile = s->tile + s->curtileno;
1851 tp = tile->tile_part + tile->tp_idx;
1852 if (tp->tp_end < s->g.buffer) {
1853 av_log(s->avctx, AV_LOG_ERROR, "Invalid tpend\n");
1854 return AVERROR_INVALIDDATA;
1856 bytestream2_init(&tp->tpg, s->g.buffer, tp->tp_end - s->g.buffer);
1857 bytestream2_skip(&s->g, tp->tp_end - s->g.buffer);
1861 if (marker == JPEG2000_EOC)
1864 len = bytestream2_get_be16(&s->g);
1865 if (len < 2 || bytestream2_get_bytes_left(&s->g) < len - 2) {
1866 av_log(s->avctx, AV_LOG_ERROR, "Invalid len %d left=%d\n", len, bytestream2_get_bytes_left(&s->g));
1867 return AVERROR_INVALIDDATA;
1872 if (s->ncomponents) {
1873 av_log(s->avctx, AV_LOG_ERROR, "Duplicate SIZ\n");
1874 return AVERROR_INVALIDDATA;
1878 s->numXtiles = s->numYtiles = 0;
1881 ret = get_coc(s, codsty, properties);
1884 ret = get_cod(s, codsty, properties);
1887 ret = get_qcc(s, len, qntsty, properties);
1890 ret = get_qcd(s, len, qntsty, properties);
1893 ret = get_poc(s, len, poc);
1896 if (!(ret = get_sot(s, len))) {
1897 av_assert1(s->curtileno >= 0);
1898 codsty = s->tile[s->curtileno].codsty;
1899 qntsty = s->tile[s->curtileno].qntsty;
1900 poc = &s->tile[s->curtileno].poc;
1901 properties = s->tile[s->curtileno].properties;
1905 // the PLM marker is ignored
1907 // the comment is ignored
1908 bytestream2_skip(&s->g, len - 2);
1911 // Tile-part lengths
1912 ret = get_tlm(s, len);
1915 // Packet length, tile-part header
1916 ret = get_plt(s, len);
1919 av_log(s->avctx, AV_LOG_ERROR,
1920 "unsupported marker 0x%.4"PRIX16" at pos 0x%X\n",
1921 marker, bytestream2_tell(&s->g) - 4);
1922 bytestream2_skip(&s->g, len - 2);
1925 if (bytestream2_tell(&s->g) - oldpos != len || ret) {
1926 av_log(s->avctx, AV_LOG_ERROR,
1927 "error during processing marker segment %.4"PRIx16"\n",
1929 return ret ? ret : -1;
1935 /* Read bit stream packets --> T2 operation. */
1936 static int jpeg2000_read_bitstream_packets(Jpeg2000DecoderContext *s)
1941 for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++) {
1942 Jpeg2000Tile *tile = s->tile + tileno;
1944 if ((ret = init_tile(s, tileno)) < 0)
1947 s->g = tile->tile_part[0].tpg;
1948 if ((ret = jpeg2000_decode_packets(s, tile)) < 0)
1955 static int jp2_find_codestream(Jpeg2000DecoderContext *s)
1957 uint32_t atom_size, atom, atom_end;
1958 int search_range = 10;
1962 bytestream2_get_bytes_left(&s->g) >= 8) {
1963 atom_size = bytestream2_get_be32u(&s->g);
1964 atom = bytestream2_get_be32u(&s->g);
1965 atom_end = bytestream2_tell(&s->g) + atom_size - 8;
1967 if (atom == JP2_CODESTREAM)
1970 if (bytestream2_get_bytes_left(&s->g) < atom_size || atom_end < atom_size)
1973 if (atom == JP2_HEADER &&
1975 uint32_t atom2_size, atom2, atom2_end;
1977 atom2_size = bytestream2_get_be32u(&s->g);
1978 atom2 = bytestream2_get_be32u(&s->g);
1979 atom2_end = bytestream2_tell(&s->g) + atom2_size - 8;
1980 if (atom2_size < 8 || atom2_end > atom_end || atom2_end < atom2_size)
1982 if (atom2 == JP2_CODESTREAM) {
1984 } else if (atom2 == MKBETAG('c','o','l','r') && atom2_size >= 7) {
1985 int method = bytestream2_get_byteu(&s->g);
1986 bytestream2_skipu(&s->g, 2);
1988 s->colour_space = bytestream2_get_be32u(&s->g);
1990 } else if (atom2 == MKBETAG('p','c','l','r') && atom2_size >= 6) {
1991 int i, size, colour_count, colour_channels, colour_depth[3];
1993 colour_count = bytestream2_get_be16u(&s->g);
1994 colour_channels = bytestream2_get_byteu(&s->g);
1995 // FIXME: Do not ignore channel_sign
1996 colour_depth[0] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1;
1997 colour_depth[1] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1;
1998 colour_depth[2] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1;
1999 size = (colour_depth[0] + 7 >> 3) * colour_count +
2000 (colour_depth[1] + 7 >> 3) * colour_count +
2001 (colour_depth[2] + 7 >> 3) * colour_count;
2002 if (colour_count > 256 ||
2003 colour_channels != 3 ||
2004 colour_depth[0] > 16 ||
2005 colour_depth[1] > 16 ||
2006 colour_depth[2] > 16 ||
2007 atom2_size < size) {
2008 avpriv_request_sample(s->avctx, "Unknown palette");
2009 bytestream2_seek(&s->g, atom2_end, SEEK_SET);
2013 for (i = 0; i < colour_count; i++) {
2014 if (colour_depth[0] <= 8) {
2015 r = bytestream2_get_byteu(&s->g) << 8 - colour_depth[0];
2016 r |= r >> colour_depth[0];
2018 r = bytestream2_get_be16u(&s->g) >> colour_depth[0] - 8;
2020 if (colour_depth[1] <= 8) {
2021 g = bytestream2_get_byteu(&s->g) << 8 - colour_depth[1];
2022 r |= r >> colour_depth[1];
2024 g = bytestream2_get_be16u(&s->g) >> colour_depth[1] - 8;
2026 if (colour_depth[2] <= 8) {
2027 b = bytestream2_get_byteu(&s->g) << 8 - colour_depth[2];
2028 r |= r >> colour_depth[2];
2030 b = bytestream2_get_be16u(&s->g) >> colour_depth[2] - 8;
2032 s->palette[i] = 0xffu << 24 | r << 16 | g << 8 | b;
2034 } else if (atom2 == MKBETAG('c','d','e','f') && atom2_size >= 2) {
2035 int n = bytestream2_get_be16u(&s->g);
2037 int cn = bytestream2_get_be16(&s->g);
2038 int av_unused typ = bytestream2_get_be16(&s->g);
2039 int asoc = bytestream2_get_be16(&s->g);
2040 if (cn < 4 && asoc < 4)
2044 bytestream2_seek(&s->g, atom2_end, SEEK_SET);
2045 } while (atom_end - atom2_end >= 8);
2049 bytestream2_seek(&s->g, atom_end, SEEK_SET);
2055 static av_cold int jpeg2000_decode_init(AVCodecContext *avctx)
2057 Jpeg2000DecoderContext *s = avctx->priv_data;
2059 ff_jpeg2000dsp_init(&s->dsp);
2064 static int jpeg2000_decode_frame(AVCodecContext *avctx, void *data,
2065 int *got_frame, AVPacket *avpkt)
2067 Jpeg2000DecoderContext *s = avctx->priv_data;
2068 ThreadFrame frame = { .f = data };
2069 AVFrame *picture = data;
2073 bytestream2_init(&s->g, avpkt->data, avpkt->size);
2075 memset(s->cdef, -1, sizeof(s->cdef));
2077 if (bytestream2_get_bytes_left(&s->g) < 2) {
2078 ret = AVERROR_INVALIDDATA;
2082 // check if the image is in jp2 format
2083 if (bytestream2_get_bytes_left(&s->g) >= 12 &&
2084 (bytestream2_get_be32u(&s->g) == 12) &&
2085 (bytestream2_get_be32u(&s->g) == JP2_SIG_TYPE) &&
2086 (bytestream2_get_be32u(&s->g) == JP2_SIG_VALUE)) {
2087 if (!jp2_find_codestream(s)) {
2088 av_log(avctx, AV_LOG_ERROR,
2089 "Could not find Jpeg2000 codestream atom.\n");
2090 ret = AVERROR_INVALIDDATA;
2094 bytestream2_seek(&s->g, 0, SEEK_SET);
2097 while (bytestream2_get_bytes_left(&s->g) >= 3 && bytestream2_peek_be16(&s->g) != JPEG2000_SOC)
2098 bytestream2_skip(&s->g, 1);
2100 if (bytestream2_get_be16u(&s->g) != JPEG2000_SOC) {
2101 av_log(avctx, AV_LOG_ERROR, "SOC marker not present\n");
2102 ret = AVERROR_INVALIDDATA;
2105 if (ret = jpeg2000_read_main_headers(s))
2108 /* get picture buffer */
2109 if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
2111 picture->pict_type = AV_PICTURE_TYPE_I;
2112 picture->key_frame = 1;
2114 if (ret = jpeg2000_read_bitstream_packets(s))
2117 for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++)
2118 if (ret = jpeg2000_decode_tile(s, s->tile + tileno, picture))
2121 jpeg2000_dec_cleanup(s);
2125 if (s->avctx->pix_fmt == AV_PIX_FMT_PAL8)
2126 memcpy(picture->data[1], s->palette, 256 * sizeof(uint32_t));
2128 return bytestream2_tell(&s->g);
2131 jpeg2000_dec_cleanup(s);
2135 static av_cold void jpeg2000_init_static_data(AVCodec *codec)
2137 ff_jpeg2000_init_tier1_luts();
2138 ff_mqc_init_context_tables();
2141 #define OFFSET(x) offsetof(Jpeg2000DecoderContext, x)
2142 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
2144 static const AVOption options[] = {
2145 { "lowres", "Lower the decoding resolution by a power of two",
2146 OFFSET(reduction_factor), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, JPEG2000_MAX_RESLEVELS - 1, VD },
2150 static const AVClass jpeg2000_class = {
2151 .class_name = "jpeg2000",
2152 .item_name = av_default_item_name,
2154 .version = LIBAVUTIL_VERSION_INT,
2157 AVCodec ff_jpeg2000_decoder = {
2159 .long_name = NULL_IF_CONFIG_SMALL("JPEG 2000"),
2160 .type = AVMEDIA_TYPE_VIDEO,
2161 .id = AV_CODEC_ID_JPEG2000,
2162 .capabilities = AV_CODEC_CAP_FRAME_THREADS | AV_CODEC_CAP_DR1,
2163 .priv_data_size = sizeof(Jpeg2000DecoderContext),
2164 .init_static_data = jpeg2000_init_static_data,
2165 .init = jpeg2000_decode_init,
2166 .decode = jpeg2000_decode_frame,
2167 .priv_class = &jpeg2000_class,
2169 .profiles = NULL_IF_CONFIG_SMALL(ff_jpeg2000_profiles)