a4f5c8c23c19c41f95cb67419fee5045751e1ec0
[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 (!(ret = get_bits(s, 1))) {
816         jpeg2000_flush(s);
817         return 0;
818     } else if (ret < 0)
819         return ret;
820
821     for (bandno = 0; bandno < rlevel->nbands; bandno++) {
822         Jpeg2000Band *band = rlevel->band + bandno;
823         Jpeg2000Prec *prec = band->prec + precno;
824
825         if (band->coord[0][0] == band->coord[0][1] ||
826             band->coord[1][0] == band->coord[1][1])
827             continue;
828         nb_code_blocks =  prec->nb_codeblocks_height *
829                           prec->nb_codeblocks_width;
830         for (cblkno = 0; cblkno < nb_code_blocks; cblkno++) {
831             Jpeg2000Cblk *cblk = prec->cblk + cblkno;
832             int incl, newpasses, llen;
833
834             if (cblk->npasses)
835                 incl = get_bits(s, 1);
836             else
837                 incl = tag_tree_decode(s, prec->cblkincl + cblkno, layno + 1) == layno;
838             if (!incl)
839                 continue;
840             else if (incl < 0)
841                 return incl;
842
843             if (!cblk->npasses) {
844                 int v = expn[bandno] + numgbits - 1 -
845                         tag_tree_decode(s, prec->zerobits + cblkno, 100);
846                 if (v < 0) {
847                     av_log(s->avctx, AV_LOG_ERROR,
848                            "nonzerobits %d invalid\n", v);
849                     return AVERROR_INVALIDDATA;
850                 }
851                 cblk->nonzerobits = v;
852             }
853             if ((newpasses = getnpasses(s)) < 0)
854                 return newpasses;
855             av_assert2(newpasses > 0);
856             if (cblk->npasses + newpasses >= JPEG2000_MAX_PASSES) {
857                 avpriv_request_sample(s->avctx, "Too many passes\n");
858                 return AVERROR_PATCHWELCOME;
859             }
860             if ((llen = getlblockinc(s)) < 0)
861                 return llen;
862             if (cblk->lblock + llen + av_log2(newpasses) > 16) {
863                 avpriv_request_sample(s->avctx,
864                                       "Block with length beyond 16 bits\n");
865                 return AVERROR_PATCHWELCOME;
866             }
867
868             cblk->lblock += llen;
869
870             cblk->nb_lengthinc = 0;
871             cblk->nb_terminationsinc = 0;
872             do {
873                 int newpasses1 = 0;
874
875                 while (newpasses1 < newpasses) {
876                     newpasses1 ++;
877                     if (needs_termination(codsty->cblk_style, cblk->npasses + newpasses1 - 1)) {
878                         cblk->nb_terminationsinc ++;
879                         break;
880                     }
881                 }
882
883                 if ((ret = get_bits(s, av_log2(newpasses1) + cblk->lblock)) < 0)
884                     return ret;
885                 if (ret > sizeof(cblk->data)) {
886                     avpriv_request_sample(s->avctx,
887                                         "Block with lengthinc greater than %"SIZE_SPECIFIER"",
888                                         sizeof(cblk->data));
889                     return AVERROR_PATCHWELCOME;
890                 }
891                 cblk->lengthinc[cblk->nb_lengthinc++] = ret;
892                 cblk->npasses  += newpasses1;
893                 newpasses -= newpasses1;
894             } while(newpasses);
895         }
896     }
897     jpeg2000_flush(s);
898
899     if (codsty->csty & JPEG2000_CSTY_EPH) {
900         if (bytestream2_peek_be16(&s->g) == JPEG2000_EPH)
901             bytestream2_skip(&s->g, 2);
902         else
903             av_log(s->avctx, AV_LOG_ERROR, "EPH marker not found.\n");
904     }
905
906     for (bandno = 0; bandno < rlevel->nbands; bandno++) {
907         Jpeg2000Band *band = rlevel->band + bandno;
908         Jpeg2000Prec *prec = band->prec + precno;
909
910         nb_code_blocks = prec->nb_codeblocks_height * prec->nb_codeblocks_width;
911         for (cblkno = 0; cblkno < nb_code_blocks; cblkno++) {
912             Jpeg2000Cblk *cblk = prec->cblk + cblkno;
913             for (cwsno = 0; cwsno < cblk->nb_lengthinc; cwsno ++) {
914                 if (   bytestream2_get_bytes_left(&s->g) < cblk->lengthinc[cwsno]
915                     || sizeof(cblk->data) < cblk->length + cblk->lengthinc[cwsno] + 4
916                 ) {
917                     av_log(s->avctx, AV_LOG_ERROR,
918                         "Block length %"PRIu16" or lengthinc %d is too large, left %d\n",
919                         cblk->length, cblk->lengthinc[cwsno], bytestream2_get_bytes_left(&s->g));
920                     return AVERROR_INVALIDDATA;
921                 }
922
923                 bytestream2_get_bufferu(&s->g, cblk->data + cblk->length, cblk->lengthinc[cwsno]);
924                 cblk->length   += cblk->lengthinc[cwsno];
925                 cblk->lengthinc[cwsno] = 0;
926                 if (cblk->nb_terminationsinc) {
927                     cblk->nb_terminationsinc--;
928                     cblk->nb_terminations++;
929                     cblk->data[cblk->length++] = 0xFF;
930                     cblk->data[cblk->length++] = 0xFF;
931                     cblk->data_start[cblk->nb_terminations] = cblk->length;
932                 }
933             }
934         }
935     }
936     return 0;
937 }
938
939 static int jpeg2000_decode_packets(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
940 {
941     int ret = 0;
942     int layno, reslevelno, compno, precno, ok_reslevel;
943     int x, y;
944     int tp_index = 0;
945     int step_x, step_y;
946
947     s->bit_index = 8;
948     switch (tile->codsty[0].prog_order) {
949     case JPEG2000_PGOD_RLCP:
950         av_log(s->avctx, AV_LOG_DEBUG, "Progression order RLCP\n");
951         ok_reslevel = 1;
952         for (reslevelno = 0; ok_reslevel; reslevelno++) {
953             ok_reslevel = 0;
954             for (layno = 0; layno < tile->codsty[0].nlayers; layno++) {
955                 for (compno = 0; compno < s->ncomponents; compno++) {
956                     Jpeg2000CodingStyle *codsty = tile->codsty + compno;
957                     Jpeg2000QuantStyle *qntsty  = tile->qntsty + compno;
958                     if (reslevelno < codsty->nreslevels) {
959                         Jpeg2000ResLevel *rlevel = tile->comp[compno].reslevel +
960                                                 reslevelno;
961                         ok_reslevel = 1;
962                         for (precno = 0; precno < rlevel->num_precincts_x * rlevel->num_precincts_y; precno++)
963                             if ((ret = jpeg2000_decode_packet(s, tile, &tp_index,
964                                                               codsty, rlevel,
965                                                               precno, layno,
966                                                               qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
967                                                               qntsty->nguardbits)) < 0)
968                                 return ret;
969                     }
970                 }
971             }
972         }
973         break;
974
975     case JPEG2000_PGOD_LRCP:
976         av_log(s->avctx, AV_LOG_DEBUG, "Progression order LRCP\n");
977         for (layno = 0; layno < tile->codsty[0].nlayers; layno++) {
978             ok_reslevel = 1;
979             for (reslevelno = 0; ok_reslevel; reslevelno++) {
980                 ok_reslevel = 0;
981                 for (compno = 0; compno < s->ncomponents; compno++) {
982                     Jpeg2000CodingStyle *codsty = tile->codsty + compno;
983                     Jpeg2000QuantStyle *qntsty  = tile->qntsty + compno;
984                     if (reslevelno < codsty->nreslevels) {
985                         Jpeg2000ResLevel *rlevel = tile->comp[compno].reslevel +
986                                                 reslevelno;
987                         ok_reslevel = 1;
988                         for (precno = 0; precno < rlevel->num_precincts_x * rlevel->num_precincts_y; precno++)
989                             if ((ret = jpeg2000_decode_packet(s, tile, &tp_index,
990                                                               codsty, rlevel,
991                                                               precno, layno,
992                                                               qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
993                                                               qntsty->nguardbits)) < 0)
994                                 return ret;
995                     }
996                 }
997             }
998         }
999         break;
1000
1001     case JPEG2000_PGOD_CPRL:
1002         av_log(s->avctx, AV_LOG_DEBUG, "Progression order CPRL\n");
1003         for (compno = 0; compno < s->ncomponents; compno++) {
1004             Jpeg2000Component *comp     = tile->comp + compno;
1005             Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1006             Jpeg2000QuantStyle *qntsty  = tile->qntsty + compno;
1007             int maxlogstep_x = 0;
1008             int maxlogstep_y = 0;
1009             int start_x, start_y;
1010             step_x = 32;
1011             step_y = 32;
1012
1013             for (reslevelno = 0; reslevelno < codsty->nreslevels; reslevelno++) {
1014                 uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; //  ==> N_L - r
1015                 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1016                 step_x = FFMIN(step_x, rlevel->log2_prec_width  + reducedresno);
1017                 step_y = FFMIN(step_y, rlevel->log2_prec_height + reducedresno);
1018                 maxlogstep_x = FFMAX(maxlogstep_x, rlevel->log2_prec_width  + reducedresno);
1019                 maxlogstep_y = FFMAX(maxlogstep_y, rlevel->log2_prec_height + reducedresno);
1020             }
1021             step_x = 1<<step_x;
1022             step_y = 1<<step_y;
1023
1024             start_y = comp->coord_o[1][0] >> maxlogstep_y << maxlogstep_y;
1025             start_x = comp->coord_o[0][0] >> maxlogstep_x << maxlogstep_x;
1026             for (y = start_y; y < comp->coord_o[1][1]; y += step_y) {
1027                 for (x = start_x; x < comp->coord_o[0][1]; x += step_x) {
1028                     for (reslevelno = 0; reslevelno < codsty->nreslevels; reslevelno++) {
1029                         unsigned prcx, prcy;
1030                         uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; //  ==> N_L - r
1031                         Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1032
1033                         if (y % (1 << (rlevel->log2_prec_height + reducedresno)))
1034                             continue;
1035
1036                         if (x % (1 << (rlevel->log2_prec_width + reducedresno)))
1037                             continue;
1038
1039                         // check if a precinct exists
1040                         prcx   = ff_jpeg2000_ceildivpow2(x, reducedresno) >> rlevel->log2_prec_width;
1041                         prcy   = ff_jpeg2000_ceildivpow2(y, reducedresno) >> rlevel->log2_prec_height;
1042                         prcx  -= ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], reducedresno) >> rlevel->log2_prec_width;
1043                         prcy  -= ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], reducedresno) >> rlevel->log2_prec_height;
1044
1045                         precno = prcx + rlevel->num_precincts_x * prcy;
1046
1047                         if (prcx >= rlevel->num_precincts_x || prcy >= rlevel->num_precincts_y) {
1048                             av_log(s->avctx, AV_LOG_WARNING, "prc %d %d outside limits %d %d\n",
1049                                    prcx, prcy, rlevel->num_precincts_x, rlevel->num_precincts_y);
1050                             continue;
1051                         }
1052
1053                         for (layno = 0; layno < tile->codsty[0].nlayers; layno++) {
1054                             if ((ret = jpeg2000_decode_packet(s, tile, &tp_index, codsty, rlevel,
1055                                                               precno, layno,
1056                                                               qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1057                                                               qntsty->nguardbits)) < 0)
1058                                 return ret;
1059                         }
1060                     }
1061                 }
1062             }
1063         }
1064         break;
1065
1066     case JPEG2000_PGOD_RPCL:
1067         av_log(s->avctx, AV_LOG_WARNING, "Progression order RPCL\n");
1068         ok_reslevel = 1;
1069         for (reslevelno = 0; ok_reslevel; reslevelno++) {
1070             ok_reslevel = 0;
1071
1072             step_x = 32;
1073             step_y = 32;
1074             for (compno = 0; compno < s->ncomponents; compno++) {
1075                 Jpeg2000Component *comp     = tile->comp + compno;
1076                 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1077
1078                 if (reslevelno < codsty->nreslevels) {
1079                     uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; //  ==> N_L - r
1080                     Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1081                     step_x = FFMIN(step_x, rlevel->log2_prec_width  + reducedresno);
1082                     step_y = FFMIN(step_y, rlevel->log2_prec_height + reducedresno);
1083                 }
1084             }
1085             step_x = 1<<step_x;
1086             step_y = 1<<step_y;
1087
1088             //FIXME we could iterate over less than the whole image
1089             for (y = 0; y < s->height; y += step_y) {
1090                 for (x = 0; x < s->width; x += step_x) {
1091                     for (compno = 0; compno < s->ncomponents; compno++) {
1092                         Jpeg2000Component *comp     = tile->comp + compno;
1093                         Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1094                         Jpeg2000QuantStyle *qntsty  = tile->qntsty + compno;
1095                         uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; //  ==> N_L - r
1096                         Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1097                         unsigned prcx, prcy;
1098
1099                         int xc = x / s->cdx[compno];
1100                         int yc = y / s->cdy[compno];
1101
1102                         if (yc % (1 << (rlevel->log2_prec_height + reducedresno)))
1103                             continue;
1104
1105                         if (xc % (1 << (rlevel->log2_prec_width + reducedresno)))
1106                             continue;
1107
1108                         // check if a precinct exists
1109                         prcx   = ff_jpeg2000_ceildivpow2(xc, reducedresno) >> rlevel->log2_prec_width;
1110                         prcy   = ff_jpeg2000_ceildivpow2(yc, reducedresno) >> rlevel->log2_prec_height;
1111                         prcx  -= ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], reducedresno) >> rlevel->log2_prec_width;
1112                         prcy  -= ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], reducedresno) >> rlevel->log2_prec_height;
1113
1114                         precno = prcx + rlevel->num_precincts_x * prcy;
1115
1116                         if (prcx >= rlevel->num_precincts_x || prcy >= rlevel->num_precincts_y) {
1117                             av_log(s->avctx, AV_LOG_WARNING, "prc %d %d outside limits %d %d\n",
1118                                    prcx, prcy, rlevel->num_precincts_x, rlevel->num_precincts_y);
1119                             continue;
1120                         }
1121
1122                         if (reslevelno < codsty->nreslevels) {
1123                             Jpeg2000ResLevel *rlevel = tile->comp[compno].reslevel +
1124                                                     reslevelno;
1125                             ok_reslevel = 1;
1126                             for (layno = 0; layno < tile->codsty[0].nlayers; layno++) {
1127                                 if ((ret = jpeg2000_decode_packet(s, tile, &tp_index,
1128                                                                 codsty, rlevel,
1129                                                                 precno, layno,
1130                                                                 qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1131                                                                 qntsty->nguardbits)) < 0)
1132                                     return ret;
1133                             }
1134                         }
1135                     }
1136                 }
1137             }
1138         }
1139         break;
1140
1141     case JPEG2000_PGOD_PCRL:
1142         av_log(s->avctx, AV_LOG_WARNING, "Progression order PCRL");
1143         step_x = 32;
1144         step_y = 32;
1145         for (compno = 0; compno < s->ncomponents; compno++) {
1146             Jpeg2000Component *comp     = tile->comp + compno;
1147             Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1148             Jpeg2000QuantStyle *qntsty  = tile->qntsty + compno;
1149
1150             for (reslevelno = 0; reslevelno < codsty->nreslevels; reslevelno++) {
1151                 uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; //  ==> N_L - r
1152                 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1153                 step_x = FFMIN(step_x, rlevel->log2_prec_width  + reducedresno);
1154                 step_y = FFMIN(step_y, rlevel->log2_prec_height + reducedresno);
1155             }
1156         }
1157         step_x = 1<<step_x;
1158         step_y = 1<<step_y;
1159
1160         //FIXME we could iterate over less than the whole image
1161         for (y = 0; y < s->height; y += step_y) {
1162             for (x = 0; x < s->width; x += step_x) {
1163                 for (compno = 0; compno < s->ncomponents; compno++) {
1164                     Jpeg2000Component *comp     = tile->comp + compno;
1165                     Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1166                     Jpeg2000QuantStyle *qntsty  = tile->qntsty + compno;
1167                     int xc = x / s->cdx[compno];
1168                     int yc = y / s->cdy[compno];
1169
1170                     for (reslevelno = 0; reslevelno < codsty->nreslevels; reslevelno++) {
1171                         unsigned prcx, prcy;
1172                         uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; //  ==> N_L - r
1173                         Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1174
1175                         if (yc % (1 << (rlevel->log2_prec_height + reducedresno)))
1176                             continue;
1177
1178                         if (xc % (1 << (rlevel->log2_prec_width + reducedresno)))
1179                             continue;
1180
1181                         // check if a precinct exists
1182                         prcx   = ff_jpeg2000_ceildivpow2(xc, reducedresno) >> rlevel->log2_prec_width;
1183                         prcy   = ff_jpeg2000_ceildivpow2(yc, reducedresno) >> rlevel->log2_prec_height;
1184                         prcx  -= ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], reducedresno) >> rlevel->log2_prec_width;
1185                         prcy  -= ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], reducedresno) >> rlevel->log2_prec_height;
1186
1187                         precno = prcx + rlevel->num_precincts_x * prcy;
1188
1189                         if (prcx >= rlevel->num_precincts_x || prcy >= rlevel->num_precincts_y) {
1190                             av_log(s->avctx, AV_LOG_WARNING, "prc %d %d outside limits %d %d\n",
1191                                    prcx, prcy, rlevel->num_precincts_x, rlevel->num_precincts_y);
1192                             continue;
1193                         }
1194
1195                         for (layno = 0; layno < tile->codsty[0].nlayers; layno++) {
1196                             if ((ret = jpeg2000_decode_packet(s, tile, &tp_index, codsty, rlevel,
1197                                                               precno, layno,
1198                                                               qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1199                                                               qntsty->nguardbits)) < 0)
1200                                 return ret;
1201                         }
1202                     }
1203                 }
1204             }
1205         }
1206         break;
1207
1208     default:
1209         break;
1210     }
1211
1212     /* EOC marker reached */
1213     bytestream2_skip(&s->g, 2);
1214
1215     return ret;
1216 }
1217
1218 /* TIER-1 routines */
1219 static void decode_sigpass(Jpeg2000T1Context *t1, int width, int height,
1220                            int bpno, int bandno,
1221                            int vert_causal_ctx_csty_symbol)
1222 {
1223     int mask = 3 << (bpno - 1), y0, x, y;
1224
1225     for (y0 = 0; y0 < height; y0 += 4)
1226         for (x = 0; x < width; x++)
1227             for (y = y0; y < height && y < y0 + 4; y++) {
1228                 if ((t1->flags[y+1][x+1] & JPEG2000_T1_SIG_NB)
1229                 && !(t1->flags[y+1][x+1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS))) {
1230                     int flags_mask = -1;
1231                     if (vert_causal_ctx_csty_symbol && y == y0 + 3)
1232                         flags_mask &= ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE);
1233                     if (ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ff_jpeg2000_getsigctxno(t1->flags[y+1][x+1] & flags_mask, bandno))) {
1234                         int xorbit, ctxno = ff_jpeg2000_getsgnctxno(t1->flags[y+1][x+1], &xorbit);
1235                         if (t1->mqc.raw)
1236                              t1->data[y][x] = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ctxno) ? -mask : mask;
1237                         else
1238                              t1->data[y][x] = (ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ctxno) ^ xorbit) ?
1239                                                -mask : mask;
1240
1241                         ff_jpeg2000_set_significance(t1, x, y,
1242                                                      t1->data[y][x] < 0);
1243                     }
1244                     t1->flags[y + 1][x + 1] |= JPEG2000_T1_VIS;
1245                 }
1246             }
1247 }
1248
1249 static void decode_refpass(Jpeg2000T1Context *t1, int width, int height,
1250                            int bpno)
1251 {
1252     int phalf, nhalf;
1253     int y0, x, y;
1254
1255     phalf = 1 << (bpno - 1);
1256     nhalf = -phalf;
1257
1258     for (y0 = 0; y0 < height; y0 += 4)
1259         for (x = 0; x < width; x++)
1260             for (y = y0; y < height && y < y0 + 4; y++)
1261                 if ((t1->flags[y + 1][x + 1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS)) == JPEG2000_T1_SIG) {
1262                     int ctxno = ff_jpeg2000_getrefctxno(t1->flags[y + 1][x + 1]);
1263                     int r     = ff_mqc_decode(&t1->mqc,
1264                                               t1->mqc.cx_states + ctxno)
1265                                 ? phalf : nhalf;
1266                     t1->data[y][x]          += t1->data[y][x] < 0 ? -r : r;
1267                     t1->flags[y + 1][x + 1] |= JPEG2000_T1_REF;
1268                 }
1269 }
1270
1271 static void decode_clnpass(Jpeg2000DecoderContext *s, Jpeg2000T1Context *t1,
1272                            int width, int height, int bpno, int bandno,
1273                            int seg_symbols, int vert_causal_ctx_csty_symbol)
1274 {
1275     int mask = 3 << (bpno - 1), y0, x, y, runlen, dec;
1276
1277     for (y0 = 0; y0 < height; y0 += 4) {
1278         for (x = 0; x < width; x++) {
1279             if (y0 + 3 < height &&
1280                 !((t1->flags[y0 + 1][x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
1281                   (t1->flags[y0 + 2][x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
1282                   (t1->flags[y0 + 3][x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
1283                   (t1->flags[y0 + 4][x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)))) {
1284                 if (!ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_RL))
1285                     continue;
1286                 runlen = ff_mqc_decode(&t1->mqc,
1287                                        t1->mqc.cx_states + MQC_CX_UNI);
1288                 runlen = (runlen << 1) | ff_mqc_decode(&t1->mqc,
1289                                                        t1->mqc.cx_states +
1290                                                        MQC_CX_UNI);
1291                 dec = 1;
1292             } else {
1293                 runlen = 0;
1294                 dec    = 0;
1295             }
1296
1297             for (y = y0 + runlen; y < y0 + 4 && y < height; y++) {
1298                 if (!dec) {
1299                     if (!(t1->flags[y+1][x+1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS))) {
1300                         int flags_mask = -1;
1301                         if (vert_causal_ctx_csty_symbol && y == y0 + 3)
1302                             flags_mask &= ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE);
1303                         dec = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ff_jpeg2000_getsigctxno(t1->flags[y+1][x+1] & flags_mask,
1304                                                                                              bandno));
1305                     }
1306                 }
1307                 if (dec) {
1308                     int xorbit;
1309                     int ctxno = ff_jpeg2000_getsgnctxno(t1->flags[y + 1][x + 1],
1310                                                         &xorbit);
1311                     t1->data[y][x] = (ff_mqc_decode(&t1->mqc,
1312                                                     t1->mqc.cx_states + ctxno) ^
1313                                       xorbit)
1314                                      ? -mask : mask;
1315                     ff_jpeg2000_set_significance(t1, x, y, t1->data[y][x] < 0);
1316                 }
1317                 dec = 0;
1318                 t1->flags[y + 1][x + 1] &= ~JPEG2000_T1_VIS;
1319             }
1320         }
1321     }
1322     if (seg_symbols) {
1323         int val;
1324         val = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1325         val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1326         val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1327         val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1328         if (val != 0xa)
1329             av_log(s->avctx, AV_LOG_ERROR,
1330                    "Segmentation symbol value incorrect\n");
1331     }
1332 }
1333
1334 static int decode_cblk(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *codsty,
1335                        Jpeg2000T1Context *t1, Jpeg2000Cblk *cblk,
1336                        int width, int height, int bandpos)
1337 {
1338     int passno = cblk->npasses, pass_t = 2, bpno = cblk->nonzerobits - 1, y;
1339     int pass_cnt = 0;
1340     int vert_causal_ctx_csty_symbol = codsty->cblk_style & JPEG2000_CBLK_VSC;
1341     int term_cnt = 0;
1342     int coder_type;
1343
1344     av_assert0(width  <= JPEG2000_MAX_CBLKW);
1345     av_assert0(height <= JPEG2000_MAX_CBLKH);
1346
1347     for (y = 0; y < height; y++)
1348         memset(t1->data[y], 0, width * sizeof(**t1->data));
1349
1350     /* If code-block contains no compressed data: nothing to do. */
1351     if (!cblk->length)
1352         return 0;
1353
1354     for (y = 0; y < height + 2; y++)
1355         memset(t1->flags[y], 0, (width + 2) * sizeof(**t1->flags));
1356
1357     cblk->data[cblk->length] = 0xff;
1358     cblk->data[cblk->length+1] = 0xff;
1359     ff_mqc_initdec(&t1->mqc, cblk->data, 0, 1);
1360
1361     while (passno--) {
1362         switch(pass_t) {
1363         case 0:
1364             decode_sigpass(t1, width, height, bpno + 1, bandpos,
1365                            vert_causal_ctx_csty_symbol);
1366             break;
1367         case 1:
1368             decode_refpass(t1, width, height, bpno + 1);
1369             break;
1370         case 2:
1371             av_assert2(!t1->mqc.raw);
1372             decode_clnpass(s, t1, width, height, bpno + 1, bandpos,
1373                            codsty->cblk_style & JPEG2000_CBLK_SEGSYM,
1374                            vert_causal_ctx_csty_symbol);
1375             break;
1376         }
1377         if (codsty->cblk_style & JPEG2000_CBLK_RESET) // XXX no testcase for just this
1378             ff_mqc_init_contexts(&t1->mqc);
1379
1380         if ((coder_type = needs_termination(codsty->cblk_style, pass_cnt))) {
1381             if (term_cnt >= cblk->nb_terminations) {
1382                 av_log(s->avctx, AV_LOG_ERROR, "Missing needed termination \n");
1383                 return AVERROR_INVALIDDATA;
1384             }
1385             ff_mqc_initdec(&t1->mqc, cblk->data + cblk->data_start[++term_cnt], coder_type == 2, 0);
1386         }
1387
1388         pass_t++;
1389         if (pass_t == 3) {
1390             bpno--;
1391             pass_t = 0;
1392         }
1393         pass_cnt ++;
1394     }
1395
1396     if (cblk->data + cblk->length != t1->mqc.bp) {
1397         av_log(s->avctx, AV_LOG_WARNING, "End mismatch %"PTRDIFF_SPECIFIER"\n", cblk->data + cblk->length - t1->mqc.bp);
1398     }
1399
1400     return 0;
1401 }
1402
1403 /* TODO: Verify dequantization for lossless case
1404  * comp->data can be float or int
1405  * band->stepsize can be float or int
1406  * depending on the type of DWT transformation.
1407  * see ISO/IEC 15444-1:2002 A.6.1 */
1408
1409 /* Float dequantization of a codeblock.*/
1410 static void dequantization_float(int x, int y, Jpeg2000Cblk *cblk,
1411                                  Jpeg2000Component *comp,
1412                                  Jpeg2000T1Context *t1, Jpeg2000Band *band)
1413 {
1414     int i, j;
1415     int w = cblk->coord[0][1] - cblk->coord[0][0];
1416     for (j = 0; j < (cblk->coord[1][1] - cblk->coord[1][0]); ++j) {
1417         float *datap = &comp->f_data[(comp->coord[0][1] - comp->coord[0][0]) * (y + j) + x];
1418         int *src = t1->data[j];
1419         for (i = 0; i < w; ++i)
1420             datap[i] = src[i] * band->f_stepsize;
1421     }
1422 }
1423
1424 /* Integer dequantization of a codeblock.*/
1425 static void dequantization_int(int x, int y, Jpeg2000Cblk *cblk,
1426                                Jpeg2000Component *comp,
1427                                Jpeg2000T1Context *t1, Jpeg2000Band *band)
1428 {
1429     int i, j;
1430     int w = cblk->coord[0][1] - cblk->coord[0][0];
1431     for (j = 0; j < (cblk->coord[1][1] - cblk->coord[1][0]); ++j) {
1432         int32_t *datap = &comp->i_data[(comp->coord[0][1] - comp->coord[0][0]) * (y + j) + x];
1433         int *src = t1->data[j];
1434         for (i = 0; i < w; ++i)
1435             datap[i] = (src[i] * band->i_stepsize) / 32768;
1436     }
1437 }
1438
1439 static void dequantization_int_97(int x, int y, Jpeg2000Cblk *cblk,
1440                                Jpeg2000Component *comp,
1441                                Jpeg2000T1Context *t1, Jpeg2000Band *band)
1442 {
1443     int i, j;
1444     int w = cblk->coord[0][1] - cblk->coord[0][0];
1445     for (j = 0; j < (cblk->coord[1][1] - cblk->coord[1][0]); ++j) {
1446         int32_t *datap = &comp->i_data[(comp->coord[0][1] - comp->coord[0][0]) * (y + j) + x];
1447         int *src = t1->data[j];
1448         for (i = 0; i < w; ++i)
1449             datap[i] = (src[i] * band->i_stepsize + (1<<14)) >> 15;
1450     }
1451 }
1452
1453 static inline void mct_decode(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
1454 {
1455     int i, csize = 1;
1456     void *src[3];
1457
1458     for (i = 1; i < 3; i++) {
1459         if (tile->codsty[0].transform != tile->codsty[i].transform) {
1460             av_log(s->avctx, AV_LOG_ERROR, "Transforms mismatch, MCT not supported\n");
1461             return;
1462         }
1463         if (memcmp(tile->comp[0].coord, tile->comp[i].coord, sizeof(tile->comp[0].coord))) {
1464             av_log(s->avctx, AV_LOG_ERROR, "Coords mismatch, MCT not supported\n");
1465             return;
1466         }
1467     }
1468
1469     for (i = 0; i < 3; i++)
1470         if (tile->codsty[0].transform == FF_DWT97)
1471             src[i] = tile->comp[i].f_data;
1472         else
1473             src[i] = tile->comp[i].i_data;
1474
1475     for (i = 0; i < 2; i++)
1476         csize *= tile->comp[0].coord[i][1] - tile->comp[0].coord[i][0];
1477
1478     s->dsp.mct_decode[tile->codsty[0].transform](src[0], src[1], src[2], csize);
1479 }
1480
1481 static int jpeg2000_decode_tile(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile,
1482                                 AVFrame *picture)
1483 {
1484     const AVPixFmtDescriptor *pixdesc = av_pix_fmt_desc_get(s->avctx->pix_fmt);
1485     int compno, reslevelno, bandno;
1486     int x, y;
1487     int planar    = !!(pixdesc->flags & AV_PIX_FMT_FLAG_PLANAR);
1488     int pixelsize = planar ? 1 : pixdesc->nb_components;
1489
1490     uint8_t *line;
1491     Jpeg2000T1Context t1;
1492
1493     /* Loop on tile components */
1494     for (compno = 0; compno < s->ncomponents; compno++) {
1495         Jpeg2000Component *comp     = tile->comp + compno;
1496         Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1497
1498         /* Loop on resolution levels */
1499         for (reslevelno = 0; reslevelno < codsty->nreslevels2decode; reslevelno++) {
1500             Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1501             /* Loop on bands */
1502             for (bandno = 0; bandno < rlevel->nbands; bandno++) {
1503                 int nb_precincts, precno;
1504                 Jpeg2000Band *band = rlevel->band + bandno;
1505                 int cblkno = 0, bandpos;
1506
1507                 bandpos = bandno + (reslevelno > 0);
1508
1509                 if (band->coord[0][0] == band->coord[0][1] ||
1510                     band->coord[1][0] == band->coord[1][1])
1511                     continue;
1512
1513                 nb_precincts = rlevel->num_precincts_x * rlevel->num_precincts_y;
1514                 /* Loop on precincts */
1515                 for (precno = 0; precno < nb_precincts; precno++) {
1516                     Jpeg2000Prec *prec = band->prec + precno;
1517
1518                     /* Loop on codeblocks */
1519                     for (cblkno = 0; cblkno < prec->nb_codeblocks_width * prec->nb_codeblocks_height; cblkno++) {
1520                         int x, y;
1521                         Jpeg2000Cblk *cblk = prec->cblk + cblkno;
1522                         decode_cblk(s, codsty, &t1, cblk,
1523                                     cblk->coord[0][1] - cblk->coord[0][0],
1524                                     cblk->coord[1][1] - cblk->coord[1][0],
1525                                     bandpos);
1526
1527                         x = cblk->coord[0][0] - band->coord[0][0];
1528                         y = cblk->coord[1][0] - band->coord[1][0];
1529
1530                         if (codsty->transform == FF_DWT97)
1531                             dequantization_float(x, y, cblk, comp, &t1, band);
1532                         else if (codsty->transform == FF_DWT97_INT)
1533                             dequantization_int_97(x, y, cblk, comp, &t1, band);
1534                         else
1535                             dequantization_int(x, y, cblk, comp, &t1, band);
1536                    } /* end cblk */
1537                 } /*end prec */
1538             } /* end band */
1539         } /* end reslevel */
1540
1541         /* inverse DWT */
1542         ff_dwt_decode(&comp->dwt, codsty->transform == FF_DWT97 ? (void*)comp->f_data : (void*)comp->i_data);
1543     } /*end comp */
1544
1545     /* inverse MCT transformation */
1546     if (tile->codsty[0].mct)
1547         mct_decode(s, tile);
1548
1549     if (s->cdef[0] < 0) {
1550         for (x = 0; x < s->ncomponents; x++)
1551             s->cdef[x] = x + 1;
1552         if ((s->ncomponents & 1) == 0)
1553             s->cdef[s->ncomponents-1] = 0;
1554     }
1555
1556     if (s->precision <= 8) {
1557         for (compno = 0; compno < s->ncomponents; compno++) {
1558             Jpeg2000Component *comp = tile->comp + compno;
1559             Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1560             float *datap = comp->f_data;
1561             int32_t *i_datap = comp->i_data;
1562             int cbps = s->cbps[compno];
1563             int w = tile->comp[compno].coord[0][1] - s->image_offset_x;
1564             int plane = 0;
1565
1566             if (planar)
1567                 plane = s->cdef[compno] ? s->cdef[compno]-1 : (s->ncomponents-1);
1568
1569
1570             y    = tile->comp[compno].coord[1][0] - s->image_offset_y;
1571             line = picture->data[plane] + y / s->cdy[compno] * picture->linesize[plane];
1572             for (; y < tile->comp[compno].coord[1][1] - s->image_offset_y; y ++) {
1573                 uint8_t *dst;
1574
1575                 x   = tile->comp[compno].coord[0][0] - s->image_offset_x;
1576                 dst = line + x / s->cdx[compno] * pixelsize + compno*!planar;
1577
1578                 if (codsty->transform == FF_DWT97) {
1579                     for (; x < w; x ++) {
1580                         int val = lrintf(*datap) + (1 << (cbps - 1));
1581                         /* DC level shift and clip see ISO 15444-1:2002 G.1.2 */
1582                         val = av_clip(val, 0, (1 << cbps) - 1);
1583                         *dst = val << (8 - cbps);
1584                         datap++;
1585                         dst += pixelsize;
1586                     }
1587                 } else {
1588                     for (; x < w; x ++) {
1589                         int val = *i_datap + (1 << (cbps - 1));
1590                         /* DC level shift and clip see ISO 15444-1:2002 G.1.2 */
1591                         val = av_clip(val, 0, (1 << cbps) - 1);
1592                         *dst = val << (8 - cbps);
1593                         i_datap++;
1594                         dst += pixelsize;
1595                     }
1596                 }
1597                 line += picture->linesize[plane];
1598             }
1599         }
1600     } else {
1601         int precision = picture->format == AV_PIX_FMT_XYZ12 ||
1602                         picture->format == AV_PIX_FMT_RGB48 ||
1603                         picture->format == AV_PIX_FMT_RGBA64 ||
1604                         picture->format == AV_PIX_FMT_GRAY16 ? 16 : s->precision;
1605
1606         for (compno = 0; compno < s->ncomponents; compno++) {
1607             Jpeg2000Component *comp = tile->comp + compno;
1608             Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1609             float *datap = comp->f_data;
1610             int32_t *i_datap = comp->i_data;
1611             uint16_t *linel;
1612             int cbps = s->cbps[compno];
1613             int w = tile->comp[compno].coord[0][1] - s->image_offset_x;
1614             int plane = 0;
1615
1616             if (planar)
1617                 plane = s->cdef[compno] ? s->cdef[compno]-1 : (s->ncomponents-1);
1618
1619             y     = tile->comp[compno].coord[1][0] - s->image_offset_y;
1620             linel = (uint16_t *)picture->data[plane] + y / s->cdy[compno] * (picture->linesize[plane] >> 1);
1621             for (; y < tile->comp[compno].coord[1][1] - s->image_offset_y; y ++) {
1622                 uint16_t *dst;
1623
1624                 x   = tile->comp[compno].coord[0][0] - s->image_offset_x;
1625                 dst = linel + (x / s->cdx[compno] * pixelsize + compno*!planar);
1626                 if (codsty->transform == FF_DWT97) {
1627                     for (; x < w; x ++) {
1628                         int  val = lrintf(*datap) + (1 << (cbps - 1));
1629                         /* DC level shift and clip see ISO 15444-1:2002 G.1.2 */
1630                         val = av_clip(val, 0, (1 << cbps) - 1);
1631                         /* align 12 bit values in little-endian mode */
1632                         *dst = val << (precision - cbps);
1633                         datap++;
1634                         dst += pixelsize;
1635                     }
1636                 } else {
1637                     for (; x < w; x ++) {
1638                         int val = *i_datap + (1 << (cbps - 1));
1639                         /* DC level shift and clip see ISO 15444-1:2002 G.1.2 */
1640                         val = av_clip(val, 0, (1 << cbps) - 1);
1641                         /* align 12 bit values in little-endian mode */
1642                         *dst = val << (precision - cbps);
1643                         i_datap++;
1644                         dst += pixelsize;
1645                     }
1646                 }
1647                 linel += picture->linesize[plane] >> 1;
1648             }
1649         }
1650     }
1651
1652     return 0;
1653 }
1654
1655 static void jpeg2000_dec_cleanup(Jpeg2000DecoderContext *s)
1656 {
1657     int tileno, compno;
1658     for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++) {
1659         if (s->tile[tileno].comp) {
1660             for (compno = 0; compno < s->ncomponents; compno++) {
1661                 Jpeg2000Component *comp     = s->tile[tileno].comp   + compno;
1662                 Jpeg2000CodingStyle *codsty = s->tile[tileno].codsty + compno;
1663
1664                 ff_jpeg2000_cleanup(comp, codsty);
1665             }
1666             av_freep(&s->tile[tileno].comp);
1667         }
1668     }
1669     av_freep(&s->tile);
1670     memset(s->codsty, 0, sizeof(s->codsty));
1671     memset(s->qntsty, 0, sizeof(s->qntsty));
1672     s->numXtiles = s->numYtiles = 0;
1673 }
1674
1675 static int jpeg2000_read_main_headers(Jpeg2000DecoderContext *s)
1676 {
1677     Jpeg2000CodingStyle *codsty = s->codsty;
1678     Jpeg2000QuantStyle *qntsty  = s->qntsty;
1679     uint8_t *properties         = s->properties;
1680
1681     for (;;) {
1682         int len, ret = 0;
1683         uint16_t marker;
1684         int oldpos;
1685
1686         if (bytestream2_get_bytes_left(&s->g) < 2) {
1687             av_log(s->avctx, AV_LOG_ERROR, "Missing EOC\n");
1688             break;
1689         }
1690
1691         marker = bytestream2_get_be16u(&s->g);
1692         oldpos = bytestream2_tell(&s->g);
1693
1694         if (marker == JPEG2000_SOD) {
1695             Jpeg2000Tile *tile;
1696             Jpeg2000TilePart *tp;
1697
1698             if (!s->tile) {
1699                 av_log(s->avctx, AV_LOG_ERROR, "Missing SIZ\n");
1700                 return AVERROR_INVALIDDATA;
1701             }
1702             if (s->curtileno < 0) {
1703                 av_log(s->avctx, AV_LOG_ERROR, "Missing SOT\n");
1704                 return AVERROR_INVALIDDATA;
1705             }
1706
1707             tile = s->tile + s->curtileno;
1708             tp = tile->tile_part + tile->tp_idx;
1709             if (tp->tp_end < s->g.buffer) {
1710                 av_log(s->avctx, AV_LOG_ERROR, "Invalid tpend\n");
1711                 return AVERROR_INVALIDDATA;
1712             }
1713             bytestream2_init(&tp->tpg, s->g.buffer, tp->tp_end - s->g.buffer);
1714             bytestream2_skip(&s->g, tp->tp_end - s->g.buffer);
1715
1716             continue;
1717         }
1718         if (marker == JPEG2000_EOC)
1719             break;
1720
1721         len = bytestream2_get_be16(&s->g);
1722         if (len < 2 || bytestream2_get_bytes_left(&s->g) < len - 2) {
1723             av_log(s->avctx, AV_LOG_ERROR, "Invalid len %d left=%d\n", len, bytestream2_get_bytes_left(&s->g));
1724             return AVERROR_INVALIDDATA;
1725         }
1726
1727         switch (marker) {
1728         case JPEG2000_SIZ:
1729             ret = get_siz(s);
1730             if (!s->tile)
1731                 s->numXtiles = s->numYtiles = 0;
1732             break;
1733         case JPEG2000_COC:
1734             ret = get_coc(s, codsty, properties);
1735             break;
1736         case JPEG2000_COD:
1737             ret = get_cod(s, codsty, properties);
1738             break;
1739         case JPEG2000_QCC:
1740             ret = get_qcc(s, len, qntsty, properties);
1741             break;
1742         case JPEG2000_QCD:
1743             ret = get_qcd(s, len, qntsty, properties);
1744             break;
1745         case JPEG2000_SOT:
1746             if (!(ret = get_sot(s, len))) {
1747                 av_assert1(s->curtileno >= 0);
1748                 codsty = s->tile[s->curtileno].codsty;
1749                 qntsty = s->tile[s->curtileno].qntsty;
1750                 properties = s->tile[s->curtileno].properties;
1751             }
1752             break;
1753         case JPEG2000_COM:
1754             // the comment is ignored
1755             bytestream2_skip(&s->g, len - 2);
1756             break;
1757         case JPEG2000_TLM:
1758             // Tile-part lengths
1759             ret = get_tlm(s, len);
1760             break;
1761         case JPEG2000_PLT:
1762             // Packet length, tile-part header
1763             ret = get_plt(s, len);
1764             break;
1765         default:
1766             av_log(s->avctx, AV_LOG_ERROR,
1767                    "unsupported marker 0x%.4"PRIX16" at pos 0x%X\n",
1768                    marker, bytestream2_tell(&s->g) - 4);
1769             bytestream2_skip(&s->g, len - 2);
1770             break;
1771         }
1772         if (bytestream2_tell(&s->g) - oldpos != len || ret) {
1773             av_log(s->avctx, AV_LOG_ERROR,
1774                    "error during processing marker segment %.4"PRIx16"\n",
1775                    marker);
1776             return ret ? ret : -1;
1777         }
1778     }
1779     return 0;
1780 }
1781
1782 /* Read bit stream packets --> T2 operation. */
1783 static int jpeg2000_read_bitstream_packets(Jpeg2000DecoderContext *s)
1784 {
1785     int ret = 0;
1786     int tileno;
1787
1788     for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++) {
1789         Jpeg2000Tile *tile = s->tile + tileno;
1790
1791         if ((ret = init_tile(s, tileno)) < 0)
1792             return ret;
1793
1794         s->g = tile->tile_part[0].tpg;
1795         if ((ret = jpeg2000_decode_packets(s, tile)) < 0)
1796             return ret;
1797     }
1798
1799     return 0;
1800 }
1801
1802 static int jp2_find_codestream(Jpeg2000DecoderContext *s)
1803 {
1804     uint32_t atom_size, atom, atom_end;
1805     int search_range = 10;
1806
1807     while (search_range
1808            &&
1809            bytestream2_get_bytes_left(&s->g) >= 8) {
1810         atom_size = bytestream2_get_be32u(&s->g);
1811         atom      = bytestream2_get_be32u(&s->g);
1812         atom_end  = bytestream2_tell(&s->g) + atom_size - 8;
1813
1814         if (atom == JP2_CODESTREAM)
1815             return 1;
1816
1817         if (bytestream2_get_bytes_left(&s->g) < atom_size || atom_end < atom_size)
1818             return 0;
1819
1820         if (atom == JP2_HEADER &&
1821                    atom_size >= 16) {
1822             uint32_t atom2_size, atom2, atom2_end;
1823             do {
1824                 atom2_size = bytestream2_get_be32u(&s->g);
1825                 atom2      = bytestream2_get_be32u(&s->g);
1826                 atom2_end  = bytestream2_tell(&s->g) + atom2_size - 8;
1827                 if (atom2_size < 8 || atom2_end > atom_end || atom2_end < atom2_size)
1828                     break;
1829                 if (atom2 == JP2_CODESTREAM) {
1830                     return 1;
1831                 } else if (atom2 == MKBETAG('c','o','l','r') && atom2_size >= 7) {
1832                     int method = bytestream2_get_byteu(&s->g);
1833                     bytestream2_skipu(&s->g, 2);
1834                     if (method == 1) {
1835                         s->colour_space = bytestream2_get_be32u(&s->g);
1836                     }
1837                 } else if (atom2 == MKBETAG('p','c','l','r') && atom2_size >= 6) {
1838                     int i, size, colour_count, colour_channels, colour_depth[3];
1839                     uint32_t r, g, b;
1840                     colour_count = bytestream2_get_be16u(&s->g);
1841                     colour_channels = bytestream2_get_byteu(&s->g);
1842                     // FIXME: Do not ignore channel_sign
1843                     colour_depth[0] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1;
1844                     colour_depth[1] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1;
1845                     colour_depth[2] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1;
1846                     size = (colour_depth[0] + 7 >> 3) * colour_count +
1847                            (colour_depth[1] + 7 >> 3) * colour_count +
1848                            (colour_depth[2] + 7 >> 3) * colour_count;
1849                     if (colour_count > 256   ||
1850                         colour_channels != 3 ||
1851                         colour_depth[0] > 16 ||
1852                         colour_depth[1] > 16 ||
1853                         colour_depth[2] > 16 ||
1854                         atom2_size < size) {
1855                         avpriv_request_sample(s->avctx, "Unknown palette");
1856                         bytestream2_seek(&s->g, atom2_end, SEEK_SET);
1857                         continue;
1858                     }
1859                     s->pal8 = 1;
1860                     for (i = 0; i < colour_count; i++) {
1861                         if (colour_depth[0] <= 8) {
1862                             r = bytestream2_get_byteu(&s->g) << 8 - colour_depth[0];
1863                             r |= r >> colour_depth[0];
1864                         } else {
1865                             r = bytestream2_get_be16u(&s->g) >> colour_depth[0] - 8;
1866                         }
1867                         if (colour_depth[1] <= 8) {
1868                             g = bytestream2_get_byteu(&s->g) << 8 - colour_depth[1];
1869                             r |= r >> colour_depth[1];
1870                         } else {
1871                             g = bytestream2_get_be16u(&s->g) >> colour_depth[1] - 8;
1872                         }
1873                         if (colour_depth[2] <= 8) {
1874                             b = bytestream2_get_byteu(&s->g) << 8 - colour_depth[2];
1875                             r |= r >> colour_depth[2];
1876                         } else {
1877                             b = bytestream2_get_be16u(&s->g) >> colour_depth[2] - 8;
1878                         }
1879                         s->palette[i] = 0xffu << 24 | r << 16 | g << 8 | b;
1880                     }
1881                 } else if (atom2 == MKBETAG('c','d','e','f') && atom2_size >= 2) {
1882                     int n = bytestream2_get_be16u(&s->g);
1883                     for (; n>0; n--) {
1884                         int cn   = bytestream2_get_be16(&s->g);
1885                         int av_unused typ  = bytestream2_get_be16(&s->g);
1886                         int asoc = bytestream2_get_be16(&s->g);
1887                         if (cn < 4 && asoc < 4)
1888                             s->cdef[cn] = asoc;
1889                     }
1890                 }
1891                 bytestream2_seek(&s->g, atom2_end, SEEK_SET);
1892             } while (atom_end - atom2_end >= 8);
1893         } else {
1894             search_range--;
1895         }
1896         bytestream2_seek(&s->g, atom_end, SEEK_SET);
1897     }
1898
1899     return 0;
1900 }
1901
1902 static av_cold int jpeg2000_decode_init(AVCodecContext *avctx)
1903 {
1904     Jpeg2000DecoderContext *s = avctx->priv_data;
1905
1906     ff_jpeg2000dsp_init(&s->dsp);
1907
1908     return 0;
1909 }
1910
1911 static int jpeg2000_decode_frame(AVCodecContext *avctx, void *data,
1912                                  int *got_frame, AVPacket *avpkt)
1913 {
1914     Jpeg2000DecoderContext *s = avctx->priv_data;
1915     ThreadFrame frame = { .f = data };
1916     AVFrame *picture = data;
1917     int tileno, ret;
1918
1919     s->avctx     = avctx;
1920     bytestream2_init(&s->g, avpkt->data, avpkt->size);
1921     s->curtileno = -1;
1922     memset(s->cdef, -1, sizeof(s->cdef));
1923
1924     if (bytestream2_get_bytes_left(&s->g) < 2) {
1925         ret = AVERROR_INVALIDDATA;
1926         goto end;
1927     }
1928
1929     // check if the image is in jp2 format
1930     if (bytestream2_get_bytes_left(&s->g) >= 12 &&
1931        (bytestream2_get_be32u(&s->g) == 12) &&
1932        (bytestream2_get_be32u(&s->g) == JP2_SIG_TYPE) &&
1933        (bytestream2_get_be32u(&s->g) == JP2_SIG_VALUE)) {
1934         if (!jp2_find_codestream(s)) {
1935             av_log(avctx, AV_LOG_ERROR,
1936                    "Could not find Jpeg2000 codestream atom.\n");
1937             ret = AVERROR_INVALIDDATA;
1938             goto end;
1939         }
1940     } else {
1941         bytestream2_seek(&s->g, 0, SEEK_SET);
1942     }
1943
1944     while (bytestream2_get_bytes_left(&s->g) >= 3 && bytestream2_peek_be16(&s->g) != JPEG2000_SOC)
1945         bytestream2_skip(&s->g, 1);
1946
1947     if (bytestream2_get_be16u(&s->g) != JPEG2000_SOC) {
1948         av_log(avctx, AV_LOG_ERROR, "SOC marker not present\n");
1949         ret = AVERROR_INVALIDDATA;
1950         goto end;
1951     }
1952     if (ret = jpeg2000_read_main_headers(s))
1953         goto end;
1954
1955     /* get picture buffer */
1956     if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
1957         goto end;
1958     picture->pict_type = AV_PICTURE_TYPE_I;
1959     picture->key_frame = 1;
1960
1961     if (ret = jpeg2000_read_bitstream_packets(s))
1962         goto end;
1963
1964     for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++)
1965         if (ret = jpeg2000_decode_tile(s, s->tile + tileno, picture))
1966             goto end;
1967
1968     jpeg2000_dec_cleanup(s);
1969
1970     *got_frame = 1;
1971
1972     if (s->avctx->pix_fmt == AV_PIX_FMT_PAL8)
1973         memcpy(picture->data[1], s->palette, 256 * sizeof(uint32_t));
1974
1975     return bytestream2_tell(&s->g);
1976
1977 end:
1978     jpeg2000_dec_cleanup(s);
1979     return ret;
1980 }
1981
1982 static av_cold void jpeg2000_init_static_data(AVCodec *codec)
1983 {
1984     ff_jpeg2000_init_tier1_luts();
1985     ff_mqc_init_context_tables();
1986 }
1987
1988 #define OFFSET(x) offsetof(Jpeg2000DecoderContext, x)
1989 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
1990
1991 static const AVOption options[] = {
1992     { "lowres",  "Lower the decoding resolution by a power of two",
1993         OFFSET(reduction_factor), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, JPEG2000_MAX_RESLEVELS - 1, VD },
1994     { NULL },
1995 };
1996
1997 static const AVProfile profiles[] = {
1998     { FF_PROFILE_JPEG2000_CSTREAM_RESTRICTION_0,  "JPEG 2000 codestream restriction 0"   },
1999     { FF_PROFILE_JPEG2000_CSTREAM_RESTRICTION_1,  "JPEG 2000 codestream restriction 1"   },
2000     { FF_PROFILE_JPEG2000_CSTREAM_NO_RESTRICTION, "JPEG 2000 no codestream restrictions" },
2001     { FF_PROFILE_JPEG2000_DCINEMA_2K,             "JPEG 2000 digital cinema 2K"          },
2002     { FF_PROFILE_JPEG2000_DCINEMA_4K,             "JPEG 2000 digital cinema 4K"          },
2003     { FF_PROFILE_UNKNOWN },
2004 };
2005
2006 static const AVClass jpeg2000_class = {
2007     .class_name = "jpeg2000",
2008     .item_name  = av_default_item_name,
2009     .option     = options,
2010     .version    = LIBAVUTIL_VERSION_INT,
2011 };
2012
2013 AVCodec ff_jpeg2000_decoder = {
2014     .name             = "jpeg2000",
2015     .long_name        = NULL_IF_CONFIG_SMALL("JPEG 2000"),
2016     .type             = AVMEDIA_TYPE_VIDEO,
2017     .id               = AV_CODEC_ID_JPEG2000,
2018     .capabilities     = CODEC_CAP_FRAME_THREADS,
2019     .priv_data_size   = sizeof(Jpeg2000DecoderContext),
2020     .init_static_data = jpeg2000_init_static_data,
2021     .init             = jpeg2000_decode_init,
2022     .decode           = jpeg2000_decode_frame,
2023     .priv_class       = &jpeg2000_class,
2024     .max_lowres       = 5,
2025     .profiles         = NULL_IF_CONFIG_SMALL(profiles)
2026 };