avcodec/jpeg2000dec: Try to fix remaining DCinema hardcoded TODOs in CPRL
[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             int maxlogstep_x = 0;
970             int maxlogstep_y = 0;
971             int start_x, start_y;
972
973             for (reslevelno = 0; reslevelno < codsty->nreslevels; reslevelno++) {
974                 uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; //  ==> N_L - r
975                 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
976                 step_x = FFMIN(step_x, rlevel->log2_prec_width  + reducedresno);
977                 step_y = FFMIN(step_y, rlevel->log2_prec_height + reducedresno);
978                 maxlogstep_x = FFMAX(maxlogstep_x, rlevel->log2_prec_width  + reducedresno);
979                 maxlogstep_y = FFMAX(maxlogstep_y, rlevel->log2_prec_height + reducedresno);
980             }
981             step_x = 1<<step_x;
982             step_y = 1<<step_y;
983
984             start_y = comp->coord_o[1][0] >> maxlogstep_y << maxlogstep_y;
985             start_x = comp->coord_o[0][0] >> maxlogstep_x << maxlogstep_x;
986             for (y = start_y; y < comp->coord_o[1][1]; y += step_y) {
987                 for (x = start_x; x < comp->coord_o[0][1]; x += step_x) {
988                     for (reslevelno = 0; reslevelno < codsty->nreslevels; reslevelno++) {
989                         unsigned prcx, prcy;
990                         uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; //  ==> N_L - r
991                         Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
992
993                         if (y % (1 << (rlevel->log2_prec_height + reducedresno)))
994                             continue;
995
996                         if (x % (1 << (rlevel->log2_prec_width + reducedresno)))
997                             continue;
998
999                         // check if a precinct exists
1000                         prcx   = ff_jpeg2000_ceildivpow2(x, reducedresno) >> rlevel->log2_prec_width;
1001                         prcy   = ff_jpeg2000_ceildivpow2(y, reducedresno) >> rlevel->log2_prec_height;
1002                         prcx  -= ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], reducedresno) >> rlevel->log2_prec_width;
1003                         prcy  -= ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], reducedresno) >> rlevel->log2_prec_height;
1004
1005                         precno = prcx + rlevel->num_precincts_x * prcy;
1006
1007                         if (prcx >= rlevel->num_precincts_x || prcy >= rlevel->num_precincts_y) {
1008                             av_log(s->avctx, AV_LOG_WARNING, "prc %d %d outside limits %d %d\n",
1009                                    prcx, prcy, rlevel->num_precincts_x, rlevel->num_precincts_y);
1010                             continue;
1011                         }
1012
1013                         for (layno = 0; layno < tile->codsty[0].nlayers; layno++) {
1014                             if ((ret = jpeg2000_decode_packet(s, tile, &tp_index, codsty, rlevel,
1015                                                               precno, layno,
1016                                                               qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1017                                                               qntsty->nguardbits)) < 0)
1018                                 return ret;
1019                         }
1020                     }
1021                 }
1022             }
1023         }
1024         break;
1025
1026     case JPEG2000_PGOD_RPCL:
1027         avpriv_request_sample(s->avctx, "Progression order RPCL");
1028         ret = AVERROR_PATCHWELCOME;
1029         break;
1030
1031     case JPEG2000_PGOD_PCRL:
1032         avpriv_request_sample(s->avctx, "Progression order PCRL");
1033         ret = AVERROR_PATCHWELCOME;
1034         break;
1035
1036     default:
1037         break;
1038     }
1039
1040     /* EOC marker reached */
1041     bytestream2_skip(&s->g, 2);
1042
1043     return ret;
1044 }
1045
1046 /* TIER-1 routines */
1047 static void decode_sigpass(Jpeg2000T1Context *t1, int width, int height,
1048                            int bpno, int bandno,
1049                            int vert_causal_ctx_csty_symbol)
1050 {
1051     int mask = 3 << (bpno - 1), y0, x, y;
1052
1053     for (y0 = 0; y0 < height; y0 += 4)
1054         for (x = 0; x < width; x++)
1055             for (y = y0; y < height && y < y0 + 4; y++) {
1056                 if ((t1->flags[y+1][x+1] & JPEG2000_T1_SIG_NB)
1057                 && !(t1->flags[y+1][x+1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS))) {
1058                     int flags_mask = -1;
1059                     if (vert_causal_ctx_csty_symbol && y == y0 + 3)
1060                         flags_mask &= ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE);
1061                     if (ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ff_jpeg2000_getsigctxno(t1->flags[y+1][x+1] & flags_mask, bandno))) {
1062                         int xorbit, ctxno = ff_jpeg2000_getsgnctxno(t1->flags[y+1][x+1], &xorbit);
1063                         if (t1->mqc.raw)
1064                              t1->data[y][x] = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ctxno) ? -mask : mask;
1065                         else
1066                              t1->data[y][x] = (ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ctxno) ^ xorbit) ?
1067                                                -mask : mask;
1068
1069                         ff_jpeg2000_set_significance(t1, x, y,
1070                                                      t1->data[y][x] < 0);
1071                     }
1072                     t1->flags[y + 1][x + 1] |= JPEG2000_T1_VIS;
1073                 }
1074             }
1075 }
1076
1077 static void decode_refpass(Jpeg2000T1Context *t1, int width, int height,
1078                            int bpno)
1079 {
1080     int phalf, nhalf;
1081     int y0, x, y;
1082
1083     phalf = 1 << (bpno - 1);
1084     nhalf = -phalf;
1085
1086     for (y0 = 0; y0 < height; y0 += 4)
1087         for (x = 0; x < width; x++)
1088             for (y = y0; y < height && y < y0 + 4; y++)
1089                 if ((t1->flags[y + 1][x + 1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS)) == JPEG2000_T1_SIG) {
1090                     int ctxno = ff_jpeg2000_getrefctxno(t1->flags[y + 1][x + 1]);
1091                     int r     = ff_mqc_decode(&t1->mqc,
1092                                               t1->mqc.cx_states + ctxno)
1093                                 ? phalf : nhalf;
1094                     t1->data[y][x]          += t1->data[y][x] < 0 ? -r : r;
1095                     t1->flags[y + 1][x + 1] |= JPEG2000_T1_REF;
1096                 }
1097 }
1098
1099 static void decode_clnpass(Jpeg2000DecoderContext *s, Jpeg2000T1Context *t1,
1100                            int width, int height, int bpno, int bandno,
1101                            int seg_symbols, int vert_causal_ctx_csty_symbol)
1102 {
1103     int mask = 3 << (bpno - 1), y0, x, y, runlen, dec;
1104
1105     for (y0 = 0; y0 < height; y0 += 4) {
1106         for (x = 0; x < width; x++) {
1107             if (y0 + 3 < height &&
1108                 !((t1->flags[y0 + 1][x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
1109                   (t1->flags[y0 + 2][x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
1110                   (t1->flags[y0 + 3][x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
1111                   (t1->flags[y0 + 4][x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)))) {
1112                 if (!ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_RL))
1113                     continue;
1114                 runlen = ff_mqc_decode(&t1->mqc,
1115                                        t1->mqc.cx_states + MQC_CX_UNI);
1116                 runlen = (runlen << 1) | ff_mqc_decode(&t1->mqc,
1117                                                        t1->mqc.cx_states +
1118                                                        MQC_CX_UNI);
1119                 dec = 1;
1120             } else {
1121                 runlen = 0;
1122                 dec    = 0;
1123             }
1124
1125             for (y = y0 + runlen; y < y0 + 4 && y < height; y++) {
1126                 if (!dec) {
1127                     if (!(t1->flags[y+1][x+1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS))) {
1128                         int flags_mask = -1;
1129                         if (vert_causal_ctx_csty_symbol && y == y0 + 3)
1130                             flags_mask &= ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE);
1131                         dec = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ff_jpeg2000_getsigctxno(t1->flags[y+1][x+1] & flags_mask,
1132                                                                                              bandno));
1133                     }
1134                 }
1135                 if (dec) {
1136                     int xorbit;
1137                     int ctxno = ff_jpeg2000_getsgnctxno(t1->flags[y + 1][x + 1],
1138                                                         &xorbit);
1139                     t1->data[y][x] = (ff_mqc_decode(&t1->mqc,
1140                                                     t1->mqc.cx_states + ctxno) ^
1141                                       xorbit)
1142                                      ? -mask : mask;
1143                     ff_jpeg2000_set_significance(t1, x, y, t1->data[y][x] < 0);
1144                 }
1145                 dec = 0;
1146                 t1->flags[y + 1][x + 1] &= ~JPEG2000_T1_VIS;
1147             }
1148         }
1149     }
1150     if (seg_symbols) {
1151         int val;
1152         val = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1153         val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1154         val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1155         val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1156         if (val != 0xa)
1157             av_log(s->avctx, AV_LOG_ERROR,
1158                    "Segmentation symbol value incorrect\n");
1159     }
1160 }
1161
1162 static int decode_cblk(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *codsty,
1163                        Jpeg2000T1Context *t1, Jpeg2000Cblk *cblk,
1164                        int width, int height, int bandpos)
1165 {
1166     int passno = cblk->npasses, pass_t = 2, bpno = cblk->nonzerobits - 1, y;
1167     int pass_cnt = 0;
1168     int vert_causal_ctx_csty_symbol = codsty->cblk_style & JPEG2000_CBLK_VSC;
1169     int term_cnt = 0;
1170     int coder_type;
1171
1172     av_assert0(width  <= JPEG2000_MAX_CBLKW);
1173     av_assert0(height <= JPEG2000_MAX_CBLKH);
1174
1175     for (y = 0; y < height; y++)
1176         memset(t1->data[y], 0, width * sizeof(**t1->data));
1177
1178     /* If code-block contains no compressed data: nothing to do. */
1179     if (!cblk->length)
1180         return 0;
1181
1182     for (y = 0; y < height + 2; y++)
1183         memset(t1->flags[y], 0, (width + 2) * sizeof(**t1->flags));
1184
1185     cblk->data[cblk->length] = 0xff;
1186     cblk->data[cblk->length+1] = 0xff;
1187     ff_mqc_initdec(&t1->mqc, cblk->data, 0, 1);
1188
1189     while (passno--) {
1190         switch(pass_t) {
1191         case 0:
1192             decode_sigpass(t1, width, height, bpno + 1, bandpos,
1193                            vert_causal_ctx_csty_symbol);
1194             break;
1195         case 1:
1196             decode_refpass(t1, width, height, bpno + 1);
1197             break;
1198         case 2:
1199             av_assert2(!t1->mqc.raw);
1200             decode_clnpass(s, t1, width, height, bpno + 1, bandpos,
1201                            codsty->cblk_style & JPEG2000_CBLK_SEGSYM,
1202                            vert_causal_ctx_csty_symbol);
1203             break;
1204         }
1205         if ((coder_type = needs_termination(codsty->cblk_style, pass_cnt))) {
1206             if (term_cnt >= cblk->nb_terminations) {
1207                 av_log(s->avctx, AV_LOG_ERROR, "Missing needed termination \n");
1208                 return AVERROR_INVALIDDATA;
1209             }
1210             ff_mqc_initdec(&t1->mqc, cblk->data + cblk->data_start[++term_cnt], coder_type == 2, 0);
1211         }
1212
1213         pass_t++;
1214         if (pass_t == 3) {
1215             bpno--;
1216             pass_t = 0;
1217         }
1218         pass_cnt ++;
1219     }
1220     return 0;
1221 }
1222
1223 /* TODO: Verify dequantization for lossless case
1224  * comp->data can be float or int
1225  * band->stepsize can be float or int
1226  * depending on the type of DWT transformation.
1227  * see ISO/IEC 15444-1:2002 A.6.1 */
1228
1229 /* Float dequantization of a codeblock.*/
1230 static void dequantization_float(int x, int y, Jpeg2000Cblk *cblk,
1231                                  Jpeg2000Component *comp,
1232                                  Jpeg2000T1Context *t1, Jpeg2000Band *band)
1233 {
1234     int i, j;
1235     int w = cblk->coord[0][1] - cblk->coord[0][0];
1236     for (j = 0; j < (cblk->coord[1][1] - cblk->coord[1][0]); ++j) {
1237         float *datap = &comp->f_data[(comp->coord[0][1] - comp->coord[0][0]) * (y + j) + x];
1238         int *src = t1->data[j];
1239         for (i = 0; i < w; ++i)
1240             datap[i] = src[i] * band->f_stepsize;
1241     }
1242 }
1243
1244 /* Integer dequantization of a codeblock.*/
1245 static void dequantization_int(int x, int y, Jpeg2000Cblk *cblk,
1246                                Jpeg2000Component *comp,
1247                                Jpeg2000T1Context *t1, Jpeg2000Band *band)
1248 {
1249     int i, j;
1250     int w = cblk->coord[0][1] - cblk->coord[0][0];
1251     for (j = 0; j < (cblk->coord[1][1] - cblk->coord[1][0]); ++j) {
1252         int32_t *datap = &comp->i_data[(comp->coord[0][1] - comp->coord[0][0]) * (y + j) + x];
1253         int *src = t1->data[j];
1254         for (i = 0; i < w; ++i)
1255             datap[i] = (src[i] * band->i_stepsize) / 32768;
1256     }
1257 }
1258
1259 static void dequantization_int_97(int x, int y, Jpeg2000Cblk *cblk,
1260                                Jpeg2000Component *comp,
1261                                Jpeg2000T1Context *t1, Jpeg2000Band *band)
1262 {
1263     int i, j;
1264     int w = cblk->coord[0][1] - cblk->coord[0][0];
1265     for (j = 0; j < (cblk->coord[1][1] - cblk->coord[1][0]); ++j) {
1266         int32_t *datap = &comp->i_data[(comp->coord[0][1] - comp->coord[0][0]) * (y + j) + x];
1267         int *src = t1->data[j];
1268         for (i = 0; i < w; ++i)
1269             datap[i] = (src[i] * band->i_stepsize + (1<<14)) >> 15;
1270     }
1271 }
1272
1273 static inline void mct_decode(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
1274 {
1275     int i, csize = 1;
1276     void *src[3];
1277
1278     for (i = 1; i < 3; i++) {
1279         if (tile->codsty[0].transform != tile->codsty[i].transform) {
1280             av_log(s->avctx, AV_LOG_ERROR, "Transforms mismatch, MCT not supported\n");
1281             return;
1282         }
1283         if (memcmp(tile->comp[0].coord, tile->comp[i].coord, sizeof(tile->comp[0].coord))) {
1284             av_log(s->avctx, AV_LOG_ERROR, "Coords mismatch, MCT not supported\n");
1285             return;
1286         }
1287     }
1288
1289     for (i = 0; i < 3; i++)
1290         if (tile->codsty[0].transform == FF_DWT97)
1291             src[i] = tile->comp[i].f_data;
1292         else
1293             src[i] = tile->comp[i].i_data;
1294
1295     for (i = 0; i < 2; i++)
1296         csize *= tile->comp[0].coord[i][1] - tile->comp[0].coord[i][0];
1297
1298     s->dsp.mct_decode[tile->codsty[0].transform](src[0], src[1], src[2], csize);
1299 }
1300
1301 static int jpeg2000_decode_tile(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile,
1302                                 AVFrame *picture)
1303 {
1304     const AVPixFmtDescriptor *pixdesc = av_pix_fmt_desc_get(s->avctx->pix_fmt);
1305     int compno, reslevelno, bandno;
1306     int x, y;
1307     int planar    = !!(pixdesc->flags & AV_PIX_FMT_FLAG_PLANAR);
1308     int pixelsize = planar ? 1 : pixdesc->nb_components;
1309
1310     uint8_t *line;
1311     Jpeg2000T1Context t1;
1312
1313     /* Loop on tile components */
1314     for (compno = 0; compno < s->ncomponents; compno++) {
1315         Jpeg2000Component *comp     = tile->comp + compno;
1316         Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1317
1318         /* Loop on resolution levels */
1319         for (reslevelno = 0; reslevelno < codsty->nreslevels2decode; reslevelno++) {
1320             Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1321             /* Loop on bands */
1322             for (bandno = 0; bandno < rlevel->nbands; bandno++) {
1323                 int nb_precincts, precno;
1324                 Jpeg2000Band *band = rlevel->band + bandno;
1325                 int cblkno = 0, bandpos;
1326
1327                 bandpos = bandno + (reslevelno > 0);
1328
1329                 if (band->coord[0][0] == band->coord[0][1] ||
1330                     band->coord[1][0] == band->coord[1][1])
1331                     continue;
1332
1333                 nb_precincts = rlevel->num_precincts_x * rlevel->num_precincts_y;
1334                 /* Loop on precincts */
1335                 for (precno = 0; precno < nb_precincts; precno++) {
1336                     Jpeg2000Prec *prec = band->prec + precno;
1337
1338                     /* Loop on codeblocks */
1339                     for (cblkno = 0; cblkno < prec->nb_codeblocks_width * prec->nb_codeblocks_height; cblkno++) {
1340                         int x, y;
1341                         Jpeg2000Cblk *cblk = prec->cblk + cblkno;
1342                         decode_cblk(s, codsty, &t1, cblk,
1343                                     cblk->coord[0][1] - cblk->coord[0][0],
1344                                     cblk->coord[1][1] - cblk->coord[1][0],
1345                                     bandpos);
1346
1347                         x = cblk->coord[0][0];
1348                         y = cblk->coord[1][0];
1349
1350                         if (codsty->transform == FF_DWT97)
1351                             dequantization_float(x, y, cblk, comp, &t1, band);
1352                         else if (codsty->transform == FF_DWT97_INT)
1353                             dequantization_int_97(x, y, cblk, comp, &t1, band);
1354                         else
1355                             dequantization_int(x, y, cblk, comp, &t1, band);
1356                    } /* end cblk */
1357                 } /*end prec */
1358             } /* end band */
1359         } /* end reslevel */
1360
1361         /* inverse DWT */
1362         ff_dwt_decode(&comp->dwt, codsty->transform == FF_DWT97 ? (void*)comp->f_data : (void*)comp->i_data);
1363     } /*end comp */
1364
1365     /* inverse MCT transformation */
1366     if (tile->codsty[0].mct)
1367         mct_decode(s, tile);
1368
1369     if (s->cdef[0] < 0) {
1370         for (x = 0; x < s->ncomponents; x++)
1371             s->cdef[x] = x + 1;
1372         if ((s->ncomponents & 1) == 0)
1373             s->cdef[s->ncomponents-1] = 0;
1374     }
1375
1376     if (s->precision <= 8) {
1377         for (compno = 0; compno < s->ncomponents; compno++) {
1378             Jpeg2000Component *comp = tile->comp + compno;
1379             Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1380             float *datap = comp->f_data;
1381             int32_t *i_datap = comp->i_data;
1382             int cbps = s->cbps[compno];
1383             int w = tile->comp[compno].coord[0][1] - s->image_offset_x;
1384             int plane = 0;
1385
1386             if (planar)
1387                 plane = s->cdef[compno] ? s->cdef[compno]-1 : (s->ncomponents-1);
1388
1389
1390             y    = tile->comp[compno].coord[1][0] - s->image_offset_y;
1391             line = picture->data[plane] + y / s->cdy[compno] * picture->linesize[plane];
1392             for (; y < tile->comp[compno].coord[1][1] - s->image_offset_y; y ++) {
1393                 uint8_t *dst;
1394
1395                 x   = tile->comp[compno].coord[0][0] - s->image_offset_x;
1396                 dst = line + x / s->cdx[compno] * pixelsize + compno*!planar;
1397
1398                 if (codsty->transform == FF_DWT97) {
1399                     for (; x < w; x ++) {
1400                         int val = lrintf(*datap) + (1 << (cbps - 1));
1401                         /* DC level shift and clip see ISO 15444-1:2002 G.1.2 */
1402                         val = av_clip(val, 0, (1 << cbps) - 1);
1403                         *dst = val << (8 - cbps);
1404                         datap++;
1405                         dst += pixelsize;
1406                     }
1407                 } else {
1408                     for (; x < w; x ++) {
1409                         int val = *i_datap + (1 << (cbps - 1));
1410                         /* DC level shift and clip see ISO 15444-1:2002 G.1.2 */
1411                         val = av_clip(val, 0, (1 << cbps) - 1);
1412                         *dst = val << (8 - cbps);
1413                         i_datap++;
1414                         dst += pixelsize;
1415                     }
1416                 }
1417                 line += picture->linesize[plane];
1418             }
1419         }
1420     } else {
1421         int precision = picture->format == AV_PIX_FMT_XYZ12 ||
1422                         picture->format == AV_PIX_FMT_RGB48 ||
1423                         picture->format == AV_PIX_FMT_RGBA64 ||
1424                         picture->format == AV_PIX_FMT_GRAY16 ? 16 : s->precision;
1425
1426         for (compno = 0; compno < s->ncomponents; compno++) {
1427             Jpeg2000Component *comp = tile->comp + compno;
1428             Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1429             float *datap = comp->f_data;
1430             int32_t *i_datap = comp->i_data;
1431             uint16_t *linel;
1432             int cbps = s->cbps[compno];
1433             int w = tile->comp[compno].coord[0][1] - s->image_offset_x;
1434             int plane = 0;
1435
1436             if (planar)
1437                 plane = s->cdef[compno] ? s->cdef[compno]-1 : (s->ncomponents-1);
1438
1439             y     = tile->comp[compno].coord[1][0] - s->image_offset_y;
1440             linel = (uint16_t *)picture->data[plane] + y / s->cdy[compno] * (picture->linesize[plane] >> 1);
1441             for (; y < tile->comp[compno].coord[1][1] - s->image_offset_y; y ++) {
1442                 uint16_t *dst;
1443
1444                 x   = tile->comp[compno].coord[0][0] - s->image_offset_x;
1445                 dst = linel + (x / s->cdx[compno] * pixelsize + compno*!planar);
1446                 if (codsty->transform == FF_DWT97) {
1447                     for (; x < w; x ++) {
1448                         int  val = lrintf(*datap) + (1 << (cbps - 1));
1449                         /* DC level shift and clip see ISO 15444-1:2002 G.1.2 */
1450                         val = av_clip(val, 0, (1 << cbps) - 1);
1451                         /* align 12 bit values in little-endian mode */
1452                         *dst = val << (precision - cbps);
1453                         datap++;
1454                         dst += pixelsize;
1455                     }
1456                 } else {
1457                     for (; x < w; x ++) {
1458                         int val = *i_datap + (1 << (cbps - 1));
1459                         /* DC level shift and clip see ISO 15444-1:2002 G.1.2 */
1460                         val = av_clip(val, 0, (1 << cbps) - 1);
1461                         /* align 12 bit values in little-endian mode */
1462                         *dst = val << (precision - cbps);
1463                         i_datap++;
1464                         dst += pixelsize;
1465                     }
1466                 }
1467                 linel += picture->linesize[plane] >> 1;
1468             }
1469         }
1470     }
1471
1472     return 0;
1473 }
1474
1475 static void jpeg2000_dec_cleanup(Jpeg2000DecoderContext *s)
1476 {
1477     int tileno, compno;
1478     for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++) {
1479         if (s->tile[tileno].comp) {
1480             for (compno = 0; compno < s->ncomponents; compno++) {
1481                 Jpeg2000Component *comp     = s->tile[tileno].comp   + compno;
1482                 Jpeg2000CodingStyle *codsty = s->tile[tileno].codsty + compno;
1483
1484                 ff_jpeg2000_cleanup(comp, codsty);
1485             }
1486             av_freep(&s->tile[tileno].comp);
1487         }
1488     }
1489     av_freep(&s->tile);
1490     memset(s->codsty, 0, sizeof(s->codsty));
1491     memset(s->qntsty, 0, sizeof(s->qntsty));
1492     s->numXtiles = s->numYtiles = 0;
1493 }
1494
1495 static int jpeg2000_read_main_headers(Jpeg2000DecoderContext *s)
1496 {
1497     Jpeg2000CodingStyle *codsty = s->codsty;
1498     Jpeg2000QuantStyle *qntsty  = s->qntsty;
1499     uint8_t *properties         = s->properties;
1500
1501     for (;;) {
1502         int len, ret = 0;
1503         uint16_t marker;
1504         int oldpos;
1505
1506         if (bytestream2_get_bytes_left(&s->g) < 2) {
1507             av_log(s->avctx, AV_LOG_ERROR, "Missing EOC\n");
1508             break;
1509         }
1510
1511         marker = bytestream2_get_be16u(&s->g);
1512         oldpos = bytestream2_tell(&s->g);
1513
1514         if (marker == JPEG2000_SOD) {
1515             Jpeg2000Tile *tile;
1516             Jpeg2000TilePart *tp;
1517
1518             if (!s->tile) {
1519                 av_log(s->avctx, AV_LOG_ERROR, "Missing SIZ\n");
1520                 return AVERROR_INVALIDDATA;
1521             }
1522             if (s->curtileno < 0) {
1523                 av_log(s->avctx, AV_LOG_ERROR, "Missing SOT\n");
1524                 return AVERROR_INVALIDDATA;
1525             }
1526
1527             tile = s->tile + s->curtileno;
1528             tp = tile->tile_part + tile->tp_idx;
1529             if (tp->tp_end < s->g.buffer) {
1530                 av_log(s->avctx, AV_LOG_ERROR, "Invalid tpend\n");
1531                 return AVERROR_INVALIDDATA;
1532             }
1533             bytestream2_init(&tp->tpg, s->g.buffer, tp->tp_end - s->g.buffer);
1534             bytestream2_skip(&s->g, tp->tp_end - s->g.buffer);
1535
1536             continue;
1537         }
1538         if (marker == JPEG2000_EOC)
1539             break;
1540
1541         len = bytestream2_get_be16(&s->g);
1542         if (len < 2 || bytestream2_get_bytes_left(&s->g) < len - 2)
1543             return AVERROR_INVALIDDATA;
1544
1545         switch (marker) {
1546         case JPEG2000_SIZ:
1547             ret = get_siz(s);
1548             if (!s->tile)
1549                 s->numXtiles = s->numYtiles = 0;
1550             break;
1551         case JPEG2000_COC:
1552             ret = get_coc(s, codsty, properties);
1553             break;
1554         case JPEG2000_COD:
1555             ret = get_cod(s, codsty, properties);
1556             break;
1557         case JPEG2000_QCC:
1558             ret = get_qcc(s, len, qntsty, properties);
1559             break;
1560         case JPEG2000_QCD:
1561             ret = get_qcd(s, len, qntsty, properties);
1562             break;
1563         case JPEG2000_SOT:
1564             if (!(ret = get_sot(s, len))) {
1565                 av_assert1(s->curtileno >= 0);
1566                 codsty = s->tile[s->curtileno].codsty;
1567                 qntsty = s->tile[s->curtileno].qntsty;
1568                 properties = s->tile[s->curtileno].properties;
1569             }
1570             break;
1571         case JPEG2000_COM:
1572             // the comment is ignored
1573             bytestream2_skip(&s->g, len - 2);
1574             break;
1575         case JPEG2000_TLM:
1576             // Tile-part lengths
1577             ret = get_tlm(s, len);
1578             break;
1579         case JPEG2000_PLT:
1580             // Packet length, tile-part header
1581             ret = get_plt(s, len);
1582             break;
1583         default:
1584             av_log(s->avctx, AV_LOG_ERROR,
1585                    "unsupported marker 0x%.4"PRIX16" at pos 0x%X\n",
1586                    marker, bytestream2_tell(&s->g) - 4);
1587             bytestream2_skip(&s->g, len - 2);
1588             break;
1589         }
1590         if (bytestream2_tell(&s->g) - oldpos != len || ret) {
1591             av_log(s->avctx, AV_LOG_ERROR,
1592                    "error during processing marker segment %.4"PRIx16"\n",
1593                    marker);
1594             return ret ? ret : -1;
1595         }
1596     }
1597     return 0;
1598 }
1599
1600 /* Read bit stream packets --> T2 operation. */
1601 static int jpeg2000_read_bitstream_packets(Jpeg2000DecoderContext *s)
1602 {
1603     int ret = 0;
1604     int tileno;
1605
1606     for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++) {
1607         Jpeg2000Tile *tile = s->tile + tileno;
1608
1609         if (ret = init_tile(s, tileno))
1610             return ret;
1611
1612         s->g = tile->tile_part[0].tpg;
1613         if (ret = jpeg2000_decode_packets(s, tile))
1614             return ret;
1615     }
1616
1617     return 0;
1618 }
1619
1620 static int jp2_find_codestream(Jpeg2000DecoderContext *s)
1621 {
1622     uint32_t atom_size, atom, atom_end;
1623     int search_range = 10;
1624
1625     while (search_range
1626            &&
1627            bytestream2_get_bytes_left(&s->g) >= 8) {
1628         atom_size = bytestream2_get_be32u(&s->g);
1629         atom      = bytestream2_get_be32u(&s->g);
1630         atom_end  = bytestream2_tell(&s->g) + atom_size - 8;
1631
1632         if (atom == JP2_CODESTREAM)
1633             return 1;
1634
1635         if (bytestream2_get_bytes_left(&s->g) < atom_size || atom_end < atom_size)
1636             return 0;
1637
1638         if (atom == JP2_HEADER &&
1639                    atom_size >= 16) {
1640             uint32_t atom2_size, atom2, atom2_end;
1641             do {
1642                 atom2_size = bytestream2_get_be32u(&s->g);
1643                 atom2      = bytestream2_get_be32u(&s->g);
1644                 atom2_end  = bytestream2_tell(&s->g) + atom2_size - 8;
1645                 if (atom2_size < 8 || atom2_end > atom_end || atom2_end < atom2_size)
1646                     break;
1647                 if (atom2 == JP2_CODESTREAM) {
1648                     return 1;
1649                 } else if (atom2 == MKBETAG('c','o','l','r') && atom2_size >= 7) {
1650                     int method = bytestream2_get_byteu(&s->g);
1651                     bytestream2_skipu(&s->g, 2);
1652                     if (method == 1) {
1653                         s->colour_space = bytestream2_get_be32u(&s->g);
1654                     }
1655                 } else if (atom2 == MKBETAG('p','c','l','r') && atom2_size >= 6) {
1656                     int i, size, colour_count, colour_channels, colour_depth[3];
1657                     uint32_t r, g, b;
1658                     colour_count = bytestream2_get_be16u(&s->g);
1659                     colour_channels = bytestream2_get_byteu(&s->g);
1660                     // FIXME: Do not ignore channel_sign
1661                     colour_depth[0] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1;
1662                     colour_depth[1] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1;
1663                     colour_depth[2] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1;
1664                     size = (colour_depth[0] + 7 >> 3) * colour_count +
1665                            (colour_depth[1] + 7 >> 3) * colour_count +
1666                            (colour_depth[2] + 7 >> 3) * colour_count;
1667                     if (colour_count > 256   ||
1668                         colour_channels != 3 ||
1669                         colour_depth[0] > 16 ||
1670                         colour_depth[1] > 16 ||
1671                         colour_depth[2] > 16 ||
1672                         atom2_size < size) {
1673                         avpriv_request_sample(s->avctx, "Unknown palette");
1674                         bytestream2_seek(&s->g, atom2_end, SEEK_SET);
1675                         continue;
1676                     }
1677                     s->pal8 = 1;
1678                     for (i = 0; i < colour_count; i++) {
1679                         if (colour_depth[0] <= 8) {
1680                             r = bytestream2_get_byteu(&s->g) << 8 - colour_depth[0];
1681                             r |= r >> colour_depth[0];
1682                         } else {
1683                             r = bytestream2_get_be16u(&s->g) >> colour_depth[0] - 8;
1684                         }
1685                         if (colour_depth[1] <= 8) {
1686                             g = bytestream2_get_byteu(&s->g) << 8 - colour_depth[1];
1687                             r |= r >> colour_depth[1];
1688                         } else {
1689                             g = bytestream2_get_be16u(&s->g) >> colour_depth[1] - 8;
1690                         }
1691                         if (colour_depth[2] <= 8) {
1692                             b = bytestream2_get_byteu(&s->g) << 8 - colour_depth[2];
1693                             r |= r >> colour_depth[2];
1694                         } else {
1695                             b = bytestream2_get_be16u(&s->g) >> colour_depth[2] - 8;
1696                         }
1697                         s->palette[i] = 0xffu << 24 | r << 16 | g << 8 | b;
1698                     }
1699                 } else if (atom2 == MKBETAG('c','d','e','f') && atom2_size >= 2) {
1700                     int n = bytestream2_get_be16u(&s->g);
1701                     for (; n>0; n--) {
1702                         int cn   = bytestream2_get_be16(&s->g);
1703                         int av_unused typ  = bytestream2_get_be16(&s->g);
1704                         int asoc = bytestream2_get_be16(&s->g);
1705                         if (cn < 4 && asoc < 4)
1706                             s->cdef[cn] = asoc;
1707                     }
1708                 }
1709                 bytestream2_seek(&s->g, atom2_end, SEEK_SET);
1710             } while (atom_end - atom2_end >= 8);
1711         } else {
1712             search_range--;
1713         }
1714         bytestream2_seek(&s->g, atom_end, SEEK_SET);
1715     }
1716
1717     return 0;
1718 }
1719
1720 static av_cold int jpeg2000_decode_init(AVCodecContext *avctx)
1721 {
1722     Jpeg2000DecoderContext *s = avctx->priv_data;
1723
1724     ff_jpeg2000dsp_init(&s->dsp);
1725
1726     return 0;
1727 }
1728
1729 static int jpeg2000_decode_frame(AVCodecContext *avctx, void *data,
1730                                  int *got_frame, AVPacket *avpkt)
1731 {
1732     Jpeg2000DecoderContext *s = avctx->priv_data;
1733     ThreadFrame frame = { .f = data };
1734     AVFrame *picture = data;
1735     int tileno, ret;
1736
1737     s->avctx     = avctx;
1738     bytestream2_init(&s->g, avpkt->data, avpkt->size);
1739     s->curtileno = -1;
1740     memset(s->cdef, -1, sizeof(s->cdef));
1741
1742     if (bytestream2_get_bytes_left(&s->g) < 2) {
1743         ret = AVERROR_INVALIDDATA;
1744         goto end;
1745     }
1746
1747     // check if the image is in jp2 format
1748     if (bytestream2_get_bytes_left(&s->g) >= 12 &&
1749        (bytestream2_get_be32u(&s->g) == 12) &&
1750        (bytestream2_get_be32u(&s->g) == JP2_SIG_TYPE) &&
1751        (bytestream2_get_be32u(&s->g) == JP2_SIG_VALUE)) {
1752         if (!jp2_find_codestream(s)) {
1753             av_log(avctx, AV_LOG_ERROR,
1754                    "Could not find Jpeg2000 codestream atom.\n");
1755             ret = AVERROR_INVALIDDATA;
1756             goto end;
1757         }
1758     } else {
1759         bytestream2_seek(&s->g, 0, SEEK_SET);
1760     }
1761
1762     while (bytestream2_get_bytes_left(&s->g) >= 3 && bytestream2_peek_be16(&s->g) != JPEG2000_SOC)
1763         bytestream2_skip(&s->g, 1);
1764
1765     if (bytestream2_get_be16u(&s->g) != JPEG2000_SOC) {
1766         av_log(avctx, AV_LOG_ERROR, "SOC marker not present\n");
1767         ret = AVERROR_INVALIDDATA;
1768         goto end;
1769     }
1770     if (ret = jpeg2000_read_main_headers(s))
1771         goto end;
1772
1773     /* get picture buffer */
1774     if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
1775         goto end;
1776     picture->pict_type = AV_PICTURE_TYPE_I;
1777     picture->key_frame = 1;
1778
1779     if (ret = jpeg2000_read_bitstream_packets(s))
1780         goto end;
1781
1782     for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++)
1783         if (ret = jpeg2000_decode_tile(s, s->tile + tileno, picture))
1784             goto end;
1785
1786     jpeg2000_dec_cleanup(s);
1787
1788     *got_frame = 1;
1789
1790     if (s->avctx->pix_fmt == AV_PIX_FMT_PAL8)
1791         memcpy(picture->data[1], s->palette, 256 * sizeof(uint32_t));
1792
1793     return bytestream2_tell(&s->g);
1794
1795 end:
1796     jpeg2000_dec_cleanup(s);
1797     return ret;
1798 }
1799
1800 static av_cold void jpeg2000_init_static_data(AVCodec *codec)
1801 {
1802     ff_jpeg2000_init_tier1_luts();
1803     ff_mqc_init_context_tables();
1804 }
1805
1806 #define OFFSET(x) offsetof(Jpeg2000DecoderContext, x)
1807 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
1808
1809 static const AVOption options[] = {
1810     { "lowres",  "Lower the decoding resolution by a power of two",
1811         OFFSET(reduction_factor), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, JPEG2000_MAX_RESLEVELS - 1, VD },
1812     { NULL },
1813 };
1814
1815 static const AVProfile profiles[] = {
1816     { FF_PROFILE_JPEG2000_CSTREAM_RESTRICTION_0,  "JPEG 2000 codestream restriction 0"   },
1817     { FF_PROFILE_JPEG2000_CSTREAM_RESTRICTION_1,  "JPEG 2000 codestream restriction 1"   },
1818     { FF_PROFILE_JPEG2000_CSTREAM_NO_RESTRICTION, "JPEG 2000 no codestream restrictions" },
1819     { FF_PROFILE_JPEG2000_DCINEMA_2K,             "JPEG 2000 digital cinema 2K"          },
1820     { FF_PROFILE_JPEG2000_DCINEMA_4K,             "JPEG 2000 digital cinema 4K"          },
1821     { FF_PROFILE_UNKNOWN },
1822 };
1823
1824 static const AVClass jpeg2000_class = {
1825     .class_name = "jpeg2000",
1826     .item_name  = av_default_item_name,
1827     .option     = options,
1828     .version    = LIBAVUTIL_VERSION_INT,
1829 };
1830
1831 AVCodec ff_jpeg2000_decoder = {
1832     .name             = "jpeg2000",
1833     .long_name        = NULL_IF_CONFIG_SMALL("JPEG 2000"),
1834     .type             = AVMEDIA_TYPE_VIDEO,
1835     .id               = AV_CODEC_ID_JPEG2000,
1836     .capabilities     = CODEC_CAP_FRAME_THREADS,
1837     .priv_data_size   = sizeof(Jpeg2000DecoderContext),
1838     .init_static_data = jpeg2000_init_static_data,
1839     .init             = jpeg2000_decode_init,
1840     .decode           = jpeg2000_decode_frame,
1841     .priv_class       = &jpeg2000_class,
1842     .max_lowres       = 5,
1843     .profiles         = NULL_IF_CONFIG_SMALL(profiles)
1844 };