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