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