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