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
[4];
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
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
605 if (Psot
> bytestream2_get_bytes_left(&s
->g
) + n
+ 2) {
606 av_log(s
->avctx
, AV_LOG_ERROR
, "Psot %"PRIu32
" too big\n", Psot
);
607 return AVERROR_INVALIDDATA
;
610 if (TPsot
>= FF_ARRAY_ELEMS(s
->tile
[Isot
].tile_part
)) {
611 avpriv_request_sample(s
->avctx
, "Support for %"PRIu8
" components", TPsot
);
612 return AVERROR_PATCHWELCOME
;
615 s
->tile
[Isot
].tp_idx
= TPsot
;
616 tp
= s
->tile
[Isot
].tile_part
+ TPsot
;
617 tp
->tile_index
= Isot
;
618 tp
->tp_end
= s
->g
.buffer
+ Psot
- n
- 2;
621 Jpeg2000Tile
*tile
= s
->tile
+ s
->curtileno
;
624 memcpy(tile
->codsty
, s
->codsty
, s
->ncomponents
* sizeof(Jpeg2000CodingStyle
));
625 memcpy(tile
->qntsty
, s
->qntsty
, s
->ncomponents
* sizeof(Jpeg2000QuantStyle
));
631 /* Tile-part lengths: see ISO 15444-1:2002, section A.7.1
632 * Used to know the number of tile parts and lengths.
633 * There may be multiple TLMs in the header.
634 * TODO: The function is not used for tile-parts management, nor anywhere else.
635 * It can be useful to allocate memory for tile parts, before managing the SOT
636 * markers. Parsing the TLM header is needed to increment the input header
638 * This marker is mandatory for DCI. */
639 static uint8_t get_tlm(Jpeg2000DecoderContext
*s
, int n
)
641 uint8_t Stlm
, ST
, SP
, tile_tlm
, i
;
642 bytestream2_get_byte(&s
->g
); /* Ztlm: skipped */
643 Stlm
= bytestream2_get_byte(&s
->g
);
645 // too complex ? ST = ((Stlm >> 4) & 0x01) + ((Stlm >> 4) & 0x02);
646 ST
= (Stlm
>> 4) & 0x03;
647 // TODO: Manage case of ST = 0b11 --> raise error
648 SP
= (Stlm
>> 6) & 0x01;
649 tile_tlm
= (n
- 4) / ((SP
+ 1) * 2 + ST
);
650 for (i
= 0; i
< tile_tlm
; i
++) {
655 bytestream2_get_byte(&s
->g
);
658 bytestream2_get_be16(&s
->g
);
661 bytestream2_get_be32(&s
->g
);
665 bytestream2_get_be16(&s
->g
);
667 bytestream2_get_be32(&s
->g
);
673 static int init_tile(Jpeg2000DecoderContext
*s
, int tileno
)
676 int tilex
= tileno
% s
->numXtiles
;
677 int tiley
= tileno
/ s
->numXtiles
;
678 Jpeg2000Tile
*tile
= s
->tile
+ tileno
;
681 return AVERROR(ENOMEM
);
683 for (compno
= 0; compno
< s
->ncomponents
; compno
++) {
684 Jpeg2000Component
*comp
= tile
->comp
+ compno
;
685 Jpeg2000CodingStyle
*codsty
= tile
->codsty
+ compno
;
686 Jpeg2000QuantStyle
*qntsty
= tile
->qntsty
+ compno
;
687 int ret
; // global bandno
689 comp
->coord_o
[0][0] = FFMAX(tilex
* s
->tile_width
+ s
->tile_offset_x
, s
->image_offset_x
);
690 comp
->coord_o
[0][1] = FFMIN((tilex
+ 1) * s
->tile_width
+ s
->tile_offset_x
, s
->width
);
691 comp
->coord_o
[1][0] = FFMAX(tiley
* s
->tile_height
+ s
->tile_offset_y
, s
->image_offset_y
);
692 comp
->coord_o
[1][1] = FFMIN((tiley
+ 1) * s
->tile_height
+ s
->tile_offset_y
, s
->height
);
694 comp
->coord
[0][0] = ff_jpeg2000_ceildivpow2(comp
->coord_o
[0][0], s
->reduction_factor
);
695 comp
->coord
[0][1] = ff_jpeg2000_ceildivpow2(comp
->coord_o
[0][1], s
->reduction_factor
);
696 comp
->coord
[1][0] = ff_jpeg2000_ceildivpow2(comp
->coord_o
[1][0], s
->reduction_factor
);
697 comp
->coord
[1][1] = ff_jpeg2000_ceildivpow2(comp
->coord_o
[1][1], s
->reduction_factor
);
699 if (ret
= ff_jpeg2000_init_component(comp
, codsty
, qntsty
,
700 s
->cbps
[compno
], s
->cdx
[compno
],
701 s
->cdy
[compno
], s
->avctx
))
707 /* Read the number of coding passes. */
708 static int getnpasses(Jpeg2000DecoderContext
*s
)
715 if ((num
= get_bits(s
, 2)) != 3)
716 return num
< 0 ? num
: 3 + num
;
717 if ((num
= get_bits(s
, 5)) != 31)
718 return num
< 0 ? num
: 6 + num
;
719 num
= get_bits(s
, 7);
720 return num
< 0 ? num
: 37 + num
;
723 static int getlblockinc(Jpeg2000DecoderContext
*s
)
726 while (ret
= get_bits(s
, 1)) {
734 static int jpeg2000_decode_packet(Jpeg2000DecoderContext
*s
,
735 Jpeg2000CodingStyle
*codsty
,
736 Jpeg2000ResLevel
*rlevel
, int precno
,
737 int layno
, uint8_t *expn
, int numgbits
)
739 int bandno
, cblkno
, ret
, nb_code_blocks
;
741 if (!(ret
= get_bits(s
, 1))) {
747 for (bandno
= 0; bandno
< rlevel
->nbands
; bandno
++) {
748 Jpeg2000Band
*band
= rlevel
->band
+ bandno
;
749 Jpeg2000Prec
*prec
= band
->prec
+ precno
;
751 if (band
->coord
[0][0] == band
->coord
[0][1] ||
752 band
->coord
[1][0] == band
->coord
[1][1])
754 nb_code_blocks
= prec
->nb_codeblocks_height
*
755 prec
->nb_codeblocks_width
;
756 for (cblkno
= 0; cblkno
< nb_code_blocks
; cblkno
++) {
757 Jpeg2000Cblk
*cblk
= prec
->cblk
+ cblkno
;
758 int incl
, newpasses
, llen
;
761 incl
= get_bits(s
, 1);
763 incl
= tag_tree_decode(s
, prec
->cblkincl
+ cblkno
, layno
+ 1) == layno
;
769 if (!cblk
->npasses
) {
770 int v
= expn
[bandno
] + numgbits
- 1 -
771 tag_tree_decode(s
, prec
->zerobits
+ cblkno
, 100);
773 av_log(s
->avctx
, AV_LOG_ERROR
,
774 "nonzerobits %d invalid\n", v
);
775 return AVERROR_INVALIDDATA
;
777 cblk
->nonzerobits
= v
;
779 if ((newpasses
= getnpasses(s
)) < 0)
781 if ((llen
= getlblockinc(s
)) < 0)
783 cblk
->lblock
+= llen
;
784 if ((ret
= get_bits(s
, av_log2(newpasses
) + cblk
->lblock
)) < 0)
786 if (ret
> sizeof(cblk
->data
)) {
787 avpriv_request_sample(s
->avctx
,
788 "Block with lengthinc greater than %"SIZE_SPECIFIER
"",
790 return AVERROR_PATCHWELCOME
;
792 cblk
->lengthinc
= ret
;
793 cblk
->npasses
+= newpasses
;
798 if (codsty
->csty
& JPEG2000_CSTY_EPH
) {
799 if (bytestream2_peek_be16(&s
->g
) == JPEG2000_EPH
)
800 bytestream2_skip(&s
->g
, 2);
802 av_log(s
->avctx
, AV_LOG_ERROR
, "EPH marker not found.\n");
805 for (bandno
= 0; bandno
< rlevel
->nbands
; bandno
++) {
806 Jpeg2000Band
*band
= rlevel
->band
+ bandno
;
807 Jpeg2000Prec
*prec
= band
->prec
+ precno
;
809 nb_code_blocks
= prec
->nb_codeblocks_height
* prec
->nb_codeblocks_width
;
810 for (cblkno
= 0; cblkno
< nb_code_blocks
; cblkno
++) {
811 Jpeg2000Cblk
*cblk
= prec
->cblk
+ cblkno
;
812 if ( bytestream2_get_bytes_left(&s
->g
) < cblk
->lengthinc
813 || sizeof(cblk
->data
) < cblk
->length
+ cblk
->lengthinc
+ 2
815 av_log(s
->avctx
, AV_LOG_ERROR
,
816 "Block length %"PRIu16
" or lengthinc %d is too large\n",
817 cblk
->length
, cblk
->lengthinc
);
818 return AVERROR_INVALIDDATA
;
821 bytestream2_get_bufferu(&s
->g
, cblk
->data
+ cblk
->length
, cblk
->lengthinc
);
822 cblk
->length
+= cblk
->lengthinc
;
829 static int jpeg2000_decode_packets(Jpeg2000DecoderContext
*s
, Jpeg2000Tile
*tile
)
832 int layno
, reslevelno
, compno
, precno
, ok_reslevel
;
836 switch (tile
->codsty
[0].prog_order
) {
837 case JPEG2000_PGOD_RLCP
:
838 avpriv_request_sample(s
->avctx
, "Progression order RLCP");
840 case JPEG2000_PGOD_LRCP
:
841 for (layno
= 0; layno
< tile
->codsty
[0].nlayers
; layno
++) {
843 for (reslevelno
= 0; ok_reslevel
; reslevelno
++) {
845 for (compno
= 0; compno
< s
->ncomponents
; compno
++) {
846 Jpeg2000CodingStyle
*codsty
= tile
->codsty
+ compno
;
847 Jpeg2000QuantStyle
*qntsty
= tile
->qntsty
+ compno
;
848 if (reslevelno
< codsty
->nreslevels
) {
849 Jpeg2000ResLevel
*rlevel
= tile
->comp
[compno
].reslevel
+
852 for (precno
= 0; precno
< rlevel
->num_precincts_x
* rlevel
->num_precincts_y
; precno
++)
853 if ((ret
= jpeg2000_decode_packet(s
,
856 qntsty
->expn
+ (reslevelno
? 3 * (reslevelno
- 1) + 1 : 0),
857 qntsty
->nguardbits
)) < 0)
865 case JPEG2000_PGOD_CPRL
:
866 for (compno
= 0; compno
< s
->ncomponents
; compno
++) {
867 Jpeg2000CodingStyle
*codsty
= tile
->codsty
+ compno
;
868 Jpeg2000QuantStyle
*qntsty
= tile
->qntsty
+ compno
;
870 /* Set bit stream buffer address according to tile-part.
871 * For DCinema one tile-part per component, so can be
872 * indexed by component. */
873 s
->g
= tile
->tile_part
[compno
].tpg
;
875 /* Position loop (y axis)
876 * TODO: Automate computing of step 256.
877 * Fixed here, but to be computed before entering here. */
878 for (y
= 0; y
< s
->height
; y
+= 256) {
879 /* Position loop (y axis)
880 * TODO: automate computing of step 256.
881 * Fixed here, but to be computed before entering here. */
882 for (x
= 0; x
< s
->width
; x
+= 256) {
883 for (reslevelno
= 0; reslevelno
< codsty
->nreslevels
; reslevelno
++) {
885 uint8_t reducedresno
= codsty
->nreslevels
- 1 -reslevelno
; // ==> N_L - r
886 Jpeg2000ResLevel
*rlevel
= tile
->comp
[compno
].reslevel
+ reslevelno
;
888 if (!((y
% (1 << (rlevel
->log2_prec_height
+ reducedresno
)) == 0) ||
889 (y
== 0))) // TODO: 2nd condition simplified as try0 always =0 for dcinema
892 if (!((x
% (1 << (rlevel
->log2_prec_width
+ reducedresno
)) == 0) ||
893 (x
== 0))) // TODO: 2nd condition simplified as try0 always =0 for dcinema
896 // check if a precinct exists
897 prcx
= ff_jpeg2000_ceildivpow2(x
, reducedresno
) >> rlevel
->log2_prec_width
;
898 prcy
= ff_jpeg2000_ceildivpow2(y
, reducedresno
) >> rlevel
->log2_prec_height
;
899 precno
= prcx
+ rlevel
->num_precincts_x
* prcy
;
901 if (prcx
>= rlevel
->num_precincts_x
|| prcy
>= rlevel
->num_precincts_y
)
902 return AVERROR_PATCHWELCOME
;
904 for (layno
= 0; layno
< tile
->codsty
[0].nlayers
; layno
++) {
905 if ((ret
= jpeg2000_decode_packet(s
, codsty
, rlevel
,
907 qntsty
->expn
+ (reslevelno
? 3 * (reslevelno
- 1) + 1 : 0),
908 qntsty
->nguardbits
)) < 0)
917 case JPEG2000_PGOD_RPCL
:
918 avpriv_request_sample(s
->avctx
, "Progression order RPCL");
919 ret
= AVERROR_PATCHWELCOME
;
922 case JPEG2000_PGOD_PCRL
:
923 avpriv_request_sample(s
->avctx
, "Progression order PCRL");
924 ret
= AVERROR_PATCHWELCOME
;
931 /* EOC marker reached */
932 bytestream2_skip(&s
->g
, 2);
937 /* TIER-1 routines */
938 static void decode_sigpass(Jpeg2000T1Context
*t1
, int width
, int height
,
939 int bpno
, int bandno
, int bpass_csty_symbol
,
940 int vert_causal_ctx_csty_symbol
)
942 int mask
= 3 << (bpno
- 1), y0
, x
, y
;
944 for (y0
= 0; y0
< height
; y0
+= 4)
945 for (x
= 0; x
< width
; x
++)
946 for (y
= y0
; y
< height
&& y
< y0
+ 4; y
++) {
947 if ((t1
->flags
[y
+1][x
+1] & JPEG2000_T1_SIG_NB
)
948 && !(t1
->flags
[y
+1][x
+1] & (JPEG2000_T1_SIG
| JPEG2000_T1_VIS
))) {
950 if (vert_causal_ctx_csty_symbol
&& y
== y0
+ 3)
951 flags_mask
&= ~(JPEG2000_T1_SIG_S
| JPEG2000_T1_SIG_SW
| JPEG2000_T1_SIG_SE
);
952 if (ff_mqc_decode(&t1
->mqc
, t1
->mqc
.cx_states
+ ff_jpeg2000_getsigctxno(t1
->flags
[y
+1][x
+1] & flags_mask
, bandno
))) {
953 int xorbit
, ctxno
= ff_jpeg2000_getsgnctxno(t1
->flags
[y
+1][x
+1], &xorbit
);
954 if (bpass_csty_symbol
)
955 t1
->data
[y
][x
] = ff_mqc_decode(&t1
->mqc
, t1
->mqc
.cx_states
+ ctxno
) ? -mask
: mask
;
957 t1
->data
[y
][x
] = (ff_mqc_decode(&t1
->mqc
, t1
->mqc
.cx_states
+ ctxno
) ^ xorbit
) ?
960 ff_jpeg2000_set_significance(t1
, x
, y
,
963 t1
->flags
[y
+ 1][x
+ 1] |= JPEG2000_T1_VIS
;
968 static void decode_refpass(Jpeg2000T1Context
*t1
, int width
, int height
,
974 phalf
= 1 << (bpno
- 1);
977 for (y0
= 0; y0
< height
; y0
+= 4)
978 for (x
= 0; x
< width
; x
++)
979 for (y
= y0
; y
< height
&& y
< y0
+ 4; y
++)
980 if ((t1
->flags
[y
+ 1][x
+ 1] & (JPEG2000_T1_SIG
| JPEG2000_T1_VIS
)) == JPEG2000_T1_SIG
) {
981 int ctxno
= ff_jpeg2000_getrefctxno(t1
->flags
[y
+ 1][x
+ 1]);
982 int r
= ff_mqc_decode(&t1
->mqc
,
983 t1
->mqc
.cx_states
+ ctxno
)
985 t1
->data
[y
][x
] += t1
->data
[y
][x
] < 0 ? -r
: r
;
986 t1
->flags
[y
+ 1][x
+ 1] |= JPEG2000_T1_REF
;
990 static void decode_clnpass(Jpeg2000DecoderContext
*s
, Jpeg2000T1Context
*t1
,
991 int width
, int height
, int bpno
, int bandno
,
992 int seg_symbols
, int vert_causal_ctx_csty_symbol
)
994 int mask
= 3 << (bpno
- 1), y0
, x
, y
, runlen
, dec
;
996 for (y0
= 0; y0
< height
; y0
+= 4) {
997 for (x
= 0; x
< width
; x
++) {
998 if (y0
+ 3 < height
&&
999 !((t1
->flags
[y0
+ 1][x
+ 1] & (JPEG2000_T1_SIG_NB
| JPEG2000_T1_VIS
| JPEG2000_T1_SIG
)) ||
1000 (t1
->flags
[y0
+ 2][x
+ 1] & (JPEG2000_T1_SIG_NB
| JPEG2000_T1_VIS
| JPEG2000_T1_SIG
)) ||
1001 (t1
->flags
[y0
+ 3][x
+ 1] & (JPEG2000_T1_SIG_NB
| JPEG2000_T1_VIS
| JPEG2000_T1_SIG
)) ||
1002 (t1
->flags
[y0
+ 4][x
+ 1] & (JPEG2000_T1_SIG_NB
| JPEG2000_T1_VIS
| JPEG2000_T1_SIG
)))) {
1003 if (!ff_mqc_decode(&t1
->mqc
, t1
->mqc
.cx_states
+ MQC_CX_RL
))
1005 runlen
= ff_mqc_decode(&t1
->mqc
,
1006 t1
->mqc
.cx_states
+ MQC_CX_UNI
);
1007 runlen
= (runlen
<< 1) | ff_mqc_decode(&t1
->mqc
,
1016 for (y
= y0
+ runlen
; y
< y0
+ 4 && y
< height
; y
++) {
1018 if (!(t1
->flags
[y
+1][x
+1] & (JPEG2000_T1_SIG
| JPEG2000_T1_VIS
))) {
1019 int flags_mask
= -1;
1020 if (vert_causal_ctx_csty_symbol
&& y
== y0
+ 3)
1021 flags_mask
&= ~(JPEG2000_T1_SIG_S
| JPEG2000_T1_SIG_SW
| JPEG2000_T1_SIG_SE
);
1022 dec
= ff_mqc_decode(&t1
->mqc
, t1
->mqc
.cx_states
+ ff_jpeg2000_getsigctxno(t1
->flags
[y
+1][x
+1] & flags_mask
,
1028 int ctxno
= ff_jpeg2000_getsgnctxno(t1
->flags
[y
+ 1][x
+ 1],
1030 t1
->data
[y
][x
] = (ff_mqc_decode(&t1
->mqc
,
1031 t1
->mqc
.cx_states
+ ctxno
) ^
1034 ff_jpeg2000_set_significance(t1
, x
, y
, t1
->data
[y
][x
] < 0);
1037 t1
->flags
[y
+ 1][x
+ 1] &= ~JPEG2000_T1_VIS
;
1043 val
= ff_mqc_decode(&t1
->mqc
, t1
->mqc
.cx_states
+ MQC_CX_UNI
);
1044 val
= (val
<< 1) + ff_mqc_decode(&t1
->mqc
, t1
->mqc
.cx_states
+ MQC_CX_UNI
);
1045 val
= (val
<< 1) + ff_mqc_decode(&t1
->mqc
, t1
->mqc
.cx_states
+ MQC_CX_UNI
);
1046 val
= (val
<< 1) + ff_mqc_decode(&t1
->mqc
, t1
->mqc
.cx_states
+ MQC_CX_UNI
);
1048 av_log(s
->avctx
, AV_LOG_ERROR
,
1049 "Segmentation symbol value incorrect\n");
1053 static int decode_cblk(Jpeg2000DecoderContext
*s
, Jpeg2000CodingStyle
*codsty
,
1054 Jpeg2000T1Context
*t1
, Jpeg2000Cblk
*cblk
,
1055 int width
, int height
, int bandpos
)
1057 int passno
= cblk
->npasses
, pass_t
= 2, bpno
= cblk
->nonzerobits
- 1, y
;
1058 int clnpass_cnt
= 0;
1059 int bpass_csty_symbol
= codsty
->cblk_style
& JPEG2000_CBLK_BYPASS
;
1060 int vert_causal_ctx_csty_symbol
= codsty
->cblk_style
& JPEG2000_CBLK_VSC
;
1062 av_assert0(width
<= JPEG2000_MAX_CBLKW
);
1063 av_assert0(height
<= JPEG2000_MAX_CBLKH
);
1065 for (y
= 0; y
< height
; y
++)
1066 memset(t1
->data
[y
], 0, width
* sizeof(**t1
->data
));
1068 /* If code-block contains no compressed data: nothing to do. */
1072 for (y
= 0; y
< height
+ 2; y
++)
1073 memset(t1
->flags
[y
], 0, (width
+ 2) * sizeof(**t1
->flags
));
1075 cblk
->data
[cblk
->length
] = 0xff;
1076 cblk
->data
[cblk
->length
+1] = 0xff;
1077 ff_mqc_initdec(&t1
->mqc
, cblk
->data
);
1082 decode_sigpass(t1
, width
, height
, bpno
+ 1, bandpos
,
1083 bpass_csty_symbol
&& (clnpass_cnt
>= 4),
1084 vert_causal_ctx_csty_symbol
);
1087 decode_refpass(t1
, width
, height
, bpno
+ 1);
1088 if (bpass_csty_symbol
&& clnpass_cnt
>= 4)
1089 ff_mqc_initdec(&t1
->mqc
, cblk
->data
);
1092 decode_clnpass(s
, t1
, width
, height
, bpno
+ 1, bandpos
,
1093 codsty
->cblk_style
& JPEG2000_CBLK_SEGSYM
,
1094 vert_causal_ctx_csty_symbol
);
1095 clnpass_cnt
= clnpass_cnt
+ 1;
1096 if (bpass_csty_symbol
&& clnpass_cnt
>= 4)
1097 ff_mqc_initdec(&t1
->mqc
, cblk
->data
);
1110 /* TODO: Verify dequantization for lossless case
1111 * comp->data can be float or int
1112 * band->stepsize can be float or int
1113 * depending on the type of DWT transformation.
1114 * see ISO/IEC 15444-1:2002 A.6.1 */
1116 /* Float dequantization of a codeblock.*/
1117 static void dequantization_float(int x
, int y
, Jpeg2000Cblk
*cblk
,
1118 Jpeg2000Component
*comp
,
1119 Jpeg2000T1Context
*t1
, Jpeg2000Band
*band
)
1122 int w
= cblk
->coord
[0][1] - cblk
->coord
[0][0];
1123 for (j
= 0; j
< (cblk
->coord
[1][1] - cblk
->coord
[1][0]); ++j
) {
1124 float *datap
= &comp
->f_data
[(comp
->coord
[0][1] - comp
->coord
[0][0]) * (y
+ j
) + x
];
1125 int *src
= t1
->data
[j
];
1126 for (i
= 0; i
< w
; ++i
)
1127 datap
[i
] = src
[i
] * band
->f_stepsize
;
1131 /* Integer dequantization of a codeblock.*/
1132 static void dequantization_int(int x
, int y
, Jpeg2000Cblk
*cblk
,
1133 Jpeg2000Component
*comp
,
1134 Jpeg2000T1Context
*t1
, Jpeg2000Band
*band
)
1137 int w
= cblk
->coord
[0][1] - cblk
->coord
[0][0];
1138 for (j
= 0; j
< (cblk
->coord
[1][1] - cblk
->coord
[1][0]); ++j
) {
1139 int32_t *datap
= &comp
->i_data
[(comp
->coord
[0][1] - comp
->coord
[0][0]) * (y
+ j
) + x
];
1140 int *src
= t1
->data
[j
];
1141 for (i
= 0; i
< w
; ++i
)
1142 datap
[i
] = (src
[i
] * band
->i_stepsize
+ (1 << 14)) >> 15;
1146 static inline void mct_decode(Jpeg2000DecoderContext
*s
, Jpeg2000Tile
*tile
)
1151 for (i
= 1; i
< 3; i
++)
1152 if (tile
->codsty
[0].transform
!= tile
->codsty
[i
].transform
) {
1153 av_log(s
->avctx
, AV_LOG_ERROR
, "Transforms mismatch, MCT not supported\n");
1157 for (i
= 0; i
< 3; i
++)
1158 if (tile
->codsty
[0].transform
== FF_DWT97
)
1159 src
[i
] = tile
->comp
[i
].f_data
;
1161 src
[i
] = tile
->comp
[i
].i_data
;
1163 for (i
= 0; i
< 2; i
++)
1164 csize
*= tile
->comp
[0].coord
[i
][1] - tile
->comp
[0].coord
[i
][0];
1166 s
->dsp
.mct_decode
[tile
->codsty
[0].transform
](src
[0], src
[1], src
[2], csize
);
1169 static int jpeg2000_decode_tile(Jpeg2000DecoderContext
*s
, Jpeg2000Tile
*tile
,
1172 const AVPixFmtDescriptor
*pixdesc
= av_pix_fmt_desc_get(s
->avctx
->pix_fmt
);
1173 int compno
, reslevelno
, bandno
;
1175 int planar
= !!(pixdesc
->flags
& AV_PIX_FMT_FLAG_PLANAR
);
1176 int pixelsize
= planar
? 1 : pixdesc
->nb_components
;
1179 Jpeg2000T1Context t1
;
1181 /* Loop on tile components */
1182 for (compno
= 0; compno
< s
->ncomponents
; compno
++) {
1183 Jpeg2000Component
*comp
= tile
->comp
+ compno
;
1184 Jpeg2000CodingStyle
*codsty
= tile
->codsty
+ compno
;
1186 /* Loop on resolution levels */
1187 for (reslevelno
= 0; reslevelno
< codsty
->nreslevels2decode
; reslevelno
++) {
1188 Jpeg2000ResLevel
*rlevel
= comp
->reslevel
+ reslevelno
;
1190 for (bandno
= 0; bandno
< rlevel
->nbands
; bandno
++) {
1191 int nb_precincts
, precno
;
1192 Jpeg2000Band
*band
= rlevel
->band
+ bandno
;
1193 int cblkno
= 0, bandpos
;
1195 bandpos
= bandno
+ (reslevelno
> 0);
1197 if (band
->coord
[0][0] == band
->coord
[0][1] ||
1198 band
->coord
[1][0] == band
->coord
[1][1])
1201 nb_precincts
= rlevel
->num_precincts_x
* rlevel
->num_precincts_y
;
1202 /* Loop on precincts */
1203 for (precno
= 0; precno
< nb_precincts
; precno
++) {
1204 Jpeg2000Prec
*prec
= band
->prec
+ precno
;
1206 /* Loop on codeblocks */
1207 for (cblkno
= 0; cblkno
< prec
->nb_codeblocks_width
* prec
->nb_codeblocks_height
; cblkno
++) {
1209 Jpeg2000Cblk
*cblk
= prec
->cblk
+ cblkno
;
1210 decode_cblk(s
, codsty
, &t1
, cblk
,
1211 cblk
->coord
[0][1] - cblk
->coord
[0][0],
1212 cblk
->coord
[1][1] - cblk
->coord
[1][0],
1215 x
= cblk
->coord
[0][0];
1216 y
= cblk
->coord
[1][0];
1218 if (codsty
->transform
== FF_DWT97
)
1219 dequantization_float(x
, y
, cblk
, comp
, &t1
, band
);
1221 dequantization_int(x
, y
, cblk
, comp
, &t1
, band
);
1225 } /* end reslevel */
1228 ff_dwt_decode(&comp
->dwt
, codsty
->transform
== FF_DWT97
? (void*)comp
->f_data
: (void*)comp
->i_data
);
1231 /* inverse MCT transformation */
1232 if (tile
->codsty
[0].mct
)
1233 mct_decode(s
, tile
);
1235 if (s
->cdef
[0] < 0) {
1236 for (x
= 0; x
< s
->ncomponents
; x
++)
1238 if ((s
->ncomponents
& 1) == 0)
1239 s
->cdef
[s
->ncomponents
-1] = 0;
1242 if (s
->precision
<= 8) {
1243 for (compno
= 0; compno
< s
->ncomponents
; compno
++) {
1244 Jpeg2000Component
*comp
= tile
->comp
+ compno
;
1245 Jpeg2000CodingStyle
*codsty
= tile
->codsty
+ compno
;
1246 float *datap
= comp
->f_data
;
1247 int32_t *i_datap
= comp
->i_data
;
1248 int cbps
= s
->cbps
[compno
];
1249 int w
= tile
->comp
[compno
].coord
[0][1] - s
->image_offset_x
;
1253 plane
= s
->cdef
[compno
] ? s
->cdef
[compno
]-1 : (s
->ncomponents
-1);
1256 y
= tile
->comp
[compno
].coord
[1][0] - s
->image_offset_y
;
1257 line
= picture
->data
[plane
] + y
/ s
->cdy
[compno
] * picture
->linesize
[plane
];
1258 for (; y
< tile
->comp
[compno
].coord
[1][1] - s
->image_offset_y
; y
+= s
->cdy
[compno
]) {
1261 x
= tile
->comp
[compno
].coord
[0][0] - s
->image_offset_x
;
1262 dst
= line
+ x
/ s
->cdx
[compno
] * pixelsize
+ compno
*!planar
;
1264 if (codsty
->transform
== FF_DWT97
) {
1265 for (; x
< w
; x
+= s
->cdx
[compno
]) {
1266 int val
= lrintf(*datap
) + (1 << (cbps
- 1));
1267 /* DC level shift and clip see ISO 15444-1:2002 G.1.2 */
1268 val
= av_clip(val
, 0, (1 << cbps
) - 1);
1269 *dst
= val
<< (8 - cbps
);
1274 for (; x
< w
; x
+= s
->cdx
[compno
]) {
1275 int val
= *i_datap
+ (1 << (cbps
- 1));
1276 /* DC level shift and clip see ISO 15444-1:2002 G.1.2 */
1277 val
= av_clip(val
, 0, (1 << cbps
) - 1);
1278 *dst
= val
<< (8 - cbps
);
1283 line
+= picture
->linesize
[plane
];
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
;
1293 int cbps
= s
->cbps
[compno
];
1294 int w
= tile
->comp
[compno
].coord
[0][1] - s
->image_offset_x
;
1298 plane
= s
->cdef
[compno
] ? s
->cdef
[compno
]-1 : (s
->ncomponents
-1);
1300 y
= tile
->comp
[compno
].coord
[1][0] - s
->image_offset_y
;
1301 linel
= (uint16_t *)picture
->data
[plane
] + y
/ s
->cdy
[compno
] * (picture
->linesize
[plane
] >> 1);
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
= linel
+ (x
/ s
->cdx
[compno
] * pixelsize
+ compno
*!planar
);
1307 if (codsty
->transform
== FF_DWT97
) {
1308 for (; x
< w
; x
+= s
-> cdx
[compno
]) {
1309 int val
= lrintf(*datap
) + (1 << (cbps
- 1));
1310 /* DC level shift and clip see ISO 15444-1:2002 G.1.2 */
1311 val
= av_clip(val
, 0, (1 << cbps
) - 1);
1312 /* align 12 bit values in little-endian mode */
1313 *dst
= val
<< (16 - 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 /* align 12 bit values in little-endian mode */
1323 *dst
= val
<< (16 - cbps
);
1328 linel
+= picture
->linesize
[plane
] >> 1;
1336 static void jpeg2000_dec_cleanup(Jpeg2000DecoderContext
*s
)
1339 for (tileno
= 0; tileno
< s
->numXtiles
* s
->numYtiles
; tileno
++) {
1340 if (s
->tile
[tileno
].comp
) {
1341 for (compno
= 0; compno
< s
->ncomponents
; compno
++) {
1342 Jpeg2000Component
*comp
= s
->tile
[tileno
].comp
+ compno
;
1343 Jpeg2000CodingStyle
*codsty
= s
->tile
[tileno
].codsty
+ compno
;
1345 ff_jpeg2000_cleanup(comp
, codsty
);
1347 av_freep(&s
->tile
[tileno
].comp
);
1351 memset(s
->codsty
, 0, sizeof(s
->codsty
));
1352 memset(s
->qntsty
, 0, sizeof(s
->qntsty
));
1353 s
->numXtiles
= s
->numYtiles
= 0;
1356 static int jpeg2000_read_main_headers(Jpeg2000DecoderContext
*s
)
1358 Jpeg2000CodingStyle
*codsty
= s
->codsty
;
1359 Jpeg2000QuantStyle
*qntsty
= s
->qntsty
;
1360 uint8_t *properties
= s
->properties
;
1367 if (bytestream2_get_bytes_left(&s
->g
) < 2) {
1368 av_log(s
->avctx
, AV_LOG_ERROR
, "Missing EOC\n");
1372 marker
= bytestream2_get_be16u(&s
->g
);
1373 oldpos
= bytestream2_tell(&s
->g
);
1375 if (marker
== JPEG2000_SOD
) {
1377 Jpeg2000TilePart
*tp
;
1380 av_log(s
->avctx
, AV_LOG_ERROR
, "Missing SIZ\n");
1381 return AVERROR_INVALIDDATA
;
1383 if (s
->curtileno
< 0) {
1384 av_log(s
->avctx
, AV_LOG_ERROR
, "Missing SOT\n");
1385 return AVERROR_INVALIDDATA
;
1388 tile
= s
->tile
+ s
->curtileno
;
1389 tp
= tile
->tile_part
+ tile
->tp_idx
;
1390 if (tp
->tp_end
< s
->g
.buffer
) {
1391 av_log(s
->avctx
, AV_LOG_ERROR
, "Invalid tpend\n");
1392 return AVERROR_INVALIDDATA
;
1394 bytestream2_init(&tp
->tpg
, s
->g
.buffer
, tp
->tp_end
- s
->g
.buffer
);
1395 bytestream2_skip(&s
->g
, tp
->tp_end
- s
->g
.buffer
);
1399 if (marker
== JPEG2000_EOC
)
1402 len
= bytestream2_get_be16(&s
->g
);
1403 if (len
< 2 || bytestream2_get_bytes_left(&s
->g
) < len
- 2)
1404 return AVERROR_INVALIDDATA
;
1410 s
->numXtiles
= s
->numYtiles
= 0;
1413 ret
= get_coc(s
, codsty
, properties
);
1416 ret
= get_cod(s
, codsty
, properties
);
1419 ret
= get_qcc(s
, len
, qntsty
, properties
);
1422 ret
= get_qcd(s
, len
, qntsty
, properties
);
1425 if (!(ret
= get_sot(s
, len
))) {
1426 av_assert1(s
->curtileno
>= 0);
1427 codsty
= s
->tile
[s
->curtileno
].codsty
;
1428 qntsty
= s
->tile
[s
->curtileno
].qntsty
;
1429 properties
= s
->tile
[s
->curtileno
].properties
;
1433 // the comment is ignored
1434 bytestream2_skip(&s
->g
, len
- 2);
1437 // Tile-part lengths
1438 ret
= get_tlm(s
, len
);
1441 av_log(s
->avctx
, AV_LOG_ERROR
,
1442 "unsupported marker 0x%.4"PRIX16
" at pos 0x%X\n",
1443 marker
, bytestream2_tell(&s
->g
) - 4);
1444 bytestream2_skip(&s
->g
, len
- 2);
1447 if (bytestream2_tell(&s
->g
) - oldpos
!= len
|| ret
) {
1448 av_log(s
->avctx
, AV_LOG_ERROR
,
1449 "error during processing marker segment %.4"PRIx16
"\n",
1451 return ret
? ret
: -1;
1457 /* Read bit stream packets --> T2 operation. */
1458 static int jpeg2000_read_bitstream_packets(Jpeg2000DecoderContext
*s
)
1463 for (tileno
= 0; tileno
< s
->numXtiles
* s
->numYtiles
; tileno
++) {
1464 Jpeg2000Tile
*tile
= s
->tile
+ tileno
;
1466 if (ret
= init_tile(s
, tileno
))
1469 s
->g
= tile
->tile_part
[0].tpg
;
1470 if (ret
= jpeg2000_decode_packets(s
, tile
))
1477 static int jp2_find_codestream(Jpeg2000DecoderContext
*s
)
1479 uint32_t atom_size
, atom
, atom_end
;
1480 int search_range
= 10;
1484 bytestream2_get_bytes_left(&s
->g
) >= 8) {
1485 atom_size
= bytestream2_get_be32u(&s
->g
);
1486 atom
= bytestream2_get_be32u(&s
->g
);
1487 atom_end
= bytestream2_tell(&s
->g
) + atom_size
- 8;
1489 if (atom
== JP2_CODESTREAM
)
1492 if (bytestream2_get_bytes_left(&s
->g
) < atom_size
|| atom_end
< atom_size
)
1495 if (atom
== JP2_HEADER
&&
1497 uint32_t atom2_size
, atom2
, atom2_end
;
1499 atom2_size
= bytestream2_get_be32u(&s
->g
);
1500 atom2
= bytestream2_get_be32u(&s
->g
);
1501 atom2_end
= bytestream2_tell(&s
->g
) + atom2_size
- 8;
1502 if (atom2_size
< 8 || atom2_end
> atom_end
|| atom2_end
< atom2_size
)
1504 if (atom2
== JP2_CODESTREAM
) {
1506 } else if (atom2
== MKBETAG('c','o','l','r') && atom2_size
>= 7) {
1507 int method
= bytestream2_get_byteu(&s
->g
);
1508 bytestream2_skipu(&s
->g
, 2);
1510 s
->colour_space
= bytestream2_get_be32u(&s
->g
);
1512 } else if (atom2
== MKBETAG('p','c','l','r') && atom2_size
>= 6) {
1513 int i
, size
, colour_count
, colour_channels
, colour_depth
[3];
1515 colour_count
= bytestream2_get_be16u(&s
->g
);
1516 colour_channels
= bytestream2_get_byteu(&s
->g
);
1517 // FIXME: Do not ignore channel_sign
1518 colour_depth
[0] = (bytestream2_get_byteu(&s
->g
) & 0x7f) + 1;
1519 colour_depth
[1] = (bytestream2_get_byteu(&s
->g
) & 0x7f) + 1;
1520 colour_depth
[2] = (bytestream2_get_byteu(&s
->g
) & 0x7f) + 1;
1521 size
= (colour_depth
[0] + 7 >> 3) * colour_count
+
1522 (colour_depth
[1] + 7 >> 3) * colour_count
+
1523 (colour_depth
[2] + 7 >> 3) * colour_count
;
1524 if (colour_count
> 256 ||
1525 colour_channels
!= 3 ||
1526 colour_depth
[0] > 16 ||
1527 colour_depth
[1] > 16 ||
1528 colour_depth
[2] > 16 ||
1529 atom2_size
< size
) {
1530 avpriv_request_sample(s
->avctx
, "Unknown palette");
1531 bytestream2_seek(&s
->g
, atom2_end
, SEEK_SET
);
1535 for (i
= 0; i
< colour_count
; i
++) {
1536 if (colour_depth
[0] <= 8) {
1537 r
= bytestream2_get_byteu(&s
->g
) << 8 - colour_depth
[0];
1538 r
|= r
>> colour_depth
[0];
1540 r
= bytestream2_get_be16u(&s
->g
) >> colour_depth
[0] - 8;
1542 if (colour_depth
[1] <= 8) {
1543 g
= bytestream2_get_byteu(&s
->g
) << 8 - colour_depth
[1];
1544 r
|= r
>> colour_depth
[1];
1546 g
= bytestream2_get_be16u(&s
->g
) >> colour_depth
[1] - 8;
1548 if (colour_depth
[2] <= 8) {
1549 b
= bytestream2_get_byteu(&s
->g
) << 8 - colour_depth
[2];
1550 r
|= r
>> colour_depth
[2];
1552 b
= bytestream2_get_be16u(&s
->g
) >> colour_depth
[2] - 8;
1554 s
->palette
[i
] = 0xffu
<< 24 | r
<< 16 | g
<< 8 | b
;
1556 } else if (atom2
== MKBETAG('c','d','e','f') && atom2_size
>= 2) {
1557 int n
= bytestream2_get_be16u(&s
->g
);
1559 int cn
= bytestream2_get_be16(&s
->g
);
1560 int av_unused typ
= bytestream2_get_be16(&s
->g
);
1561 int asoc
= bytestream2_get_be16(&s
->g
);
1562 if (cn
< 4 || asoc
< 4)
1566 bytestream2_seek(&s
->g
, atom2_end
, SEEK_SET
);
1567 } while (atom_end
- atom2_end
>= 8);
1571 bytestream2_seek(&s
->g
, atom_end
, SEEK_SET
);
1577 static av_cold
int jpeg2000_decode_init(AVCodecContext
*avctx
)
1579 Jpeg2000DecoderContext
*s
= avctx
->priv_data
;
1581 ff_jpeg2000dsp_init(&s
->dsp
);
1586 static int jpeg2000_decode_frame(AVCodecContext
*avctx
, void *data
,
1587 int *got_frame
, AVPacket
*avpkt
)
1589 Jpeg2000DecoderContext
*s
= avctx
->priv_data
;
1590 ThreadFrame frame
= { .f
= data
};
1591 AVFrame
*picture
= data
;
1595 bytestream2_init(&s
->g
, avpkt
->data
, avpkt
->size
);
1597 memset(s
->cdef
, -1, sizeof(s
->cdef
));
1599 if (bytestream2_get_bytes_left(&s
->g
) < 2) {
1600 ret
= AVERROR_INVALIDDATA
;
1604 // check if the image is in jp2 format
1605 if (bytestream2_get_bytes_left(&s
->g
) >= 12 &&
1606 (bytestream2_get_be32u(&s
->g
) == 12) &&
1607 (bytestream2_get_be32u(&s
->g
) == JP2_SIG_TYPE
) &&
1608 (bytestream2_get_be32u(&s
->g
) == JP2_SIG_VALUE
)) {
1609 if (!jp2_find_codestream(s
)) {
1610 av_log(avctx
, AV_LOG_ERROR
,
1611 "Could not find Jpeg2000 codestream atom.\n");
1612 ret
= AVERROR_INVALIDDATA
;
1616 bytestream2_seek(&s
->g
, 0, SEEK_SET
);
1619 while (bytestream2_get_bytes_left(&s
->g
) >= 3 && bytestream2_peek_be16(&s
->g
) != JPEG2000_SOC
)
1620 bytestream2_skip(&s
->g
, 1);
1622 if (bytestream2_get_be16u(&s
->g
) != JPEG2000_SOC
) {
1623 av_log(avctx
, AV_LOG_ERROR
, "SOC marker not present\n");
1624 ret
= AVERROR_INVALIDDATA
;
1627 if (ret
= jpeg2000_read_main_headers(s
))
1630 /* get picture buffer */
1631 if ((ret
= ff_thread_get_buffer(avctx
, &frame
, 0)) < 0)
1633 picture
->pict_type
= AV_PICTURE_TYPE_I
;
1634 picture
->key_frame
= 1;
1636 if (ret
= jpeg2000_read_bitstream_packets(s
))
1639 for (tileno
= 0; tileno
< s
->numXtiles
* s
->numYtiles
; tileno
++)
1640 if (ret
= jpeg2000_decode_tile(s
, s
->tile
+ tileno
, picture
))
1643 jpeg2000_dec_cleanup(s
);
1647 if (s
->avctx
->pix_fmt
== AV_PIX_FMT_PAL8
)
1648 memcpy(picture
->data
[1], s
->palette
, 256 * sizeof(uint32_t));
1650 return bytestream2_tell(&s
->g
);
1653 jpeg2000_dec_cleanup(s
);
1657 static av_cold
void jpeg2000_init_static_data(AVCodec
*codec
)
1659 ff_jpeg2000_init_tier1_luts();
1660 ff_mqc_init_context_tables();
1663 #define OFFSET(x) offsetof(Jpeg2000DecoderContext, x)
1664 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
1666 static const AVOption options
[] = {
1667 { "lowres", "Lower the decoding resolution by a power of two",
1668 OFFSET(reduction_factor
), AV_OPT_TYPE_INT
, { .i64
= 0 }, 0, JPEG2000_MAX_RESLEVELS
- 1, VD
},
1672 static const AVProfile profiles
[] = {
1673 { FF_PROFILE_JPEG2000_CSTREAM_RESTRICTION_0
, "JPEG 2000 codestream restriction 0" },
1674 { FF_PROFILE_JPEG2000_CSTREAM_RESTRICTION_1
, "JPEG 2000 codestream restriction 1" },
1675 { FF_PROFILE_JPEG2000_CSTREAM_NO_RESTRICTION
, "JPEG 2000 no codestream restrictions" },
1676 { FF_PROFILE_JPEG2000_DCINEMA_2K
, "JPEG 2000 digital cinema 2K" },
1677 { FF_PROFILE_JPEG2000_DCINEMA_4K
, "JPEG 2000 digital cinema 4K" },
1678 { FF_PROFILE_UNKNOWN
},
1681 static const AVClass jpeg2000_class
= {
1682 .class_name
= "jpeg2000",
1683 .item_name
= av_default_item_name
,
1685 .version
= LIBAVUTIL_VERSION_INT
,
1688 AVCodec ff_jpeg2000_decoder
= {
1690 .long_name
= NULL_IF_CONFIG_SMALL("JPEG 2000"),
1691 .type
= AVMEDIA_TYPE_VIDEO
,
1692 .id
= AV_CODEC_ID_JPEG2000
,
1693 .capabilities
= CODEC_CAP_FRAME_THREADS
,
1694 .priv_data_size
= sizeof(Jpeg2000DecoderContext
),
1695 .init_static_data
= jpeg2000_init_static_data
,
1696 .init
= jpeg2000_decode_init
,
1697 .decode
= jpeg2000_decode_frame
,
1698 .priv_class
= &jpeg2000_class
,
1700 .profiles
= NULL_IF_CONFIG_SMALL(profiles
)