avcodec/mqcdec: Support raw bypass and non reseting init
[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[6];
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,AV_PIX_FMT_YA16
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                               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         if (c->cblk_style & JPEG2000_CBLK_BYPASS)
415             av_log(s->avctx, AV_LOG_WARNING, "Selective arithmetic coding bypass\n");
416     }
417     c->transform = bytestream2_get_byteu(&s->g); // DWT transformation type
418     /* set integer 9/7 DWT in case of BITEXACT flag */
419     if ((s->avctx->flags & CODEC_FLAG_BITEXACT) && (c->transform == FF_DWT97))
420         c->transform = FF_DWT97_INT;
421
422     if (c->csty & JPEG2000_CSTY_PREC) {
423         int i;
424         for (i = 0; i < c->nreslevels; i++) {
425             byte = bytestream2_get_byte(&s->g);
426             c->log2_prec_widths[i]  =  byte       & 0x0F;    // precinct PPx
427             c->log2_prec_heights[i] = (byte >> 4) & 0x0F;    // precinct PPy
428         }
429     } else {
430         memset(c->log2_prec_widths , 15, sizeof(c->log2_prec_widths ));
431         memset(c->log2_prec_heights, 15, sizeof(c->log2_prec_heights));
432     }
433     return 0;
434 }
435
436 /* get coding parameters for a particular tile or whole image*/
437 static int get_cod(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c,
438                    uint8_t *properties)
439 {
440     Jpeg2000CodingStyle tmp;
441     int compno, ret;
442
443     if (bytestream2_get_bytes_left(&s->g) < 5)
444         return AVERROR_INVALIDDATA;
445
446     tmp.csty = bytestream2_get_byteu(&s->g);
447
448     // get progression order
449     tmp.prog_order = bytestream2_get_byteu(&s->g);
450
451     tmp.nlayers    = bytestream2_get_be16u(&s->g);
452     tmp.mct        = bytestream2_get_byteu(&s->g); // multiple component transformation
453
454     if (tmp.mct && s->ncomponents < 3) {
455         av_log(s->avctx, AV_LOG_ERROR,
456                "MCT %"PRIu8" with too few components (%d)\n",
457                tmp.mct, s->ncomponents);
458         return AVERROR_INVALIDDATA;
459     }
460
461     if ((ret = get_cox(s, &tmp)) < 0)
462         return ret;
463
464     for (compno = 0; compno < s->ncomponents; compno++)
465         if (!(properties[compno] & HAD_COC))
466             memcpy(c + compno, &tmp, sizeof(tmp));
467     return 0;
468 }
469
470 /* Get coding parameters for a component in the whole image or a
471  * particular tile. */
472 static int get_coc(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c,
473                    uint8_t *properties)
474 {
475     int compno, ret;
476
477     if (bytestream2_get_bytes_left(&s->g) < 2)
478         return AVERROR_INVALIDDATA;
479
480     compno = bytestream2_get_byteu(&s->g);
481
482     if (compno >= s->ncomponents) {
483         av_log(s->avctx, AV_LOG_ERROR,
484                "Invalid compno %d. There are %d components in the image.\n",
485                compno, s->ncomponents);
486         return AVERROR_INVALIDDATA;
487     }
488
489     c      += compno;
490     c->csty = bytestream2_get_byteu(&s->g);
491
492     if ((ret = get_cox(s, c)) < 0)
493         return ret;
494
495     properties[compno] |= HAD_COC;
496     return 0;
497 }
498
499 /* Get common part for QCD and QCC segments. */
500 static int get_qcx(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q)
501 {
502     int i, x;
503
504     if (bytestream2_get_bytes_left(&s->g) < 1)
505         return AVERROR_INVALIDDATA;
506
507     x = bytestream2_get_byteu(&s->g); // Sqcd
508
509     q->nguardbits = x >> 5;
510     q->quantsty   = x & 0x1f;
511
512     if (q->quantsty == JPEG2000_QSTY_NONE) {
513         n -= 3;
514         if (bytestream2_get_bytes_left(&s->g) < n ||
515             n > JPEG2000_MAX_DECLEVELS*3)
516             return AVERROR_INVALIDDATA;
517         for (i = 0; i < n; i++)
518             q->expn[i] = bytestream2_get_byteu(&s->g) >> 3;
519     } else if (q->quantsty == JPEG2000_QSTY_SI) {
520         if (bytestream2_get_bytes_left(&s->g) < 2)
521             return AVERROR_INVALIDDATA;
522         x          = bytestream2_get_be16u(&s->g);
523         q->expn[0] = x >> 11;
524         q->mant[0] = x & 0x7ff;
525         for (i = 1; i < JPEG2000_MAX_DECLEVELS * 3; i++) {
526             int curexpn = FFMAX(0, q->expn[0] - (i - 1) / 3);
527             q->expn[i] = curexpn;
528             q->mant[i] = q->mant[0];
529         }
530     } else {
531         n = (n - 3) >> 1;
532         if (bytestream2_get_bytes_left(&s->g) < 2 * n ||
533             n > JPEG2000_MAX_DECLEVELS*3)
534             return AVERROR_INVALIDDATA;
535         for (i = 0; i < n; i++) {
536             x          = bytestream2_get_be16u(&s->g);
537             q->expn[i] = x >> 11;
538             q->mant[i] = x & 0x7ff;
539         }
540     }
541     return 0;
542 }
543
544 /* Get quantization parameters for a particular tile or a whole image. */
545 static int get_qcd(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q,
546                    uint8_t *properties)
547 {
548     Jpeg2000QuantStyle tmp;
549     int compno, ret;
550
551     memset(&tmp, 0, sizeof(tmp));
552
553     if ((ret = get_qcx(s, n, &tmp)) < 0)
554         return ret;
555     for (compno = 0; compno < s->ncomponents; compno++)
556         if (!(properties[compno] & HAD_QCC))
557             memcpy(q + compno, &tmp, sizeof(tmp));
558     return 0;
559 }
560
561 /* Get quantization parameters for a component in the whole image
562  * on in a particular tile. */
563 static int get_qcc(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q,
564                    uint8_t *properties)
565 {
566     int compno;
567
568     if (bytestream2_get_bytes_left(&s->g) < 1)
569         return AVERROR_INVALIDDATA;
570
571     compno = bytestream2_get_byteu(&s->g);
572
573     if (compno >= s->ncomponents) {
574         av_log(s->avctx, AV_LOG_ERROR,
575                "Invalid compno %d. There are %d components in the image.\n",
576                compno, s->ncomponents);
577         return AVERROR_INVALIDDATA;
578     }
579
580     properties[compno] |= HAD_QCC;
581     return get_qcx(s, n - 1, q + compno);
582 }
583
584 /* Get start of tile segment. */
585 static int get_sot(Jpeg2000DecoderContext *s, int n)
586 {
587     Jpeg2000TilePart *tp;
588     uint16_t Isot;
589     uint32_t Psot;
590     uint8_t TPsot;
591
592     if (bytestream2_get_bytes_left(&s->g) < 8)
593         return AVERROR_INVALIDDATA;
594
595     s->curtileno = 0;
596     Isot = bytestream2_get_be16u(&s->g);        // Isot
597     if (Isot >= s->numXtiles * s->numYtiles)
598         return AVERROR_INVALIDDATA;
599
600     s->curtileno = Isot;
601     Psot  = bytestream2_get_be32u(&s->g);       // Psot
602     TPsot = bytestream2_get_byteu(&s->g);       // TPsot
603
604     /* Read TNSot but not used */
605     bytestream2_get_byteu(&s->g);               // TNsot
606
607     if (!Psot)
608         Psot = bytestream2_get_bytes_left(&s->g) + n + 2;
609
610     if (Psot > bytestream2_get_bytes_left(&s->g) + n + 2) {
611         av_log(s->avctx, AV_LOG_ERROR, "Psot %"PRIu32" too big\n", Psot);
612         return AVERROR_INVALIDDATA;
613     }
614
615     if (TPsot >= FF_ARRAY_ELEMS(s->tile[Isot].tile_part)) {
616         avpriv_request_sample(s->avctx, "Support for %"PRIu8" components", TPsot);
617         return AVERROR_PATCHWELCOME;
618     }
619
620     s->tile[Isot].tp_idx = TPsot;
621     tp             = s->tile[Isot].tile_part + TPsot;
622     tp->tile_index = Isot;
623     tp->tp_end     = s->g.buffer + Psot - n - 2;
624
625     if (!TPsot) {
626         Jpeg2000Tile *tile = s->tile + s->curtileno;
627
628         /* copy defaults */
629         memcpy(tile->codsty, s->codsty, s->ncomponents * sizeof(Jpeg2000CodingStyle));
630         memcpy(tile->qntsty, s->qntsty, s->ncomponents * sizeof(Jpeg2000QuantStyle));
631     }
632
633     return 0;
634 }
635
636 /* Tile-part lengths: see ISO 15444-1:2002, section A.7.1
637  * Used to know the number of tile parts and lengths.
638  * There may be multiple TLMs in the header.
639  * TODO: The function is not used for tile-parts management, nor anywhere else.
640  * It can be useful to allocate memory for tile parts, before managing the SOT
641  * markers. Parsing the TLM header is needed to increment the input header
642  * buffer.
643  * This marker is mandatory for DCI. */
644 static uint8_t get_tlm(Jpeg2000DecoderContext *s, int n)
645 {
646     uint8_t Stlm, ST, SP, tile_tlm, i;
647     bytestream2_get_byte(&s->g);               /* Ztlm: skipped */
648     Stlm = bytestream2_get_byte(&s->g);
649
650     // too complex ? ST = ((Stlm >> 4) & 0x01) + ((Stlm >> 4) & 0x02);
651     ST = (Stlm >> 4) & 0x03;
652     // TODO: Manage case of ST = 0b11 --> raise error
653     SP       = (Stlm >> 6) & 0x01;
654     tile_tlm = (n - 4) / ((SP + 1) * 2 + ST);
655     for (i = 0; i < tile_tlm; i++) {
656         switch (ST) {
657         case 0:
658             break;
659         case 1:
660             bytestream2_get_byte(&s->g);
661             break;
662         case 2:
663             bytestream2_get_be16(&s->g);
664             break;
665         case 3:
666             bytestream2_get_be32(&s->g);
667             break;
668         }
669         if (SP == 0) {
670             bytestream2_get_be16(&s->g);
671         } else {
672             bytestream2_get_be32(&s->g);
673         }
674     }
675     return 0;
676 }
677
678 static uint8_t get_plt(Jpeg2000DecoderContext *s, int n)
679 {
680     int i;
681
682     av_log(s->avctx, AV_LOG_ERROR,
683             "PLT marker at pos 0x%X\n", bytestream2_tell(&s->g) - 4);
684
685     /*Zplt =*/ bytestream2_get_byte(&s->g);
686
687     for (i = 0; i < n - 3; i++) {
688         bytestream2_get_byte(&s->g);
689     }
690
691     return 0;
692 }
693
694 static int init_tile(Jpeg2000DecoderContext *s, int tileno)
695 {
696     int compno;
697     int tilex = tileno % s->numXtiles;
698     int tiley = tileno / s->numXtiles;
699     Jpeg2000Tile *tile = s->tile + tileno;
700
701     if (!tile->comp)
702         return AVERROR(ENOMEM);
703
704     for (compno = 0; compno < s->ncomponents; compno++) {
705         Jpeg2000Component *comp = tile->comp + compno;
706         Jpeg2000CodingStyle *codsty = tile->codsty + compno;
707         Jpeg2000QuantStyle  *qntsty = tile->qntsty + compno;
708         int ret; // global bandno
709
710         comp->coord_o[0][0] = FFMAX(tilex       * s->tile_width  + s->tile_offset_x, s->image_offset_x);
711         comp->coord_o[0][1] = FFMIN((tilex + 1) * s->tile_width  + s->tile_offset_x, s->width);
712         comp->coord_o[1][0] = FFMAX(tiley       * s->tile_height + s->tile_offset_y, s->image_offset_y);
713         comp->coord_o[1][1] = FFMIN((tiley + 1) * s->tile_height + s->tile_offset_y, s->height);
714         if (compno) {
715             comp->coord_o[0][0] /= s->cdx[compno];
716             comp->coord_o[0][1] /= s->cdx[compno];
717             comp->coord_o[1][0] /= s->cdy[compno];
718             comp->coord_o[1][1] /= s->cdy[compno];
719         }
720
721         comp->coord[0][0] = ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], s->reduction_factor);
722         comp->coord[0][1] = ff_jpeg2000_ceildivpow2(comp->coord_o[0][1], s->reduction_factor);
723         comp->coord[1][0] = ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], s->reduction_factor);
724         comp->coord[1][1] = ff_jpeg2000_ceildivpow2(comp->coord_o[1][1], s->reduction_factor);
725
726         if (ret = ff_jpeg2000_init_component(comp, codsty, qntsty,
727                                              s->cbps[compno], s->cdx[compno],
728                                              s->cdy[compno], s->avctx))
729             return ret;
730     }
731     return 0;
732 }
733
734 /* Read the number of coding passes. */
735 static int getnpasses(Jpeg2000DecoderContext *s)
736 {
737     int num;
738     if (!get_bits(s, 1))
739         return 1;
740     if (!get_bits(s, 1))
741         return 2;
742     if ((num = get_bits(s, 2)) != 3)
743         return num < 0 ? num : 3 + num;
744     if ((num = get_bits(s, 5)) != 31)
745         return num < 0 ? num : 6 + num;
746     num = get_bits(s, 7);
747     return num < 0 ? num : 37 + num;
748 }
749
750 static int getlblockinc(Jpeg2000DecoderContext *s)
751 {
752     int res = 0, ret;
753     while (ret = get_bits(s, 1)) {
754         if (ret < 0)
755             return ret;
756         res++;
757     }
758     return res;
759 }
760
761 static int jpeg2000_decode_packet(Jpeg2000DecoderContext *s,
762                                   Jpeg2000CodingStyle *codsty,
763                                   Jpeg2000ResLevel *rlevel, int precno,
764                                   int layno, uint8_t *expn, int numgbits)
765 {
766     int bandno, cblkno, ret, nb_code_blocks;
767
768     if (!(ret = get_bits(s, 1))) {
769         jpeg2000_flush(s);
770         return 0;
771     } else if (ret < 0)
772         return ret;
773
774     for (bandno = 0; bandno < rlevel->nbands; bandno++) {
775         Jpeg2000Band *band = rlevel->band + bandno;
776         Jpeg2000Prec *prec = band->prec + precno;
777
778         if (band->coord[0][0] == band->coord[0][1] ||
779             band->coord[1][0] == band->coord[1][1])
780             continue;
781         nb_code_blocks =  prec->nb_codeblocks_height *
782                           prec->nb_codeblocks_width;
783         for (cblkno = 0; cblkno < nb_code_blocks; cblkno++) {
784             Jpeg2000Cblk *cblk = prec->cblk + cblkno;
785             int incl, newpasses, llen;
786
787             if (cblk->npasses)
788                 incl = get_bits(s, 1);
789             else
790                 incl = tag_tree_decode(s, prec->cblkincl + cblkno, layno + 1) == layno;
791             if (!incl)
792                 continue;
793             else if (incl < 0)
794                 return incl;
795
796             if (!cblk->npasses) {
797                 int v = expn[bandno] + numgbits - 1 -
798                         tag_tree_decode(s, prec->zerobits + cblkno, 100);
799                 if (v < 0) {
800                     av_log(s->avctx, AV_LOG_ERROR,
801                            "nonzerobits %d invalid\n", v);
802                     return AVERROR_INVALIDDATA;
803                 }
804                 cblk->nonzerobits = v;
805             }
806             if ((newpasses = getnpasses(s)) < 0)
807                 return newpasses;
808             av_assert2(newpasses > 0);
809             if (cblk->npasses + newpasses >= JPEG2000_MAX_PASSES) {
810                 avpriv_request_sample(s->avctx, "Too many passes\n");
811                 return AVERROR_PATCHWELCOME;
812             }
813             if ((llen = getlblockinc(s)) < 0)
814                 return llen;
815             if (cblk->lblock + llen + av_log2(newpasses) > 16) {
816                 avpriv_request_sample(s->avctx,
817                                       "Block with length beyond 16 bits\n");
818                 return AVERROR_PATCHWELCOME;
819             }
820
821             cblk->lblock += llen;
822             if ((ret = get_bits(s, av_log2(newpasses) + cblk->lblock)) < 0)
823                 return ret;
824             if (ret > sizeof(cblk->data)) {
825                 avpriv_request_sample(s->avctx,
826                                       "Block with lengthinc greater than %"SIZE_SPECIFIER"",
827                                       sizeof(cblk->data));
828                 return AVERROR_PATCHWELCOME;
829             }
830             cblk->lengthinc = ret;
831             cblk->npasses  += newpasses;
832         }
833     }
834     jpeg2000_flush(s);
835
836     if (codsty->csty & JPEG2000_CSTY_EPH) {
837         if (bytestream2_peek_be16(&s->g) == JPEG2000_EPH)
838             bytestream2_skip(&s->g, 2);
839         else
840             av_log(s->avctx, AV_LOG_ERROR, "EPH marker not found.\n");
841     }
842
843     for (bandno = 0; bandno < rlevel->nbands; bandno++) {
844         Jpeg2000Band *band = rlevel->band + bandno;
845         Jpeg2000Prec *prec = band->prec + precno;
846
847         nb_code_blocks = prec->nb_codeblocks_height * prec->nb_codeblocks_width;
848         for (cblkno = 0; cblkno < nb_code_blocks; cblkno++) {
849             Jpeg2000Cblk *cblk = prec->cblk + cblkno;
850             if (   bytestream2_get_bytes_left(&s->g) < cblk->lengthinc
851                 || sizeof(cblk->data) < cblk->length + cblk->lengthinc + 2
852             ) {
853                 av_log(s->avctx, AV_LOG_ERROR,
854                        "Block length %"PRIu16" or lengthinc %d is too large\n",
855                        cblk->length, cblk->lengthinc);
856                 return AVERROR_INVALIDDATA;
857             }
858
859             bytestream2_get_bufferu(&s->g, cblk->data + cblk->length, cblk->lengthinc);
860             cblk->length   += cblk->lengthinc;
861             cblk->lengthinc = 0;
862         }
863     }
864     return 0;
865 }
866
867 static int jpeg2000_decode_packets(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
868 {
869     int ret = 0;
870     int layno, reslevelno, compno, precno, ok_reslevel;
871     int x, y;
872
873     s->bit_index = 8;
874     switch (tile->codsty[0].prog_order) {
875     case JPEG2000_PGOD_RLCP:
876         av_log(s->avctx, AV_LOG_WARNING, "Progression order RLCP\n");
877         ok_reslevel = 1;
878         for (reslevelno = 0; ok_reslevel; reslevelno++) {
879             ok_reslevel = 0;
880             for (layno = 0; layno < tile->codsty[0].nlayers; layno++) {
881                 for (compno = 0; compno < s->ncomponents; compno++) {
882                     Jpeg2000CodingStyle *codsty = tile->codsty + compno;
883                     Jpeg2000QuantStyle *qntsty  = tile->qntsty + compno;
884                     if (reslevelno < codsty->nreslevels) {
885                         Jpeg2000ResLevel *rlevel = tile->comp[compno].reslevel +
886                                                 reslevelno;
887                         ok_reslevel = 1;
888                         for (precno = 0; precno < rlevel->num_precincts_x * rlevel->num_precincts_y; precno++)
889                             if ((ret = jpeg2000_decode_packet(s,
890                                                               codsty, rlevel,
891                                                               precno, layno,
892                                                               qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
893                                                               qntsty->nguardbits)) < 0)
894                                 return ret;
895                     }
896                 }
897             }
898         }
899         break;
900
901     case JPEG2000_PGOD_LRCP:
902         for (layno = 0; layno < tile->codsty[0].nlayers; layno++) {
903             ok_reslevel = 1;
904             for (reslevelno = 0; ok_reslevel; reslevelno++) {
905                 ok_reslevel = 0;
906                 for (compno = 0; compno < s->ncomponents; compno++) {
907                     Jpeg2000CodingStyle *codsty = tile->codsty + compno;
908                     Jpeg2000QuantStyle *qntsty  = tile->qntsty + compno;
909                     if (reslevelno < codsty->nreslevels) {
910                         Jpeg2000ResLevel *rlevel = tile->comp[compno].reslevel +
911                                                 reslevelno;
912                         ok_reslevel = 1;
913                         for (precno = 0; precno < rlevel->num_precincts_x * rlevel->num_precincts_y; precno++)
914                             if ((ret = jpeg2000_decode_packet(s,
915                                                               codsty, rlevel,
916                                                               precno, layno,
917                                                               qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
918                                                               qntsty->nguardbits)) < 0)
919                                 return ret;
920                     }
921                 }
922             }
923         }
924         break;
925
926     case JPEG2000_PGOD_CPRL:
927         for (compno = 0; compno < s->ncomponents; compno++) {
928             Jpeg2000CodingStyle *codsty = tile->codsty + compno;
929             Jpeg2000QuantStyle *qntsty  = tile->qntsty + compno;
930
931             /* Set bit stream buffer address according to tile-part.
932              * For DCinema one tile-part per component, so can be
933              * indexed by component. */
934             s->g = tile->tile_part[compno].tpg;
935
936             /* Position loop (y axis)
937              * TODO: Automate computing of step 256.
938              * Fixed here, but to be computed before entering here. */
939             for (y = 0; y < s->height; y += 256) {
940                 /* Position loop (y axis)
941                  * TODO: automate computing of step 256.
942                  * Fixed here, but to be computed before entering here. */
943                 for (x = 0; x < s->width; x += 256) {
944                     for (reslevelno = 0; reslevelno < codsty->nreslevels; reslevelno++) {
945                         uint16_t prcx, prcy;
946                         uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; //  ==> N_L - r
947                         Jpeg2000ResLevel *rlevel = tile->comp[compno].reslevel + reslevelno;
948
949                         if (!((y % (1 << (rlevel->log2_prec_height + reducedresno)) == 0) ||
950                               (y == 0))) // TODO: 2nd condition simplified as try0 always =0 for dcinema
951                             continue;
952
953                         if (!((x % (1 << (rlevel->log2_prec_width + reducedresno)) == 0) ||
954                               (x == 0))) // TODO: 2nd condition simplified as try0 always =0 for dcinema
955                             continue;
956
957                         // check if a precinct exists
958                         prcx   = ff_jpeg2000_ceildivpow2(x, reducedresno) >> rlevel->log2_prec_width;
959                         prcy   = ff_jpeg2000_ceildivpow2(y, reducedresno) >> rlevel->log2_prec_height;
960                         precno = prcx + rlevel->num_precincts_x * prcy;
961
962                         if (prcx >= rlevel->num_precincts_x || prcy >= rlevel->num_precincts_y)
963                             return AVERROR_PATCHWELCOME;
964
965                         for (layno = 0; layno < tile->codsty[0].nlayers; layno++) {
966                             if ((ret = jpeg2000_decode_packet(s, codsty, rlevel,
967                                                               precno, layno,
968                                                               qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
969                                                               qntsty->nguardbits)) < 0)
970                                 return ret;
971                         }
972                     }
973                 }
974             }
975         }
976         break;
977
978     case JPEG2000_PGOD_RPCL:
979         avpriv_request_sample(s->avctx, "Progression order RPCL");
980         ret = AVERROR_PATCHWELCOME;
981         break;
982
983     case JPEG2000_PGOD_PCRL:
984         avpriv_request_sample(s->avctx, "Progression order PCRL");
985         ret = AVERROR_PATCHWELCOME;
986         break;
987
988     default:
989         break;
990     }
991
992     /* EOC marker reached */
993     bytestream2_skip(&s->g, 2);
994
995     return ret;
996 }
997
998 /* TIER-1 routines */
999 static void decode_sigpass(Jpeg2000T1Context *t1, int width, int height,
1000                            int bpno, int bandno, int bpass_csty_symbol,
1001                            int vert_causal_ctx_csty_symbol)
1002 {
1003     int mask = 3 << (bpno - 1), y0, x, y;
1004
1005     for (y0 = 0; y0 < height; y0 += 4)
1006         for (x = 0; x < width; x++)
1007             for (y = y0; y < height && y < y0 + 4; y++) {
1008                 if ((t1->flags[y+1][x+1] & JPEG2000_T1_SIG_NB)
1009                 && !(t1->flags[y+1][x+1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS))) {
1010                     int flags_mask = -1;
1011                     if (vert_causal_ctx_csty_symbol && y == y0 + 3)
1012                         flags_mask &= ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE);
1013                     if (ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ff_jpeg2000_getsigctxno(t1->flags[y+1][x+1] & flags_mask, bandno))) {
1014                         int xorbit, ctxno = ff_jpeg2000_getsgnctxno(t1->flags[y+1][x+1], &xorbit);
1015                         if (bpass_csty_symbol)
1016                              t1->data[y][x] = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ctxno) ? -mask : mask;
1017                         else
1018                              t1->data[y][x] = (ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ctxno) ^ xorbit) ?
1019                                                -mask : mask;
1020
1021                         ff_jpeg2000_set_significance(t1, x, y,
1022                                                      t1->data[y][x] < 0);
1023                     }
1024                     t1->flags[y + 1][x + 1] |= JPEG2000_T1_VIS;
1025                 }
1026             }
1027 }
1028
1029 static void decode_refpass(Jpeg2000T1Context *t1, int width, int height,
1030                            int bpno)
1031 {
1032     int phalf, nhalf;
1033     int y0, x, y;
1034
1035     phalf = 1 << (bpno - 1);
1036     nhalf = -phalf;
1037
1038     for (y0 = 0; y0 < height; y0 += 4)
1039         for (x = 0; x < width; x++)
1040             for (y = y0; y < height && y < y0 + 4; y++)
1041                 if ((t1->flags[y + 1][x + 1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS)) == JPEG2000_T1_SIG) {
1042                     int ctxno = ff_jpeg2000_getrefctxno(t1->flags[y + 1][x + 1]);
1043                     int r     = ff_mqc_decode(&t1->mqc,
1044                                               t1->mqc.cx_states + ctxno)
1045                                 ? phalf : nhalf;
1046                     t1->data[y][x]          += t1->data[y][x] < 0 ? -r : r;
1047                     t1->flags[y + 1][x + 1] |= JPEG2000_T1_REF;
1048                 }
1049 }
1050
1051 static void decode_clnpass(Jpeg2000DecoderContext *s, Jpeg2000T1Context *t1,
1052                            int width, int height, int bpno, int bandno,
1053                            int seg_symbols, int vert_causal_ctx_csty_symbol)
1054 {
1055     int mask = 3 << (bpno - 1), y0, x, y, runlen, dec;
1056
1057     for (y0 = 0; y0 < height; y0 += 4) {
1058         for (x = 0; x < width; x++) {
1059             if (y0 + 3 < height &&
1060                 !((t1->flags[y0 + 1][x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
1061                   (t1->flags[y0 + 2][x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
1062                   (t1->flags[y0 + 3][x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
1063                   (t1->flags[y0 + 4][x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)))) {
1064                 if (!ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_RL))
1065                     continue;
1066                 runlen = ff_mqc_decode(&t1->mqc,
1067                                        t1->mqc.cx_states + MQC_CX_UNI);
1068                 runlen = (runlen << 1) | ff_mqc_decode(&t1->mqc,
1069                                                        t1->mqc.cx_states +
1070                                                        MQC_CX_UNI);
1071                 dec = 1;
1072             } else {
1073                 runlen = 0;
1074                 dec    = 0;
1075             }
1076
1077             for (y = y0 + runlen; y < y0 + 4 && y < height; y++) {
1078                 if (!dec) {
1079                     if (!(t1->flags[y+1][x+1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS))) {
1080                         int flags_mask = -1;
1081                         if (vert_causal_ctx_csty_symbol && y == y0 + 3)
1082                             flags_mask &= ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE);
1083                         dec = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ff_jpeg2000_getsigctxno(t1->flags[y+1][x+1] & flags_mask,
1084                                                                                              bandno));
1085                     }
1086                 }
1087                 if (dec) {
1088                     int xorbit;
1089                     int ctxno = ff_jpeg2000_getsgnctxno(t1->flags[y + 1][x + 1],
1090                                                         &xorbit);
1091                     t1->data[y][x] = (ff_mqc_decode(&t1->mqc,
1092                                                     t1->mqc.cx_states + ctxno) ^
1093                                       xorbit)
1094                                      ? -mask : mask;
1095                     ff_jpeg2000_set_significance(t1, x, y, t1->data[y][x] < 0);
1096                 }
1097                 dec = 0;
1098                 t1->flags[y + 1][x + 1] &= ~JPEG2000_T1_VIS;
1099             }
1100         }
1101     }
1102     if (seg_symbols) {
1103         int val;
1104         val = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1105         val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1106         val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1107         val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1108         if (val != 0xa)
1109             av_log(s->avctx, AV_LOG_ERROR,
1110                    "Segmentation symbol value incorrect\n");
1111     }
1112 }
1113
1114 static int decode_cblk(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *codsty,
1115                        Jpeg2000T1Context *t1, Jpeg2000Cblk *cblk,
1116                        int width, int height, int bandpos)
1117 {
1118     int passno = cblk->npasses, pass_t = 2, bpno = cblk->nonzerobits - 1, y;
1119     int clnpass_cnt = 0;
1120     int bpass_csty_symbol           = codsty->cblk_style & JPEG2000_CBLK_BYPASS;
1121     int vert_causal_ctx_csty_symbol = codsty->cblk_style & JPEG2000_CBLK_VSC;
1122
1123     av_assert0(width  <= JPEG2000_MAX_CBLKW);
1124     av_assert0(height <= JPEG2000_MAX_CBLKH);
1125
1126     for (y = 0; y < height; y++)
1127         memset(t1->data[y], 0, width * sizeof(**t1->data));
1128
1129     /* If code-block contains no compressed data: nothing to do. */
1130     if (!cblk->length)
1131         return 0;
1132
1133     for (y = 0; y < height + 2; y++)
1134         memset(t1->flags[y], 0, (width + 2) * sizeof(**t1->flags));
1135
1136     cblk->data[cblk->length] = 0xff;
1137     cblk->data[cblk->length+1] = 0xff;
1138     ff_mqc_initdec(&t1->mqc, cblk->data, 0, 1);
1139
1140     while (passno--) {
1141         switch(pass_t) {
1142         case 0:
1143             decode_sigpass(t1, width, height, bpno + 1, bandpos,
1144                            bpass_csty_symbol && (clnpass_cnt >= 4),
1145                            vert_causal_ctx_csty_symbol);
1146             break;
1147         case 1:
1148             decode_refpass(t1, width, height, bpno + 1);
1149             break;
1150         case 2:
1151             decode_clnpass(s, t1, width, height, bpno + 1, bandpos,
1152                            codsty->cblk_style & JPEG2000_CBLK_SEGSYM,
1153                            vert_causal_ctx_csty_symbol);
1154             break;
1155         }
1156
1157         pass_t++;
1158         if (pass_t == 3) {
1159             bpno--;
1160             pass_t = 0;
1161         }
1162     }
1163     return 0;
1164 }
1165
1166 /* TODO: Verify dequantization for lossless case
1167  * comp->data can be float or int
1168  * band->stepsize can be float or int
1169  * depending on the type of DWT transformation.
1170  * see ISO/IEC 15444-1:2002 A.6.1 */
1171
1172 /* Float dequantization of a codeblock.*/
1173 static void dequantization_float(int x, int y, Jpeg2000Cblk *cblk,
1174                                  Jpeg2000Component *comp,
1175                                  Jpeg2000T1Context *t1, Jpeg2000Band *band)
1176 {
1177     int i, j;
1178     int w = cblk->coord[0][1] - cblk->coord[0][0];
1179     for (j = 0; j < (cblk->coord[1][1] - cblk->coord[1][0]); ++j) {
1180         float *datap = &comp->f_data[(comp->coord[0][1] - comp->coord[0][0]) * (y + j) + x];
1181         int *src = t1->data[j];
1182         for (i = 0; i < w; ++i)
1183             datap[i] = src[i] * band->f_stepsize;
1184     }
1185 }
1186
1187 /* Integer dequantization of a codeblock.*/
1188 static void dequantization_int(int x, int y, Jpeg2000Cblk *cblk,
1189                                Jpeg2000Component *comp,
1190                                Jpeg2000T1Context *t1, Jpeg2000Band *band)
1191 {
1192     int i, j;
1193     int w = cblk->coord[0][1] - cblk->coord[0][0];
1194     for (j = 0; j < (cblk->coord[1][1] - cblk->coord[1][0]); ++j) {
1195         int32_t *datap = &comp->i_data[(comp->coord[0][1] - comp->coord[0][0]) * (y + j) + x];
1196         int *src = t1->data[j];
1197         for (i = 0; i < w; ++i)
1198             datap[i] = (src[i] * band->i_stepsize) / 32768;
1199     }
1200 }
1201
1202 static void dequantization_int_97(int x, int y, Jpeg2000Cblk *cblk,
1203                                Jpeg2000Component *comp,
1204                                Jpeg2000T1Context *t1, Jpeg2000Band *band)
1205 {
1206     int i, j;
1207     int w = cblk->coord[0][1] - cblk->coord[0][0];
1208     for (j = 0; j < (cblk->coord[1][1] - cblk->coord[1][0]); ++j) {
1209         int32_t *datap = &comp->i_data[(comp->coord[0][1] - comp->coord[0][0]) * (y + j) + x];
1210         int *src = t1->data[j];
1211         for (i = 0; i < w; ++i)
1212             datap[i] = (src[i] * band->i_stepsize + (1<<14)) >> 15;
1213     }
1214 }
1215
1216 static inline void mct_decode(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
1217 {
1218     int i, csize = 1;
1219     void *src[3];
1220
1221     for (i = 1; i < 3; i++) {
1222         if (tile->codsty[0].transform != tile->codsty[i].transform) {
1223             av_log(s->avctx, AV_LOG_ERROR, "Transforms mismatch, MCT not supported\n");
1224             return;
1225         }
1226         if (memcmp(tile->comp[0].coord, tile->comp[i].coord, sizeof(tile->comp[0].coord))) {
1227             av_log(s->avctx, AV_LOG_ERROR, "Coords mismatch, MCT not supported\n");
1228             return;
1229         }
1230     }
1231
1232     for (i = 0; i < 3; i++)
1233         if (tile->codsty[0].transform == FF_DWT97)
1234             src[i] = tile->comp[i].f_data;
1235         else
1236             src[i] = tile->comp[i].i_data;
1237
1238     for (i = 0; i < 2; i++)
1239         csize *= tile->comp[0].coord[i][1] - tile->comp[0].coord[i][0];
1240
1241     s->dsp.mct_decode[tile->codsty[0].transform](src[0], src[1], src[2], csize);
1242 }
1243
1244 static int jpeg2000_decode_tile(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile,
1245                                 AVFrame *picture)
1246 {
1247     const AVPixFmtDescriptor *pixdesc = av_pix_fmt_desc_get(s->avctx->pix_fmt);
1248     int compno, reslevelno, bandno;
1249     int x, y;
1250     int planar    = !!(pixdesc->flags & AV_PIX_FMT_FLAG_PLANAR);
1251     int pixelsize = planar ? 1 : pixdesc->nb_components;
1252
1253     uint8_t *line;
1254     Jpeg2000T1Context t1;
1255
1256     /* Loop on tile components */
1257     for (compno = 0; compno < s->ncomponents; compno++) {
1258         Jpeg2000Component *comp     = tile->comp + compno;
1259         Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1260
1261         /* Loop on resolution levels */
1262         for (reslevelno = 0; reslevelno < codsty->nreslevels2decode; reslevelno++) {
1263             Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1264             /* Loop on bands */
1265             for (bandno = 0; bandno < rlevel->nbands; bandno++) {
1266                 int nb_precincts, precno;
1267                 Jpeg2000Band *band = rlevel->band + bandno;
1268                 int cblkno = 0, bandpos;
1269
1270                 bandpos = bandno + (reslevelno > 0);
1271
1272                 if (band->coord[0][0] == band->coord[0][1] ||
1273                     band->coord[1][0] == band->coord[1][1])
1274                     continue;
1275
1276                 nb_precincts = rlevel->num_precincts_x * rlevel->num_precincts_y;
1277                 /* Loop on precincts */
1278                 for (precno = 0; precno < nb_precincts; precno++) {
1279                     Jpeg2000Prec *prec = band->prec + precno;
1280
1281                     /* Loop on codeblocks */
1282                     for (cblkno = 0; cblkno < prec->nb_codeblocks_width * prec->nb_codeblocks_height; cblkno++) {
1283                         int x, y;
1284                         Jpeg2000Cblk *cblk = prec->cblk + cblkno;
1285                         decode_cblk(s, codsty, &t1, cblk,
1286                                     cblk->coord[0][1] - cblk->coord[0][0],
1287                                     cblk->coord[1][1] - cblk->coord[1][0],
1288                                     bandpos);
1289
1290                         x = cblk->coord[0][0];
1291                         y = cblk->coord[1][0];
1292
1293                         if (codsty->transform == FF_DWT97)
1294                             dequantization_float(x, y, cblk, comp, &t1, band);
1295                         else if (codsty->transform == FF_DWT97_INT)
1296                             dequantization_int_97(x, y, cblk, comp, &t1, band);
1297                         else
1298                             dequantization_int(x, y, cblk, comp, &t1, band);
1299                    } /* end cblk */
1300                 } /*end prec */
1301             } /* end band */
1302         } /* end reslevel */
1303
1304         /* inverse DWT */
1305         ff_dwt_decode(&comp->dwt, codsty->transform == FF_DWT97 ? (void*)comp->f_data : (void*)comp->i_data);
1306     } /*end comp */
1307
1308     /* inverse MCT transformation */
1309     if (tile->codsty[0].mct)
1310         mct_decode(s, tile);
1311
1312     if (s->cdef[0] < 0) {
1313         for (x = 0; x < s->ncomponents; x++)
1314             s->cdef[x] = x + 1;
1315         if ((s->ncomponents & 1) == 0)
1316             s->cdef[s->ncomponents-1] = 0;
1317     }
1318
1319     if (s->precision <= 8) {
1320         for (compno = 0; compno < s->ncomponents; compno++) {
1321             Jpeg2000Component *comp = tile->comp + compno;
1322             Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1323             float *datap = comp->f_data;
1324             int32_t *i_datap = comp->i_data;
1325             int cbps = s->cbps[compno];
1326             int w = tile->comp[compno].coord[0][1] - s->image_offset_x;
1327             int plane = 0;
1328
1329             if (planar)
1330                 plane = s->cdef[compno] ? s->cdef[compno]-1 : (s->ncomponents-1);
1331
1332
1333             y    = tile->comp[compno].coord[1][0] - s->image_offset_y;
1334             line = picture->data[plane] + y / s->cdy[compno] * picture->linesize[plane];
1335             for (; y < tile->comp[compno].coord[1][1] - s->image_offset_y; y ++) {
1336                 uint8_t *dst;
1337
1338                 x   = tile->comp[compno].coord[0][0] - s->image_offset_x;
1339                 dst = line + x / s->cdx[compno] * pixelsize + compno*!planar;
1340
1341                 if (codsty->transform == FF_DWT97) {
1342                     for (; x < w; x ++) {
1343                         int val = lrintf(*datap) + (1 << (cbps - 1));
1344                         /* DC level shift and clip see ISO 15444-1:2002 G.1.2 */
1345                         val = av_clip(val, 0, (1 << cbps) - 1);
1346                         *dst = val << (8 - cbps);
1347                         datap++;
1348                         dst += pixelsize;
1349                     }
1350                 } else {
1351                     for (; x < w; x ++) {
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                         *dst = val << (8 - cbps);
1356                         i_datap++;
1357                         dst += pixelsize;
1358                     }
1359                 }
1360                 line += picture->linesize[plane];
1361             }
1362         }
1363     } else {
1364         int precision = picture->format == AV_PIX_FMT_XYZ12 ||
1365                         picture->format == AV_PIX_FMT_RGB48 ||
1366                         picture->format == AV_PIX_FMT_RGBA64 ||
1367                         picture->format == AV_PIX_FMT_GRAY16 ? 16 : s->precision;
1368
1369         for (compno = 0; compno < s->ncomponents; compno++) {
1370             Jpeg2000Component *comp = tile->comp + compno;
1371             Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1372             float *datap = comp->f_data;
1373             int32_t *i_datap = comp->i_data;
1374             uint16_t *linel;
1375             int cbps = s->cbps[compno];
1376             int w = tile->comp[compno].coord[0][1] - s->image_offset_x;
1377             int plane = 0;
1378
1379             if (planar)
1380                 plane = s->cdef[compno] ? s->cdef[compno]-1 : (s->ncomponents-1);
1381
1382             y     = tile->comp[compno].coord[1][0] - s->image_offset_y;
1383             linel = (uint16_t *)picture->data[plane] + y / s->cdy[compno] * (picture->linesize[plane] >> 1);
1384             for (; y < tile->comp[compno].coord[1][1] - s->image_offset_y; y ++) {
1385                 uint16_t *dst;
1386
1387                 x   = tile->comp[compno].coord[0][0] - s->image_offset_x;
1388                 dst = linel + (x / s->cdx[compno] * pixelsize + compno*!planar);
1389                 if (codsty->transform == FF_DWT97) {
1390                     for (; x < w; x ++) {
1391                         int  val = lrintf(*datap) + (1 << (cbps - 1));
1392                         /* DC level shift and clip see ISO 15444-1:2002 G.1.2 */
1393                         val = av_clip(val, 0, (1 << cbps) - 1);
1394                         /* align 12 bit values in little-endian mode */
1395                         *dst = val << (precision - cbps);
1396                         datap++;
1397                         dst += pixelsize;
1398                     }
1399                 } else {
1400                     for (; x < w; x ++) {
1401                         int val = *i_datap + (1 << (cbps - 1));
1402                         /* DC level shift and clip see ISO 15444-1:2002 G.1.2 */
1403                         val = av_clip(val, 0, (1 << cbps) - 1);
1404                         /* align 12 bit values in little-endian mode */
1405                         *dst = val << (precision - cbps);
1406                         i_datap++;
1407                         dst += pixelsize;
1408                     }
1409                 }
1410                 linel += picture->linesize[plane] >> 1;
1411             }
1412         }
1413     }
1414
1415     return 0;
1416 }
1417
1418 static void jpeg2000_dec_cleanup(Jpeg2000DecoderContext *s)
1419 {
1420     int tileno, compno;
1421     for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++) {
1422         if (s->tile[tileno].comp) {
1423             for (compno = 0; compno < s->ncomponents; compno++) {
1424                 Jpeg2000Component *comp     = s->tile[tileno].comp   + compno;
1425                 Jpeg2000CodingStyle *codsty = s->tile[tileno].codsty + compno;
1426
1427                 ff_jpeg2000_cleanup(comp, codsty);
1428             }
1429             av_freep(&s->tile[tileno].comp);
1430         }
1431     }
1432     av_freep(&s->tile);
1433     memset(s->codsty, 0, sizeof(s->codsty));
1434     memset(s->qntsty, 0, sizeof(s->qntsty));
1435     s->numXtiles = s->numYtiles = 0;
1436 }
1437
1438 static int jpeg2000_read_main_headers(Jpeg2000DecoderContext *s)
1439 {
1440     Jpeg2000CodingStyle *codsty = s->codsty;
1441     Jpeg2000QuantStyle *qntsty  = s->qntsty;
1442     uint8_t *properties         = s->properties;
1443
1444     for (;;) {
1445         int len, ret = 0;
1446         uint16_t marker;
1447         int oldpos;
1448
1449         if (bytestream2_get_bytes_left(&s->g) < 2) {
1450             av_log(s->avctx, AV_LOG_ERROR, "Missing EOC\n");
1451             break;
1452         }
1453
1454         marker = bytestream2_get_be16u(&s->g);
1455         oldpos = bytestream2_tell(&s->g);
1456
1457         if (marker == JPEG2000_SOD) {
1458             Jpeg2000Tile *tile;
1459             Jpeg2000TilePart *tp;
1460
1461             if (!s->tile) {
1462                 av_log(s->avctx, AV_LOG_ERROR, "Missing SIZ\n");
1463                 return AVERROR_INVALIDDATA;
1464             }
1465             if (s->curtileno < 0) {
1466                 av_log(s->avctx, AV_LOG_ERROR, "Missing SOT\n");
1467                 return AVERROR_INVALIDDATA;
1468             }
1469
1470             tile = s->tile + s->curtileno;
1471             tp = tile->tile_part + tile->tp_idx;
1472             if (tp->tp_end < s->g.buffer) {
1473                 av_log(s->avctx, AV_LOG_ERROR, "Invalid tpend\n");
1474                 return AVERROR_INVALIDDATA;
1475             }
1476             bytestream2_init(&tp->tpg, s->g.buffer, tp->tp_end - s->g.buffer);
1477             bytestream2_skip(&s->g, tp->tp_end - s->g.buffer);
1478
1479             continue;
1480         }
1481         if (marker == JPEG2000_EOC)
1482             break;
1483
1484         len = bytestream2_get_be16(&s->g);
1485         if (len < 2 || bytestream2_get_bytes_left(&s->g) < len - 2)
1486             return AVERROR_INVALIDDATA;
1487
1488         switch (marker) {
1489         case JPEG2000_SIZ:
1490             ret = get_siz(s);
1491             if (!s->tile)
1492                 s->numXtiles = s->numYtiles = 0;
1493             break;
1494         case JPEG2000_COC:
1495             ret = get_coc(s, codsty, properties);
1496             break;
1497         case JPEG2000_COD:
1498             ret = get_cod(s, codsty, properties);
1499             break;
1500         case JPEG2000_QCC:
1501             ret = get_qcc(s, len, qntsty, properties);
1502             break;
1503         case JPEG2000_QCD:
1504             ret = get_qcd(s, len, qntsty, properties);
1505             break;
1506         case JPEG2000_SOT:
1507             if (!(ret = get_sot(s, len))) {
1508                 av_assert1(s->curtileno >= 0);
1509                 codsty = s->tile[s->curtileno].codsty;
1510                 qntsty = s->tile[s->curtileno].qntsty;
1511                 properties = s->tile[s->curtileno].properties;
1512             }
1513             break;
1514         case JPEG2000_COM:
1515             // the comment is ignored
1516             bytestream2_skip(&s->g, len - 2);
1517             break;
1518         case JPEG2000_TLM:
1519             // Tile-part lengths
1520             ret = get_tlm(s, len);
1521             break;
1522         case JPEG2000_PLT:
1523             // Packet length, tile-part header
1524             ret = get_plt(s, len);
1525             break;
1526         default:
1527             av_log(s->avctx, AV_LOG_ERROR,
1528                    "unsupported marker 0x%.4"PRIX16" at pos 0x%X\n",
1529                    marker, bytestream2_tell(&s->g) - 4);
1530             bytestream2_skip(&s->g, len - 2);
1531             break;
1532         }
1533         if (bytestream2_tell(&s->g) - oldpos != len || ret) {
1534             av_log(s->avctx, AV_LOG_ERROR,
1535                    "error during processing marker segment %.4"PRIx16"\n",
1536                    marker);
1537             return ret ? ret : -1;
1538         }
1539     }
1540     return 0;
1541 }
1542
1543 /* Read bit stream packets --> T2 operation. */
1544 static int jpeg2000_read_bitstream_packets(Jpeg2000DecoderContext *s)
1545 {
1546     int ret = 0;
1547     int tileno;
1548
1549     for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++) {
1550         Jpeg2000Tile *tile = s->tile + tileno;
1551
1552         if (ret = init_tile(s, tileno))
1553             return ret;
1554
1555         s->g = tile->tile_part[0].tpg;
1556         if (ret = jpeg2000_decode_packets(s, tile))
1557             return ret;
1558     }
1559
1560     return 0;
1561 }
1562
1563 static int jp2_find_codestream(Jpeg2000DecoderContext *s)
1564 {
1565     uint32_t atom_size, atom, atom_end;
1566     int search_range = 10;
1567
1568     while (search_range
1569            &&
1570            bytestream2_get_bytes_left(&s->g) >= 8) {
1571         atom_size = bytestream2_get_be32u(&s->g);
1572         atom      = bytestream2_get_be32u(&s->g);
1573         atom_end  = bytestream2_tell(&s->g) + atom_size - 8;
1574
1575         if (atom == JP2_CODESTREAM)
1576             return 1;
1577
1578         if (bytestream2_get_bytes_left(&s->g) < atom_size || atom_end < atom_size)
1579             return 0;
1580
1581         if (atom == JP2_HEADER &&
1582                    atom_size >= 16) {
1583             uint32_t atom2_size, atom2, atom2_end;
1584             do {
1585                 atom2_size = bytestream2_get_be32u(&s->g);
1586                 atom2      = bytestream2_get_be32u(&s->g);
1587                 atom2_end  = bytestream2_tell(&s->g) + atom2_size - 8;
1588                 if (atom2_size < 8 || atom2_end > atom_end || atom2_end < atom2_size)
1589                     break;
1590                 if (atom2 == JP2_CODESTREAM) {
1591                     return 1;
1592                 } else if (atom2 == MKBETAG('c','o','l','r') && atom2_size >= 7) {
1593                     int method = bytestream2_get_byteu(&s->g);
1594                     bytestream2_skipu(&s->g, 2);
1595                     if (method == 1) {
1596                         s->colour_space = bytestream2_get_be32u(&s->g);
1597                     }
1598                 } else if (atom2 == MKBETAG('p','c','l','r') && atom2_size >= 6) {
1599                     int i, size, colour_count, colour_channels, colour_depth[3];
1600                     uint32_t r, g, b;
1601                     colour_count = bytestream2_get_be16u(&s->g);
1602                     colour_channels = bytestream2_get_byteu(&s->g);
1603                     // FIXME: Do not ignore channel_sign
1604                     colour_depth[0] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1;
1605                     colour_depth[1] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1;
1606                     colour_depth[2] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1;
1607                     size = (colour_depth[0] + 7 >> 3) * colour_count +
1608                            (colour_depth[1] + 7 >> 3) * colour_count +
1609                            (colour_depth[2] + 7 >> 3) * colour_count;
1610                     if (colour_count > 256   ||
1611                         colour_channels != 3 ||
1612                         colour_depth[0] > 16 ||
1613                         colour_depth[1] > 16 ||
1614                         colour_depth[2] > 16 ||
1615                         atom2_size < size) {
1616                         avpriv_request_sample(s->avctx, "Unknown palette");
1617                         bytestream2_seek(&s->g, atom2_end, SEEK_SET);
1618                         continue;
1619                     }
1620                     s->pal8 = 1;
1621                     for (i = 0; i < colour_count; i++) {
1622                         if (colour_depth[0] <= 8) {
1623                             r = bytestream2_get_byteu(&s->g) << 8 - colour_depth[0];
1624                             r |= r >> colour_depth[0];
1625                         } else {
1626                             r = bytestream2_get_be16u(&s->g) >> colour_depth[0] - 8;
1627                         }
1628                         if (colour_depth[1] <= 8) {
1629                             g = bytestream2_get_byteu(&s->g) << 8 - colour_depth[1];
1630                             r |= r >> colour_depth[1];
1631                         } else {
1632                             g = bytestream2_get_be16u(&s->g) >> colour_depth[1] - 8;
1633                         }
1634                         if (colour_depth[2] <= 8) {
1635                             b = bytestream2_get_byteu(&s->g) << 8 - colour_depth[2];
1636                             r |= r >> colour_depth[2];
1637                         } else {
1638                             b = bytestream2_get_be16u(&s->g) >> colour_depth[2] - 8;
1639                         }
1640                         s->palette[i] = 0xffu << 24 | r << 16 | g << 8 | b;
1641                     }
1642                 } else if (atom2 == MKBETAG('c','d','e','f') && atom2_size >= 2) {
1643                     int n = bytestream2_get_be16u(&s->g);
1644                     for (; n>0; n--) {
1645                         int cn   = bytestream2_get_be16(&s->g);
1646                         int av_unused typ  = bytestream2_get_be16(&s->g);
1647                         int asoc = bytestream2_get_be16(&s->g);
1648                         if (cn < 4 && asoc < 4)
1649                             s->cdef[cn] = asoc;
1650                     }
1651                 }
1652                 bytestream2_seek(&s->g, atom2_end, SEEK_SET);
1653             } while (atom_end - atom2_end >= 8);
1654         } else {
1655             search_range--;
1656         }
1657         bytestream2_seek(&s->g, atom_end, SEEK_SET);
1658     }
1659
1660     return 0;
1661 }
1662
1663 static av_cold int jpeg2000_decode_init(AVCodecContext *avctx)
1664 {
1665     Jpeg2000DecoderContext *s = avctx->priv_data;
1666
1667     ff_jpeg2000dsp_init(&s->dsp);
1668
1669     return 0;
1670 }
1671
1672 static int jpeg2000_decode_frame(AVCodecContext *avctx, void *data,
1673                                  int *got_frame, AVPacket *avpkt)
1674 {
1675     Jpeg2000DecoderContext *s = avctx->priv_data;
1676     ThreadFrame frame = { .f = data };
1677     AVFrame *picture = data;
1678     int tileno, ret;
1679
1680     s->avctx     = avctx;
1681     bytestream2_init(&s->g, avpkt->data, avpkt->size);
1682     s->curtileno = -1;
1683     memset(s->cdef, -1, sizeof(s->cdef));
1684
1685     if (bytestream2_get_bytes_left(&s->g) < 2) {
1686         ret = AVERROR_INVALIDDATA;
1687         goto end;
1688     }
1689
1690     // check if the image is in jp2 format
1691     if (bytestream2_get_bytes_left(&s->g) >= 12 &&
1692        (bytestream2_get_be32u(&s->g) == 12) &&
1693        (bytestream2_get_be32u(&s->g) == JP2_SIG_TYPE) &&
1694        (bytestream2_get_be32u(&s->g) == JP2_SIG_VALUE)) {
1695         if (!jp2_find_codestream(s)) {
1696             av_log(avctx, AV_LOG_ERROR,
1697                    "Could not find Jpeg2000 codestream atom.\n");
1698             ret = AVERROR_INVALIDDATA;
1699             goto end;
1700         }
1701     } else {
1702         bytestream2_seek(&s->g, 0, SEEK_SET);
1703     }
1704
1705     while (bytestream2_get_bytes_left(&s->g) >= 3 && bytestream2_peek_be16(&s->g) != JPEG2000_SOC)
1706         bytestream2_skip(&s->g, 1);
1707
1708     if (bytestream2_get_be16u(&s->g) != JPEG2000_SOC) {
1709         av_log(avctx, AV_LOG_ERROR, "SOC marker not present\n");
1710         ret = AVERROR_INVALIDDATA;
1711         goto end;
1712     }
1713     if (ret = jpeg2000_read_main_headers(s))
1714         goto end;
1715
1716     /* get picture buffer */
1717     if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
1718         goto end;
1719     picture->pict_type = AV_PICTURE_TYPE_I;
1720     picture->key_frame = 1;
1721
1722     if (ret = jpeg2000_read_bitstream_packets(s))
1723         goto end;
1724
1725     for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++)
1726         if (ret = jpeg2000_decode_tile(s, s->tile + tileno, picture))
1727             goto end;
1728
1729     jpeg2000_dec_cleanup(s);
1730
1731     *got_frame = 1;
1732
1733     if (s->avctx->pix_fmt == AV_PIX_FMT_PAL8)
1734         memcpy(picture->data[1], s->palette, 256 * sizeof(uint32_t));
1735
1736     return bytestream2_tell(&s->g);
1737
1738 end:
1739     jpeg2000_dec_cleanup(s);
1740     return ret;
1741 }
1742
1743 static av_cold void jpeg2000_init_static_data(AVCodec *codec)
1744 {
1745     ff_jpeg2000_init_tier1_luts();
1746     ff_mqc_init_context_tables();
1747 }
1748
1749 #define OFFSET(x) offsetof(Jpeg2000DecoderContext, x)
1750 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
1751
1752 static const AVOption options[] = {
1753     { "lowres",  "Lower the decoding resolution by a power of two",
1754         OFFSET(reduction_factor), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, JPEG2000_MAX_RESLEVELS - 1, VD },
1755     { NULL },
1756 };
1757
1758 static const AVProfile profiles[] = {
1759     { FF_PROFILE_JPEG2000_CSTREAM_RESTRICTION_0,  "JPEG 2000 codestream restriction 0"   },
1760     { FF_PROFILE_JPEG2000_CSTREAM_RESTRICTION_1,  "JPEG 2000 codestream restriction 1"   },
1761     { FF_PROFILE_JPEG2000_CSTREAM_NO_RESTRICTION, "JPEG 2000 no codestream restrictions" },
1762     { FF_PROFILE_JPEG2000_DCINEMA_2K,             "JPEG 2000 digital cinema 2K"          },
1763     { FF_PROFILE_JPEG2000_DCINEMA_4K,             "JPEG 2000 digital cinema 4K"          },
1764     { FF_PROFILE_UNKNOWN },
1765 };
1766
1767 static const AVClass jpeg2000_class = {
1768     .class_name = "jpeg2000",
1769     .item_name  = av_default_item_name,
1770     .option     = options,
1771     .version    = LIBAVUTIL_VERSION_INT,
1772 };
1773
1774 AVCodec ff_jpeg2000_decoder = {
1775     .name             = "jpeg2000",
1776     .long_name        = NULL_IF_CONFIG_SMALL("JPEG 2000"),
1777     .type             = AVMEDIA_TYPE_VIDEO,
1778     .id               = AV_CODEC_ID_JPEG2000,
1779     .capabilities     = CODEC_CAP_FRAME_THREADS,
1780     .priv_data_size   = sizeof(Jpeg2000DecoderContext),
1781     .init_static_data = jpeg2000_init_static_data,
1782     .init             = jpeg2000_decode_init,
1783     .decode           = jpeg2000_decode_frame,
1784     .priv_class       = &jpeg2000_class,
1785     .max_lowres       = 5,
1786     .profiles         = NULL_IF_CONFIG_SMALL(profiles)
1787 };