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