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
28 #include "libavutil/avassert.h"
29 #include "libavutil/common.h"
30 #include "libavutil/opt.h"
31 #include "libavutil/pixdesc.h"
33 #include "bytestream.h"
38 #define JP2_SIG_TYPE 0x6A502020
39 #define JP2_SIG_VALUE 0x0D0A870A
40 #define JP2_CODESTREAM 0x6A703263
41 #define JP2_HEADER 0x6A703268
46 typedef struct Jpeg2000TilePart {
47 uint8_t tile_index; // Tile index who refers the tile-part
48 const uint8_t *tp_end;
49 GetByteContext tpg; // bit stream in tile-part
52 /* RMK: For JPEG2000 DCINEMA 3 tile-parts in a tile
53 * one per component, so tile_part elements have a size of 3 */
54 typedef struct Jpeg2000Tile {
55 Jpeg2000Component *comp;
56 uint8_t properties[4];
57 Jpeg2000CodingStyle codsty[4];
58 Jpeg2000QuantStyle qntsty[4];
59 Jpeg2000TilePart tile_part[4];
60 uint16_t tp_idx; // Tile-part index
63 typedef struct Jpeg2000DecoderContext {
65 AVCodecContext *avctx;
69 int image_offset_x, image_offset_y;
70 int tile_offset_x, tile_offset_y;
71 uint8_t cbps[4]; // bits per sample in particular components
72 uint8_t sgnd[4]; // if a component is signed
73 uint8_t properties[4];
78 uint32_t palette[256];
81 int tile_width, tile_height;
82 unsigned numXtiles, numYtiles;
85 Jpeg2000CodingStyle codsty[4];
86 Jpeg2000QuantStyle qntsty[4];
94 /*options parameters*/
96 } Jpeg2000DecoderContext;
98 /* get_bits functions for JPEG2000 packet bitstream
99 * It is a get_bit function with a bit-stuffing routine. If the value of the
100 * byte is 0xFF, the next byte includes an extra zero bit stuffed into the MSB.
101 * cf. ISO-15444-1:2002 / B.10.1 Bit-stuffing routine */
102 static int get_bits(Jpeg2000DecoderContext *s, int n)
108 if (s->bit_index == 0) {
109 s->bit_index = 7 + (bytestream2_get_byte(&s->g) != 0xFFu);
112 res |= (bytestream2_peek_byte(&s->g) >> s->bit_index) & 1;
117 static void jpeg2000_flush(Jpeg2000DecoderContext *s)
119 if (bytestream2_get_byte(&s->g) == 0xff)
120 bytestream2_skip(&s->g, 1);
124 /* decode the value stored in node */
125 static int tag_tree_decode(Jpeg2000DecoderContext *s, Jpeg2000TgtNode *node,
128 Jpeg2000TgtNode *stack[30];
129 int sp = -1, curval = 0;
132 return AVERROR_INVALIDDATA;
134 while (node && !node->vis) {
142 curval = stack[sp]->val;
144 while (curval < threshold && sp >= 0) {
145 if (curval < stack[sp]->val)
146 curval = stack[sp]->val;
147 while (curval < threshold) {
149 if ((ret = get_bits(s, 1)) > 0) {
157 stack[sp]->val = curval;
163 static int pix_fmt_match(enum AVPixelFormat pix_fmt, int components,
164 int bpc, uint32_t log2_chroma_wh, int pal8)
167 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
169 if (desc->nb_components != components) {
173 switch (components) {
175 match = match && desc->comp[3].depth_minus1 + 1 >= bpc &&
176 (log2_chroma_wh >> 14 & 3) == 0 &&
177 (log2_chroma_wh >> 12 & 3) == 0;
179 match = match && desc->comp[2].depth_minus1 + 1 >= bpc &&
180 (log2_chroma_wh >> 10 & 3) == desc->log2_chroma_w &&
181 (log2_chroma_wh >> 8 & 3) == desc->log2_chroma_h;
183 match = match && desc->comp[1].depth_minus1 + 1 >= bpc &&
184 (log2_chroma_wh >> 6 & 3) == desc->log2_chroma_w &&
185 (log2_chroma_wh >> 4 & 3) == desc->log2_chroma_h;
188 match = match && desc->comp[0].depth_minus1 + 1 >= bpc &&
189 (log2_chroma_wh >> 2 & 3) == 0 &&
190 (log2_chroma_wh & 3) == 0 &&
191 (desc->flags & AV_PIX_FMT_FLAG_PAL) == pal8 * AV_PIX_FMT_FLAG_PAL;
196 // pix_fmts with lower bpp have to be listed before
197 // similar pix_fmts with higher bpp.
198 #define RGB_PIXEL_FORMATS AV_PIX_FMT_PAL8,AV_PIX_FMT_RGB24,AV_PIX_FMT_RGBA,AV_PIX_FMT_RGB48,AV_PIX_FMT_RGBA64
199 #define GRAY_PIXEL_FORMATS AV_PIX_FMT_GRAY8,AV_PIX_FMT_GRAY8A,AV_PIX_FMT_GRAY16
200 #define YUV_PIXEL_FORMATS AV_PIX_FMT_YUV410P,AV_PIX_FMT_YUV411P,AV_PIX_FMT_YUVA420P, \
201 AV_PIX_FMT_YUV420P,AV_PIX_FMT_YUV422P,AV_PIX_FMT_YUVA422P, \
202 AV_PIX_FMT_YUV440P,AV_PIX_FMT_YUV444P,AV_PIX_FMT_YUVA444P, \
203 AV_PIX_FMT_YUV420P9,AV_PIX_FMT_YUV422P9,AV_PIX_FMT_YUV444P9, \
204 AV_PIX_FMT_YUVA420P9,AV_PIX_FMT_YUVA422P9,AV_PIX_FMT_YUVA444P9, \
205 AV_PIX_FMT_YUV420P10,AV_PIX_FMT_YUV422P10,AV_PIX_FMT_YUV444P10, \
206 AV_PIX_FMT_YUVA420P10,AV_PIX_FMT_YUVA422P10,AV_PIX_FMT_YUVA444P10, \
207 AV_PIX_FMT_YUV420P12,AV_PIX_FMT_YUV422P12,AV_PIX_FMT_YUV444P12, \
208 AV_PIX_FMT_YUV420P14,AV_PIX_FMT_YUV422P14,AV_PIX_FMT_YUV444P14, \
209 AV_PIX_FMT_YUV420P16,AV_PIX_FMT_YUV422P16,AV_PIX_FMT_YUV444P16, \
210 AV_PIX_FMT_YUVA420P16,AV_PIX_FMT_YUVA422P16,AV_PIX_FMT_YUVA444P16
211 #define XYZ_PIXEL_FORMATS AV_PIX_FMT_XYZ12
213 static const enum AVPixelFormat rgb_pix_fmts[] = {RGB_PIXEL_FORMATS};
214 static const enum AVPixelFormat gray_pix_fmts[] = {GRAY_PIXEL_FORMATS};
215 static const enum AVPixelFormat yuv_pix_fmts[] = {YUV_PIXEL_FORMATS};
216 static const enum AVPixelFormat xyz_pix_fmts[] = {XYZ_PIXEL_FORMATS};
217 static const enum AVPixelFormat all_pix_fmts[] = {RGB_PIXEL_FORMATS,
222 /* marker segments */
223 /* get sizes and offsets of image, tiles; number of components */
224 static int get_siz(Jpeg2000DecoderContext *s)
228 uint32_t log2_chroma_wh = 0;
229 const enum AVPixelFormat *possible_fmts = NULL;
230 int possible_fmts_nb = 0;
232 if (bytestream2_get_bytes_left(&s->g) < 36)
233 return AVERROR_INVALIDDATA;
235 s->avctx->profile = bytestream2_get_be16u(&s->g); // Rsiz
236 s->width = bytestream2_get_be32u(&s->g); // Width
237 s->height = bytestream2_get_be32u(&s->g); // Height
238 s->image_offset_x = bytestream2_get_be32u(&s->g); // X0Siz
239 s->image_offset_y = bytestream2_get_be32u(&s->g); // Y0Siz
240 s->tile_width = bytestream2_get_be32u(&s->g); // XTSiz
241 s->tile_height = bytestream2_get_be32u(&s->g); // YTSiz
242 s->tile_offset_x = bytestream2_get_be32u(&s->g); // XT0Siz
243 s->tile_offset_y = bytestream2_get_be32u(&s->g); // YT0Siz
244 ncomponents = bytestream2_get_be16u(&s->g); // CSiz
246 if (s->image_offset_x || s->image_offset_y) {
247 avpriv_request_sample(s->avctx, "Support for image offsets");
248 return AVERROR_PATCHWELCOME;
251 if (ncomponents <= 0) {
252 av_log(s->avctx, AV_LOG_ERROR, "Invalid number of components: %d\n",
254 return AVERROR_INVALIDDATA;
257 if (ncomponents > 4) {
258 avpriv_request_sample(s->avctx, "Support for %d components",
260 return AVERROR_PATCHWELCOME;
263 s->ncomponents = ncomponents;
265 if (s->tile_width <= 0 || s->tile_height <= 0) {
266 av_log(s->avctx, AV_LOG_ERROR, "Invalid tile dimension %dx%d.\n",
267 s->tile_width, s->tile_height);
268 return AVERROR_INVALIDDATA;
271 if (bytestream2_get_bytes_left(&s->g) < 3 * s->ncomponents)
272 return AVERROR_INVALIDDATA;
274 for (i = 0; i < s->ncomponents; i++) { // Ssiz_i XRsiz_i, YRsiz_i
275 uint8_t x = bytestream2_get_byteu(&s->g);
276 s->cbps[i] = (x & 0x7f) + 1;
277 s->precision = FFMAX(s->cbps[i], s->precision);
278 s->sgnd[i] = !!(x & 0x80);
279 s->cdx[i] = bytestream2_get_byteu(&s->g);
280 s->cdy[i] = bytestream2_get_byteu(&s->g);
281 if ( !s->cdx[i] || s->cdx[i] == 3 || s->cdx[i] > 4
282 || !s->cdy[i] || s->cdy[i] == 3 || s->cdy[i] > 4) {
283 av_log(s->avctx, AV_LOG_ERROR, "Invalid sample separation %d/%d\n", s->cdx[i], s->cdy[i]);
284 return AVERROR_INVALIDDATA;
286 log2_chroma_wh |= s->cdy[i] >> 1 << i * 4 | s->cdx[i] >> 1 << i * 4 + 2;
289 s->numXtiles = ff_jpeg2000_ceildiv(s->width - s->tile_offset_x, s->tile_width);
290 s->numYtiles = ff_jpeg2000_ceildiv(s->height - s->tile_offset_y, s->tile_height);
292 if (s->numXtiles * (uint64_t)s->numYtiles > INT_MAX/sizeof(*s->tile)) {
293 s->numXtiles = s->numYtiles = 0;
294 return AVERROR(EINVAL);
297 s->tile = av_mallocz_array(s->numXtiles * s->numYtiles, sizeof(*s->tile));
299 s->numXtiles = s->numYtiles = 0;
300 return AVERROR(ENOMEM);
303 for (i = 0; i < s->numXtiles * s->numYtiles; i++) {
304 Jpeg2000Tile *tile = s->tile + i;
306 tile->comp = av_mallocz(s->ncomponents * sizeof(*tile->comp));
308 return AVERROR(ENOMEM);
311 /* compute image size with reduction factor */
312 s->avctx->width = ff_jpeg2000_ceildivpow2(s->width - s->image_offset_x,
313 s->reduction_factor);
314 s->avctx->height = ff_jpeg2000_ceildivpow2(s->height - s->image_offset_y,
315 s->reduction_factor);
317 if (s->avctx->profile == FF_PROFILE_JPEG2000_DCINEMA_2K ||
318 s->avctx->profile == FF_PROFILE_JPEG2000_DCINEMA_4K) {
319 possible_fmts = xyz_pix_fmts;
320 possible_fmts_nb = FF_ARRAY_ELEMS(xyz_pix_fmts);
322 switch (s->colour_space) {
324 possible_fmts = rgb_pix_fmts;
325 possible_fmts_nb = FF_ARRAY_ELEMS(rgb_pix_fmts);
328 possible_fmts = gray_pix_fmts;
329 possible_fmts_nb = FF_ARRAY_ELEMS(gray_pix_fmts);
332 possible_fmts = yuv_pix_fmts;
333 possible_fmts_nb = FF_ARRAY_ELEMS(yuv_pix_fmts);
336 possible_fmts = all_pix_fmts;
337 possible_fmts_nb = FF_ARRAY_ELEMS(all_pix_fmts);
341 for (i = 0; i < possible_fmts_nb; ++i) {
342 if (pix_fmt_match(possible_fmts[i], ncomponents, s->precision, log2_chroma_wh, s->pal8)) {
343 s->avctx->pix_fmt = possible_fmts[i];
347 if (i == possible_fmts_nb) {
348 av_log(s->avctx, AV_LOG_ERROR,
349 "Unknown pix_fmt, profile: %d, colour_space: %d, "
350 "components: %d, precision: %d, "
351 "cdx[1]: %d, cdy[1]: %d, cdx[2]: %d, cdy[2]: %d\n",
352 s->avctx->profile, s->colour_space, ncomponents, s->precision,
353 ncomponents > 2 ? s->cdx[1] : 0,
354 ncomponents > 2 ? s->cdy[1] : 0,
355 ncomponents > 2 ? s->cdx[2] : 0,
356 ncomponents > 2 ? s->cdy[2] : 0);
357 return AVERROR_PATCHWELCOME;
359 s->avctx->bits_per_raw_sample = s->precision;
363 /* get common part for COD and COC segments */
364 static int get_cox(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c)
368 if (bytestream2_get_bytes_left(&s->g) < 5)
369 return AVERROR_INVALIDDATA;
371 /* nreslevels = number of resolution levels
372 = number of decomposition level +1 */
373 c->nreslevels = bytestream2_get_byteu(&s->g) + 1;
374 if (c->nreslevels >= JPEG2000_MAX_RESLEVELS) {
375 av_log(s->avctx, AV_LOG_ERROR, "nreslevels %d is invalid\n", c->nreslevels);
376 return AVERROR_INVALIDDATA;
379 if (c->nreslevels <= s->reduction_factor) {
380 /* we are forced to update reduction_factor as its requested value is
381 not compatible with this bitstream, and as we might have used it
382 already in setup earlier we have to fail this frame until
383 reinitialization is implemented */
384 av_log(s->avctx, AV_LOG_ERROR, "reduction_factor too large for this bitstream, max is %d\n", c->nreslevels - 1);
385 s->reduction_factor = c->nreslevels - 1;
386 return AVERROR(EINVAL);
389 /* compute number of resolution levels to decode */
390 c->nreslevels2decode = c->nreslevels - s->reduction_factor;
392 c->log2_cblk_width = (bytestream2_get_byteu(&s->g) & 15) + 2; // cblk width
393 c->log2_cblk_height = (bytestream2_get_byteu(&s->g) & 15) + 2; // cblk height
395 if (c->log2_cblk_width > 10 || c->log2_cblk_height > 10 ||
396 c->log2_cblk_width + c->log2_cblk_height > 12) {
397 av_log(s->avctx, AV_LOG_ERROR, "cblk size invalid\n");
398 return AVERROR_INVALIDDATA;
401 if (c->log2_cblk_width > 6 || c->log2_cblk_height > 6) {
402 avpriv_request_sample(s->avctx, "cblk size > 64");
403 return AVERROR_PATCHWELCOME;
406 c->cblk_style = bytestream2_get_byteu(&s->g);
407 if (c->cblk_style != 0) { // cblk style
408 av_log(s->avctx, AV_LOG_WARNING, "extra cblk styles %X\n", c->cblk_style);
410 c->transform = bytestream2_get_byteu(&s->g); // DWT transformation type
411 /* set integer 9/7 DWT in case of BITEXACT flag */
412 if ((s->avctx->flags & CODEC_FLAG_BITEXACT) && (c->transform == FF_DWT97))
413 c->transform = FF_DWT97_INT;
415 if (c->csty & JPEG2000_CSTY_PREC) {
417 for (i = 0; i < c->nreslevels; i++) {
418 byte = bytestream2_get_byte(&s->g);
419 c->log2_prec_widths[i] = byte & 0x0F; // precinct PPx
420 c->log2_prec_heights[i] = (byte >> 4) & 0x0F; // precinct PPy
423 memset(c->log2_prec_widths , 15, sizeof(c->log2_prec_widths ));
424 memset(c->log2_prec_heights, 15, sizeof(c->log2_prec_heights));
429 /* get coding parameters for a particular tile or whole image*/
430 static int get_cod(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c,
433 Jpeg2000CodingStyle tmp;
436 if (bytestream2_get_bytes_left(&s->g) < 5)
437 return AVERROR_INVALIDDATA;
439 tmp.csty = bytestream2_get_byteu(&s->g);
441 // get progression order
442 tmp.prog_order = bytestream2_get_byteu(&s->g);
444 tmp.nlayers = bytestream2_get_be16u(&s->g);
445 tmp.mct = bytestream2_get_byteu(&s->g); // multiple component transformation
447 if (tmp.mct && s->ncomponents < 3) {
448 av_log(s->avctx, AV_LOG_ERROR,
449 "MCT %d with too few components (%d)\n",
450 tmp.mct, s->ncomponents);
451 return AVERROR_INVALIDDATA;
454 if ((ret = get_cox(s, &tmp)) < 0)
457 for (compno = 0; compno < s->ncomponents; compno++)
458 if (!(properties[compno] & HAD_COC))
459 memcpy(c + compno, &tmp, sizeof(tmp));
463 /* Get coding parameters for a component in the whole image or a
464 * particular tile. */
465 static int get_coc(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c,
470 if (bytestream2_get_bytes_left(&s->g) < 2)
471 return AVERROR_INVALIDDATA;
473 compno = bytestream2_get_byteu(&s->g);
475 if (compno >= s->ncomponents) {
476 av_log(s->avctx, AV_LOG_ERROR,
477 "Invalid compno %d. There are %d components in the image.\n",
478 compno, s->ncomponents);
479 return AVERROR_INVALIDDATA;
483 c->csty = bytestream2_get_byteu(&s->g);
485 if ((ret = get_cox(s, c)) < 0)
488 properties[compno] |= HAD_COC;
492 /* Get common part for QCD and QCC segments. */
493 static int get_qcx(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q)
497 if (bytestream2_get_bytes_left(&s->g) < 1)
498 return AVERROR_INVALIDDATA;
500 x = bytestream2_get_byteu(&s->g); // Sqcd
502 q->nguardbits = x >> 5;
503 q->quantsty = x & 0x1f;
505 if (q->quantsty == JPEG2000_QSTY_NONE) {
507 if (bytestream2_get_bytes_left(&s->g) < n ||
508 n > JPEG2000_MAX_DECLEVELS*3)
509 return AVERROR_INVALIDDATA;
510 for (i = 0; i < n; i++)
511 q->expn[i] = bytestream2_get_byteu(&s->g) >> 3;
512 } else if (q->quantsty == JPEG2000_QSTY_SI) {
513 if (bytestream2_get_bytes_left(&s->g) < 2)
514 return AVERROR_INVALIDDATA;
515 x = bytestream2_get_be16u(&s->g);
516 q->expn[0] = x >> 11;
517 q->mant[0] = x & 0x7ff;
518 for (i = 1; i < JPEG2000_MAX_DECLEVELS * 3; i++) {
519 int curexpn = FFMAX(0, q->expn[0] - (i - 1) / 3);
520 q->expn[i] = curexpn;
521 q->mant[i] = q->mant[0];
525 if (bytestream2_get_bytes_left(&s->g) < 2 * n ||
526 n > JPEG2000_MAX_DECLEVELS*3)
527 return AVERROR_INVALIDDATA;
528 for (i = 0; i < n; i++) {
529 x = bytestream2_get_be16u(&s->g);
530 q->expn[i] = x >> 11;
531 q->mant[i] = x & 0x7ff;
537 /* Get quantization parameters for a particular tile or a whole image. */
538 static int get_qcd(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q,
541 Jpeg2000QuantStyle tmp;
544 memset(&tmp, 0, sizeof(tmp));
546 if ((ret = get_qcx(s, n, &tmp)) < 0)
548 for (compno = 0; compno < s->ncomponents; compno++)
549 if (!(properties[compno] & HAD_QCC))
550 memcpy(q + compno, &tmp, sizeof(tmp));
554 /* Get quantization parameters for a component in the whole image
555 * on in a particular tile. */
556 static int get_qcc(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q,
561 if (bytestream2_get_bytes_left(&s->g) < 1)
562 return AVERROR_INVALIDDATA;
564 compno = bytestream2_get_byteu(&s->g);
566 if (compno >= s->ncomponents) {
567 av_log(s->avctx, AV_LOG_ERROR,
568 "Invalid compno %d. There are %d components in the image.\n",
569 compno, s->ncomponents);
570 return AVERROR_INVALIDDATA;
573 properties[compno] |= HAD_QCC;
574 return get_qcx(s, n - 1, q + compno);
577 /* Get start of tile segment. */
578 static int get_sot(Jpeg2000DecoderContext *s, int n)
580 Jpeg2000TilePart *tp;
585 if (bytestream2_get_bytes_left(&s->g) < 8)
586 return AVERROR_INVALIDDATA;
589 Isot = bytestream2_get_be16u(&s->g); // Isot
590 if (Isot >= s->numXtiles * s->numYtiles)
591 return AVERROR_INVALIDDATA;
594 Psot = bytestream2_get_be32u(&s->g); // Psot
595 TPsot = bytestream2_get_byteu(&s->g); // TPsot
597 /* Read TNSot but not used */
598 bytestream2_get_byteu(&s->g); // TNsot
600 if (Psot > bytestream2_get_bytes_left(&s->g) + n + 2) {
601 av_log(s->avctx, AV_LOG_ERROR, "Psot %d too big\n", Psot);
602 return AVERROR_INVALIDDATA;
605 if (TPsot >= FF_ARRAY_ELEMS(s->tile[Isot].tile_part)) {
606 avpriv_request_sample(s->avctx, "Support for %d components", TPsot);
607 return AVERROR_PATCHWELCOME;
610 s->tile[Isot].tp_idx = TPsot;
611 tp = s->tile[Isot].tile_part + TPsot;
612 tp->tile_index = Isot;
613 tp->tp_end = s->g.buffer + Psot - n - 2;
616 Jpeg2000Tile *tile = s->tile + s->curtileno;
619 memcpy(tile->codsty, s->codsty, s->ncomponents * sizeof(Jpeg2000CodingStyle));
620 memcpy(tile->qntsty, s->qntsty, s->ncomponents * sizeof(Jpeg2000QuantStyle));
626 /* Tile-part lengths: see ISO 15444-1:2002, section A.7.1
627 * Used to know the number of tile parts and lengths.
628 * There may be multiple TLMs in the header.
629 * TODO: The function is not used for tile-parts management, nor anywhere else.
630 * It can be useful to allocate memory for tile parts, before managing the SOT
631 * markers. Parsing the TLM header is needed to increment the input header
633 * This marker is mandatory for DCI. */
634 static uint8_t get_tlm(Jpeg2000DecoderContext *s, int n)
636 uint8_t Stlm, ST, SP, tile_tlm, i;
637 bytestream2_get_byte(&s->g); /* Ztlm: skipped */
638 Stlm = bytestream2_get_byte(&s->g);
640 // too complex ? ST = ((Stlm >> 4) & 0x01) + ((Stlm >> 4) & 0x02);
641 ST = (Stlm >> 4) & 0x03;
642 // TODO: Manage case of ST = 0b11 --> raise error
643 SP = (Stlm >> 6) & 0x01;
644 tile_tlm = (n - 4) / ((SP + 1) * 2 + ST);
645 for (i = 0; i < tile_tlm; i++) {
650 bytestream2_get_byte(&s->g);
653 bytestream2_get_be16(&s->g);
656 bytestream2_get_be32(&s->g);
660 bytestream2_get_be16(&s->g);
662 bytestream2_get_be32(&s->g);
668 static int init_tile(Jpeg2000DecoderContext *s, int tileno)
671 int tilex = tileno % s->numXtiles;
672 int tiley = tileno / s->numXtiles;
673 Jpeg2000Tile *tile = s->tile + tileno;
676 return AVERROR(ENOMEM);
678 for (compno = 0; compno < s->ncomponents; compno++) {
679 Jpeg2000Component *comp = tile->comp + compno;
680 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
681 Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
682 int ret; // global bandno
684 comp->coord_o[0][0] = FFMAX(tilex * s->tile_width + s->tile_offset_x, s->image_offset_x);
685 comp->coord_o[0][1] = FFMIN((tilex + 1) * s->tile_width + s->tile_offset_x, s->width);
686 comp->coord_o[1][0] = FFMAX(tiley * s->tile_height + s->tile_offset_y, s->image_offset_y);
687 comp->coord_o[1][1] = FFMIN((tiley + 1) * s->tile_height + s->tile_offset_y, s->height);
689 comp->coord[0][0] = ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], s->reduction_factor);
690 comp->coord[0][1] = ff_jpeg2000_ceildivpow2(comp->coord_o[0][1], s->reduction_factor);
691 comp->coord[1][0] = ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], s->reduction_factor);
692 comp->coord[1][1] = ff_jpeg2000_ceildivpow2(comp->coord_o[1][1], s->reduction_factor);
694 if (ret = ff_jpeg2000_init_component(comp, codsty, qntsty,
695 s->cbps[compno], s->cdx[compno],
696 s->cdy[compno], s->avctx))
702 /* Read the number of coding passes. */
703 static int getnpasses(Jpeg2000DecoderContext *s)
710 if ((num = get_bits(s, 2)) != 3)
711 return num < 0 ? num : 3 + num;
712 if ((num = get_bits(s, 5)) != 31)
713 return num < 0 ? num : 6 + num;
714 num = get_bits(s, 7);
715 return num < 0 ? num : 37 + num;
718 static int getlblockinc(Jpeg2000DecoderContext *s)
721 while (ret = get_bits(s, 1)) {
729 static int jpeg2000_decode_packet(Jpeg2000DecoderContext *s,
730 Jpeg2000CodingStyle *codsty,
731 Jpeg2000ResLevel *rlevel, int precno,
732 int layno, uint8_t *expn, int numgbits)
734 int bandno, cblkno, ret, nb_code_blocks;
736 if (!(ret = get_bits(s, 1))) {
742 for (bandno = 0; bandno < rlevel->nbands; bandno++) {
743 Jpeg2000Band *band = rlevel->band + bandno;
744 Jpeg2000Prec *prec = band->prec + precno;
746 if (band->coord[0][0] == band->coord[0][1] ||
747 band->coord[1][0] == band->coord[1][1])
749 nb_code_blocks = prec->nb_codeblocks_height *
750 prec->nb_codeblocks_width;
751 for (cblkno = 0; cblkno < nb_code_blocks; cblkno++) {
752 Jpeg2000Cblk *cblk = prec->cblk + cblkno;
753 int incl, newpasses, llen;
756 incl = get_bits(s, 1);
758 incl = tag_tree_decode(s, prec->cblkincl + cblkno, layno + 1) == layno;
764 if (!cblk->npasses) {
765 int v = expn[bandno] + numgbits - 1 -
766 tag_tree_decode(s, prec->zerobits + cblkno, 100);
768 av_log(s->avctx, AV_LOG_ERROR,
769 "nonzerobits %d invalid\n", v);
770 return AVERROR_INVALIDDATA;
772 cblk->nonzerobits = v;
774 if ((newpasses = getnpasses(s)) < 0)
776 if ((llen = getlblockinc(s)) < 0)
778 cblk->lblock += llen;
779 if ((ret = get_bits(s, av_log2(newpasses) + cblk->lblock)) < 0)
781 if (ret > sizeof(cblk->data)) {
782 avpriv_request_sample(s->avctx,
783 "Block with lengthinc greater than %zu",
785 return AVERROR_PATCHWELCOME;
787 cblk->lengthinc = ret;
788 cblk->npasses += newpasses;
793 if (codsty->csty & JPEG2000_CSTY_EPH) {
794 if (bytestream2_peek_be16(&s->g) == JPEG2000_EPH)
795 bytestream2_skip(&s->g, 2);
797 av_log(s->avctx, AV_LOG_ERROR, "EPH marker not found.\n");
800 for (bandno = 0; bandno < rlevel->nbands; bandno++) {
801 Jpeg2000Band *band = rlevel->band + bandno;
802 Jpeg2000Prec *prec = band->prec + precno;
804 nb_code_blocks = prec->nb_codeblocks_height * prec->nb_codeblocks_width;
805 for (cblkno = 0; cblkno < nb_code_blocks; cblkno++) {
806 Jpeg2000Cblk *cblk = prec->cblk + cblkno;
807 if ( bytestream2_get_bytes_left(&s->g) < cblk->lengthinc
808 || sizeof(cblk->data) < cblk->length + cblk->lengthinc + 2
810 av_log(s->avctx, AV_LOG_ERROR,
811 "Block length %d or lengthinc %d is too large\n",
812 cblk->length, cblk->lengthinc);
813 return AVERROR_INVALIDDATA;
816 bytestream2_get_bufferu(&s->g, cblk->data + cblk->length, cblk->lengthinc);
817 cblk->length += cblk->lengthinc;
824 static int jpeg2000_decode_packets(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
827 int layno, reslevelno, compno, precno, ok_reslevel;
831 switch (tile->codsty[0].prog_order) {
832 case JPEG2000_PGOD_RLCP:
833 avpriv_request_sample(s->avctx, "Progression order RLCP");
835 case JPEG2000_PGOD_LRCP:
836 for (layno = 0; layno < tile->codsty[0].nlayers; layno++) {
838 for (reslevelno = 0; ok_reslevel; reslevelno++) {
840 for (compno = 0; compno < s->ncomponents; compno++) {
841 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
842 Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
843 if (reslevelno < codsty->nreslevels) {
844 Jpeg2000ResLevel *rlevel = tile->comp[compno].reslevel +
847 for (precno = 0; precno < rlevel->num_precincts_x * rlevel->num_precincts_y; precno++)
848 if ((ret = jpeg2000_decode_packet(s,
851 qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
852 qntsty->nguardbits)) < 0)
860 case JPEG2000_PGOD_CPRL:
861 for (compno = 0; compno < s->ncomponents; compno++) {
862 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
863 Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
865 /* Set bit stream buffer address according to tile-part.
866 * For DCinema one tile-part per component, so can be
867 * indexed by component. */
868 s->g = tile->tile_part[compno].tpg;
870 /* Position loop (y axis)
871 * TODO: Automate computing of step 256.
872 * Fixed here, but to be computed before entering here. */
873 for (y = 0; y < s->height; y += 256) {
874 /* Position loop (y axis)
875 * TODO: automate computing of step 256.
876 * Fixed here, but to be computed before entering here. */
877 for (x = 0; x < s->width; x += 256) {
878 for (reslevelno = 0; reslevelno < codsty->nreslevels; reslevelno++) {
880 uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
881 Jpeg2000ResLevel *rlevel = tile->comp[compno].reslevel + reslevelno;
883 if (!((y % (1 << (rlevel->log2_prec_height + reducedresno)) == 0) ||
884 (y == 0))) // TODO: 2nd condition simplified as try0 always =0 for dcinema
887 if (!((x % (1 << (rlevel->log2_prec_width + reducedresno)) == 0) ||
888 (x == 0))) // TODO: 2nd condition simplified as try0 always =0 for dcinema
891 // check if a precinct exists
892 prcx = ff_jpeg2000_ceildivpow2(x, reducedresno) >> rlevel->log2_prec_width;
893 prcy = ff_jpeg2000_ceildivpow2(y, reducedresno) >> rlevel->log2_prec_height;
894 precno = prcx + rlevel->num_precincts_x * prcy;
896 if (prcx >= rlevel->num_precincts_x || prcy >= rlevel->num_precincts_y)
897 return AVERROR_PATCHWELCOME;
899 for (layno = 0; layno < tile->codsty[0].nlayers; layno++) {
900 if ((ret = jpeg2000_decode_packet(s, codsty, rlevel,
902 qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
903 qntsty->nguardbits)) < 0)
912 case JPEG2000_PGOD_RPCL:
913 avpriv_request_sample(s->avctx, "Progression order RPCL");
914 ret = AVERROR_PATCHWELCOME;
917 case JPEG2000_PGOD_PCRL:
918 avpriv_request_sample(s->avctx, "Progression order PCRL");
919 ret = AVERROR_PATCHWELCOME;
926 /* EOC marker reached */
927 bytestream2_skip(&s->g, 2);
932 /* TIER-1 routines */
933 static void decode_sigpass(Jpeg2000T1Context *t1, int width, int height,
934 int bpno, int bandno, int bpass_csty_symbol,
935 int vert_causal_ctx_csty_symbol)
937 int mask = 3 << (bpno - 1), y0, x, y;
939 for (y0 = 0; y0 < height; y0 += 4)
940 for (x = 0; x < width; x++)
941 for (y = y0; y < height && y < y0 + 4; y++) {
942 if ((t1->flags[y+1][x+1] & JPEG2000_T1_SIG_NB)
943 && !(t1->flags[y+1][x+1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS))) {
945 if (vert_causal_ctx_csty_symbol && y == y0 + 3)
946 flags_mask &= ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE);
947 if (ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ff_jpeg2000_getsigctxno(t1->flags[y+1][x+1] & flags_mask, bandno))) {
948 int xorbit, ctxno = ff_jpeg2000_getsgnctxno(t1->flags[y+1][x+1], &xorbit);
949 if (bpass_csty_symbol)
950 t1->data[y][x] = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ctxno) ? -mask : mask;
952 t1->data[y][x] = (ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ctxno) ^ xorbit) ?
955 ff_jpeg2000_set_significance(t1, x, y,
958 t1->flags[y + 1][x + 1] |= JPEG2000_T1_VIS;
963 static void decode_refpass(Jpeg2000T1Context *t1, int width, int height,
969 phalf = 1 << (bpno - 1);
972 for (y0 = 0; y0 < height; y0 += 4)
973 for (x = 0; x < width; x++)
974 for (y = y0; y < height && y < y0 + 4; y++)
975 if ((t1->flags[y + 1][x + 1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS)) == JPEG2000_T1_SIG) {
976 int ctxno = ff_jpeg2000_getrefctxno(t1->flags[y + 1][x + 1]);
977 int r = ff_mqc_decode(&t1->mqc,
978 t1->mqc.cx_states + ctxno)
980 t1->data[y][x] += t1->data[y][x] < 0 ? -r : r;
981 t1->flags[y + 1][x + 1] |= JPEG2000_T1_REF;
985 static void decode_clnpass(Jpeg2000DecoderContext *s, Jpeg2000T1Context *t1,
986 int width, int height, int bpno, int bandno,
987 int seg_symbols, int vert_causal_ctx_csty_symbol)
989 int mask = 3 << (bpno - 1), y0, x, y, runlen, dec;
991 for (y0 = 0; y0 < height; y0 += 4) {
992 for (x = 0; x < width; x++) {
993 if (y0 + 3 < height &&
994 !((t1->flags[y0 + 1][x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
995 (t1->flags[y0 + 2][x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
996 (t1->flags[y0 + 3][x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
997 (t1->flags[y0 + 4][x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)))) {
998 if (!ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_RL))
1000 runlen = ff_mqc_decode(&t1->mqc,
1001 t1->mqc.cx_states + MQC_CX_UNI);
1002 runlen = (runlen << 1) | ff_mqc_decode(&t1->mqc,
1011 for (y = y0 + runlen; y < y0 + 4 && y < height; y++) {
1013 if (!(t1->flags[y+1][x+1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS))) {
1014 int flags_mask = -1;
1015 if (vert_causal_ctx_csty_symbol && y == y0 + 3)
1016 flags_mask &= ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE);
1017 dec = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ff_jpeg2000_getsigctxno(t1->flags[y+1][x+1] & flags_mask,
1023 int ctxno = ff_jpeg2000_getsgnctxno(t1->flags[y + 1][x + 1],
1025 t1->data[y][x] = (ff_mqc_decode(&t1->mqc,
1026 t1->mqc.cx_states + ctxno) ^
1029 ff_jpeg2000_set_significance(t1, x, y, t1->data[y][x] < 0);
1032 t1->flags[y + 1][x + 1] &= ~JPEG2000_T1_VIS;
1038 val = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1039 val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1040 val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1041 val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1043 av_log(s->avctx, AV_LOG_ERROR,
1044 "Segmentation symbol value incorrect\n");
1048 static int decode_cblk(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *codsty,
1049 Jpeg2000T1Context *t1, Jpeg2000Cblk *cblk,
1050 int width, int height, int bandpos)
1052 int passno = cblk->npasses, pass_t = 2, bpno = cblk->nonzerobits - 1, y;
1053 int clnpass_cnt = 0;
1054 int bpass_csty_symbol = codsty->cblk_style & JPEG2000_CBLK_BYPASS;
1055 int vert_causal_ctx_csty_symbol = codsty->cblk_style & JPEG2000_CBLK_VSC;
1057 av_assert0(width <= JPEG2000_MAX_CBLKW);
1058 av_assert0(height <= JPEG2000_MAX_CBLKH);
1060 for (y = 0; y < height; y++)
1061 memset(t1->data[y], 0, width * sizeof(**t1->data));
1063 /* If code-block contains no compressed data: nothing to do. */
1067 for (y = 0; y < height + 2; y++)
1068 memset(t1->flags[y], 0, (width + 2) * sizeof(**t1->flags));
1070 cblk->data[cblk->length] = 0xff;
1071 cblk->data[cblk->length+1] = 0xff;
1072 ff_mqc_initdec(&t1->mqc, cblk->data);
1077 decode_sigpass(t1, width, height, bpno + 1, bandpos,
1078 bpass_csty_symbol && (clnpass_cnt >= 4),
1079 vert_causal_ctx_csty_symbol);
1082 decode_refpass(t1, width, height, bpno + 1);
1083 if (bpass_csty_symbol && clnpass_cnt >= 4)
1084 ff_mqc_initdec(&t1->mqc, cblk->data);
1087 decode_clnpass(s, t1, width, height, bpno + 1, bandpos,
1088 codsty->cblk_style & JPEG2000_CBLK_SEGSYM,
1089 vert_causal_ctx_csty_symbol);
1090 clnpass_cnt = clnpass_cnt + 1;
1091 if (bpass_csty_symbol && clnpass_cnt >= 4)
1092 ff_mqc_initdec(&t1->mqc, cblk->data);
1105 /* TODO: Verify dequantization for lossless case
1106 * comp->data can be float or int
1107 * band->stepsize can be float or int
1108 * depending on the type of DWT transformation.
1109 * see ISO/IEC 15444-1:2002 A.6.1 */
1111 /* Float dequantization of a codeblock.*/
1112 static void dequantization_float(int x, int y, Jpeg2000Cblk *cblk,
1113 Jpeg2000Component *comp,
1114 Jpeg2000T1Context *t1, Jpeg2000Band *band)
1117 int w = cblk->coord[0][1] - cblk->coord[0][0];
1118 for (j = 0; j < (cblk->coord[1][1] - cblk->coord[1][0]); ++j) {
1119 float *datap = &comp->f_data[(comp->coord[0][1] - comp->coord[0][0]) * (y + j) + x];
1120 int *src = t1->data[j];
1121 for (i = 0; i < w; ++i)
1122 datap[i] = src[i] * band->f_stepsize;
1126 /* Integer dequantization of a codeblock.*/
1127 static void dequantization_int(int x, int y, Jpeg2000Cblk *cblk,
1128 Jpeg2000Component *comp,
1129 Jpeg2000T1Context *t1, Jpeg2000Band *band)
1132 int w = cblk->coord[0][1] - cblk->coord[0][0];
1133 for (j = 0; j < (cblk->coord[1][1] - cblk->coord[1][0]); ++j) {
1134 int32_t *datap = &comp->i_data[(comp->coord[0][1] - comp->coord[0][0]) * (y + j) + x];
1135 int *src = t1->data[j];
1136 for (i = 0; i < w; ++i)
1137 datap[i] = (src[i] * band->i_stepsize + (1 << 14)) >> 15;
1141 /* Inverse ICT parameters in float and integer.
1142 * int value = (float value) * (1<<16) */
1143 static const float f_ict_params[4] = {
1149 static const int i_ict_params[4] = {
1156 static void mct_decode(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
1159 int32_t *src[3], i0, i1, i2;
1160 float *srcf[3], i0f, i1f, i2f;
1162 for (i = 1; i < 3; i++)
1163 if (tile->codsty[0].transform != tile->codsty[i].transform) {
1164 av_log(s->avctx, AV_LOG_ERROR, "Transforms mismatch, MCT not supported\n");
1168 for (i = 0; i < 3; i++)
1169 if (tile->codsty[0].transform == FF_DWT97)
1170 srcf[i] = tile->comp[i].f_data;
1172 src [i] = tile->comp[i].i_data;
1174 for (i = 0; i < 2; i++)
1175 csize *= tile->comp[0].coord[i][1] - tile->comp[0].coord[i][0];
1177 switch (tile->codsty[0].transform) {
1179 for (i = 0; i < csize; i++) {
1180 i0f = *srcf[0] + (f_ict_params[0] * *srcf[2]);
1181 i1f = *srcf[0] - (f_ict_params[1] * *srcf[1])
1182 - (f_ict_params[2] * *srcf[2]);
1183 i2f = *srcf[0] + (f_ict_params[3] * *srcf[1]);
1190 for (i = 0; i < csize; i++) {
1191 i0 = *src[0] + (((i_ict_params[0] * *src[2]) + (1 << 15)) >> 16);
1192 i1 = *src[0] - (((i_ict_params[1] * *src[1]) + (1 << 15)) >> 16)
1193 - (((i_ict_params[2] * *src[2]) + (1 << 15)) >> 16);
1194 i2 = *src[0] + (((i_ict_params[3] * *src[1]) + (1 << 15)) >> 16);
1201 for (i = 0; i < csize; i++) {
1202 i1 = *src[0] - (*src[2] + *src[1] >> 2);
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);
1265 dequantization_int(x, y, cblk, comp, &t1, band);
1269 } /* end reslevel */
1272 ff_dwt_decode(&comp->dwt, codsty->transform == FF_DWT97 ? (void*)comp->f_data : (void*)comp->i_data);
1275 /* inverse MCT transformation */
1276 if (tile->codsty[0].mct)
1277 mct_decode(s, tile);
1279 if (s->cdef[0] < 0) {
1280 for (x = 0; x < s->ncomponents; x++)
1282 if ((s->ncomponents & 1) == 0)
1283 s->cdef[s->ncomponents-1] = 0;
1286 if (s->precision <= 8) {
1287 for (compno = 0; compno < s->ncomponents; compno++) {
1288 Jpeg2000Component *comp = tile->comp + compno;
1289 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1290 float *datap = comp->f_data;
1291 int32_t *i_datap = comp->i_data;
1292 int cbps = s->cbps[compno];
1293 int w = tile->comp[compno].coord[0][1] - s->image_offset_x;
1297 plane = s->cdef[compno] ? s->cdef[compno]-1 : (s->ncomponents-1);
1300 y = tile->comp[compno].coord[1][0] - s->image_offset_y;
1301 line = picture->data[plane] + y / s->cdy[compno] * picture->linesize[plane];
1302 for (; y < tile->comp[compno].coord[1][1] - s->image_offset_y; y += s->cdy[compno]) {
1305 x = tile->comp[compno].coord[0][0] - s->image_offset_x;
1306 dst = line + x / s->cdx[compno] * pixelsize + compno*!planar;
1308 if (codsty->transform == FF_DWT97) {
1309 for (; x < w; x += s->cdx[compno]) {
1310 int val = lrintf(*datap) + (1 << (cbps - 1));
1311 /* DC level shift and clip see ISO 15444-1:2002 G.1.2 */
1312 val = av_clip(val, 0, (1 << cbps) - 1);
1313 *dst = val << (8 - cbps);
1318 for (; x < w; x += s->cdx[compno]) {
1319 int val = *i_datap + (1 << (cbps - 1));
1320 /* DC level shift and clip see ISO 15444-1:2002 G.1.2 */
1321 val = av_clip(val, 0, (1 << cbps) - 1);
1322 *dst = val << (8 - cbps);
1327 line += picture->linesize[plane];
1331 for (compno = 0; compno < s->ncomponents; compno++) {
1332 Jpeg2000Component *comp = tile->comp + compno;
1333 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1334 float *datap = comp->f_data;
1335 int32_t *i_datap = comp->i_data;
1337 int cbps = s->cbps[compno];
1338 int w = tile->comp[compno].coord[0][1] - s->image_offset_x;
1342 plane = s->cdef[compno] ? s->cdef[compno]-1 : (s->ncomponents-1);
1344 y = tile->comp[compno].coord[1][0] - s->image_offset_y;
1345 linel = (uint16_t *)picture->data[plane] + y / s->cdy[compno] * (picture->linesize[plane] >> 1);
1346 for (; y < tile->comp[compno].coord[1][1] - s->image_offset_y; y += s->cdy[compno]) {
1349 x = tile->comp[compno].coord[0][0] - s->image_offset_x;
1350 dst = linel + (x / s->cdx[compno] * pixelsize + compno*!planar);
1351 if (codsty->transform == FF_DWT97) {
1352 for (; x < w; x += s-> cdx[compno]) {
1353 int val = lrintf(*datap) + (1 << (cbps - 1));
1354 /* DC level shift and clip see ISO 15444-1:2002 G.1.2 */
1355 val = av_clip(val, 0, (1 << cbps) - 1);
1356 /* align 12 bit values in little-endian mode */
1357 *dst = val << (16 - cbps);
1362 for (; x < w; x += s-> cdx[compno]) {
1363 int val = *i_datap + (1 << (cbps - 1));
1364 /* DC level shift and clip see ISO 15444-1:2002 G.1.2 */
1365 val = av_clip(val, 0, (1 << cbps) - 1);
1366 /* align 12 bit values in little-endian mode */
1367 *dst = val << (16 - cbps);
1372 linel += picture->linesize[plane] >> 1;
1380 static void jpeg2000_dec_cleanup(Jpeg2000DecoderContext *s)
1383 for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++) {
1384 if (s->tile[tileno].comp) {
1385 for (compno = 0; compno < s->ncomponents; compno++) {
1386 Jpeg2000Component *comp = s->tile[tileno].comp + compno;
1387 Jpeg2000CodingStyle *codsty = s->tile[tileno].codsty + compno;
1389 ff_jpeg2000_cleanup(comp, codsty);
1391 av_freep(&s->tile[tileno].comp);
1395 memset(s->codsty, 0, sizeof(s->codsty));
1396 memset(s->qntsty, 0, sizeof(s->qntsty));
1397 s->numXtiles = s->numYtiles = 0;
1400 static int jpeg2000_read_main_headers(Jpeg2000DecoderContext *s)
1402 Jpeg2000CodingStyle *codsty = s->codsty;
1403 Jpeg2000QuantStyle *qntsty = s->qntsty;
1404 uint8_t *properties = s->properties;
1411 if (bytestream2_get_bytes_left(&s->g) < 2) {
1412 av_log(s->avctx, AV_LOG_ERROR, "Missing EOC\n");
1416 marker = bytestream2_get_be16u(&s->g);
1417 oldpos = bytestream2_tell(&s->g);
1419 if (marker == JPEG2000_SOD) {
1421 Jpeg2000TilePart *tp;
1424 av_log(s->avctx, AV_LOG_ERROR, "Missing SIZ\n");
1425 return AVERROR_INVALIDDATA;
1427 if (s->curtileno < 0) {
1428 av_log(s->avctx, AV_LOG_ERROR, "Missing SOT\n");
1429 return AVERROR_INVALIDDATA;
1432 tile = s->tile + s->curtileno;
1433 tp = tile->tile_part + tile->tp_idx;
1434 if (tp->tp_end < s->g.buffer) {
1435 av_log(s->avctx, AV_LOG_ERROR, "Invalid tpend\n");
1436 return AVERROR_INVALIDDATA;
1438 bytestream2_init(&tp->tpg, s->g.buffer, tp->tp_end - s->g.buffer);
1439 bytestream2_skip(&s->g, tp->tp_end - s->g.buffer);
1443 if (marker == JPEG2000_EOC)
1446 len = bytestream2_get_be16(&s->g);
1447 if (len < 2 || bytestream2_get_bytes_left(&s->g) < len - 2)
1448 return AVERROR_INVALIDDATA;
1454 s->numXtiles = s->numYtiles = 0;
1457 ret = get_coc(s, codsty, properties);
1460 ret = get_cod(s, codsty, properties);
1463 ret = get_qcc(s, len, qntsty, properties);
1466 ret = get_qcd(s, len, qntsty, properties);
1469 if (!(ret = get_sot(s, len))) {
1470 av_assert1(s->curtileno >= 0);
1471 codsty = s->tile[s->curtileno].codsty;
1472 qntsty = s->tile[s->curtileno].qntsty;
1473 properties = s->tile[s->curtileno].properties;
1477 // the comment is ignored
1478 bytestream2_skip(&s->g, len - 2);
1481 // Tile-part lengths
1482 ret = get_tlm(s, len);
1485 av_log(s->avctx, AV_LOG_ERROR,
1486 "unsupported marker 0x%.4X at pos 0x%X\n",
1487 marker, bytestream2_tell(&s->g) - 4);
1488 bytestream2_skip(&s->g, len - 2);
1491 if (bytestream2_tell(&s->g) - oldpos != len || ret) {
1492 av_log(s->avctx, AV_LOG_ERROR,
1493 "error during processing marker segment %.4x\n", marker);
1494 return ret ? ret : -1;
1500 /* Read bit stream packets --> T2 operation. */
1501 static int jpeg2000_read_bitstream_packets(Jpeg2000DecoderContext *s)
1506 for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++) {
1507 Jpeg2000Tile *tile = s->tile + tileno;
1509 if (ret = init_tile(s, tileno))
1512 s->g = tile->tile_part[0].tpg;
1513 if (ret = jpeg2000_decode_packets(s, tile))
1520 static int jp2_find_codestream(Jpeg2000DecoderContext *s)
1522 uint32_t atom_size, atom, atom_end;
1523 int search_range = 10;
1527 bytestream2_get_bytes_left(&s->g) >= 8) {
1528 atom_size = bytestream2_get_be32u(&s->g);
1529 atom = bytestream2_get_be32u(&s->g);
1530 atom_end = bytestream2_tell(&s->g) + atom_size - 8;
1532 if (atom == JP2_CODESTREAM)
1535 if (bytestream2_get_bytes_left(&s->g) < atom_size || atom_end < atom_size)
1538 if (atom == JP2_HEADER &&
1540 uint32_t atom2_size, atom2, atom2_end;
1542 atom2_size = bytestream2_get_be32u(&s->g);
1543 atom2 = bytestream2_get_be32u(&s->g);
1544 atom2_end = bytestream2_tell(&s->g) + atom2_size - 8;
1545 if (atom2_size < 8 || atom2_end > atom_end || atom2_end < atom2_size)
1547 if (atom2 == JP2_CODESTREAM) {
1549 } else if (atom2 == MKBETAG('c','o','l','r') && atom2_size >= 7) {
1550 int method = bytestream2_get_byteu(&s->g);
1551 bytestream2_skipu(&s->g, 2);
1553 s->colour_space = bytestream2_get_be32u(&s->g);
1555 } else if (atom2 == MKBETAG('p','c','l','r') && atom2_size >= 6) {
1556 int i, size, colour_count, colour_channels, colour_depth[3];
1558 colour_count = bytestream2_get_be16u(&s->g);
1559 colour_channels = bytestream2_get_byteu(&s->g);
1560 // FIXME: Do not ignore channel_sign
1561 colour_depth[0] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1;
1562 colour_depth[1] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1;
1563 colour_depth[2] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1;
1564 size = (colour_depth[0] + 7 >> 3) * colour_count +
1565 (colour_depth[1] + 7 >> 3) * colour_count +
1566 (colour_depth[2] + 7 >> 3) * colour_count;
1567 if (colour_count > 256 ||
1568 colour_channels != 3 ||
1569 colour_depth[0] > 16 ||
1570 colour_depth[1] > 16 ||
1571 colour_depth[2] > 16 ||
1572 atom2_size < size) {
1573 avpriv_request_sample(s->avctx, "Unknown palette");
1574 bytestream2_seek(&s->g, atom2_end, SEEK_SET);
1578 for (i = 0; i < colour_count; i++) {
1579 if (colour_depth[0] <= 8) {
1580 r = bytestream2_get_byteu(&s->g) << 8 - colour_depth[0];
1581 r |= r >> colour_depth[0];
1583 r = bytestream2_get_be16u(&s->g) >> colour_depth[0] - 8;
1585 if (colour_depth[1] <= 8) {
1586 g = bytestream2_get_byteu(&s->g) << 8 - colour_depth[1];
1587 r |= r >> colour_depth[1];
1589 g = bytestream2_get_be16u(&s->g) >> colour_depth[1] - 8;
1591 if (colour_depth[2] <= 8) {
1592 b = bytestream2_get_byteu(&s->g) << 8 - colour_depth[2];
1593 r |= r >> colour_depth[2];
1595 b = bytestream2_get_be16u(&s->g) >> colour_depth[2] - 8;
1597 s->palette[i] = 0xffu << 24 | r << 16 | g << 8 | b;
1599 } else if (atom2 == MKBETAG('c','d','e','f') && atom2_size >= 2) {
1600 int n = bytestream2_get_be16u(&s->g);
1602 int cn = bytestream2_get_be16(&s->g);
1603 int av_unused typ = bytestream2_get_be16(&s->g);
1604 int asoc = bytestream2_get_be16(&s->g);
1605 if (cn < 4 || asoc < 4)
1609 bytestream2_seek(&s->g, atom2_end, SEEK_SET);
1610 } while (atom_end - atom2_end >= 8);
1614 bytestream2_seek(&s->g, atom_end, SEEK_SET);
1620 static int jpeg2000_decode_frame(AVCodecContext *avctx, void *data,
1621 int *got_frame, AVPacket *avpkt)
1623 Jpeg2000DecoderContext *s = avctx->priv_data;
1624 ThreadFrame frame = { .f = data };
1625 AVFrame *picture = data;
1629 bytestream2_init(&s->g, avpkt->data, avpkt->size);
1631 memset(s->cdef, -1, sizeof(s->cdef));
1633 if (bytestream2_get_bytes_left(&s->g) < 2) {
1634 ret = AVERROR_INVALIDDATA;
1638 // check if the image is in jp2 format
1639 if (bytestream2_get_bytes_left(&s->g) >= 12 &&
1640 (bytestream2_get_be32u(&s->g) == 12) &&
1641 (bytestream2_get_be32u(&s->g) == JP2_SIG_TYPE) &&
1642 (bytestream2_get_be32u(&s->g) == JP2_SIG_VALUE)) {
1643 if (!jp2_find_codestream(s)) {
1644 av_log(avctx, AV_LOG_ERROR,
1645 "Could not find Jpeg2000 codestream atom.\n");
1646 ret = AVERROR_INVALIDDATA;
1650 bytestream2_seek(&s->g, 0, SEEK_SET);
1653 while (bytestream2_get_bytes_left(&s->g) >= 3 && bytestream2_peek_be16(&s->g) != JPEG2000_SOC)
1654 bytestream2_skip(&s->g, 1);
1656 if (bytestream2_get_be16u(&s->g) != JPEG2000_SOC) {
1657 av_log(avctx, AV_LOG_ERROR, "SOC marker not present\n");
1658 ret = AVERROR_INVALIDDATA;
1661 if (ret = jpeg2000_read_main_headers(s))
1664 /* get picture buffer */
1665 if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
1667 picture->pict_type = AV_PICTURE_TYPE_I;
1668 picture->key_frame = 1;
1670 if (ret = jpeg2000_read_bitstream_packets(s))
1673 for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++)
1674 if (ret = jpeg2000_decode_tile(s, s->tile + tileno, picture))
1677 jpeg2000_dec_cleanup(s);
1681 if (s->avctx->pix_fmt == AV_PIX_FMT_PAL8)
1682 memcpy(picture->data[1], s->palette, 256 * sizeof(uint32_t));
1684 return bytestream2_tell(&s->g);
1687 jpeg2000_dec_cleanup(s);
1691 static void jpeg2000_init_static_data(AVCodec *codec)
1693 ff_jpeg2000_init_tier1_luts();
1694 ff_mqc_init_context_tables();
1697 #define OFFSET(x) offsetof(Jpeg2000DecoderContext, x)
1698 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
1700 static const AVOption options[] = {
1701 { "lowres", "Lower the decoding resolution by a power of two",
1702 OFFSET(reduction_factor), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, JPEG2000_MAX_RESLEVELS - 1, VD },
1706 static const AVProfile profiles[] = {
1707 { FF_PROFILE_JPEG2000_CSTREAM_RESTRICTION_0, "JPEG 2000 codestream restriction 0" },
1708 { FF_PROFILE_JPEG2000_CSTREAM_RESTRICTION_1, "JPEG 2000 codestream restriction 1" },
1709 { FF_PROFILE_JPEG2000_CSTREAM_NO_RESTRICTION, "JPEG 2000 no codestream restrictions" },
1710 { FF_PROFILE_JPEG2000_DCINEMA_2K, "JPEG 2000 digital cinema 2K" },
1711 { FF_PROFILE_JPEG2000_DCINEMA_4K, "JPEG 2000 digital cinema 4K" },
1712 { FF_PROFILE_UNKNOWN },
1715 static const AVClass jpeg2000_class = {
1716 .class_name = "jpeg2000",
1717 .item_name = av_default_item_name,
1719 .version = LIBAVUTIL_VERSION_INT,
1722 AVCodec ff_jpeg2000_decoder = {
1724 .long_name = NULL_IF_CONFIG_SMALL("JPEG 2000"),
1725 .type = AVMEDIA_TYPE_VIDEO,
1726 .id = AV_CODEC_ID_JPEG2000,
1727 .capabilities = CODEC_CAP_FRAME_THREADS,
1728 .priv_data_size = sizeof(Jpeg2000DecoderContext),
1729 .init_static_data = jpeg2000_init_static_data,
1730 .decode = jpeg2000_decode_frame,
1731 .priv_class = &jpeg2000_class,
1733 .profiles = NULL_IF_CONFIG_SMALL(profiles)