2 * JPEG 2000 image decoder
3 * Copyright (c) 2007 Kamil Nowosad
4 * Copyright (c) 2013 Nicolas Bertrand <nicoinattendu@gmail.com>
6 * This file is part of FFmpeg.
8 * FFmpeg is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
13 * FFmpeg is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with FFmpeg; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
25 * JPEG 2000 image decoder
30 #include "libavutil/attributes.h"
31 #include "libavutil/avassert.h"
32 #include "libavutil/common.h"
33 #include "libavutil/opt.h"
34 #include "libavutil/pixdesc.h"
36 #include "bytestream.h"
40 #include "jpeg2000dsp.h"
42 #define JP2_SIG_TYPE 0x6A502020
43 #define JP2_SIG_VALUE 0x0D0A870A
44 #define JP2_CODESTREAM 0x6A703263
45 #define JP2_HEADER 0x6A703268
52 typedef struct Jpeg2000POCEntry {
61 typedef struct Jpeg2000POC {
62 Jpeg2000POCEntry poc[MAX_POCS];
67 typedef struct Jpeg2000TilePart {
68 uint8_t tile_index; // Tile index who refers the tile-part
69 const uint8_t *tp_end;
70 GetByteContext tpg; // bit stream in tile-part
73 /* RMK: For JPEG2000 DCINEMA 3 tile-parts in a tile
74 * one per component, so tile_part elements have a size of 3 */
75 typedef struct Jpeg2000Tile {
76 Jpeg2000Component *comp;
77 uint8_t properties[4];
78 Jpeg2000CodingStyle codsty[4];
79 Jpeg2000QuantStyle qntsty[4];
81 Jpeg2000TilePart tile_part[256];
82 uint16_t tp_idx; // Tile-part index
83 int coord[2][2]; // border coordinates {{x0, x1}, {y0, y1}}
86 typedef struct Jpeg2000DecoderContext {
88 AVCodecContext *avctx;
92 int image_offset_x, image_offset_y;
93 int tile_offset_x, tile_offset_y;
94 uint8_t cbps[4]; // bits per sample in particular components
95 uint8_t sgnd[4]; // if a component is signed
96 uint8_t properties[4];
101 uint32_t palette[256];
104 int tile_width, tile_height;
105 unsigned numXtiles, numYtiles;
108 Jpeg2000CodingStyle codsty[4];
109 Jpeg2000QuantStyle qntsty[4];
117 Jpeg2000DSPContext dsp;
119 /*options parameters*/
120 int reduction_factor;
121 } Jpeg2000DecoderContext;
123 /* get_bits functions for JPEG2000 packet bitstream
124 * It is a get_bit function with a bit-stuffing routine. If the value of the
125 * byte is 0xFF, the next byte includes an extra zero bit stuffed into the MSB.
126 * cf. ISO-15444-1:2002 / B.10.1 Bit-stuffing routine */
127 static int get_bits(Jpeg2000DecoderContext *s, int n)
133 if (s->bit_index == 0) {
134 s->bit_index = 7 + (bytestream2_get_byte(&s->g) != 0xFFu);
137 res |= (bytestream2_peek_byte(&s->g) >> s->bit_index) & 1;
142 static void jpeg2000_flush(Jpeg2000DecoderContext *s)
144 if (bytestream2_get_byte(&s->g) == 0xff)
145 bytestream2_skip(&s->g, 1);
149 /* decode the value stored in node */
150 static int tag_tree_decode(Jpeg2000DecoderContext *s, Jpeg2000TgtNode *node,
153 Jpeg2000TgtNode *stack[30];
154 int sp = -1, curval = 0;
157 av_log(s->avctx, AV_LOG_ERROR, "missing node\n");
158 return AVERROR_INVALIDDATA;
161 while (node && !node->vis) {
169 curval = stack[sp]->val;
171 while (curval < threshold && sp >= 0) {
172 if (curval < stack[sp]->val)
173 curval = stack[sp]->val;
174 while (curval < threshold) {
176 if ((ret = get_bits(s, 1)) > 0) {
184 stack[sp]->val = curval;
190 static int pix_fmt_match(enum AVPixelFormat pix_fmt, int components,
191 int bpc, uint32_t log2_chroma_wh, int pal8)
194 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
198 if (desc->nb_components != components) {
202 switch (components) {
204 match = match && desc->comp[3].depth_minus1 + 1 >= bpc &&
205 (log2_chroma_wh >> 14 & 3) == 0 &&
206 (log2_chroma_wh >> 12 & 3) == 0;
208 match = match && desc->comp[2].depth_minus1 + 1 >= bpc &&
209 (log2_chroma_wh >> 10 & 3) == desc->log2_chroma_w &&
210 (log2_chroma_wh >> 8 & 3) == desc->log2_chroma_h;
212 match = match && desc->comp[1].depth_minus1 + 1 >= bpc &&
213 (log2_chroma_wh >> 6 & 3) == desc->log2_chroma_w &&
214 (log2_chroma_wh >> 4 & 3) == desc->log2_chroma_h;
217 match = match && desc->comp[0].depth_minus1 + 1 >= bpc &&
218 (log2_chroma_wh >> 2 & 3) == 0 &&
219 (log2_chroma_wh & 3) == 0 &&
220 (desc->flags & AV_PIX_FMT_FLAG_PAL) == pal8 * AV_PIX_FMT_FLAG_PAL;
225 // pix_fmts with lower bpp have to be listed before
226 // similar pix_fmts with higher bpp.
227 #define RGB_PIXEL_FORMATS AV_PIX_FMT_PAL8,AV_PIX_FMT_RGB24,AV_PIX_FMT_RGBA,AV_PIX_FMT_RGB48,AV_PIX_FMT_RGBA64
228 #define GRAY_PIXEL_FORMATS AV_PIX_FMT_GRAY8,AV_PIX_FMT_GRAY8A,AV_PIX_FMT_GRAY16,AV_PIX_FMT_YA16
229 #define YUV_PIXEL_FORMATS AV_PIX_FMT_YUV410P,AV_PIX_FMT_YUV411P,AV_PIX_FMT_YUVA420P, \
230 AV_PIX_FMT_YUV420P,AV_PIX_FMT_YUV422P,AV_PIX_FMT_YUVA422P, \
231 AV_PIX_FMT_YUV440P,AV_PIX_FMT_YUV444P,AV_PIX_FMT_YUVA444P, \
232 AV_PIX_FMT_YUV420P9,AV_PIX_FMT_YUV422P9,AV_PIX_FMT_YUV444P9, \
233 AV_PIX_FMT_YUVA420P9,AV_PIX_FMT_YUVA422P9,AV_PIX_FMT_YUVA444P9, \
234 AV_PIX_FMT_YUV420P10,AV_PIX_FMT_YUV422P10,AV_PIX_FMT_YUV444P10, \
235 AV_PIX_FMT_YUVA420P10,AV_PIX_FMT_YUVA422P10,AV_PIX_FMT_YUVA444P10, \
236 AV_PIX_FMT_YUV420P12,AV_PIX_FMT_YUV422P12,AV_PIX_FMT_YUV444P12, \
237 AV_PIX_FMT_YUV420P14,AV_PIX_FMT_YUV422P14,AV_PIX_FMT_YUV444P14, \
238 AV_PIX_FMT_YUV420P16,AV_PIX_FMT_YUV422P16,AV_PIX_FMT_YUV444P16, \
239 AV_PIX_FMT_YUVA420P16,AV_PIX_FMT_YUVA422P16,AV_PIX_FMT_YUVA444P16
240 #define XYZ_PIXEL_FORMATS AV_PIX_FMT_XYZ12
242 static const enum AVPixelFormat rgb_pix_fmts[] = {RGB_PIXEL_FORMATS};
243 static const enum AVPixelFormat gray_pix_fmts[] = {GRAY_PIXEL_FORMATS};
244 static const enum AVPixelFormat yuv_pix_fmts[] = {YUV_PIXEL_FORMATS};
245 static const enum AVPixelFormat xyz_pix_fmts[] = {XYZ_PIXEL_FORMATS,
247 static const enum AVPixelFormat all_pix_fmts[] = {RGB_PIXEL_FORMATS,
252 /* marker segments */
253 /* get sizes and offsets of image, tiles; number of components */
254 static int get_siz(Jpeg2000DecoderContext *s)
258 uint32_t log2_chroma_wh = 0;
259 const enum AVPixelFormat *possible_fmts = NULL;
260 int possible_fmts_nb = 0;
262 if (bytestream2_get_bytes_left(&s->g) < 36) {
263 av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for SIZ\n");
264 return AVERROR_INVALIDDATA;
267 s->avctx->profile = bytestream2_get_be16u(&s->g); // Rsiz
268 s->width = bytestream2_get_be32u(&s->g); // Width
269 s->height = bytestream2_get_be32u(&s->g); // Height
270 s->image_offset_x = bytestream2_get_be32u(&s->g); // X0Siz
271 s->image_offset_y = bytestream2_get_be32u(&s->g); // Y0Siz
272 s->tile_width = bytestream2_get_be32u(&s->g); // XTSiz
273 s->tile_height = bytestream2_get_be32u(&s->g); // YTSiz
274 s->tile_offset_x = bytestream2_get_be32u(&s->g); // XT0Siz
275 s->tile_offset_y = bytestream2_get_be32u(&s->g); // YT0Siz
276 ncomponents = bytestream2_get_be16u(&s->g); // CSiz
278 if (s->image_offset_x || s->image_offset_y) {
279 avpriv_request_sample(s->avctx, "Support for image offsets");
280 return AVERROR_PATCHWELCOME;
283 if (ncomponents <= 0) {
284 av_log(s->avctx, AV_LOG_ERROR, "Invalid number of components: %d\n",
286 return AVERROR_INVALIDDATA;
289 if (ncomponents > 4) {
290 avpriv_request_sample(s->avctx, "Support for %d components",
292 return AVERROR_PATCHWELCOME;
295 s->ncomponents = ncomponents;
297 if (s->tile_width <= 0 || s->tile_height <= 0) {
298 av_log(s->avctx, AV_LOG_ERROR, "Invalid tile dimension %dx%d.\n",
299 s->tile_width, s->tile_height);
300 return AVERROR_INVALIDDATA;
303 if (bytestream2_get_bytes_left(&s->g) < 3 * s->ncomponents) {
304 av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for %d components in SIZ\n", s->ncomponents);
305 return AVERROR_INVALIDDATA;
308 for (i = 0; i < s->ncomponents; i++) { // Ssiz_i XRsiz_i, YRsiz_i
309 uint8_t x = bytestream2_get_byteu(&s->g);
310 s->cbps[i] = (x & 0x7f) + 1;
311 s->precision = FFMAX(s->cbps[i], s->precision);
312 s->sgnd[i] = !!(x & 0x80);
313 s->cdx[i] = bytestream2_get_byteu(&s->g);
314 s->cdy[i] = bytestream2_get_byteu(&s->g);
315 if ( !s->cdx[i] || s->cdx[i] == 3 || s->cdx[i] > 4
316 || !s->cdy[i] || s->cdy[i] == 3 || s->cdy[i] > 4) {
317 av_log(s->avctx, AV_LOG_ERROR, "Invalid sample separation %d/%d\n", s->cdx[i], s->cdy[i]);
318 return AVERROR_INVALIDDATA;
320 log2_chroma_wh |= s->cdy[i] >> 1 << i * 4 | s->cdx[i] >> 1 << i * 4 + 2;
323 s->numXtiles = ff_jpeg2000_ceildiv(s->width - s->tile_offset_x, s->tile_width);
324 s->numYtiles = ff_jpeg2000_ceildiv(s->height - s->tile_offset_y, s->tile_height);
326 if (s->numXtiles * (uint64_t)s->numYtiles > INT_MAX/sizeof(*s->tile)) {
327 s->numXtiles = s->numYtiles = 0;
328 return AVERROR(EINVAL);
331 s->tile = av_mallocz_array(s->numXtiles * s->numYtiles, sizeof(*s->tile));
333 s->numXtiles = s->numYtiles = 0;
334 return AVERROR(ENOMEM);
337 for (i = 0; i < s->numXtiles * s->numYtiles; i++) {
338 Jpeg2000Tile *tile = s->tile + i;
340 tile->comp = av_mallocz(s->ncomponents * sizeof(*tile->comp));
342 return AVERROR(ENOMEM);
345 /* compute image size with reduction factor */
346 s->avctx->width = ff_jpeg2000_ceildivpow2(s->width - s->image_offset_x,
347 s->reduction_factor);
348 s->avctx->height = ff_jpeg2000_ceildivpow2(s->height - s->image_offset_y,
349 s->reduction_factor);
351 if (s->avctx->profile == FF_PROFILE_JPEG2000_DCINEMA_2K ||
352 s->avctx->profile == FF_PROFILE_JPEG2000_DCINEMA_4K) {
353 possible_fmts = xyz_pix_fmts;
354 possible_fmts_nb = FF_ARRAY_ELEMS(xyz_pix_fmts);
356 switch (s->colour_space) {
358 possible_fmts = rgb_pix_fmts;
359 possible_fmts_nb = FF_ARRAY_ELEMS(rgb_pix_fmts);
362 possible_fmts = gray_pix_fmts;
363 possible_fmts_nb = FF_ARRAY_ELEMS(gray_pix_fmts);
366 possible_fmts = yuv_pix_fmts;
367 possible_fmts_nb = FF_ARRAY_ELEMS(yuv_pix_fmts);
370 possible_fmts = all_pix_fmts;
371 possible_fmts_nb = FF_ARRAY_ELEMS(all_pix_fmts);
375 for (i = 0; i < possible_fmts_nb; ++i) {
376 if (pix_fmt_match(possible_fmts[i], ncomponents, s->precision, log2_chroma_wh, s->pal8)) {
377 s->avctx->pix_fmt = possible_fmts[i];
382 if (i == possible_fmts_nb) {
383 if (ncomponents == 4 &&
384 s->cdy[0] == 1 && s->cdx[0] == 1 &&
385 s->cdy[1] == 1 && s->cdx[1] == 1 &&
386 s->cdy[2] == s->cdy[3] && s->cdx[2] == s->cdx[3]) {
387 if (s->precision == 8 && s->cdy[2] == 2 && s->cdx[2] == 2 && !s->pal8) {
388 s->avctx->pix_fmt = AV_PIX_FMT_YUVA420P;
399 if (i == possible_fmts_nb) {
400 av_log(s->avctx, AV_LOG_ERROR,
401 "Unknown pix_fmt, profile: %d, colour_space: %d, "
402 "components: %d, precision: %d\n"
403 "cdx[0]: %d, cdy[0]: %d\n"
404 "cdx[1]: %d, cdy[1]: %d\n"
405 "cdx[2]: %d, cdy[2]: %d\n"
406 "cdx[3]: %d, cdy[3]: %d\n",
407 s->avctx->profile, s->colour_space, ncomponents, s->precision,
410 ncomponents > 1 ? s->cdx[1] : 0,
411 ncomponents > 1 ? s->cdy[1] : 0,
412 ncomponents > 2 ? s->cdx[2] : 0,
413 ncomponents > 2 ? s->cdy[2] : 0,
414 ncomponents > 3 ? s->cdx[3] : 0,
415 ncomponents > 3 ? s->cdy[3] : 0);
416 return AVERROR_PATCHWELCOME;
418 s->avctx->bits_per_raw_sample = s->precision;
422 /* get common part for COD and COC segments */
423 static int get_cox(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c)
427 if (bytestream2_get_bytes_left(&s->g) < 5) {
428 av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for COX\n");
429 return AVERROR_INVALIDDATA;
432 /* nreslevels = number of resolution levels
433 = number of decomposition level +1 */
434 c->nreslevels = bytestream2_get_byteu(&s->g) + 1;
435 if (c->nreslevels >= JPEG2000_MAX_RESLEVELS) {
436 av_log(s->avctx, AV_LOG_ERROR, "nreslevels %d is invalid\n", c->nreslevels);
437 return AVERROR_INVALIDDATA;
440 if (c->nreslevels <= s->reduction_factor) {
441 /* we are forced to update reduction_factor as its requested value is
442 not compatible with this bitstream, and as we might have used it
443 already in setup earlier we have to fail this frame until
444 reinitialization is implemented */
445 av_log(s->avctx, AV_LOG_ERROR, "reduction_factor too large for this bitstream, max is %d\n", c->nreslevels - 1);
446 s->reduction_factor = c->nreslevels - 1;
447 return AVERROR(EINVAL);
450 /* compute number of resolution levels to decode */
451 c->nreslevels2decode = c->nreslevels - s->reduction_factor;
453 c->log2_cblk_width = (bytestream2_get_byteu(&s->g) & 15) + 2; // cblk width
454 c->log2_cblk_height = (bytestream2_get_byteu(&s->g) & 15) + 2; // cblk height
456 if (c->log2_cblk_width > 10 || c->log2_cblk_height > 10 ||
457 c->log2_cblk_width + c->log2_cblk_height > 12) {
458 av_log(s->avctx, AV_LOG_ERROR, "cblk size invalid\n");
459 return AVERROR_INVALIDDATA;
462 c->cblk_style = bytestream2_get_byteu(&s->g);
463 if (c->cblk_style != 0) { // cblk style
464 av_log(s->avctx, AV_LOG_WARNING, "extra cblk styles %X\n", c->cblk_style);
465 if (c->cblk_style & JPEG2000_CBLK_BYPASS)
466 av_log(s->avctx, AV_LOG_WARNING, "Selective arithmetic coding bypass\n");
468 c->transform = bytestream2_get_byteu(&s->g); // DWT transformation type
469 /* set integer 9/7 DWT in case of BITEXACT flag */
470 if ((s->avctx->flags & CODEC_FLAG_BITEXACT) && (c->transform == FF_DWT97))
471 c->transform = FF_DWT97_INT;
473 if (c->csty & JPEG2000_CSTY_PREC) {
475 for (i = 0; i < c->nreslevels; i++) {
476 byte = bytestream2_get_byte(&s->g);
477 c->log2_prec_widths[i] = byte & 0x0F; // precinct PPx
478 c->log2_prec_heights[i] = (byte >> 4) & 0x0F; // precinct PPy
480 if (c->log2_prec_widths[i] == 0 || c->log2_prec_heights[i] == 0) {
481 av_log(s->avctx, AV_LOG_ERROR, "PPx %d PPy %d invalid\n",
482 c->log2_prec_widths[i], c->log2_prec_heights[i]);
483 c->log2_prec_widths[i] = c->log2_prec_heights[i] = 1;
484 return AVERROR_INVALIDDATA;
488 memset(c->log2_prec_widths , 15, sizeof(c->log2_prec_widths ));
489 memset(c->log2_prec_heights, 15, sizeof(c->log2_prec_heights));
494 /* get coding parameters for a particular tile or whole image*/
495 static int get_cod(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c,
498 Jpeg2000CodingStyle tmp;
501 if (bytestream2_get_bytes_left(&s->g) < 5) {
502 av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for COD\n");
503 return AVERROR_INVALIDDATA;
506 tmp.csty = bytestream2_get_byteu(&s->g);
508 // get progression order
509 tmp.prog_order = bytestream2_get_byteu(&s->g);
511 tmp.nlayers = bytestream2_get_be16u(&s->g);
512 tmp.mct = bytestream2_get_byteu(&s->g); // multiple component transformation
514 if (tmp.mct && s->ncomponents < 3) {
515 av_log(s->avctx, AV_LOG_ERROR,
516 "MCT %"PRIu8" with too few components (%d)\n",
517 tmp.mct, s->ncomponents);
518 return AVERROR_INVALIDDATA;
521 if ((ret = get_cox(s, &tmp)) < 0)
524 for (compno = 0; compno < s->ncomponents; compno++)
525 if (!(properties[compno] & HAD_COC))
526 memcpy(c + compno, &tmp, sizeof(tmp));
530 /* Get coding parameters for a component in the whole image or a
531 * particular tile. */
532 static int get_coc(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c,
537 if (bytestream2_get_bytes_left(&s->g) < 2) {
538 av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for COC\n");
539 return AVERROR_INVALIDDATA;
542 compno = bytestream2_get_byteu(&s->g);
544 if (compno >= s->ncomponents) {
545 av_log(s->avctx, AV_LOG_ERROR,
546 "Invalid compno %d. There are %d components in the image.\n",
547 compno, s->ncomponents);
548 return AVERROR_INVALIDDATA;
552 c->csty = bytestream2_get_byteu(&s->g);
554 if ((ret = get_cox(s, c)) < 0)
557 properties[compno] |= HAD_COC;
561 /* Get common part for QCD and QCC segments. */
562 static int get_qcx(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q)
566 if (bytestream2_get_bytes_left(&s->g) < 1)
567 return AVERROR_INVALIDDATA;
569 x = bytestream2_get_byteu(&s->g); // Sqcd
571 q->nguardbits = x >> 5;
572 q->quantsty = x & 0x1f;
574 if (q->quantsty == JPEG2000_QSTY_NONE) {
576 if (bytestream2_get_bytes_left(&s->g) < n ||
577 n > JPEG2000_MAX_DECLEVELS*3)
578 return AVERROR_INVALIDDATA;
579 for (i = 0; i < n; i++)
580 q->expn[i] = bytestream2_get_byteu(&s->g) >> 3;
581 } else if (q->quantsty == JPEG2000_QSTY_SI) {
582 if (bytestream2_get_bytes_left(&s->g) < 2)
583 return AVERROR_INVALIDDATA;
584 x = bytestream2_get_be16u(&s->g);
585 q->expn[0] = x >> 11;
586 q->mant[0] = x & 0x7ff;
587 for (i = 1; i < JPEG2000_MAX_DECLEVELS * 3; i++) {
588 int curexpn = FFMAX(0, q->expn[0] - (i - 1) / 3);
589 q->expn[i] = curexpn;
590 q->mant[i] = q->mant[0];
594 if (bytestream2_get_bytes_left(&s->g) < 2 * n ||
595 n > JPEG2000_MAX_DECLEVELS*3)
596 return AVERROR_INVALIDDATA;
597 for (i = 0; i < n; i++) {
598 x = bytestream2_get_be16u(&s->g);
599 q->expn[i] = x >> 11;
600 q->mant[i] = x & 0x7ff;
606 /* Get quantization parameters for a particular tile or a whole image. */
607 static int get_qcd(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q,
610 Jpeg2000QuantStyle tmp;
613 memset(&tmp, 0, sizeof(tmp));
615 if ((ret = get_qcx(s, n, &tmp)) < 0)
617 for (compno = 0; compno < s->ncomponents; compno++)
618 if (!(properties[compno] & HAD_QCC))
619 memcpy(q + compno, &tmp, sizeof(tmp));
623 /* Get quantization parameters for a component in the whole image
624 * on in a particular tile. */
625 static int get_qcc(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q,
630 if (bytestream2_get_bytes_left(&s->g) < 1)
631 return AVERROR_INVALIDDATA;
633 compno = bytestream2_get_byteu(&s->g);
635 if (compno >= s->ncomponents) {
636 av_log(s->avctx, AV_LOG_ERROR,
637 "Invalid compno %d. There are %d components in the image.\n",
638 compno, s->ncomponents);
639 return AVERROR_INVALIDDATA;
642 properties[compno] |= HAD_QCC;
643 return get_qcx(s, n - 1, q + compno);
646 static int get_poc(Jpeg2000DecoderContext *s, int size, Jpeg2000POC *p)
649 int elem_size = s->ncomponents <= 257 ? 7 : 9;
650 Jpeg2000POC tmp = {{{0}}};
652 if (bytestream2_get_bytes_left(&s->g) < 5 || size < 2 + elem_size) {
653 av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for POC\n");
654 return AVERROR_INVALIDDATA;
658 avpriv_request_sample(s->avctx, "Fat POC not supported\n");
659 return AVERROR_PATCHWELCOME;
662 tmp.nb_poc = (size - 2) / elem_size;
663 if (tmp.nb_poc > MAX_POCS) {
664 avpriv_request_sample(s->avctx, "Too many POCs (%d)\n", tmp.nb_poc);
665 return AVERROR_PATCHWELCOME;
668 for (i = 0; i<tmp.nb_poc; i++) {
669 Jpeg2000POCEntry *e = &tmp.poc[i];
670 e->RSpoc = bytestream2_get_byteu(&s->g);
671 e->CSpoc = bytestream2_get_byteu(&s->g);
672 e->LYEpoc = bytestream2_get_be16u(&s->g);
673 e->REpoc = bytestream2_get_byteu(&s->g);
674 e->CEpoc = bytestream2_get_byteu(&s->g);
675 e->Ppoc = bytestream2_get_byteu(&s->g);
678 if (e->CEpoc > s->ncomponents)
679 e->CEpoc = s->ncomponents;
680 if ( e->RSpoc >= e->REpoc || e->REpoc > 33
681 || e->CSpoc >= e->CEpoc || e->CEpoc > s->ncomponents
683 av_log(s->avctx, AV_LOG_ERROR, "POC Entry %d is invalid (%d, %d, %d, %d, %d, %d)\n", i,
684 e->RSpoc, e->CSpoc, e->LYEpoc, e->REpoc, e->CEpoc, e->Ppoc
686 return AVERROR_INVALIDDATA;
690 if (!p->nb_poc || p->is_default) {
693 if (p->nb_poc + tmp.nb_poc > MAX_POCS) {
694 av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for POC\n");
695 return AVERROR_INVALIDDATA;
697 memcpy(p->poc + p->nb_poc, tmp.poc, tmp.nb_poc * sizeof(tmp.poc[0]));
698 p->nb_poc += tmp.nb_poc;
707 /* Get start of tile segment. */
708 static int get_sot(Jpeg2000DecoderContext *s, int n)
710 Jpeg2000TilePart *tp;
715 if (bytestream2_get_bytes_left(&s->g) < 8)
716 return AVERROR_INVALIDDATA;
719 Isot = bytestream2_get_be16u(&s->g); // Isot
720 if (Isot >= s->numXtiles * s->numYtiles)
721 return AVERROR_INVALIDDATA;
724 Psot = bytestream2_get_be32u(&s->g); // Psot
725 TPsot = bytestream2_get_byteu(&s->g); // TPsot
727 /* Read TNSot but not used */
728 bytestream2_get_byteu(&s->g); // TNsot
731 Psot = bytestream2_get_bytes_left(&s->g) + n + 2;
733 if (Psot > bytestream2_get_bytes_left(&s->g) + n + 2) {
734 av_log(s->avctx, AV_LOG_ERROR, "Psot %"PRIu32" too big\n", Psot);
735 return AVERROR_INVALIDDATA;
738 av_assert0(TPsot < FF_ARRAY_ELEMS(s->tile[Isot].tile_part));
740 s->tile[Isot].tp_idx = TPsot;
741 tp = s->tile[Isot].tile_part + TPsot;
742 tp->tile_index = Isot;
743 tp->tp_end = s->g.buffer + Psot - n - 2;
746 Jpeg2000Tile *tile = s->tile + s->curtileno;
749 memcpy(tile->codsty, s->codsty, s->ncomponents * sizeof(Jpeg2000CodingStyle));
750 memcpy(tile->qntsty, s->qntsty, s->ncomponents * sizeof(Jpeg2000QuantStyle));
751 memcpy(&tile->poc , &s->poc , sizeof(tile->poc));
752 tile->poc.is_default = 1;
758 /* Tile-part lengths: see ISO 15444-1:2002, section A.7.1
759 * Used to know the number of tile parts and lengths.
760 * There may be multiple TLMs in the header.
761 * TODO: The function is not used for tile-parts management, nor anywhere else.
762 * It can be useful to allocate memory for tile parts, before managing the SOT
763 * markers. Parsing the TLM header is needed to increment the input header
765 * This marker is mandatory for DCI. */
766 static uint8_t get_tlm(Jpeg2000DecoderContext *s, int n)
768 uint8_t Stlm, ST, SP, tile_tlm, i;
769 bytestream2_get_byte(&s->g); /* Ztlm: skipped */
770 Stlm = bytestream2_get_byte(&s->g);
772 // too complex ? ST = ((Stlm >> 4) & 0x01) + ((Stlm >> 4) & 0x02);
773 ST = (Stlm >> 4) & 0x03;
774 // TODO: Manage case of ST = 0b11 --> raise error
775 SP = (Stlm >> 6) & 0x01;
776 tile_tlm = (n - 4) / ((SP + 1) * 2 + ST);
777 for (i = 0; i < tile_tlm; i++) {
782 bytestream2_get_byte(&s->g);
785 bytestream2_get_be16(&s->g);
788 bytestream2_get_be32(&s->g);
792 bytestream2_get_be16(&s->g);
794 bytestream2_get_be32(&s->g);
800 static uint8_t get_plt(Jpeg2000DecoderContext *s, int n)
804 av_log(s->avctx, AV_LOG_DEBUG,
805 "PLT marker at pos 0x%X\n", bytestream2_tell(&s->g) - 4);
807 /*Zplt =*/ bytestream2_get_byte(&s->g);
809 for (i = 0; i < n - 3; i++) {
810 bytestream2_get_byte(&s->g);
816 static int init_tile(Jpeg2000DecoderContext *s, int tileno)
819 int tilex = tileno % s->numXtiles;
820 int tiley = tileno / s->numXtiles;
821 Jpeg2000Tile *tile = s->tile + tileno;
824 return AVERROR(ENOMEM);
826 tile->coord[0][0] = FFMAX(tilex * s->tile_width + s->tile_offset_x, s->image_offset_x);
827 tile->coord[0][1] = FFMIN((tilex + 1) * s->tile_width + s->tile_offset_x, s->width);
828 tile->coord[1][0] = FFMAX(tiley * s->tile_height + s->tile_offset_y, s->image_offset_y);
829 tile->coord[1][1] = FFMIN((tiley + 1) * s->tile_height + s->tile_offset_y, s->height);
831 for (compno = 0; compno < s->ncomponents; compno++) {
832 Jpeg2000Component *comp = tile->comp + compno;
833 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
834 Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
835 int ret; // global bandno
837 comp->coord_o[0][0] = tile->coord[0][0];
838 comp->coord_o[0][1] = tile->coord[0][1];
839 comp->coord_o[1][0] = tile->coord[1][0];
840 comp->coord_o[1][1] = tile->coord[1][1];
842 comp->coord_o[0][0] /= s->cdx[compno];
843 comp->coord_o[0][1] /= s->cdx[compno];
844 comp->coord_o[1][0] /= s->cdy[compno];
845 comp->coord_o[1][1] /= s->cdy[compno];
848 comp->coord[0][0] = ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], s->reduction_factor);
849 comp->coord[0][1] = ff_jpeg2000_ceildivpow2(comp->coord_o[0][1], s->reduction_factor);
850 comp->coord[1][0] = ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], s->reduction_factor);
851 comp->coord[1][1] = ff_jpeg2000_ceildivpow2(comp->coord_o[1][1], s->reduction_factor);
853 if (ret = ff_jpeg2000_init_component(comp, codsty, qntsty,
854 s->cbps[compno], s->cdx[compno],
855 s->cdy[compno], s->avctx))
861 /* Read the number of coding passes. */
862 static int getnpasses(Jpeg2000DecoderContext *s)
869 if ((num = get_bits(s, 2)) != 3)
870 return num < 0 ? num : 3 + num;
871 if ((num = get_bits(s, 5)) != 31)
872 return num < 0 ? num : 6 + num;
873 num = get_bits(s, 7);
874 return num < 0 ? num : 37 + num;
877 static int getlblockinc(Jpeg2000DecoderContext *s)
880 while (ret = get_bits(s, 1)) {
888 static int jpeg2000_decode_packet(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile, int *tp_index,
889 Jpeg2000CodingStyle *codsty,
890 Jpeg2000ResLevel *rlevel, int precno,
891 int layno, uint8_t *expn, int numgbits)
893 int bandno, cblkno, ret, nb_code_blocks;
896 if (layno < rlevel->band[0].prec[precno].decoded_layers)
898 rlevel->band[0].prec[precno].decoded_layers = layno + 1;
900 if (bytestream2_get_bytes_left(&s->g) == 0 && s->bit_index == 8) {
901 if (*tp_index < FF_ARRAY_ELEMS(tile->tile_part) - 1) {
902 s->g = tile->tile_part[++(*tp_index)].tpg;
906 if (bytestream2_peek_be32(&s->g) == JPEG2000_SOP_FIXED_BYTES)
907 bytestream2_skip(&s->g, JPEG2000_SOP_BYTE_LENGTH);
909 if (!(ret = get_bits(s, 1))) {
915 for (bandno = 0; bandno < rlevel->nbands; bandno++) {
916 Jpeg2000Band *band = rlevel->band + bandno;
917 Jpeg2000Prec *prec = band->prec + precno;
919 if (band->coord[0][0] == band->coord[0][1] ||
920 band->coord[1][0] == band->coord[1][1])
922 nb_code_blocks = prec->nb_codeblocks_height *
923 prec->nb_codeblocks_width;
924 for (cblkno = 0; cblkno < nb_code_blocks; cblkno++) {
925 Jpeg2000Cblk *cblk = prec->cblk + cblkno;
926 int incl, newpasses, llen;
929 incl = get_bits(s, 1);
931 incl = tag_tree_decode(s, prec->cblkincl + cblkno, layno + 1) == layno;
937 if (!cblk->npasses) {
938 int v = expn[bandno] + numgbits - 1 -
939 tag_tree_decode(s, prec->zerobits + cblkno, 100);
941 av_log(s->avctx, AV_LOG_ERROR,
942 "nonzerobits %d invalid\n", v);
943 return AVERROR_INVALIDDATA;
945 cblk->nonzerobits = v;
947 if ((newpasses = getnpasses(s)) < 0)
949 av_assert2(newpasses > 0);
950 if (cblk->npasses + newpasses >= JPEG2000_MAX_PASSES) {
951 avpriv_request_sample(s->avctx, "Too many passes\n");
952 return AVERROR_PATCHWELCOME;
954 if ((llen = getlblockinc(s)) < 0)
956 if (cblk->lblock + llen + av_log2(newpasses) > 16) {
957 avpriv_request_sample(s->avctx,
958 "Block with length beyond 16 bits\n");
959 return AVERROR_PATCHWELCOME;
962 cblk->lblock += llen;
964 cblk->nb_lengthinc = 0;
965 cblk->nb_terminationsinc = 0;
969 while (newpasses1 < newpasses) {
971 if (needs_termination(codsty->cblk_style, cblk->npasses + newpasses1 - 1)) {
972 cblk->nb_terminationsinc ++;
977 if ((ret = get_bits(s, av_log2(newpasses1) + cblk->lblock)) < 0)
979 if (ret > sizeof(cblk->data)) {
980 avpriv_request_sample(s->avctx,
981 "Block with lengthinc greater than %"SIZE_SPECIFIER"",
983 return AVERROR_PATCHWELCOME;
985 cblk->lengthinc[cblk->nb_lengthinc++] = ret;
986 cblk->npasses += newpasses1;
987 newpasses -= newpasses1;
993 if (codsty->csty & JPEG2000_CSTY_EPH) {
994 if (bytestream2_peek_be16(&s->g) == JPEG2000_EPH)
995 bytestream2_skip(&s->g, 2);
997 av_log(s->avctx, AV_LOG_ERROR, "EPH marker not found. instead %X\n", bytestream2_peek_be32(&s->g));
1000 for (bandno = 0; bandno < rlevel->nbands; bandno++) {
1001 Jpeg2000Band *band = rlevel->band + bandno;
1002 Jpeg2000Prec *prec = band->prec + precno;
1004 nb_code_blocks = prec->nb_codeblocks_height * prec->nb_codeblocks_width;
1005 for (cblkno = 0; cblkno < nb_code_blocks; cblkno++) {
1006 Jpeg2000Cblk *cblk = prec->cblk + cblkno;
1007 for (cwsno = 0; cwsno < cblk->nb_lengthinc; cwsno ++) {
1008 if ( bytestream2_get_bytes_left(&s->g) < cblk->lengthinc[cwsno]
1009 || sizeof(cblk->data) < cblk->length + cblk->lengthinc[cwsno] + 4
1011 av_log(s->avctx, AV_LOG_ERROR,
1012 "Block length %"PRIu16" or lengthinc %d is too large, left %d\n",
1013 cblk->length, cblk->lengthinc[cwsno], bytestream2_get_bytes_left(&s->g));
1014 return AVERROR_INVALIDDATA;
1017 bytestream2_get_bufferu(&s->g, cblk->data + cblk->length, cblk->lengthinc[cwsno]);
1018 cblk->length += cblk->lengthinc[cwsno];
1019 cblk->lengthinc[cwsno] = 0;
1020 if (cblk->nb_terminationsinc) {
1021 cblk->nb_terminationsinc--;
1022 cblk->nb_terminations++;
1023 cblk->data[cblk->length++] = 0xFF;
1024 cblk->data[cblk->length++] = 0xFF;
1025 cblk->data_start[cblk->nb_terminations] = cblk->length;
1033 static int jpeg2000_decode_packets_po_iteration(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile,
1034 int RSpoc, int CSpoc,
1035 int LYEpoc, int REpoc, int CEpoc,
1036 int Ppoc, int *tp_index)
1039 int layno, reslevelno, compno, precno, ok_reslevel;
1044 case JPEG2000_PGOD_RLCP:
1045 av_log(s->avctx, AV_LOG_DEBUG, "Progression order RLCP\n");
1047 for (reslevelno = RSpoc; ok_reslevel && reslevelno < REpoc; reslevelno++) {
1049 for (layno = 0; layno < LYEpoc; layno++) {
1050 for (compno = CSpoc; compno < CEpoc; compno++) {
1051 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1052 Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
1053 if (reslevelno < codsty->nreslevels) {
1054 Jpeg2000ResLevel *rlevel = tile->comp[compno].reslevel +
1057 for (precno = 0; precno < rlevel->num_precincts_x * rlevel->num_precincts_y; precno++)
1058 if ((ret = jpeg2000_decode_packet(s, tile, tp_index,
1061 qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1062 qntsty->nguardbits)) < 0)
1070 case JPEG2000_PGOD_LRCP:
1071 av_log(s->avctx, AV_LOG_DEBUG, "Progression order LRCP\n");
1072 for (layno = 0; layno < LYEpoc; layno++) {
1074 for (reslevelno = RSpoc; ok_reslevel && reslevelno < REpoc; reslevelno++) {
1076 for (compno = CSpoc; compno < CEpoc; compno++) {
1077 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1078 Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
1079 if (reslevelno < codsty->nreslevels) {
1080 Jpeg2000ResLevel *rlevel = tile->comp[compno].reslevel +
1083 for (precno = 0; precno < rlevel->num_precincts_x * rlevel->num_precincts_y; precno++)
1084 if ((ret = jpeg2000_decode_packet(s, tile, tp_index,
1087 qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1088 qntsty->nguardbits)) < 0)
1096 case JPEG2000_PGOD_CPRL:
1097 av_log(s->avctx, AV_LOG_DEBUG, "Progression order CPRL\n");
1098 for (compno = CSpoc; compno < CEpoc; compno++) {
1099 Jpeg2000Component *comp = tile->comp + compno;
1100 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1101 Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
1105 for (reslevelno = RSpoc; reslevelno < FFMIN(codsty->nreslevels, REpoc); reslevelno++) {
1106 uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1107 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1108 step_x = FFMIN(step_x, rlevel->log2_prec_width + reducedresno);
1109 step_y = FFMIN(step_y, rlevel->log2_prec_height + reducedresno);
1114 for (y = tile->coord[1][0]; y < tile->coord[1][1]; y = (y/step_y + 1)*step_y) {
1115 for (x = tile->coord[0][0]; x < tile->coord[0][1]; x = (x/step_x + 1)*step_x) {
1116 for (reslevelno = RSpoc; reslevelno < FFMIN(codsty->nreslevels, REpoc); reslevelno++) {
1117 unsigned prcx, prcy;
1118 uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1119 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1120 int xc = x / s->cdx[compno];
1121 int yc = y / s->cdy[compno];
1123 if (yc % (1 << (rlevel->log2_prec_height + reducedresno)) && y != tile->coord[1][0]) //FIXME this is a subset of the check
1126 if (xc % (1 << (rlevel->log2_prec_width + reducedresno)) && x != tile->coord[0][0]) //FIXME this is a subset of the check
1129 // check if a precinct exists
1130 prcx = ff_jpeg2000_ceildivpow2(xc, reducedresno) >> rlevel->log2_prec_width;
1131 prcy = ff_jpeg2000_ceildivpow2(yc, reducedresno) >> rlevel->log2_prec_height;
1132 prcx -= ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], reducedresno) >> rlevel->log2_prec_width;
1133 prcy -= ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], reducedresno) >> rlevel->log2_prec_height;
1135 precno = prcx + rlevel->num_precincts_x * prcy;
1137 if (prcx >= rlevel->num_precincts_x || prcy >= rlevel->num_precincts_y) {
1138 av_log(s->avctx, AV_LOG_WARNING, "prc %d %d outside limits %d %d\n",
1139 prcx, prcy, rlevel->num_precincts_x, rlevel->num_precincts_y);
1143 for (layno = 0; layno < LYEpoc; layno++) {
1144 if ((ret = jpeg2000_decode_packet(s, tile, tp_index, codsty, rlevel,
1146 qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1147 qntsty->nguardbits)) < 0)
1156 case JPEG2000_PGOD_RPCL:
1157 av_log(s->avctx, AV_LOG_WARNING, "Progression order RPCL\n");
1159 for (reslevelno = RSpoc; ok_reslevel && reslevelno < REpoc; reslevelno++) {
1163 for (compno = CSpoc; compno < CEpoc; compno++) {
1164 Jpeg2000Component *comp = tile->comp + compno;
1165 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1167 if (reslevelno < codsty->nreslevels) {
1168 uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1169 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1170 step_x = FFMIN(step_x, rlevel->log2_prec_width + reducedresno);
1171 step_y = FFMIN(step_y, rlevel->log2_prec_height + reducedresno);
1177 for (y = tile->coord[1][0]; y < tile->coord[1][1]; y = (y/step_y + 1)*step_y) {
1178 for (x = tile->coord[0][0]; x < tile->coord[0][1]; x = (x/step_x + 1)*step_x) {
1179 for (compno = CSpoc; compno < CEpoc; compno++) {
1180 Jpeg2000Component *comp = tile->comp + compno;
1181 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1182 Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
1183 uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1184 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1185 unsigned prcx, prcy;
1187 int xc = x / s->cdx[compno];
1188 int yc = y / s->cdy[compno];
1190 if (reslevelno >= codsty->nreslevels)
1193 if (yc % (1 << (rlevel->log2_prec_height + reducedresno)) && y != tile->coord[1][0]) //FIXME this is a subset of the check
1196 if (xc % (1 << (rlevel->log2_prec_width + reducedresno)) && x != tile->coord[0][0]) //FIXME this is a subset of the check
1199 // check if a precinct exists
1200 prcx = ff_jpeg2000_ceildivpow2(xc, reducedresno) >> rlevel->log2_prec_width;
1201 prcy = ff_jpeg2000_ceildivpow2(yc, reducedresno) >> rlevel->log2_prec_height;
1202 prcx -= ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], reducedresno) >> rlevel->log2_prec_width;
1203 prcy -= ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], reducedresno) >> rlevel->log2_prec_height;
1205 precno = prcx + rlevel->num_precincts_x * prcy;
1208 if (prcx >= rlevel->num_precincts_x || prcy >= rlevel->num_precincts_y) {
1209 av_log(s->avctx, AV_LOG_WARNING, "prc %d %d outside limits %d %d\n",
1210 prcx, prcy, rlevel->num_precincts_x, rlevel->num_precincts_y);
1214 for (layno = 0; layno < LYEpoc; layno++) {
1215 if ((ret = jpeg2000_decode_packet(s, tile, tp_index,
1218 qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1219 qntsty->nguardbits)) < 0)
1228 case JPEG2000_PGOD_PCRL:
1229 av_log(s->avctx, AV_LOG_WARNING, "Progression order PCRL\n");
1232 for (compno = CSpoc; compno < CEpoc; compno++) {
1233 Jpeg2000Component *comp = tile->comp + compno;
1234 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1236 for (reslevelno = RSpoc; reslevelno < FFMIN(codsty->nreslevels, REpoc); reslevelno++) {
1237 uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1238 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1239 step_x = FFMIN(step_x, rlevel->log2_prec_width + reducedresno);
1240 step_y = FFMIN(step_y, rlevel->log2_prec_height + reducedresno);
1246 for (y = tile->coord[1][0]; y < tile->coord[1][1]; y = (y/step_y + 1)*step_y) {
1247 for (x = tile->coord[0][0]; x < tile->coord[0][1]; x = (x/step_x + 1)*step_x) {
1248 for (compno = CSpoc; compno < CEpoc; compno++) {
1249 Jpeg2000Component *comp = tile->comp + compno;
1250 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1251 Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
1252 int xc = x / s->cdx[compno];
1253 int yc = y / s->cdy[compno];
1255 for (reslevelno = RSpoc; reslevelno < FFMIN(codsty->nreslevels, REpoc); reslevelno++) {
1256 unsigned prcx, prcy;
1257 uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1258 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1260 if (yc % (1 << (rlevel->log2_prec_height + reducedresno)) && y != tile->coord[1][0]) //FIXME this is a subset of the check
1263 if (xc % (1 << (rlevel->log2_prec_width + reducedresno)) && x != tile->coord[0][0]) //FIXME this is a subset of the check
1266 // check if a precinct exists
1267 prcx = ff_jpeg2000_ceildivpow2(xc, reducedresno) >> rlevel->log2_prec_width;
1268 prcy = ff_jpeg2000_ceildivpow2(yc, reducedresno) >> rlevel->log2_prec_height;
1269 prcx -= ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], reducedresno) >> rlevel->log2_prec_width;
1270 prcy -= ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], reducedresno) >> rlevel->log2_prec_height;
1272 precno = prcx + rlevel->num_precincts_x * prcy;
1274 if (prcx >= rlevel->num_precincts_x || prcy >= rlevel->num_precincts_y) {
1275 av_log(s->avctx, AV_LOG_WARNING, "prc %d %d outside limits %d %d\n",
1276 prcx, prcy, rlevel->num_precincts_x, rlevel->num_precincts_y);
1280 for (layno = 0; layno < LYEpoc; layno++) {
1281 if ((ret = jpeg2000_decode_packet(s, tile, tp_index, codsty, rlevel,
1283 qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1284 qntsty->nguardbits)) < 0)
1300 static int jpeg2000_decode_packets(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
1306 if (tile->poc.nb_poc) {
1307 for (i=0; i<tile->poc.nb_poc; i++) {
1308 Jpeg2000POCEntry *e = &tile->poc.poc[i];
1309 ret = jpeg2000_decode_packets_po_iteration(s, tile,
1311 FFMIN(e->LYEpoc, tile->codsty[0].nlayers),
1313 FFMIN(e->CEpoc, s->ncomponents),
1320 ret = jpeg2000_decode_packets_po_iteration(s, tile,
1322 tile->codsty[0].nlayers,
1325 tile->codsty[0].prog_order,
1329 /* EOC marker reached */
1330 bytestream2_skip(&s->g, 2);
1335 /* TIER-1 routines */
1336 static void decode_sigpass(Jpeg2000T1Context *t1, int width, int height,
1337 int bpno, int bandno,
1338 int vert_causal_ctx_csty_symbol)
1340 int mask = 3 << (bpno - 1), y0, x, y;
1342 for (y0 = 0; y0 < height; y0 += 4)
1343 for (x = 0; x < width; x++)
1344 for (y = y0; y < height && y < y0 + 4; y++) {
1345 int flags_mask = -1;
1346 if (vert_causal_ctx_csty_symbol && y == y0 + 3)
1347 flags_mask &= ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE | JPEG2000_T1_SGN_S);
1348 if ((t1->flags[(y+1) * t1->stride + x+1] & JPEG2000_T1_SIG_NB & flags_mask)
1349 && !(t1->flags[(y+1) * t1->stride + x+1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS))) {
1350 if (ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ff_jpeg2000_getsigctxno(t1->flags[(y+1) * t1->stride + x+1] & flags_mask, bandno))) {
1351 int xorbit, ctxno = ff_jpeg2000_getsgnctxno(t1->flags[(y+1) * t1->stride + x+1] & flags_mask, &xorbit);
1353 t1->data[(y) * t1->stride + x] = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ctxno) ? -mask : mask;
1355 t1->data[(y) * t1->stride + x] = (ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ctxno) ^ xorbit) ?
1358 ff_jpeg2000_set_significance(t1, x, y,
1359 t1->data[(y) * t1->stride + x] < 0);
1361 t1->flags[(y + 1) * t1->stride + x + 1] |= JPEG2000_T1_VIS;
1366 static void decode_refpass(Jpeg2000T1Context *t1, int width, int height,
1367 int bpno, int vert_causal_ctx_csty_symbol)
1372 phalf = 1 << (bpno - 1);
1375 for (y0 = 0; y0 < height; y0 += 4)
1376 for (x = 0; x < width; x++)
1377 for (y = y0; y < height && y < y0 + 4; y++)
1378 if ((t1->flags[(y + 1) * t1->stride + x + 1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS)) == JPEG2000_T1_SIG) {
1379 int flags_mask = (vert_causal_ctx_csty_symbol && y == y0 + 3) ?
1380 ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE | JPEG2000_T1_SGN_S) : -1;
1381 int ctxno = ff_jpeg2000_getrefctxno(t1->flags[(y + 1) * t1->stride + x + 1] & flags_mask);
1382 int r = ff_mqc_decode(&t1->mqc,
1383 t1->mqc.cx_states + ctxno)
1385 t1->data[(y) * t1->stride + x] += t1->data[(y) * t1->stride + x] < 0 ? -r : r;
1386 t1->flags[(y + 1) * t1->stride + x + 1] |= JPEG2000_T1_REF;
1390 static void decode_clnpass(Jpeg2000DecoderContext *s, Jpeg2000T1Context *t1,
1391 int width, int height, int bpno, int bandno,
1392 int seg_symbols, int vert_causal_ctx_csty_symbol)
1394 int mask = 3 << (bpno - 1), y0, x, y, runlen, dec;
1396 for (y0 = 0; y0 < height; y0 += 4) {
1397 for (x = 0; x < width; x++) {
1398 int flags_mask = -1;
1399 if (vert_causal_ctx_csty_symbol)
1400 flags_mask &= ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE | JPEG2000_T1_SGN_S);
1401 if (y0 + 3 < height &&
1402 !((t1->flags[(y0 + 1) * t1->stride + x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
1403 (t1->flags[(y0 + 2) * t1->stride + x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
1404 (t1->flags[(y0 + 3) * t1->stride + x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
1405 (t1->flags[(y0 + 4) * t1->stride + x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG) & flags_mask))) {
1406 if (!ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_RL))
1408 runlen = ff_mqc_decode(&t1->mqc,
1409 t1->mqc.cx_states + MQC_CX_UNI);
1410 runlen = (runlen << 1) | ff_mqc_decode(&t1->mqc,
1419 for (y = y0 + runlen; y < y0 + 4 && y < height; y++) {
1420 int flags_mask = -1;
1421 if (vert_causal_ctx_csty_symbol && y == y0 + 3)
1422 flags_mask &= ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE | JPEG2000_T1_SGN_S);
1424 if (!(t1->flags[(y+1) * t1->stride + x+1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS))) {
1425 dec = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ff_jpeg2000_getsigctxno(t1->flags[(y+1) * t1->stride + x+1] & flags_mask,
1431 int ctxno = ff_jpeg2000_getsgnctxno(t1->flags[(y + 1) * t1->stride + x + 1] & flags_mask,
1433 t1->data[(y) * t1->stride + x] = (ff_mqc_decode(&t1->mqc,
1434 t1->mqc.cx_states + ctxno) ^
1437 ff_jpeg2000_set_significance(t1, x, y, t1->data[(y) * t1->stride + x] < 0);
1440 t1->flags[(y + 1) * t1->stride + x + 1] &= ~JPEG2000_T1_VIS;
1446 val = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1447 val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1448 val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1449 val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1451 av_log(s->avctx, AV_LOG_ERROR,
1452 "Segmentation symbol value incorrect\n");
1456 static int decode_cblk(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *codsty,
1457 Jpeg2000T1Context *t1, Jpeg2000Cblk *cblk,
1458 int width, int height, int bandpos)
1460 int passno = cblk->npasses, pass_t = 2, bpno = cblk->nonzerobits - 1;
1462 int vert_causal_ctx_csty_symbol = codsty->cblk_style & JPEG2000_CBLK_VSC;
1466 av_assert0(width <= 1024U && height <= 1024U);
1467 av_assert0(width*height <= 4096);
1469 memset(t1->data, 0, t1->stride * height * sizeof(*t1->data));
1471 /* If code-block contains no compressed data: nothing to do. */
1475 memset(t1->flags, 0, t1->stride * (height + 2) * sizeof(*t1->flags));
1477 cblk->data[cblk->length] = 0xff;
1478 cblk->data[cblk->length+1] = 0xff;
1479 ff_mqc_initdec(&t1->mqc, cblk->data, 0, 1);
1484 decode_sigpass(t1, width, height, bpno + 1, bandpos,
1485 vert_causal_ctx_csty_symbol);
1488 decode_refpass(t1, width, height, bpno + 1, vert_causal_ctx_csty_symbol);
1491 av_assert2(!t1->mqc.raw);
1492 decode_clnpass(s, t1, width, height, bpno + 1, bandpos,
1493 codsty->cblk_style & JPEG2000_CBLK_SEGSYM,
1494 vert_causal_ctx_csty_symbol);
1497 if (codsty->cblk_style & JPEG2000_CBLK_RESET) // XXX no testcase for just this
1498 ff_mqc_init_contexts(&t1->mqc);
1500 if (passno && (coder_type = needs_termination(codsty->cblk_style, pass_cnt))) {
1501 if (term_cnt >= cblk->nb_terminations) {
1502 av_log(s->avctx, AV_LOG_ERROR, "Missing needed termination \n");
1503 return AVERROR_INVALIDDATA;
1505 if (FFABS(cblk->data + cblk->data_start[term_cnt + 1] - 2 - t1->mqc.bp) > 0) {
1506 av_log(s->avctx, AV_LOG_WARNING, "Mid mismatch %"PTRDIFF_SPECIFIER" in pass %d of %d\n",
1507 cblk->data + cblk->data_start[term_cnt + 1] - 2 - t1->mqc.bp,
1508 pass_cnt, cblk->npasses);
1511 ff_mqc_initdec(&t1->mqc, cblk->data + cblk->data_start[++term_cnt], coder_type == 2, 0);
1522 if (cblk->data + cblk->length - 2*(term_cnt < cblk->nb_terminations) != t1->mqc.bp) {
1523 av_log(s->avctx, AV_LOG_WARNING, "End mismatch %"PTRDIFF_SPECIFIER"\n",
1524 cblk->data + cblk->length - 2*(term_cnt < cblk->nb_terminations) - t1->mqc.bp);
1530 /* TODO: Verify dequantization for lossless case
1531 * comp->data can be float or int
1532 * band->stepsize can be float or int
1533 * depending on the type of DWT transformation.
1534 * see ISO/IEC 15444-1:2002 A.6.1 */
1536 /* Float dequantization of a codeblock.*/
1537 static void dequantization_float(int x, int y, Jpeg2000Cblk *cblk,
1538 Jpeg2000Component *comp,
1539 Jpeg2000T1Context *t1, Jpeg2000Band *band)
1542 int w = cblk->coord[0][1] - cblk->coord[0][0];
1543 for (j = 0; j < (cblk->coord[1][1] - cblk->coord[1][0]); ++j) {
1544 float *datap = &comp->f_data[(comp->coord[0][1] - comp->coord[0][0]) * (y + j) + x];
1545 int *src = t1->data + j*t1->stride;
1546 for (i = 0; i < w; ++i)
1547 datap[i] = src[i] * band->f_stepsize;
1551 /* Integer dequantization of a codeblock.*/
1552 static void dequantization_int(int x, int y, Jpeg2000Cblk *cblk,
1553 Jpeg2000Component *comp,
1554 Jpeg2000T1Context *t1, Jpeg2000Band *band)
1557 int w = cblk->coord[0][1] - cblk->coord[0][0];
1558 for (j = 0; j < (cblk->coord[1][1] - cblk->coord[1][0]); ++j) {
1559 int32_t *datap = &comp->i_data[(comp->coord[0][1] - comp->coord[0][0]) * (y + j) + x];
1560 int *src = t1->data + j*t1->stride;
1561 if (band->i_stepsize == 32768) {
1562 for (i = 0; i < w; ++i)
1563 datap[i] = src[i] / 2;
1565 // This should be VERY uncommon
1566 for (i = 0; i < w; ++i)
1567 datap[i] = (src[i] * (int64_t)band->i_stepsize) / 65536;
1572 static void dequantization_int_97(int x, int y, Jpeg2000Cblk *cblk,
1573 Jpeg2000Component *comp,
1574 Jpeg2000T1Context *t1, Jpeg2000Band *band)
1577 int w = cblk->coord[0][1] - cblk->coord[0][0];
1578 for (j = 0; j < (cblk->coord[1][1] - cblk->coord[1][0]); ++j) {
1579 int32_t *datap = &comp->i_data[(comp->coord[0][1] - comp->coord[0][0]) * (y + j) + x];
1580 int *src = t1->data + j*t1->stride;
1581 for (i = 0; i < w; ++i)
1582 datap[i] = (src[i] * (int64_t)band->i_stepsize + (1<<15)) >> 16;
1586 static inline void mct_decode(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
1591 for (i = 1; i < 3; i++) {
1592 if (tile->codsty[0].transform != tile->codsty[i].transform) {
1593 av_log(s->avctx, AV_LOG_ERROR, "Transforms mismatch, MCT not supported\n");
1596 if (memcmp(tile->comp[0].coord, tile->comp[i].coord, sizeof(tile->comp[0].coord))) {
1597 av_log(s->avctx, AV_LOG_ERROR, "Coords mismatch, MCT not supported\n");
1602 for (i = 0; i < 3; i++)
1603 if (tile->codsty[0].transform == FF_DWT97)
1604 src[i] = tile->comp[i].f_data;
1606 src[i] = tile->comp[i].i_data;
1608 for (i = 0; i < 2; i++)
1609 csize *= tile->comp[0].coord[i][1] - tile->comp[0].coord[i][0];
1611 s->dsp.mct_decode[tile->codsty[0].transform](src[0], src[1], src[2], csize);
1614 static int jpeg2000_decode_tile(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile,
1617 const AVPixFmtDescriptor *pixdesc = av_pix_fmt_desc_get(s->avctx->pix_fmt);
1618 int compno, reslevelno, bandno;
1620 int planar = !!(pixdesc->flags & AV_PIX_FMT_FLAG_PLANAR);
1621 int pixelsize = planar ? 1 : pixdesc->nb_components;
1624 Jpeg2000T1Context t1;
1626 /* Loop on tile components */
1627 for (compno = 0; compno < s->ncomponents; compno++) {
1628 Jpeg2000Component *comp = tile->comp + compno;
1629 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1631 t1.stride = (1<<codsty->log2_cblk_width) + 2;
1633 /* Loop on resolution levels */
1634 for (reslevelno = 0; reslevelno < codsty->nreslevels2decode; reslevelno++) {
1635 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1637 for (bandno = 0; bandno < rlevel->nbands; bandno++) {
1638 int nb_precincts, precno;
1639 Jpeg2000Band *band = rlevel->band + bandno;
1640 int cblkno = 0, bandpos;
1642 bandpos = bandno + (reslevelno > 0);
1644 if (band->coord[0][0] == band->coord[0][1] ||
1645 band->coord[1][0] == band->coord[1][1])
1648 nb_precincts = rlevel->num_precincts_x * rlevel->num_precincts_y;
1649 /* Loop on precincts */
1650 for (precno = 0; precno < nb_precincts; precno++) {
1651 Jpeg2000Prec *prec = band->prec + precno;
1653 /* Loop on codeblocks */
1654 for (cblkno = 0; cblkno < prec->nb_codeblocks_width * prec->nb_codeblocks_height; cblkno++) {
1656 Jpeg2000Cblk *cblk = prec->cblk + cblkno;
1657 decode_cblk(s, codsty, &t1, cblk,
1658 cblk->coord[0][1] - cblk->coord[0][0],
1659 cblk->coord[1][1] - cblk->coord[1][0],
1662 x = cblk->coord[0][0] - band->coord[0][0];
1663 y = cblk->coord[1][0] - band->coord[1][0];
1665 if (codsty->transform == FF_DWT97)
1666 dequantization_float(x, y, cblk, comp, &t1, band);
1667 else if (codsty->transform == FF_DWT97_INT)
1668 dequantization_int_97(x, y, cblk, comp, &t1, band);
1670 dequantization_int(x, y, cblk, comp, &t1, band);
1674 } /* end reslevel */
1677 ff_dwt_decode(&comp->dwt, codsty->transform == FF_DWT97 ? (void*)comp->f_data : (void*)comp->i_data);
1680 /* inverse MCT transformation */
1681 if (tile->codsty[0].mct)
1682 mct_decode(s, tile);
1684 if (s->cdef[0] < 0) {
1685 for (x = 0; x < s->ncomponents; x++)
1687 if ((s->ncomponents & 1) == 0)
1688 s->cdef[s->ncomponents-1] = 0;
1691 if (s->precision <= 8) {
1692 for (compno = 0; compno < s->ncomponents; compno++) {
1693 Jpeg2000Component *comp = tile->comp + compno;
1694 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1695 float *datap = comp->f_data;
1696 int32_t *i_datap = comp->i_data;
1697 int cbps = s->cbps[compno];
1698 int w = tile->comp[compno].coord[0][1] - s->image_offset_x;
1702 plane = s->cdef[compno] ? s->cdef[compno]-1 : (s->ncomponents-1);
1705 y = tile->comp[compno].coord[1][0] - s->image_offset_y / s->cdy[compno];
1706 line = picture->data[plane] + y * picture->linesize[plane];
1707 for (; y < tile->comp[compno].coord[1][1] - s->image_offset_y; y ++) {
1710 x = tile->comp[compno].coord[0][0] - s->image_offset_x / s->cdx[compno];
1711 dst = line + x * pixelsize + compno*!planar;
1713 if (codsty->transform == FF_DWT97) {
1714 for (; x < w; x ++) {
1715 int val = lrintf(*datap) + (1 << (cbps - 1));
1716 /* DC level shift and clip see ISO 15444-1:2002 G.1.2 */
1717 val = av_clip(val, 0, (1 << cbps) - 1);
1718 *dst = val << (8 - cbps);
1723 for (; x < w; x ++) {
1724 int val = *i_datap + (1 << (cbps - 1));
1725 /* DC level shift and clip see ISO 15444-1:2002 G.1.2 */
1726 val = av_clip(val, 0, (1 << cbps) - 1);
1727 *dst = val << (8 - cbps);
1732 line += picture->linesize[plane];
1736 int precision = picture->format == AV_PIX_FMT_XYZ12 ||
1737 picture->format == AV_PIX_FMT_RGB48 ||
1738 picture->format == AV_PIX_FMT_RGBA64 ||
1739 picture->format == AV_PIX_FMT_GRAY16 ? 16 : s->precision;
1741 for (compno = 0; compno < s->ncomponents; compno++) {
1742 Jpeg2000Component *comp = tile->comp + compno;
1743 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1744 float *datap = comp->f_data;
1745 int32_t *i_datap = comp->i_data;
1747 int cbps = s->cbps[compno];
1748 int w = tile->comp[compno].coord[0][1] - s->image_offset_x;
1752 plane = s->cdef[compno] ? s->cdef[compno]-1 : (s->ncomponents-1);
1754 y = tile->comp[compno].coord[1][0] - s->image_offset_y / s->cdy[compno];
1755 linel = (uint16_t *)picture->data[plane] + y * (picture->linesize[plane] >> 1);
1756 for (; y < tile->comp[compno].coord[1][1] - s->image_offset_y; y ++) {
1759 x = tile->comp[compno].coord[0][0] - s->image_offset_x / s->cdx[compno];
1760 dst = linel + (x * pixelsize + compno*!planar);
1761 if (codsty->transform == FF_DWT97) {
1762 for (; x < w; x ++) {
1763 int val = lrintf(*datap) + (1 << (cbps - 1));
1764 /* DC level shift and clip see ISO 15444-1:2002 G.1.2 */
1765 val = av_clip(val, 0, (1 << cbps) - 1);
1766 /* align 12 bit values in little-endian mode */
1767 *dst = val << (precision - cbps);
1772 for (; x < w; x ++) {
1773 int val = *i_datap + (1 << (cbps - 1));
1774 /* DC level shift and clip see ISO 15444-1:2002 G.1.2 */
1775 val = av_clip(val, 0, (1 << cbps) - 1);
1776 /* align 12 bit values in little-endian mode */
1777 *dst = val << (precision - cbps);
1782 linel += picture->linesize[plane] >> 1;
1790 static void jpeg2000_dec_cleanup(Jpeg2000DecoderContext *s)
1793 for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++) {
1794 if (s->tile[tileno].comp) {
1795 for (compno = 0; compno < s->ncomponents; compno++) {
1796 Jpeg2000Component *comp = s->tile[tileno].comp + compno;
1797 Jpeg2000CodingStyle *codsty = s->tile[tileno].codsty + compno;
1799 ff_jpeg2000_cleanup(comp, codsty);
1801 av_freep(&s->tile[tileno].comp);
1805 memset(s->codsty, 0, sizeof(s->codsty));
1806 memset(s->qntsty, 0, sizeof(s->qntsty));
1807 memset(&s->poc , 0, sizeof(s->poc));
1808 s->numXtiles = s->numYtiles = 0;
1811 static int jpeg2000_read_main_headers(Jpeg2000DecoderContext *s)
1813 Jpeg2000CodingStyle *codsty = s->codsty;
1814 Jpeg2000QuantStyle *qntsty = s->qntsty;
1815 Jpeg2000POC *poc = &s->poc;
1816 uint8_t *properties = s->properties;
1823 if (bytestream2_get_bytes_left(&s->g) < 2) {
1824 av_log(s->avctx, AV_LOG_ERROR, "Missing EOC\n");
1828 marker = bytestream2_get_be16u(&s->g);
1829 oldpos = bytestream2_tell(&s->g);
1831 if (marker == JPEG2000_SOD) {
1833 Jpeg2000TilePart *tp;
1836 av_log(s->avctx, AV_LOG_ERROR, "Missing SIZ\n");
1837 return AVERROR_INVALIDDATA;
1839 if (s->curtileno < 0) {
1840 av_log(s->avctx, AV_LOG_ERROR, "Missing SOT\n");
1841 return AVERROR_INVALIDDATA;
1844 tile = s->tile + s->curtileno;
1845 tp = tile->tile_part + tile->tp_idx;
1846 if (tp->tp_end < s->g.buffer) {
1847 av_log(s->avctx, AV_LOG_ERROR, "Invalid tpend\n");
1848 return AVERROR_INVALIDDATA;
1850 bytestream2_init(&tp->tpg, s->g.buffer, tp->tp_end - s->g.buffer);
1851 bytestream2_skip(&s->g, tp->tp_end - s->g.buffer);
1855 if (marker == JPEG2000_EOC)
1858 len = bytestream2_get_be16(&s->g);
1859 if (len < 2 || bytestream2_get_bytes_left(&s->g) < len - 2) {
1860 av_log(s->avctx, AV_LOG_ERROR, "Invalid len %d left=%d\n", len, bytestream2_get_bytes_left(&s->g));
1861 return AVERROR_INVALIDDATA;
1868 s->numXtiles = s->numYtiles = 0;
1871 ret = get_coc(s, codsty, properties);
1874 ret = get_cod(s, codsty, properties);
1877 ret = get_qcc(s, len, qntsty, properties);
1880 ret = get_qcd(s, len, qntsty, properties);
1883 ret = get_poc(s, len, poc);
1886 if (!(ret = get_sot(s, len))) {
1887 av_assert1(s->curtileno >= 0);
1888 codsty = s->tile[s->curtileno].codsty;
1889 qntsty = s->tile[s->curtileno].qntsty;
1890 poc = &s->tile[s->curtileno].poc;
1891 properties = s->tile[s->curtileno].properties;
1895 // the comment is ignored
1896 bytestream2_skip(&s->g, len - 2);
1899 // Tile-part lengths
1900 ret = get_tlm(s, len);
1903 // Packet length, tile-part header
1904 ret = get_plt(s, len);
1907 av_log(s->avctx, AV_LOG_ERROR,
1908 "unsupported marker 0x%.4"PRIX16" at pos 0x%X\n",
1909 marker, bytestream2_tell(&s->g) - 4);
1910 bytestream2_skip(&s->g, len - 2);
1913 if (bytestream2_tell(&s->g) - oldpos != len || ret) {
1914 av_log(s->avctx, AV_LOG_ERROR,
1915 "error during processing marker segment %.4"PRIx16"\n",
1917 return ret ? ret : -1;
1923 /* Read bit stream packets --> T2 operation. */
1924 static int jpeg2000_read_bitstream_packets(Jpeg2000DecoderContext *s)
1929 for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++) {
1930 Jpeg2000Tile *tile = s->tile + tileno;
1932 if ((ret = init_tile(s, tileno)) < 0)
1935 s->g = tile->tile_part[0].tpg;
1936 if ((ret = jpeg2000_decode_packets(s, tile)) < 0)
1943 static int jp2_find_codestream(Jpeg2000DecoderContext *s)
1945 uint32_t atom_size, atom, atom_end;
1946 int search_range = 10;
1950 bytestream2_get_bytes_left(&s->g) >= 8) {
1951 atom_size = bytestream2_get_be32u(&s->g);
1952 atom = bytestream2_get_be32u(&s->g);
1953 atom_end = bytestream2_tell(&s->g) + atom_size - 8;
1955 if (atom == JP2_CODESTREAM)
1958 if (bytestream2_get_bytes_left(&s->g) < atom_size || atom_end < atom_size)
1961 if (atom == JP2_HEADER &&
1963 uint32_t atom2_size, atom2, atom2_end;
1965 atom2_size = bytestream2_get_be32u(&s->g);
1966 atom2 = bytestream2_get_be32u(&s->g);
1967 atom2_end = bytestream2_tell(&s->g) + atom2_size - 8;
1968 if (atom2_size < 8 || atom2_end > atom_end || atom2_end < atom2_size)
1970 if (atom2 == JP2_CODESTREAM) {
1972 } else if (atom2 == MKBETAG('c','o','l','r') && atom2_size >= 7) {
1973 int method = bytestream2_get_byteu(&s->g);
1974 bytestream2_skipu(&s->g, 2);
1976 s->colour_space = bytestream2_get_be32u(&s->g);
1978 } else if (atom2 == MKBETAG('p','c','l','r') && atom2_size >= 6) {
1979 int i, size, colour_count, colour_channels, colour_depth[3];
1981 colour_count = bytestream2_get_be16u(&s->g);
1982 colour_channels = bytestream2_get_byteu(&s->g);
1983 // FIXME: Do not ignore channel_sign
1984 colour_depth[0] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1;
1985 colour_depth[1] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1;
1986 colour_depth[2] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1;
1987 size = (colour_depth[0] + 7 >> 3) * colour_count +
1988 (colour_depth[1] + 7 >> 3) * colour_count +
1989 (colour_depth[2] + 7 >> 3) * colour_count;
1990 if (colour_count > 256 ||
1991 colour_channels != 3 ||
1992 colour_depth[0] > 16 ||
1993 colour_depth[1] > 16 ||
1994 colour_depth[2] > 16 ||
1995 atom2_size < size) {
1996 avpriv_request_sample(s->avctx, "Unknown palette");
1997 bytestream2_seek(&s->g, atom2_end, SEEK_SET);
2001 for (i = 0; i < colour_count; i++) {
2002 if (colour_depth[0] <= 8) {
2003 r = bytestream2_get_byteu(&s->g) << 8 - colour_depth[0];
2004 r |= r >> colour_depth[0];
2006 r = bytestream2_get_be16u(&s->g) >> colour_depth[0] - 8;
2008 if (colour_depth[1] <= 8) {
2009 g = bytestream2_get_byteu(&s->g) << 8 - colour_depth[1];
2010 r |= r >> colour_depth[1];
2012 g = bytestream2_get_be16u(&s->g) >> colour_depth[1] - 8;
2014 if (colour_depth[2] <= 8) {
2015 b = bytestream2_get_byteu(&s->g) << 8 - colour_depth[2];
2016 r |= r >> colour_depth[2];
2018 b = bytestream2_get_be16u(&s->g) >> colour_depth[2] - 8;
2020 s->palette[i] = 0xffu << 24 | r << 16 | g << 8 | b;
2022 } else if (atom2 == MKBETAG('c','d','e','f') && atom2_size >= 2) {
2023 int n = bytestream2_get_be16u(&s->g);
2025 int cn = bytestream2_get_be16(&s->g);
2026 int av_unused typ = bytestream2_get_be16(&s->g);
2027 int asoc = bytestream2_get_be16(&s->g);
2028 if (cn < 4 && asoc < 4)
2032 bytestream2_seek(&s->g, atom2_end, SEEK_SET);
2033 } while (atom_end - atom2_end >= 8);
2037 bytestream2_seek(&s->g, atom_end, SEEK_SET);
2043 static av_cold int jpeg2000_decode_init(AVCodecContext *avctx)
2045 Jpeg2000DecoderContext *s = avctx->priv_data;
2047 ff_jpeg2000dsp_init(&s->dsp);
2052 static int jpeg2000_decode_frame(AVCodecContext *avctx, void *data,
2053 int *got_frame, AVPacket *avpkt)
2055 Jpeg2000DecoderContext *s = avctx->priv_data;
2056 ThreadFrame frame = { .f = data };
2057 AVFrame *picture = data;
2061 bytestream2_init(&s->g, avpkt->data, avpkt->size);
2063 memset(s->cdef, -1, sizeof(s->cdef));
2065 if (bytestream2_get_bytes_left(&s->g) < 2) {
2066 ret = AVERROR_INVALIDDATA;
2070 // check if the image is in jp2 format
2071 if (bytestream2_get_bytes_left(&s->g) >= 12 &&
2072 (bytestream2_get_be32u(&s->g) == 12) &&
2073 (bytestream2_get_be32u(&s->g) == JP2_SIG_TYPE) &&
2074 (bytestream2_get_be32u(&s->g) == JP2_SIG_VALUE)) {
2075 if (!jp2_find_codestream(s)) {
2076 av_log(avctx, AV_LOG_ERROR,
2077 "Could not find Jpeg2000 codestream atom.\n");
2078 ret = AVERROR_INVALIDDATA;
2082 bytestream2_seek(&s->g, 0, SEEK_SET);
2085 while (bytestream2_get_bytes_left(&s->g) >= 3 && bytestream2_peek_be16(&s->g) != JPEG2000_SOC)
2086 bytestream2_skip(&s->g, 1);
2088 if (bytestream2_get_be16u(&s->g) != JPEG2000_SOC) {
2089 av_log(avctx, AV_LOG_ERROR, "SOC marker not present\n");
2090 ret = AVERROR_INVALIDDATA;
2093 if (ret = jpeg2000_read_main_headers(s))
2096 /* get picture buffer */
2097 if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
2099 picture->pict_type = AV_PICTURE_TYPE_I;
2100 picture->key_frame = 1;
2102 if (ret = jpeg2000_read_bitstream_packets(s))
2105 for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++)
2106 if (ret = jpeg2000_decode_tile(s, s->tile + tileno, picture))
2109 jpeg2000_dec_cleanup(s);
2113 if (s->avctx->pix_fmt == AV_PIX_FMT_PAL8)
2114 memcpy(picture->data[1], s->palette, 256 * sizeof(uint32_t));
2116 return bytestream2_tell(&s->g);
2119 jpeg2000_dec_cleanup(s);
2123 static av_cold void jpeg2000_init_static_data(AVCodec *codec)
2125 ff_jpeg2000_init_tier1_luts();
2126 ff_mqc_init_context_tables();
2129 #define OFFSET(x) offsetof(Jpeg2000DecoderContext, x)
2130 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
2132 static const AVOption options[] = {
2133 { "lowres", "Lower the decoding resolution by a power of two",
2134 OFFSET(reduction_factor), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, JPEG2000_MAX_RESLEVELS - 1, VD },
2138 static const AVProfile profiles[] = {
2139 { FF_PROFILE_JPEG2000_CSTREAM_RESTRICTION_0, "JPEG 2000 codestream restriction 0" },
2140 { FF_PROFILE_JPEG2000_CSTREAM_RESTRICTION_1, "JPEG 2000 codestream restriction 1" },
2141 { FF_PROFILE_JPEG2000_CSTREAM_NO_RESTRICTION, "JPEG 2000 no codestream restrictions" },
2142 { FF_PROFILE_JPEG2000_DCINEMA_2K, "JPEG 2000 digital cinema 2K" },
2143 { FF_PROFILE_JPEG2000_DCINEMA_4K, "JPEG 2000 digital cinema 4K" },
2144 { FF_PROFILE_UNKNOWN },
2147 static const AVClass jpeg2000_class = {
2148 .class_name = "jpeg2000",
2149 .item_name = av_default_item_name,
2151 .version = LIBAVUTIL_VERSION_INT,
2154 AVCodec ff_jpeg2000_decoder = {
2156 .long_name = NULL_IF_CONFIG_SMALL("JPEG 2000"),
2157 .type = AVMEDIA_TYPE_VIDEO,
2158 .id = AV_CODEC_ID_JPEG2000,
2159 .capabilities = CODEC_CAP_FRAME_THREADS | CODEC_CAP_DR1,
2160 .priv_data_size = sizeof(Jpeg2000DecoderContext),
2161 .init_static_data = jpeg2000_init_static_data,
2162 .init = jpeg2000_decode_init,
2163 .decode = jpeg2000_decode_frame,
2164 .priv_class = &jpeg2000_class,
2166 .profiles = NULL_IF_CONFIG_SMALL(profiles)