avcodec/jpeg2000dec: Fix off by 1 error in JPEG2000_PGOD_CPRL handling
[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 #include <math.h>
30
31 #include "libavutil/attributes.h"
32 #include "libavutil/avassert.h"
33 #include "libavutil/common.h"
34 #include "libavutil/imgutils.h"
35 #include "libavutil/opt.h"
36 #include "libavutil/pixdesc.h"
37 #include "libavutil/thread.h"
38 #include "avcodec.h"
39 #include "bytestream.h"
40 #include "internal.h"
41 #include "thread.h"
42 #include "jpeg2000.h"
43 #include "jpeg2000dsp.h"
44 #include "profiles.h"
45
46 #define JP2_SIG_TYPE    0x6A502020
47 #define JP2_SIG_VALUE   0x0D0A870A
48 #define JP2_CODESTREAM  0x6A703263
49 #define JP2_HEADER      0x6A703268
50
51 #define HAD_COC 0x01
52 #define HAD_QCC 0x02
53
54 #define MAX_POCS 32
55
56 typedef struct Jpeg2000POCEntry {
57     uint16_t LYEpoc;
58     uint16_t CSpoc;
59     uint16_t CEpoc;
60     uint8_t RSpoc;
61     uint8_t REpoc;
62     uint8_t Ppoc;
63 } Jpeg2000POCEntry;
64
65 typedef struct Jpeg2000POC {
66     Jpeg2000POCEntry poc[MAX_POCS];
67     int nb_poc;
68     int is_default;
69 } Jpeg2000POC;
70
71 typedef struct Jpeg2000TilePart {
72     uint8_t tile_index;                 // Tile index who refers the tile-part
73     const uint8_t *tp_end;
74     GetByteContext tpg;                 // bit stream in tile-part
75 } Jpeg2000TilePart;
76
77 /* RMK: For JPEG2000 DCINEMA 3 tile-parts in a tile
78  * one per component, so tile_part elements have a size of 3 */
79 typedef struct Jpeg2000Tile {
80     Jpeg2000Component   *comp;
81     uint8_t             properties[4];
82     Jpeg2000CodingStyle codsty[4];
83     Jpeg2000QuantStyle  qntsty[4];
84     Jpeg2000POC         poc;
85     Jpeg2000TilePart    tile_part[32];
86     uint16_t tp_idx;                    // Tile-part index
87     int coord[2][2];                    // border coordinates {{x0, x1}, {y0, y1}}
88 } Jpeg2000Tile;
89
90 typedef struct Jpeg2000DecoderContext {
91     AVClass         *class;
92     AVCodecContext  *avctx;
93     GetByteContext  g;
94
95     int             width, height;
96     int             image_offset_x, image_offset_y;
97     int             tile_offset_x, tile_offset_y;
98     uint8_t         cbps[4];    // bits per sample in particular components
99     uint8_t         sgnd[4];    // if a component is signed
100     uint8_t         properties[4];
101     int             cdx[4], cdy[4];
102     int             precision;
103     int             ncomponents;
104     int             colour_space;
105     uint32_t        palette[256];
106     int8_t          pal8;
107     int             cdef[4];
108     int             tile_width, tile_height;
109     unsigned        numXtiles, numYtiles;
110     int             maxtilelen;
111     AVRational      sar;
112
113     Jpeg2000CodingStyle codsty[4];
114     Jpeg2000QuantStyle  qntsty[4];
115     Jpeg2000POC         poc;
116
117     int             bit_index;
118
119     int             curtileno;
120
121     Jpeg2000Tile    *tile;
122     Jpeg2000DSPContext dsp;
123
124     /*options parameters*/
125     int             reduction_factor;
126 } Jpeg2000DecoderContext;
127
128 /* get_bits functions for JPEG2000 packet bitstream
129  * It is a get_bit function with a bit-stuffing routine. If the value of the
130  * byte is 0xFF, the next byte includes an extra zero bit stuffed into the MSB.
131  * cf. ISO-15444-1:2002 / B.10.1 Bit-stuffing routine */
132 static int get_bits(Jpeg2000DecoderContext *s, int n)
133 {
134     int res = 0;
135
136     while (--n >= 0) {
137         res <<= 1;
138         if (s->bit_index == 0) {
139             s->bit_index = 7 + (bytestream2_get_byte(&s->g) != 0xFFu);
140         }
141         s->bit_index--;
142         res |= (bytestream2_peek_byte(&s->g) >> s->bit_index) & 1;
143     }
144     return res;
145 }
146
147 static void jpeg2000_flush(Jpeg2000DecoderContext *s)
148 {
149     if (bytestream2_get_byte(&s->g) == 0xff)
150         bytestream2_skip(&s->g, 1);
151     s->bit_index = 8;
152 }
153
154 /* decode the value stored in node */
155 static int tag_tree_decode(Jpeg2000DecoderContext *s, Jpeg2000TgtNode *node,
156                            int threshold)
157 {
158     Jpeg2000TgtNode *stack[30];
159     int sp = -1, curval = 0;
160
161     if (!node) {
162         av_log(s->avctx, AV_LOG_ERROR, "missing node\n");
163         return AVERROR_INVALIDDATA;
164     }
165
166     while (node && !node->vis) {
167         stack[++sp] = node;
168         node        = node->parent;
169     }
170
171     if (node)
172         curval = node->val;
173     else
174         curval = stack[sp]->val;
175
176     while (curval < threshold && sp >= 0) {
177         if (curval < stack[sp]->val)
178             curval = stack[sp]->val;
179         while (curval < threshold) {
180             int ret;
181             if ((ret = get_bits(s, 1)) > 0) {
182                 stack[sp]->vis++;
183                 break;
184             } else if (!ret)
185                 curval++;
186             else
187                 return ret;
188         }
189         stack[sp]->val = curval;
190         sp--;
191     }
192     return curval;
193 }
194
195 static int pix_fmt_match(enum AVPixelFormat pix_fmt, int components,
196                          int bpc, uint32_t log2_chroma_wh, int pal8)
197 {
198     int match = 1;
199     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
200
201     av_assert2(desc);
202
203     if (desc->nb_components != components) {
204         return 0;
205     }
206
207     switch (components) {
208     case 4:
209         match = match && desc->comp[3].depth >= bpc &&
210                          (log2_chroma_wh >> 14 & 3) == 0 &&
211                          (log2_chroma_wh >> 12 & 3) == 0;
212     case 3:
213         match = match && desc->comp[2].depth >= bpc &&
214                          (log2_chroma_wh >> 10 & 3) == desc->log2_chroma_w &&
215                          (log2_chroma_wh >>  8 & 3) == desc->log2_chroma_h;
216     case 2:
217         match = match && desc->comp[1].depth >= bpc &&
218                          (log2_chroma_wh >>  6 & 3) == desc->log2_chroma_w &&
219                          (log2_chroma_wh >>  4 & 3) == desc->log2_chroma_h;
220
221     case 1:
222         match = match && desc->comp[0].depth >= bpc &&
223                          (log2_chroma_wh >>  2 & 3) == 0 &&
224                          (log2_chroma_wh       & 3) == 0 &&
225                          (desc->flags & AV_PIX_FMT_FLAG_PAL) == pal8 * AV_PIX_FMT_FLAG_PAL;
226     }
227     return match;
228 }
229
230 // pix_fmts with lower bpp have to be listed before
231 // similar pix_fmts with higher bpp.
232 #define RGB_PIXEL_FORMATS   AV_PIX_FMT_PAL8,AV_PIX_FMT_RGB24,AV_PIX_FMT_RGBA,AV_PIX_FMT_RGB48,AV_PIX_FMT_RGBA64
233 #define GRAY_PIXEL_FORMATS  AV_PIX_FMT_GRAY8,AV_PIX_FMT_GRAY8A,AV_PIX_FMT_GRAY16,AV_PIX_FMT_YA16
234 #define YUV_PIXEL_FORMATS   AV_PIX_FMT_YUV410P,AV_PIX_FMT_YUV411P,AV_PIX_FMT_YUVA420P, \
235                             AV_PIX_FMT_YUV420P,AV_PIX_FMT_YUV422P,AV_PIX_FMT_YUVA422P, \
236                             AV_PIX_FMT_YUV440P,AV_PIX_FMT_YUV444P,AV_PIX_FMT_YUVA444P, \
237                             AV_PIX_FMT_YUV420P9,AV_PIX_FMT_YUV422P9,AV_PIX_FMT_YUV444P9, \
238                             AV_PIX_FMT_YUVA420P9,AV_PIX_FMT_YUVA422P9,AV_PIX_FMT_YUVA444P9, \
239                             AV_PIX_FMT_YUV420P10,AV_PIX_FMT_YUV422P10,AV_PIX_FMT_YUV444P10, \
240                             AV_PIX_FMT_YUVA420P10,AV_PIX_FMT_YUVA422P10,AV_PIX_FMT_YUVA444P10, \
241                             AV_PIX_FMT_YUV420P12,AV_PIX_FMT_YUV422P12,AV_PIX_FMT_YUV444P12, \
242                             AV_PIX_FMT_YUV420P14,AV_PIX_FMT_YUV422P14,AV_PIX_FMT_YUV444P14, \
243                             AV_PIX_FMT_YUV420P16,AV_PIX_FMT_YUV422P16,AV_PIX_FMT_YUV444P16, \
244                             AV_PIX_FMT_YUVA420P16,AV_PIX_FMT_YUVA422P16,AV_PIX_FMT_YUVA444P16
245 #define XYZ_PIXEL_FORMATS   AV_PIX_FMT_XYZ12
246
247 static const enum AVPixelFormat rgb_pix_fmts[]  = {RGB_PIXEL_FORMATS};
248 static const enum AVPixelFormat gray_pix_fmts[] = {GRAY_PIXEL_FORMATS};
249 static const enum AVPixelFormat yuv_pix_fmts[]  = {YUV_PIXEL_FORMATS};
250 static const enum AVPixelFormat xyz_pix_fmts[]  = {XYZ_PIXEL_FORMATS,
251                                                    YUV_PIXEL_FORMATS};
252 static const enum AVPixelFormat all_pix_fmts[]  = {RGB_PIXEL_FORMATS,
253                                                    GRAY_PIXEL_FORMATS,
254                                                    YUV_PIXEL_FORMATS,
255                                                    XYZ_PIXEL_FORMATS};
256
257 /* marker segments */
258 /* get sizes and offsets of image, tiles; number of components */
259 static int get_siz(Jpeg2000DecoderContext *s)
260 {
261     int i;
262     int ncomponents;
263     uint32_t log2_chroma_wh = 0;
264     const enum AVPixelFormat *possible_fmts = NULL;
265     int possible_fmts_nb = 0;
266     int ret;
267
268     if (bytestream2_get_bytes_left(&s->g) < 36) {
269         av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for SIZ\n");
270         return AVERROR_INVALIDDATA;
271     }
272
273     s->avctx->profile = bytestream2_get_be16u(&s->g); // Rsiz
274     s->width          = bytestream2_get_be32u(&s->g); // Width
275     s->height         = bytestream2_get_be32u(&s->g); // Height
276     s->image_offset_x = bytestream2_get_be32u(&s->g); // X0Siz
277     s->image_offset_y = bytestream2_get_be32u(&s->g); // Y0Siz
278     s->tile_width     = bytestream2_get_be32u(&s->g); // XTSiz
279     s->tile_height    = bytestream2_get_be32u(&s->g); // YTSiz
280     s->tile_offset_x  = bytestream2_get_be32u(&s->g); // XT0Siz
281     s->tile_offset_y  = bytestream2_get_be32u(&s->g); // YT0Siz
282     ncomponents       = bytestream2_get_be16u(&s->g); // CSiz
283
284     if (s->image_offset_x || s->image_offset_y) {
285         avpriv_request_sample(s->avctx, "Support for image offsets");
286         return AVERROR_PATCHWELCOME;
287     }
288     if (av_image_check_size2(s->width, s->height, s->avctx->max_pixels, AV_PIX_FMT_NONE, 0, s->avctx)) {
289         avpriv_request_sample(s->avctx, "Large Dimensions");
290         return AVERROR_PATCHWELCOME;
291     }
292
293     if (ncomponents <= 0) {
294         av_log(s->avctx, AV_LOG_ERROR, "Invalid number of components: %d\n",
295                s->ncomponents);
296         return AVERROR_INVALIDDATA;
297     }
298
299     if (ncomponents > 4) {
300         avpriv_request_sample(s->avctx, "Support for %d components",
301                               ncomponents);
302         return AVERROR_PATCHWELCOME;
303     }
304
305     if (s->tile_offset_x < 0 || s->tile_offset_y < 0 ||
306         s->image_offset_x < s->tile_offset_x ||
307         s->image_offset_y < s->tile_offset_y ||
308         s->tile_width  + (int64_t)s->tile_offset_x <= s->image_offset_x ||
309         s->tile_height + (int64_t)s->tile_offset_y <= s->image_offset_y
310     ) {
311         av_log(s->avctx, AV_LOG_ERROR, "Tile offsets are invalid\n");
312         return AVERROR_INVALIDDATA;
313     }
314
315     s->ncomponents = ncomponents;
316
317     if (s->tile_width <= 0 || s->tile_height <= 0) {
318         av_log(s->avctx, AV_LOG_ERROR, "Invalid tile dimension %dx%d.\n",
319                s->tile_width, s->tile_height);
320         return AVERROR_INVALIDDATA;
321     }
322
323     if (bytestream2_get_bytes_left(&s->g) < 3 * s->ncomponents) {
324         av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for %d components in SIZ\n", s->ncomponents);
325         return AVERROR_INVALIDDATA;
326     }
327
328     for (i = 0; i < s->ncomponents; i++) { // Ssiz_i XRsiz_i, YRsiz_i
329         uint8_t x    = bytestream2_get_byteu(&s->g);
330         s->cbps[i]   = (x & 0x7f) + 1;
331         s->precision = FFMAX(s->cbps[i], s->precision);
332         s->sgnd[i]   = !!(x & 0x80);
333         s->cdx[i]    = bytestream2_get_byteu(&s->g);
334         s->cdy[i]    = bytestream2_get_byteu(&s->g);
335         if (   !s->cdx[i] || s->cdx[i] == 3 || s->cdx[i] > 4
336             || !s->cdy[i] || s->cdy[i] == 3 || s->cdy[i] > 4) {
337             av_log(s->avctx, AV_LOG_ERROR, "Invalid sample separation %d/%d\n", s->cdx[i], s->cdy[i]);
338             return AVERROR_INVALIDDATA;
339         }
340         log2_chroma_wh |= s->cdy[i] >> 1 << i * 4 | s->cdx[i] >> 1 << i * 4 + 2;
341     }
342
343     s->numXtiles = ff_jpeg2000_ceildiv(s->width  - s->tile_offset_x, s->tile_width);
344     s->numYtiles = ff_jpeg2000_ceildiv(s->height - s->tile_offset_y, s->tile_height);
345
346     // There must be at least a SOT and SOD per tile, their minimum size is 14
347     if (s->numXtiles * (uint64_t)s->numYtiles > INT_MAX/sizeof(*s->tile) ||
348         s->numXtiles * s->numYtiles * 14LL > bytestream2_size(&s->g)
349     ) {
350         s->numXtiles = s->numYtiles = 0;
351         return AVERROR(EINVAL);
352     }
353
354     s->tile = av_mallocz_array(s->numXtiles * s->numYtiles, sizeof(*s->tile));
355     if (!s->tile) {
356         s->numXtiles = s->numYtiles = 0;
357         return AVERROR(ENOMEM);
358     }
359
360     for (i = 0; i < s->numXtiles * s->numYtiles; i++) {
361         Jpeg2000Tile *tile = s->tile + i;
362
363         tile->comp = av_mallocz(s->ncomponents * sizeof(*tile->comp));
364         if (!tile->comp)
365             return AVERROR(ENOMEM);
366     }
367
368     /* compute image size with reduction factor */
369     ret = ff_set_dimensions(s->avctx,
370             ff_jpeg2000_ceildivpow2(s->width  - s->image_offset_x,
371                                                s->reduction_factor),
372             ff_jpeg2000_ceildivpow2(s->height - s->image_offset_y,
373                                                s->reduction_factor));
374     if (ret < 0)
375         return ret;
376
377     if (s->avctx->profile == FF_PROFILE_JPEG2000_DCINEMA_2K ||
378         s->avctx->profile == FF_PROFILE_JPEG2000_DCINEMA_4K) {
379         possible_fmts = xyz_pix_fmts;
380         possible_fmts_nb = FF_ARRAY_ELEMS(xyz_pix_fmts);
381     } else {
382         switch (s->colour_space) {
383         case 16:
384             possible_fmts = rgb_pix_fmts;
385             possible_fmts_nb = FF_ARRAY_ELEMS(rgb_pix_fmts);
386             break;
387         case 17:
388             possible_fmts = gray_pix_fmts;
389             possible_fmts_nb = FF_ARRAY_ELEMS(gray_pix_fmts);
390             break;
391         case 18:
392             possible_fmts = yuv_pix_fmts;
393             possible_fmts_nb = FF_ARRAY_ELEMS(yuv_pix_fmts);
394             break;
395         default:
396             possible_fmts = all_pix_fmts;
397             possible_fmts_nb = FF_ARRAY_ELEMS(all_pix_fmts);
398             break;
399         }
400     }
401     for (i = 0; i < possible_fmts_nb; ++i) {
402         if (pix_fmt_match(possible_fmts[i], ncomponents, s->precision, log2_chroma_wh, s->pal8)) {
403             s->avctx->pix_fmt = possible_fmts[i];
404             break;
405         }
406     }
407
408     if (i == possible_fmts_nb) {
409         if (ncomponents == 4 &&
410             s->cdy[0] == 1 && s->cdx[0] == 1 &&
411             s->cdy[1] == 1 && s->cdx[1] == 1 &&
412             s->cdy[2] == s->cdy[3] && s->cdx[2] == s->cdx[3]) {
413             if (s->precision == 8 && s->cdy[2] == 2 && s->cdx[2] == 2 && !s->pal8) {
414                 s->avctx->pix_fmt = AV_PIX_FMT_YUVA420P;
415                 s->cdef[0] = 0;
416                 s->cdef[1] = 1;
417                 s->cdef[2] = 2;
418                 s->cdef[3] = 3;
419                 i = 0;
420             }
421         }
422     }
423
424
425     if (i == possible_fmts_nb) {
426         av_log(s->avctx, AV_LOG_ERROR,
427                "Unknown pix_fmt, profile: %d, colour_space: %d, "
428                "components: %d, precision: %d\n"
429                "cdx[0]: %d, cdy[0]: %d\n"
430                "cdx[1]: %d, cdy[1]: %d\n"
431                "cdx[2]: %d, cdy[2]: %d\n"
432                "cdx[3]: %d, cdy[3]: %d\n",
433                s->avctx->profile, s->colour_space, ncomponents, s->precision,
434                s->cdx[0],
435                s->cdy[0],
436                ncomponents > 1 ? s->cdx[1] : 0,
437                ncomponents > 1 ? s->cdy[1] : 0,
438                ncomponents > 2 ? s->cdx[2] : 0,
439                ncomponents > 2 ? s->cdy[2] : 0,
440                ncomponents > 3 ? s->cdx[3] : 0,
441                ncomponents > 3 ? s->cdy[3] : 0);
442         return AVERROR_PATCHWELCOME;
443     }
444     s->avctx->bits_per_raw_sample = s->precision;
445     return 0;
446 }
447
448 /* get common part for COD and COC segments */
449 static int get_cox(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c)
450 {
451     uint8_t byte;
452
453     if (bytestream2_get_bytes_left(&s->g) < 5) {
454         av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for COX\n");
455         return AVERROR_INVALIDDATA;
456     }
457
458     /*  nreslevels = number of resolution levels
459                    = number of decomposition level +1 */
460     c->nreslevels = bytestream2_get_byteu(&s->g) + 1;
461     if (c->nreslevels >= JPEG2000_MAX_RESLEVELS) {
462         av_log(s->avctx, AV_LOG_ERROR, "nreslevels %d is invalid\n", c->nreslevels);
463         return AVERROR_INVALIDDATA;
464     }
465
466     if (c->nreslevels <= s->reduction_factor) {
467         /* we are forced to update reduction_factor as its requested value is
468            not compatible with this bitstream, and as we might have used it
469            already in setup earlier we have to fail this frame until
470            reinitialization is implemented */
471         av_log(s->avctx, AV_LOG_ERROR, "reduction_factor too large for this bitstream, max is %d\n", c->nreslevels - 1);
472         s->reduction_factor = c->nreslevels - 1;
473         return AVERROR(EINVAL);
474     }
475
476     /* compute number of resolution levels to decode */
477     c->nreslevels2decode = c->nreslevels - s->reduction_factor;
478
479     c->log2_cblk_width  = (bytestream2_get_byteu(&s->g) & 15) + 2; // cblk width
480     c->log2_cblk_height = (bytestream2_get_byteu(&s->g) & 15) + 2; // cblk height
481
482     if (c->log2_cblk_width > 10 || c->log2_cblk_height > 10 ||
483         c->log2_cblk_width + c->log2_cblk_height > 12) {
484         av_log(s->avctx, AV_LOG_ERROR, "cblk size invalid\n");
485         return AVERROR_INVALIDDATA;
486     }
487
488     c->cblk_style = bytestream2_get_byteu(&s->g);
489     if (c->cblk_style != 0) { // cblk style
490         av_log(s->avctx, AV_LOG_WARNING, "extra cblk styles %X\n", c->cblk_style);
491         if (c->cblk_style & JPEG2000_CBLK_BYPASS)
492             av_log(s->avctx, AV_LOG_WARNING, "Selective arithmetic coding bypass\n");
493     }
494     c->transform = bytestream2_get_byteu(&s->g); // DWT transformation type
495     /* set integer 9/7 DWT in case of BITEXACT flag */
496     if ((s->avctx->flags & AV_CODEC_FLAG_BITEXACT) && (c->transform == FF_DWT97))
497         c->transform = FF_DWT97_INT;
498     else if (c->transform == FF_DWT53) {
499         s->avctx->properties |= FF_CODEC_PROPERTY_LOSSLESS;
500     }
501
502     if (c->csty & JPEG2000_CSTY_PREC) {
503         int i;
504         for (i = 0; i < c->nreslevels; i++) {
505             byte = bytestream2_get_byte(&s->g);
506             c->log2_prec_widths[i]  =  byte       & 0x0F;    // precinct PPx
507             c->log2_prec_heights[i] = (byte >> 4) & 0x0F;    // precinct PPy
508             if (i)
509                 if (c->log2_prec_widths[i] == 0 || c->log2_prec_heights[i] == 0) {
510                     av_log(s->avctx, AV_LOG_ERROR, "PPx %d PPy %d invalid\n",
511                            c->log2_prec_widths[i], c->log2_prec_heights[i]);
512                     c->log2_prec_widths[i] = c->log2_prec_heights[i] = 1;
513                     return AVERROR_INVALIDDATA;
514                 }
515         }
516     } else {
517         memset(c->log2_prec_widths , 15, sizeof(c->log2_prec_widths ));
518         memset(c->log2_prec_heights, 15, sizeof(c->log2_prec_heights));
519     }
520     return 0;
521 }
522
523 /* get coding parameters for a particular tile or whole image*/
524 static int get_cod(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c,
525                    uint8_t *properties)
526 {
527     Jpeg2000CodingStyle tmp;
528     int compno, ret;
529
530     if (bytestream2_get_bytes_left(&s->g) < 5) {
531         av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for COD\n");
532         return AVERROR_INVALIDDATA;
533     }
534
535     tmp.csty = bytestream2_get_byteu(&s->g);
536
537     // get progression order
538     tmp.prog_order = bytestream2_get_byteu(&s->g);
539
540     tmp.nlayers    = bytestream2_get_be16u(&s->g);
541     tmp.mct        = bytestream2_get_byteu(&s->g); // multiple component transformation
542
543     if (tmp.mct && s->ncomponents < 3) {
544         av_log(s->avctx, AV_LOG_ERROR,
545                "MCT %"PRIu8" with too few components (%d)\n",
546                tmp.mct, s->ncomponents);
547         return AVERROR_INVALIDDATA;
548     }
549
550     if ((ret = get_cox(s, &tmp)) < 0)
551         return ret;
552
553     for (compno = 0; compno < s->ncomponents; compno++)
554         if (!(properties[compno] & HAD_COC))
555             memcpy(c + compno, &tmp, sizeof(tmp));
556     return 0;
557 }
558
559 /* Get coding parameters for a component in the whole image or a
560  * particular tile. */
561 static int get_coc(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c,
562                    uint8_t *properties)
563 {
564     int compno, ret;
565
566     if (bytestream2_get_bytes_left(&s->g) < 2) {
567         av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for COC\n");
568         return AVERROR_INVALIDDATA;
569     }
570
571     compno = bytestream2_get_byteu(&s->g);
572
573     if (compno >= s->ncomponents) {
574         av_log(s->avctx, AV_LOG_ERROR,
575                "Invalid compno %d. There are %d components in the image.\n",
576                compno, s->ncomponents);
577         return AVERROR_INVALIDDATA;
578     }
579
580     c      += compno;
581     c->csty = bytestream2_get_byteu(&s->g);
582
583     if ((ret = get_cox(s, c)) < 0)
584         return ret;
585
586     properties[compno] |= HAD_COC;
587     return 0;
588 }
589
590 /* Get common part for QCD and QCC segments. */
591 static int get_qcx(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q)
592 {
593     int i, x;
594
595     if (bytestream2_get_bytes_left(&s->g) < 1)
596         return AVERROR_INVALIDDATA;
597
598     x = bytestream2_get_byteu(&s->g); // Sqcd
599
600     q->nguardbits = x >> 5;
601     q->quantsty   = x & 0x1f;
602
603     if (q->quantsty == JPEG2000_QSTY_NONE) {
604         n -= 3;
605         if (bytestream2_get_bytes_left(&s->g) < n ||
606             n > JPEG2000_MAX_DECLEVELS*3)
607             return AVERROR_INVALIDDATA;
608         for (i = 0; i < n; i++)
609             q->expn[i] = bytestream2_get_byteu(&s->g) >> 3;
610     } else if (q->quantsty == JPEG2000_QSTY_SI) {
611         if (bytestream2_get_bytes_left(&s->g) < 2)
612             return AVERROR_INVALIDDATA;
613         x          = bytestream2_get_be16u(&s->g);
614         q->expn[0] = x >> 11;
615         q->mant[0] = x & 0x7ff;
616         for (i = 1; i < JPEG2000_MAX_DECLEVELS * 3; i++) {
617             int curexpn = FFMAX(0, q->expn[0] - (i - 1) / 3);
618             q->expn[i] = curexpn;
619             q->mant[i] = q->mant[0];
620         }
621     } else {
622         n = (n - 3) >> 1;
623         if (bytestream2_get_bytes_left(&s->g) < 2 * n ||
624             n > JPEG2000_MAX_DECLEVELS*3)
625             return AVERROR_INVALIDDATA;
626         for (i = 0; i < n; i++) {
627             x          = bytestream2_get_be16u(&s->g);
628             q->expn[i] = x >> 11;
629             q->mant[i] = x & 0x7ff;
630         }
631     }
632     return 0;
633 }
634
635 /* Get quantization parameters for a particular tile or a whole image. */
636 static int get_qcd(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q,
637                    uint8_t *properties)
638 {
639     Jpeg2000QuantStyle tmp;
640     int compno, ret;
641
642     memset(&tmp, 0, sizeof(tmp));
643
644     if ((ret = get_qcx(s, n, &tmp)) < 0)
645         return ret;
646     for (compno = 0; compno < s->ncomponents; compno++)
647         if (!(properties[compno] & HAD_QCC))
648             memcpy(q + compno, &tmp, sizeof(tmp));
649     return 0;
650 }
651
652 /* Get quantization parameters for a component in the whole image
653  * on in a particular tile. */
654 static int get_qcc(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q,
655                    uint8_t *properties)
656 {
657     int compno;
658
659     if (bytestream2_get_bytes_left(&s->g) < 1)
660         return AVERROR_INVALIDDATA;
661
662     compno = bytestream2_get_byteu(&s->g);
663
664     if (compno >= s->ncomponents) {
665         av_log(s->avctx, AV_LOG_ERROR,
666                "Invalid compno %d. There are %d components in the image.\n",
667                compno, s->ncomponents);
668         return AVERROR_INVALIDDATA;
669     }
670
671     properties[compno] |= HAD_QCC;
672     return get_qcx(s, n - 1, q + compno);
673 }
674
675 static int get_poc(Jpeg2000DecoderContext *s, int size, Jpeg2000POC *p)
676 {
677     int i;
678     int elem_size = s->ncomponents <= 257 ? 7 : 9;
679     Jpeg2000POC tmp = {{{0}}};
680
681     if (bytestream2_get_bytes_left(&s->g) < 5 || size < 2 + elem_size) {
682         av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for POC\n");
683         return AVERROR_INVALIDDATA;
684     }
685
686     if (elem_size > 7) {
687         avpriv_request_sample(s->avctx, "Fat POC not supported");
688         return AVERROR_PATCHWELCOME;
689     }
690
691     tmp.nb_poc = (size - 2) / elem_size;
692     if (tmp.nb_poc > MAX_POCS) {
693         avpriv_request_sample(s->avctx, "Too many POCs (%d)", tmp.nb_poc);
694         return AVERROR_PATCHWELCOME;
695     }
696
697     for (i = 0; i<tmp.nb_poc; i++) {
698         Jpeg2000POCEntry *e = &tmp.poc[i];
699         e->RSpoc  = bytestream2_get_byteu(&s->g);
700         e->CSpoc  = bytestream2_get_byteu(&s->g);
701         e->LYEpoc = bytestream2_get_be16u(&s->g);
702         e->REpoc  = bytestream2_get_byteu(&s->g);
703         e->CEpoc  = bytestream2_get_byteu(&s->g);
704         e->Ppoc   = bytestream2_get_byteu(&s->g);
705         if (!e->CEpoc)
706             e->CEpoc = 256;
707         if (e->CEpoc > s->ncomponents)
708             e->CEpoc = s->ncomponents;
709         if (   e->RSpoc >= e->REpoc || e->REpoc > 33
710             || e->CSpoc >= e->CEpoc || e->CEpoc > s->ncomponents
711             || !e->LYEpoc) {
712             av_log(s->avctx, AV_LOG_ERROR, "POC Entry %d is invalid (%d, %d, %d, %d, %d, %d)\n", i,
713                 e->RSpoc, e->CSpoc, e->LYEpoc, e->REpoc, e->CEpoc, e->Ppoc
714             );
715             return AVERROR_INVALIDDATA;
716         }
717     }
718
719     if (!p->nb_poc || p->is_default) {
720         *p = tmp;
721     } else {
722         if (p->nb_poc + tmp.nb_poc > MAX_POCS) {
723             av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for POC\n");
724             return AVERROR_INVALIDDATA;
725         }
726         memcpy(p->poc + p->nb_poc, tmp.poc, tmp.nb_poc * sizeof(tmp.poc[0]));
727         p->nb_poc += tmp.nb_poc;
728     }
729
730     p->is_default = 0;
731
732     return 0;
733 }
734
735
736 /* Get start of tile segment. */
737 static int get_sot(Jpeg2000DecoderContext *s, int n)
738 {
739     Jpeg2000TilePart *tp;
740     uint16_t Isot;
741     uint32_t Psot;
742     unsigned TPsot;
743
744     if (bytestream2_get_bytes_left(&s->g) < 8)
745         return AVERROR_INVALIDDATA;
746
747     s->curtileno = 0;
748     Isot = bytestream2_get_be16u(&s->g);        // Isot
749     if (Isot >= s->numXtiles * s->numYtiles)
750         return AVERROR_INVALIDDATA;
751
752     s->curtileno = Isot;
753     Psot  = bytestream2_get_be32u(&s->g);       // Psot
754     TPsot = bytestream2_get_byteu(&s->g);       // TPsot
755
756     /* Read TNSot but not used */
757     bytestream2_get_byteu(&s->g);               // TNsot
758
759     if (!Psot)
760         Psot = bytestream2_get_bytes_left(&s->g) - 2 + n + 2;
761
762     if (Psot > bytestream2_get_bytes_left(&s->g) - 2 + n + 2) {
763         av_log(s->avctx, AV_LOG_ERROR, "Psot %"PRIu32" too big\n", Psot);
764         return AVERROR_INVALIDDATA;
765     }
766
767     if (TPsot >= FF_ARRAY_ELEMS(s->tile[Isot].tile_part)) {
768         avpriv_request_sample(s->avctx, "Too many tile parts");
769         return AVERROR_PATCHWELCOME;
770     }
771
772     s->tile[Isot].tp_idx = TPsot;
773     tp             = s->tile[Isot].tile_part + TPsot;
774     tp->tile_index = Isot;
775     tp->tp_end     = s->g.buffer + Psot - n - 2;
776
777     if (!TPsot) {
778         Jpeg2000Tile *tile = s->tile + s->curtileno;
779
780         /* copy defaults */
781         memcpy(tile->codsty, s->codsty, s->ncomponents * sizeof(Jpeg2000CodingStyle));
782         memcpy(tile->qntsty, s->qntsty, s->ncomponents * sizeof(Jpeg2000QuantStyle));
783         memcpy(&tile->poc  , &s->poc  , sizeof(tile->poc));
784         tile->poc.is_default = 1;
785     }
786
787     return 0;
788 }
789
790 /* Tile-part lengths: see ISO 15444-1:2002, section A.7.1
791  * Used to know the number of tile parts and lengths.
792  * There may be multiple TLMs in the header.
793  * TODO: The function is not used for tile-parts management, nor anywhere else.
794  * It can be useful to allocate memory for tile parts, before managing the SOT
795  * markers. Parsing the TLM header is needed to increment the input header
796  * buffer.
797  * This marker is mandatory for DCI. */
798 static uint8_t get_tlm(Jpeg2000DecoderContext *s, int n)
799 {
800     uint8_t Stlm, ST, SP, tile_tlm, i;
801     bytestream2_get_byte(&s->g);               /* Ztlm: skipped */
802     Stlm = bytestream2_get_byte(&s->g);
803
804     // too complex ? ST = ((Stlm >> 4) & 0x01) + ((Stlm >> 4) & 0x02);
805     ST = (Stlm >> 4) & 0x03;
806     // TODO: Manage case of ST = 0b11 --> raise error
807     SP       = (Stlm >> 6) & 0x01;
808     tile_tlm = (n - 4) / ((SP + 1) * 2 + ST);
809     for (i = 0; i < tile_tlm; i++) {
810         switch (ST) {
811         case 0:
812             break;
813         case 1:
814             bytestream2_get_byte(&s->g);
815             break;
816         case 2:
817             bytestream2_get_be16(&s->g);
818             break;
819         case 3:
820             bytestream2_get_be32(&s->g);
821             break;
822         }
823         if (SP == 0) {
824             bytestream2_get_be16(&s->g);
825         } else {
826             bytestream2_get_be32(&s->g);
827         }
828     }
829     return 0;
830 }
831
832 static uint8_t get_plt(Jpeg2000DecoderContext *s, int n)
833 {
834     int i;
835
836     av_log(s->avctx, AV_LOG_DEBUG,
837             "PLT marker at pos 0x%X\n", bytestream2_tell(&s->g) - 4);
838
839     /*Zplt =*/ bytestream2_get_byte(&s->g);
840
841     for (i = 0; i < n - 3; i++) {
842         bytestream2_get_byte(&s->g);
843     }
844
845     return 0;
846 }
847
848 static int init_tile(Jpeg2000DecoderContext *s, int tileno)
849 {
850     int compno;
851     int tilex = tileno % s->numXtiles;
852     int tiley = tileno / s->numXtiles;
853     Jpeg2000Tile *tile = s->tile + tileno;
854
855     if (!tile->comp)
856         return AVERROR(ENOMEM);
857
858     tile->coord[0][0] = av_clip(tilex       * (int64_t)s->tile_width  + s->tile_offset_x, s->image_offset_x, s->width);
859     tile->coord[0][1] = av_clip((tilex + 1) * (int64_t)s->tile_width  + s->tile_offset_x, s->image_offset_x, s->width);
860     tile->coord[1][0] = av_clip(tiley       * (int64_t)s->tile_height + s->tile_offset_y, s->image_offset_y, s->height);
861     tile->coord[1][1] = av_clip((tiley + 1) * (int64_t)s->tile_height + s->tile_offset_y, s->image_offset_y, s->height);
862
863     for (compno = 0; compno < s->ncomponents; compno++) {
864         Jpeg2000Component *comp = tile->comp + compno;
865         Jpeg2000CodingStyle *codsty = tile->codsty + compno;
866         Jpeg2000QuantStyle  *qntsty = tile->qntsty + compno;
867         int ret; // global bandno
868
869         comp->coord_o[0][0] = tile->coord[0][0];
870         comp->coord_o[0][1] = tile->coord[0][1];
871         comp->coord_o[1][0] = tile->coord[1][0];
872         comp->coord_o[1][1] = tile->coord[1][1];
873         if (compno) {
874             comp->coord_o[0][0] /= s->cdx[compno];
875             comp->coord_o[0][1] /= s->cdx[compno];
876             comp->coord_o[1][0] /= s->cdy[compno];
877             comp->coord_o[1][1] /= s->cdy[compno];
878         }
879
880         comp->coord[0][0] = ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], s->reduction_factor);
881         comp->coord[0][1] = ff_jpeg2000_ceildivpow2(comp->coord_o[0][1], s->reduction_factor);
882         comp->coord[1][0] = ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], s->reduction_factor);
883         comp->coord[1][1] = ff_jpeg2000_ceildivpow2(comp->coord_o[1][1], s->reduction_factor);
884
885         if (ret = ff_jpeg2000_init_component(comp, codsty, qntsty,
886                                              s->cbps[compno], s->cdx[compno],
887                                              s->cdy[compno], s->avctx))
888             return ret;
889     }
890     return 0;
891 }
892
893 /* Read the number of coding passes. */
894 static int getnpasses(Jpeg2000DecoderContext *s)
895 {
896     int num;
897     if (!get_bits(s, 1))
898         return 1;
899     if (!get_bits(s, 1))
900         return 2;
901     if ((num = get_bits(s, 2)) != 3)
902         return num < 0 ? num : 3 + num;
903     if ((num = get_bits(s, 5)) != 31)
904         return num < 0 ? num : 6 + num;
905     num = get_bits(s, 7);
906     return num < 0 ? num : 37 + num;
907 }
908
909 static int getlblockinc(Jpeg2000DecoderContext *s)
910 {
911     int res = 0, ret;
912     while (ret = get_bits(s, 1)) {
913         if (ret < 0)
914             return ret;
915         res++;
916     }
917     return res;
918 }
919
920 static int jpeg2000_decode_packet(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile, int *tp_index,
921                                   Jpeg2000CodingStyle *codsty,
922                                   Jpeg2000ResLevel *rlevel, int precno,
923                                   int layno, uint8_t *expn, int numgbits)
924 {
925     int bandno, cblkno, ret, nb_code_blocks;
926     int cwsno;
927
928     if (layno < rlevel->band[0].prec[precno].decoded_layers)
929         return 0;
930     rlevel->band[0].prec[precno].decoded_layers = layno + 1;
931
932     if (bytestream2_get_bytes_left(&s->g) == 0 && s->bit_index == 8) {
933         if (*tp_index < FF_ARRAY_ELEMS(tile->tile_part) - 1) {
934             s->g = tile->tile_part[++(*tp_index)].tpg;
935         }
936     }
937
938     if (bytestream2_peek_be32(&s->g) == JPEG2000_SOP_FIXED_BYTES)
939         bytestream2_skip(&s->g, JPEG2000_SOP_BYTE_LENGTH);
940
941     if (!(ret = get_bits(s, 1))) {
942         jpeg2000_flush(s);
943         return 0;
944     } else if (ret < 0)
945         return ret;
946
947     for (bandno = 0; bandno < rlevel->nbands; bandno++) {
948         Jpeg2000Band *band = rlevel->band + bandno;
949         Jpeg2000Prec *prec = band->prec + precno;
950
951         if (band->coord[0][0] == band->coord[0][1] ||
952             band->coord[1][0] == band->coord[1][1])
953             continue;
954         nb_code_blocks =  prec->nb_codeblocks_height *
955                           prec->nb_codeblocks_width;
956         for (cblkno = 0; cblkno < nb_code_blocks; cblkno++) {
957             Jpeg2000Cblk *cblk = prec->cblk + cblkno;
958             int incl, newpasses, llen;
959             void *tmp;
960
961             if (cblk->npasses)
962                 incl = get_bits(s, 1);
963             else
964                 incl = tag_tree_decode(s, prec->cblkincl + cblkno, layno + 1) == layno;
965             if (!incl)
966                 continue;
967             else if (incl < 0)
968                 return incl;
969
970             if (!cblk->npasses) {
971                 int v = expn[bandno] + numgbits - 1 -
972                         tag_tree_decode(s, prec->zerobits + cblkno, 100);
973                 if (v < 0 || v > 30) {
974                     av_log(s->avctx, AV_LOG_ERROR,
975                            "nonzerobits %d invalid or unsupported\n", v);
976                     return AVERROR_INVALIDDATA;
977                 }
978                 cblk->nonzerobits = v;
979             }
980             if ((newpasses = getnpasses(s)) < 0)
981                 return newpasses;
982             av_assert2(newpasses > 0);
983             if (cblk->npasses + newpasses >= JPEG2000_MAX_PASSES) {
984                 avpriv_request_sample(s->avctx, "Too many passes");
985                 return AVERROR_PATCHWELCOME;
986             }
987             if ((llen = getlblockinc(s)) < 0)
988                 return llen;
989             if (cblk->lblock + llen + av_log2(newpasses) > 16) {
990                 avpriv_request_sample(s->avctx,
991                                       "Block with length beyond 16 bits");
992                 return AVERROR_PATCHWELCOME;
993             }
994
995             cblk->lblock += llen;
996
997             cblk->nb_lengthinc = 0;
998             cblk->nb_terminationsinc = 0;
999             av_free(cblk->lengthinc);
1000             cblk->lengthinc  = av_mallocz_array(newpasses    , sizeof(*cblk->lengthinc));
1001             if (!cblk->lengthinc)
1002                 return AVERROR(ENOMEM);
1003             tmp = av_realloc_array(cblk->data_start, cblk->nb_terminations + newpasses + 1, sizeof(*cblk->data_start));
1004             if (!tmp)
1005                 return AVERROR(ENOMEM);
1006             cblk->data_start = tmp;
1007             do {
1008                 int newpasses1 = 0;
1009
1010                 while (newpasses1 < newpasses) {
1011                     newpasses1 ++;
1012                     if (needs_termination(codsty->cblk_style, cblk->npasses + newpasses1 - 1)) {
1013                         cblk->nb_terminationsinc ++;
1014                         break;
1015                     }
1016                 }
1017
1018                 if ((ret = get_bits(s, av_log2(newpasses1) + cblk->lblock)) < 0)
1019                     return ret;
1020                 if (ret > cblk->data_allocated) {
1021                     size_t new_size = FFMAX(2*cblk->data_allocated, ret);
1022                     void *new = av_realloc(cblk->data, new_size);
1023                     if (new) {
1024                         cblk->data = new;
1025                         cblk->data_allocated = new_size;
1026                     }
1027                 }
1028                 if (ret > cblk->data_allocated) {
1029                     avpriv_request_sample(s->avctx,
1030                                         "Block with lengthinc greater than %"SIZE_SPECIFIER"",
1031                                         cblk->data_allocated);
1032                     return AVERROR_PATCHWELCOME;
1033                 }
1034                 cblk->lengthinc[cblk->nb_lengthinc++] = ret;
1035                 cblk->npasses  += newpasses1;
1036                 newpasses -= newpasses1;
1037             } while(newpasses);
1038         }
1039     }
1040     jpeg2000_flush(s);
1041
1042     if (codsty->csty & JPEG2000_CSTY_EPH) {
1043         if (bytestream2_peek_be16(&s->g) == JPEG2000_EPH)
1044             bytestream2_skip(&s->g, 2);
1045         else
1046             av_log(s->avctx, AV_LOG_ERROR, "EPH marker not found. instead %X\n", bytestream2_peek_be32(&s->g));
1047     }
1048
1049     for (bandno = 0; bandno < rlevel->nbands; bandno++) {
1050         Jpeg2000Band *band = rlevel->band + bandno;
1051         Jpeg2000Prec *prec = band->prec + precno;
1052
1053         nb_code_blocks = prec->nb_codeblocks_height * prec->nb_codeblocks_width;
1054         for (cblkno = 0; cblkno < nb_code_blocks; cblkno++) {
1055             Jpeg2000Cblk *cblk = prec->cblk + cblkno;
1056             if (!cblk->nb_terminationsinc && !cblk->lengthinc)
1057                 continue;
1058             for (cwsno = 0; cwsno < cblk->nb_lengthinc; cwsno ++) {
1059                 if (cblk->data_allocated < cblk->length + cblk->lengthinc[cwsno] + 4) {
1060                     size_t new_size = FFMAX(2*cblk->data_allocated, cblk->length + cblk->lengthinc[cwsno] + 4);
1061                     void *new = av_realloc(cblk->data, new_size);
1062                     if (new) {
1063                         cblk->data = new;
1064                         cblk->data_allocated = new_size;
1065                     }
1066                 }
1067                 if (   bytestream2_get_bytes_left(&s->g) < cblk->lengthinc[cwsno]
1068                     || cblk->data_allocated < cblk->length + cblk->lengthinc[cwsno] + 4
1069                 ) {
1070                     av_log(s->avctx, AV_LOG_ERROR,
1071                         "Block length %"PRIu16" or lengthinc %d is too large, left %d\n",
1072                         cblk->length, cblk->lengthinc[cwsno], bytestream2_get_bytes_left(&s->g));
1073                     return AVERROR_INVALIDDATA;
1074                 }
1075
1076                 bytestream2_get_bufferu(&s->g, cblk->data + cblk->length, cblk->lengthinc[cwsno]);
1077                 cblk->length   += cblk->lengthinc[cwsno];
1078                 cblk->lengthinc[cwsno] = 0;
1079                 if (cblk->nb_terminationsinc) {
1080                     cblk->nb_terminationsinc--;
1081                     cblk->nb_terminations++;
1082                     cblk->data[cblk->length++] = 0xFF;
1083                     cblk->data[cblk->length++] = 0xFF;
1084                     cblk->data_start[cblk->nb_terminations] = cblk->length;
1085                 }
1086             }
1087             av_freep(&cblk->lengthinc);
1088         }
1089     }
1090     return 0;
1091 }
1092
1093 static int jpeg2000_decode_packets_po_iteration(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile,
1094                                              int RSpoc, int CSpoc,
1095                                              int LYEpoc, int REpoc, int CEpoc,
1096                                              int Ppoc, int *tp_index)
1097 {
1098     int ret = 0;
1099     int layno, reslevelno, compno, precno, ok_reslevel;
1100     int x, y;
1101     int step_x, step_y;
1102
1103     switch (Ppoc) {
1104     case JPEG2000_PGOD_RLCP:
1105         av_log(s->avctx, AV_LOG_DEBUG, "Progression order RLCP\n");
1106         ok_reslevel = 1;
1107         for (reslevelno = RSpoc; ok_reslevel && reslevelno < REpoc; reslevelno++) {
1108             ok_reslevel = 0;
1109             for (layno = 0; layno < LYEpoc; layno++) {
1110                 for (compno = CSpoc; compno < CEpoc; compno++) {
1111                     Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1112                     Jpeg2000QuantStyle *qntsty  = tile->qntsty + compno;
1113                     if (reslevelno < codsty->nreslevels) {
1114                         Jpeg2000ResLevel *rlevel = tile->comp[compno].reslevel +
1115                                                 reslevelno;
1116                         ok_reslevel = 1;
1117                         for (precno = 0; precno < rlevel->num_precincts_x * rlevel->num_precincts_y; precno++)
1118                             if ((ret = jpeg2000_decode_packet(s, tile, tp_index,
1119                                                               codsty, rlevel,
1120                                                               precno, layno,
1121                                                               qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1122                                                               qntsty->nguardbits)) < 0)
1123                                 return ret;
1124                     }
1125                 }
1126             }
1127         }
1128         break;
1129
1130     case JPEG2000_PGOD_LRCP:
1131         av_log(s->avctx, AV_LOG_DEBUG, "Progression order LRCP\n");
1132         for (layno = 0; layno < LYEpoc; layno++) {
1133             ok_reslevel = 1;
1134             for (reslevelno = RSpoc; ok_reslevel && reslevelno < REpoc; reslevelno++) {
1135                 ok_reslevel = 0;
1136                 for (compno = CSpoc; compno < CEpoc; compno++) {
1137                     Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1138                     Jpeg2000QuantStyle *qntsty  = tile->qntsty + compno;
1139                     if (reslevelno < codsty->nreslevels) {
1140                         Jpeg2000ResLevel *rlevel = tile->comp[compno].reslevel +
1141                                                 reslevelno;
1142                         ok_reslevel = 1;
1143                         for (precno = 0; precno < rlevel->num_precincts_x * rlevel->num_precincts_y; precno++)
1144                             if ((ret = jpeg2000_decode_packet(s, tile, tp_index,
1145                                                               codsty, rlevel,
1146                                                               precno, layno,
1147                                                               qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1148                                                               qntsty->nguardbits)) < 0)
1149                                 return ret;
1150                     }
1151                 }
1152             }
1153         }
1154         break;
1155
1156     case JPEG2000_PGOD_CPRL:
1157         av_log(s->avctx, AV_LOG_DEBUG, "Progression order CPRL\n");
1158         for (compno = CSpoc; compno < CEpoc; compno++) {
1159             Jpeg2000Component *comp     = tile->comp + compno;
1160             Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1161             Jpeg2000QuantStyle *qntsty  = tile->qntsty + compno;
1162             step_x = 32;
1163             step_y = 32;
1164
1165             if (RSpoc >= FFMIN(codsty->nreslevels, REpoc))
1166                 continue;
1167
1168             for (reslevelno = RSpoc; reslevelno < FFMIN(codsty->nreslevels, REpoc); reslevelno++) {
1169                 uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; //  ==> N_L - r
1170                 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1171                 step_x = FFMIN(step_x, rlevel->log2_prec_width  + reducedresno);
1172                 step_y = FFMIN(step_y, rlevel->log2_prec_height + reducedresno);
1173             }
1174             av_assert0(step_x < 32 && step_y < 32);
1175             step_x = 1<<step_x;
1176             step_y = 1<<step_y;
1177
1178             for (y = tile->coord[1][0]; y < tile->coord[1][1]; y = (y/step_y + 1)*step_y) {
1179                 for (x = tile->coord[0][0]; x < tile->coord[0][1]; x = (x/step_x + 1)*step_x) {
1180                     for (reslevelno = RSpoc; reslevelno < FFMIN(codsty->nreslevels, REpoc); reslevelno++) {
1181                         unsigned prcx, prcy;
1182                         uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; //  ==> N_L - r
1183                         Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1184                         int xc = x / s->cdx[compno];
1185                         int yc = y / s->cdy[compno];
1186
1187                         if (yc % (1LL << (rlevel->log2_prec_height + reducedresno)) && y != tile->coord[1][0]) //FIXME this is a subset of the check
1188                             continue;
1189
1190                         if (xc % (1LL << (rlevel->log2_prec_width + reducedresno)) && x != tile->coord[0][0]) //FIXME this is a subset of the check
1191                             continue;
1192
1193                         // check if a precinct exists
1194                         prcx   = ff_jpeg2000_ceildivpow2(xc, reducedresno) >> rlevel->log2_prec_width;
1195                         prcy   = ff_jpeg2000_ceildivpow2(yc, reducedresno) >> rlevel->log2_prec_height;
1196                         prcx  -= ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], reducedresno) >> rlevel->log2_prec_width;
1197                         prcy  -= ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], reducedresno) >> rlevel->log2_prec_height;
1198
1199                         precno = prcx + rlevel->num_precincts_x * prcy;
1200
1201                         if (prcx >= rlevel->num_precincts_x || prcy >= rlevel->num_precincts_y) {
1202                             av_log(s->avctx, AV_LOG_WARNING, "prc %d %d outside limits %d %d\n",
1203                                    prcx, prcy, rlevel->num_precincts_x, rlevel->num_precincts_y);
1204                             continue;
1205                         }
1206
1207                         for (layno = 0; layno < LYEpoc; layno++) {
1208                             if ((ret = jpeg2000_decode_packet(s, tile, tp_index, codsty, rlevel,
1209                                                               precno, layno,
1210                                                               qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1211                                                               qntsty->nguardbits)) < 0)
1212                                 return ret;
1213                         }
1214                     }
1215                 }
1216             }
1217         }
1218         break;
1219
1220     case JPEG2000_PGOD_RPCL:
1221         av_log(s->avctx, AV_LOG_WARNING, "Progression order RPCL\n");
1222         ok_reslevel = 1;
1223         for (reslevelno = RSpoc; ok_reslevel && reslevelno < REpoc; reslevelno++) {
1224             ok_reslevel = 0;
1225             step_x = 30;
1226             step_y = 30;
1227             for (compno = CSpoc; compno < CEpoc; compno++) {
1228                 Jpeg2000Component *comp     = tile->comp + compno;
1229                 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1230
1231                 if (reslevelno < codsty->nreslevels) {
1232                     uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; //  ==> N_L - r
1233                     Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1234                     step_x = FFMIN(step_x, rlevel->log2_prec_width  + reducedresno);
1235                     step_y = FFMIN(step_y, rlevel->log2_prec_height + reducedresno);
1236                 }
1237             }
1238             step_x = 1<<step_x;
1239             step_y = 1<<step_y;
1240
1241             for (y = tile->coord[1][0]; y < tile->coord[1][1]; y = (y/step_y + 1)*step_y) {
1242                 for (x = tile->coord[0][0]; x < tile->coord[0][1]; x = (x/step_x + 1)*step_x) {
1243                     for (compno = CSpoc; compno < CEpoc; compno++) {
1244                         Jpeg2000Component *comp     = tile->comp + compno;
1245                         Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1246                         Jpeg2000QuantStyle *qntsty  = tile->qntsty + compno;
1247                         uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; //  ==> N_L - r
1248                         Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1249                         unsigned prcx, prcy;
1250
1251                         int xc = x / s->cdx[compno];
1252                         int yc = y / s->cdy[compno];
1253
1254                         if (reslevelno >= codsty->nreslevels)
1255                             continue;
1256
1257                         if (yc % (1LL << (rlevel->log2_prec_height + reducedresno)) && y != tile->coord[1][0]) //FIXME this is a subset of the check
1258                             continue;
1259
1260                         if (xc % (1LL << (rlevel->log2_prec_width + reducedresno)) && x != tile->coord[0][0]) //FIXME this is a subset of the check
1261                             continue;
1262
1263                         // check if a precinct exists
1264                         prcx   = ff_jpeg2000_ceildivpow2(xc, reducedresno) >> rlevel->log2_prec_width;
1265                         prcy   = ff_jpeg2000_ceildivpow2(yc, reducedresno) >> rlevel->log2_prec_height;
1266                         prcx  -= ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], reducedresno) >> rlevel->log2_prec_width;
1267                         prcy  -= ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], reducedresno) >> rlevel->log2_prec_height;
1268
1269                         precno = prcx + rlevel->num_precincts_x * prcy;
1270
1271                         ok_reslevel = 1;
1272                         if (prcx >= rlevel->num_precincts_x || prcy >= rlevel->num_precincts_y) {
1273                             av_log(s->avctx, AV_LOG_WARNING, "prc %d %d outside limits %d %d\n",
1274                                    prcx, prcy, rlevel->num_precincts_x, rlevel->num_precincts_y);
1275                             continue;
1276                         }
1277
1278                             for (layno = 0; layno < LYEpoc; layno++) {
1279                                 if ((ret = jpeg2000_decode_packet(s, tile, tp_index,
1280                                                                 codsty, rlevel,
1281                                                                 precno, layno,
1282                                                                 qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1283                                                                 qntsty->nguardbits)) < 0)
1284                                     return ret;
1285                             }
1286                     }
1287                 }
1288             }
1289         }
1290         break;
1291
1292     case JPEG2000_PGOD_PCRL:
1293         av_log(s->avctx, AV_LOG_WARNING, "Progression order PCRL\n");
1294         step_x = 32;
1295         step_y = 32;
1296         for (compno = CSpoc; compno < CEpoc; compno++) {
1297             Jpeg2000Component *comp     = tile->comp + compno;
1298             Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1299
1300             for (reslevelno = RSpoc; reslevelno < FFMIN(codsty->nreslevels, REpoc); reslevelno++) {
1301                 uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; //  ==> N_L - r
1302                 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1303                 step_x = FFMIN(step_x, rlevel->log2_prec_width  + reducedresno);
1304                 step_y = FFMIN(step_y, rlevel->log2_prec_height + reducedresno);
1305             }
1306         }
1307         if (step_x >= 31 || step_y >= 31){
1308             avpriv_request_sample(s->avctx, "PCRL with large step");
1309             return AVERROR_PATCHWELCOME;
1310         }
1311         step_x = 1<<step_x;
1312         step_y = 1<<step_y;
1313
1314         for (y = tile->coord[1][0]; y < tile->coord[1][1]; y = (y/step_y + 1)*step_y) {
1315             for (x = tile->coord[0][0]; x < tile->coord[0][1]; x = (x/step_x + 1)*step_x) {
1316                 for (compno = CSpoc; compno < CEpoc; compno++) {
1317                     Jpeg2000Component *comp     = tile->comp + compno;
1318                     Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1319                     Jpeg2000QuantStyle *qntsty  = tile->qntsty + compno;
1320                     int xc = x / s->cdx[compno];
1321                     int yc = y / s->cdy[compno];
1322
1323                     for (reslevelno = RSpoc; reslevelno < FFMIN(codsty->nreslevels, REpoc); reslevelno++) {
1324                         unsigned prcx, prcy;
1325                         uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; //  ==> N_L - r
1326                         Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1327
1328                         if (yc % (1LL << (rlevel->log2_prec_height + reducedresno)) && y != tile->coord[1][0]) //FIXME this is a subset of the check
1329                             continue;
1330
1331                         if (xc % (1LL << (rlevel->log2_prec_width + reducedresno)) && x != tile->coord[0][0]) //FIXME this is a subset of the check
1332                             continue;
1333
1334                         // check if a precinct exists
1335                         prcx   = ff_jpeg2000_ceildivpow2(xc, reducedresno) >> rlevel->log2_prec_width;
1336                         prcy   = ff_jpeg2000_ceildivpow2(yc, reducedresno) >> rlevel->log2_prec_height;
1337                         prcx  -= ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], reducedresno) >> rlevel->log2_prec_width;
1338                         prcy  -= ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], reducedresno) >> rlevel->log2_prec_height;
1339
1340                         precno = prcx + rlevel->num_precincts_x * prcy;
1341
1342                         if (prcx >= rlevel->num_precincts_x || prcy >= rlevel->num_precincts_y) {
1343                             av_log(s->avctx, AV_LOG_WARNING, "prc %d %d outside limits %d %d\n",
1344                                    prcx, prcy, rlevel->num_precincts_x, rlevel->num_precincts_y);
1345                             continue;
1346                         }
1347
1348                         for (layno = 0; layno < LYEpoc; layno++) {
1349                             if ((ret = jpeg2000_decode_packet(s, tile, tp_index, codsty, rlevel,
1350                                                               precno, layno,
1351                                                               qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1352                                                               qntsty->nguardbits)) < 0)
1353                                 return ret;
1354                         }
1355                     }
1356                 }
1357             }
1358         }
1359         break;
1360
1361     default:
1362         break;
1363     }
1364
1365     return ret;
1366 }
1367
1368 static int jpeg2000_decode_packets(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
1369 {
1370     int ret = AVERROR_BUG;
1371     int i;
1372     int tp_index = 0;
1373
1374     s->bit_index = 8;
1375     if (tile->poc.nb_poc) {
1376         for (i=0; i<tile->poc.nb_poc; i++) {
1377             Jpeg2000POCEntry *e = &tile->poc.poc[i];
1378             ret = jpeg2000_decode_packets_po_iteration(s, tile,
1379                 e->RSpoc, e->CSpoc,
1380                 FFMIN(e->LYEpoc, tile->codsty[0].nlayers),
1381                 e->REpoc,
1382                 FFMIN(e->CEpoc, s->ncomponents),
1383                 e->Ppoc, &tp_index
1384                 );
1385             if (ret < 0)
1386                 return ret;
1387         }
1388     } else {
1389         ret = jpeg2000_decode_packets_po_iteration(s, tile,
1390             0, 0,
1391             tile->codsty[0].nlayers,
1392             33,
1393             s->ncomponents,
1394             tile->codsty[0].prog_order,
1395             &tp_index
1396         );
1397     }
1398     /* EOC marker reached */
1399     bytestream2_skip(&s->g, 2);
1400
1401     return ret;
1402 }
1403
1404 /* TIER-1 routines */
1405 static void decode_sigpass(Jpeg2000T1Context *t1, int width, int height,
1406                            int bpno, int bandno,
1407                            int vert_causal_ctx_csty_symbol)
1408 {
1409     int mask = 3 << (bpno - 1), y0, x, y;
1410
1411     for (y0 = 0; y0 < height; y0 += 4)
1412         for (x = 0; x < width; x++)
1413             for (y = y0; y < height && y < y0 + 4; y++) {
1414                 int flags_mask = -1;
1415                 if (vert_causal_ctx_csty_symbol && y == y0 + 3)
1416                     flags_mask &= ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE | JPEG2000_T1_SGN_S);
1417                 if ((t1->flags[(y+1) * t1->stride + x+1] & JPEG2000_T1_SIG_NB & flags_mask)
1418                 && !(t1->flags[(y+1) * t1->stride + x+1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS))) {
1419                     if (ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ff_jpeg2000_getsigctxno(t1->flags[(y+1) * t1->stride + x+1] & flags_mask, bandno))) {
1420                         int xorbit, ctxno = ff_jpeg2000_getsgnctxno(t1->flags[(y+1) * t1->stride + x+1] & flags_mask, &xorbit);
1421                         if (t1->mqc.raw)
1422                              t1->data[(y) * t1->stride + x] = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ctxno) ? -mask : mask;
1423                         else
1424                              t1->data[(y) * t1->stride + x] = (ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ctxno) ^ xorbit) ?
1425                                                -mask : mask;
1426
1427                         ff_jpeg2000_set_significance(t1, x, y,
1428                                                      t1->data[(y) * t1->stride + x] < 0);
1429                     }
1430                     t1->flags[(y + 1) * t1->stride + x + 1] |= JPEG2000_T1_VIS;
1431                 }
1432             }
1433 }
1434
1435 static void decode_refpass(Jpeg2000T1Context *t1, int width, int height,
1436                            int bpno, int vert_causal_ctx_csty_symbol)
1437 {
1438     int phalf, nhalf;
1439     int y0, x, y;
1440
1441     phalf = 1 << (bpno - 1);
1442     nhalf = -phalf;
1443
1444     for (y0 = 0; y0 < height; y0 += 4)
1445         for (x = 0; x < width; x++)
1446             for (y = y0; y < height && y < y0 + 4; y++)
1447                 if ((t1->flags[(y + 1) * t1->stride + x + 1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS)) == JPEG2000_T1_SIG) {
1448                     int flags_mask = (vert_causal_ctx_csty_symbol && y == y0 + 3) ?
1449                         ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE | JPEG2000_T1_SGN_S) : -1;
1450                     int ctxno = ff_jpeg2000_getrefctxno(t1->flags[(y + 1) * t1->stride + x + 1] & flags_mask);
1451                     int r     = ff_mqc_decode(&t1->mqc,
1452                                               t1->mqc.cx_states + ctxno)
1453                                 ? phalf : nhalf;
1454                     t1->data[(y) * t1->stride + x]          += t1->data[(y) * t1->stride + x] < 0 ? -r : r;
1455                     t1->flags[(y + 1) * t1->stride + x + 1] |= JPEG2000_T1_REF;
1456                 }
1457 }
1458
1459 static void decode_clnpass(Jpeg2000DecoderContext *s, Jpeg2000T1Context *t1,
1460                            int width, int height, int bpno, int bandno,
1461                            int seg_symbols, int vert_causal_ctx_csty_symbol)
1462 {
1463     int mask = 3 << (bpno - 1), y0, x, y, runlen, dec;
1464
1465     for (y0 = 0; y0 < height; y0 += 4) {
1466         for (x = 0; x < width; x++) {
1467             int flags_mask = -1;
1468             if (vert_causal_ctx_csty_symbol)
1469                 flags_mask &= ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE | JPEG2000_T1_SGN_S);
1470             if (y0 + 3 < height &&
1471                 !((t1->flags[(y0 + 1) * t1->stride + x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
1472                   (t1->flags[(y0 + 2) * t1->stride + x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
1473                   (t1->flags[(y0 + 3) * t1->stride + x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
1474                   (t1->flags[(y0 + 4) * t1->stride + x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG) & flags_mask))) {
1475                 if (!ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_RL))
1476                     continue;
1477                 runlen = ff_mqc_decode(&t1->mqc,
1478                                        t1->mqc.cx_states + MQC_CX_UNI);
1479                 runlen = (runlen << 1) | ff_mqc_decode(&t1->mqc,
1480                                                        t1->mqc.cx_states +
1481                                                        MQC_CX_UNI);
1482                 dec = 1;
1483             } else {
1484                 runlen = 0;
1485                 dec    = 0;
1486             }
1487
1488             for (y = y0 + runlen; y < y0 + 4 && y < height; y++) {
1489                 int flags_mask = -1;
1490                 if (vert_causal_ctx_csty_symbol && y == y0 + 3)
1491                     flags_mask &= ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE | JPEG2000_T1_SGN_S);
1492                 if (!dec) {
1493                     if (!(t1->flags[(y+1) * t1->stride + x+1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS))) {
1494                         dec = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ff_jpeg2000_getsigctxno(t1->flags[(y+1) * t1->stride + x+1] & flags_mask,
1495                                                                                              bandno));
1496                     }
1497                 }
1498                 if (dec) {
1499                     int xorbit;
1500                     int ctxno = ff_jpeg2000_getsgnctxno(t1->flags[(y + 1) * t1->stride + x + 1] & flags_mask,
1501                                                         &xorbit);
1502                     t1->data[(y) * t1->stride + x] = (ff_mqc_decode(&t1->mqc,
1503                                                     t1->mqc.cx_states + ctxno) ^
1504                                       xorbit)
1505                                      ? -mask : mask;
1506                     ff_jpeg2000_set_significance(t1, x, y, t1->data[(y) * t1->stride + x] < 0);
1507                 }
1508                 dec = 0;
1509                 t1->flags[(y + 1) * t1->stride + x + 1] &= ~JPEG2000_T1_VIS;
1510             }
1511         }
1512     }
1513     if (seg_symbols) {
1514         int val;
1515         val = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1516         val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1517         val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1518         val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1519         if (val != 0xa)
1520             av_log(s->avctx, AV_LOG_ERROR,
1521                    "Segmentation symbol value incorrect\n");
1522     }
1523 }
1524
1525 static int decode_cblk(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *codsty,
1526                        Jpeg2000T1Context *t1, Jpeg2000Cblk *cblk,
1527                        int width, int height, int bandpos)
1528 {
1529     int passno = cblk->npasses, pass_t = 2, bpno = cblk->nonzerobits - 1;
1530     int pass_cnt = 0;
1531     int vert_causal_ctx_csty_symbol = codsty->cblk_style & JPEG2000_CBLK_VSC;
1532     int term_cnt = 0;
1533     int coder_type;
1534
1535     av_assert0(width <= 1024U && height <= 1024U);
1536     av_assert0(width*height <= 4096);
1537
1538     memset(t1->data, 0, t1->stride * height * sizeof(*t1->data));
1539
1540     /* If code-block contains no compressed data: nothing to do. */
1541     if (!cblk->length)
1542         return 0;
1543
1544     memset(t1->flags, 0, t1->stride * (height + 2) * sizeof(*t1->flags));
1545
1546     cblk->data[cblk->length] = 0xff;
1547     cblk->data[cblk->length+1] = 0xff;
1548     ff_mqc_initdec(&t1->mqc, cblk->data, 0, 1);
1549
1550     while (passno--) {
1551         if (bpno < 0) {
1552             av_log(s->avctx, AV_LOG_ERROR, "bpno became negative\n");
1553             return AVERROR_INVALIDDATA;
1554         }
1555         switch(pass_t) {
1556         case 0:
1557             decode_sigpass(t1, width, height, bpno + 1, bandpos,
1558                            vert_causal_ctx_csty_symbol);
1559             break;
1560         case 1:
1561             decode_refpass(t1, width, height, bpno + 1, vert_causal_ctx_csty_symbol);
1562             break;
1563         case 2:
1564             av_assert2(!t1->mqc.raw);
1565             decode_clnpass(s, t1, width, height, bpno + 1, bandpos,
1566                            codsty->cblk_style & JPEG2000_CBLK_SEGSYM,
1567                            vert_causal_ctx_csty_symbol);
1568             break;
1569         }
1570         if (codsty->cblk_style & JPEG2000_CBLK_RESET) // XXX no testcase for just this
1571             ff_mqc_init_contexts(&t1->mqc);
1572
1573         if (passno && (coder_type = needs_termination(codsty->cblk_style, pass_cnt))) {
1574             if (term_cnt >= cblk->nb_terminations) {
1575                 av_log(s->avctx, AV_LOG_ERROR, "Missing needed termination \n");
1576                 return AVERROR_INVALIDDATA;
1577             }
1578             if (FFABS(cblk->data + cblk->data_start[term_cnt + 1] - 2 - t1->mqc.bp) > 0) {
1579                 av_log(s->avctx, AV_LOG_WARNING, "Mid mismatch %"PTRDIFF_SPECIFIER" in pass %d of %d\n",
1580                     cblk->data + cblk->data_start[term_cnt + 1] - 2 - t1->mqc.bp,
1581                     pass_cnt, cblk->npasses);
1582             }
1583
1584             ff_mqc_initdec(&t1->mqc, cblk->data + cblk->data_start[++term_cnt], coder_type == 2, 0);
1585         }
1586
1587         pass_t++;
1588         if (pass_t == 3) {
1589             bpno--;
1590             pass_t = 0;
1591         }
1592         pass_cnt ++;
1593     }
1594
1595     if (cblk->data + cblk->length - 2*(term_cnt < cblk->nb_terminations) != t1->mqc.bp) {
1596         av_log(s->avctx, AV_LOG_WARNING, "End mismatch %"PTRDIFF_SPECIFIER"\n",
1597                cblk->data + cblk->length - 2*(term_cnt < cblk->nb_terminations) - t1->mqc.bp);
1598     }
1599
1600     return 0;
1601 }
1602
1603 /* TODO: Verify dequantization for lossless case
1604  * comp->data can be float or int
1605  * band->stepsize can be float or int
1606  * depending on the type of DWT transformation.
1607  * see ISO/IEC 15444-1:2002 A.6.1 */
1608
1609 /* Float dequantization of a codeblock.*/
1610 static void dequantization_float(int x, int y, Jpeg2000Cblk *cblk,
1611                                  Jpeg2000Component *comp,
1612                                  Jpeg2000T1Context *t1, Jpeg2000Band *band)
1613 {
1614     int i, j;
1615     int w = cblk->coord[0][1] - cblk->coord[0][0];
1616     for (j = 0; j < (cblk->coord[1][1] - cblk->coord[1][0]); ++j) {
1617         float *datap = &comp->f_data[(comp->coord[0][1] - comp->coord[0][0]) * (y + j) + x];
1618         int *src = t1->data + j*t1->stride;
1619         for (i = 0; i < w; ++i)
1620             datap[i] = src[i] * band->f_stepsize;
1621     }
1622 }
1623
1624 /* Integer dequantization of a codeblock.*/
1625 static void dequantization_int(int x, int y, Jpeg2000Cblk *cblk,
1626                                Jpeg2000Component *comp,
1627                                Jpeg2000T1Context *t1, Jpeg2000Band *band)
1628 {
1629     int i, j;
1630     int w = cblk->coord[0][1] - cblk->coord[0][0];
1631     for (j = 0; j < (cblk->coord[1][1] - cblk->coord[1][0]); ++j) {
1632         int32_t *datap = &comp->i_data[(comp->coord[0][1] - comp->coord[0][0]) * (y + j) + x];
1633         int *src = t1->data + j*t1->stride;
1634         if (band->i_stepsize == 32768) {
1635             for (i = 0; i < w; ++i)
1636                 datap[i] = src[i] / 2;
1637         } else {
1638             // This should be VERY uncommon
1639             for (i = 0; i < w; ++i)
1640                 datap[i] = (src[i] * (int64_t)band->i_stepsize) / 65536;
1641         }
1642     }
1643 }
1644
1645 static void dequantization_int_97(int x, int y, Jpeg2000Cblk *cblk,
1646                                Jpeg2000Component *comp,
1647                                Jpeg2000T1Context *t1, Jpeg2000Band *band)
1648 {
1649     int i, j;
1650     int w = cblk->coord[0][1] - cblk->coord[0][0];
1651     for (j = 0; j < (cblk->coord[1][1] - cblk->coord[1][0]); ++j) {
1652         int32_t *datap = &comp->i_data[(comp->coord[0][1] - comp->coord[0][0]) * (y + j) + x];
1653         int *src = t1->data + j*t1->stride;
1654         for (i = 0; i < w; ++i)
1655             datap[i] = (src[i] * (int64_t)band->i_stepsize + (1<<15)) >> 16;
1656     }
1657 }
1658
1659 static inline void mct_decode(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
1660 {
1661     int i, csize = 1;
1662     void *src[3];
1663
1664     for (i = 1; i < 3; i++) {
1665         if (tile->codsty[0].transform != tile->codsty[i].transform) {
1666             av_log(s->avctx, AV_LOG_ERROR, "Transforms mismatch, MCT not supported\n");
1667             return;
1668         }
1669         if (memcmp(tile->comp[0].coord, tile->comp[i].coord, sizeof(tile->comp[0].coord))) {
1670             av_log(s->avctx, AV_LOG_ERROR, "Coords mismatch, MCT not supported\n");
1671             return;
1672         }
1673     }
1674
1675     for (i = 0; i < 3; i++)
1676         if (tile->codsty[0].transform == FF_DWT97)
1677             src[i] = tile->comp[i].f_data;
1678         else
1679             src[i] = tile->comp[i].i_data;
1680
1681     for (i = 0; i < 2; i++)
1682         csize *= tile->comp[0].coord[i][1] - tile->comp[0].coord[i][0];
1683
1684     s->dsp.mct_decode[tile->codsty[0].transform](src[0], src[1], src[2], csize);
1685 }
1686
1687 static inline void tile_codeblocks(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
1688 {
1689     Jpeg2000T1Context t1;
1690
1691     int compno, reslevelno, bandno;
1692
1693     /* Loop on tile components */
1694     for (compno = 0; compno < s->ncomponents; compno++) {
1695         Jpeg2000Component *comp     = tile->comp + compno;
1696         Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1697
1698         t1.stride = (1<<codsty->log2_cblk_width) + 2;
1699
1700         /* Loop on resolution levels */
1701         for (reslevelno = 0; reslevelno < codsty->nreslevels2decode; reslevelno++) {
1702             Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1703             /* Loop on bands */
1704             for (bandno = 0; bandno < rlevel->nbands; bandno++) {
1705                 int nb_precincts, precno;
1706                 Jpeg2000Band *band = rlevel->band + bandno;
1707                 int cblkno = 0, bandpos;
1708
1709                 bandpos = bandno + (reslevelno > 0);
1710
1711                 if (band->coord[0][0] == band->coord[0][1] ||
1712                     band->coord[1][0] == band->coord[1][1])
1713                     continue;
1714
1715                 nb_precincts = rlevel->num_precincts_x * rlevel->num_precincts_y;
1716                 /* Loop on precincts */
1717                 for (precno = 0; precno < nb_precincts; precno++) {
1718                     Jpeg2000Prec *prec = band->prec + precno;
1719
1720                     /* Loop on codeblocks */
1721                     for (cblkno = 0;
1722                          cblkno < prec->nb_codeblocks_width * prec->nb_codeblocks_height;
1723                          cblkno++) {
1724                         int x, y;
1725                         Jpeg2000Cblk *cblk = prec->cblk + cblkno;
1726                         decode_cblk(s, codsty, &t1, cblk,
1727                                     cblk->coord[0][1] - cblk->coord[0][0],
1728                                     cblk->coord[1][1] - cblk->coord[1][0],
1729                                     bandpos);
1730
1731                         x = cblk->coord[0][0] - band->coord[0][0];
1732                         y = cblk->coord[1][0] - band->coord[1][0];
1733
1734                         if (codsty->transform == FF_DWT97)
1735                             dequantization_float(x, y, cblk, comp, &t1, band);
1736                         else if (codsty->transform == FF_DWT97_INT)
1737                             dequantization_int_97(x, y, cblk, comp, &t1, band);
1738                         else
1739                             dequantization_int(x, y, cblk, comp, &t1, band);
1740                    } /* end cblk */
1741                 } /*end prec */
1742             } /* end band */
1743         } /* end reslevel */
1744
1745         /* inverse DWT */
1746         ff_dwt_decode(&comp->dwt, codsty->transform == FF_DWT97 ? (void*)comp->f_data : (void*)comp->i_data);
1747     } /*end comp */
1748 }
1749
1750 #define WRITE_FRAME(D, PIXEL)                                                                     \
1751     static inline void write_frame_ ## D(Jpeg2000DecoderContext * s, Jpeg2000Tile * tile,         \
1752                                          AVFrame * picture, int precision)                        \
1753     {                                                                                             \
1754         const AVPixFmtDescriptor *pixdesc = av_pix_fmt_desc_get(s->avctx->pix_fmt);               \
1755         int planar    = !!(pixdesc->flags & AV_PIX_FMT_FLAG_PLANAR);                              \
1756         int pixelsize = planar ? 1 : pixdesc->nb_components;                                      \
1757                                                                                                   \
1758         int compno;                                                                               \
1759         int x, y;                                                                                 \
1760                                                                                                   \
1761         for (compno = 0; compno < s->ncomponents; compno++) {                                     \
1762             Jpeg2000Component *comp     = tile->comp + compno;                                    \
1763             Jpeg2000CodingStyle *codsty = tile->codsty + compno;                                  \
1764             PIXEL *line;                                                                          \
1765             float *datap     = comp->f_data;                                                      \
1766             int32_t *i_datap = comp->i_data;                                                      \
1767             int cbps         = s->cbps[compno];                                                   \
1768             int w            = tile->comp[compno].coord[0][1] - s->image_offset_x;                \
1769             int plane        = 0;                                                                 \
1770                                                                                                   \
1771             if (planar)                                                                           \
1772                 plane = s->cdef[compno] ? s->cdef[compno]-1 : (s->ncomponents-1);                 \
1773                                                                                                   \
1774             y    = tile->comp[compno].coord[1][0] - s->image_offset_y / s->cdy[compno];           \
1775             line = (PIXEL *)picture->data[plane] + y * (picture->linesize[plane] / sizeof(PIXEL));\
1776             for (; y < tile->comp[compno].coord[1][1] - s->image_offset_y; y++) {                 \
1777                 PIXEL *dst;                                                                       \
1778                                                                                                   \
1779                 x   = tile->comp[compno].coord[0][0] - s->image_offset_x / s->cdx[compno];        \
1780                 dst = line + x * pixelsize + compno*!planar;                                      \
1781                                                                                                   \
1782                 if (codsty->transform == FF_DWT97) {                                              \
1783                     for (; x < w; x++) {                                                          \
1784                         int val = lrintf(*datap) + (1 << (cbps - 1));                             \
1785                         /* DC level shift and clip see ISO 15444-1:2002 G.1.2 */                  \
1786                         val  = av_clip(val, 0, (1 << cbps) - 1);                                  \
1787                         *dst = val << (precision - cbps);                                         \
1788                         datap++;                                                                  \
1789                         dst += pixelsize;                                                         \
1790                     }                                                                             \
1791                 } else {                                                                          \
1792                     for (; x < w; x++) {                                                          \
1793                         int val = *i_datap + (1 << (cbps - 1));                                   \
1794                         /* DC level shift and clip see ISO 15444-1:2002 G.1.2 */                  \
1795                         val  = av_clip(val, 0, (1 << cbps) - 1);                                  \
1796                         *dst = val << (precision - cbps);                                         \
1797                         i_datap++;                                                                \
1798                         dst += pixelsize;                                                         \
1799                     }                                                                             \
1800                 }                                                                                 \
1801                 line += picture->linesize[plane] / sizeof(PIXEL);                                 \
1802             }                                                                                     \
1803         }                                                                                         \
1804                                                                                                   \
1805     }
1806
1807 WRITE_FRAME(8, uint8_t)
1808 WRITE_FRAME(16, uint16_t)
1809
1810 #undef WRITE_FRAME
1811
1812 static int jpeg2000_decode_tile(AVCodecContext *avctx, void *td,
1813                                 int jobnr, int threadnr)
1814 {
1815     Jpeg2000DecoderContext *s = avctx->priv_data;
1816     AVFrame *picture = td;
1817     Jpeg2000Tile *tile = s->tile + jobnr;
1818     int x;
1819
1820     tile_codeblocks(s, tile);
1821
1822     /* inverse MCT transformation */
1823     if (tile->codsty[0].mct)
1824         mct_decode(s, tile);
1825
1826     for (x = 0; x < s->ncomponents; x++) {
1827         if (s->cdef[x] < 0) {
1828             for (x = 0; x < s->ncomponents; x++) {
1829                 s->cdef[x] = x + 1;
1830             }
1831             if ((s->ncomponents & 1) == 0)
1832                 s->cdef[s->ncomponents-1] = 0;
1833             break;
1834         }
1835     }
1836
1837     if (s->precision <= 8) {
1838         write_frame_8(s, tile, picture, 8);
1839     } else {
1840         int precision = picture->format == AV_PIX_FMT_XYZ12 ||
1841                         picture->format == AV_PIX_FMT_RGB48 ||
1842                         picture->format == AV_PIX_FMT_RGBA64 ||
1843                         picture->format == AV_PIX_FMT_GRAY16 ? 16 : s->precision;
1844
1845         write_frame_16(s, tile, picture, precision);
1846     }
1847
1848     return 0;
1849 }
1850
1851 static void jpeg2000_dec_cleanup(Jpeg2000DecoderContext *s)
1852 {
1853     int tileno, compno;
1854     for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++) {
1855         if (s->tile[tileno].comp) {
1856             for (compno = 0; compno < s->ncomponents; compno++) {
1857                 Jpeg2000Component *comp     = s->tile[tileno].comp   + compno;
1858                 Jpeg2000CodingStyle *codsty = s->tile[tileno].codsty + compno;
1859
1860                 ff_jpeg2000_cleanup(comp, codsty);
1861             }
1862             av_freep(&s->tile[tileno].comp);
1863         }
1864     }
1865     av_freep(&s->tile);
1866     memset(s->codsty, 0, sizeof(s->codsty));
1867     memset(s->qntsty, 0, sizeof(s->qntsty));
1868     memset(s->properties, 0, sizeof(s->properties));
1869     memset(&s->poc  , 0, sizeof(s->poc));
1870     s->numXtiles = s->numYtiles = 0;
1871     s->ncomponents = 0;
1872 }
1873
1874 static int jpeg2000_read_main_headers(Jpeg2000DecoderContext *s)
1875 {
1876     Jpeg2000CodingStyle *codsty = s->codsty;
1877     Jpeg2000QuantStyle *qntsty  = s->qntsty;
1878     Jpeg2000POC         *poc    = &s->poc;
1879     uint8_t *properties         = s->properties;
1880
1881     for (;;) {
1882         int len, ret = 0;
1883         uint16_t marker;
1884         int oldpos;
1885
1886         if (bytestream2_get_bytes_left(&s->g) < 2) {
1887             av_log(s->avctx, AV_LOG_ERROR, "Missing EOC\n");
1888             break;
1889         }
1890
1891         marker = bytestream2_get_be16u(&s->g);
1892         oldpos = bytestream2_tell(&s->g);
1893
1894         if (marker == JPEG2000_SOD) {
1895             Jpeg2000Tile *tile;
1896             Jpeg2000TilePart *tp;
1897
1898             if (!s->tile) {
1899                 av_log(s->avctx, AV_LOG_ERROR, "Missing SIZ\n");
1900                 return AVERROR_INVALIDDATA;
1901             }
1902             if (s->curtileno < 0) {
1903                 av_log(s->avctx, AV_LOG_ERROR, "Missing SOT\n");
1904                 return AVERROR_INVALIDDATA;
1905             }
1906
1907             tile = s->tile + s->curtileno;
1908             tp = tile->tile_part + tile->tp_idx;
1909             if (tp->tp_end < s->g.buffer) {
1910                 av_log(s->avctx, AV_LOG_ERROR, "Invalid tpend\n");
1911                 return AVERROR_INVALIDDATA;
1912             }
1913             bytestream2_init(&tp->tpg, s->g.buffer, tp->tp_end - s->g.buffer);
1914             bytestream2_skip(&s->g, tp->tp_end - s->g.buffer);
1915
1916             continue;
1917         }
1918         if (marker == JPEG2000_EOC)
1919             break;
1920
1921         len = bytestream2_get_be16(&s->g);
1922         if (len < 2 || bytestream2_get_bytes_left(&s->g) < len - 2) {
1923             av_log(s->avctx, AV_LOG_ERROR, "Invalid len %d left=%d\n", len, bytestream2_get_bytes_left(&s->g));
1924             return AVERROR_INVALIDDATA;
1925         }
1926
1927         switch (marker) {
1928         case JPEG2000_SIZ:
1929             if (s->ncomponents) {
1930                 av_log(s->avctx, AV_LOG_ERROR, "Duplicate SIZ\n");
1931                 return AVERROR_INVALIDDATA;
1932             }
1933             ret = get_siz(s);
1934             if (!s->tile)
1935                 s->numXtiles = s->numYtiles = 0;
1936             break;
1937         case JPEG2000_COC:
1938             ret = get_coc(s, codsty, properties);
1939             break;
1940         case JPEG2000_COD:
1941             ret = get_cod(s, codsty, properties);
1942             break;
1943         case JPEG2000_QCC:
1944             ret = get_qcc(s, len, qntsty, properties);
1945             break;
1946         case JPEG2000_QCD:
1947             ret = get_qcd(s, len, qntsty, properties);
1948             break;
1949         case JPEG2000_POC:
1950             ret = get_poc(s, len, poc);
1951             break;
1952         case JPEG2000_SOT:
1953             if (!(ret = get_sot(s, len))) {
1954                 av_assert1(s->curtileno >= 0);
1955                 codsty = s->tile[s->curtileno].codsty;
1956                 qntsty = s->tile[s->curtileno].qntsty;
1957                 poc    = &s->tile[s->curtileno].poc;
1958                 properties = s->tile[s->curtileno].properties;
1959             }
1960             break;
1961         case JPEG2000_PLM:
1962             // the PLM marker is ignored
1963         case JPEG2000_COM:
1964             // the comment is ignored
1965             bytestream2_skip(&s->g, len - 2);
1966             break;
1967         case JPEG2000_TLM:
1968             // Tile-part lengths
1969             ret = get_tlm(s, len);
1970             break;
1971         case JPEG2000_PLT:
1972             // Packet length, tile-part header
1973             ret = get_plt(s, len);
1974             break;
1975         default:
1976             av_log(s->avctx, AV_LOG_ERROR,
1977                    "unsupported marker 0x%.4"PRIX16" at pos 0x%X\n",
1978                    marker, bytestream2_tell(&s->g) - 4);
1979             bytestream2_skip(&s->g, len - 2);
1980             break;
1981         }
1982         if (bytestream2_tell(&s->g) - oldpos != len || ret) {
1983             av_log(s->avctx, AV_LOG_ERROR,
1984                    "error during processing marker segment %.4"PRIx16"\n",
1985                    marker);
1986             return ret ? ret : -1;
1987         }
1988     }
1989     return 0;
1990 }
1991
1992 /* Read bit stream packets --> T2 operation. */
1993 static int jpeg2000_read_bitstream_packets(Jpeg2000DecoderContext *s)
1994 {
1995     int ret = 0;
1996     int tileno;
1997
1998     for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++) {
1999         Jpeg2000Tile *tile = s->tile + tileno;
2000
2001         if ((ret = init_tile(s, tileno)) < 0)
2002             return ret;
2003
2004         s->g = tile->tile_part[0].tpg;
2005         if ((ret = jpeg2000_decode_packets(s, tile)) < 0)
2006             return ret;
2007     }
2008
2009     return 0;
2010 }
2011
2012 static int jp2_find_codestream(Jpeg2000DecoderContext *s)
2013 {
2014     uint32_t atom_size, atom, atom_end;
2015     int search_range = 10;
2016
2017     while (search_range
2018            &&
2019            bytestream2_get_bytes_left(&s->g) >= 8) {
2020         atom_size = bytestream2_get_be32u(&s->g);
2021         atom      = bytestream2_get_be32u(&s->g);
2022         if (atom_size == 1) {
2023             if (bytestream2_get_be32u(&s->g)) {
2024                 avpriv_request_sample(s->avctx, "Huge atom");
2025                 return 0;
2026             }
2027             atom_size = bytestream2_get_be32u(&s->g);
2028             atom_end  = bytestream2_tell(&s->g) + atom_size - 16;
2029         } else {
2030             atom_end  = bytestream2_tell(&s->g) + atom_size -  8;
2031         }
2032
2033         if (atom == JP2_CODESTREAM)
2034             return 1;
2035
2036         if (bytestream2_get_bytes_left(&s->g) < atom_size || atom_end < atom_size)
2037             return 0;
2038
2039         if (atom == JP2_HEADER &&
2040                    atom_size >= 16) {
2041             uint32_t atom2_size, atom2, atom2_end;
2042             do {
2043                 atom2_size = bytestream2_get_be32u(&s->g);
2044                 atom2      = bytestream2_get_be32u(&s->g);
2045                 atom2_end  = bytestream2_tell(&s->g) + atom2_size - 8;
2046                 if (atom2_size < 8 || atom2_end > atom_end || atom2_end < atom2_size)
2047                     break;
2048                 atom2_size -= 8;
2049                 if (atom2 == JP2_CODESTREAM) {
2050                     return 1;
2051                 } else if (atom2 == MKBETAG('c','o','l','r') && atom2_size >= 7) {
2052                     int method = bytestream2_get_byteu(&s->g);
2053                     bytestream2_skipu(&s->g, 2);
2054                     if (method == 1) {
2055                         s->colour_space = bytestream2_get_be32u(&s->g);
2056                     }
2057                 } else if (atom2 == MKBETAG('p','c','l','r') && atom2_size >= 6) {
2058                     int i, size, colour_count, colour_channels, colour_depth[3];
2059                     colour_count = bytestream2_get_be16u(&s->g);
2060                     colour_channels = bytestream2_get_byteu(&s->g);
2061                     // FIXME: Do not ignore channel_sign
2062                     colour_depth[0] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1;
2063                     colour_depth[1] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1;
2064                     colour_depth[2] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1;
2065                     size = (colour_depth[0] + 7 >> 3) * colour_count +
2066                            (colour_depth[1] + 7 >> 3) * colour_count +
2067                            (colour_depth[2] + 7 >> 3) * colour_count;
2068                     if (colour_count > AVPALETTE_COUNT ||
2069                         colour_channels != 3 ||
2070                         colour_depth[0] > 16 ||
2071                         colour_depth[1] > 16 ||
2072                         colour_depth[2] > 16 ||
2073                         atom2_size < size) {
2074                         avpriv_request_sample(s->avctx, "Unknown palette");
2075                         bytestream2_seek(&s->g, atom2_end, SEEK_SET);
2076                         continue;
2077                     }
2078                     s->pal8 = 1;
2079                     for (i = 0; i < colour_count; i++) {
2080                         uint32_t r, g, b;
2081                         if (colour_depth[0] <= 8) {
2082                             r = bytestream2_get_byteu(&s->g) << 8 - colour_depth[0];
2083                             r |= r >> colour_depth[0];
2084                         } else {
2085                             r = bytestream2_get_be16u(&s->g) >> colour_depth[0] - 8;
2086                         }
2087                         if (colour_depth[1] <= 8) {
2088                             g = bytestream2_get_byteu(&s->g) << 8 - colour_depth[1];
2089                             g |= g >> colour_depth[1];
2090                         } else {
2091                             g = bytestream2_get_be16u(&s->g) >> colour_depth[1] - 8;
2092                         }
2093                         if (colour_depth[2] <= 8) {
2094                             b = bytestream2_get_byteu(&s->g) << 8 - colour_depth[2];
2095                             b |= b >> colour_depth[2];
2096                         } else {
2097                             b = bytestream2_get_be16u(&s->g) >> colour_depth[2] - 8;
2098                         }
2099                         s->palette[i] = 0xffu << 24 | r << 16 | g << 8 | b;
2100                     }
2101                 } else if (atom2 == MKBETAG('c','d','e','f') && atom2_size >= 2) {
2102                     int n = bytestream2_get_be16u(&s->g);
2103                     for (; n>0; n--) {
2104                         int cn   = bytestream2_get_be16(&s->g);
2105                         int av_unused typ  = bytestream2_get_be16(&s->g);
2106                         int asoc = bytestream2_get_be16(&s->g);
2107                         if (cn < 4 && asoc < 4)
2108                             s->cdef[cn] = asoc;
2109                     }
2110                 } else if (atom2 == MKBETAG('r','e','s',' ') && atom2_size >= 18) {
2111                     int64_t vnum, vden, hnum, hden, vexp, hexp;
2112                     uint32_t resx;
2113                     bytestream2_skip(&s->g, 4);
2114                     resx = bytestream2_get_be32u(&s->g);
2115                     if (resx != MKBETAG('r','e','s','c') && resx != MKBETAG('r','e','s','d')) {
2116                         bytestream2_seek(&s->g, atom2_end, SEEK_SET);
2117                         continue;
2118                     }
2119                     vnum = bytestream2_get_be16u(&s->g);
2120                     vden = bytestream2_get_be16u(&s->g);
2121                     hnum = bytestream2_get_be16u(&s->g);
2122                     hden = bytestream2_get_be16u(&s->g);
2123                     vexp = bytestream2_get_byteu(&s->g);
2124                     hexp = bytestream2_get_byteu(&s->g);
2125                     if (!vnum || !vden || !hnum || !hden) {
2126                         bytestream2_seek(&s->g, atom2_end, SEEK_SET);
2127                         av_log(s->avctx, AV_LOG_WARNING, "RES box invalid\n");
2128                         continue;
2129                     }
2130                     if (vexp > hexp) {
2131                         vexp -= hexp;
2132                         hexp = 0;
2133                     } else {
2134                         hexp -= vexp;
2135                         vexp = 0;
2136                     }
2137                     if (   INT64_MAX / (hnum * vden) > pow(10, hexp)
2138                         && INT64_MAX / (vnum * hden) > pow(10, vexp))
2139                         av_reduce(&s->sar.den, &s->sar.num,
2140                                   hnum * vden * pow(10, hexp),
2141                                   vnum * hden * pow(10, vexp),
2142                                   INT32_MAX);
2143                 }
2144                 bytestream2_seek(&s->g, atom2_end, SEEK_SET);
2145             } while (atom_end - atom2_end >= 8);
2146         } else {
2147             search_range--;
2148         }
2149         bytestream2_seek(&s->g, atom_end, SEEK_SET);
2150     }
2151
2152     return 0;
2153 }
2154
2155 static av_cold void jpeg2000_init_static_data(void)
2156 {
2157     ff_jpeg2000_init_tier1_luts();
2158     ff_mqc_init_context_tables();
2159 }
2160
2161 static av_cold int jpeg2000_decode_init(AVCodecContext *avctx)
2162 {
2163     static AVOnce init_static_once = AV_ONCE_INIT;
2164     Jpeg2000DecoderContext *s = avctx->priv_data;
2165
2166     ff_thread_once(&init_static_once, jpeg2000_init_static_data);
2167     ff_jpeg2000dsp_init(&s->dsp);
2168
2169     return 0;
2170 }
2171
2172 static int jpeg2000_decode_frame(AVCodecContext *avctx, void *data,
2173                                  int *got_frame, AVPacket *avpkt)
2174 {
2175     Jpeg2000DecoderContext *s = avctx->priv_data;
2176     ThreadFrame frame = { .f = data };
2177     AVFrame *picture = data;
2178     int ret;
2179
2180     s->avctx     = avctx;
2181     bytestream2_init(&s->g, avpkt->data, avpkt->size);
2182     s->curtileno = -1;
2183     memset(s->cdef, -1, sizeof(s->cdef));
2184
2185     if (bytestream2_get_bytes_left(&s->g) < 2) {
2186         ret = AVERROR_INVALIDDATA;
2187         goto end;
2188     }
2189
2190     // check if the image is in jp2 format
2191     if (bytestream2_get_bytes_left(&s->g) >= 12 &&
2192        (bytestream2_get_be32u(&s->g) == 12) &&
2193        (bytestream2_get_be32u(&s->g) == JP2_SIG_TYPE) &&
2194        (bytestream2_get_be32u(&s->g) == JP2_SIG_VALUE)) {
2195         if (!jp2_find_codestream(s)) {
2196             av_log(avctx, AV_LOG_ERROR,
2197                    "Could not find Jpeg2000 codestream atom.\n");
2198             ret = AVERROR_INVALIDDATA;
2199             goto end;
2200         }
2201     } else {
2202         bytestream2_seek(&s->g, 0, SEEK_SET);
2203     }
2204
2205     while (bytestream2_get_bytes_left(&s->g) >= 3 && bytestream2_peek_be16(&s->g) != JPEG2000_SOC)
2206         bytestream2_skip(&s->g, 1);
2207
2208     if (bytestream2_get_be16u(&s->g) != JPEG2000_SOC) {
2209         av_log(avctx, AV_LOG_ERROR, "SOC marker not present\n");
2210         ret = AVERROR_INVALIDDATA;
2211         goto end;
2212     }
2213     if (ret = jpeg2000_read_main_headers(s))
2214         goto end;
2215
2216     /* get picture buffer */
2217     if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
2218         goto end;
2219     picture->pict_type = AV_PICTURE_TYPE_I;
2220     picture->key_frame = 1;
2221
2222     if (ret = jpeg2000_read_bitstream_packets(s))
2223         goto end;
2224
2225     avctx->execute2(avctx, jpeg2000_decode_tile, picture, NULL, s->numXtiles * s->numYtiles);
2226
2227     jpeg2000_dec_cleanup(s);
2228
2229     *got_frame = 1;
2230
2231     if (s->avctx->pix_fmt == AV_PIX_FMT_PAL8)
2232         memcpy(picture->data[1], s->palette, 256 * sizeof(uint32_t));
2233     if (s->sar.num && s->sar.den)
2234         avctx->sample_aspect_ratio = s->sar;
2235     s->sar.num = s->sar.den = 0;
2236
2237     return bytestream2_tell(&s->g);
2238
2239 end:
2240     jpeg2000_dec_cleanup(s);
2241     return ret;
2242 }
2243
2244 #define OFFSET(x) offsetof(Jpeg2000DecoderContext, x)
2245 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
2246
2247 static const AVOption options[] = {
2248     { "lowres",  "Lower the decoding resolution by a power of two",
2249         OFFSET(reduction_factor), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, JPEG2000_MAX_RESLEVELS - 1, VD },
2250     { NULL },
2251 };
2252
2253 static const AVClass jpeg2000_class = {
2254     .class_name = "jpeg2000",
2255     .item_name  = av_default_item_name,
2256     .option     = options,
2257     .version    = LIBAVUTIL_VERSION_INT,
2258 };
2259
2260 AVCodec ff_jpeg2000_decoder = {
2261     .name             = "jpeg2000",
2262     .long_name        = NULL_IF_CONFIG_SMALL("JPEG 2000"),
2263     .type             = AVMEDIA_TYPE_VIDEO,
2264     .id               = AV_CODEC_ID_JPEG2000,
2265     .capabilities     = AV_CODEC_CAP_SLICE_THREADS | AV_CODEC_CAP_FRAME_THREADS | AV_CODEC_CAP_DR1,
2266     .priv_data_size   = sizeof(Jpeg2000DecoderContext),
2267     .init             = jpeg2000_decode_init,
2268     .decode           = jpeg2000_decode_frame,
2269     .priv_class       = &jpeg2000_class,
2270     .max_lowres       = 5,
2271     .profiles         = NULL_IF_CONFIG_SMALL(ff_jpeg2000_profiles)
2272 };