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[6];
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 return AVERROR_INVALIDDATA;
139 while (node && !node->vis) {
147 curval = stack[sp]->val;
149 while (curval < threshold && sp >= 0) {
150 if (curval < stack[sp]->val)
151 curval = stack[sp]->val;
152 while (curval < threshold) {
154 if ((ret = get_bits(s, 1)) > 0) {
162 stack[sp]->val = curval;
168 static int pix_fmt_match(enum AVPixelFormat pix_fmt, int components,
169 int bpc, uint32_t log2_chroma_wh, int pal8)
172 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
174 if (desc->nb_components != components) {
178 switch (components) {
180 match = match && desc->comp[3].depth_minus1 + 1 >= bpc &&
181 (log2_chroma_wh >> 14 & 3) == 0 &&
182 (log2_chroma_wh >> 12 & 3) == 0;
184 match = match && desc->comp[2].depth_minus1 + 1 >= bpc &&
185 (log2_chroma_wh >> 10 & 3) == desc->log2_chroma_w &&
186 (log2_chroma_wh >> 8 & 3) == desc->log2_chroma_h;
188 match = match && desc->comp[1].depth_minus1 + 1 >= bpc &&
189 (log2_chroma_wh >> 6 & 3) == desc->log2_chroma_w &&
190 (log2_chroma_wh >> 4 & 3) == desc->log2_chroma_h;
193 match = match && desc->comp[0].depth_minus1 + 1 >= bpc &&
194 (log2_chroma_wh >> 2 & 3) == 0 &&
195 (log2_chroma_wh & 3) == 0 &&
196 (desc->flags & AV_PIX_FMT_FLAG_PAL) == pal8 * AV_PIX_FMT_FLAG_PAL;
201 // pix_fmts with lower bpp have to be listed before
202 // similar pix_fmts with higher bpp.
203 #define RGB_PIXEL_FORMATS AV_PIX_FMT_PAL8,AV_PIX_FMT_RGB24,AV_PIX_FMT_RGBA,AV_PIX_FMT_RGB48,AV_PIX_FMT_RGBA64
204 #define GRAY_PIXEL_FORMATS AV_PIX_FMT_GRAY8,AV_PIX_FMT_GRAY8A,AV_PIX_FMT_GRAY16,AV_PIX_FMT_YA16
205 #define YUV_PIXEL_FORMATS AV_PIX_FMT_YUV410P,AV_PIX_FMT_YUV411P,AV_PIX_FMT_YUVA420P, \
206 AV_PIX_FMT_YUV420P,AV_PIX_FMT_YUV422P,AV_PIX_FMT_YUVA422P, \
207 AV_PIX_FMT_YUV440P,AV_PIX_FMT_YUV444P,AV_PIX_FMT_YUVA444P, \
208 AV_PIX_FMT_YUV420P9,AV_PIX_FMT_YUV422P9,AV_PIX_FMT_YUV444P9, \
209 AV_PIX_FMT_YUVA420P9,AV_PIX_FMT_YUVA422P9,AV_PIX_FMT_YUVA444P9, \
210 AV_PIX_FMT_YUV420P10,AV_PIX_FMT_YUV422P10,AV_PIX_FMT_YUV444P10, \
211 AV_PIX_FMT_YUVA420P10,AV_PIX_FMT_YUVA422P10,AV_PIX_FMT_YUVA444P10, \
212 AV_PIX_FMT_YUV420P12,AV_PIX_FMT_YUV422P12,AV_PIX_FMT_YUV444P12, \
213 AV_PIX_FMT_YUV420P14,AV_PIX_FMT_YUV422P14,AV_PIX_FMT_YUV444P14, \
214 AV_PIX_FMT_YUV420P16,AV_PIX_FMT_YUV422P16,AV_PIX_FMT_YUV444P16, \
215 AV_PIX_FMT_YUVA420P16,AV_PIX_FMT_YUVA422P16,AV_PIX_FMT_YUVA444P16
216 #define XYZ_PIXEL_FORMATS AV_PIX_FMT_XYZ12
218 static const enum AVPixelFormat rgb_pix_fmts[] = {RGB_PIXEL_FORMATS};
219 static const enum AVPixelFormat gray_pix_fmts[] = {GRAY_PIXEL_FORMATS};
220 static const enum AVPixelFormat yuv_pix_fmts[] = {YUV_PIXEL_FORMATS};
221 static const enum AVPixelFormat xyz_pix_fmts[] = {XYZ_PIXEL_FORMATS};
222 static const enum AVPixelFormat all_pix_fmts[] = {RGB_PIXEL_FORMATS,
227 /* marker segments */
228 /* get sizes and offsets of image, tiles; number of components */
229 static int get_siz(Jpeg2000DecoderContext *s)
233 uint32_t log2_chroma_wh = 0;
234 const enum AVPixelFormat *possible_fmts = NULL;
235 int possible_fmts_nb = 0;
237 if (bytestream2_get_bytes_left(&s->g) < 36)
238 return AVERROR_INVALIDDATA;
240 s->avctx->profile = bytestream2_get_be16u(&s->g); // Rsiz
241 s->width = bytestream2_get_be32u(&s->g); // Width
242 s->height = bytestream2_get_be32u(&s->g); // Height
243 s->image_offset_x = bytestream2_get_be32u(&s->g); // X0Siz
244 s->image_offset_y = bytestream2_get_be32u(&s->g); // Y0Siz
245 s->tile_width = bytestream2_get_be32u(&s->g); // XTSiz
246 s->tile_height = bytestream2_get_be32u(&s->g); // YTSiz
247 s->tile_offset_x = bytestream2_get_be32u(&s->g); // XT0Siz
248 s->tile_offset_y = bytestream2_get_be32u(&s->g); // YT0Siz
249 ncomponents = bytestream2_get_be16u(&s->g); // CSiz
251 if (s->image_offset_x || s->image_offset_y) {
252 avpriv_request_sample(s->avctx, "Support for image offsets");
253 return AVERROR_PATCHWELCOME;
256 if (ncomponents <= 0) {
257 av_log(s->avctx, AV_LOG_ERROR, "Invalid number of components: %d\n",
259 return AVERROR_INVALIDDATA;
262 if (ncomponents > 4) {
263 avpriv_request_sample(s->avctx, "Support for %d components",
265 return AVERROR_PATCHWELCOME;
268 s->ncomponents = ncomponents;
270 if (s->tile_width <= 0 || s->tile_height <= 0) {
271 av_log(s->avctx, AV_LOG_ERROR, "Invalid tile dimension %dx%d.\n",
272 s->tile_width, s->tile_height);
273 return AVERROR_INVALIDDATA;
276 if (bytestream2_get_bytes_left(&s->g) < 3 * s->ncomponents)
277 return AVERROR_INVALIDDATA;
279 for (i = 0; i < s->ncomponents; i++) { // Ssiz_i XRsiz_i, YRsiz_i
280 uint8_t x = bytestream2_get_byteu(&s->g);
281 s->cbps[i] = (x & 0x7f) + 1;
282 s->precision = FFMAX(s->cbps[i], s->precision);
283 s->sgnd[i] = !!(x & 0x80);
284 s->cdx[i] = bytestream2_get_byteu(&s->g);
285 s->cdy[i] = bytestream2_get_byteu(&s->g);
286 if ( !s->cdx[i] || s->cdx[i] == 3 || s->cdx[i] > 4
287 || !s->cdy[i] || s->cdy[i] == 3 || s->cdy[i] > 4) {
288 av_log(s->avctx, AV_LOG_ERROR, "Invalid sample separation %d/%d\n", s->cdx[i], s->cdy[i]);
289 return AVERROR_INVALIDDATA;
291 log2_chroma_wh |= s->cdy[i] >> 1 << i * 4 | s->cdx[i] >> 1 << i * 4 + 2;
294 s->numXtiles = ff_jpeg2000_ceildiv(s->width - s->tile_offset_x, s->tile_width);
295 s->numYtiles = ff_jpeg2000_ceildiv(s->height - s->tile_offset_y, s->tile_height);
297 if (s->numXtiles * (uint64_t)s->numYtiles > INT_MAX/sizeof(*s->tile)) {
298 s->numXtiles = s->numYtiles = 0;
299 return AVERROR(EINVAL);
302 s->tile = av_mallocz_array(s->numXtiles * s->numYtiles, sizeof(*s->tile));
304 s->numXtiles = s->numYtiles = 0;
305 return AVERROR(ENOMEM);
308 for (i = 0; i < s->numXtiles * s->numYtiles; i++) {
309 Jpeg2000Tile *tile = s->tile + i;
311 tile->comp = av_mallocz(s->ncomponents * sizeof(*tile->comp));
313 return AVERROR(ENOMEM);
316 /* compute image size with reduction factor */
317 s->avctx->width = ff_jpeg2000_ceildivpow2(s->width - s->image_offset_x,
318 s->reduction_factor);
319 s->avctx->height = ff_jpeg2000_ceildivpow2(s->height - s->image_offset_y,
320 s->reduction_factor);
322 if (s->avctx->profile == FF_PROFILE_JPEG2000_DCINEMA_2K ||
323 s->avctx->profile == FF_PROFILE_JPEG2000_DCINEMA_4K) {
324 possible_fmts = xyz_pix_fmts;
325 possible_fmts_nb = FF_ARRAY_ELEMS(xyz_pix_fmts);
327 switch (s->colour_space) {
329 possible_fmts = rgb_pix_fmts;
330 possible_fmts_nb = FF_ARRAY_ELEMS(rgb_pix_fmts);
333 possible_fmts = gray_pix_fmts;
334 possible_fmts_nb = FF_ARRAY_ELEMS(gray_pix_fmts);
337 possible_fmts = yuv_pix_fmts;
338 possible_fmts_nb = FF_ARRAY_ELEMS(yuv_pix_fmts);
341 possible_fmts = all_pix_fmts;
342 possible_fmts_nb = FF_ARRAY_ELEMS(all_pix_fmts);
346 for (i = 0; i < possible_fmts_nb; ++i) {
347 if (pix_fmt_match(possible_fmts[i], ncomponents, s->precision, log2_chroma_wh, s->pal8)) {
348 s->avctx->pix_fmt = possible_fmts[i];
352 if (i == possible_fmts_nb) {
353 av_log(s->avctx, AV_LOG_ERROR,
354 "Unknown pix_fmt, profile: %d, colour_space: %d, "
355 "components: %d, precision: %d, "
356 "cdx[1]: %d, cdy[1]: %d, cdx[2]: %d, cdy[2]: %d\n",
357 s->avctx->profile, s->colour_space, ncomponents, s->precision,
358 ncomponents > 2 ? s->cdx[1] : 0,
359 ncomponents > 2 ? s->cdy[1] : 0,
360 ncomponents > 2 ? s->cdx[2] : 0,
361 ncomponents > 2 ? s->cdy[2] : 0);
362 return AVERROR_PATCHWELCOME;
364 s->avctx->bits_per_raw_sample = s->precision;
368 /* get common part for COD and COC segments */
369 static int get_cox(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c)
373 if (bytestream2_get_bytes_left(&s->g) < 5)
374 return AVERROR_INVALIDDATA;
376 /* nreslevels = number of resolution levels
377 = number of decomposition level +1 */
378 c->nreslevels = bytestream2_get_byteu(&s->g) + 1;
379 if (c->nreslevels >= JPEG2000_MAX_RESLEVELS) {
380 av_log(s->avctx, AV_LOG_ERROR, "nreslevels %d is invalid\n", c->nreslevels);
381 return AVERROR_INVALIDDATA;
384 if (c->nreslevels <= s->reduction_factor) {
385 /* we are forced to update reduction_factor as its requested value is
386 not compatible with this bitstream, and as we might have used it
387 already in setup earlier we have to fail this frame until
388 reinitialization is implemented */
389 av_log(s->avctx, AV_LOG_ERROR, "reduction_factor too large for this bitstream, max is %d\n", c->nreslevels - 1);
390 s->reduction_factor = c->nreslevels - 1;
391 return AVERROR(EINVAL);
394 /* compute number of resolution levels to decode */
395 c->nreslevels2decode = c->nreslevels - s->reduction_factor;
397 c->log2_cblk_width = (bytestream2_get_byteu(&s->g) & 15) + 2; // cblk width
398 c->log2_cblk_height = (bytestream2_get_byteu(&s->g) & 15) + 2; // cblk height
400 if (c->log2_cblk_width > 10 || c->log2_cblk_height > 10 ||
401 c->log2_cblk_width + c->log2_cblk_height > 12) {
402 av_log(s->avctx, AV_LOG_ERROR, "cblk size invalid\n");
403 return AVERROR_INVALIDDATA;
406 if (c->log2_cblk_width > 6 || c->log2_cblk_height > 6) {
407 avpriv_request_sample(s->avctx, "cblk size > 64");
408 return AVERROR_PATCHWELCOME;
411 c->cblk_style = bytestream2_get_byteu(&s->g);
412 if (c->cblk_style != 0) { // cblk style
413 av_log(s->avctx, AV_LOG_WARNING, "extra cblk styles %X\n", c->cblk_style);
415 c->transform = bytestream2_get_byteu(&s->g); // DWT transformation type
416 /* set integer 9/7 DWT in case of BITEXACT flag */
417 if ((s->avctx->flags & CODEC_FLAG_BITEXACT) && (c->transform == FF_DWT97))
418 c->transform = FF_DWT97_INT;
420 if (c->csty & JPEG2000_CSTY_PREC) {
422 for (i = 0; i < c->nreslevels; i++) {
423 byte = bytestream2_get_byte(&s->g);
424 c->log2_prec_widths[i] = byte & 0x0F; // precinct PPx
425 c->log2_prec_heights[i] = (byte >> 4) & 0x0F; // precinct PPy
428 memset(c->log2_prec_widths , 15, sizeof(c->log2_prec_widths ));
429 memset(c->log2_prec_heights, 15, sizeof(c->log2_prec_heights));
434 /* get coding parameters for a particular tile or whole image*/
435 static int get_cod(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c,
438 Jpeg2000CodingStyle tmp;
441 if (bytestream2_get_bytes_left(&s->g) < 5)
442 return AVERROR_INVALIDDATA;
444 tmp.csty = bytestream2_get_byteu(&s->g);
446 // get progression order
447 tmp.prog_order = bytestream2_get_byteu(&s->g);
449 tmp.nlayers = bytestream2_get_be16u(&s->g);
450 tmp.mct = bytestream2_get_byteu(&s->g); // multiple component transformation
452 if (tmp.mct && s->ncomponents < 3) {
453 av_log(s->avctx, AV_LOG_ERROR,
454 "MCT %"PRIu8" with too few components (%d)\n",
455 tmp.mct, s->ncomponents);
456 return AVERROR_INVALIDDATA;
459 if ((ret = get_cox(s, &tmp)) < 0)
462 for (compno = 0; compno < s->ncomponents; compno++)
463 if (!(properties[compno] & HAD_COC))
464 memcpy(c + compno, &tmp, sizeof(tmp));
468 /* Get coding parameters for a component in the whole image or a
469 * particular tile. */
470 static int get_coc(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c,
475 if (bytestream2_get_bytes_left(&s->g) < 2)
476 return AVERROR_INVALIDDATA;
478 compno = bytestream2_get_byteu(&s->g);
480 if (compno >= s->ncomponents) {
481 av_log(s->avctx, AV_LOG_ERROR,
482 "Invalid compno %d. There are %d components in the image.\n",
483 compno, s->ncomponents);
484 return AVERROR_INVALIDDATA;
488 c->csty = bytestream2_get_byteu(&s->g);
490 if ((ret = get_cox(s, c)) < 0)
493 properties[compno] |= HAD_COC;
497 /* Get common part for QCD and QCC segments. */
498 static int get_qcx(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q)
502 if (bytestream2_get_bytes_left(&s->g) < 1)
503 return AVERROR_INVALIDDATA;
505 x = bytestream2_get_byteu(&s->g); // Sqcd
507 q->nguardbits = x >> 5;
508 q->quantsty = x & 0x1f;
510 if (q->quantsty == JPEG2000_QSTY_NONE) {
512 if (bytestream2_get_bytes_left(&s->g) < n ||
513 n > JPEG2000_MAX_DECLEVELS*3)
514 return AVERROR_INVALIDDATA;
515 for (i = 0; i < n; i++)
516 q->expn[i] = bytestream2_get_byteu(&s->g) >> 3;
517 } else if (q->quantsty == JPEG2000_QSTY_SI) {
518 if (bytestream2_get_bytes_left(&s->g) < 2)
519 return AVERROR_INVALIDDATA;
520 x = bytestream2_get_be16u(&s->g);
521 q->expn[0] = x >> 11;
522 q->mant[0] = x & 0x7ff;
523 for (i = 1; i < JPEG2000_MAX_DECLEVELS * 3; i++) {
524 int curexpn = FFMAX(0, q->expn[0] - (i - 1) / 3);
525 q->expn[i] = curexpn;
526 q->mant[i] = q->mant[0];
530 if (bytestream2_get_bytes_left(&s->g) < 2 * n ||
531 n > JPEG2000_MAX_DECLEVELS*3)
532 return AVERROR_INVALIDDATA;
533 for (i = 0; i < n; i++) {
534 x = bytestream2_get_be16u(&s->g);
535 q->expn[i] = x >> 11;
536 q->mant[i] = x & 0x7ff;
542 /* Get quantization parameters for a particular tile or a whole image. */
543 static int get_qcd(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q,
546 Jpeg2000QuantStyle tmp;
549 memset(&tmp, 0, sizeof(tmp));
551 if ((ret = get_qcx(s, n, &tmp)) < 0)
553 for (compno = 0; compno < s->ncomponents; compno++)
554 if (!(properties[compno] & HAD_QCC))
555 memcpy(q + compno, &tmp, sizeof(tmp));
559 /* Get quantization parameters for a component in the whole image
560 * on in a particular tile. */
561 static int get_qcc(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q,
566 if (bytestream2_get_bytes_left(&s->g) < 1)
567 return AVERROR_INVALIDDATA;
569 compno = bytestream2_get_byteu(&s->g);
571 if (compno >= s->ncomponents) {
572 av_log(s->avctx, AV_LOG_ERROR,
573 "Invalid compno %d. There are %d components in the image.\n",
574 compno, s->ncomponents);
575 return AVERROR_INVALIDDATA;
578 properties[compno] |= HAD_QCC;
579 return get_qcx(s, n - 1, q + compno);
582 /* Get start of tile segment. */
583 static int get_sot(Jpeg2000DecoderContext *s, int n)
585 Jpeg2000TilePart *tp;
590 if (bytestream2_get_bytes_left(&s->g) < 8)
591 return AVERROR_INVALIDDATA;
594 Isot = bytestream2_get_be16u(&s->g); // Isot
595 if (Isot >= s->numXtiles * s->numYtiles)
596 return AVERROR_INVALIDDATA;
599 Psot = bytestream2_get_be32u(&s->g); // Psot
600 TPsot = bytestream2_get_byteu(&s->g); // TPsot
602 /* Read TNSot but not used */
603 bytestream2_get_byteu(&s->g); // TNsot
606 Psot = bytestream2_get_bytes_left(&s->g) + n + 2;
608 if (Psot > bytestream2_get_bytes_left(&s->g) + n + 2) {
609 av_log(s->avctx, AV_LOG_ERROR, "Psot %"PRIu32" too big\n", Psot);
610 return AVERROR_INVALIDDATA;
613 if (TPsot >= FF_ARRAY_ELEMS(s->tile[Isot].tile_part)) {
614 avpriv_request_sample(s->avctx, "Support for %"PRIu8" components", TPsot);
615 return AVERROR_PATCHWELCOME;
618 s->tile[Isot].tp_idx = TPsot;
619 tp = s->tile[Isot].tile_part + TPsot;
620 tp->tile_index = Isot;
621 tp->tp_end = s->g.buffer + Psot - n - 2;
624 Jpeg2000Tile *tile = s->tile + s->curtileno;
627 memcpy(tile->codsty, s->codsty, s->ncomponents * sizeof(Jpeg2000CodingStyle));
628 memcpy(tile->qntsty, s->qntsty, s->ncomponents * sizeof(Jpeg2000QuantStyle));
634 /* Tile-part lengths: see ISO 15444-1:2002, section A.7.1
635 * Used to know the number of tile parts and lengths.
636 * There may be multiple TLMs in the header.
637 * TODO: The function is not used for tile-parts management, nor anywhere else.
638 * It can be useful to allocate memory for tile parts, before managing the SOT
639 * markers. Parsing the TLM header is needed to increment the input header
641 * This marker is mandatory for DCI. */
642 static uint8_t get_tlm(Jpeg2000DecoderContext *s, int n)
644 uint8_t Stlm, ST, SP, tile_tlm, i;
645 bytestream2_get_byte(&s->g); /* Ztlm: skipped */
646 Stlm = bytestream2_get_byte(&s->g);
648 // too complex ? ST = ((Stlm >> 4) & 0x01) + ((Stlm >> 4) & 0x02);
649 ST = (Stlm >> 4) & 0x03;
650 // TODO: Manage case of ST = 0b11 --> raise error
651 SP = (Stlm >> 6) & 0x01;
652 tile_tlm = (n - 4) / ((SP + 1) * 2 + ST);
653 for (i = 0; i < tile_tlm; i++) {
658 bytestream2_get_byte(&s->g);
661 bytestream2_get_be16(&s->g);
664 bytestream2_get_be32(&s->g);
668 bytestream2_get_be16(&s->g);
670 bytestream2_get_be32(&s->g);
676 static uint8_t get_plt(Jpeg2000DecoderContext *s, int n)
680 av_log(s->avctx, AV_LOG_ERROR,
681 "PLT marker at pos 0x%X\n", bytestream2_tell(&s->g) - 4);
683 /*Zplt =*/ bytestream2_get_byte(&s->g);
685 for (i = 0; i < n - 3; i++) {
686 bytestream2_get_byte(&s->g);
692 static int init_tile(Jpeg2000DecoderContext *s, int tileno)
695 int tilex = tileno % s->numXtiles;
696 int tiley = tileno / s->numXtiles;
697 Jpeg2000Tile *tile = s->tile + tileno;
700 return AVERROR(ENOMEM);
702 for (compno = 0; compno < s->ncomponents; compno++) {
703 Jpeg2000Component *comp = tile->comp + compno;
704 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
705 Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
706 int ret; // global bandno
708 comp->coord_o[0][0] = FFMAX(tilex * s->tile_width + s->tile_offset_x, s->image_offset_x);
709 comp->coord_o[0][1] = FFMIN((tilex + 1) * s->tile_width + s->tile_offset_x, s->width);
710 comp->coord_o[1][0] = FFMAX(tiley * s->tile_height + s->tile_offset_y, s->image_offset_y);
711 comp->coord_o[1][1] = FFMIN((tiley + 1) * s->tile_height + s->tile_offset_y, s->height);
713 comp->coord_o[0][0] /= s->cdx[compno];
714 comp->coord_o[0][1] /= s->cdx[compno];
715 comp->coord_o[1][0] /= s->cdy[compno];
716 comp->coord_o[1][1] /= s->cdy[compno];
719 comp->coord[0][0] = ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], s->reduction_factor);
720 comp->coord[0][1] = ff_jpeg2000_ceildivpow2(comp->coord_o[0][1], s->reduction_factor);
721 comp->coord[1][0] = ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], s->reduction_factor);
722 comp->coord[1][1] = ff_jpeg2000_ceildivpow2(comp->coord_o[1][1], s->reduction_factor);
724 if (ret = ff_jpeg2000_init_component(comp, codsty, qntsty,
725 s->cbps[compno], s->cdx[compno],
726 s->cdy[compno], s->avctx))
732 /* Read the number of coding passes. */
733 static int getnpasses(Jpeg2000DecoderContext *s)
740 if ((num = get_bits(s, 2)) != 3)
741 return num < 0 ? num : 3 + num;
742 if ((num = get_bits(s, 5)) != 31)
743 return num < 0 ? num : 6 + num;
744 num = get_bits(s, 7);
745 return num < 0 ? num : 37 + num;
748 static int getlblockinc(Jpeg2000DecoderContext *s)
751 while (ret = get_bits(s, 1)) {
759 static int jpeg2000_decode_packet(Jpeg2000DecoderContext *s,
760 Jpeg2000CodingStyle *codsty,
761 Jpeg2000ResLevel *rlevel, int precno,
762 int layno, uint8_t *expn, int numgbits)
764 int bandno, cblkno, ret, nb_code_blocks;
766 if (!(ret = get_bits(s, 1))) {
772 for (bandno = 0; bandno < rlevel->nbands; bandno++) {
773 Jpeg2000Band *band = rlevel->band + bandno;
774 Jpeg2000Prec *prec = band->prec + precno;
776 if (band->coord[0][0] == band->coord[0][1] ||
777 band->coord[1][0] == band->coord[1][1])
779 nb_code_blocks = prec->nb_codeblocks_height *
780 prec->nb_codeblocks_width;
781 for (cblkno = 0; cblkno < nb_code_blocks; cblkno++) {
782 Jpeg2000Cblk *cblk = prec->cblk + cblkno;
783 int incl, newpasses, llen;
786 incl = get_bits(s, 1);
788 incl = tag_tree_decode(s, prec->cblkincl + cblkno, layno + 1) == layno;
794 if (!cblk->npasses) {
795 int v = expn[bandno] + numgbits - 1 -
796 tag_tree_decode(s, prec->zerobits + cblkno, 100);
798 av_log(s->avctx, AV_LOG_ERROR,
799 "nonzerobits %d invalid\n", v);
800 return AVERROR_INVALIDDATA;
802 cblk->nonzerobits = v;
804 if ((newpasses = getnpasses(s)) < 0)
806 if ((llen = getlblockinc(s)) < 0)
808 cblk->lblock += llen;
809 if ((ret = get_bits(s, av_log2(newpasses) + cblk->lblock)) < 0)
811 if (ret > sizeof(cblk->data)) {
812 avpriv_request_sample(s->avctx,
813 "Block with lengthinc greater than %"SIZE_SPECIFIER"",
815 return AVERROR_PATCHWELCOME;
817 cblk->lengthinc = ret;
818 cblk->npasses += newpasses;
823 if (codsty->csty & JPEG2000_CSTY_EPH) {
824 if (bytestream2_peek_be16(&s->g) == JPEG2000_EPH)
825 bytestream2_skip(&s->g, 2);
827 av_log(s->avctx, AV_LOG_ERROR, "EPH marker not found.\n");
830 for (bandno = 0; bandno < rlevel->nbands; bandno++) {
831 Jpeg2000Band *band = rlevel->band + bandno;
832 Jpeg2000Prec *prec = band->prec + precno;
834 nb_code_blocks = prec->nb_codeblocks_height * prec->nb_codeblocks_width;
835 for (cblkno = 0; cblkno < nb_code_blocks; cblkno++) {
836 Jpeg2000Cblk *cblk = prec->cblk + cblkno;
837 if ( bytestream2_get_bytes_left(&s->g) < cblk->lengthinc
838 || sizeof(cblk->data) < cblk->length + cblk->lengthinc + 2
840 av_log(s->avctx, AV_LOG_ERROR,
841 "Block length %"PRIu16" or lengthinc %d is too large\n",
842 cblk->length, cblk->lengthinc);
843 return AVERROR_INVALIDDATA;
846 bytestream2_get_bufferu(&s->g, cblk->data + cblk->length, cblk->lengthinc);
847 cblk->length += cblk->lengthinc;
854 static int jpeg2000_decode_packets(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
857 int layno, reslevelno, compno, precno, ok_reslevel;
861 switch (tile->codsty[0].prog_order) {
862 case JPEG2000_PGOD_RLCP:
863 avpriv_request_sample(s->avctx, "Progression order RLCP");
865 case JPEG2000_PGOD_LRCP:
866 for (layno = 0; layno < tile->codsty[0].nlayers; layno++) {
868 for (reslevelno = 0; ok_reslevel; reslevelno++) {
870 for (compno = 0; compno < s->ncomponents; compno++) {
871 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
872 Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
873 if (reslevelno < codsty->nreslevels) {
874 Jpeg2000ResLevel *rlevel = tile->comp[compno].reslevel +
877 for (precno = 0; precno < rlevel->num_precincts_x * rlevel->num_precincts_y; precno++)
878 if ((ret = jpeg2000_decode_packet(s,
881 qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
882 qntsty->nguardbits)) < 0)
890 case JPEG2000_PGOD_CPRL:
891 for (compno = 0; compno < s->ncomponents; compno++) {
892 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
893 Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
895 /* Set bit stream buffer address according to tile-part.
896 * For DCinema one tile-part per component, so can be
897 * indexed by component. */
898 s->g = tile->tile_part[compno].tpg;
900 /* Position loop (y axis)
901 * TODO: Automate computing of step 256.
902 * Fixed here, but to be computed before entering here. */
903 for (y = 0; y < s->height; y += 256) {
904 /* Position loop (y axis)
905 * TODO: automate computing of step 256.
906 * Fixed here, but to be computed before entering here. */
907 for (x = 0; x < s->width; x += 256) {
908 for (reslevelno = 0; reslevelno < codsty->nreslevels; reslevelno++) {
910 uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
911 Jpeg2000ResLevel *rlevel = tile->comp[compno].reslevel + reslevelno;
913 if (!((y % (1 << (rlevel->log2_prec_height + reducedresno)) == 0) ||
914 (y == 0))) // TODO: 2nd condition simplified as try0 always =0 for dcinema
917 if (!((x % (1 << (rlevel->log2_prec_width + reducedresno)) == 0) ||
918 (x == 0))) // TODO: 2nd condition simplified as try0 always =0 for dcinema
921 // check if a precinct exists
922 prcx = ff_jpeg2000_ceildivpow2(x, reducedresno) >> rlevel->log2_prec_width;
923 prcy = ff_jpeg2000_ceildivpow2(y, reducedresno) >> rlevel->log2_prec_height;
924 precno = prcx + rlevel->num_precincts_x * prcy;
926 if (prcx >= rlevel->num_precincts_x || prcy >= rlevel->num_precincts_y)
927 return AVERROR_PATCHWELCOME;
929 for (layno = 0; layno < tile->codsty[0].nlayers; layno++) {
930 if ((ret = jpeg2000_decode_packet(s, codsty, rlevel,
932 qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
933 qntsty->nguardbits)) < 0)
942 case JPEG2000_PGOD_RPCL:
943 avpriv_request_sample(s->avctx, "Progression order RPCL");
944 ret = AVERROR_PATCHWELCOME;
947 case JPEG2000_PGOD_PCRL:
948 avpriv_request_sample(s->avctx, "Progression order PCRL");
949 ret = AVERROR_PATCHWELCOME;
956 /* EOC marker reached */
957 bytestream2_skip(&s->g, 2);
962 /* TIER-1 routines */
963 static void decode_sigpass(Jpeg2000T1Context *t1, int width, int height,
964 int bpno, int bandno, int bpass_csty_symbol,
965 int vert_causal_ctx_csty_symbol)
967 int mask = 3 << (bpno - 1), y0, x, y;
969 for (y0 = 0; y0 < height; y0 += 4)
970 for (x = 0; x < width; x++)
971 for (y = y0; y < height && y < y0 + 4; y++) {
972 if ((t1->flags[y+1][x+1] & JPEG2000_T1_SIG_NB)
973 && !(t1->flags[y+1][x+1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS))) {
975 if (vert_causal_ctx_csty_symbol && y == y0 + 3)
976 flags_mask &= ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE);
977 if (ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ff_jpeg2000_getsigctxno(t1->flags[y+1][x+1] & flags_mask, bandno))) {
978 int xorbit, ctxno = ff_jpeg2000_getsgnctxno(t1->flags[y+1][x+1], &xorbit);
979 if (bpass_csty_symbol)
980 t1->data[y][x] = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ctxno) ? -mask : mask;
982 t1->data[y][x] = (ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ctxno) ^ xorbit) ?
985 ff_jpeg2000_set_significance(t1, x, y,
988 t1->flags[y + 1][x + 1] |= JPEG2000_T1_VIS;
993 static void decode_refpass(Jpeg2000T1Context *t1, int width, int height,
999 phalf = 1 << (bpno - 1);
1002 for (y0 = 0; y0 < height; y0 += 4)
1003 for (x = 0; x < width; x++)
1004 for (y = y0; y < height && y < y0 + 4; y++)
1005 if ((t1->flags[y + 1][x + 1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS)) == JPEG2000_T1_SIG) {
1006 int ctxno = ff_jpeg2000_getrefctxno(t1->flags[y + 1][x + 1]);
1007 int r = ff_mqc_decode(&t1->mqc,
1008 t1->mqc.cx_states + ctxno)
1010 t1->data[y][x] += t1->data[y][x] < 0 ? -r : r;
1011 t1->flags[y + 1][x + 1] |= JPEG2000_T1_REF;
1015 static void decode_clnpass(Jpeg2000DecoderContext *s, Jpeg2000T1Context *t1,
1016 int width, int height, int bpno, int bandno,
1017 int seg_symbols, int vert_causal_ctx_csty_symbol)
1019 int mask = 3 << (bpno - 1), y0, x, y, runlen, dec;
1021 for (y0 = 0; y0 < height; y0 += 4) {
1022 for (x = 0; x < width; x++) {
1023 if (y0 + 3 < height &&
1024 !((t1->flags[y0 + 1][x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
1025 (t1->flags[y0 + 2][x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
1026 (t1->flags[y0 + 3][x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
1027 (t1->flags[y0 + 4][x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)))) {
1028 if (!ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_RL))
1030 runlen = ff_mqc_decode(&t1->mqc,
1031 t1->mqc.cx_states + MQC_CX_UNI);
1032 runlen = (runlen << 1) | ff_mqc_decode(&t1->mqc,
1041 for (y = y0 + runlen; y < y0 + 4 && y < height; y++) {
1043 if (!(t1->flags[y+1][x+1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS))) {
1044 int flags_mask = -1;
1045 if (vert_causal_ctx_csty_symbol && y == y0 + 3)
1046 flags_mask &= ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE);
1047 dec = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ff_jpeg2000_getsigctxno(t1->flags[y+1][x+1] & flags_mask,
1053 int ctxno = ff_jpeg2000_getsgnctxno(t1->flags[y + 1][x + 1],
1055 t1->data[y][x] = (ff_mqc_decode(&t1->mqc,
1056 t1->mqc.cx_states + ctxno) ^
1059 ff_jpeg2000_set_significance(t1, x, y, t1->data[y][x] < 0);
1062 t1->flags[y + 1][x + 1] &= ~JPEG2000_T1_VIS;
1068 val = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1069 val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1070 val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1071 val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1073 av_log(s->avctx, AV_LOG_ERROR,
1074 "Segmentation symbol value incorrect\n");
1078 static int decode_cblk(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *codsty,
1079 Jpeg2000T1Context *t1, Jpeg2000Cblk *cblk,
1080 int width, int height, int bandpos)
1082 int passno = cblk->npasses, pass_t = 2, bpno = cblk->nonzerobits - 1, y;
1083 int clnpass_cnt = 0;
1084 int bpass_csty_symbol = codsty->cblk_style & JPEG2000_CBLK_BYPASS;
1085 int vert_causal_ctx_csty_symbol = codsty->cblk_style & JPEG2000_CBLK_VSC;
1087 av_assert0(width <= JPEG2000_MAX_CBLKW);
1088 av_assert0(height <= JPEG2000_MAX_CBLKH);
1090 for (y = 0; y < height; y++)
1091 memset(t1->data[y], 0, width * sizeof(**t1->data));
1093 /* If code-block contains no compressed data: nothing to do. */
1097 for (y = 0; y < height + 2; y++)
1098 memset(t1->flags[y], 0, (width + 2) * sizeof(**t1->flags));
1100 cblk->data[cblk->length] = 0xff;
1101 cblk->data[cblk->length+1] = 0xff;
1102 ff_mqc_initdec(&t1->mqc, cblk->data);
1107 decode_sigpass(t1, width, height, bpno + 1, bandpos,
1108 bpass_csty_symbol && (clnpass_cnt >= 4),
1109 vert_causal_ctx_csty_symbol);
1112 decode_refpass(t1, width, height, bpno + 1);
1113 if (bpass_csty_symbol && clnpass_cnt >= 4)
1114 ff_mqc_initdec(&t1->mqc, cblk->data);
1117 decode_clnpass(s, t1, width, height, bpno + 1, bandpos,
1118 codsty->cblk_style & JPEG2000_CBLK_SEGSYM,
1119 vert_causal_ctx_csty_symbol);
1120 clnpass_cnt = clnpass_cnt + 1;
1121 if (bpass_csty_symbol && clnpass_cnt >= 4)
1122 ff_mqc_initdec(&t1->mqc, cblk->data);
1135 /* TODO: Verify dequantization for lossless case
1136 * comp->data can be float or int
1137 * band->stepsize can be float or int
1138 * depending on the type of DWT transformation.
1139 * see ISO/IEC 15444-1:2002 A.6.1 */
1141 /* Float dequantization of a codeblock.*/
1142 static void dequantization_float(int x, int y, Jpeg2000Cblk *cblk,
1143 Jpeg2000Component *comp,
1144 Jpeg2000T1Context *t1, Jpeg2000Band *band)
1147 int w = cblk->coord[0][1] - cblk->coord[0][0];
1148 for (j = 0; j < (cblk->coord[1][1] - cblk->coord[1][0]); ++j) {
1149 float *datap = &comp->f_data[(comp->coord[0][1] - comp->coord[0][0]) * (y + j) + x];
1150 int *src = t1->data[j];
1151 for (i = 0; i < w; ++i)
1152 datap[i] = src[i] * band->f_stepsize;
1156 /* Integer dequantization of a codeblock.*/
1157 static void dequantization_int(int x, int y, Jpeg2000Cblk *cblk,
1158 Jpeg2000Component *comp,
1159 Jpeg2000T1Context *t1, Jpeg2000Band *band)
1162 int w = cblk->coord[0][1] - cblk->coord[0][0];
1163 for (j = 0; j < (cblk->coord[1][1] - cblk->coord[1][0]); ++j) {
1164 int32_t *datap = &comp->i_data[(comp->coord[0][1] - comp->coord[0][0]) * (y + j) + x];
1165 int *src = t1->data[j];
1166 for (i = 0; i < w; ++i)
1167 datap[i] = (src[i] * band->i_stepsize) / 32768;
1171 static void dequantization_int_97(int x, int y, Jpeg2000Cblk *cblk,
1172 Jpeg2000Component *comp,
1173 Jpeg2000T1Context *t1, Jpeg2000Band *band)
1176 int w = cblk->coord[0][1] - cblk->coord[0][0];
1177 for (j = 0; j < (cblk->coord[1][1] - cblk->coord[1][0]); ++j) {
1178 int32_t *datap = &comp->i_data[(comp->coord[0][1] - comp->coord[0][0]) * (y + j) + x];
1179 int *src = t1->data[j];
1180 for (i = 0; i < w; ++i)
1181 datap[i] = (src[i] * band->i_stepsize + (1<<14)) >> 15;
1185 static inline void mct_decode(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
1190 for (i = 1; i < 3; i++) {
1191 if (tile->codsty[0].transform != tile->codsty[i].transform) {
1192 av_log(s->avctx, AV_LOG_ERROR, "Transforms mismatch, MCT not supported\n");
1195 if (memcmp(tile->comp[0].coord, tile->comp[i].coord, sizeof(tile->comp[0].coord))) {
1196 av_log(s->avctx, AV_LOG_ERROR, "Coords mismatch, MCT not supported\n");
1201 for (i = 0; i < 3; i++)
1202 if (tile->codsty[0].transform == FF_DWT97)
1203 src[i] = tile->comp[i].f_data;
1205 src[i] = tile->comp[i].i_data;
1207 for (i = 0; i < 2; i++)
1208 csize *= tile->comp[0].coord[i][1] - tile->comp[0].coord[i][0];
1210 s->dsp.mct_decode[tile->codsty[0].transform](src[0], src[1], src[2], csize);
1213 static int jpeg2000_decode_tile(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile,
1216 const AVPixFmtDescriptor *pixdesc = av_pix_fmt_desc_get(s->avctx->pix_fmt);
1217 int compno, reslevelno, bandno;
1219 int planar = !!(pixdesc->flags & AV_PIX_FMT_FLAG_PLANAR);
1220 int pixelsize = planar ? 1 : pixdesc->nb_components;
1223 Jpeg2000T1Context t1;
1225 /* Loop on tile components */
1226 for (compno = 0; compno < s->ncomponents; compno++) {
1227 Jpeg2000Component *comp = tile->comp + compno;
1228 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1230 /* Loop on resolution levels */
1231 for (reslevelno = 0; reslevelno < codsty->nreslevels2decode; reslevelno++) {
1232 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1234 for (bandno = 0; bandno < rlevel->nbands; bandno++) {
1235 int nb_precincts, precno;
1236 Jpeg2000Band *band = rlevel->band + bandno;
1237 int cblkno = 0, bandpos;
1239 bandpos = bandno + (reslevelno > 0);
1241 if (band->coord[0][0] == band->coord[0][1] ||
1242 band->coord[1][0] == band->coord[1][1])
1245 nb_precincts = rlevel->num_precincts_x * rlevel->num_precincts_y;
1246 /* Loop on precincts */
1247 for (precno = 0; precno < nb_precincts; precno++) {
1248 Jpeg2000Prec *prec = band->prec + precno;
1250 /* Loop on codeblocks */
1251 for (cblkno = 0; cblkno < prec->nb_codeblocks_width * prec->nb_codeblocks_height; cblkno++) {
1253 Jpeg2000Cblk *cblk = prec->cblk + cblkno;
1254 decode_cblk(s, codsty, &t1, cblk,
1255 cblk->coord[0][1] - cblk->coord[0][0],
1256 cblk->coord[1][1] - cblk->coord[1][0],
1259 x = cblk->coord[0][0];
1260 y = cblk->coord[1][0];
1262 if (codsty->transform == FF_DWT97)
1263 dequantization_float(x, y, cblk, comp, &t1, band);
1264 else if (codsty->transform == FF_DWT97_INT)
1265 dequantization_int_97(x, y, cblk, comp, &t1, band);
1267 dequantization_int(x, y, cblk, comp, &t1, band);
1271 } /* end reslevel */
1274 ff_dwt_decode(&comp->dwt, codsty->transform == FF_DWT97 ? (void*)comp->f_data : (void*)comp->i_data);
1277 /* inverse MCT transformation */
1278 if (tile->codsty[0].mct)
1279 mct_decode(s, tile);
1281 if (s->cdef[0] < 0) {
1282 for (x = 0; x < s->ncomponents; x++)
1284 if ((s->ncomponents & 1) == 0)
1285 s->cdef[s->ncomponents-1] = 0;
1288 if (s->precision <= 8) {
1289 for (compno = 0; compno < s->ncomponents; compno++) {
1290 Jpeg2000Component *comp = tile->comp + compno;
1291 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1292 float *datap = comp->f_data;
1293 int32_t *i_datap = comp->i_data;
1294 int cbps = s->cbps[compno];
1295 int w = tile->comp[compno].coord[0][1] - s->image_offset_x;
1299 plane = s->cdef[compno] ? s->cdef[compno]-1 : (s->ncomponents-1);
1302 y = tile->comp[compno].coord[1][0] - s->image_offset_y;
1303 line = picture->data[plane] + y / s->cdy[compno] * picture->linesize[plane];
1304 for (; y < tile->comp[compno].coord[1][1] - s->image_offset_y; y ++) {
1307 x = tile->comp[compno].coord[0][0] - s->image_offset_x;
1308 dst = line + x / s->cdx[compno] * pixelsize + compno*!planar;
1310 if (codsty->transform == FF_DWT97) {
1311 for (; x < w; x ++) {
1312 int val = lrintf(*datap) + (1 << (cbps - 1));
1313 /* DC level shift and clip see ISO 15444-1:2002 G.1.2 */
1314 val = av_clip(val, 0, (1 << cbps) - 1);
1315 *dst = val << (8 - cbps);
1320 for (; x < w; x ++) {
1321 int val = *i_datap + (1 << (cbps - 1));
1322 /* DC level shift and clip see ISO 15444-1:2002 G.1.2 */
1323 val = av_clip(val, 0, (1 << cbps) - 1);
1324 *dst = val << (8 - cbps);
1329 line += picture->linesize[plane];
1333 int precision = picture->format == AV_PIX_FMT_XYZ12 ||
1334 picture->format == AV_PIX_FMT_RGB48 ||
1335 picture->format == AV_PIX_FMT_RGBA64 ||
1336 picture->format == AV_PIX_FMT_GRAY16 ? 16 : s->precision;
1338 for (compno = 0; compno < s->ncomponents; compno++) {
1339 Jpeg2000Component *comp = tile->comp + compno;
1340 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1341 float *datap = comp->f_data;
1342 int32_t *i_datap = comp->i_data;
1344 int cbps = s->cbps[compno];
1345 int w = tile->comp[compno].coord[0][1] - s->image_offset_x;
1349 plane = s->cdef[compno] ? s->cdef[compno]-1 : (s->ncomponents-1);
1351 y = tile->comp[compno].coord[1][0] - s->image_offset_y;
1352 linel = (uint16_t *)picture->data[plane] + y / s->cdy[compno] * (picture->linesize[plane] >> 1);
1353 for (; y < tile->comp[compno].coord[1][1] - s->image_offset_y; y ++) {
1356 x = tile->comp[compno].coord[0][0] - s->image_offset_x;
1357 dst = linel + (x / s->cdx[compno] * pixelsize + compno*!planar);
1358 if (codsty->transform == FF_DWT97) {
1359 for (; x < w; x ++) {
1360 int val = lrintf(*datap) + (1 << (cbps - 1));
1361 /* DC level shift and clip see ISO 15444-1:2002 G.1.2 */
1362 val = av_clip(val, 0, (1 << cbps) - 1);
1363 /* align 12 bit values in little-endian mode */
1364 *dst = val << (precision - cbps);
1369 for (; x < w; x ++) {
1370 int val = *i_datap + (1 << (cbps - 1));
1371 /* DC level shift and clip see ISO 15444-1:2002 G.1.2 */
1372 val = av_clip(val, 0, (1 << cbps) - 1);
1373 /* align 12 bit values in little-endian mode */
1374 *dst = val << (precision - cbps);
1379 linel += picture->linesize[plane] >> 1;
1387 static void jpeg2000_dec_cleanup(Jpeg2000DecoderContext *s)
1390 for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++) {
1391 if (s->tile[tileno].comp) {
1392 for (compno = 0; compno < s->ncomponents; compno++) {
1393 Jpeg2000Component *comp = s->tile[tileno].comp + compno;
1394 Jpeg2000CodingStyle *codsty = s->tile[tileno].codsty + compno;
1396 ff_jpeg2000_cleanup(comp, codsty);
1398 av_freep(&s->tile[tileno].comp);
1402 memset(s->codsty, 0, sizeof(s->codsty));
1403 memset(s->qntsty, 0, sizeof(s->qntsty));
1404 s->numXtiles = s->numYtiles = 0;
1407 static int jpeg2000_read_main_headers(Jpeg2000DecoderContext *s)
1409 Jpeg2000CodingStyle *codsty = s->codsty;
1410 Jpeg2000QuantStyle *qntsty = s->qntsty;
1411 uint8_t *properties = s->properties;
1418 if (bytestream2_get_bytes_left(&s->g) < 2) {
1419 av_log(s->avctx, AV_LOG_ERROR, "Missing EOC\n");
1423 marker = bytestream2_get_be16u(&s->g);
1424 oldpos = bytestream2_tell(&s->g);
1426 if (marker == JPEG2000_SOD) {
1428 Jpeg2000TilePart *tp;
1431 av_log(s->avctx, AV_LOG_ERROR, "Missing SIZ\n");
1432 return AVERROR_INVALIDDATA;
1434 if (s->curtileno < 0) {
1435 av_log(s->avctx, AV_LOG_ERROR, "Missing SOT\n");
1436 return AVERROR_INVALIDDATA;
1439 tile = s->tile + s->curtileno;
1440 tp = tile->tile_part + tile->tp_idx;
1441 if (tp->tp_end < s->g.buffer) {
1442 av_log(s->avctx, AV_LOG_ERROR, "Invalid tpend\n");
1443 return AVERROR_INVALIDDATA;
1445 bytestream2_init(&tp->tpg, s->g.buffer, tp->tp_end - s->g.buffer);
1446 bytestream2_skip(&s->g, tp->tp_end - s->g.buffer);
1450 if (marker == JPEG2000_EOC)
1453 len = bytestream2_get_be16(&s->g);
1454 if (len < 2 || bytestream2_get_bytes_left(&s->g) < len - 2)
1455 return AVERROR_INVALIDDATA;
1461 s->numXtiles = s->numYtiles = 0;
1464 ret = get_coc(s, codsty, properties);
1467 ret = get_cod(s, codsty, properties);
1470 ret = get_qcc(s, len, qntsty, properties);
1473 ret = get_qcd(s, len, qntsty, properties);
1476 if (!(ret = get_sot(s, len))) {
1477 av_assert1(s->curtileno >= 0);
1478 codsty = s->tile[s->curtileno].codsty;
1479 qntsty = s->tile[s->curtileno].qntsty;
1480 properties = s->tile[s->curtileno].properties;
1484 // the comment is ignored
1485 bytestream2_skip(&s->g, len - 2);
1488 // Tile-part lengths
1489 ret = get_tlm(s, len);
1492 // Packet length, tile-part header
1493 ret = get_plt(s, len);
1496 av_log(s->avctx, AV_LOG_ERROR,
1497 "unsupported marker 0x%.4"PRIX16" at pos 0x%X\n",
1498 marker, bytestream2_tell(&s->g) - 4);
1499 bytestream2_skip(&s->g, len - 2);
1502 if (bytestream2_tell(&s->g) - oldpos != len || ret) {
1503 av_log(s->avctx, AV_LOG_ERROR,
1504 "error during processing marker segment %.4"PRIx16"\n",
1506 return ret ? ret : -1;
1512 /* Read bit stream packets --> T2 operation. */
1513 static int jpeg2000_read_bitstream_packets(Jpeg2000DecoderContext *s)
1518 for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++) {
1519 Jpeg2000Tile *tile = s->tile + tileno;
1521 if (ret = init_tile(s, tileno))
1524 s->g = tile->tile_part[0].tpg;
1525 if (ret = jpeg2000_decode_packets(s, tile))
1532 static int jp2_find_codestream(Jpeg2000DecoderContext *s)
1534 uint32_t atom_size, atom, atom_end;
1535 int search_range = 10;
1539 bytestream2_get_bytes_left(&s->g) >= 8) {
1540 atom_size = bytestream2_get_be32u(&s->g);
1541 atom = bytestream2_get_be32u(&s->g);
1542 atom_end = bytestream2_tell(&s->g) + atom_size - 8;
1544 if (atom == JP2_CODESTREAM)
1547 if (bytestream2_get_bytes_left(&s->g) < atom_size || atom_end < atom_size)
1550 if (atom == JP2_HEADER &&
1552 uint32_t atom2_size, atom2, atom2_end;
1554 atom2_size = bytestream2_get_be32u(&s->g);
1555 atom2 = bytestream2_get_be32u(&s->g);
1556 atom2_end = bytestream2_tell(&s->g) + atom2_size - 8;
1557 if (atom2_size < 8 || atom2_end > atom_end || atom2_end < atom2_size)
1559 if (atom2 == JP2_CODESTREAM) {
1561 } else if (atom2 == MKBETAG('c','o','l','r') && atom2_size >= 7) {
1562 int method = bytestream2_get_byteu(&s->g);
1563 bytestream2_skipu(&s->g, 2);
1565 s->colour_space = bytestream2_get_be32u(&s->g);
1567 } else if (atom2 == MKBETAG('p','c','l','r') && atom2_size >= 6) {
1568 int i, size, colour_count, colour_channels, colour_depth[3];
1570 colour_count = bytestream2_get_be16u(&s->g);
1571 colour_channels = bytestream2_get_byteu(&s->g);
1572 // FIXME: Do not ignore channel_sign
1573 colour_depth[0] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1;
1574 colour_depth[1] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1;
1575 colour_depth[2] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1;
1576 size = (colour_depth[0] + 7 >> 3) * colour_count +
1577 (colour_depth[1] + 7 >> 3) * colour_count +
1578 (colour_depth[2] + 7 >> 3) * colour_count;
1579 if (colour_count > 256 ||
1580 colour_channels != 3 ||
1581 colour_depth[0] > 16 ||
1582 colour_depth[1] > 16 ||
1583 colour_depth[2] > 16 ||
1584 atom2_size < size) {
1585 avpriv_request_sample(s->avctx, "Unknown palette");
1586 bytestream2_seek(&s->g, atom2_end, SEEK_SET);
1590 for (i = 0; i < colour_count; i++) {
1591 if (colour_depth[0] <= 8) {
1592 r = bytestream2_get_byteu(&s->g) << 8 - colour_depth[0];
1593 r |= r >> colour_depth[0];
1595 r = bytestream2_get_be16u(&s->g) >> colour_depth[0] - 8;
1597 if (colour_depth[1] <= 8) {
1598 g = bytestream2_get_byteu(&s->g) << 8 - colour_depth[1];
1599 r |= r >> colour_depth[1];
1601 g = bytestream2_get_be16u(&s->g) >> colour_depth[1] - 8;
1603 if (colour_depth[2] <= 8) {
1604 b = bytestream2_get_byteu(&s->g) << 8 - colour_depth[2];
1605 r |= r >> colour_depth[2];
1607 b = bytestream2_get_be16u(&s->g) >> colour_depth[2] - 8;
1609 s->palette[i] = 0xffu << 24 | r << 16 | g << 8 | b;
1611 } else if (atom2 == MKBETAG('c','d','e','f') && atom2_size >= 2) {
1612 int n = bytestream2_get_be16u(&s->g);
1614 int cn = bytestream2_get_be16(&s->g);
1615 int av_unused typ = bytestream2_get_be16(&s->g);
1616 int asoc = bytestream2_get_be16(&s->g);
1617 if (cn < 4 && asoc < 4)
1621 bytestream2_seek(&s->g, atom2_end, SEEK_SET);
1622 } while (atom_end - atom2_end >= 8);
1626 bytestream2_seek(&s->g, atom_end, SEEK_SET);
1632 static av_cold int jpeg2000_decode_init(AVCodecContext *avctx)
1634 Jpeg2000DecoderContext *s = avctx->priv_data;
1636 ff_jpeg2000dsp_init(&s->dsp);
1641 static int jpeg2000_decode_frame(AVCodecContext *avctx, void *data,
1642 int *got_frame, AVPacket *avpkt)
1644 Jpeg2000DecoderContext *s = avctx->priv_data;
1645 ThreadFrame frame = { .f = data };
1646 AVFrame *picture = data;
1650 bytestream2_init(&s->g, avpkt->data, avpkt->size);
1652 memset(s->cdef, -1, sizeof(s->cdef));
1654 if (bytestream2_get_bytes_left(&s->g) < 2) {
1655 ret = AVERROR_INVALIDDATA;
1659 // check if the image is in jp2 format
1660 if (bytestream2_get_bytes_left(&s->g) >= 12 &&
1661 (bytestream2_get_be32u(&s->g) == 12) &&
1662 (bytestream2_get_be32u(&s->g) == JP2_SIG_TYPE) &&
1663 (bytestream2_get_be32u(&s->g) == JP2_SIG_VALUE)) {
1664 if (!jp2_find_codestream(s)) {
1665 av_log(avctx, AV_LOG_ERROR,
1666 "Could not find Jpeg2000 codestream atom.\n");
1667 ret = AVERROR_INVALIDDATA;
1671 bytestream2_seek(&s->g, 0, SEEK_SET);
1674 while (bytestream2_get_bytes_left(&s->g) >= 3 && bytestream2_peek_be16(&s->g) != JPEG2000_SOC)
1675 bytestream2_skip(&s->g, 1);
1677 if (bytestream2_get_be16u(&s->g) != JPEG2000_SOC) {
1678 av_log(avctx, AV_LOG_ERROR, "SOC marker not present\n");
1679 ret = AVERROR_INVALIDDATA;
1682 if (ret = jpeg2000_read_main_headers(s))
1685 /* get picture buffer */
1686 if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
1688 picture->pict_type = AV_PICTURE_TYPE_I;
1689 picture->key_frame = 1;
1691 if (ret = jpeg2000_read_bitstream_packets(s))
1694 for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++)
1695 if (ret = jpeg2000_decode_tile(s, s->tile + tileno, picture))
1698 jpeg2000_dec_cleanup(s);
1702 if (s->avctx->pix_fmt == AV_PIX_FMT_PAL8)
1703 memcpy(picture->data[1], s->palette, 256 * sizeof(uint32_t));
1705 return bytestream2_tell(&s->g);
1708 jpeg2000_dec_cleanup(s);
1712 static av_cold void jpeg2000_init_static_data(AVCodec *codec)
1714 ff_jpeg2000_init_tier1_luts();
1715 ff_mqc_init_context_tables();
1718 #define OFFSET(x) offsetof(Jpeg2000DecoderContext, x)
1719 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
1721 static const AVOption options[] = {
1722 { "lowres", "Lower the decoding resolution by a power of two",
1723 OFFSET(reduction_factor), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, JPEG2000_MAX_RESLEVELS - 1, VD },
1727 static const AVProfile profiles[] = {
1728 { FF_PROFILE_JPEG2000_CSTREAM_RESTRICTION_0, "JPEG 2000 codestream restriction 0" },
1729 { FF_PROFILE_JPEG2000_CSTREAM_RESTRICTION_1, "JPEG 2000 codestream restriction 1" },
1730 { FF_PROFILE_JPEG2000_CSTREAM_NO_RESTRICTION, "JPEG 2000 no codestream restrictions" },
1731 { FF_PROFILE_JPEG2000_DCINEMA_2K, "JPEG 2000 digital cinema 2K" },
1732 { FF_PROFILE_JPEG2000_DCINEMA_4K, "JPEG 2000 digital cinema 4K" },
1733 { FF_PROFILE_UNKNOWN },
1736 static const AVClass jpeg2000_class = {
1737 .class_name = "jpeg2000",
1738 .item_name = av_default_item_name,
1740 .version = LIBAVUTIL_VERSION_INT,
1743 AVCodec ff_jpeg2000_decoder = {
1745 .long_name = NULL_IF_CONFIG_SMALL("JPEG 2000"),
1746 .type = AVMEDIA_TYPE_VIDEO,
1747 .id = AV_CODEC_ID_JPEG2000,
1748 .capabilities = CODEC_CAP_FRAME_THREADS,
1749 .priv_data_size = sizeof(Jpeg2000DecoderContext),
1750 .init_static_data = jpeg2000_init_static_data,
1751 .init = jpeg2000_decode_init,
1752 .decode = jpeg2000_decode_frame,
1753 .priv_class = &jpeg2000_class,
1755 .profiles = NULL_IF_CONFIG_SMALL(profiles)