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