repositories / deb_ffmpeg.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Imported Debian version 2.5.0~trusty1.1
[deb_ffmpeg.git] / ffmpeg / libavcodec / jpeg2000dec.c
CommitLineData
2ba45a60
DM		 1/*
2 * JPEG 2000 image decoder
3 * Copyright (c) 2007 Kamil Nowosad
4 * Copyright (c) 2013 Nicolas Bertrand <nicoinattendu@gmail.com>
5 *
6 * This file is part of FFmpeg.
7 *
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.
12 *
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.
17 *
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
21 */
22
23/**
24 * @file
25 * JPEG 2000 image decoder
26 */
27
28#include <inttypes.h>
29
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"
35#include "avcodec.h"
36#include "bytestream.h"
37#include "internal.h"
38#include "thread.h"
39#include "jpeg2000.h"
f6fa7814 40#include "jpeg2000dsp.h"
2ba45a60
DM		 41
42#define JP2_SIG_TYPE 0x6A502020
43#define JP2_SIG_VALUE 0x0D0A870A
44#define JP2_CODESTREAM 0x6A703263
45#define JP2_HEADER 0x6A703268
46
47#define HAD_COC 0x01
48#define HAD_QCC 0x02
49
50typedef 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
54} Jpeg2000TilePart;
55
56/* RMK: For JPEG2000 DCINEMA 3 tile-parts in a tile
57 * one per component, so tile_part elements have a size of 3 */
58typedef 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
65} Jpeg2000Tile;
66
67typedef struct Jpeg2000DecoderContext {
68 AVClass *class;
69 AVCodecContext *avctx;
70 GetByteContext g;
71
72 int width, height;
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];
78 int cdx[4], cdy[4];
79 int precision;
80 int ncomponents;
81 int colour_space;
82 uint32_t palette[256];
83 int8_t pal8;
84 int cdef[4];
85 int tile_width, tile_height;
86 unsigned numXtiles, numYtiles;
87 int maxtilelen;
88
89 Jpeg2000CodingStyle codsty[4];
90 Jpeg2000QuantStyle qntsty[4];
91
92 int bit_index;
93
94 int curtileno;
95
96 Jpeg2000Tile *tile;
f6fa7814 97 Jpeg2000DSPContext dsp;
2ba45a60
DM		 98
99 /*options parameters*/
100 int reduction_factor;
101} Jpeg2000DecoderContext;
102
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 */
107static int get_bits(Jpeg2000DecoderContext *s, int n)
108{
109 int res = 0;
110
111 while (--n >= 0) {
112 res <<= 1;
113 if (s->bit_index == 0) {
114 s->bit_index = 7 + (bytestream2_get_byte(&s->g) != 0xFFu);
115 }
116 s->bit_index--;
117 res |= (bytestream2_peek_byte(&s->g) >> s->bit_index) & 1;
118 }
119 return res;
120}
121
122static void jpeg2000_flush(Jpeg2000DecoderContext *s)
123{
124 if (bytestream2_get_byte(&s->g) == 0xff)
125 bytestream2_skip(&s->g, 1);
126 s->bit_index = 8;
127}
128
129/* decode the value stored in node */
130static int tag_tree_decode(Jpeg2000DecoderContext *s, Jpeg2000TgtNode *node,
131 int threshold)
132{
133 Jpeg2000TgtNode *stack[30];
134 int sp = -1, curval = 0;
135
136 if (!node)
137 return AVERROR_INVALIDDATA;
138
139 while (node && !node->vis) {
140 stack[++sp] = node;
141 node = node->parent;
142 }
143
144 if (node)
145 curval = node->val;
146 else
147 curval = stack[sp]->val;
148
149 while (curval < threshold && sp >= 0) {
150 if (curval < stack[sp]->val)
151 curval = stack[sp]->val;
152 while (curval < threshold) {
153 int ret;
154 if ((ret = get_bits(s, 1)) > 0) {
155 stack[sp]->vis++;
156 break;
157 } else if (!ret)
158 curval++;
159 else
160 return ret;
161 }
162 stack[sp]->val = curval;
163 sp--;
164 }
165 return curval;
166}
167
168static int pix_fmt_match(enum AVPixelFormat pix_fmt, int components,
169 int bpc, uint32_t log2_chroma_wh, int pal8)
170{
171 int match = 1;
172 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
173
174 if (desc->nb_components != components) {
175 return 0;
176 }
177
178 switch (components) {
179 case 4:
180 match = match && desc->comp[3].depth_minus1 + 1 >= bpc &&
181 (log2_chroma_wh >> 14 & 3) == 0 &&
182 (log2_chroma_wh >> 12 & 3) == 0;
183 case 3:
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;
187 case 2:
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;
191
192 case 1:
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;
197 }
198 return match;
199}
200
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
217
218static const enum AVPixelFormat rgb_pix_fmts[] = {RGB_PIXEL_FORMATS};
219static const enum AVPixelFormat gray_pix_fmts[] = {GRAY_PIXEL_FORMATS};
220static const enum AVPixelFormat yuv_pix_fmts[] = {YUV_PIXEL_FORMATS};
221static const enum AVPixelFormat xyz_pix_fmts[] = {XYZ_PIXEL_FORMATS};
222static const enum AVPixelFormat all_pix_fmts[] = {RGB_PIXEL_FORMATS,
223 GRAY_PIXEL_FORMATS,
224 YUV_PIXEL_FORMATS,
225 XYZ_PIXEL_FORMATS};
226
227/* marker segments */
228/* get sizes and offsets of image, tiles; number of components */
229static int get_siz(Jpeg2000DecoderContext *s)
230{
231 int i;
232 int ncomponents;
233 uint32_t log2_chroma_wh = 0;
234 const enum AVPixelFormat *possible_fmts = NULL;
235 int possible_fmts_nb = 0;
236
237 if (bytestream2_get_bytes_left(&s->g) < 36)
238 return AVERROR_INVALIDDATA;
239
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
250
251 if (s->image_offset_x || s->image_offset_y) {
252 avpriv_request_sample(s->avctx, "Support for image offsets");
253 return AVERROR_PATCHWELCOME;
254 }
255
256 if (ncomponents <= 0) {
257 av_log(s->avctx, AV_LOG_ERROR, "Invalid number of components: %d\n",
258 s->ncomponents);
259 return AVERROR_INVALIDDATA;
260 }
261
262 if (ncomponents > 4) {
263 avpriv_request_sample(s->avctx, "Support for %d components",
264 s->ncomponents);
265 return AVERROR_PATCHWELCOME;
266 }
267
268 s->ncomponents = ncomponents;
269
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;
274 }
275
276 if (bytestream2_get_bytes_left(&s->g) < 3 * s->ncomponents)
277 return AVERROR_INVALIDDATA;
278
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;
290 }
291 log2_chroma_wh |= s->cdy[i] >> 1 << i * 4 | s->cdx[i] >> 1 << i * 4 + 2;
292 }
293
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);
296
297 if (s->numXtiles * (uint64_t)s->numYtiles > INT_MAX/sizeof(*s->tile)) {
298 s->numXtiles = s->numYtiles = 0;
299 return AVERROR(EINVAL);
300 }
301
302 s->tile = av_mallocz_array(s->numXtiles * s->numYtiles, sizeof(*s->tile));
303 if (!s->tile) {
304 s->numXtiles = s->numYtiles = 0;
305 return AVERROR(ENOMEM);
306 }
307
308 for (i = 0; i < s->numXtiles * s->numYtiles; i++) {
309 Jpeg2000Tile *tile = s->tile + i;
310
311 tile->comp = av_mallocz(s->ncomponents * sizeof(*tile->comp));
312 if (!tile->comp)
313 return AVERROR(ENOMEM);
314 }
315
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);
321
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);
326 } else {
327 switch (s->colour_space) {
328 case 16:
329 possible_fmts = rgb_pix_fmts;
330 possible_fmts_nb = FF_ARRAY_ELEMS(rgb_pix_fmts);
331 break;
332 case 17:
333 possible_fmts = gray_pix_fmts;
334 possible_fmts_nb = FF_ARRAY_ELEMS(gray_pix_fmts);
335 break;
336 case 18:
337 possible_fmts = yuv_pix_fmts;
338 possible_fmts_nb = FF_ARRAY_ELEMS(yuv_pix_fmts);
339 break;
340 default:
341 possible_fmts = all_pix_fmts;
342 possible_fmts_nb = FF_ARRAY_ELEMS(all_pix_fmts);
343 break;
344 }
345 }
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];
349 break;
350 }
351 }
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;
363 }
364 s->avctx->bits_per_raw_sample = s->precision;
365 return 0;
366}
367
368/* get common part for COD and COC segments */
369static int get_cox(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c)
370{
371 uint8_t byte;
372
373 if (bytestream2_get_bytes_left(&s->g) < 5)
374 return AVERROR_INVALIDDATA;
375
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;
382 }
383
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);
392 }
393
394 /* compute number of resolution levels to decode */
395 c->nreslevels2decode = c->nreslevels - s->reduction_factor;
396
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
399
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;
404 }
405
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;
409 }
410
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);
414 }
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;
419
420 if (c->csty & JPEG2000_CSTY_PREC) {
421 int i;
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
426 }
427 } else {
428 memset(c->log2_prec_widths , 15, sizeof(c->log2_prec_widths ));
429 memset(c->log2_prec_heights, 15, sizeof(c->log2_prec_heights));
430 }
431 return 0;
432}
433
434/* get coding parameters for a particular tile or whole image*/
435static int get_cod(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c,
436 uint8_t *properties)
437{
438 Jpeg2000CodingStyle tmp;
439 int compno, ret;
440
441 if (bytestream2_get_bytes_left(&s->g) < 5)
442 return AVERROR_INVALIDDATA;
443
444 tmp.csty = bytestream2_get_byteu(&s->g);
445
446 // get progression order
447 tmp.prog_order = bytestream2_get_byteu(&s->g);
448
449 tmp.nlayers = bytestream2_get_be16u(&s->g);
450 tmp.mct = bytestream2_get_byteu(&s->g); // multiple component transformation
451
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;
457 }
458
459 if ((ret = get_cox(s, &tmp)) < 0)
460 return ret;
461
462 for (compno = 0; compno < s->ncomponents; compno++)
463 if (!(properties[compno] & HAD_COC))
464 memcpy(c + compno, &tmp, sizeof(tmp));
465 return 0;
466}
467
468/* Get coding parameters for a component in the whole image or a
469 * particular tile. */
470static int get_coc(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c,
471 uint8_t *properties)
472{
473 int compno, ret;
474
475 if (bytestream2_get_bytes_left(&s->g) < 2)
476 return AVERROR_INVALIDDATA;
477
478 compno = bytestream2_get_byteu(&s->g);
479
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;
485 }
486
487 c += compno;
488 c->csty = bytestream2_get_byteu(&s->g);
489
490 if ((ret = get_cox(s, c)) < 0)
491 return ret;
492
493 properties[compno] |= HAD_COC;
494 return 0;
495}
496
497/* Get common part for QCD and QCC segments. */
498static int get_qcx(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q)
499{
500 int i, x;
501
502 if (bytestream2_get_bytes_left(&s->g) < 1)
503 return AVERROR_INVALIDDATA;
504
505 x = bytestream2_get_byteu(&s->g); // Sqcd
506
507 q->nguardbits = x >> 5;
508 q->quantsty = x & 0x1f;
509
510 if (q->quantsty == JPEG2000_QSTY_NONE) {
511 n -= 3;
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];
527 }
528 } else {
529 n = (n - 3) >> 1;
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;
537 }
538 }
539 return 0;
540}
541
542/* Get quantization parameters for a particular tile or a whole image. */
543static int get_qcd(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q,
544 uint8_t *properties)
545{
546 Jpeg2000QuantStyle tmp;
547 int compno, ret;
548
549 memset(&tmp, 0, sizeof(tmp));
550
551 if ((ret = get_qcx(s, n, &tmp)) < 0)
552 return ret;
553 for (compno = 0; compno < s->ncomponents; compno++)
554 if (!(properties[compno] & HAD_QCC))
555 memcpy(q + compno, &tmp, sizeof(tmp));
556 return 0;
557}
558
559/* Get quantization parameters for a component in the whole image
560 * on in a particular tile. */
561static int get_qcc(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q,
562 uint8_t *properties)
563{
564 int compno;
565
566 if (bytestream2_get_bytes_left(&s->g) < 1)
567 return AVERROR_INVALIDDATA;
568
569 compno = bytestream2_get_byteu(&s->g);
570
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;
576 }
577
578 properties[compno] |= HAD_QCC;
579 return get_qcx(s, n - 1, q + compno);
580}
581
582/* Get start of tile segment. */
583static int get_sot(Jpeg2000DecoderContext *s, int n)
584{
585 Jpeg2000TilePart *tp;
586 uint16_t Isot;
587 uint32_t Psot;
588 uint8_t TPsot;
589
590 if (bytestream2_get_bytes_left(&s->g) < 8)
591 return AVERROR_INVALIDDATA;
592
593 s->curtileno = 0;
594 Isot = bytestream2_get_be16u(&s->g); // Isot
595 if (Isot >= s->numXtiles * s->numYtiles)
596 return AVERROR_INVALIDDATA;
597
598 s->curtileno = Isot;
599 Psot = bytestream2_get_be32u(&s->g); // Psot
600 TPsot = bytestream2_get_byteu(&s->g); // TPsot
601
602 /* Read TNSot but not used */
603 bytestream2_get_byteu(&s->g); // TNsot
604
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;
608 }
609
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;
613 }
614
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;
619
620 if (!TPsot) {
621 Jpeg2000Tile *tile = s->tile + s->curtileno;
622
623 /* copy defaults */
624 memcpy(tile->codsty, s->codsty, s->ncomponents * sizeof(Jpeg2000CodingStyle));
625 memcpy(tile->qntsty, s->qntsty, s->ncomponents * sizeof(Jpeg2000QuantStyle));
626 }
627
628 return 0;
629}
630
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
637 * buffer.
638 * This marker is mandatory for DCI. */
639static uint8_t get_tlm(Jpeg2000DecoderContext *s, int n)
640{
641 uint8_t Stlm, ST, SP, tile_tlm, i;
642 bytestream2_get_byte(&s->g); /* Ztlm: skipped */
643 Stlm = bytestream2_get_byte(&s->g);
644
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++) {
651 switch (ST) {
652 case 0:
653 break;
654 case 1:
655 bytestream2_get_byte(&s->g);
656 break;
657 case 2:
658 bytestream2_get_be16(&s->g);
659 break;
660 case 3:
661 bytestream2_get_be32(&s->g);
662 break;
663 }
664 if (SP == 0) {
665 bytestream2_get_be16(&s->g);
666 } else {
667 bytestream2_get_be32(&s->g);
668 }
669 }
670 return 0;
671}
672
673static int init_tile(Jpeg2000DecoderContext *s, int tileno)
674{
675 int compno;
676 int tilex = tileno % s->numXtiles;
677 int tiley = tileno / s->numXtiles;
678 Jpeg2000Tile *tile = s->tile + tileno;
679
680 if (!tile->comp)
681 return AVERROR(ENOMEM);
682
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
688
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);
693
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);
698
699 if (ret = ff_jpeg2000_init_component(comp, codsty, qntsty,
700 s->cbps[compno], s->cdx[compno],
701 s->cdy[compno], s->avctx))
702 return ret;
703 }
704 return 0;
705}
706
707/* Read the number of coding passes. */
708static int getnpasses(Jpeg2000DecoderContext *s)
709{
710 int num;
711 if (!get_bits(s, 1))
712 return 1;
713 if (!get_bits(s, 1))
714 return 2;
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;
721}
722
723static int getlblockinc(Jpeg2000DecoderContext *s)
724{
725 int res = 0, ret;
726 while (ret = get_bits(s, 1)) {
727 if (ret < 0)
728 return ret;
729 res++;
730 }
731 return res;
732}
733
734static int jpeg2000_decode_packet(Jpeg2000DecoderContext *s,
735 Jpeg2000CodingStyle *codsty,
736 Jpeg2000ResLevel *rlevel, int precno,
737 int layno, uint8_t *expn, int numgbits)
738{
739 int bandno, cblkno, ret, nb_code_blocks;
740
741 if (!(ret = get_bits(s, 1))) {
742 jpeg2000_flush(s);
743 return 0;
744 } else if (ret < 0)
745 return ret;
746
747 for (bandno = 0; bandno < rlevel->nbands; bandno++) {
748 Jpeg2000Band *band = rlevel->band + bandno;
749 Jpeg2000Prec *prec = band->prec + precno;
750
751 if (band->coord[0][0] == band->coord[0][1] ||
752 band->coord[1][0] == band->coord[1][1])
753 continue;
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;
759
760 if (cblk->npasses)
761 incl = get_bits(s, 1);
762 else
763 incl = tag_tree_decode(s, prec->cblkincl + cblkno, layno + 1) == layno;
764 if (!incl)
765 continue;
766 else if (incl < 0)
767 return incl;
768
769 if (!cblk->npasses) {
770 int v = expn[bandno] + numgbits - 1 -
771 tag_tree_decode(s, prec->zerobits + cblkno, 100);
772 if (v < 0) {
773 av_log(s->avctx, AV_LOG_ERROR,
774 "nonzerobits %d invalid\n", v);
775 return AVERROR_INVALIDDATA;
776 }
777 cblk->nonzerobits = v;
778 }
779 if ((newpasses = getnpasses(s)) < 0)
780 return newpasses;
781 if ((llen = getlblockinc(s)) < 0)
782 return llen;
783 cblk->lblock += llen;
784 if ((ret = get_bits(s, av_log2(newpasses) + cblk->lblock)) < 0)
785 return ret;
786 if (ret > sizeof(cblk->data)) {
787 avpriv_request_sample(s->avctx,
788 "Block with lengthinc greater than %"SIZE_SPECIFIER"",
789 sizeof(cblk->data));
790 return AVERROR_PATCHWELCOME;
791 }
792 cblk->lengthinc = ret;
793 cblk->npasses += newpasses;
794 }
795 }
796 jpeg2000_flush(s);
797
798 if (codsty->csty & JPEG2000_CSTY_EPH) {
799 if (bytestream2_peek_be16(&s->g) == JPEG2000_EPH)
800 bytestream2_skip(&s->g, 2);
801 else
802 av_log(s->avctx, AV_LOG_ERROR, "EPH marker not found.\n");
803 }
804
805 for (bandno = 0; bandno < rlevel->nbands; bandno++) {
806 Jpeg2000Band *band = rlevel->band + bandno;
807 Jpeg2000Prec *prec = band->prec + precno;
808
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
814 ) {
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;
819 }
820
821 bytestream2_get_bufferu(&s->g, cblk->data + cblk->length, cblk->lengthinc);
822 cblk->length += cblk->lengthinc;
823 cblk->lengthinc = 0;
824 }
825 }
826 return 0;
827}
828
829static int jpeg2000_decode_packets(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
830{
831 int ret = 0;
832 int layno, reslevelno, compno, precno, ok_reslevel;
833 int x, y;
834
835 s->bit_index = 8;
836 switch (tile->codsty[0].prog_order) {
837 case JPEG2000_PGOD_RLCP:
838 avpriv_request_sample(s->avctx, "Progression order RLCP");
839
840 case JPEG2000_PGOD_LRCP:
841 for (layno = 0; layno < tile->codsty[0].nlayers; layno++) {
842 ok_reslevel = 1;
843 for (reslevelno = 0; ok_reslevel; reslevelno++) {
844 ok_reslevel = 0;
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 +
850 reslevelno;
851 ok_reslevel = 1;
852 for (precno = 0; precno < rlevel->num_precincts_x * rlevel->num_precincts_y; precno++)
853 if ((ret = jpeg2000_decode_packet(s,
854 codsty, rlevel,
855 precno, layno,
856 qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
857 qntsty->nguardbits)) < 0)
858 return ret;
859 }
860 }
861 }
862 }
863 break;
864
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;
869
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;
874
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++) {
884 uint16_t prcx, prcy;
885 uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
886 Jpeg2000ResLevel *rlevel = tile->comp[compno].reslevel + reslevelno;
887
888 if (!((y % (1 << (rlevel->log2_prec_height + reducedresno)) == 0) ||
889 (y == 0))) // TODO: 2nd condition simplified as try0 always =0 for dcinema
890 continue;
891
892 if (!((x % (1 << (rlevel->log2_prec_width + reducedresno)) == 0) ||
893 (x == 0))) // TODO: 2nd condition simplified as try0 always =0 for dcinema
894 continue;
895
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;
900
901 if (prcx >= rlevel->num_precincts_x || prcy >= rlevel->num_precincts_y)
902 return AVERROR_PATCHWELCOME;
903
904 for (layno = 0; layno < tile->codsty[0].nlayers; layno++) {
905 if ((ret = jpeg2000_decode_packet(s, codsty, rlevel,
906 precno, layno,
907 qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
908 qntsty->nguardbits)) < 0)
909 return ret;
910 }
911 }
912 }
913 }
914 }
915 break;
916
917 case JPEG2000_PGOD_RPCL:
918 avpriv_request_sample(s->avctx, "Progression order RPCL");
919 ret = AVERROR_PATCHWELCOME;
920 break;
921
922 case JPEG2000_PGOD_PCRL:
923 avpriv_request_sample(s->avctx, "Progression order PCRL");
924 ret = AVERROR_PATCHWELCOME;
925 break;
926
927 default:
928 break;
929 }
930
931 /* EOC marker reached */
932 bytestream2_skip(&s->g, 2);
933
934 return ret;
935}
936
937/* TIER-1 routines */
938static 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)
941{
942 int mask = 3 << (bpno - 1), y0, x, y;
943
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))) {
949 int flags_mask = -1;
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;
956 else
957 t1->data[y][x] = (ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ctxno) ^ xorbit) ?
958 -mask : mask;
959
960 ff_jpeg2000_set_significance(t1, x, y,
961 t1->data[y][x] < 0);
962 }
963 t1->flags[y + 1][x + 1] |= JPEG2000_T1_VIS;
964 }
965 }
966}
967
968static void decode_refpass(Jpeg2000T1Context *t1, int width, int height,
969 int bpno)
970{
971 int phalf, nhalf;
972 int y0, x, y;
973
974 phalf = 1 << (bpno - 1);
975 nhalf = -phalf;
976
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)
984 ? phalf : nhalf;
985 t1->data[y][x] += t1->data[y][x] < 0 ? -r : r;
986 t1->flags[y + 1][x + 1] |= JPEG2000_T1_REF;
987 }
988}
989
990static 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)
993{
994 int mask = 3 << (bpno - 1), y0, x, y, runlen, dec;
995
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))
1004 continue;
1005 runlen = ff_mqc_decode(&t1->mqc,
1006 t1->mqc.cx_states + MQC_CX_UNI);
1007 runlen = (runlen << 1) | ff_mqc_decode(&t1->mqc,
1008 t1->mqc.cx_states +
1009 MQC_CX_UNI);
1010 dec = 1;
1011 } else {
1012 runlen = 0;
1013 dec = 0;
1014 }
1015
1016 for (y = y0 + runlen; y < y0 + 4 && y < height; y++) {
1017 if (!dec) {
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,
1023 bandno));
1024 }
1025 }
1026 if (dec) {
1027 int xorbit;
1028 int ctxno = ff_jpeg2000_getsgnctxno(t1->flags[y + 1][x + 1],
1029 &xorbit);
1030 t1->data[y][x] = (ff_mqc_decode(&t1->mqc,
1031 t1->mqc.cx_states + ctxno) ^
1032 xorbit)
1033 ? -mask : mask;
1034 ff_jpeg2000_set_significance(t1, x, y, t1->data[y][x] < 0);
1035 }
1036 dec = 0;
1037 t1->flags[y + 1][x + 1] &= ~JPEG2000_T1_VIS;
1038 }
1039 }
1040 }
1041 if (seg_symbols) {
1042 int val;
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);
1047 if (val != 0xa)
1048 av_log(s->avctx, AV_LOG_ERROR,
1049 "Segmentation symbol value incorrect\n");
1050 }
1051}
1052
1053static int decode_cblk(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *codsty,
1054 Jpeg2000T1Context *t1, Jpeg2000Cblk *cblk,
1055 int width, int height, int bandpos)
1056{
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;
1061
1062 av_assert0(width <= JPEG2000_MAX_CBLKW);
1063 av_assert0(height <= JPEG2000_MAX_CBLKH);
1064
1065 for (y = 0; y < height; y++)
1066 memset(t1->data[y], 0, width * sizeof(**t1->data));
1067
1068 /* If code-block contains no compressed data: nothing to do. */
1069 if (!cblk->length)
1070 return 0;
1071
1072 for (y = 0; y < height + 2; y++)
1073 memset(t1->flags[y], 0, (width + 2) * sizeof(**t1->flags));
1074
1075 cblk->data[cblk->length] = 0xff;
1076 cblk->data[cblk->length+1] = 0xff;
1077 ff_mqc_initdec(&t1->mqc, cblk->data);
1078
1079 while (passno--) {
1080 switch(pass_t) {
1081 case 0:
1082 decode_sigpass(t1, width, height, bpno + 1, bandpos,
1083 bpass_csty_symbol && (clnpass_cnt >= 4),
1084 vert_causal_ctx_csty_symbol);
1085 break;
1086 case 1:
1087 decode_refpass(t1, width, height, bpno + 1);
1088 if (bpass_csty_symbol && clnpass_cnt >= 4)
1089 ff_mqc_initdec(&t1->mqc, cblk->data);
1090 break;
1091 case 2:
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);
1098 break;
1099 }
1100
1101 pass_t++;
1102 if (pass_t == 3) {
1103 bpno--;
1104 pass_t = 0;
1105 }
1106 }
1107 return 0;
1108}
1109
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 */
1115
1116/* Float dequantization of a codeblock.*/
1117static void dequantization_float(int x, int y, Jpeg2000Cblk *cblk,
1118 Jpeg2000Component *comp,
1119 Jpeg2000T1Context *t1, Jpeg2000Band *band)
1120{
1121 int i, j;
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;
1128 }
1129}
1130
1131/* Integer dequantization of a codeblock.*/
1132static void dequantization_int(int x, int y, Jpeg2000Cblk *cblk,
1133 Jpeg2000Component *comp,
1134 Jpeg2000T1Context *t1, Jpeg2000Band *band)
1135{
1136 int i, j;
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;
1143 }
1144}
1145
f6fa7814 1146static inline void mct_decode(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
2ba45a60
DM		 1147{
1148 int i, csize = 1;
f6fa7814 1149 void *src[3];
2ba45a60
DM		 1150
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");
1154 return;
1155 }
1156
1157 for (i = 0; i < 3; i++)
1158 if (tile->codsty[0].transform == FF_DWT97)
f6fa7814 1159 src[i] = tile->comp[i].f_data;
2ba45a60 1160 else
f6fa7814 1161 src[i] = tile->comp[i].i_data;
2ba45a60
DM		 1162
1163 for (i = 0; i < 2; i++)
1164 csize *= tile->comp[0].coord[i][1] - tile->comp[0].coord[i][0];
1165
f6fa7814 1166 s->dsp.mct_decode[tile->codsty[0].transform](src[0], src[1], src[2], csize);
2ba45a60
DM		 1167}
1168
1169static int jpeg2000_decode_tile(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile,
1170 AVFrame *picture)
1171{
1172 const AVPixFmtDescriptor *pixdesc = av_pix_fmt_desc_get(s->avctx->pix_fmt);
1173 int compno, reslevelno, bandno;
1174 int x, y;
1175 int planar = !!(pixdesc->flags & AV_PIX_FMT_FLAG_PLANAR);
1176 int pixelsize = planar ? 1 : pixdesc->nb_components;
1177
1178 uint8_t *line;
1179 Jpeg2000T1Context t1;
1180
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;
1185
1186 /* Loop on resolution levels */
1187 for (reslevelno = 0; reslevelno < codsty->nreslevels2decode; reslevelno++) {
1188 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1189 /* Loop on bands */
1190 for (bandno = 0; bandno < rlevel->nbands; bandno++) {
1191 int nb_precincts, precno;
1192 Jpeg2000Band *band = rlevel->band + bandno;
1193 int cblkno = 0, bandpos;
1194
1195 bandpos = bandno + (reslevelno > 0);
1196
1197 if (band->coord[0][0] == band->coord[0][1] ||
1198 band->coord[1][0] == band->coord[1][1])
1199 continue;
1200
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;
1205
1206 /* Loop on codeblocks */
1207 for (cblkno = 0; cblkno < prec->nb_codeblocks_width * prec->nb_codeblocks_height; cblkno++) {
1208 int x, y;
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],
1213 bandpos);
1214
1215 x = cblk->coord[0][0];
1216 y = cblk->coord[1][0];
1217
1218 if (codsty->transform == FF_DWT97)
1219 dequantization_float(x, y, cblk, comp, &t1, band);
1220 else
1221 dequantization_int(x, y, cblk, comp, &t1, band);
1222 } /* end cblk */
1223 } /*end prec */
1224 } /* end band */
1225 } /* end reslevel */
1226
1227 /* inverse DWT */
1228 ff_dwt_decode(&comp->dwt, codsty->transform == FF_DWT97 ? (void*)comp->f_data : (void*)comp->i_data);
1229 } /*end comp */
1230
1231 /* inverse MCT transformation */
1232 if (tile->codsty[0].mct)
1233 mct_decode(s, tile);
1234
1235 if (s->cdef[0] < 0) {
1236 for (x = 0; x < s->ncomponents; x++)
1237 s->cdef[x] = x + 1;
1238 if ((s->ncomponents & 1) == 0)
1239 s->cdef[s->ncomponents-1] = 0;
1240 }
1241
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;
1250 int plane = 0;
1251
1252 if (planar)
1253 plane = s->cdef[compno] ? s->cdef[compno]-1 : (s->ncomponents-1);
1254
1255
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]) {
1259 uint8_t *dst;
1260
1261 x = tile->comp[compno].coord[0][0] - s->image_offset_x;
1262 dst = line + x / s->cdx[compno] * pixelsize + compno*!planar;
1263
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);
1270 datap++;
1271 dst += pixelsize;
1272 }
1273 } else {
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);
1279 i_datap++;
1280 dst += pixelsize;
1281 }
1282 }
1283 line += picture->linesize[plane];
1284 }
1285 }
1286 } else {
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 uint16_t *linel;
1293 int cbps = s->cbps[compno];
1294 int w = tile->comp[compno].coord[0][1] - s->image_offset_x;
1295 int plane = 0;
1296
1297 if (planar)
1298 plane = s->cdef[compno] ? s->cdef[compno]-1 : (s->ncomponents-1);
1299
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]) {
1303 uint16_t *dst;
1304
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);
1314 datap++;
1315 dst += pixelsize;
1316 }
1317 } else {
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);
1324 i_datap++;
1325 dst += pixelsize;
1326 }
1327 }
1328 linel += picture->linesize[plane] >> 1;
1329 }
1330 }
1331 }
1332
1333 return 0;
1334}
1335
1336static void jpeg2000_dec_cleanup(Jpeg2000DecoderContext *s)
1337{
1338 int tileno, compno;
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;
1344
1345 ff_jpeg2000_cleanup(comp, codsty);
1346 }
1347 av_freep(&s->tile[tileno].comp);
1348 }
1349 }
1350 av_freep(&s->tile);
1351 memset(s->codsty, 0, sizeof(s->codsty));
1352 memset(s->qntsty, 0, sizeof(s->qntsty));
1353 s->numXtiles = s->numYtiles = 0;
1354}
1355
1356static int jpeg2000_read_main_headers(Jpeg2000DecoderContext *s)
1357{
1358 Jpeg2000CodingStyle *codsty = s->codsty;
1359 Jpeg2000QuantStyle *qntsty = s->qntsty;
1360 uint8_t *properties = s->properties;
1361
1362 for (;;) {
1363 int len, ret = 0;
1364 uint16_t marker;
1365 int oldpos;
1366
1367 if (bytestream2_get_bytes_left(&s->g) < 2) {
1368 av_log(s->avctx, AV_LOG_ERROR, "Missing EOC\n");
1369 break;
1370 }
1371
1372 marker = bytestream2_get_be16u(&s->g);
1373 oldpos = bytestream2_tell(&s->g);
1374
1375 if (marker == JPEG2000_SOD) {
1376 Jpeg2000Tile *tile;
1377 Jpeg2000TilePart *tp;
1378
1379 if (!s->tile) {
1380 av_log(s->avctx, AV_LOG_ERROR, "Missing SIZ\n");
1381 return AVERROR_INVALIDDATA;
1382 }
1383 if (s->curtileno < 0) {
1384 av_log(s->avctx, AV_LOG_ERROR, "Missing SOT\n");
1385 return AVERROR_INVALIDDATA;
1386 }
1387
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;
1393 }
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);
1396
1397 continue;
1398 }
1399 if (marker == JPEG2000_EOC)
1400 break;
1401
1402 len = bytestream2_get_be16(&s->g);
1403 if (len < 2 || bytestream2_get_bytes_left(&s->g) < len - 2)
1404 return AVERROR_INVALIDDATA;
1405
1406 switch (marker) {
1407 case JPEG2000_SIZ:
1408 ret = get_siz(s);
1409 if (!s->tile)
1410 s->numXtiles = s->numYtiles = 0;
1411 break;
1412 case JPEG2000_COC:
1413 ret = get_coc(s, codsty, properties);
1414 break;
1415 case JPEG2000_COD:
1416 ret = get_cod(s, codsty, properties);
1417 break;
1418 case JPEG2000_QCC:
1419 ret = get_qcc(s, len, qntsty, properties);
1420 break;
1421 case JPEG2000_QCD:
1422 ret = get_qcd(s, len, qntsty, properties);
1423 break;
1424 case JPEG2000_SOT:
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;
1430 }
1431 break;
1432 case JPEG2000_COM:
1433 // the comment is ignored
1434 bytestream2_skip(&s->g, len - 2);
1435 break;
1436 case JPEG2000_TLM:
1437 // Tile-part lengths
1438 ret = get_tlm(s, len);
1439 break;
1440 default:
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);
1445 break;
1446 }
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",
1450 marker);
1451 return ret ? ret : -1;
1452 }
1453 }
1454 return 0;
1455}
1456
1457/* Read bit stream packets --> T2 operation. */
1458static int jpeg2000_read_bitstream_packets(Jpeg2000DecoderContext *s)
1459{
1460 int ret = 0;
1461 int tileno;
1462
1463 for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++) {
1464 Jpeg2000Tile *tile = s->tile + tileno;
1465
1466 if (ret = init_tile(s, tileno))
1467 return ret;
1468
1469 s->g = tile->tile_part[0].tpg;
1470 if (ret = jpeg2000_decode_packets(s, tile))
1471 return ret;
1472 }
1473
1474 return 0;
1475}
1476
1477static int jp2_find_codestream(Jpeg2000DecoderContext *s)
1478{
1479 uint32_t atom_size, atom, atom_end;
1480 int search_range = 10;
1481
1482 while (search_range
1483 &&
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;
1488
1489 if (atom == JP2_CODESTREAM)
1490 return 1;
1491
1492 if (bytestream2_get_bytes_left(&s->g) < atom_size || atom_end < atom_size)
1493 return 0;
1494
1495 if (atom == JP2_HEADER &&
1496 atom_size >= 16) {
1497 uint32_t atom2_size, atom2, atom2_end;
1498 do {
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)
1503 break;
1504 if (atom2 == JP2_CODESTREAM) {
1505 return 1;
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);
1509 if (method == 1) {
1510 s->colour_space = bytestream2_get_be32u(&s->g);
1511 }
1512 } else if (atom2 == MKBETAG('p','c','l','r') && atom2_size >= 6) {
1513 int i, size, colour_count, colour_channels, colour_depth[3];
1514 uint32_t r, g, b;
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);
1532 continue;
1533 }
1534 s->pal8 = 1;
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];
1539 } else {
1540 r = bytestream2_get_be16u(&s->g) >> colour_depth[0] - 8;
1541 }
1542 if (colour_depth[1] <= 8) {
1543 g = bytestream2_get_byteu(&s->g) << 8 - colour_depth[1];
1544 r |= r >> colour_depth[1];
1545 } else {
1546 g = bytestream2_get_be16u(&s->g) >> colour_depth[1] - 8;
1547 }
1548 if (colour_depth[2] <= 8) {
1549 b = bytestream2_get_byteu(&s->g) << 8 - colour_depth[2];
1550 r |= r >> colour_depth[2];
1551 } else {
1552 b = bytestream2_get_be16u(&s->g) >> colour_depth[2] - 8;
1553 }
1554 s->palette[i] = 0xffu << 24 | r << 16 | g << 8 | b;
1555 }
1556 } else if (atom2 == MKBETAG('c','d','e','f') && atom2_size >= 2) {
1557 int n = bytestream2_get_be16u(&s->g);
1558 for (; n>0; n--) {
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)
1563 s->cdef[cn] = asoc;
1564 }
1565 }
1566 bytestream2_seek(&s->g, atom2_end, SEEK_SET);
1567 } while (atom_end - atom2_end >= 8);
1568 } else {
1569 search_range--;
1570 }
1571 bytestream2_seek(&s->g, atom_end, SEEK_SET);
1572 }
1573
1574 return 0;
1575}
1576
f6fa7814
DM		 1577static av_cold int jpeg2000_decode_init(AVCodecContext *avctx)
1578{
1579 Jpeg2000DecoderContext *s = avctx->priv_data;
1580
1581 ff_jpeg2000dsp_init(&s->dsp);
1582
1583 return 0;
1584}
1585
2ba45a60
DM		 1586static int jpeg2000_decode_frame(AVCodecContext *avctx, void *data,
1587 int *got_frame, AVPacket *avpkt)
1588{
1589 Jpeg2000DecoderContext *s = avctx->priv_data;
1590 ThreadFrame frame = { .f = data };
1591 AVFrame *picture = data;
1592 int tileno, ret;
1593
1594 s->avctx = avctx;
1595 bytestream2_init(&s->g, avpkt->data, avpkt->size);
1596 s->curtileno = -1;
1597 memset(s->cdef, -1, sizeof(s->cdef));
1598
1599 if (bytestream2_get_bytes_left(&s->g) < 2) {
1600 ret = AVERROR_INVALIDDATA;
1601 goto end;
1602 }
1603
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;
1613 goto end;
1614 }
1615 } else {
1616 bytestream2_seek(&s->g, 0, SEEK_SET);
1617 }
1618
1619 while (bytestream2_get_bytes_left(&s->g) >= 3 && bytestream2_peek_be16(&s->g) != JPEG2000_SOC)
1620 bytestream2_skip(&s->g, 1);
1621
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;
1625 goto end;
1626 }
1627 if (ret = jpeg2000_read_main_headers(s))
1628 goto end;
1629
1630 /* get picture buffer */
1631 if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
1632 goto end;
1633 picture->pict_type = AV_PICTURE_TYPE_I;
1634 picture->key_frame = 1;
1635
1636 if (ret = jpeg2000_read_bitstream_packets(s))
1637 goto end;
1638
1639 for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++)
1640 if (ret = jpeg2000_decode_tile(s, s->tile + tileno, picture))
1641 goto end;
1642
1643 jpeg2000_dec_cleanup(s);
1644
1645 *got_frame = 1;
1646
1647 if (s->avctx->pix_fmt == AV_PIX_FMT_PAL8)
1648 memcpy(picture->data[1], s->palette, 256 * sizeof(uint32_t));
1649
1650 return bytestream2_tell(&s->g);
1651
1652end:
1653 jpeg2000_dec_cleanup(s);
1654 return ret;
1655}
1656
1657static av_cold void jpeg2000_init_static_data(AVCodec *codec)
1658{
1659 ff_jpeg2000_init_tier1_luts();
1660 ff_mqc_init_context_tables();
1661}
1662
1663#define OFFSET(x) offsetof(Jpeg2000DecoderContext, x)
1664#define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
1665
1666static 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 },
1669 { NULL },
1670};
1671
1672static 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 },
1679};
1680
1681static const AVClass jpeg2000_class = {
1682 .class_name = "jpeg2000",
1683 .item_name = av_default_item_name,
1684 .option = options,
1685 .version = LIBAVUTIL_VERSION_INT,
1686};
1687
1688AVCodec ff_jpeg2000_decoder = {
1689 .name = "jpeg2000",
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,
f6fa7814 1696 .init = jpeg2000_decode_init,
2ba45a60
DM		 1697 .decode = jpeg2000_decode_frame,
1698 .priv_class = &jpeg2000_class,
1699 .max_lowres = 5,
1700 .profiles = NULL_IF_CONFIG_SMALL(profiles)
1701};
ffmpeg Piment Noir Debian package repository