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