avcodec/jpeg2000dec: fix context consistency with too large lowres
[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 "libavutil/avassert.h"
29 #include "libavutil/common.h"
30 #include "libavutil/opt.h"
31 #include "libavutil/pixdesc.h"
32 #include "avcodec.h"
33 #include "bytestream.h"
34 #include "internal.h"
35 #include "thread.h"
36 #include "jpeg2000.h"
37
38 #define JP2_SIG_TYPE    0x6A502020
39 #define JP2_SIG_VALUE   0x0D0A870A
40 #define JP2_CODESTREAM  0x6A703263
41 #define JP2_HEADER      0x6A703268
42
43 #define HAD_COC 0x01
44 #define HAD_QCC 0x02
45
46 typedef struct Jpeg2000TilePart {
47     uint8_t tile_index;                 // Tile index who refers the tile-part
48     const uint8_t *tp_end;
49     GetByteContext tpg;                 // bit stream in tile-part
50 } Jpeg2000TilePart;
51
52 /* RMK: For JPEG2000 DCINEMA 3 tile-parts in a tile
53  * one per component, so tile_part elements have a size of 3 */
54 typedef struct Jpeg2000Tile {
55     Jpeg2000Component   *comp;
56     uint8_t             properties[4];
57     Jpeg2000CodingStyle codsty[4];
58     Jpeg2000QuantStyle  qntsty[4];
59     Jpeg2000TilePart    tile_part[4];
60     uint16_t tp_idx;                    // Tile-part index
61 } Jpeg2000Tile;
62
63 typedef struct Jpeg2000DecoderContext {
64     AVClass         *class;
65     AVCodecContext  *avctx;
66     GetByteContext  g;
67
68     int             width, height;
69     int             image_offset_x, image_offset_y;
70     int             tile_offset_x, tile_offset_y;
71     uint8_t         cbps[4];    // bits per sample in particular components
72     uint8_t         sgnd[4];    // if a component is signed
73     uint8_t         properties[4];
74     int             cdx[4], cdy[4];
75     int             precision;
76     int             ncomponents;
77     int             colour_space;
78     uint32_t        palette[256];
79     int8_t          pal8;
80     int             cdef[4];
81     int             tile_width, tile_height;
82     unsigned        numXtiles, numYtiles;
83     int             maxtilelen;
84
85     Jpeg2000CodingStyle codsty[4];
86     Jpeg2000QuantStyle  qntsty[4];
87
88     int             bit_index;
89
90     int             curtileno;
91
92     Jpeg2000Tile    *tile;
93
94     /*options parameters*/
95     int             reduction_factor;
96 } Jpeg2000DecoderContext;
97
98 /* get_bits functions for JPEG2000 packet bitstream
99  * It is a get_bit function with a bit-stuffing routine. If the value of the
100  * byte is 0xFF, the next byte includes an extra zero bit stuffed into the MSB.
101  * cf. ISO-15444-1:2002 / B.10.1 Bit-stuffing routine */
102 static int get_bits(Jpeg2000DecoderContext *s, int n)
103 {
104     int res = 0;
105
106     while (--n >= 0) {
107         res <<= 1;
108         if (s->bit_index == 0) {
109             s->bit_index = 7 + (bytestream2_get_byte(&s->g) != 0xFFu);
110         }
111         s->bit_index--;
112         res |= (bytestream2_peek_byte(&s->g) >> s->bit_index) & 1;
113     }
114     return res;
115 }
116
117 static void jpeg2000_flush(Jpeg2000DecoderContext *s)
118 {
119     if (bytestream2_get_byte(&s->g) == 0xff)
120         bytestream2_skip(&s->g, 1);
121     s->bit_index = 8;
122 }
123
124 /* decode the value stored in node */
125 static int tag_tree_decode(Jpeg2000DecoderContext *s, Jpeg2000TgtNode *node,
126                            int threshold)
127 {
128     Jpeg2000TgtNode *stack[30];
129     int sp = -1, curval = 0;
130
131     if (!node)
132         return AVERROR_INVALIDDATA;
133
134     while (node && !node->vis) {
135         stack[++sp] = node;
136         node        = node->parent;
137     }
138
139     if (node)
140         curval = node->val;
141     else
142         curval = stack[sp]->val;
143
144     while (curval < threshold && sp >= 0) {
145         if (curval < stack[sp]->val)
146             curval = stack[sp]->val;
147         while (curval < threshold) {
148             int ret;
149             if ((ret = get_bits(s, 1)) > 0) {
150                 stack[sp]->vis++;
151                 break;
152             } else if (!ret)
153                 curval++;
154             else
155                 return ret;
156         }
157         stack[sp]->val = curval;
158         sp--;
159     }
160     return curval;
161 }
162
163 static int pix_fmt_match(enum AVPixelFormat pix_fmt, int components,
164                          int bpc, uint32_t log2_chroma_wh, int pal8)
165 {
166     int match = 1;
167     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
168
169     if (desc->nb_components != components) {
170         return 0;
171     }
172
173     switch (components) {
174     case 4:
175         match = match && desc->comp[3].depth_minus1 + 1 >= bpc &&
176                          (log2_chroma_wh >> 14 & 3) == 0 &&
177                          (log2_chroma_wh >> 12 & 3) == 0;
178     case 3:
179         match = match && desc->comp[2].depth_minus1 + 1 >= bpc &&
180                          (log2_chroma_wh >> 10 & 3) == desc->log2_chroma_w &&
181                          (log2_chroma_wh >>  8 & 3) == desc->log2_chroma_h;
182     case 2:
183         match = match && desc->comp[1].depth_minus1 + 1 >= bpc &&
184                          (log2_chroma_wh >>  6 & 3) == desc->log2_chroma_w &&
185                          (log2_chroma_wh >>  4 & 3) == desc->log2_chroma_h;
186
187     case 1:
188         match = match && desc->comp[0].depth_minus1 + 1 >= bpc &&
189                          (log2_chroma_wh >>  2 & 3) == 0 &&
190                          (log2_chroma_wh       & 3) == 0 &&
191                          (desc->flags & AV_PIX_FMT_FLAG_PAL) == pal8 * AV_PIX_FMT_FLAG_PAL;
192     }
193     return match;
194 }
195
196 // pix_fmts with lower bpp have to be listed before
197 // similar pix_fmts with higher bpp.
198 #define RGB_PIXEL_FORMATS   AV_PIX_FMT_PAL8,AV_PIX_FMT_RGB24,AV_PIX_FMT_RGBA,AV_PIX_FMT_RGB48,AV_PIX_FMT_RGBA64
199 #define GRAY_PIXEL_FORMATS  AV_PIX_FMT_GRAY8,AV_PIX_FMT_GRAY8A,AV_PIX_FMT_GRAY16
200 #define YUV_PIXEL_FORMATS   AV_PIX_FMT_YUV410P,AV_PIX_FMT_YUV411P,AV_PIX_FMT_YUVA420P, \
201                             AV_PIX_FMT_YUV420P,AV_PIX_FMT_YUV422P,AV_PIX_FMT_YUVA422P, \
202                             AV_PIX_FMT_YUV440P,AV_PIX_FMT_YUV444P,AV_PIX_FMT_YUVA444P, \
203                             AV_PIX_FMT_YUV420P9,AV_PIX_FMT_YUV422P9,AV_PIX_FMT_YUV444P9, \
204                             AV_PIX_FMT_YUVA420P9,AV_PIX_FMT_YUVA422P9,AV_PIX_FMT_YUVA444P9, \
205                             AV_PIX_FMT_YUV420P10,AV_PIX_FMT_YUV422P10,AV_PIX_FMT_YUV444P10, \
206                             AV_PIX_FMT_YUVA420P10,AV_PIX_FMT_YUVA422P10,AV_PIX_FMT_YUVA444P10, \
207                             AV_PIX_FMT_YUV420P12,AV_PIX_FMT_YUV422P12,AV_PIX_FMT_YUV444P12, \
208                             AV_PIX_FMT_YUV420P14,AV_PIX_FMT_YUV422P14,AV_PIX_FMT_YUV444P14, \
209                             AV_PIX_FMT_YUV420P16,AV_PIX_FMT_YUV422P16,AV_PIX_FMT_YUV444P16, \
210                             AV_PIX_FMT_YUVA420P16,AV_PIX_FMT_YUVA422P16,AV_PIX_FMT_YUVA444P16
211 #define XYZ_PIXEL_FORMATS   AV_PIX_FMT_XYZ12
212
213 static const enum AVPixelFormat rgb_pix_fmts[]  = {RGB_PIXEL_FORMATS};
214 static const enum AVPixelFormat gray_pix_fmts[] = {GRAY_PIXEL_FORMATS};
215 static const enum AVPixelFormat yuv_pix_fmts[]  = {YUV_PIXEL_FORMATS};
216 static const enum AVPixelFormat xyz_pix_fmts[]  = {XYZ_PIXEL_FORMATS};
217 static const enum AVPixelFormat all_pix_fmts[]  = {RGB_PIXEL_FORMATS,
218                                                    GRAY_PIXEL_FORMATS,
219                                                    YUV_PIXEL_FORMATS,
220                                                    XYZ_PIXEL_FORMATS};
221
222 /* marker segments */
223 /* get sizes and offsets of image, tiles; number of components */
224 static int get_siz(Jpeg2000DecoderContext *s)
225 {
226     int i;
227     int ncomponents;
228     uint32_t log2_chroma_wh = 0;
229     const enum AVPixelFormat *possible_fmts = NULL;
230     int possible_fmts_nb = 0;
231
232     if (bytestream2_get_bytes_left(&s->g) < 36)
233         return AVERROR_INVALIDDATA;
234
235     s->avctx->profile = bytestream2_get_be16u(&s->g); // Rsiz
236     s->width          = bytestream2_get_be32u(&s->g); // Width
237     s->height         = bytestream2_get_be32u(&s->g); // Height
238     s->image_offset_x = bytestream2_get_be32u(&s->g); // X0Siz
239     s->image_offset_y = bytestream2_get_be32u(&s->g); // Y0Siz
240     s->tile_width     = bytestream2_get_be32u(&s->g); // XTSiz
241     s->tile_height    = bytestream2_get_be32u(&s->g); // YTSiz
242     s->tile_offset_x  = bytestream2_get_be32u(&s->g); // XT0Siz
243     s->tile_offset_y  = bytestream2_get_be32u(&s->g); // YT0Siz
244     ncomponents       = bytestream2_get_be16u(&s->g); // CSiz
245
246     if (ncomponents <= 0) {
247         av_log(s->avctx, AV_LOG_ERROR, "Invalid number of components: %d\n",
248                s->ncomponents);
249         return AVERROR_INVALIDDATA;
250     }
251
252     if (ncomponents > 4) {
253         avpriv_request_sample(s->avctx, "Support for %d components",
254                               s->ncomponents);
255         return AVERROR_PATCHWELCOME;
256     }
257
258     s->ncomponents = ncomponents;
259
260     if (s->tile_width <= 0 || s->tile_height <= 0) {
261         av_log(s->avctx, AV_LOG_ERROR, "Invalid tile dimension %dx%d.\n",
262                s->tile_width, s->tile_height);
263         return AVERROR_INVALIDDATA;
264     }
265
266     if (bytestream2_get_bytes_left(&s->g) < 3 * s->ncomponents)
267         return AVERROR_INVALIDDATA;
268
269     for (i = 0; i < s->ncomponents; i++) { // Ssiz_i XRsiz_i, YRsiz_i
270         uint8_t x    = bytestream2_get_byteu(&s->g);
271         s->cbps[i]   = (x & 0x7f) + 1;
272         s->precision = FFMAX(s->cbps[i], s->precision);
273         s->sgnd[i]   = !!(x & 0x80);
274         s->cdx[i]    = bytestream2_get_byteu(&s->g);
275         s->cdy[i]    = bytestream2_get_byteu(&s->g);
276         if (   !s->cdx[i] || s->cdx[i] == 3 || s->cdx[i] > 4
277             || !s->cdy[i] || s->cdy[i] == 3 || s->cdy[i] > 4) {
278             av_log(s->avctx, AV_LOG_ERROR, "Invalid sample separation %d/%d\n", s->cdx[i], s->cdy[i]);
279             return AVERROR_INVALIDDATA;
280         }
281         log2_chroma_wh |= s->cdy[i] >> 1 << i * 4 | s->cdx[i] >> 1 << i * 4 + 2;
282     }
283
284     s->numXtiles = ff_jpeg2000_ceildiv(s->width  - s->tile_offset_x, s->tile_width);
285     s->numYtiles = ff_jpeg2000_ceildiv(s->height - s->tile_offset_y, s->tile_height);
286
287     if (s->numXtiles * (uint64_t)s->numYtiles > INT_MAX/sizeof(*s->tile)) {
288         s->numXtiles = s->numYtiles = 0;
289         return AVERROR(EINVAL);
290     }
291
292     s->tile = av_mallocz_array(s->numXtiles * s->numYtiles, sizeof(*s->tile));
293     if (!s->tile) {
294         s->numXtiles = s->numYtiles = 0;
295         return AVERROR(ENOMEM);
296     }
297
298     for (i = 0; i < s->numXtiles * s->numYtiles; i++) {
299         Jpeg2000Tile *tile = s->tile + i;
300
301         tile->comp = av_mallocz(s->ncomponents * sizeof(*tile->comp));
302         if (!tile->comp)
303             return AVERROR(ENOMEM);
304     }
305
306     /* compute image size with reduction factor */
307     s->avctx->width  = ff_jpeg2000_ceildivpow2(s->width  - s->image_offset_x,
308                                                s->reduction_factor);
309     s->avctx->height = ff_jpeg2000_ceildivpow2(s->height - s->image_offset_y,
310                                                s->reduction_factor);
311
312     if (s->avctx->profile == FF_PROFILE_JPEG2000_DCINEMA_2K ||
313         s->avctx->profile == FF_PROFILE_JPEG2000_DCINEMA_4K) {
314         possible_fmts = xyz_pix_fmts;
315         possible_fmts_nb = FF_ARRAY_ELEMS(xyz_pix_fmts);
316     } else {
317         switch (s->colour_space) {
318         case 16:
319             possible_fmts = rgb_pix_fmts;
320             possible_fmts_nb = FF_ARRAY_ELEMS(rgb_pix_fmts);
321             break;
322         case 17:
323             possible_fmts = gray_pix_fmts;
324             possible_fmts_nb = FF_ARRAY_ELEMS(gray_pix_fmts);
325             break;
326         case 18:
327             possible_fmts = yuv_pix_fmts;
328             possible_fmts_nb = FF_ARRAY_ELEMS(yuv_pix_fmts);
329             break;
330         default:
331             possible_fmts = all_pix_fmts;
332             possible_fmts_nb = FF_ARRAY_ELEMS(all_pix_fmts);
333             break;
334         }
335     }
336     for (i = 0; i < possible_fmts_nb; ++i) {
337         if (pix_fmt_match(possible_fmts[i], ncomponents, s->precision, log2_chroma_wh, s->pal8)) {
338             s->avctx->pix_fmt = possible_fmts[i];
339             break;
340         }
341     }
342     if (s->avctx->pix_fmt == AV_PIX_FMT_NONE) {
343         av_log(s->avctx, AV_LOG_ERROR,
344                "Unknown pix_fmt, profile: %d, colour_space: %d, "
345                "components: %d, precision: %d, "
346                "cdx[1]: %d, cdy[1]: %d, cdx[2]: %d, cdy[2]: %d\n",
347                s->avctx->profile, s->colour_space, ncomponents, s->precision,
348                ncomponents > 2 ? s->cdx[1] : 0,
349                ncomponents > 2 ? s->cdy[1] : 0,
350                ncomponents > 2 ? s->cdx[2] : 0,
351                ncomponents > 2 ? s->cdy[2] : 0);
352     }
353     s->avctx->bits_per_raw_sample = s->precision;
354     return 0;
355 }
356
357 /* get common part for COD and COC segments */
358 static int get_cox(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c)
359 {
360     uint8_t byte;
361
362     if (bytestream2_get_bytes_left(&s->g) < 5)
363         return AVERROR_INVALIDDATA;
364
365     /*  nreslevels = number of resolution levels
366                    = number of decomposition level +1 */
367     c->nreslevels = bytestream2_get_byteu(&s->g) + 1;
368     if (c->nreslevels >= JPEG2000_MAX_RESLEVELS) {
369         av_log(s->avctx, AV_LOG_ERROR, "nreslevels %d is invalid\n", c->nreslevels);
370         return AVERROR_INVALIDDATA;
371     }
372
373     if (c->nreslevels <= s->reduction_factor) {
374         /* we are forced to update reduction_factor as its requested value is
375            not compatible with this bitstream, and as we might have used it
376            already in setup earlier we have to fail this frame until
377            reinitialization is implemented */
378         av_log(s->avctx, AV_LOG_ERROR, "reduction_factor too large for this bitstream, max is %d\n", c->nreslevels - 1);
379         s->reduction_factor = c->nreslevels - 1;
380         return AVERROR(EINVAL);
381     }
382
383     /* compute number of resolution levels to decode */
384     c->nreslevels2decode = c->nreslevels - s->reduction_factor;
385
386     c->log2_cblk_width  = (bytestream2_get_byteu(&s->g) & 15) + 2; // cblk width
387     c->log2_cblk_height = (bytestream2_get_byteu(&s->g) & 15) + 2; // cblk height
388
389     if (c->log2_cblk_width > 10 || c->log2_cblk_height > 10 ||
390         c->log2_cblk_width + c->log2_cblk_height > 12) {
391         av_log(s->avctx, AV_LOG_ERROR, "cblk size invalid\n");
392         return AVERROR_INVALIDDATA;
393     }
394
395     if (c->log2_cblk_width > 6 || c->log2_cblk_height > 6) {
396         avpriv_request_sample(s->avctx, "cblk size > 64");
397         return AVERROR_PATCHWELCOME;
398     }
399
400     c->cblk_style = bytestream2_get_byteu(&s->g);
401     if (c->cblk_style != 0) { // cblk style
402         av_log(s->avctx, AV_LOG_WARNING, "extra cblk styles %X\n", c->cblk_style);
403     }
404     c->transform = bytestream2_get_byteu(&s->g); // DWT transformation type
405     /* set integer 9/7 DWT in case of BITEXACT flag */
406     if ((s->avctx->flags & CODEC_FLAG_BITEXACT) && (c->transform == FF_DWT97))
407         c->transform = FF_DWT97_INT;
408
409     if (c->csty & JPEG2000_CSTY_PREC) {
410         int i;
411         for (i = 0; i < c->nreslevels; i++) {
412             byte = bytestream2_get_byte(&s->g);
413             c->log2_prec_widths[i]  =  byte       & 0x0F;    // precinct PPx
414             c->log2_prec_heights[i] = (byte >> 4) & 0x0F;    // precinct PPy
415         }
416     } else {
417         memset(c->log2_prec_widths , 15, sizeof(c->log2_prec_widths ));
418         memset(c->log2_prec_heights, 15, sizeof(c->log2_prec_heights));
419     }
420     return 0;
421 }
422
423 /* get coding parameters for a particular tile or whole image*/
424 static int get_cod(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c,
425                    uint8_t *properties)
426 {
427     Jpeg2000CodingStyle tmp;
428     int compno, ret;
429
430     if (bytestream2_get_bytes_left(&s->g) < 5)
431         return AVERROR_INVALIDDATA;
432
433     tmp.csty = bytestream2_get_byteu(&s->g);
434
435     // get progression order
436     tmp.prog_order = bytestream2_get_byteu(&s->g);
437
438     tmp.nlayers    = bytestream2_get_be16u(&s->g);
439     tmp.mct        = bytestream2_get_byteu(&s->g); // multiple component transformation
440
441     if (tmp.mct && s->ncomponents < 3) {
442         av_log(s->avctx, AV_LOG_ERROR,
443                "MCT %d with too few components (%d)\n",
444                tmp.mct, s->ncomponents);
445         return AVERROR_INVALIDDATA;
446     }
447
448     if ((ret = get_cox(s, &tmp)) < 0)
449         return ret;
450
451     for (compno = 0; compno < s->ncomponents; compno++)
452         if (!(properties[compno] & HAD_COC))
453             memcpy(c + compno, &tmp, sizeof(tmp));
454     return 0;
455 }
456
457 /* Get coding parameters for a component in the whole image or a
458  * particular tile. */
459 static int get_coc(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c,
460                    uint8_t *properties)
461 {
462     int compno, ret;
463
464     if (bytestream2_get_bytes_left(&s->g) < 2)
465         return AVERROR_INVALIDDATA;
466
467     compno = bytestream2_get_byteu(&s->g);
468
469     if (compno >= s->ncomponents) {
470         av_log(s->avctx, AV_LOG_ERROR,
471                "Invalid compno %d. There are %d components in the image.\n",
472                compno, s->ncomponents);
473         return AVERROR_INVALIDDATA;
474     }
475
476     c      += compno;
477     c->csty = bytestream2_get_byteu(&s->g);
478
479     if ((ret = get_cox(s, c)) < 0)
480         return ret;
481
482     properties[compno] |= HAD_COC;
483     return 0;
484 }
485
486 /* Get common part for QCD and QCC segments. */
487 static int get_qcx(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q)
488 {
489     int i, x;
490
491     if (bytestream2_get_bytes_left(&s->g) < 1)
492         return AVERROR_INVALIDDATA;
493
494     x = bytestream2_get_byteu(&s->g); // Sqcd
495
496     q->nguardbits = x >> 5;
497     q->quantsty   = x & 0x1f;
498
499     if (q->quantsty == JPEG2000_QSTY_NONE) {
500         n -= 3;
501         if (bytestream2_get_bytes_left(&s->g) < n ||
502             n > JPEG2000_MAX_DECLEVELS*3)
503             return AVERROR_INVALIDDATA;
504         for (i = 0; i < n; i++)
505             q->expn[i] = bytestream2_get_byteu(&s->g) >> 3;
506     } else if (q->quantsty == JPEG2000_QSTY_SI) {
507         if (bytestream2_get_bytes_left(&s->g) < 2)
508             return AVERROR_INVALIDDATA;
509         x          = bytestream2_get_be16u(&s->g);
510         q->expn[0] = x >> 11;
511         q->mant[0] = x & 0x7ff;
512         for (i = 1; i < JPEG2000_MAX_DECLEVELS * 3; i++) {
513             int curexpn = FFMAX(0, q->expn[0] - (i - 1) / 3);
514             q->expn[i] = curexpn;
515             q->mant[i] = q->mant[0];
516         }
517     } else {
518         n = (n - 3) >> 1;
519         if (bytestream2_get_bytes_left(&s->g) < 2 * n ||
520             n > JPEG2000_MAX_DECLEVELS*3)
521             return AVERROR_INVALIDDATA;
522         for (i = 0; i < n; i++) {
523             x          = bytestream2_get_be16u(&s->g);
524             q->expn[i] = x >> 11;
525             q->mant[i] = x & 0x7ff;
526         }
527     }
528     return 0;
529 }
530
531 /* Get quantization parameters for a particular tile or a whole image. */
532 static int get_qcd(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q,
533                    uint8_t *properties)
534 {
535     Jpeg2000QuantStyle tmp;
536     int compno, ret;
537
538     if ((ret = get_qcx(s, n, &tmp)) < 0)
539         return ret;
540     for (compno = 0; compno < s->ncomponents; compno++)
541         if (!(properties[compno] & HAD_QCC))
542             memcpy(q + compno, &tmp, sizeof(tmp));
543     return 0;
544 }
545
546 /* Get quantization parameters for a component in the whole image
547  * on in a particular tile. */
548 static int get_qcc(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q,
549                    uint8_t *properties)
550 {
551     int compno;
552
553     if (bytestream2_get_bytes_left(&s->g) < 1)
554         return AVERROR_INVALIDDATA;
555
556     compno = bytestream2_get_byteu(&s->g);
557
558     if (compno >= s->ncomponents) {
559         av_log(s->avctx, AV_LOG_ERROR,
560                "Invalid compno %d. There are %d components in the image.\n",
561                compno, s->ncomponents);
562         return AVERROR_INVALIDDATA;
563     }
564
565     properties[compno] |= HAD_QCC;
566     return get_qcx(s, n - 1, q + compno);
567 }
568
569 /* Get start of tile segment. */
570 static int get_sot(Jpeg2000DecoderContext *s, int n)
571 {
572     Jpeg2000TilePart *tp;
573     uint16_t Isot;
574     uint32_t Psot;
575     uint8_t TPsot;
576
577     if (bytestream2_get_bytes_left(&s->g) < 8)
578         return AVERROR_INVALIDDATA;
579
580     s->curtileno = 0;
581     Isot = bytestream2_get_be16u(&s->g);        // Isot
582     if (Isot >= s->numXtiles * s->numYtiles)
583         return AVERROR_INVALIDDATA;
584
585     s->curtileno = Isot;
586     Psot  = bytestream2_get_be32u(&s->g);       // Psot
587     TPsot = bytestream2_get_byteu(&s->g);       // TPsot
588
589     /* Read TNSot but not used */
590     bytestream2_get_byteu(&s->g);               // TNsot
591
592     if (Psot > bytestream2_get_bytes_left(&s->g) + n + 2) {
593         av_log(s->avctx, AV_LOG_ERROR, "Psot %d too big\n", Psot);
594         return AVERROR_INVALIDDATA;
595     }
596
597     if (TPsot >= FF_ARRAY_ELEMS(s->tile[Isot].tile_part)) {
598         avpriv_request_sample(s->avctx, "Support for %d components", TPsot);
599         return AVERROR_PATCHWELCOME;
600     }
601
602     s->tile[Isot].tp_idx = TPsot;
603     tp             = s->tile[Isot].tile_part + TPsot;
604     tp->tile_index = Isot;
605     tp->tp_end     = s->g.buffer + Psot - n - 2;
606
607     if (!TPsot) {
608         Jpeg2000Tile *tile = s->tile + s->curtileno;
609
610         /* copy defaults */
611         memcpy(tile->codsty, s->codsty, s->ncomponents * sizeof(Jpeg2000CodingStyle));
612         memcpy(tile->qntsty, s->qntsty, s->ncomponents * sizeof(Jpeg2000QuantStyle));
613     }
614
615     return 0;
616 }
617
618 /* Tile-part lengths: see ISO 15444-1:2002, section A.7.1
619  * Used to know the number of tile parts and lengths.
620  * There may be multiple TLMs in the header.
621  * TODO: The function is not used for tile-parts management, nor anywhere else.
622  * It can be useful to allocate memory for tile parts, before managing the SOT
623  * markers. Parsing the TLM header is needed to increment the input header
624  * buffer.
625  * This marker is mandatory for DCI. */
626 static uint8_t get_tlm(Jpeg2000DecoderContext *s, int n)
627 {
628     uint8_t Stlm, ST, SP, tile_tlm, i;
629     bytestream2_get_byte(&s->g);               /* Ztlm: skipped */
630     Stlm = bytestream2_get_byte(&s->g);
631
632     // too complex ? ST = ((Stlm >> 4) & 0x01) + ((Stlm >> 4) & 0x02);
633     ST = (Stlm >> 4) & 0x03;
634     // TODO: Manage case of ST = 0b11 --> raise error
635     SP       = (Stlm >> 6) & 0x01;
636     tile_tlm = (n - 4) / ((SP + 1) * 2 + ST);
637     for (i = 0; i < tile_tlm; i++) {
638         switch (ST) {
639         case 0:
640             break;
641         case 1:
642             bytestream2_get_byte(&s->g);
643             break;
644         case 2:
645             bytestream2_get_be16(&s->g);
646             break;
647         case 3:
648             bytestream2_get_be32(&s->g);
649             break;
650         }
651         if (SP == 0) {
652             bytestream2_get_be16(&s->g);
653         } else {
654             bytestream2_get_be32(&s->g);
655         }
656     }
657     return 0;
658 }
659
660 static int init_tile(Jpeg2000DecoderContext *s, int tileno)
661 {
662     int compno;
663     int tilex = tileno % s->numXtiles;
664     int tiley = tileno / s->numXtiles;
665     Jpeg2000Tile *tile = s->tile + tileno;
666
667     if (!tile->comp)
668         return AVERROR(ENOMEM);
669
670     for (compno = 0; compno < s->ncomponents; compno++) {
671         Jpeg2000Component *comp = tile->comp + compno;
672         Jpeg2000CodingStyle *codsty = tile->codsty + compno;
673         Jpeg2000QuantStyle  *qntsty = tile->qntsty + compno;
674         int ret; // global bandno
675
676         comp->coord_o[0][0] = FFMAX(tilex       * s->tile_width  + s->tile_offset_x, s->image_offset_x);
677         comp->coord_o[0][1] = FFMIN((tilex + 1) * s->tile_width  + s->tile_offset_x, s->width);
678         comp->coord_o[1][0] = FFMAX(tiley       * s->tile_height + s->tile_offset_y, s->image_offset_y);
679         comp->coord_o[1][1] = FFMIN((tiley + 1) * s->tile_height + s->tile_offset_y, s->height);
680
681         comp->coord[0][0] = ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], s->reduction_factor);
682         comp->coord[0][1] = ff_jpeg2000_ceildivpow2(comp->coord_o[0][1], s->reduction_factor);
683         comp->coord[1][0] = ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], s->reduction_factor);
684         comp->coord[1][1] = ff_jpeg2000_ceildivpow2(comp->coord_o[1][1], s->reduction_factor);
685
686         if (ret = ff_jpeg2000_init_component(comp, codsty, qntsty,
687                                              s->cbps[compno], s->cdx[compno],
688                                              s->cdy[compno], s->avctx))
689             return ret;
690     }
691     return 0;
692 }
693
694 /* Read the number of coding passes. */
695 static int getnpasses(Jpeg2000DecoderContext *s)
696 {
697     int num;
698     if (!get_bits(s, 1))
699         return 1;
700     if (!get_bits(s, 1))
701         return 2;
702     if ((num = get_bits(s, 2)) != 3)
703         return num < 0 ? num : 3 + num;
704     if ((num = get_bits(s, 5)) != 31)
705         return num < 0 ? num : 6 + num;
706     num = get_bits(s, 7);
707     return num < 0 ? num : 37 + num;
708 }
709
710 static int getlblockinc(Jpeg2000DecoderContext *s)
711 {
712     int res = 0, ret;
713     while (ret = get_bits(s, 1)) {
714         if (ret < 0)
715             return ret;
716         res++;
717     }
718     return res;
719 }
720
721 static int jpeg2000_decode_packet(Jpeg2000DecoderContext *s,
722                                   Jpeg2000CodingStyle *codsty,
723                                   Jpeg2000ResLevel *rlevel, int precno,
724                                   int layno, uint8_t *expn, int numgbits)
725 {
726     int bandno, cblkno, ret, nb_code_blocks;
727
728     if (!(ret = get_bits(s, 1))) {
729         jpeg2000_flush(s);
730         return 0;
731     } else if (ret < 0)
732         return ret;
733
734     for (bandno = 0; bandno < rlevel->nbands; bandno++) {
735         Jpeg2000Band *band = rlevel->band + bandno;
736         Jpeg2000Prec *prec = band->prec + precno;
737
738         if (band->coord[0][0] == band->coord[0][1] ||
739             band->coord[1][0] == band->coord[1][1])
740             continue;
741         nb_code_blocks =  prec->nb_codeblocks_height *
742                           prec->nb_codeblocks_width;
743         for (cblkno = 0; cblkno < nb_code_blocks; cblkno++) {
744             Jpeg2000Cblk *cblk = prec->cblk + cblkno;
745             int incl, newpasses, llen;
746
747             if (cblk->npasses)
748                 incl = get_bits(s, 1);
749             else
750                 incl = tag_tree_decode(s, prec->cblkincl + cblkno, layno + 1) == layno;
751             if (!incl)
752                 continue;
753             else if (incl < 0)
754                 return incl;
755
756             if (!cblk->npasses) {
757                 int v = expn[bandno] + numgbits - 1 -
758                         tag_tree_decode(s, prec->zerobits + cblkno, 100);
759                 if (v < 0) {
760                     av_log(s->avctx, AV_LOG_ERROR,
761                            "nonzerobits %d invalid\n", v);
762                     return AVERROR_INVALIDDATA;
763                 }
764                 cblk->nonzerobits = v;
765             }
766             if ((newpasses = getnpasses(s)) < 0)
767                 return newpasses;
768             if ((llen = getlblockinc(s)) < 0)
769                 return llen;
770             cblk->lblock += llen;
771             if ((ret = get_bits(s, av_log2(newpasses) + cblk->lblock)) < 0)
772                 return ret;
773             if (ret > sizeof(cblk->data)) {
774                 avpriv_request_sample(s->avctx,
775                                       "Block with lengthinc greater than %zu",
776                                       sizeof(cblk->data));
777                 return AVERROR_PATCHWELCOME;
778             }
779             cblk->lengthinc = ret;
780             cblk->npasses  += newpasses;
781         }
782     }
783     jpeg2000_flush(s);
784
785     if (codsty->csty & JPEG2000_CSTY_EPH) {
786         if (bytestream2_peek_be16(&s->g) == JPEG2000_EPH)
787             bytestream2_skip(&s->g, 2);
788         else
789             av_log(s->avctx, AV_LOG_ERROR, "EPH marker not found.\n");
790     }
791
792     for (bandno = 0; bandno < rlevel->nbands; bandno++) {
793         Jpeg2000Band *band = rlevel->band + bandno;
794         Jpeg2000Prec *prec = band->prec + precno;
795
796         nb_code_blocks = prec->nb_codeblocks_height * prec->nb_codeblocks_width;
797         for (cblkno = 0; cblkno < nb_code_blocks; cblkno++) {
798             Jpeg2000Cblk *cblk = prec->cblk + cblkno;
799             if (   bytestream2_get_bytes_left(&s->g) < cblk->lengthinc
800                 || sizeof(cblk->data) < cblk->length + cblk->lengthinc + 2
801             ) {
802                 av_log(s->avctx, AV_LOG_ERROR,
803                        "Block length %d or lengthinc %d is too large\n",
804                        cblk->length, cblk->lengthinc);
805                 return AVERROR_INVALIDDATA;
806             }
807
808             bytestream2_get_bufferu(&s->g, cblk->data + cblk->length, cblk->lengthinc);
809             cblk->length   += cblk->lengthinc;
810             cblk->lengthinc = 0;
811         }
812     }
813     return 0;
814 }
815
816 static int jpeg2000_decode_packets(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
817 {
818     int ret = 0;
819     int layno, reslevelno, compno, precno, ok_reslevel;
820     int x, y;
821
822     s->bit_index = 8;
823     switch (tile->codsty[0].prog_order) {
824     case JPEG2000_PGOD_RLCP:
825         avpriv_request_sample(s->avctx, "Progression order RLCP");
826
827     case JPEG2000_PGOD_LRCP:
828         for (layno = 0; layno < tile->codsty[0].nlayers; layno++) {
829             ok_reslevel = 1;
830             for (reslevelno = 0; ok_reslevel; reslevelno++) {
831                 ok_reslevel = 0;
832                 for (compno = 0; compno < s->ncomponents; compno++) {
833                     Jpeg2000CodingStyle *codsty = tile->codsty + compno;
834                     Jpeg2000QuantStyle *qntsty  = tile->qntsty + compno;
835                     if (reslevelno < codsty->nreslevels) {
836                         Jpeg2000ResLevel *rlevel = tile->comp[compno].reslevel +
837                                                 reslevelno;
838                         ok_reslevel = 1;
839                         for (precno = 0; precno < rlevel->num_precincts_x * rlevel->num_precincts_y; precno++)
840                             if ((ret = jpeg2000_decode_packet(s,
841                                                               codsty, rlevel,
842                                                               precno, layno,
843                                                               qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
844                                                               qntsty->nguardbits)) < 0)
845                                 return ret;
846                     }
847                 }
848             }
849         }
850         break;
851
852     case JPEG2000_PGOD_CPRL:
853         for (compno = 0; compno < s->ncomponents; compno++) {
854             Jpeg2000CodingStyle *codsty = tile->codsty + compno;
855             Jpeg2000QuantStyle *qntsty  = tile->qntsty + compno;
856
857             /* Set bit stream buffer address according to tile-part.
858              * For DCinema one tile-part per component, so can be
859              * indexed by component. */
860             s->g = tile->tile_part[compno].tpg;
861
862             /* Position loop (y axis)
863              * TODO: Automate computing of step 256.
864              * Fixed here, but to be computed before entering here. */
865             for (y = 0; y < s->height; y += 256) {
866                 /* Position loop (y axis)
867                  * TODO: automate computing of step 256.
868                  * Fixed here, but to be computed before entering here. */
869                 for (x = 0; x < s->width; x += 256) {
870                     for (reslevelno = 0; reslevelno < codsty->nreslevels; reslevelno++) {
871                         uint16_t prcx, prcy;
872                         uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; //  ==> N_L - r
873                         Jpeg2000ResLevel *rlevel = tile->comp[compno].reslevel + reslevelno;
874
875                         if (!((y % (1 << (rlevel->log2_prec_height + reducedresno)) == 0) ||
876                               (y == 0))) // TODO: 2nd condition simplified as try0 always =0 for dcinema
877                             continue;
878
879                         if (!((x % (1 << (rlevel->log2_prec_width + reducedresno)) == 0) ||
880                               (x == 0))) // TODO: 2nd condition simplified as try0 always =0 for dcinema
881                             continue;
882
883                         // check if a precinct exists
884                         prcx   = ff_jpeg2000_ceildivpow2(x, reducedresno) >> rlevel->log2_prec_width;
885                         prcy   = ff_jpeg2000_ceildivpow2(y, reducedresno) >> rlevel->log2_prec_height;
886                         precno = prcx + rlevel->num_precincts_x * prcy;
887                         for (layno = 0; layno < tile->codsty[0].nlayers; layno++) {
888                             if ((ret = jpeg2000_decode_packet(s, codsty, rlevel,
889                                                               precno, layno,
890                                                               qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
891                                                               qntsty->nguardbits)) < 0)
892                                 return ret;
893                         }
894                     }
895                 }
896             }
897         }
898         break;
899
900     case JPEG2000_PGOD_RPCL:
901         avpriv_request_sample(s->avctx, "Progression order RPCL");
902         ret = AVERROR_PATCHWELCOME;
903         break;
904
905     case JPEG2000_PGOD_PCRL:
906         avpriv_request_sample(s->avctx, "Progression order PCRL");
907         ret = AVERROR_PATCHWELCOME;
908         break;
909
910     default:
911         break;
912     }
913
914     /* EOC marker reached */
915     bytestream2_skip(&s->g, 2);
916
917     return ret;
918 }
919
920 /* TIER-1 routines */
921 static void decode_sigpass(Jpeg2000T1Context *t1, int width, int height,
922                            int bpno, int bandno, int bpass_csty_symbol,
923                            int vert_causal_ctx_csty_symbol)
924 {
925     int mask = 3 << (bpno - 1), y0, x, y;
926
927     for (y0 = 0; y0 < height; y0 += 4)
928         for (x = 0; x < width; x++)
929             for (y = y0; y < height && y < y0 + 4; y++) {
930                 if ((t1->flags[y+1][x+1] & JPEG2000_T1_SIG_NB)
931                 && !(t1->flags[y+1][x+1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS))) {
932                     int flags_mask = -1;
933                     if (vert_causal_ctx_csty_symbol && y == y0 + 3)
934                         flags_mask &= ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE);
935                     if (ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ff_jpeg2000_getsigctxno(t1->flags[y+1][x+1] & flags_mask, bandno))) {
936                         int xorbit, ctxno = ff_jpeg2000_getsgnctxno(t1->flags[y+1][x+1], &xorbit);
937                         if (bpass_csty_symbol)
938                              t1->data[y][x] = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ctxno) ? -mask : mask;
939                         else
940                              t1->data[y][x] = (ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ctxno) ^ xorbit) ?
941                                                -mask : mask;
942
943                         ff_jpeg2000_set_significance(t1, x, y,
944                                                      t1->data[y][x] < 0);
945                     }
946                     t1->flags[y + 1][x + 1] |= JPEG2000_T1_VIS;
947                 }
948             }
949 }
950
951 static void decode_refpass(Jpeg2000T1Context *t1, int width, int height,
952                            int bpno)
953 {
954     int phalf, nhalf;
955     int y0, x, y;
956
957     phalf = 1 << (bpno - 1);
958     nhalf = -phalf;
959
960     for (y0 = 0; y0 < height; y0 += 4)
961         for (x = 0; x < width; x++)
962             for (y = y0; y < height && y < y0 + 4; y++)
963                 if ((t1->flags[y + 1][x + 1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS)) == JPEG2000_T1_SIG) {
964                     int ctxno = ff_jpeg2000_getrefctxno(t1->flags[y + 1][x + 1]);
965                     int r     = ff_mqc_decode(&t1->mqc,
966                                               t1->mqc.cx_states + ctxno)
967                                 ? phalf : nhalf;
968                     t1->data[y][x]          += t1->data[y][x] < 0 ? -r : r;
969                     t1->flags[y + 1][x + 1] |= JPEG2000_T1_REF;
970                 }
971 }
972
973 static void decode_clnpass(Jpeg2000DecoderContext *s, Jpeg2000T1Context *t1,
974                            int width, int height, int bpno, int bandno,
975                            int seg_symbols, int vert_causal_ctx_csty_symbol)
976 {
977     int mask = 3 << (bpno - 1), y0, x, y, runlen, dec;
978
979     for (y0 = 0; y0 < height; y0 += 4) {
980         for (x = 0; x < width; x++) {
981             if (y0 + 3 < height &&
982                 !((t1->flags[y0 + 1][x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
983                   (t1->flags[y0 + 2][x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
984                   (t1->flags[y0 + 3][x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
985                   (t1->flags[y0 + 4][x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)))) {
986                 if (!ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_RL))
987                     continue;
988                 runlen = ff_mqc_decode(&t1->mqc,
989                                        t1->mqc.cx_states + MQC_CX_UNI);
990                 runlen = (runlen << 1) | ff_mqc_decode(&t1->mqc,
991                                                        t1->mqc.cx_states +
992                                                        MQC_CX_UNI);
993                 dec = 1;
994             } else {
995                 runlen = 0;
996                 dec    = 0;
997             }
998
999             for (y = y0 + runlen; y < y0 + 4 && y < height; y++) {
1000                 if (!dec) {
1001                     if (!(t1->flags[y+1][x+1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS))) {
1002                         int flags_mask = -1;
1003                         if (vert_causal_ctx_csty_symbol && y == y0 + 3)
1004                             flags_mask &= ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE);
1005                         dec = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ff_jpeg2000_getsigctxno(t1->flags[y+1][x+1] & flags_mask,
1006                                                                                              bandno));
1007                     }
1008                 }
1009                 if (dec) {
1010                     int xorbit;
1011                     int ctxno = ff_jpeg2000_getsgnctxno(t1->flags[y + 1][x + 1],
1012                                                         &xorbit);
1013                     t1->data[y][x] = (ff_mqc_decode(&t1->mqc,
1014                                                     t1->mqc.cx_states + ctxno) ^
1015                                       xorbit)
1016                                      ? -mask : mask;
1017                     ff_jpeg2000_set_significance(t1, x, y, t1->data[y][x] < 0);
1018                 }
1019                 dec = 0;
1020                 t1->flags[y + 1][x + 1] &= ~JPEG2000_T1_VIS;
1021             }
1022         }
1023     }
1024     if (seg_symbols) {
1025         int val;
1026         val = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1027         val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1028         val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1029         val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1030         if (val != 0xa)
1031             av_log(s->avctx, AV_LOG_ERROR,
1032                    "Segmentation symbol value incorrect\n");
1033     }
1034 }
1035
1036 static int decode_cblk(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *codsty,
1037                        Jpeg2000T1Context *t1, Jpeg2000Cblk *cblk,
1038                        int width, int height, int bandpos)
1039 {
1040     int passno = cblk->npasses, pass_t = 2, bpno = cblk->nonzerobits - 1, y;
1041     int clnpass_cnt = 0;
1042     int bpass_csty_symbol           = codsty->cblk_style & JPEG2000_CBLK_BYPASS;
1043     int vert_causal_ctx_csty_symbol = codsty->cblk_style & JPEG2000_CBLK_VSC;
1044
1045     av_assert0(width  <= JPEG2000_MAX_CBLKW);
1046     av_assert0(height <= JPEG2000_MAX_CBLKH);
1047
1048     for (y = 0; y < height; y++)
1049         memset(t1->data[y], 0, width * sizeof(**t1->data));
1050
1051     /* If code-block contains no compressed data: nothing to do. */
1052     if (!cblk->length)
1053         return 0;
1054
1055     for (y = 0; y < height + 2; y++)
1056         memset(t1->flags[y], 0, (width + 2) * sizeof(**t1->flags));
1057
1058     cblk->data[cblk->length] = 0xff;
1059     cblk->data[cblk->length+1] = 0xff;
1060     ff_mqc_initdec(&t1->mqc, cblk->data);
1061
1062     while (passno--) {
1063         switch(pass_t) {
1064         case 0:
1065             decode_sigpass(t1, width, height, bpno + 1, bandpos,
1066                            bpass_csty_symbol && (clnpass_cnt >= 4),
1067                            vert_causal_ctx_csty_symbol);
1068             break;
1069         case 1:
1070             decode_refpass(t1, width, height, bpno + 1);
1071             if (bpass_csty_symbol && clnpass_cnt >= 4)
1072                 ff_mqc_initdec(&t1->mqc, cblk->data);
1073             break;
1074         case 2:
1075             decode_clnpass(s, t1, width, height, bpno + 1, bandpos,
1076                            codsty->cblk_style & JPEG2000_CBLK_SEGSYM,
1077                            vert_causal_ctx_csty_symbol);
1078             clnpass_cnt = clnpass_cnt + 1;
1079             if (bpass_csty_symbol && clnpass_cnt >= 4)
1080                 ff_mqc_initdec(&t1->mqc, cblk->data);
1081             break;
1082         }
1083
1084         pass_t++;
1085         if (pass_t == 3) {
1086             bpno--;
1087             pass_t = 0;
1088         }
1089     }
1090     return 0;
1091 }
1092
1093 /* TODO: Verify dequantization for lossless case
1094  * comp->data can be float or int
1095  * band->stepsize can be float or int
1096  * depending on the type of DWT transformation.
1097  * see ISO/IEC 15444-1:2002 A.6.1 */
1098
1099 /* Float dequantization of a codeblock.*/
1100 static void dequantization_float(int x, int y, Jpeg2000Cblk *cblk,
1101                                  Jpeg2000Component *comp,
1102                                  Jpeg2000T1Context *t1, Jpeg2000Band *band)
1103 {
1104     int i, j;
1105     int w = cblk->coord[0][1] - cblk->coord[0][0];
1106     for (j = 0; j < (cblk->coord[1][1] - cblk->coord[1][0]); ++j) {
1107         float *datap = &comp->f_data[(comp->coord[0][1] - comp->coord[0][0]) * (y + j) + x];
1108         int *src = t1->data[j];
1109         for (i = 0; i < w; ++i)
1110             datap[i] = src[i] * band->f_stepsize;
1111     }
1112 }
1113
1114 /* Integer dequantization of a codeblock.*/
1115 static void dequantization_int(int x, int y, Jpeg2000Cblk *cblk,
1116                                Jpeg2000Component *comp,
1117                                Jpeg2000T1Context *t1, Jpeg2000Band *band)
1118 {
1119     int i, j;
1120     int w = cblk->coord[0][1] - cblk->coord[0][0];
1121     for (j = 0; j < (cblk->coord[1][1] - cblk->coord[1][0]); ++j) {
1122         int32_t *datap = &comp->i_data[(comp->coord[0][1] - comp->coord[0][0]) * (y + j) + x];
1123         int *src = t1->data[j];
1124         for (i = 0; i < w; ++i)
1125             datap[i] = (src[i] * band->i_stepsize + (1 << 14)) >> 15;
1126     }
1127 }
1128
1129 /* Inverse ICT parameters in float and integer.
1130  * int value = (float value) * (1<<16) */
1131 static const float f_ict_params[4] = {
1132     1.402f,
1133     0.34413f,
1134     0.71414f,
1135     1.772f
1136 };
1137 static const int   i_ict_params[4] = {
1138      91881,
1139      22553,
1140      46802,
1141     116130
1142 };
1143
1144 static void mct_decode(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
1145 {
1146     int i, csize = 1;
1147     int32_t *src[3],  i0,  i1,  i2;
1148     float   *srcf[3], i0f, i1f, i2f;
1149
1150     for (i = 1; i < 3; i++)
1151         if (tile->codsty[0].transform != tile->codsty[i].transform) {
1152             av_log(s->avctx, AV_LOG_ERROR, "Transforms mismatch, MCT not supported\n");
1153             return;
1154         }
1155
1156     for (i = 0; i < 3; i++)
1157         if (tile->codsty[0].transform == FF_DWT97)
1158             srcf[i] = tile->comp[i].f_data;
1159         else
1160             src [i] = tile->comp[i].i_data;
1161
1162     for (i = 0; i < 2; i++)
1163         csize *= tile->comp[0].coord[i][1] - tile->comp[0].coord[i][0];
1164
1165     switch (tile->codsty[0].transform) {
1166     case FF_DWT97:
1167         for (i = 0; i < csize; i++) {
1168             i0f = *srcf[0] + (f_ict_params[0] * *srcf[2]);
1169             i1f = *srcf[0] - (f_ict_params[1] * *srcf[1])
1170                            - (f_ict_params[2] * *srcf[2]);
1171             i2f = *srcf[0] + (f_ict_params[3] * *srcf[1]);
1172             *srcf[0]++ = i0f;
1173             *srcf[1]++ = i1f;
1174             *srcf[2]++ = i2f;
1175         }
1176         break;
1177     case FF_DWT97_INT:
1178         for (i = 0; i < csize; i++) {
1179             i0 = *src[0] + (((i_ict_params[0] * *src[2]) + (1 << 15)) >> 16);
1180             i1 = *src[0] - (((i_ict_params[1] * *src[1]) + (1 << 15)) >> 16)
1181                          - (((i_ict_params[2] * *src[2]) + (1 << 15)) >> 16);
1182             i2 = *src[0] + (((i_ict_params[3] * *src[1]) + (1 << 15)) >> 16);
1183             *src[0]++ = i0;
1184             *src[1]++ = i1;
1185             *src[2]++ = i2;
1186         }
1187         break;
1188     case FF_DWT53:
1189         for (i = 0; i < csize; i++) {
1190             i1 = *src[0] - (*src[2] + *src[1] >> 2);
1191             i0 = i1 + *src[2];
1192             i2 = i1 + *src[1];
1193             *src[0]++ = i0;
1194             *src[1]++ = i1;
1195             *src[2]++ = i2;
1196         }
1197         break;
1198     }
1199 }
1200
1201 static int jpeg2000_decode_tile(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile,
1202                                 AVFrame *picture)
1203 {
1204     int compno, reslevelno, bandno;
1205     int x, y;
1206
1207     uint8_t *line;
1208     Jpeg2000T1Context t1;
1209
1210     /* Loop on tile components */
1211     for (compno = 0; compno < s->ncomponents; compno++) {
1212         Jpeg2000Component *comp     = tile->comp + compno;
1213         Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1214
1215         /* Loop on resolution levels */
1216         for (reslevelno = 0; reslevelno < codsty->nreslevels2decode; reslevelno++) {
1217             Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1218             /* Loop on bands */
1219             for (bandno = 0; bandno < rlevel->nbands; bandno++) {
1220                 int nb_precincts, precno;
1221                 Jpeg2000Band *band = rlevel->band + bandno;
1222                 int cblkno = 0, bandpos;
1223
1224                 bandpos = bandno + (reslevelno > 0);
1225
1226                 if (band->coord[0][0] == band->coord[0][1] ||
1227                     band->coord[1][0] == band->coord[1][1])
1228                     continue;
1229
1230                 nb_precincts = rlevel->num_precincts_x * rlevel->num_precincts_y;
1231                 /* Loop on precincts */
1232                 for (precno = 0; precno < nb_precincts; precno++) {
1233                     Jpeg2000Prec *prec = band->prec + precno;
1234
1235                     /* Loop on codeblocks */
1236                     for (cblkno = 0; cblkno < prec->nb_codeblocks_width * prec->nb_codeblocks_height; cblkno++) {
1237                         int x, y;
1238                         Jpeg2000Cblk *cblk = prec->cblk + cblkno;
1239                         decode_cblk(s, codsty, &t1, cblk,
1240                                     cblk->coord[0][1] - cblk->coord[0][0],
1241                                     cblk->coord[1][1] - cblk->coord[1][0],
1242                                     bandpos);
1243
1244                         x = cblk->coord[0][0];
1245                         y = cblk->coord[1][0];
1246
1247                         if (codsty->transform == FF_DWT97)
1248                             dequantization_float(x, y, cblk, comp, &t1, band);
1249                         else
1250                             dequantization_int(x, y, cblk, comp, &t1, band);
1251                    } /* end cblk */
1252                 } /*end prec */
1253             } /* end band */
1254         } /* end reslevel */
1255
1256         /* inverse DWT */
1257         ff_dwt_decode(&comp->dwt, codsty->transform == FF_DWT97 ? (void*)comp->f_data : (void*)comp->i_data);
1258     } /*end comp */
1259
1260     /* inverse MCT transformation */
1261     if (tile->codsty[0].mct)
1262         mct_decode(s, tile);
1263
1264     if (s->cdef[0] < 0) {
1265         for (x = 0; x < s->ncomponents; x++)
1266             s->cdef[x] = x + 1;
1267         if ((s->ncomponents & 1) == 0)
1268             s->cdef[s->ncomponents-1] = 0;
1269     }
1270
1271     if (s->precision <= 8) {
1272         for (compno = 0; compno < s->ncomponents; compno++) {
1273             Jpeg2000Component *comp = tile->comp + compno;
1274             Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1275             float *datap = comp->f_data;
1276             int32_t *i_datap = comp->i_data;
1277             int cbps = s->cbps[compno];
1278             int w = tile->comp[compno].coord[0][1] - s->image_offset_x;
1279             int planar = !!picture->data[2];
1280             int pixelsize = planar ? 1 : s->ncomponents;
1281             int plane = 0;
1282
1283             if (planar)
1284                 plane = s->cdef[compno] ? s->cdef[compno]-1 : (s->ncomponents-1);
1285
1286
1287             y    = tile->comp[compno].coord[1][0] - s->image_offset_y;
1288             line = picture->data[plane] + y / s->cdy[compno] * picture->linesize[plane];
1289             for (; y < tile->comp[compno].coord[1][1] - s->image_offset_y; y += s->cdy[compno]) {
1290                 uint8_t *dst;
1291
1292                 x   = tile->comp[compno].coord[0][0] - s->image_offset_x;
1293                 dst = line + x / s->cdx[compno] * pixelsize + compno*!planar;
1294
1295                 if (codsty->transform == FF_DWT97) {
1296                     for (; x < w; x += s->cdx[compno]) {
1297                         int val = lrintf(*datap) + (1 << (cbps - 1));
1298                         /* DC level shift and clip see ISO 15444-1:2002 G.1.2 */
1299                         val = av_clip(val, 0, (1 << cbps) - 1);
1300                         *dst = val << (8 - cbps);
1301                         datap++;
1302                         dst += pixelsize;
1303                     }
1304                 } else {
1305                     for (; x < w; x += s->cdx[compno]) {
1306                         int val = *i_datap + (1 << (cbps - 1));
1307                         /* DC level shift and clip see ISO 15444-1:2002 G.1.2 */
1308                         val = av_clip(val, 0, (1 << cbps) - 1);
1309                         *dst = val << (8 - cbps);
1310                         i_datap++;
1311                         dst += pixelsize;
1312                     }
1313                 }
1314                 line += picture->linesize[plane];
1315             }
1316         }
1317     } else {
1318         for (compno = 0; compno < s->ncomponents; compno++) {
1319             Jpeg2000Component *comp = tile->comp + compno;
1320             Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1321             float *datap = comp->f_data;
1322             int32_t *i_datap = comp->i_data;
1323             uint16_t *linel;
1324             int cbps = s->cbps[compno];
1325             int w = tile->comp[compno].coord[0][1] - s->image_offset_x;
1326             int planar = !!picture->data[2];
1327             int pixelsize = planar ? 1 : s->ncomponents;
1328             int plane = 0;
1329
1330             if (planar)
1331                 plane = s->cdef[compno] ? s->cdef[compno]-1 : (s->ncomponents-1);
1332
1333             y     = tile->comp[compno].coord[1][0] - s->image_offset_y;
1334             linel = (uint16_t *)picture->data[plane] + y / s->cdy[compno] * (picture->linesize[plane] >> 1);
1335             for (; y < tile->comp[compno].coord[1][1] - s->image_offset_y; y += s->cdy[compno]) {
1336                 uint16_t *dst;
1337
1338                 x   = tile->comp[compno].coord[0][0] - s->image_offset_x;
1339                 dst = linel + (x / s->cdx[compno] * pixelsize + compno*!planar);
1340                 if (codsty->transform == FF_DWT97) {
1341                     for (; x < w; x += s-> cdx[compno]) {
1342                         int  val = lrintf(*datap) + (1 << (cbps - 1));
1343                         /* DC level shift and clip see ISO 15444-1:2002 G.1.2 */
1344                         val = av_clip(val, 0, (1 << cbps) - 1);
1345                         /* align 12 bit values in little-endian mode */
1346                         *dst = val << (16 - cbps);
1347                         datap++;
1348                         dst += pixelsize;
1349                     }
1350                 } else {
1351                     for (; x < w; x += s-> cdx[compno]) {
1352                         int val = *i_datap + (1 << (cbps - 1));
1353                         /* DC level shift and clip see ISO 15444-1:2002 G.1.2 */
1354                         val = av_clip(val, 0, (1 << cbps) - 1);
1355                         /* align 12 bit values in little-endian mode */
1356                         *dst = val << (16 - cbps);
1357                         i_datap++;
1358                         dst += pixelsize;
1359                     }
1360                 }
1361                 linel += picture->linesize[plane] >> 1;
1362             }
1363         }
1364     }
1365
1366     return 0;
1367 }
1368
1369 static void jpeg2000_dec_cleanup(Jpeg2000DecoderContext *s)
1370 {
1371     int tileno, compno;
1372     for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++) {
1373         if (s->tile[tileno].comp) {
1374             for (compno = 0; compno < s->ncomponents; compno++) {
1375                 Jpeg2000Component *comp     = s->tile[tileno].comp   + compno;
1376                 Jpeg2000CodingStyle *codsty = s->tile[tileno].codsty + compno;
1377
1378                 ff_jpeg2000_cleanup(comp, codsty);
1379             }
1380             av_freep(&s->tile[tileno].comp);
1381         }
1382     }
1383     av_freep(&s->tile);
1384     memset(s->codsty, 0, sizeof(s->codsty));
1385     memset(s->qntsty, 0, sizeof(s->qntsty));
1386     s->numXtiles = s->numYtiles = 0;
1387 }
1388
1389 static int jpeg2000_read_main_headers(Jpeg2000DecoderContext *s)
1390 {
1391     Jpeg2000CodingStyle *codsty = s->codsty;
1392     Jpeg2000QuantStyle *qntsty  = s->qntsty;
1393     uint8_t *properties         = s->properties;
1394
1395     for (;;) {
1396         int len, ret = 0;
1397         uint16_t marker;
1398         int oldpos;
1399
1400         if (bytestream2_get_bytes_left(&s->g) < 2) {
1401             av_log(s->avctx, AV_LOG_ERROR, "Missing EOC\n");
1402             break;
1403         }
1404
1405         marker = bytestream2_get_be16u(&s->g);
1406         oldpos = bytestream2_tell(&s->g);
1407
1408         if (marker == JPEG2000_SOD) {
1409             Jpeg2000Tile *tile;
1410             Jpeg2000TilePart *tp;
1411
1412             if (!s->tile) {
1413                 av_log(s->avctx, AV_LOG_ERROR, "Missing SIZ\n");
1414                 return AVERROR_INVALIDDATA;
1415             }
1416             if (s->curtileno < 0) {
1417                 av_log(s->avctx, AV_LOG_ERROR, "Missing SOT\n");
1418                 return AVERROR_INVALIDDATA;
1419             }
1420
1421             tile = s->tile + s->curtileno;
1422             tp = tile->tile_part + tile->tp_idx;
1423             if (tp->tp_end < s->g.buffer) {
1424                 av_log(s->avctx, AV_LOG_ERROR, "Invalid tpend\n");
1425                 return AVERROR_INVALIDDATA;
1426             }
1427             bytestream2_init(&tp->tpg, s->g.buffer, tp->tp_end - s->g.buffer);
1428             bytestream2_skip(&s->g, tp->tp_end - s->g.buffer);
1429
1430             continue;
1431         }
1432         if (marker == JPEG2000_EOC)
1433             break;
1434
1435         len = bytestream2_get_be16(&s->g);
1436         if (len < 2 || bytestream2_get_bytes_left(&s->g) < len - 2)
1437             return AVERROR_INVALIDDATA;
1438
1439         switch (marker) {
1440         case JPEG2000_SIZ:
1441             ret = get_siz(s);
1442             if (!s->tile)
1443                 s->numXtiles = s->numYtiles = 0;
1444             break;
1445         case JPEG2000_COC:
1446             ret = get_coc(s, codsty, properties);
1447             break;
1448         case JPEG2000_COD:
1449             ret = get_cod(s, codsty, properties);
1450             break;
1451         case JPEG2000_QCC:
1452             ret = get_qcc(s, len, qntsty, properties);
1453             break;
1454         case JPEG2000_QCD:
1455             ret = get_qcd(s, len, qntsty, properties);
1456             break;
1457         case JPEG2000_SOT:
1458             if (!(ret = get_sot(s, len))) {
1459                 av_assert1(s->curtileno >= 0);
1460                 codsty = s->tile[s->curtileno].codsty;
1461                 qntsty = s->tile[s->curtileno].qntsty;
1462                 properties = s->tile[s->curtileno].properties;
1463             }
1464             break;
1465         case JPEG2000_COM:
1466             // the comment is ignored
1467             bytestream2_skip(&s->g, len - 2);
1468             break;
1469         case JPEG2000_TLM:
1470             // Tile-part lengths
1471             ret = get_tlm(s, len);
1472             break;
1473         default:
1474             av_log(s->avctx, AV_LOG_ERROR,
1475                    "unsupported marker 0x%.4X at pos 0x%X\n",
1476                    marker, bytestream2_tell(&s->g) - 4);
1477             bytestream2_skip(&s->g, len - 2);
1478             break;
1479         }
1480         if (bytestream2_tell(&s->g) - oldpos != len || ret) {
1481             av_log(s->avctx, AV_LOG_ERROR,
1482                    "error during processing marker segment %.4x\n", marker);
1483             return ret ? ret : -1;
1484         }
1485     }
1486     return 0;
1487 }
1488
1489 /* Read bit stream packets --> T2 operation. */
1490 static int jpeg2000_read_bitstream_packets(Jpeg2000DecoderContext *s)
1491 {
1492     int ret = 0;
1493     int tileno;
1494
1495     for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++) {
1496         Jpeg2000Tile *tile = s->tile + tileno;
1497
1498         if (ret = init_tile(s, tileno))
1499             return ret;
1500
1501         s->g = tile->tile_part[0].tpg;
1502         if (ret = jpeg2000_decode_packets(s, tile))
1503             return ret;
1504     }
1505
1506     return 0;
1507 }
1508
1509 static int jp2_find_codestream(Jpeg2000DecoderContext *s)
1510 {
1511     uint32_t atom_size, atom, atom_end;
1512     int search_range = 10;
1513
1514     while (search_range
1515            &&
1516            bytestream2_get_bytes_left(&s->g) >= 8) {
1517         atom_size = bytestream2_get_be32u(&s->g);
1518         atom      = bytestream2_get_be32u(&s->g);
1519         atom_end  = bytestream2_tell(&s->g) + atom_size - 8;
1520
1521         if (atom == JP2_CODESTREAM)
1522             return 1;
1523
1524         if (bytestream2_get_bytes_left(&s->g) < atom_size || atom_end < atom_size)
1525             return 0;
1526
1527         if (atom == JP2_HEADER &&
1528                    atom_size >= 16) {
1529             uint32_t atom2_size, atom2, atom2_end;
1530             do {
1531                 atom2_size = bytestream2_get_be32u(&s->g);
1532                 atom2      = bytestream2_get_be32u(&s->g);
1533                 atom2_end  = bytestream2_tell(&s->g) + atom2_size - 8;
1534                 if (atom2_size < 8 || atom2_end > atom_end || atom2_end < atom2_size)
1535                     break;
1536                 if (atom2 == JP2_CODESTREAM) {
1537                     return 1;
1538                 } else if (atom2 == MKBETAG('c','o','l','r') && atom2_size >= 7) {
1539                     int method = bytestream2_get_byteu(&s->g);
1540                     bytestream2_skipu(&s->g, 2);
1541                     if (method == 1) {
1542                         s->colour_space = bytestream2_get_be32u(&s->g);
1543                     }
1544                 } else if (atom2 == MKBETAG('p','c','l','r') && atom2_size >= 6) {
1545                     int i, size, colour_count, colour_channels, colour_depth[3];
1546                     uint32_t r, g, b;
1547                     colour_count = bytestream2_get_be16u(&s->g);
1548                     colour_channels = bytestream2_get_byteu(&s->g);
1549                     // FIXME: Do not ignore channel_sign
1550                     colour_depth[0] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1;
1551                     colour_depth[1] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1;
1552                     colour_depth[2] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1;
1553                     size = (colour_depth[0] + 7 >> 3) * colour_count +
1554                            (colour_depth[1] + 7 >> 3) * colour_count +
1555                            (colour_depth[2] + 7 >> 3) * colour_count;
1556                     if (colour_count > 256   ||
1557                         colour_channels != 3 ||
1558                         colour_depth[0] > 16 ||
1559                         colour_depth[1] > 16 ||
1560                         colour_depth[2] > 16 ||
1561                         atom2_size < size) {
1562                         avpriv_request_sample(s->avctx, "Unknown palette");
1563                         bytestream2_seek(&s->g, atom2_end, SEEK_SET);
1564                         continue;
1565                     }
1566                     s->pal8 = 1;
1567                     for (i = 0; i < colour_count; i++) {
1568                         if (colour_depth[0] <= 8) {
1569                             r = bytestream2_get_byteu(&s->g) << 8 - colour_depth[0];
1570                             r |= r >> colour_depth[0];
1571                         } else {
1572                             r = bytestream2_get_be16u(&s->g) >> colour_depth[0] - 8;
1573                         }
1574                         if (colour_depth[1] <= 8) {
1575                             g = bytestream2_get_byteu(&s->g) << 8 - colour_depth[1];
1576                             r |= r >> colour_depth[1];
1577                         } else {
1578                             g = bytestream2_get_be16u(&s->g) >> colour_depth[1] - 8;
1579                         }
1580                         if (colour_depth[2] <= 8) {
1581                             b = bytestream2_get_byteu(&s->g) << 8 - colour_depth[2];
1582                             r |= r >> colour_depth[2];
1583                         } else {
1584                             b = bytestream2_get_be16u(&s->g) >> colour_depth[2] - 8;
1585                         }
1586                         s->palette[i] = 0xffu << 24 | r << 16 | g << 8 | b;
1587                     }
1588                 } else if (atom2 == MKBETAG('c','d','e','f') && atom2_size >= 2) {
1589                     int n = bytestream2_get_be16u(&s->g);
1590                     for (; n>0; n--) {
1591                         int cn   = bytestream2_get_be16(&s->g);
1592                         int av_unused typ  = bytestream2_get_be16(&s->g);
1593                         int asoc = bytestream2_get_be16(&s->g);
1594                         if (cn < 4 || asoc < 4)
1595                             s->cdef[cn] = asoc;
1596                     }
1597                 }
1598                 bytestream2_seek(&s->g, atom2_end, SEEK_SET);
1599             } while (atom_end - atom2_end >= 8);
1600         } else {
1601             search_range--;
1602         }
1603         bytestream2_seek(&s->g, atom_end, SEEK_SET);
1604     }
1605
1606     return 0;
1607 }
1608
1609 static int jpeg2000_decode_frame(AVCodecContext *avctx, void *data,
1610                                  int *got_frame, AVPacket *avpkt)
1611 {
1612     Jpeg2000DecoderContext *s = avctx->priv_data;
1613     ThreadFrame frame = { .f = data };
1614     AVFrame *picture = data;
1615     int tileno, ret;
1616
1617     s->avctx     = avctx;
1618     bytestream2_init(&s->g, avpkt->data, avpkt->size);
1619     s->curtileno = -1;
1620     memset(s->cdef, -1, sizeof(s->cdef));
1621
1622     if (bytestream2_get_bytes_left(&s->g) < 2) {
1623         ret = AVERROR_INVALIDDATA;
1624         goto end;
1625     }
1626
1627     // check if the image is in jp2 format
1628     if (bytestream2_get_bytes_left(&s->g) >= 12 &&
1629        (bytestream2_get_be32u(&s->g) == 12) &&
1630        (bytestream2_get_be32u(&s->g) == JP2_SIG_TYPE) &&
1631        (bytestream2_get_be32u(&s->g) == JP2_SIG_VALUE)) {
1632         if (!jp2_find_codestream(s)) {
1633             av_log(avctx, AV_LOG_ERROR,
1634                    "Could not find Jpeg2000 codestream atom.\n");
1635             ret = AVERROR_INVALIDDATA;
1636             goto end;
1637         }
1638     } else {
1639         bytestream2_seek(&s->g, 0, SEEK_SET);
1640     }
1641
1642     while (bytestream2_get_bytes_left(&s->g) >= 3 && bytestream2_peek_be16(&s->g) != JPEG2000_SOC)
1643         bytestream2_skip(&s->g, 1);
1644
1645     if (bytestream2_get_be16u(&s->g) != JPEG2000_SOC) {
1646         av_log(avctx, AV_LOG_ERROR, "SOC marker not present\n");
1647         ret = AVERROR_INVALIDDATA;
1648         goto end;
1649     }
1650     if (ret = jpeg2000_read_main_headers(s))
1651         goto end;
1652
1653     /* get picture buffer */
1654     if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
1655         goto end;
1656     picture->pict_type = AV_PICTURE_TYPE_I;
1657     picture->key_frame = 1;
1658
1659     if (ret = jpeg2000_read_bitstream_packets(s))
1660         goto end;
1661
1662     for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++)
1663         if (ret = jpeg2000_decode_tile(s, s->tile + tileno, picture))
1664             goto end;
1665
1666     jpeg2000_dec_cleanup(s);
1667
1668     *got_frame = 1;
1669
1670     if (s->avctx->pix_fmt == AV_PIX_FMT_PAL8)
1671         memcpy(picture->data[1], s->palette, 256 * sizeof(uint32_t));
1672
1673     return bytestream2_tell(&s->g);
1674
1675 end:
1676     jpeg2000_dec_cleanup(s);
1677     return ret;
1678 }
1679
1680 static void jpeg2000_init_static_data(AVCodec *codec)
1681 {
1682     ff_jpeg2000_init_tier1_luts();
1683     ff_mqc_init_context_tables();
1684 }
1685
1686 #define OFFSET(x) offsetof(Jpeg2000DecoderContext, x)
1687 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
1688
1689 static const AVOption options[] = {
1690     { "lowres",  "Lower the decoding resolution by a power of two",
1691         OFFSET(reduction_factor), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, JPEG2000_MAX_RESLEVELS - 1, VD },
1692     { NULL },
1693 };
1694
1695 static const AVProfile profiles[] = {
1696     { FF_PROFILE_JPEG2000_CSTREAM_RESTRICTION_0,  "JPEG 2000 codestream restriction 0"   },
1697     { FF_PROFILE_JPEG2000_CSTREAM_RESTRICTION_1,  "JPEG 2000 codestream restriction 1"   },
1698     { FF_PROFILE_JPEG2000_CSTREAM_NO_RESTRICTION, "JPEG 2000 no codestream restrictions" },
1699     { FF_PROFILE_JPEG2000_DCINEMA_2K,             "JPEG 2000 digital cinema 2K"          },
1700     { FF_PROFILE_JPEG2000_DCINEMA_4K,             "JPEG 2000 digital cinema 4K"          },
1701     { FF_PROFILE_UNKNOWN },
1702 };
1703
1704 static const AVClass jpeg2000_class = {
1705     .class_name = "jpeg2000",
1706     .item_name  = av_default_item_name,
1707     .option     = options,
1708     .version    = LIBAVUTIL_VERSION_INT,
1709 };
1710
1711 AVCodec ff_jpeg2000_decoder = {
1712     .name             = "jpeg2000",
1713     .long_name        = NULL_IF_CONFIG_SMALL("JPEG 2000"),
1714     .type             = AVMEDIA_TYPE_VIDEO,
1715     .id               = AV_CODEC_ID_JPEG2000,
1716     .capabilities     = CODEC_CAP_FRAME_THREADS,
1717     .priv_data_size   = sizeof(Jpeg2000DecoderContext),
1718     .init_static_data = jpeg2000_init_static_data,
1719     .decode           = jpeg2000_decode_frame,
1720     .priv_class       = &jpeg2000_class,
1721     .max_lowres       = 5,
1722     .profiles         = NULL_IF_CONFIG_SMALL(profiles)
1723 };