17ee5418c0033b58a6f92decbd1c9eb19d9157aa
[ffmpeg.git] / libavcodec / jpeg2000dec.c
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"
40 #include "jpeg2000dsp.h"
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
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
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 */
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
65 } Jpeg2000Tile;
66
67 typedef 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;
97     Jpeg2000DSPContext dsp;
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 */
107 static 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
122 static 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 */
130 static 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
168 static 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
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,
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 */
229 static 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 */
369 static 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*/
435 static 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. */
470 static 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. */
498 static 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. */
543 static 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. */
561 static 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. */
583 static 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. */
639 static 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
673 static 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. */
708 static 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
723 static 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
734 static 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
829 static 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 */
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)
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
968 static 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
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)
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
1053 static 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.*/
1117 static 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.*/
1132 static 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
1146 static inline void mct_decode(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
1147 {
1148     int i, csize = 1;
1149     void *src[3];
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)
1159             src[i] = tile->comp[i].f_data;
1160         else
1161             src[i] = tile->comp[i].i_data;
1162
1163     for (i = 0; i < 2; i++)
1164         csize *= tile->comp[0].coord[i][1] - tile->comp[0].coord[i][0];
1165
1166     s->dsp.mct_decode[tile->codsty[0].transform](src[0], src[1], src[2], csize);
1167 }
1168
1169 static 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
1336 static 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
1356 static 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. */
1458 static 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
1477 static 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
1577 static 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
1586 static 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
1652 end:
1653     jpeg2000_dec_cleanup(s);
1654     return ret;
1655 }
1656
1657 static 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
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 },
1669     { NULL },
1670 };
1671
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 },
1679 };
1680
1681 static 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
1688 AVCodec 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,
1696     .init             = jpeg2000_decode_init,
1697     .decode           = jpeg2000_decode_frame,
1698     .priv_class       = &jpeg2000_class,
1699     .max_lowres       = 5,
1700     .profiles         = NULL_IF_CONFIG_SMALL(profiles)
1701 };