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
50 typedef struct Jpeg2000TilePart {
51 uint8_t tile_index; // Tile index who refers the tile-part
52 const uint8_t *tp_end;
53 GetByteContext tpg; // bit stream in tile-part
56 /* RMK: For JPEG2000 DCINEMA 3 tile-parts in a tile
57 * one per component, so tile_part elements have a size of 3 */
58 typedef struct Jpeg2000Tile {
59 Jpeg2000Component *comp;
60 uint8_t properties[4];
61 Jpeg2000CodingStyle codsty[4];
62 Jpeg2000QuantStyle qntsty[4];
63 Jpeg2000TilePart tile_part[256];
64 uint16_t tp_idx; // Tile-part index
67 typedef struct Jpeg2000DecoderContext {
69 AVCodecContext *avctx;
73 int image_offset_x, image_offset_y;
74 int tile_offset_x, tile_offset_y;
75 uint8_t cbps[4]; // bits per sample in particular components
76 uint8_t sgnd[4]; // if a component is signed
77 uint8_t properties[4];
82 uint32_t palette[256];
85 int tile_width, tile_height;
86 unsigned numXtiles, numYtiles;
89 Jpeg2000CodingStyle codsty[4];
90 Jpeg2000QuantStyle qntsty[4];
97 Jpeg2000DSPContext dsp;
99 /*options parameters*/
100 int reduction_factor;
101 } Jpeg2000DecoderContext;
103 /* get_bits functions for JPEG2000 packet bitstream
104 * It is a get_bit function with a bit-stuffing routine. If the value of the
105 * byte is 0xFF, the next byte includes an extra zero bit stuffed into the MSB.
106 * cf. ISO-15444-1:2002 / B.10.1 Bit-stuffing routine */
107 static int get_bits(Jpeg2000DecoderContext *s, int n)
113 if (s->bit_index == 0) {
114 s->bit_index = 7 + (bytestream2_get_byte(&s->g) != 0xFFu);
117 res |= (bytestream2_peek_byte(&s->g) >> s->bit_index) & 1;
122 static void jpeg2000_flush(Jpeg2000DecoderContext *s)
124 if (bytestream2_get_byte(&s->g) == 0xff)
125 bytestream2_skip(&s->g, 1);
129 /* decode the value stored in node */
130 static int tag_tree_decode(Jpeg2000DecoderContext *s, Jpeg2000TgtNode *node,
133 Jpeg2000TgtNode *stack[30];
134 int sp = -1, curval = 0;
137 av_log(s->avctx, AV_LOG_ERROR, "missing node\n");
138 return AVERROR_INVALIDDATA;
141 while (node && !node->vis) {
149 curval = stack[sp]->val;
151 while (curval < threshold && sp >= 0) {
152 if (curval < stack[sp]->val)
153 curval = stack[sp]->val;
154 while (curval < threshold) {
156 if ((ret = get_bits(s, 1)) > 0) {
164 stack[sp]->val = curval;
170 static int pix_fmt_match(enum AVPixelFormat pix_fmt, int components,
171 int bpc, uint32_t log2_chroma_wh, int pal8)
174 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
178 if (desc->nb_components != components) {
182 switch (components) {
184 match = match && desc->comp[3].depth_minus1 + 1 >= bpc &&
185 (log2_chroma_wh >> 14 & 3) == 0 &&
186 (log2_chroma_wh >> 12 & 3) == 0;
188 match = match && desc->comp[2].depth_minus1 + 1 >= bpc &&
189 (log2_chroma_wh >> 10 & 3) == desc->log2_chroma_w &&
190 (log2_chroma_wh >> 8 & 3) == desc->log2_chroma_h;
192 match = match && desc->comp[1].depth_minus1 + 1 >= bpc &&
193 (log2_chroma_wh >> 6 & 3) == desc->log2_chroma_w &&
194 (log2_chroma_wh >> 4 & 3) == desc->log2_chroma_h;
197 match = match && desc->comp[0].depth_minus1 + 1 >= bpc &&
198 (log2_chroma_wh >> 2 & 3) == 0 &&
199 (log2_chroma_wh & 3) == 0 &&
200 (desc->flags & AV_PIX_FMT_FLAG_PAL) == pal8 * AV_PIX_FMT_FLAG_PAL;
205 // pix_fmts with lower bpp have to be listed before
206 // similar pix_fmts with higher bpp.
207 #define RGB_PIXEL_FORMATS AV_PIX_FMT_PAL8,AV_PIX_FMT_RGB24,AV_PIX_FMT_RGBA,AV_PIX_FMT_RGB48,AV_PIX_FMT_RGBA64
208 #define GRAY_PIXEL_FORMATS AV_PIX_FMT_GRAY8,AV_PIX_FMT_GRAY8A,AV_PIX_FMT_GRAY16,AV_PIX_FMT_YA16
209 #define YUV_PIXEL_FORMATS AV_PIX_FMT_YUV410P,AV_PIX_FMT_YUV411P,AV_PIX_FMT_YUVA420P, \
210 AV_PIX_FMT_YUV420P,AV_PIX_FMT_YUV422P,AV_PIX_FMT_YUVA422P, \
211 AV_PIX_FMT_YUV440P,AV_PIX_FMT_YUV444P,AV_PIX_FMT_YUVA444P, \
212 AV_PIX_FMT_YUV420P9,AV_PIX_FMT_YUV422P9,AV_PIX_FMT_YUV444P9, \
213 AV_PIX_FMT_YUVA420P9,AV_PIX_FMT_YUVA422P9,AV_PIX_FMT_YUVA444P9, \
214 AV_PIX_FMT_YUV420P10,AV_PIX_FMT_YUV422P10,AV_PIX_FMT_YUV444P10, \
215 AV_PIX_FMT_YUVA420P10,AV_PIX_FMT_YUVA422P10,AV_PIX_FMT_YUVA444P10, \
216 AV_PIX_FMT_YUV420P12,AV_PIX_FMT_YUV422P12,AV_PIX_FMT_YUV444P12, \
217 AV_PIX_FMT_YUV420P14,AV_PIX_FMT_YUV422P14,AV_PIX_FMT_YUV444P14, \
218 AV_PIX_FMT_YUV420P16,AV_PIX_FMT_YUV422P16,AV_PIX_FMT_YUV444P16, \
219 AV_PIX_FMT_YUVA420P16,AV_PIX_FMT_YUVA422P16,AV_PIX_FMT_YUVA444P16
220 #define XYZ_PIXEL_FORMATS AV_PIX_FMT_XYZ12
222 static const enum AVPixelFormat rgb_pix_fmts[] = {RGB_PIXEL_FORMATS};
223 static const enum AVPixelFormat gray_pix_fmts[] = {GRAY_PIXEL_FORMATS};
224 static const enum AVPixelFormat yuv_pix_fmts[] = {YUV_PIXEL_FORMATS};
225 static const enum AVPixelFormat xyz_pix_fmts[] = {XYZ_PIXEL_FORMATS,
227 static const enum AVPixelFormat all_pix_fmts[] = {RGB_PIXEL_FORMATS,
232 /* marker segments */
233 /* get sizes and offsets of image, tiles; number of components */
234 static int get_siz(Jpeg2000DecoderContext *s)
238 uint32_t log2_chroma_wh = 0;
239 const enum AVPixelFormat *possible_fmts = NULL;
240 int possible_fmts_nb = 0;
242 if (bytestream2_get_bytes_left(&s->g) < 36) {
243 av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for SIZ\n");
244 return AVERROR_INVALIDDATA;
247 s->avctx->profile = bytestream2_get_be16u(&s->g); // Rsiz
248 s->width = bytestream2_get_be32u(&s->g); // Width
249 s->height = bytestream2_get_be32u(&s->g); // Height
250 s->image_offset_x = bytestream2_get_be32u(&s->g); // X0Siz
251 s->image_offset_y = bytestream2_get_be32u(&s->g); // Y0Siz
252 s->tile_width = bytestream2_get_be32u(&s->g); // XTSiz
253 s->tile_height = bytestream2_get_be32u(&s->g); // YTSiz
254 s->tile_offset_x = bytestream2_get_be32u(&s->g); // XT0Siz
255 s->tile_offset_y = bytestream2_get_be32u(&s->g); // YT0Siz
256 ncomponents = bytestream2_get_be16u(&s->g); // CSiz
258 if (s->image_offset_x || s->image_offset_y) {
259 avpriv_request_sample(s->avctx, "Support for image offsets");
260 return AVERROR_PATCHWELCOME;
263 if (ncomponents <= 0) {
264 av_log(s->avctx, AV_LOG_ERROR, "Invalid number of components: %d\n",
266 return AVERROR_INVALIDDATA;
269 if (ncomponents > 4) {
270 avpriv_request_sample(s->avctx, "Support for %d components",
272 return AVERROR_PATCHWELCOME;
275 s->ncomponents = ncomponents;
277 if (s->tile_width <= 0 || s->tile_height <= 0) {
278 av_log(s->avctx, AV_LOG_ERROR, "Invalid tile dimension %dx%d.\n",
279 s->tile_width, s->tile_height);
280 return AVERROR_INVALIDDATA;
283 if (bytestream2_get_bytes_left(&s->g) < 3 * s->ncomponents) {
284 av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for %d components in SIZ\n", s->ncomponents);
285 return AVERROR_INVALIDDATA;
288 for (i = 0; i < s->ncomponents; i++) { // Ssiz_i XRsiz_i, YRsiz_i
289 uint8_t x = bytestream2_get_byteu(&s->g);
290 s->cbps[i] = (x & 0x7f) + 1;
291 s->precision = FFMAX(s->cbps[i], s->precision);
292 s->sgnd[i] = !!(x & 0x80);
293 s->cdx[i] = bytestream2_get_byteu(&s->g);
294 s->cdy[i] = bytestream2_get_byteu(&s->g);
295 if ( !s->cdx[i] || s->cdx[i] == 3 || s->cdx[i] > 4
296 || !s->cdy[i] || s->cdy[i] == 3 || s->cdy[i] > 4) {
297 av_log(s->avctx, AV_LOG_ERROR, "Invalid sample separation %d/%d\n", s->cdx[i], s->cdy[i]);
298 return AVERROR_INVALIDDATA;
300 log2_chroma_wh |= s->cdy[i] >> 1 << i * 4 | s->cdx[i] >> 1 << i * 4 + 2;
303 s->numXtiles = ff_jpeg2000_ceildiv(s->width - s->tile_offset_x, s->tile_width);
304 s->numYtiles = ff_jpeg2000_ceildiv(s->height - s->tile_offset_y, s->tile_height);
306 if (s->numXtiles * (uint64_t)s->numYtiles > INT_MAX/sizeof(*s->tile)) {
307 s->numXtiles = s->numYtiles = 0;
308 return AVERROR(EINVAL);
311 s->tile = av_mallocz_array(s->numXtiles * s->numYtiles, sizeof(*s->tile));
313 s->numXtiles = s->numYtiles = 0;
314 return AVERROR(ENOMEM);
317 for (i = 0; i < s->numXtiles * s->numYtiles; i++) {
318 Jpeg2000Tile *tile = s->tile + i;
320 tile->comp = av_mallocz(s->ncomponents * sizeof(*tile->comp));
322 return AVERROR(ENOMEM);
325 /* compute image size with reduction factor */
326 s->avctx->width = ff_jpeg2000_ceildivpow2(s->width - s->image_offset_x,
327 s->reduction_factor);
328 s->avctx->height = ff_jpeg2000_ceildivpow2(s->height - s->image_offset_y,
329 s->reduction_factor);
331 if (s->avctx->profile == FF_PROFILE_JPEG2000_DCINEMA_2K ||
332 s->avctx->profile == FF_PROFILE_JPEG2000_DCINEMA_4K) {
333 possible_fmts = xyz_pix_fmts;
334 possible_fmts_nb = FF_ARRAY_ELEMS(xyz_pix_fmts);
336 switch (s->colour_space) {
338 possible_fmts = rgb_pix_fmts;
339 possible_fmts_nb = FF_ARRAY_ELEMS(rgb_pix_fmts);
342 possible_fmts = gray_pix_fmts;
343 possible_fmts_nb = FF_ARRAY_ELEMS(gray_pix_fmts);
346 possible_fmts = yuv_pix_fmts;
347 possible_fmts_nb = FF_ARRAY_ELEMS(yuv_pix_fmts);
350 possible_fmts = all_pix_fmts;
351 possible_fmts_nb = FF_ARRAY_ELEMS(all_pix_fmts);
355 for (i = 0; i < possible_fmts_nb; ++i) {
356 if (pix_fmt_match(possible_fmts[i], ncomponents, s->precision, log2_chroma_wh, s->pal8)) {
357 s->avctx->pix_fmt = possible_fmts[i];
362 if (i == possible_fmts_nb) {
363 if (ncomponents == 4 &&
364 s->cdy[0] == 1 && s->cdx[0] == 1 &&
365 s->cdy[1] == 1 && s->cdx[1] == 1 &&
366 s->cdy[2] == s->cdy[3] && s->cdx[2] == s->cdx[3]) {
367 if (s->precision == 8 && s->cdy[2] == 2 && s->cdx[2] == 2 && !s->pal8) {
368 s->avctx->pix_fmt = AV_PIX_FMT_YUVA420P;
379 if (i == possible_fmts_nb) {
380 av_log(s->avctx, AV_LOG_ERROR,
381 "Unknown pix_fmt, profile: %d, colour_space: %d, "
382 "components: %d, precision: %d\n"
383 "cdx[0]: %d, cdy[0]: %d\n"
384 "cdx[1]: %d, cdy[1]: %d\n"
385 "cdx[2]: %d, cdy[2]: %d\n"
386 "cdx[3]: %d, cdy[3]: %d\n",
387 s->avctx->profile, s->colour_space, ncomponents, s->precision,
390 ncomponents > 1 ? s->cdx[1] : 0,
391 ncomponents > 1 ? s->cdy[1] : 0,
392 ncomponents > 2 ? s->cdx[2] : 0,
393 ncomponents > 2 ? s->cdy[2] : 0,
394 ncomponents > 3 ? s->cdx[3] : 0,
395 ncomponents > 3 ? s->cdy[3] : 0);
396 return AVERROR_PATCHWELCOME;
398 s->avctx->bits_per_raw_sample = s->precision;
402 /* get common part for COD and COC segments */
403 static int get_cox(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c)
407 if (bytestream2_get_bytes_left(&s->g) < 5) {
408 av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for COX\n");
409 return AVERROR_INVALIDDATA;
412 /* nreslevels = number of resolution levels
413 = number of decomposition level +1 */
414 c->nreslevels = bytestream2_get_byteu(&s->g) + 1;
415 if (c->nreslevels >= JPEG2000_MAX_RESLEVELS) {
416 av_log(s->avctx, AV_LOG_ERROR, "nreslevels %d is invalid\n", c->nreslevels);
417 return AVERROR_INVALIDDATA;
420 if (c->nreslevels <= s->reduction_factor) {
421 /* we are forced to update reduction_factor as its requested value is
422 not compatible with this bitstream, and as we might have used it
423 already in setup earlier we have to fail this frame until
424 reinitialization is implemented */
425 av_log(s->avctx, AV_LOG_ERROR, "reduction_factor too large for this bitstream, max is %d\n", c->nreslevels - 1);
426 s->reduction_factor = c->nreslevels - 1;
427 return AVERROR(EINVAL);
430 /* compute number of resolution levels to decode */
431 c->nreslevels2decode = c->nreslevels - s->reduction_factor;
433 c->log2_cblk_width = (bytestream2_get_byteu(&s->g) & 15) + 2; // cblk width
434 c->log2_cblk_height = (bytestream2_get_byteu(&s->g) & 15) + 2; // cblk height
436 if (c->log2_cblk_width > 10 || c->log2_cblk_height > 10 ||
437 c->log2_cblk_width + c->log2_cblk_height > 12) {
438 av_log(s->avctx, AV_LOG_ERROR, "cblk size invalid\n");
439 return AVERROR_INVALIDDATA;
442 if (c->log2_cblk_width > 7 || c->log2_cblk_height > 7) {
443 avpriv_request_sample(s->avctx, "cblk size > 128");
444 return AVERROR_PATCHWELCOME;
447 c->cblk_style = bytestream2_get_byteu(&s->g);
448 if (c->cblk_style != 0) { // cblk style
449 av_log(s->avctx, AV_LOG_WARNING, "extra cblk styles %X\n", c->cblk_style);
450 if (c->cblk_style & JPEG2000_CBLK_BYPASS)
451 av_log(s->avctx, AV_LOG_WARNING, "Selective arithmetic coding bypass\n");
453 c->transform = bytestream2_get_byteu(&s->g); // DWT transformation type
454 /* set integer 9/7 DWT in case of BITEXACT flag */
455 if ((s->avctx->flags & CODEC_FLAG_BITEXACT) && (c->transform == FF_DWT97))
456 c->transform = FF_DWT97_INT;
458 if (c->csty & JPEG2000_CSTY_PREC) {
460 for (i = 0; i < c->nreslevels; i++) {
461 byte = bytestream2_get_byte(&s->g);
462 c->log2_prec_widths[i] = byte & 0x0F; // precinct PPx
463 c->log2_prec_heights[i] = (byte >> 4) & 0x0F; // precinct PPy
466 memset(c->log2_prec_widths , 15, sizeof(c->log2_prec_widths ));
467 memset(c->log2_prec_heights, 15, sizeof(c->log2_prec_heights));
472 /* get coding parameters for a particular tile or whole image*/
473 static int get_cod(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c,
476 Jpeg2000CodingStyle tmp;
479 if (bytestream2_get_bytes_left(&s->g) < 5) {
480 av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for COD\n");
481 return AVERROR_INVALIDDATA;
484 tmp.csty = bytestream2_get_byteu(&s->g);
486 // get progression order
487 tmp.prog_order = bytestream2_get_byteu(&s->g);
489 tmp.nlayers = bytestream2_get_be16u(&s->g);
490 tmp.mct = bytestream2_get_byteu(&s->g); // multiple component transformation
492 if (tmp.mct && s->ncomponents < 3) {
493 av_log(s->avctx, AV_LOG_ERROR,
494 "MCT %"PRIu8" with too few components (%d)\n",
495 tmp.mct, s->ncomponents);
496 return AVERROR_INVALIDDATA;
499 if ((ret = get_cox(s, &tmp)) < 0)
502 for (compno = 0; compno < s->ncomponents; compno++)
503 if (!(properties[compno] & HAD_COC))
504 memcpy(c + compno, &tmp, sizeof(tmp));
508 /* Get coding parameters for a component in the whole image or a
509 * particular tile. */
510 static int get_coc(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c,
515 if (bytestream2_get_bytes_left(&s->g) < 2) {
516 av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for COC\n");
517 return AVERROR_INVALIDDATA;
520 compno = bytestream2_get_byteu(&s->g);
522 if (compno >= s->ncomponents) {
523 av_log(s->avctx, AV_LOG_ERROR,
524 "Invalid compno %d. There are %d components in the image.\n",
525 compno, s->ncomponents);
526 return AVERROR_INVALIDDATA;
530 c->csty = bytestream2_get_byteu(&s->g);
532 if ((ret = get_cox(s, c)) < 0)
535 properties[compno] |= HAD_COC;
539 /* Get common part for QCD and QCC segments. */
540 static int get_qcx(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q)
544 if (bytestream2_get_bytes_left(&s->g) < 1)
545 return AVERROR_INVALIDDATA;
547 x = bytestream2_get_byteu(&s->g); // Sqcd
549 q->nguardbits = x >> 5;
550 q->quantsty = x & 0x1f;
552 if (q->quantsty == JPEG2000_QSTY_NONE) {
554 if (bytestream2_get_bytes_left(&s->g) < n ||
555 n > JPEG2000_MAX_DECLEVELS*3)
556 return AVERROR_INVALIDDATA;
557 for (i = 0; i < n; i++)
558 q->expn[i] = bytestream2_get_byteu(&s->g) >> 3;
559 } else if (q->quantsty == JPEG2000_QSTY_SI) {
560 if (bytestream2_get_bytes_left(&s->g) < 2)
561 return AVERROR_INVALIDDATA;
562 x = bytestream2_get_be16u(&s->g);
563 q->expn[0] = x >> 11;
564 q->mant[0] = x & 0x7ff;
565 for (i = 1; i < JPEG2000_MAX_DECLEVELS * 3; i++) {
566 int curexpn = FFMAX(0, q->expn[0] - (i - 1) / 3);
567 q->expn[i] = curexpn;
568 q->mant[i] = q->mant[0];
572 if (bytestream2_get_bytes_left(&s->g) < 2 * n ||
573 n > JPEG2000_MAX_DECLEVELS*3)
574 return AVERROR_INVALIDDATA;
575 for (i = 0; i < n; i++) {
576 x = bytestream2_get_be16u(&s->g);
577 q->expn[i] = x >> 11;
578 q->mant[i] = x & 0x7ff;
584 /* Get quantization parameters for a particular tile or a whole image. */
585 static int get_qcd(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q,
588 Jpeg2000QuantStyle tmp;
591 memset(&tmp, 0, sizeof(tmp));
593 if ((ret = get_qcx(s, n, &tmp)) < 0)
595 for (compno = 0; compno < s->ncomponents; compno++)
596 if (!(properties[compno] & HAD_QCC))
597 memcpy(q + compno, &tmp, sizeof(tmp));
601 /* Get quantization parameters for a component in the whole image
602 * on in a particular tile. */
603 static int get_qcc(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q,
608 if (bytestream2_get_bytes_left(&s->g) < 1)
609 return AVERROR_INVALIDDATA;
611 compno = bytestream2_get_byteu(&s->g);
613 if (compno >= s->ncomponents) {
614 av_log(s->avctx, AV_LOG_ERROR,
615 "Invalid compno %d. There are %d components in the image.\n",
616 compno, s->ncomponents);
617 return AVERROR_INVALIDDATA;
620 properties[compno] |= HAD_QCC;
621 return get_qcx(s, n - 1, q + compno);
624 /* Get start of tile segment. */
625 static int get_sot(Jpeg2000DecoderContext *s, int n)
627 Jpeg2000TilePart *tp;
632 if (bytestream2_get_bytes_left(&s->g) < 8)
633 return AVERROR_INVALIDDATA;
636 Isot = bytestream2_get_be16u(&s->g); // Isot
637 if (Isot >= s->numXtiles * s->numYtiles)
638 return AVERROR_INVALIDDATA;
641 Psot = bytestream2_get_be32u(&s->g); // Psot
642 TPsot = bytestream2_get_byteu(&s->g); // TPsot
644 /* Read TNSot but not used */
645 bytestream2_get_byteu(&s->g); // TNsot
648 Psot = bytestream2_get_bytes_left(&s->g) + n + 2;
650 if (Psot > bytestream2_get_bytes_left(&s->g) + n + 2) {
651 av_log(s->avctx, AV_LOG_ERROR, "Psot %"PRIu32" too big\n", Psot);
652 return AVERROR_INVALIDDATA;
655 av_assert0(TPsot < FF_ARRAY_ELEMS(s->tile[Isot].tile_part));
657 s->tile[Isot].tp_idx = TPsot;
658 tp = s->tile[Isot].tile_part + TPsot;
659 tp->tile_index = Isot;
660 tp->tp_end = s->g.buffer + Psot - n - 2;
663 Jpeg2000Tile *tile = s->tile + s->curtileno;
666 memcpy(tile->codsty, s->codsty, s->ncomponents * sizeof(Jpeg2000CodingStyle));
667 memcpy(tile->qntsty, s->qntsty, s->ncomponents * sizeof(Jpeg2000QuantStyle));
673 /* Tile-part lengths: see ISO 15444-1:2002, section A.7.1
674 * Used to know the number of tile parts and lengths.
675 * There may be multiple TLMs in the header.
676 * TODO: The function is not used for tile-parts management, nor anywhere else.
677 * It can be useful to allocate memory for tile parts, before managing the SOT
678 * markers. Parsing the TLM header is needed to increment the input header
680 * This marker is mandatory for DCI. */
681 static uint8_t get_tlm(Jpeg2000DecoderContext *s, int n)
683 uint8_t Stlm, ST, SP, tile_tlm, i;
684 bytestream2_get_byte(&s->g); /* Ztlm: skipped */
685 Stlm = bytestream2_get_byte(&s->g);
687 // too complex ? ST = ((Stlm >> 4) & 0x01) + ((Stlm >> 4) & 0x02);
688 ST = (Stlm >> 4) & 0x03;
689 // TODO: Manage case of ST = 0b11 --> raise error
690 SP = (Stlm >> 6) & 0x01;
691 tile_tlm = (n - 4) / ((SP + 1) * 2 + ST);
692 for (i = 0; i < tile_tlm; i++) {
697 bytestream2_get_byte(&s->g);
700 bytestream2_get_be16(&s->g);
703 bytestream2_get_be32(&s->g);
707 bytestream2_get_be16(&s->g);
709 bytestream2_get_be32(&s->g);
715 static uint8_t get_plt(Jpeg2000DecoderContext *s, int n)
719 av_log(s->avctx, AV_LOG_DEBUG,
720 "PLT marker at pos 0x%X\n", bytestream2_tell(&s->g) - 4);
722 /*Zplt =*/ bytestream2_get_byte(&s->g);
724 for (i = 0; i < n - 3; i++) {
725 bytestream2_get_byte(&s->g);
731 static int init_tile(Jpeg2000DecoderContext *s, int tileno)
734 int tilex = tileno % s->numXtiles;
735 int tiley = tileno / s->numXtiles;
736 Jpeg2000Tile *tile = s->tile + tileno;
739 return AVERROR(ENOMEM);
741 for (compno = 0; compno < s->ncomponents; compno++) {
742 Jpeg2000Component *comp = tile->comp + compno;
743 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
744 Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
745 int ret; // global bandno
747 comp->coord_o[0][0] = FFMAX(tilex * s->tile_width + s->tile_offset_x, s->image_offset_x);
748 comp->coord_o[0][1] = FFMIN((tilex + 1) * s->tile_width + s->tile_offset_x, s->width);
749 comp->coord_o[1][0] = FFMAX(tiley * s->tile_height + s->tile_offset_y, s->image_offset_y);
750 comp->coord_o[1][1] = FFMIN((tiley + 1) * s->tile_height + s->tile_offset_y, s->height);
752 comp->coord_o[0][0] /= s->cdx[compno];
753 comp->coord_o[0][1] /= s->cdx[compno];
754 comp->coord_o[1][0] /= s->cdy[compno];
755 comp->coord_o[1][1] /= s->cdy[compno];
758 comp->coord[0][0] = ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], s->reduction_factor);
759 comp->coord[0][1] = ff_jpeg2000_ceildivpow2(comp->coord_o[0][1], s->reduction_factor);
760 comp->coord[1][0] = ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], s->reduction_factor);
761 comp->coord[1][1] = ff_jpeg2000_ceildivpow2(comp->coord_o[1][1], s->reduction_factor);
763 if (ret = ff_jpeg2000_init_component(comp, codsty, qntsty,
764 s->cbps[compno], s->cdx[compno],
765 s->cdy[compno], s->avctx))
771 /* Read the number of coding passes. */
772 static int getnpasses(Jpeg2000DecoderContext *s)
779 if ((num = get_bits(s, 2)) != 3)
780 return num < 0 ? num : 3 + num;
781 if ((num = get_bits(s, 5)) != 31)
782 return num < 0 ? num : 6 + num;
783 num = get_bits(s, 7);
784 return num < 0 ? num : 37 + num;
787 static int getlblockinc(Jpeg2000DecoderContext *s)
790 while (ret = get_bits(s, 1)) {
798 static int jpeg2000_decode_packet(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile, int *tp_index,
799 Jpeg2000CodingStyle *codsty,
800 Jpeg2000ResLevel *rlevel, int precno,
801 int layno, uint8_t *expn, int numgbits)
803 int bandno, cblkno, ret, nb_code_blocks;
806 if (bytestream2_get_bytes_left(&s->g) == 0 && s->bit_index == 8) {
807 if (*tp_index < FF_ARRAY_ELEMS(tile->tile_part) - 1) {
808 s->g = tile->tile_part[++(*tp_index)].tpg;
812 if (bytestream2_peek_be32(&s->g) == JPEG2000_SOP_FIXED_BYTES)
813 bytestream2_skip(&s->g, JPEG2000_SOP_BYTE_LENGTH);
815 if (!(ret = get_bits(s, 1))) {
821 for (bandno = 0; bandno < rlevel->nbands; bandno++) {
822 Jpeg2000Band *band = rlevel->band + bandno;
823 Jpeg2000Prec *prec = band->prec + precno;
825 if (band->coord[0][0] == band->coord[0][1] ||
826 band->coord[1][0] == band->coord[1][1])
828 nb_code_blocks = prec->nb_codeblocks_height *
829 prec->nb_codeblocks_width;
830 for (cblkno = 0; cblkno < nb_code_blocks; cblkno++) {
831 Jpeg2000Cblk *cblk = prec->cblk + cblkno;
832 int incl, newpasses, llen;
835 incl = get_bits(s, 1);
837 incl = tag_tree_decode(s, prec->cblkincl + cblkno, layno + 1) == layno;
843 if (!cblk->npasses) {
844 int v = expn[bandno] + numgbits - 1 -
845 tag_tree_decode(s, prec->zerobits + cblkno, 100);
847 av_log(s->avctx, AV_LOG_ERROR,
848 "nonzerobits %d invalid\n", v);
849 return AVERROR_INVALIDDATA;
851 cblk->nonzerobits = v;
853 if ((newpasses = getnpasses(s)) < 0)
855 av_assert2(newpasses > 0);
856 if (cblk->npasses + newpasses >= JPEG2000_MAX_PASSES) {
857 avpriv_request_sample(s->avctx, "Too many passes\n");
858 return AVERROR_PATCHWELCOME;
860 if ((llen = getlblockinc(s)) < 0)
862 if (cblk->lblock + llen + av_log2(newpasses) > 16) {
863 avpriv_request_sample(s->avctx,
864 "Block with length beyond 16 bits\n");
865 return AVERROR_PATCHWELCOME;
868 cblk->lblock += llen;
870 cblk->nb_lengthinc = 0;
871 cblk->nb_terminationsinc = 0;
875 while (newpasses1 < newpasses) {
877 if (needs_termination(codsty->cblk_style, cblk->npasses + newpasses1 - 1)) {
878 cblk->nb_terminationsinc ++;
883 if ((ret = get_bits(s, av_log2(newpasses1) + cblk->lblock)) < 0)
885 if (ret > sizeof(cblk->data)) {
886 avpriv_request_sample(s->avctx,
887 "Block with lengthinc greater than %"SIZE_SPECIFIER"",
889 return AVERROR_PATCHWELCOME;
891 cblk->lengthinc[cblk->nb_lengthinc++] = ret;
892 cblk->npasses += newpasses1;
893 newpasses -= newpasses1;
899 if (codsty->csty & JPEG2000_CSTY_EPH) {
900 if (bytestream2_peek_be16(&s->g) == JPEG2000_EPH)
901 bytestream2_skip(&s->g, 2);
903 av_log(s->avctx, AV_LOG_ERROR, "EPH marker not found.\n");
906 for (bandno = 0; bandno < rlevel->nbands; bandno++) {
907 Jpeg2000Band *band = rlevel->band + bandno;
908 Jpeg2000Prec *prec = band->prec + precno;
910 nb_code_blocks = prec->nb_codeblocks_height * prec->nb_codeblocks_width;
911 for (cblkno = 0; cblkno < nb_code_blocks; cblkno++) {
912 Jpeg2000Cblk *cblk = prec->cblk + cblkno;
913 for (cwsno = 0; cwsno < cblk->nb_lengthinc; cwsno ++) {
914 if ( bytestream2_get_bytes_left(&s->g) < cblk->lengthinc[cwsno]
915 || sizeof(cblk->data) < cblk->length + cblk->lengthinc[cwsno] + 4
917 av_log(s->avctx, AV_LOG_ERROR,
918 "Block length %"PRIu16" or lengthinc %d is too large, left %d\n",
919 cblk->length, cblk->lengthinc[cwsno], bytestream2_get_bytes_left(&s->g));
920 return AVERROR_INVALIDDATA;
923 bytestream2_get_bufferu(&s->g, cblk->data + cblk->length, cblk->lengthinc[cwsno]);
924 cblk->length += cblk->lengthinc[cwsno];
925 cblk->lengthinc[cwsno] = 0;
926 if (cblk->nb_terminationsinc) {
927 cblk->nb_terminationsinc--;
928 cblk->nb_terminations++;
929 cblk->data[cblk->length++] = 0xFF;
930 cblk->data[cblk->length++] = 0xFF;
931 cblk->data_start[cblk->nb_terminations] = cblk->length;
939 static int jpeg2000_decode_packets(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
942 int layno, reslevelno, compno, precno, ok_reslevel;
948 switch (tile->codsty[0].prog_order) {
949 case JPEG2000_PGOD_RLCP:
950 av_log(s->avctx, AV_LOG_DEBUG, "Progression order RLCP\n");
952 for (reslevelno = 0; ok_reslevel; reslevelno++) {
954 for (layno = 0; layno < tile->codsty[0].nlayers; layno++) {
955 for (compno = 0; compno < s->ncomponents; compno++) {
956 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
957 Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
958 if (reslevelno < codsty->nreslevels) {
959 Jpeg2000ResLevel *rlevel = tile->comp[compno].reslevel +
962 for (precno = 0; precno < rlevel->num_precincts_x * rlevel->num_precincts_y; precno++)
963 if ((ret = jpeg2000_decode_packet(s, tile, &tp_index,
966 qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
967 qntsty->nguardbits)) < 0)
975 case JPEG2000_PGOD_LRCP:
976 av_log(s->avctx, AV_LOG_DEBUG, "Progression order LRCP\n");
977 for (layno = 0; layno < tile->codsty[0].nlayers; layno++) {
979 for (reslevelno = 0; ok_reslevel; reslevelno++) {
981 for (compno = 0; compno < s->ncomponents; compno++) {
982 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
983 Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
984 if (reslevelno < codsty->nreslevels) {
985 Jpeg2000ResLevel *rlevel = tile->comp[compno].reslevel +
988 for (precno = 0; precno < rlevel->num_precincts_x * rlevel->num_precincts_y; precno++)
989 if ((ret = jpeg2000_decode_packet(s, tile, &tp_index,
992 qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
993 qntsty->nguardbits)) < 0)
1001 case JPEG2000_PGOD_CPRL:
1002 av_log(s->avctx, AV_LOG_DEBUG, "Progression order CPRL\n");
1003 for (compno = 0; compno < s->ncomponents; compno++) {
1004 Jpeg2000Component *comp = tile->comp + compno;
1005 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1006 Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
1007 int maxlogstep_x = 0;
1008 int maxlogstep_y = 0;
1009 int start_x, start_y;
1013 for (reslevelno = 0; reslevelno < codsty->nreslevels; reslevelno++) {
1014 uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1015 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1016 step_x = FFMIN(step_x, rlevel->log2_prec_width + reducedresno);
1017 step_y = FFMIN(step_y, rlevel->log2_prec_height + reducedresno);
1018 maxlogstep_x = FFMAX(maxlogstep_x, rlevel->log2_prec_width + reducedresno);
1019 maxlogstep_y = FFMAX(maxlogstep_y, rlevel->log2_prec_height + reducedresno);
1024 start_y = comp->coord_o[1][0] >> maxlogstep_y << maxlogstep_y;
1025 start_x = comp->coord_o[0][0] >> maxlogstep_x << maxlogstep_x;
1026 for (y = start_y; y < comp->coord_o[1][1]; y += step_y) {
1027 for (x = start_x; x < comp->coord_o[0][1]; x += step_x) {
1028 for (reslevelno = 0; reslevelno < codsty->nreslevels; reslevelno++) {
1029 unsigned prcx, prcy;
1030 uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1031 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1033 if (y % (1 << (rlevel->log2_prec_height + reducedresno)))
1036 if (x % (1 << (rlevel->log2_prec_width + reducedresno)))
1039 // check if a precinct exists
1040 prcx = ff_jpeg2000_ceildivpow2(x, reducedresno) >> rlevel->log2_prec_width;
1041 prcy = ff_jpeg2000_ceildivpow2(y, reducedresno) >> rlevel->log2_prec_height;
1042 prcx -= ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], reducedresno) >> rlevel->log2_prec_width;
1043 prcy -= ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], reducedresno) >> rlevel->log2_prec_height;
1045 precno = prcx + rlevel->num_precincts_x * prcy;
1047 if (prcx >= rlevel->num_precincts_x || prcy >= rlevel->num_precincts_y) {
1048 av_log(s->avctx, AV_LOG_WARNING, "prc %d %d outside limits %d %d\n",
1049 prcx, prcy, rlevel->num_precincts_x, rlevel->num_precincts_y);
1053 for (layno = 0; layno < tile->codsty[0].nlayers; layno++) {
1054 if ((ret = jpeg2000_decode_packet(s, tile, &tp_index, codsty, rlevel,
1056 qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1057 qntsty->nguardbits)) < 0)
1066 case JPEG2000_PGOD_RPCL:
1067 av_log(s->avctx, AV_LOG_WARNING, "Progression order RPCL\n");
1069 for (reslevelno = 0; ok_reslevel; reslevelno++) {
1074 for (compno = 0; compno < s->ncomponents; compno++) {
1075 Jpeg2000Component *comp = tile->comp + compno;
1076 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1078 if (reslevelno < codsty->nreslevels) {
1079 uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1080 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1081 step_x = FFMIN(step_x, rlevel->log2_prec_width + reducedresno);
1082 step_y = FFMIN(step_y, rlevel->log2_prec_height + reducedresno);
1088 //FIXME we could iterate over less than the whole image
1089 for (y = 0; y < s->height; y += step_y) {
1090 for (x = 0; x < s->width; x += step_x) {
1091 for (compno = 0; compno < s->ncomponents; compno++) {
1092 Jpeg2000Component *comp = tile->comp + compno;
1093 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1094 Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
1095 uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1096 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1097 unsigned prcx, prcy;
1099 int xc = x / s->cdx[compno];
1100 int yc = y / s->cdy[compno];
1102 if (reslevelno >= codsty->nreslevels)
1105 if (yc % (1 << (rlevel->log2_prec_height + reducedresno)))
1108 if (xc % (1 << (rlevel->log2_prec_width + reducedresno)))
1111 // check if a precinct exists
1112 prcx = ff_jpeg2000_ceildivpow2(xc, reducedresno) >> rlevel->log2_prec_width;
1113 prcy = ff_jpeg2000_ceildivpow2(yc, reducedresno) >> rlevel->log2_prec_height;
1114 prcx -= ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], reducedresno) >> rlevel->log2_prec_width;
1115 prcy -= ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], reducedresno) >> rlevel->log2_prec_height;
1117 precno = prcx + rlevel->num_precincts_x * prcy;
1120 if (prcx >= rlevel->num_precincts_x || prcy >= rlevel->num_precincts_y) {
1121 av_log(s->avctx, AV_LOG_WARNING, "prc %d %d outside limits %d %d\n",
1122 prcx, prcy, rlevel->num_precincts_x, rlevel->num_precincts_y);
1126 for (layno = 0; layno < tile->codsty[0].nlayers; layno++) {
1127 if ((ret = jpeg2000_decode_packet(s, tile, &tp_index,
1130 qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1131 qntsty->nguardbits)) < 0)
1140 case JPEG2000_PGOD_PCRL:
1141 av_log(s->avctx, AV_LOG_WARNING, "Progression order PCRL");
1144 for (compno = 0; compno < s->ncomponents; compno++) {
1145 Jpeg2000Component *comp = tile->comp + compno;
1146 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1147 Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
1149 for (reslevelno = 0; reslevelno < codsty->nreslevels; reslevelno++) {
1150 uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1151 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1152 step_x = FFMIN(step_x, rlevel->log2_prec_width + reducedresno);
1153 step_y = FFMIN(step_y, rlevel->log2_prec_height + reducedresno);
1159 //FIXME we could iterate over less than the whole image
1160 for (y = 0; y < s->height; y += step_y) {
1161 for (x = 0; x < s->width; x += step_x) {
1162 for (compno = 0; compno < s->ncomponents; compno++) {
1163 Jpeg2000Component *comp = tile->comp + compno;
1164 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1165 Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
1166 int xc = x / s->cdx[compno];
1167 int yc = y / s->cdy[compno];
1169 for (reslevelno = 0; reslevelno < codsty->nreslevels; reslevelno++) {
1170 unsigned prcx, prcy;
1171 uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1172 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1174 if (yc % (1 << (rlevel->log2_prec_height + reducedresno)))
1177 if (xc % (1 << (rlevel->log2_prec_width + reducedresno)))
1180 // check if a precinct exists
1181 prcx = ff_jpeg2000_ceildivpow2(xc, reducedresno) >> rlevel->log2_prec_width;
1182 prcy = ff_jpeg2000_ceildivpow2(yc, reducedresno) >> rlevel->log2_prec_height;
1183 prcx -= ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], reducedresno) >> rlevel->log2_prec_width;
1184 prcy -= ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], reducedresno) >> rlevel->log2_prec_height;
1186 precno = prcx + rlevel->num_precincts_x * prcy;
1188 if (prcx >= rlevel->num_precincts_x || prcy >= rlevel->num_precincts_y) {
1189 av_log(s->avctx, AV_LOG_WARNING, "prc %d %d outside limits %d %d\n",
1190 prcx, prcy, rlevel->num_precincts_x, rlevel->num_precincts_y);
1194 for (layno = 0; layno < tile->codsty[0].nlayers; layno++) {
1195 if ((ret = jpeg2000_decode_packet(s, tile, &tp_index, codsty, rlevel,
1197 qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1198 qntsty->nguardbits)) < 0)
1211 /* EOC marker reached */
1212 bytestream2_skip(&s->g, 2);
1217 /* TIER-1 routines */
1218 static void decode_sigpass(Jpeg2000T1Context *t1, int width, int height,
1219 int bpno, int bandno,
1220 int vert_causal_ctx_csty_symbol)
1222 int mask = 3 << (bpno - 1), y0, x, y;
1224 for (y0 = 0; y0 < height; y0 += 4)
1225 for (x = 0; x < width; x++)
1226 for (y = y0; y < height && y < y0 + 4; y++) {
1227 int flags_mask = -1;
1228 if (vert_causal_ctx_csty_symbol && y == y0 + 3)
1229 flags_mask &= ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE | JPEG2000_T1_SGN_S);
1230 if ((t1->flags[y+1][x+1] & JPEG2000_T1_SIG_NB & flags_mask)
1231 && !(t1->flags[y+1][x+1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS))) {
1232 if (ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ff_jpeg2000_getsigctxno(t1->flags[y+1][x+1] & flags_mask, bandno))) {
1233 int xorbit, ctxno = ff_jpeg2000_getsgnctxno(t1->flags[y+1][x+1] & flags_mask, &xorbit);
1235 t1->data[y][x] = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ctxno) ? -mask : mask;
1237 t1->data[y][x] = (ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ctxno) ^ xorbit) ?
1240 ff_jpeg2000_set_significance(t1, x, y,
1241 t1->data[y][x] < 0);
1243 t1->flags[y + 1][x + 1] |= JPEG2000_T1_VIS;
1248 static void decode_refpass(Jpeg2000T1Context *t1, int width, int height,
1249 int bpno, int vert_causal_ctx_csty_symbol)
1254 phalf = 1 << (bpno - 1);
1257 for (y0 = 0; y0 < height; y0 += 4)
1258 for (x = 0; x < width; x++)
1259 for (y = y0; y < height && y < y0 + 4; y++)
1260 if ((t1->flags[y + 1][x + 1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS)) == JPEG2000_T1_SIG) {
1261 int flags_mask = (vert_causal_ctx_csty_symbol && y == y0 + 3) ?
1262 ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE | JPEG2000_T1_SGN_S) : -1;
1263 int ctxno = ff_jpeg2000_getrefctxno(t1->flags[y + 1][x + 1] & flags_mask);
1264 int r = ff_mqc_decode(&t1->mqc,
1265 t1->mqc.cx_states + ctxno)
1267 t1->data[y][x] += t1->data[y][x] < 0 ? -r : r;
1268 t1->flags[y + 1][x + 1] |= JPEG2000_T1_REF;
1272 static void decode_clnpass(Jpeg2000DecoderContext *s, Jpeg2000T1Context *t1,
1273 int width, int height, int bpno, int bandno,
1274 int seg_symbols, int vert_causal_ctx_csty_symbol)
1276 int mask = 3 << (bpno - 1), y0, x, y, runlen, dec;
1278 for (y0 = 0; y0 < height; y0 += 4) {
1279 for (x = 0; x < width; x++) {
1280 int flags_mask = -1;
1281 if (vert_causal_ctx_csty_symbol)
1282 flags_mask &= ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE | JPEG2000_T1_SGN_S);
1283 if (y0 + 3 < height &&
1284 !((t1->flags[y0 + 1][x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
1285 (t1->flags[y0 + 2][x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
1286 (t1->flags[y0 + 3][x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
1287 (t1->flags[y0 + 4][x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG) & flags_mask))) {
1288 if (!ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_RL))
1290 runlen = ff_mqc_decode(&t1->mqc,
1291 t1->mqc.cx_states + MQC_CX_UNI);
1292 runlen = (runlen << 1) | ff_mqc_decode(&t1->mqc,
1301 for (y = y0 + runlen; y < y0 + 4 && y < height; y++) {
1302 int flags_mask = -1;
1303 if (vert_causal_ctx_csty_symbol && y == y0 + 3)
1304 flags_mask &= ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE | JPEG2000_T1_SGN_S);
1306 if (!(t1->flags[y+1][x+1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS))) {
1307 dec = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ff_jpeg2000_getsigctxno(t1->flags[y+1][x+1] & flags_mask,
1313 int ctxno = ff_jpeg2000_getsgnctxno(t1->flags[y + 1][x + 1] & flags_mask,
1315 t1->data[y][x] = (ff_mqc_decode(&t1->mqc,
1316 t1->mqc.cx_states + ctxno) ^
1319 ff_jpeg2000_set_significance(t1, x, y, t1->data[y][x] < 0);
1322 t1->flags[y + 1][x + 1] &= ~JPEG2000_T1_VIS;
1328 val = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1329 val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1330 val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1331 val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1333 av_log(s->avctx, AV_LOG_ERROR,
1334 "Segmentation symbol value incorrect\n");
1338 static int decode_cblk(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *codsty,
1339 Jpeg2000T1Context *t1, Jpeg2000Cblk *cblk,
1340 int width, int height, int bandpos)
1342 int passno = cblk->npasses, pass_t = 2, bpno = cblk->nonzerobits - 1, y;
1344 int vert_causal_ctx_csty_symbol = codsty->cblk_style & JPEG2000_CBLK_VSC;
1348 av_assert0(width <= JPEG2000_MAX_CBLKW);
1349 av_assert0(height <= JPEG2000_MAX_CBLKH);
1351 for (y = 0; y < height; y++)
1352 memset(t1->data[y], 0, width * sizeof(**t1->data));
1354 /* If code-block contains no compressed data: nothing to do. */
1358 for (y = 0; y < height + 2; y++)
1359 memset(t1->flags[y], 0, (width + 2) * sizeof(**t1->flags));
1361 cblk->data[cblk->length] = 0xff;
1362 cblk->data[cblk->length+1] = 0xff;
1363 ff_mqc_initdec(&t1->mqc, cblk->data, 0, 1);
1368 decode_sigpass(t1, width, height, bpno + 1, bandpos,
1369 vert_causal_ctx_csty_symbol);
1372 decode_refpass(t1, width, height, bpno + 1, vert_causal_ctx_csty_symbol);
1375 av_assert2(!t1->mqc.raw);
1376 decode_clnpass(s, t1, width, height, bpno + 1, bandpos,
1377 codsty->cblk_style & JPEG2000_CBLK_SEGSYM,
1378 vert_causal_ctx_csty_symbol);
1381 if (codsty->cblk_style & JPEG2000_CBLK_RESET) // XXX no testcase for just this
1382 ff_mqc_init_contexts(&t1->mqc);
1384 if (passno && (coder_type = needs_termination(codsty->cblk_style, pass_cnt))) {
1385 if (term_cnt >= cblk->nb_terminations) {
1386 av_log(s->avctx, AV_LOG_ERROR, "Missing needed termination \n");
1387 return AVERROR_INVALIDDATA;
1389 ff_mqc_initdec(&t1->mqc, cblk->data + cblk->data_start[++term_cnt], coder_type == 2, 0);
1400 if (cblk->data + cblk->length - 2*(term_cnt < cblk->nb_terminations) != t1->mqc.bp) {
1401 av_log(s->avctx, AV_LOG_WARNING, "End mismatch %"PTRDIFF_SPECIFIER"\n",
1402 cblk->data + cblk->length - 2*(term_cnt < cblk->nb_terminations) - t1->mqc.bp);
1408 /* TODO: Verify dequantization for lossless case
1409 * comp->data can be float or int
1410 * band->stepsize can be float or int
1411 * depending on the type of DWT transformation.
1412 * see ISO/IEC 15444-1:2002 A.6.1 */
1414 /* Float dequantization of a codeblock.*/
1415 static void dequantization_float(int x, int y, Jpeg2000Cblk *cblk,
1416 Jpeg2000Component *comp,
1417 Jpeg2000T1Context *t1, Jpeg2000Band *band)
1420 int w = cblk->coord[0][1] - cblk->coord[0][0];
1421 for (j = 0; j < (cblk->coord[1][1] - cblk->coord[1][0]); ++j) {
1422 float *datap = &comp->f_data[(comp->coord[0][1] - comp->coord[0][0]) * (y + j) + x];
1423 int *src = t1->data[j];
1424 for (i = 0; i < w; ++i)
1425 datap[i] = src[i] * band->f_stepsize;
1429 /* Integer dequantization of a codeblock.*/
1430 static void dequantization_int(int x, int y, Jpeg2000Cblk *cblk,
1431 Jpeg2000Component *comp,
1432 Jpeg2000T1Context *t1, Jpeg2000Band *band)
1435 int w = cblk->coord[0][1] - cblk->coord[0][0];
1436 for (j = 0; j < (cblk->coord[1][1] - cblk->coord[1][0]); ++j) {
1437 int32_t *datap = &comp->i_data[(comp->coord[0][1] - comp->coord[0][0]) * (y + j) + x];
1438 int *src = t1->data[j];
1439 if (band->i_stepsize == 16384) {
1440 for (i = 0; i < w; ++i)
1441 datap[i] = src[i] / 2;
1443 // This should be VERY uncommon
1444 for (i = 0; i < w; ++i)
1445 datap[i] = (src[i] * (int64_t)band->i_stepsize) / 32768;
1450 static void dequantization_int_97(int x, int y, Jpeg2000Cblk *cblk,
1451 Jpeg2000Component *comp,
1452 Jpeg2000T1Context *t1, Jpeg2000Band *band)
1455 int w = cblk->coord[0][1] - cblk->coord[0][0];
1456 for (j = 0; j < (cblk->coord[1][1] - cblk->coord[1][0]); ++j) {
1457 int32_t *datap = &comp->i_data[(comp->coord[0][1] - comp->coord[0][0]) * (y + j) + x];
1458 int *src = t1->data[j];
1459 for (i = 0; i < w; ++i)
1460 datap[i] = (src[i] * (int64_t)band->i_stepsize + (1<<14)) >> 15;
1464 static inline void mct_decode(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
1469 for (i = 1; i < 3; i++) {
1470 if (tile->codsty[0].transform != tile->codsty[i].transform) {
1471 av_log(s->avctx, AV_LOG_ERROR, "Transforms mismatch, MCT not supported\n");
1474 if (memcmp(tile->comp[0].coord, tile->comp[i].coord, sizeof(tile->comp[0].coord))) {
1475 av_log(s->avctx, AV_LOG_ERROR, "Coords mismatch, MCT not supported\n");
1480 for (i = 0; i < 3; i++)
1481 if (tile->codsty[0].transform == FF_DWT97)
1482 src[i] = tile->comp[i].f_data;
1484 src[i] = tile->comp[i].i_data;
1486 for (i = 0; i < 2; i++)
1487 csize *= tile->comp[0].coord[i][1] - tile->comp[0].coord[i][0];
1489 s->dsp.mct_decode[tile->codsty[0].transform](src[0], src[1], src[2], csize);
1492 static int jpeg2000_decode_tile(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile,
1495 const AVPixFmtDescriptor *pixdesc = av_pix_fmt_desc_get(s->avctx->pix_fmt);
1496 int compno, reslevelno, bandno;
1498 int planar = !!(pixdesc->flags & AV_PIX_FMT_FLAG_PLANAR);
1499 int pixelsize = planar ? 1 : pixdesc->nb_components;
1502 Jpeg2000T1Context t1;
1504 /* Loop on tile components */
1505 for (compno = 0; compno < s->ncomponents; compno++) {
1506 Jpeg2000Component *comp = tile->comp + compno;
1507 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1509 /* Loop on resolution levels */
1510 for (reslevelno = 0; reslevelno < codsty->nreslevels2decode; reslevelno++) {
1511 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1513 for (bandno = 0; bandno < rlevel->nbands; bandno++) {
1514 int nb_precincts, precno;
1515 Jpeg2000Band *band = rlevel->band + bandno;
1516 int cblkno = 0, bandpos;
1518 bandpos = bandno + (reslevelno > 0);
1520 if (band->coord[0][0] == band->coord[0][1] ||
1521 band->coord[1][0] == band->coord[1][1])
1524 nb_precincts = rlevel->num_precincts_x * rlevel->num_precincts_y;
1525 /* Loop on precincts */
1526 for (precno = 0; precno < nb_precincts; precno++) {
1527 Jpeg2000Prec *prec = band->prec + precno;
1529 /* Loop on codeblocks */
1530 for (cblkno = 0; cblkno < prec->nb_codeblocks_width * prec->nb_codeblocks_height; cblkno++) {
1532 Jpeg2000Cblk *cblk = prec->cblk + cblkno;
1533 decode_cblk(s, codsty, &t1, cblk,
1534 cblk->coord[0][1] - cblk->coord[0][0],
1535 cblk->coord[1][1] - cblk->coord[1][0],
1538 x = cblk->coord[0][0] - band->coord[0][0];
1539 y = cblk->coord[1][0] - band->coord[1][0];
1541 if (codsty->transform == FF_DWT97)
1542 dequantization_float(x, y, cblk, comp, &t1, band);
1543 else if (codsty->transform == FF_DWT97_INT)
1544 dequantization_int_97(x, y, cblk, comp, &t1, band);
1546 dequantization_int(x, y, cblk, comp, &t1, band);
1550 } /* end reslevel */
1553 ff_dwt_decode(&comp->dwt, codsty->transform == FF_DWT97 ? (void*)comp->f_data : (void*)comp->i_data);
1556 /* inverse MCT transformation */
1557 if (tile->codsty[0].mct)
1558 mct_decode(s, tile);
1560 if (s->cdef[0] < 0) {
1561 for (x = 0; x < s->ncomponents; x++)
1563 if ((s->ncomponents & 1) == 0)
1564 s->cdef[s->ncomponents-1] = 0;
1567 if (s->precision <= 8) {
1568 for (compno = 0; compno < s->ncomponents; compno++) {
1569 Jpeg2000Component *comp = tile->comp + compno;
1570 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1571 float *datap = comp->f_data;
1572 int32_t *i_datap = comp->i_data;
1573 int cbps = s->cbps[compno];
1574 int w = tile->comp[compno].coord[0][1] - s->image_offset_x;
1578 plane = s->cdef[compno] ? s->cdef[compno]-1 : (s->ncomponents-1);
1581 y = tile->comp[compno].coord[1][0] - s->image_offset_y;
1582 line = picture->data[plane] + y / s->cdy[compno] * picture->linesize[plane];
1583 for (; y < tile->comp[compno].coord[1][1] - s->image_offset_y; y ++) {
1586 x = tile->comp[compno].coord[0][0] - s->image_offset_x;
1587 dst = line + x / s->cdx[compno] * pixelsize + compno*!planar;
1589 if (codsty->transform == FF_DWT97) {
1590 for (; x < w; x ++) {
1591 int val = lrintf(*datap) + (1 << (cbps - 1));
1592 /* DC level shift and clip see ISO 15444-1:2002 G.1.2 */
1593 val = av_clip(val, 0, (1 << cbps) - 1);
1594 *dst = val << (8 - cbps);
1599 for (; x < w; x ++) {
1600 int val = *i_datap + (1 << (cbps - 1));
1601 /* DC level shift and clip see ISO 15444-1:2002 G.1.2 */
1602 val = av_clip(val, 0, (1 << cbps) - 1);
1603 *dst = val << (8 - cbps);
1608 line += picture->linesize[plane];
1612 int precision = picture->format == AV_PIX_FMT_XYZ12 ||
1613 picture->format == AV_PIX_FMT_RGB48 ||
1614 picture->format == AV_PIX_FMT_RGBA64 ||
1615 picture->format == AV_PIX_FMT_GRAY16 ? 16 : s->precision;
1617 for (compno = 0; compno < s->ncomponents; compno++) {
1618 Jpeg2000Component *comp = tile->comp + compno;
1619 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1620 float *datap = comp->f_data;
1621 int32_t *i_datap = comp->i_data;
1623 int cbps = s->cbps[compno];
1624 int w = tile->comp[compno].coord[0][1] - s->image_offset_x;
1628 plane = s->cdef[compno] ? s->cdef[compno]-1 : (s->ncomponents-1);
1630 y = tile->comp[compno].coord[1][0] - s->image_offset_y;
1631 linel = (uint16_t *)picture->data[plane] + y / s->cdy[compno] * (picture->linesize[plane] >> 1);
1632 for (; y < tile->comp[compno].coord[1][1] - s->image_offset_y; y ++) {
1635 x = tile->comp[compno].coord[0][0] - s->image_offset_x;
1636 dst = linel + (x / s->cdx[compno] * pixelsize + compno*!planar);
1637 if (codsty->transform == FF_DWT97) {
1638 for (; x < w; x ++) {
1639 int val = lrintf(*datap) + (1 << (cbps - 1));
1640 /* DC level shift and clip see ISO 15444-1:2002 G.1.2 */
1641 val = av_clip(val, 0, (1 << cbps) - 1);
1642 /* align 12 bit values in little-endian mode */
1643 *dst = val << (precision - cbps);
1648 for (; x < w; x ++) {
1649 int val = *i_datap + (1 << (cbps - 1));
1650 /* DC level shift and clip see ISO 15444-1:2002 G.1.2 */
1651 val = av_clip(val, 0, (1 << cbps) - 1);
1652 /* align 12 bit values in little-endian mode */
1653 *dst = val << (precision - cbps);
1658 linel += picture->linesize[plane] >> 1;
1666 static void jpeg2000_dec_cleanup(Jpeg2000DecoderContext *s)
1669 for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++) {
1670 if (s->tile[tileno].comp) {
1671 for (compno = 0; compno < s->ncomponents; compno++) {
1672 Jpeg2000Component *comp = s->tile[tileno].comp + compno;
1673 Jpeg2000CodingStyle *codsty = s->tile[tileno].codsty + compno;
1675 ff_jpeg2000_cleanup(comp, codsty);
1677 av_freep(&s->tile[tileno].comp);
1681 memset(s->codsty, 0, sizeof(s->codsty));
1682 memset(s->qntsty, 0, sizeof(s->qntsty));
1683 s->numXtiles = s->numYtiles = 0;
1686 static int jpeg2000_read_main_headers(Jpeg2000DecoderContext *s)
1688 Jpeg2000CodingStyle *codsty = s->codsty;
1689 Jpeg2000QuantStyle *qntsty = s->qntsty;
1690 uint8_t *properties = s->properties;
1697 if (bytestream2_get_bytes_left(&s->g) < 2) {
1698 av_log(s->avctx, AV_LOG_ERROR, "Missing EOC\n");
1702 marker = bytestream2_get_be16u(&s->g);
1703 oldpos = bytestream2_tell(&s->g);
1705 if (marker == JPEG2000_SOD) {
1707 Jpeg2000TilePart *tp;
1710 av_log(s->avctx, AV_LOG_ERROR, "Missing SIZ\n");
1711 return AVERROR_INVALIDDATA;
1713 if (s->curtileno < 0) {
1714 av_log(s->avctx, AV_LOG_ERROR, "Missing SOT\n");
1715 return AVERROR_INVALIDDATA;
1718 tile = s->tile + s->curtileno;
1719 tp = tile->tile_part + tile->tp_idx;
1720 if (tp->tp_end < s->g.buffer) {
1721 av_log(s->avctx, AV_LOG_ERROR, "Invalid tpend\n");
1722 return AVERROR_INVALIDDATA;
1724 bytestream2_init(&tp->tpg, s->g.buffer, tp->tp_end - s->g.buffer);
1725 bytestream2_skip(&s->g, tp->tp_end - s->g.buffer);
1729 if (marker == JPEG2000_EOC)
1732 len = bytestream2_get_be16(&s->g);
1733 if (len < 2 || bytestream2_get_bytes_left(&s->g) < len - 2) {
1734 av_log(s->avctx, AV_LOG_ERROR, "Invalid len %d left=%d\n", len, bytestream2_get_bytes_left(&s->g));
1735 return AVERROR_INVALIDDATA;
1742 s->numXtiles = s->numYtiles = 0;
1745 ret = get_coc(s, codsty, properties);
1748 ret = get_cod(s, codsty, properties);
1751 ret = get_qcc(s, len, qntsty, properties);
1754 ret = get_qcd(s, len, qntsty, properties);
1757 if (!(ret = get_sot(s, len))) {
1758 av_assert1(s->curtileno >= 0);
1759 codsty = s->tile[s->curtileno].codsty;
1760 qntsty = s->tile[s->curtileno].qntsty;
1761 properties = s->tile[s->curtileno].properties;
1765 // the comment is ignored
1766 bytestream2_skip(&s->g, len - 2);
1769 // Tile-part lengths
1770 ret = get_tlm(s, len);
1773 // Packet length, tile-part header
1774 ret = get_plt(s, len);
1777 av_log(s->avctx, AV_LOG_ERROR,
1778 "unsupported marker 0x%.4"PRIX16" at pos 0x%X\n",
1779 marker, bytestream2_tell(&s->g) - 4);
1780 bytestream2_skip(&s->g, len - 2);
1783 if (bytestream2_tell(&s->g) - oldpos != len || ret) {
1784 av_log(s->avctx, AV_LOG_ERROR,
1785 "error during processing marker segment %.4"PRIx16"\n",
1787 return ret ? ret : -1;
1793 /* Read bit stream packets --> T2 operation. */
1794 static int jpeg2000_read_bitstream_packets(Jpeg2000DecoderContext *s)
1799 for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++) {
1800 Jpeg2000Tile *tile = s->tile + tileno;
1802 if ((ret = init_tile(s, tileno)) < 0)
1805 s->g = tile->tile_part[0].tpg;
1806 if ((ret = jpeg2000_decode_packets(s, tile)) < 0)
1813 static int jp2_find_codestream(Jpeg2000DecoderContext *s)
1815 uint32_t atom_size, atom, atom_end;
1816 int search_range = 10;
1820 bytestream2_get_bytes_left(&s->g) >= 8) {
1821 atom_size = bytestream2_get_be32u(&s->g);
1822 atom = bytestream2_get_be32u(&s->g);
1823 atom_end = bytestream2_tell(&s->g) + atom_size - 8;
1825 if (atom == JP2_CODESTREAM)
1828 if (bytestream2_get_bytes_left(&s->g) < atom_size || atom_end < atom_size)
1831 if (atom == JP2_HEADER &&
1833 uint32_t atom2_size, atom2, atom2_end;
1835 atom2_size = bytestream2_get_be32u(&s->g);
1836 atom2 = bytestream2_get_be32u(&s->g);
1837 atom2_end = bytestream2_tell(&s->g) + atom2_size - 8;
1838 if (atom2_size < 8 || atom2_end > atom_end || atom2_end < atom2_size)
1840 if (atom2 == JP2_CODESTREAM) {
1842 } else if (atom2 == MKBETAG('c','o','l','r') && atom2_size >= 7) {
1843 int method = bytestream2_get_byteu(&s->g);
1844 bytestream2_skipu(&s->g, 2);
1846 s->colour_space = bytestream2_get_be32u(&s->g);
1848 } else if (atom2 == MKBETAG('p','c','l','r') && atom2_size >= 6) {
1849 int i, size, colour_count, colour_channels, colour_depth[3];
1851 colour_count = bytestream2_get_be16u(&s->g);
1852 colour_channels = bytestream2_get_byteu(&s->g);
1853 // FIXME: Do not ignore channel_sign
1854 colour_depth[0] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1;
1855 colour_depth[1] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1;
1856 colour_depth[2] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1;
1857 size = (colour_depth[0] + 7 >> 3) * colour_count +
1858 (colour_depth[1] + 7 >> 3) * colour_count +
1859 (colour_depth[2] + 7 >> 3) * colour_count;
1860 if (colour_count > 256 ||
1861 colour_channels != 3 ||
1862 colour_depth[0] > 16 ||
1863 colour_depth[1] > 16 ||
1864 colour_depth[2] > 16 ||
1865 atom2_size < size) {
1866 avpriv_request_sample(s->avctx, "Unknown palette");
1867 bytestream2_seek(&s->g, atom2_end, SEEK_SET);
1871 for (i = 0; i < colour_count; i++) {
1872 if (colour_depth[0] <= 8) {
1873 r = bytestream2_get_byteu(&s->g) << 8 - colour_depth[0];
1874 r |= r >> colour_depth[0];
1876 r = bytestream2_get_be16u(&s->g) >> colour_depth[0] - 8;
1878 if (colour_depth[1] <= 8) {
1879 g = bytestream2_get_byteu(&s->g) << 8 - colour_depth[1];
1880 r |= r >> colour_depth[1];
1882 g = bytestream2_get_be16u(&s->g) >> colour_depth[1] - 8;
1884 if (colour_depth[2] <= 8) {
1885 b = bytestream2_get_byteu(&s->g) << 8 - colour_depth[2];
1886 r |= r >> colour_depth[2];
1888 b = bytestream2_get_be16u(&s->g) >> colour_depth[2] - 8;
1890 s->palette[i] = 0xffu << 24 | r << 16 | g << 8 | b;
1892 } else if (atom2 == MKBETAG('c','d','e','f') && atom2_size >= 2) {
1893 int n = bytestream2_get_be16u(&s->g);
1895 int cn = bytestream2_get_be16(&s->g);
1896 int av_unused typ = bytestream2_get_be16(&s->g);
1897 int asoc = bytestream2_get_be16(&s->g);
1898 if (cn < 4 && asoc < 4)
1902 bytestream2_seek(&s->g, atom2_end, SEEK_SET);
1903 } while (atom_end - atom2_end >= 8);
1907 bytestream2_seek(&s->g, atom_end, SEEK_SET);
1913 static av_cold int jpeg2000_decode_init(AVCodecContext *avctx)
1915 Jpeg2000DecoderContext *s = avctx->priv_data;
1917 ff_jpeg2000dsp_init(&s->dsp);
1922 static int jpeg2000_decode_frame(AVCodecContext *avctx, void *data,
1923 int *got_frame, AVPacket *avpkt)
1925 Jpeg2000DecoderContext *s = avctx->priv_data;
1926 ThreadFrame frame = { .f = data };
1927 AVFrame *picture = data;
1931 bytestream2_init(&s->g, avpkt->data, avpkt->size);
1933 memset(s->cdef, -1, sizeof(s->cdef));
1935 if (bytestream2_get_bytes_left(&s->g) < 2) {
1936 ret = AVERROR_INVALIDDATA;
1940 // check if the image is in jp2 format
1941 if (bytestream2_get_bytes_left(&s->g) >= 12 &&
1942 (bytestream2_get_be32u(&s->g) == 12) &&
1943 (bytestream2_get_be32u(&s->g) == JP2_SIG_TYPE) &&
1944 (bytestream2_get_be32u(&s->g) == JP2_SIG_VALUE)) {
1945 if (!jp2_find_codestream(s)) {
1946 av_log(avctx, AV_LOG_ERROR,
1947 "Could not find Jpeg2000 codestream atom.\n");
1948 ret = AVERROR_INVALIDDATA;
1952 bytestream2_seek(&s->g, 0, SEEK_SET);
1955 while (bytestream2_get_bytes_left(&s->g) >= 3 && bytestream2_peek_be16(&s->g) != JPEG2000_SOC)
1956 bytestream2_skip(&s->g, 1);
1958 if (bytestream2_get_be16u(&s->g) != JPEG2000_SOC) {
1959 av_log(avctx, AV_LOG_ERROR, "SOC marker not present\n");
1960 ret = AVERROR_INVALIDDATA;
1963 if (ret = jpeg2000_read_main_headers(s))
1966 /* get picture buffer */
1967 if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
1969 picture->pict_type = AV_PICTURE_TYPE_I;
1970 picture->key_frame = 1;
1972 if (ret = jpeg2000_read_bitstream_packets(s))
1975 for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++)
1976 if (ret = jpeg2000_decode_tile(s, s->tile + tileno, picture))
1979 jpeg2000_dec_cleanup(s);
1983 if (s->avctx->pix_fmt == AV_PIX_FMT_PAL8)
1984 memcpy(picture->data[1], s->palette, 256 * sizeof(uint32_t));
1986 return bytestream2_tell(&s->g);
1989 jpeg2000_dec_cleanup(s);
1993 static av_cold void jpeg2000_init_static_data(AVCodec *codec)
1995 ff_jpeg2000_init_tier1_luts();
1996 ff_mqc_init_context_tables();
1999 #define OFFSET(x) offsetof(Jpeg2000DecoderContext, x)
2000 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
2002 static const AVOption options[] = {
2003 { "lowres", "Lower the decoding resolution by a power of two",
2004 OFFSET(reduction_factor), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, JPEG2000_MAX_RESLEVELS - 1, VD },
2008 static const AVProfile profiles[] = {
2009 { FF_PROFILE_JPEG2000_CSTREAM_RESTRICTION_0, "JPEG 2000 codestream restriction 0" },
2010 { FF_PROFILE_JPEG2000_CSTREAM_RESTRICTION_1, "JPEG 2000 codestream restriction 1" },
2011 { FF_PROFILE_JPEG2000_CSTREAM_NO_RESTRICTION, "JPEG 2000 no codestream restrictions" },
2012 { FF_PROFILE_JPEG2000_DCINEMA_2K, "JPEG 2000 digital cinema 2K" },
2013 { FF_PROFILE_JPEG2000_DCINEMA_4K, "JPEG 2000 digital cinema 4K" },
2014 { FF_PROFILE_UNKNOWN },
2017 static const AVClass jpeg2000_class = {
2018 .class_name = "jpeg2000",
2019 .item_name = av_default_item_name,
2021 .version = LIBAVUTIL_VERSION_INT,
2024 AVCodec ff_jpeg2000_decoder = {
2026 .long_name = NULL_IF_CONFIG_SMALL("JPEG 2000"),
2027 .type = AVMEDIA_TYPE_VIDEO,
2028 .id = AV_CODEC_ID_JPEG2000,
2029 .capabilities = CODEC_CAP_FRAME_THREADS,
2030 .priv_data_size = sizeof(Jpeg2000DecoderContext),
2031 .init_static_data = jpeg2000_init_static_data,
2032 .init = jpeg2000_decode_init,
2033 .decode = jpeg2000_decode_frame,
2034 .priv_class = &jpeg2000_class,
2036 .profiles = NULL_IF_CONFIG_SMALL(profiles)