jpeg2000dec.c 85.6 KB
Newer Older
1 2 3 4 5
/*
 * JPEG 2000 image decoder
 * Copyright (c) 2007 Kamil Nowosad
 * Copyright (c) 2013 Nicolas Bertrand <nicoinattendu@gmail.com>
 *
6
 * This file is part of FFmpeg.
7
 *
8
 * FFmpeg is free software; you can redistribute it and/or
9 10 11 12
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
13
 * FFmpeg is distributed in the hope that it will be useful,
14 15 16 17 18
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * 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 21 22 23 24 25 26 27
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

/**
 * @file
 * JPEG 2000 image decoder
 */

28 29
#include <inttypes.h>

30
#include "libavutil/attributes.h"
31
#include "libavutil/avassert.h"
32
#include "libavutil/common.h"
33
#include "libavutil/imgutils.h"
34
#include "libavutil/opt.h"
35
#include "libavutil/pixdesc.h"
36 37 38
#include "avcodec.h"
#include "bytestream.h"
#include "internal.h"
39
#include "thread.h"
40
#include "jpeg2000.h"
41
#include "jpeg2000dsp.h"
42
#include "profiles.h"
43 44 45 46

#define JP2_SIG_TYPE    0x6A502020
#define JP2_SIG_VALUE   0x0D0A870A
#define JP2_CODESTREAM  0x6A703263
47
#define JP2_HEADER      0x6A703268
48 49 50 51

#define HAD_COC 0x01
#define HAD_QCC 0x02

52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68
#define MAX_POCS 32

typedef struct Jpeg2000POCEntry {
    uint16_t LYEpoc;
    uint16_t CSpoc;
    uint16_t CEpoc;
    uint8_t RSpoc;
    uint8_t REpoc;
    uint8_t Ppoc;
} Jpeg2000POCEntry;

typedef struct Jpeg2000POC {
    Jpeg2000POCEntry poc[MAX_POCS];
    int nb_poc;
    int is_default;
} Jpeg2000POC;

69 70
typedef struct Jpeg2000TilePart {
    uint8_t tile_index;                 // Tile index who refers the tile-part
71
    const uint8_t *tp_end;
72
    GetByteContext tpg;                 // bit stream in tile-part
73 74 75 76 77 78 79 80 81
} Jpeg2000TilePart;

/* RMK: For JPEG2000 DCINEMA 3 tile-parts in a tile
 * one per component, so tile_part elements have a size of 3 */
typedef struct Jpeg2000Tile {
    Jpeg2000Component   *comp;
    uint8_t             properties[4];
    Jpeg2000CodingStyle codsty[4];
    Jpeg2000QuantStyle  qntsty[4];
82
    Jpeg2000POC         poc;
83
    Jpeg2000TilePart    tile_part[256];
84
    uint16_t tp_idx;                    // Tile-part index
85
    int coord[2][2];                    // border coordinates {{x0, x1}, {y0, y1}}
86 87 88 89 90
} Jpeg2000Tile;

typedef struct Jpeg2000DecoderContext {
    AVClass         *class;
    AVCodecContext  *avctx;
91
    GetByteContext  g;
92 93 94 95 96 97 98 99 100 101

    int             width, height;
    int             image_offset_x, image_offset_y;
    int             tile_offset_x, tile_offset_y;
    uint8_t         cbps[4];    // bits per sample in particular components
    uint8_t         sgnd[4];    // if a component is signed
    uint8_t         properties[4];
    int             cdx[4], cdy[4];
    int             precision;
    int             ncomponents;
102 103 104
    int             colour_space;
    uint32_t        palette[256];
    int8_t          pal8;
105
    int             cdef[4];
106
    int             tile_width, tile_height;
107
    unsigned        numXtiles, numYtiles;
108 109 110 111
    int             maxtilelen;

    Jpeg2000CodingStyle codsty[4];
    Jpeg2000QuantStyle  qntsty[4];
112
    Jpeg2000POC         poc;
113 114 115

    int             bit_index;

116 117
    int             curtileno;

118
    Jpeg2000Tile    *tile;
119
    Jpeg2000DSPContext dsp;
120 121

    /*options parameters*/
122
    int             reduction_factor;
123 124 125 126 127 128 129 130 131
} Jpeg2000DecoderContext;

/* get_bits functions for JPEG2000 packet bitstream
 * It is a get_bit function with a bit-stuffing routine. If the value of the
 * byte is 0xFF, the next byte includes an extra zero bit stuffed into the MSB.
 * cf. ISO-15444-1:2002 / B.10.1 Bit-stuffing routine */
static int get_bits(Jpeg2000DecoderContext *s, int n)
{
    int res = 0;
132

133 134 135
    while (--n >= 0) {
        res <<= 1;
        if (s->bit_index == 0) {
136
            s->bit_index = 7 + (bytestream2_get_byte(&s->g) != 0xFFu);
137 138
        }
        s->bit_index--;
139
        res |= (bytestream2_peek_byte(&s->g) >> s->bit_index) & 1;
140 141 142 143 144 145
    }
    return res;
}

static void jpeg2000_flush(Jpeg2000DecoderContext *s)
{
146 147
    if (bytestream2_get_byte(&s->g) == 0xff)
        bytestream2_skip(&s->g, 1);
148 149 150 151 152 153 154 155 156 157
    s->bit_index = 8;
}

/* decode the value stored in node */
static int tag_tree_decode(Jpeg2000DecoderContext *s, Jpeg2000TgtNode *node,
                           int threshold)
{
    Jpeg2000TgtNode *stack[30];
    int sp = -1, curval = 0;

158 159
    if (!node) {
        av_log(s->avctx, AV_LOG_ERROR, "missing node\n");
160
        return AVERROR_INVALIDDATA;
161
    }
162

163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191
    while (node && !node->vis) {
        stack[++sp] = node;
        node        = node->parent;
    }

    if (node)
        curval = node->val;
    else
        curval = stack[sp]->val;

    while (curval < threshold && sp >= 0) {
        if (curval < stack[sp]->val)
            curval = stack[sp]->val;
        while (curval < threshold) {
            int ret;
            if ((ret = get_bits(s, 1)) > 0) {
                stack[sp]->vis++;
                break;
            } else if (!ret)
                curval++;
            else
                return ret;
        }
        stack[sp]->val = curval;
        sp--;
    }
    return curval;
}

192 193 194 195 196 197
static int pix_fmt_match(enum AVPixelFormat pix_fmt, int components,
                         int bpc, uint32_t log2_chroma_wh, int pal8)
{
    int match = 1;
    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);

198 199
    av_assert2(desc);

200 201 202 203 204 205
    if (desc->nb_components != components) {
        return 0;
    }

    switch (components) {
    case 4:
206
        match = match && desc->comp[3].depth >= bpc &&
207 208 209
                         (log2_chroma_wh >> 14 & 3) == 0 &&
                         (log2_chroma_wh >> 12 & 3) == 0;
    case 3:
210
        match = match && desc->comp[2].depth >= bpc &&
211 212 213
                         (log2_chroma_wh >> 10 & 3) == desc->log2_chroma_w &&
                         (log2_chroma_wh >>  8 & 3) == desc->log2_chroma_h;
    case 2:
214
        match = match && desc->comp[1].depth >= bpc &&
215 216 217 218
                         (log2_chroma_wh >>  6 & 3) == desc->log2_chroma_w &&
                         (log2_chroma_wh >>  4 & 3) == desc->log2_chroma_h;

    case 1:
219
        match = match && desc->comp[0].depth >= bpc &&
220 221 222 223 224 225 226 227 228 229
                         (log2_chroma_wh >>  2 & 3) == 0 &&
                         (log2_chroma_wh       & 3) == 0 &&
                         (desc->flags & AV_PIX_FMT_FLAG_PAL) == pal8 * AV_PIX_FMT_FLAG_PAL;
    }
    return match;
}

// pix_fmts with lower bpp have to be listed before
// similar pix_fmts with higher bpp.
#define RGB_PIXEL_FORMATS   AV_PIX_FMT_PAL8,AV_PIX_FMT_RGB24,AV_PIX_FMT_RGBA,AV_PIX_FMT_RGB48,AV_PIX_FMT_RGBA64
230
#define GRAY_PIXEL_FORMATS  AV_PIX_FMT_GRAY8,AV_PIX_FMT_GRAY8A,AV_PIX_FMT_GRAY16,AV_PIX_FMT_YA16
231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246
#define YUV_PIXEL_FORMATS   AV_PIX_FMT_YUV410P,AV_PIX_FMT_YUV411P,AV_PIX_FMT_YUVA420P, \
                            AV_PIX_FMT_YUV420P,AV_PIX_FMT_YUV422P,AV_PIX_FMT_YUVA422P, \
                            AV_PIX_FMT_YUV440P,AV_PIX_FMT_YUV444P,AV_PIX_FMT_YUVA444P, \
                            AV_PIX_FMT_YUV420P9,AV_PIX_FMT_YUV422P9,AV_PIX_FMT_YUV444P9, \
                            AV_PIX_FMT_YUVA420P9,AV_PIX_FMT_YUVA422P9,AV_PIX_FMT_YUVA444P9, \
                            AV_PIX_FMT_YUV420P10,AV_PIX_FMT_YUV422P10,AV_PIX_FMT_YUV444P10, \
                            AV_PIX_FMT_YUVA420P10,AV_PIX_FMT_YUVA422P10,AV_PIX_FMT_YUVA444P10, \
                            AV_PIX_FMT_YUV420P12,AV_PIX_FMT_YUV422P12,AV_PIX_FMT_YUV444P12, \
                            AV_PIX_FMT_YUV420P14,AV_PIX_FMT_YUV422P14,AV_PIX_FMT_YUV444P14, \
                            AV_PIX_FMT_YUV420P16,AV_PIX_FMT_YUV422P16,AV_PIX_FMT_YUV444P16, \
                            AV_PIX_FMT_YUVA420P16,AV_PIX_FMT_YUVA422P16,AV_PIX_FMT_YUVA444P16
#define XYZ_PIXEL_FORMATS   AV_PIX_FMT_XYZ12

static const enum AVPixelFormat rgb_pix_fmts[]  = {RGB_PIXEL_FORMATS};
static const enum AVPixelFormat gray_pix_fmts[] = {GRAY_PIXEL_FORMATS};
static const enum AVPixelFormat yuv_pix_fmts[]  = {YUV_PIXEL_FORMATS};
247 248
static const enum AVPixelFormat xyz_pix_fmts[]  = {XYZ_PIXEL_FORMATS,
                                                   YUV_PIXEL_FORMATS};
249 250 251 252 253
static const enum AVPixelFormat all_pix_fmts[]  = {RGB_PIXEL_FORMATS,
                                                   GRAY_PIXEL_FORMATS,
                                                   YUV_PIXEL_FORMATS,
                                                   XYZ_PIXEL_FORMATS};

254 255 256 257 258
/* marker segments */
/* get sizes and offsets of image, tiles; number of components */
static int get_siz(Jpeg2000DecoderContext *s)
{
    int i;
259
    int ncomponents;
260 261 262
    uint32_t log2_chroma_wh = 0;
    const enum AVPixelFormat *possible_fmts = NULL;
    int possible_fmts_nb = 0;
263

264 265
    if (bytestream2_get_bytes_left(&s->g) < 36) {
        av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for SIZ\n");
266
        return AVERROR_INVALIDDATA;
267
    }
268

269 270 271 272 273 274 275 276 277
    s->avctx->profile = bytestream2_get_be16u(&s->g); // Rsiz
    s->width          = bytestream2_get_be32u(&s->g); // Width
    s->height         = bytestream2_get_be32u(&s->g); // Height
    s->image_offset_x = bytestream2_get_be32u(&s->g); // X0Siz
    s->image_offset_y = bytestream2_get_be32u(&s->g); // Y0Siz
    s->tile_width     = bytestream2_get_be32u(&s->g); // XTSiz
    s->tile_height    = bytestream2_get_be32u(&s->g); // YTSiz
    s->tile_offset_x  = bytestream2_get_be32u(&s->g); // XT0Siz
    s->tile_offset_y  = bytestream2_get_be32u(&s->g); // YT0Siz
278
    ncomponents       = bytestream2_get_be16u(&s->g); // CSiz
279

280 281 282 283
    if (s->image_offset_x || s->image_offset_y) {
        avpriv_request_sample(s->avctx, "Support for image offsets");
        return AVERROR_PATCHWELCOME;
    }
284
    if (av_image_check_size(s->width, s->height, 0, s->avctx)) {
285 286 287
        avpriv_request_sample(s->avctx, "Large Dimensions");
        return AVERROR_PATCHWELCOME;
    }
288

289 290 291
    if (ncomponents <= 0) {
        av_log(s->avctx, AV_LOG_ERROR, "Invalid number of components: %d\n",
               s->ncomponents);
292
        return AVERROR_INVALIDDATA;
293
    }
294

295
    if (ncomponents > 4) {
296
        avpriv_request_sample(s->avctx, "Support for %d components",
297
                              ncomponents);
298 299 300
        return AVERROR_PATCHWELCOME;
    }

301 302
    s->ncomponents = ncomponents;

303
    if (s->tile_width <= 0 || s->tile_height <= 0) {
304 305
        av_log(s->avctx, AV_LOG_ERROR, "Invalid tile dimension %dx%d.\n",
               s->tile_width, s->tile_height);
306
        return AVERROR_INVALIDDATA;
307
    }
308

309 310
    if (bytestream2_get_bytes_left(&s->g) < 3 * s->ncomponents) {
        av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for %d components in SIZ\n", s->ncomponents);
311
        return AVERROR_INVALIDDATA;
312
    }
313 314

    for (i = 0; i < s->ncomponents; i++) { // Ssiz_i XRsiz_i, YRsiz_i
315
        uint8_t x    = bytestream2_get_byteu(&s->g);
316 317
        s->cbps[i]   = (x & 0x7f) + 1;
        s->precision = FFMAX(s->cbps[i], s->precision);
318
        s->sgnd[i]   = !!(x & 0x80);
319 320
        s->cdx[i]    = bytestream2_get_byteu(&s->g);
        s->cdy[i]    = bytestream2_get_byteu(&s->g);
321 322
        if (   !s->cdx[i] || s->cdx[i] == 3 || s->cdx[i] > 4
            || !s->cdy[i] || s->cdy[i] == 3 || s->cdy[i] > 4) {
323
            av_log(s->avctx, AV_LOG_ERROR, "Invalid sample separation %d/%d\n", s->cdx[i], s->cdy[i]);
324 325
            return AVERROR_INVALIDDATA;
        }
326
        log2_chroma_wh |= s->cdy[i] >> 1 << i * 4 | s->cdx[i] >> 1 << i * 4 + 2;
327 328 329 330 331
    }

    s->numXtiles = ff_jpeg2000_ceildiv(s->width  - s->tile_offset_x, s->tile_width);
    s->numYtiles = ff_jpeg2000_ceildiv(s->height - s->tile_offset_y, s->tile_height);

332 333
    if (s->numXtiles * (uint64_t)s->numYtiles > INT_MAX/sizeof(*s->tile)) {
        s->numXtiles = s->numYtiles = 0;
334
        return AVERROR(EINVAL);
335
    }
336

337 338 339
    s->tile = av_mallocz_array(s->numXtiles * s->numYtiles, sizeof(*s->tile));
    if (!s->tile) {
        s->numXtiles = s->numYtiles = 0;
340
        return AVERROR(ENOMEM);
341
    }
342 343 344 345 346 347 348 349 350 351 352 353 354 355 356

    for (i = 0; i < s->numXtiles * s->numYtiles; i++) {
        Jpeg2000Tile *tile = s->tile + i;

        tile->comp = av_mallocz(s->ncomponents * sizeof(*tile->comp));
        if (!tile->comp)
            return AVERROR(ENOMEM);
    }

    /* compute image size with reduction factor */
    s->avctx->width  = ff_jpeg2000_ceildivpow2(s->width  - s->image_offset_x,
                                               s->reduction_factor);
    s->avctx->height = ff_jpeg2000_ceildivpow2(s->height - s->image_offset_y,
                                               s->reduction_factor);

357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373
    if (s->avctx->profile == FF_PROFILE_JPEG2000_DCINEMA_2K ||
        s->avctx->profile == FF_PROFILE_JPEG2000_DCINEMA_4K) {
        possible_fmts = xyz_pix_fmts;
        possible_fmts_nb = FF_ARRAY_ELEMS(xyz_pix_fmts);
    } else {
        switch (s->colour_space) {
        case 16:
            possible_fmts = rgb_pix_fmts;
            possible_fmts_nb = FF_ARRAY_ELEMS(rgb_pix_fmts);
            break;
        case 17:
            possible_fmts = gray_pix_fmts;
            possible_fmts_nb = FF_ARRAY_ELEMS(gray_pix_fmts);
            break;
        case 18:
            possible_fmts = yuv_pix_fmts;
            possible_fmts_nb = FF_ARRAY_ELEMS(yuv_pix_fmts);
374
            break;
375
        default:
376 377
            possible_fmts = all_pix_fmts;
            possible_fmts_nb = FF_ARRAY_ELEMS(all_pix_fmts);
378 379
            break;
        }
380 381 382 383 384 385 386
    }
    for (i = 0; i < possible_fmts_nb; ++i) {
        if (pix_fmt_match(possible_fmts[i], ncomponents, s->precision, log2_chroma_wh, s->pal8)) {
            s->avctx->pix_fmt = possible_fmts[i];
            break;
        }
    }
387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404

    if (i == possible_fmts_nb) {
        if (ncomponents == 4 &&
            s->cdy[0] == 1 && s->cdx[0] == 1 &&
            s->cdy[1] == 1 && s->cdx[1] == 1 &&
            s->cdy[2] == s->cdy[3] && s->cdx[2] == s->cdx[3]) {
            if (s->precision == 8 && s->cdy[2] == 2 && s->cdx[2] == 2 && !s->pal8) {
                s->avctx->pix_fmt = AV_PIX_FMT_YUVA420P;
                s->cdef[0] = 0;
                s->cdef[1] = 1;
                s->cdef[2] = 2;
                s->cdef[3] = 3;
                i = 0;
            }
        }
    }


405
    if (i == possible_fmts_nb) {
406 407
        av_log(s->avctx, AV_LOG_ERROR,
               "Unknown pix_fmt, profile: %d, colour_space: %d, "
408 409 410 411 412
               "components: %d, precision: %d\n"
               "cdx[0]: %d, cdy[0]: %d\n"
               "cdx[1]: %d, cdy[1]: %d\n"
               "cdx[2]: %d, cdy[2]: %d\n"
               "cdx[3]: %d, cdy[3]: %d\n",
413
               s->avctx->profile, s->colour_space, ncomponents, s->precision,
414 415 416 417
               s->cdx[0],
               s->cdy[0],
               ncomponents > 1 ? s->cdx[1] : 0,
               ncomponents > 1 ? s->cdy[1] : 0,
418
               ncomponents > 2 ? s->cdx[2] : 0,
419 420 421
               ncomponents > 2 ? s->cdy[2] : 0,
               ncomponents > 3 ? s->cdx[3] : 0,
               ncomponents > 3 ? s->cdy[3] : 0);
422
        return AVERROR_PATCHWELCOME;
423
    }
424
    s->avctx->bits_per_raw_sample = s->precision;
425 426 427 428 429 430 431 432
    return 0;
}

/* get common part for COD and COC segments */
static int get_cox(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c)
{
    uint8_t byte;

433 434
    if (bytestream2_get_bytes_left(&s->g) < 5) {
        av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for COX\n");
435
        return AVERROR_INVALIDDATA;
436
    }
437

438 439
    /*  nreslevels = number of resolution levels
                   = number of decomposition level +1 */
440
    c->nreslevels = bytestream2_get_byteu(&s->g) + 1;
441 442 443 444
    if (c->nreslevels >= JPEG2000_MAX_RESLEVELS) {
        av_log(s->avctx, AV_LOG_ERROR, "nreslevels %d is invalid\n", c->nreslevels);
        return AVERROR_INVALIDDATA;
    }
445

446 447 448 449 450 451 452 453 454 455
    if (c->nreslevels <= s->reduction_factor) {
        /* we are forced to update reduction_factor as its requested value is
           not compatible with this bitstream, and as we might have used it
           already in setup earlier we have to fail this frame until
           reinitialization is implemented */
        av_log(s->avctx, AV_LOG_ERROR, "reduction_factor too large for this bitstream, max is %d\n", c->nreslevels - 1);
        s->reduction_factor = c->nreslevels - 1;
        return AVERROR(EINVAL);
    }

456
    /* compute number of resolution levels to decode */
457
    c->nreslevels2decode = c->nreslevels - s->reduction_factor;
458

459 460 461 462
    c->log2_cblk_width  = (bytestream2_get_byteu(&s->g) & 15) + 2; // cblk width
    c->log2_cblk_height = (bytestream2_get_byteu(&s->g) & 15) + 2; // cblk height

    if (c->log2_cblk_width > 10 || c->log2_cblk_height > 10 ||
463
        c->log2_cblk_width + c->log2_cblk_height > 12) {
464 465 466
        av_log(s->avctx, AV_LOG_ERROR, "cblk size invalid\n");
        return AVERROR_INVALIDDATA;
    }
467

468
    c->cblk_style = bytestream2_get_byteu(&s->g);
469
    if (c->cblk_style != 0) { // cblk style
470
        av_log(s->avctx, AV_LOG_WARNING, "extra cblk styles %X\n", c->cblk_style);
471 472
        if (c->cblk_style & JPEG2000_CBLK_BYPASS)
            av_log(s->avctx, AV_LOG_WARNING, "Selective arithmetic coding bypass\n");
473
    }
474
    c->transform = bytestream2_get_byteu(&s->g); // DWT transformation type
475
    /* set integer 9/7 DWT in case of BITEXACT flag */
476
    if ((s->avctx->flags & AV_CODEC_FLAG_BITEXACT) && (c->transform == FF_DWT97))
477
        c->transform = FF_DWT97_INT;
478 479 480
    else if (c->transform == FF_DWT53) {
        s->avctx->properties |= FF_CODEC_PROPERTY_LOSSLESS;
    }
481 482 483 484

    if (c->csty & JPEG2000_CSTY_PREC) {
        int i;
        for (i = 0; i < c->nreslevels; i++) {
485
            byte = bytestream2_get_byte(&s->g);
486 487
            c->log2_prec_widths[i]  =  byte       & 0x0F;    // precinct PPx
            c->log2_prec_heights[i] = (byte >> 4) & 0x0F;    // precinct PPy
488 489 490 491 492 493 494
            if (i)
                if (c->log2_prec_widths[i] == 0 || c->log2_prec_heights[i] == 0) {
                    av_log(s->avctx, AV_LOG_ERROR, "PPx %d PPy %d invalid\n",
                           c->log2_prec_widths[i], c->log2_prec_heights[i]);
                    c->log2_prec_widths[i] = c->log2_prec_heights[i] = 1;
                    return AVERROR_INVALIDDATA;
                }
495
        }
496 497 498
    } else {
        memset(c->log2_prec_widths , 15, sizeof(c->log2_prec_widths ));
        memset(c->log2_prec_heights, 15, sizeof(c->log2_prec_heights));
499 500 501 502 503 504 505 506 507
    }
    return 0;
}

/* get coding parameters for a particular tile or whole image*/
static int get_cod(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c,
                   uint8_t *properties)
{
    Jpeg2000CodingStyle tmp;
508
    int compno, ret;
509

510 511
    if (bytestream2_get_bytes_left(&s->g) < 5) {
        av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for COD\n");
512
        return AVERROR_INVALIDDATA;
513
    }
514

515
    tmp.csty = bytestream2_get_byteu(&s->g);
516 517

    // get progression order
518
    tmp.prog_order = bytestream2_get_byteu(&s->g);
519

520 521
    tmp.nlayers    = bytestream2_get_be16u(&s->g);
    tmp.mct        = bytestream2_get_byteu(&s->g); // multiple component transformation
522

523
    if (tmp.mct && s->ncomponents < 3) {
524
        av_log(s->avctx, AV_LOG_ERROR,
525
               "MCT %"PRIu8" with too few components (%d)\n",
526
               tmp.mct, s->ncomponents);
527 528 529
        return AVERROR_INVALIDDATA;
    }

530 531 532
    if ((ret = get_cox(s, &tmp)) < 0)
        return ret;

533 534 535 536 537 538 539 540 541 542 543
    for (compno = 0; compno < s->ncomponents; compno++)
        if (!(properties[compno] & HAD_COC))
            memcpy(c + compno, &tmp, sizeof(tmp));
    return 0;
}

/* Get coding parameters for a component in the whole image or a
 * particular tile. */
static int get_coc(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c,
                   uint8_t *properties)
{
544
    int compno, ret;
545

546 547
    if (bytestream2_get_bytes_left(&s->g) < 2) {
        av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for COC\n");
548
        return AVERROR_INVALIDDATA;
549
    }
550

551
    compno = bytestream2_get_byteu(&s->g);
552

553
    if (compno >= s->ncomponents) {
554 555 556
        av_log(s->avctx, AV_LOG_ERROR,
               "Invalid compno %d. There are %d components in the image.\n",
               compno, s->ncomponents);
557 558 559
        return AVERROR_INVALIDDATA;
    }

560
    c      += compno;
561
    c->csty = bytestream2_get_byteu(&s->g);
562 563 564

    if ((ret = get_cox(s, c)) < 0)
        return ret;
565 566 567 568 569 570 571 572 573 574

    properties[compno] |= HAD_COC;
    return 0;
}

/* Get common part for QCD and QCC segments. */
static int get_qcx(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q)
{
    int i, x;

575
    if (bytestream2_get_bytes_left(&s->g) < 1)
576
        return AVERROR_INVALIDDATA;
577

578
    x = bytestream2_get_byteu(&s->g); // Sqcd
579 580 581 582 583 584

    q->nguardbits = x >> 5;
    q->quantsty   = x & 0x1f;

    if (q->quantsty == JPEG2000_QSTY_NONE) {
        n -= 3;
585
        if (bytestream2_get_bytes_left(&s->g) < n ||
586
            n > JPEG2000_MAX_DECLEVELS*3)
587
            return AVERROR_INVALIDDATA;
588
        for (i = 0; i < n; i++)
589
            q->expn[i] = bytestream2_get_byteu(&s->g) >> 3;
590
    } else if (q->quantsty == JPEG2000_QSTY_SI) {
591
        if (bytestream2_get_bytes_left(&s->g) < 2)
592
            return AVERROR_INVALIDDATA;
593
        x          = bytestream2_get_be16u(&s->g);
594 595
        q->expn[0] = x >> 11;
        q->mant[0] = x & 0x7ff;
596
        for (i = 1; i < JPEG2000_MAX_DECLEVELS * 3; i++) {
597 598 599 600 601 602
            int curexpn = FFMAX(0, q->expn[0] - (i - 1) / 3);
            q->expn[i] = curexpn;
            q->mant[i] = q->mant[0];
        }
    } else {
        n = (n - 3) >> 1;
603
        if (bytestream2_get_bytes_left(&s->g) < 2 * n ||
604
            n > JPEG2000_MAX_DECLEVELS*3)
605
            return AVERROR_INVALIDDATA;
606
        for (i = 0; i < n; i++) {
607
            x          = bytestream2_get_be16u(&s->g);
608 609 610 611 612 613 614 615 616 617 618 619
            q->expn[i] = x >> 11;
            q->mant[i] = x & 0x7ff;
        }
    }
    return 0;
}

/* Get quantization parameters for a particular tile or a whole image. */
static int get_qcd(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q,
                   uint8_t *properties)
{
    Jpeg2000QuantStyle tmp;
620
    int compno, ret;
621

622 623
    memset(&tmp, 0, sizeof(tmp));

624 625
    if ((ret = get_qcx(s, n, &tmp)) < 0)
        return ret;
626 627 628 629 630 631 632 633 634 635 636 637 638
    for (compno = 0; compno < s->ncomponents; compno++)
        if (!(properties[compno] & HAD_QCC))
            memcpy(q + compno, &tmp, sizeof(tmp));
    return 0;
}

/* Get quantization parameters for a component in the whole image
 * on in a particular tile. */
static int get_qcc(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q,
                   uint8_t *properties)
{
    int compno;

639
    if (bytestream2_get_bytes_left(&s->g) < 1)
640
        return AVERROR_INVALIDDATA;
641

642 643
    compno = bytestream2_get_byteu(&s->g);

644
    if (compno >= s->ncomponents) {
645 646 647
        av_log(s->avctx, AV_LOG_ERROR,
               "Invalid compno %d. There are %d components in the image.\n",
               compno, s->ncomponents);
648 649 650
        return AVERROR_INVALIDDATA;
    }

651 652 653 654
    properties[compno] |= HAD_QCC;
    return get_qcx(s, n - 1, q + compno);
}

655 656 657 658 659 660 661 662 663 664 665 666
static int get_poc(Jpeg2000DecoderContext *s, int size, Jpeg2000POC *p)
{
    int i;
    int elem_size = s->ncomponents <= 257 ? 7 : 9;
    Jpeg2000POC tmp = {{{0}}};

    if (bytestream2_get_bytes_left(&s->g) < 5 || size < 2 + elem_size) {
        av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for POC\n");
        return AVERROR_INVALIDDATA;
    }

    if (elem_size > 7) {
667
        avpriv_request_sample(s->avctx, "Fat POC not supported");
668 669 670 671 672
        return AVERROR_PATCHWELCOME;
    }

    tmp.nb_poc = (size - 2) / elem_size;
    if (tmp.nb_poc > MAX_POCS) {
673
        avpriv_request_sample(s->avctx, "Too many POCs (%d)", tmp.nb_poc);
674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715
        return AVERROR_PATCHWELCOME;
    }

    for (i = 0; i<tmp.nb_poc; i++) {
        Jpeg2000POCEntry *e = &tmp.poc[i];
        e->RSpoc  = bytestream2_get_byteu(&s->g);
        e->CSpoc  = bytestream2_get_byteu(&s->g);
        e->LYEpoc = bytestream2_get_be16u(&s->g);
        e->REpoc  = bytestream2_get_byteu(&s->g);
        e->CEpoc  = bytestream2_get_byteu(&s->g);
        e->Ppoc   = bytestream2_get_byteu(&s->g);
        if (!e->CEpoc)
            e->CEpoc = 256;
        if (e->CEpoc > s->ncomponents)
            e->CEpoc = s->ncomponents;
        if (   e->RSpoc >= e->REpoc || e->REpoc > 33
            || e->CSpoc >= e->CEpoc || e->CEpoc > s->ncomponents
            || !e->LYEpoc) {
            av_log(s->avctx, AV_LOG_ERROR, "POC Entry %d is invalid (%d, %d, %d, %d, %d, %d)\n", i,
                e->RSpoc, e->CSpoc, e->LYEpoc, e->REpoc, e->CEpoc, e->Ppoc
            );
            return AVERROR_INVALIDDATA;
        }
    }

    if (!p->nb_poc || p->is_default) {
        *p = tmp;
    } else {
        if (p->nb_poc + tmp.nb_poc > MAX_POCS) {
            av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for POC\n");
            return AVERROR_INVALIDDATA;
        }
        memcpy(p->poc + p->nb_poc, tmp.poc, tmp.nb_poc * sizeof(tmp.poc[0]));
        p->nb_poc += tmp.nb_poc;
    }

    p->is_default = 0;

    return 0;
}


716
/* Get start of tile segment. */
717
static int get_sot(Jpeg2000DecoderContext *s, int n)
718 719 720 721
{
    Jpeg2000TilePart *tp;
    uint16_t Isot;
    uint32_t Psot;
722
    unsigned TPsot;
723

724
    if (bytestream2_get_bytes_left(&s->g) < 8)
725
        return AVERROR_INVALIDDATA;
726

727
    s->curtileno = 0;
728
    Isot = bytestream2_get_be16u(&s->g);        // Isot
729
    if (Isot >= s->numXtiles * s->numYtiles)
730
        return AVERROR_INVALIDDATA;
731

732
    s->curtileno = Isot;
733 734
    Psot  = bytestream2_get_be32u(&s->g);       // Psot
    TPsot = bytestream2_get_byteu(&s->g);       // TPsot
735 736

    /* Read TNSot but not used */
737
    bytestream2_get_byteu(&s->g);               // TNsot
738

739
    if (!Psot)
740
        Psot = bytestream2_get_bytes_left(&s->g) - 2 + n + 2;
741

742
    if (Psot > bytestream2_get_bytes_left(&s->g) - 2 + n + 2) {
743
        av_log(s->avctx, AV_LOG_ERROR, "Psot %"PRIu32" too big\n", Psot);
744 745
        return AVERROR_INVALIDDATA;
    }
746

747
    av_assert0(TPsot < FF_ARRAY_ELEMS(s->tile[Isot].tile_part));
748

749 750
    s->tile[Isot].tp_idx = TPsot;
    tp             = s->tile[Isot].tile_part + TPsot;
751
    tp->tile_index = Isot;
752 753 754 755
    tp->tp_end     = s->g.buffer + Psot - n - 2;

    if (!TPsot) {
        Jpeg2000Tile *tile = s->tile + s->curtileno;
756

757 758 759
        /* copy defaults */
        memcpy(tile->codsty, s->codsty, s->ncomponents * sizeof(Jpeg2000CodingStyle));
        memcpy(tile->qntsty, s->qntsty, s->ncomponents * sizeof(Jpeg2000QuantStyle));
760 761
        memcpy(&tile->poc  , &s->poc  , sizeof(tile->poc));
        tile->poc.is_default = 1;
762
    }
763 764 765 766 767 768 769 770 771 772 773 774 775 776 777

    return 0;
}

/* Tile-part lengths: see ISO 15444-1:2002, section A.7.1
 * Used to know the number of tile parts and lengths.
 * There may be multiple TLMs in the header.
 * TODO: The function is not used for tile-parts management, nor anywhere else.
 * It can be useful to allocate memory for tile parts, before managing the SOT
 * markers. Parsing the TLM header is needed to increment the input header
 * buffer.
 * This marker is mandatory for DCI. */
static uint8_t get_tlm(Jpeg2000DecoderContext *s, int n)
{
    uint8_t Stlm, ST, SP, tile_tlm, i;
778 779
    bytestream2_get_byte(&s->g);               /* Ztlm: skipped */
    Stlm = bytestream2_get_byte(&s->g);
780 781 782 783 784 785 786 787 788 789 790

    // too complex ? ST = ((Stlm >> 4) & 0x01) + ((Stlm >> 4) & 0x02);
    ST = (Stlm >> 4) & 0x03;
    // TODO: Manage case of ST = 0b11 --> raise error
    SP       = (Stlm >> 6) & 0x01;
    tile_tlm = (n - 4) / ((SP + 1) * 2 + ST);
    for (i = 0; i < tile_tlm; i++) {
        switch (ST) {
        case 0:
            break;
        case 1:
791
            bytestream2_get_byte(&s->g);
792 793
            break;
        case 2:
794
            bytestream2_get_be16(&s->g);
795 796
            break;
        case 3:
797
            bytestream2_get_be32(&s->g);
798 799 800
            break;
        }
        if (SP == 0) {
801
            bytestream2_get_be16(&s->g);
802
        } else {
803
            bytestream2_get_be32(&s->g);
804 805 806 807 808
        }
    }
    return 0;
}

809 810 811 812
static uint8_t get_plt(Jpeg2000DecoderContext *s, int n)
{
    int i;

813
    av_log(s->avctx, AV_LOG_DEBUG,
814 815 816 817 818 819 820 821 822 823 824
            "PLT marker at pos 0x%X\n", bytestream2_tell(&s->g) - 4);

    /*Zplt =*/ bytestream2_get_byte(&s->g);

    for (i = 0; i < n - 3; i++) {
        bytestream2_get_byte(&s->g);
    }

    return 0;
}

825 826 827 828 829 830 831 832 833 834
static int init_tile(Jpeg2000DecoderContext *s, int tileno)
{
    int compno;
    int tilex = tileno % s->numXtiles;
    int tiley = tileno / s->numXtiles;
    Jpeg2000Tile *tile = s->tile + tileno;

    if (!tile->comp)
        return AVERROR(ENOMEM);

835 836 837 838
    tile->coord[0][0] = av_clip(tilex       * (int64_t)s->tile_width  + s->tile_offset_x, s->image_offset_x, s->width);
    tile->coord[0][1] = av_clip((tilex + 1) * (int64_t)s->tile_width  + s->tile_offset_x, s->image_offset_x, s->width);
    tile->coord[1][0] = av_clip(tiley       * (int64_t)s->tile_height + s->tile_offset_y, s->image_offset_y, s->height);
    tile->coord[1][1] = av_clip((tiley + 1) * (int64_t)s->tile_height + s->tile_offset_y, s->image_offset_y, s->height);
839

840 841
    for (compno = 0; compno < s->ncomponents; compno++) {
        Jpeg2000Component *comp = tile->comp + compno;
842 843
        Jpeg2000CodingStyle *codsty = tile->codsty + compno;
        Jpeg2000QuantStyle  *qntsty = tile->qntsty + compno;
844 845
        int ret; // global bandno

846 847 848 849
        comp->coord_o[0][0] = tile->coord[0][0];
        comp->coord_o[0][1] = tile->coord[0][1];
        comp->coord_o[1][0] = tile->coord[1][0];
        comp->coord_o[1][1] = tile->coord[1][1];
850 851 852 853 854 855
        if (compno) {
            comp->coord_o[0][0] /= s->cdx[compno];
            comp->coord_o[0][1] /= s->cdx[compno];
            comp->coord_o[1][0] /= s->cdy[compno];
            comp->coord_o[1][1] /= s->cdy[compno];
        }
856

857 858 859 860
        comp->coord[0][0] = ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], s->reduction_factor);
        comp->coord[0][1] = ff_jpeg2000_ceildivpow2(comp->coord_o[0][1], s->reduction_factor);
        comp->coord[1][0] = ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], s->reduction_factor);
        comp->coord[1][1] = ff_jpeg2000_ceildivpow2(comp->coord_o[1][1], s->reduction_factor);
861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896

        if (ret = ff_jpeg2000_init_component(comp, codsty, qntsty,
                                             s->cbps[compno], s->cdx[compno],
                                             s->cdy[compno], s->avctx))
            return ret;
    }
    return 0;
}

/* Read the number of coding passes. */
static int getnpasses(Jpeg2000DecoderContext *s)
{
    int num;
    if (!get_bits(s, 1))
        return 1;
    if (!get_bits(s, 1))
        return 2;
    if ((num = get_bits(s, 2)) != 3)
        return num < 0 ? num : 3 + num;
    if ((num = get_bits(s, 5)) != 31)
        return num < 0 ? num : 6 + num;
    num = get_bits(s, 7);
    return num < 0 ? num : 37 + num;
}

static int getlblockinc(Jpeg2000DecoderContext *s)
{
    int res = 0, ret;
    while (ret = get_bits(s, 1)) {
        if (ret < 0)
            return ret;
        res++;
    }
    return res;
}

897
static int jpeg2000_decode_packet(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile, int *tp_index,
898 899 900 901 902
                                  Jpeg2000CodingStyle *codsty,
                                  Jpeg2000ResLevel *rlevel, int precno,
                                  int layno, uint8_t *expn, int numgbits)
{
    int bandno, cblkno, ret, nb_code_blocks;
903
    int cwsno;
904

905 906 907 908
    if (layno < rlevel->band[0].prec[precno].decoded_layers)
        return 0;
    rlevel->band[0].prec[precno].decoded_layers = layno + 1;

909 910 911 912 913 914
    if (bytestream2_get_bytes_left(&s->g) == 0 && s->bit_index == 8) {
        if (*tp_index < FF_ARRAY_ELEMS(tile->tile_part) - 1) {
            s->g = tile->tile_part[++(*tp_index)].tpg;
        }
    }

915 916
    if (bytestream2_peek_be32(&s->g) == JPEG2000_SOP_FIXED_BYTES)
        bytestream2_skip(&s->g, JPEG2000_SOP_BYTE_LENGTH);
917

918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945
    if (!(ret = get_bits(s, 1))) {
        jpeg2000_flush(s);
        return 0;
    } else if (ret < 0)
        return ret;

    for (bandno = 0; bandno < rlevel->nbands; bandno++) {
        Jpeg2000Band *band = rlevel->band + bandno;
        Jpeg2000Prec *prec = band->prec + precno;

        if (band->coord[0][0] == band->coord[0][1] ||
            band->coord[1][0] == band->coord[1][1])
            continue;
        nb_code_blocks =  prec->nb_codeblocks_height *
                          prec->nb_codeblocks_width;
        for (cblkno = 0; cblkno < nb_code_blocks; cblkno++) {
            Jpeg2000Cblk *cblk = prec->cblk + cblkno;
            int incl, newpasses, llen;

            if (cblk->npasses)
                incl = get_bits(s, 1);
            else
                incl = tag_tree_decode(s, prec->cblkincl + cblkno, layno + 1) == layno;
            if (!incl)
                continue;
            else if (incl < 0)
                return incl;

946 947
            if (!cblk->npasses) {
                int v = expn[bandno] + numgbits - 1 -
948
                        tag_tree_decode(s, prec->zerobits + cblkno, 100);
949
                if (v < 0) {
950 951
                    av_log(s->avctx, AV_LOG_ERROR,
                           "nonzerobits %d invalid\n", v);
952 953 954 955
                    return AVERROR_INVALIDDATA;
                }
                cblk->nonzerobits = v;
            }
956 957
            if ((newpasses = getnpasses(s)) < 0)
                return newpasses;
958 959
            av_assert2(newpasses > 0);
            if (cblk->npasses + newpasses >= JPEG2000_MAX_PASSES) {
960
                avpriv_request_sample(s->avctx, "Too many passes");
961 962
                return AVERROR_PATCHWELCOME;
            }
963 964
            if ((llen = getlblockinc(s)) < 0)
                return llen;
965 966
            if (cblk->lblock + llen + av_log2(newpasses) > 16) {
                avpriv_request_sample(s->avctx,
967
                                      "Block with length beyond 16 bits");
968 969 970
                return AVERROR_PATCHWELCOME;
            }

971
            cblk->lblock += llen;
972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997

            cblk->nb_lengthinc = 0;
            cblk->nb_terminationsinc = 0;
            do {
                int newpasses1 = 0;

                while (newpasses1 < newpasses) {
                    newpasses1 ++;
                    if (needs_termination(codsty->cblk_style, cblk->npasses + newpasses1 - 1)) {
                        cblk->nb_terminationsinc ++;
                        break;
                    }
                }

                if ((ret = get_bits(s, av_log2(newpasses1) + cblk->lblock)) < 0)
                    return ret;
                if (ret > sizeof(cblk->data)) {
                    avpriv_request_sample(s->avctx,
                                        "Block with lengthinc greater than %"SIZE_SPECIFIER"",
                                        sizeof(cblk->data));
                    return AVERROR_PATCHWELCOME;
                }
                cblk->lengthinc[cblk->nb_lengthinc++] = ret;
                cblk->npasses  += newpasses1;
                newpasses -= newpasses1;
            } while(newpasses);
998 999 1000 1001 1002
        }
    }
    jpeg2000_flush(s);

    if (codsty->csty & JPEG2000_CSTY_EPH) {
1003 1004
        if (bytestream2_peek_be16(&s->g) == JPEG2000_EPH)
            bytestream2_skip(&s->g, 2);
1005
        else
1006
            av_log(s->avctx, AV_LOG_ERROR, "EPH marker not found. instead %X\n", bytestream2_peek_be32(&s->g));
1007 1008 1009 1010 1011 1012 1013 1014 1015
    }

    for (bandno = 0; bandno < rlevel->nbands; bandno++) {
        Jpeg2000Band *band = rlevel->band + bandno;
        Jpeg2000Prec *prec = band->prec + precno;

        nb_code_blocks = prec->nb_codeblocks_height * prec->nb_codeblocks_width;
        for (cblkno = 0; cblkno < nb_code_blocks; cblkno++) {
            Jpeg2000Cblk *cblk = prec->cblk + cblkno;
1016 1017 1018 1019 1020
            for (cwsno = 0; cwsno < cblk->nb_lengthinc; cwsno ++) {
                if (   bytestream2_get_bytes_left(&s->g) < cblk->lengthinc[cwsno]
                    || sizeof(cblk->data) < cblk->length + cblk->lengthinc[cwsno] + 4
                ) {
                    av_log(s->avctx, AV_LOG_ERROR,
1021 1022
                        "Block length %"PRIu16" or lengthinc %d is too large, left %d\n",
                        cblk->length, cblk->lengthinc[cwsno], bytestream2_get_bytes_left(&s->g));
1023 1024
                    return AVERROR_INVALIDDATA;
                }
1025

1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036
                bytestream2_get_bufferu(&s->g, cblk->data + cblk->length, cblk->lengthinc[cwsno]);
                cblk->length   += cblk->lengthinc[cwsno];
                cblk->lengthinc[cwsno] = 0;
                if (cblk->nb_terminationsinc) {
                    cblk->nb_terminationsinc--;
                    cblk->nb_terminations++;
                    cblk->data[cblk->length++] = 0xFF;
                    cblk->data[cblk->length++] = 0xFF;
                    cblk->data_start[cblk->nb_terminations] = cblk->length;
                }
            }
1037 1038 1039 1040 1041
        }
    }
    return 0;
}

1042 1043 1044
static int jpeg2000_decode_packets_po_iteration(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile,
                                             int RSpoc, int CSpoc,
                                             int LYEpoc, int REpoc, int CEpoc,
1045
                                             int Ppoc, int *tp_index)
1046
{
1047 1048
    int ret = 0;
    int layno, reslevelno, compno, precno, ok_reslevel;
1049
    int x, y;
1050
    int step_x, step_y;
1051

1052
    switch (Ppoc) {
1053
    case JPEG2000_PGOD_RLCP:
1054
        av_log(s->avctx, AV_LOG_DEBUG, "Progression order RLCP\n");
1055
        ok_reslevel = 1;
1056
        for (reslevelno = RSpoc; ok_reslevel && reslevelno < REpoc; reslevelno++) {
1057
            ok_reslevel = 0;
1058 1059
            for (layno = 0; layno < LYEpoc; layno++) {
                for (compno = CSpoc; compno < CEpoc; compno++) {
1060 1061 1062 1063 1064 1065 1066
                    Jpeg2000CodingStyle *codsty = tile->codsty + compno;
                    Jpeg2000QuantStyle *qntsty  = tile->qntsty + compno;
                    if (reslevelno < codsty->nreslevels) {
                        Jpeg2000ResLevel *rlevel = tile->comp[compno].reslevel +
                                                reslevelno;
                        ok_reslevel = 1;
                        for (precno = 0; precno < rlevel->num_precincts_x * rlevel->num_precincts_y; precno++)
1067
                            if ((ret = jpeg2000_decode_packet(s, tile, tp_index,
1068 1069 1070 1071 1072 1073 1074 1075 1076 1077
                                                              codsty, rlevel,
                                                              precno, layno,
                                                              qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
                                                              qntsty->nguardbits)) < 0)
                                return ret;
                    }
                }
            }
        }
        break;
1078

1079
    case JPEG2000_PGOD_LRCP:
1080
        av_log(s->avctx, AV_LOG_DEBUG, "Progression order LRCP\n");
1081
        for (layno = 0; layno < LYEpoc; layno++) {
1082
            ok_reslevel = 1;
1083
            for (reslevelno = RSpoc; ok_reslevel && reslevelno < REpoc; reslevelno++) {
1084
                ok_reslevel = 0;
1085
                for (compno = CSpoc; compno < CEpoc; compno++) {
1086 1087 1088 1089
                    Jpeg2000CodingStyle *codsty = tile->codsty + compno;
                    Jpeg2000QuantStyle *qntsty  = tile->qntsty + compno;
                    if (reslevelno < codsty->nreslevels) {
                        Jpeg2000ResLevel *rlevel = tile->comp[compno].reslevel +
1090
                                                reslevelno;
1091 1092
                        ok_reslevel = 1;
                        for (precno = 0; precno < rlevel->num_precincts_x * rlevel->num_precincts_y; precno++)
1093
                            if ((ret = jpeg2000_decode_packet(s, tile, tp_index,
1094 1095 1096 1097 1098
                                                              codsty, rlevel,
                                                              precno, layno,
                                                              qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
                                                              qntsty->nguardbits)) < 0)
                                return ret;
1099 1100 1101 1102 1103 1104 1105
                    }
                }
            }
        }
        break;

    case JPEG2000_PGOD_CPRL:
1106
        av_log(s->avctx, AV_LOG_DEBUG, "Progression order CPRL\n");
1107
        for (compno = CSpoc; compno < CEpoc; compno++) {
1108
            Jpeg2000Component *comp     = tile->comp + compno;
1109 1110
            Jpeg2000CodingStyle *codsty = tile->codsty + compno;
            Jpeg2000QuantStyle *qntsty  = tile->qntsty + compno;
1111 1112
            step_x = 32;
            step_y = 32;
1113

1114
            for (reslevelno = RSpoc; reslevelno < FFMIN(codsty->nreslevels, REpoc); reslevelno++) {
1115
                uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; //  ==> N_L - r
1116
                Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1117 1118 1119
                step_x = FFMIN(step_x, rlevel->log2_prec_width  + reducedresno);
                step_y = FFMIN(step_y, rlevel->log2_prec_height + reducedresno);
            }
1120
            av_assert0(step_x < 32 && step_y < 32);
1121 1122
            step_x = 1<<step_x;
            step_y = 1<<step_y;
1123

1124 1125
            for (y = tile->coord[1][0]; y < tile->coord[1][1]; y = (y/step_y + 1)*step_y) {
                for (x = tile->coord[0][0]; x < tile->coord[0][1]; x = (x/step_x + 1)*step_x) {
1126
                    for (reslevelno = RSpoc; reslevelno < FFMIN(codsty->nreslevels, REpoc); reslevelno++) {
1127
                        unsigned prcx, prcy;
1128
                        uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; //  ==> N_L - r
1129
                        Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1130 1131
                        int xc = x / s->cdx[compno];
                        int yc = y / s->cdy[compno];
1132

1133
                        if (yc % (1 << (rlevel->log2_prec_height + reducedresno)) && y != tile->coord[1][0]) //FIXME this is a subset of the check
1134 1135
                            continue;

1136
                        if (xc % (1 << (rlevel->log2_prec_width + reducedresno)) && x != tile->coord[0][0]) //FIXME this is a subset of the check
1137 1138 1139
                            continue;

                        // check if a precinct exists
1140 1141
                        prcx   = ff_jpeg2000_ceildivpow2(xc, reducedresno) >> rlevel->log2_prec_width;
                        prcy   = ff_jpeg2000_ceildivpow2(yc, reducedresno) >> rlevel->log2_prec_height;
1142 1143 1144
                        prcx  -= ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], reducedresno) >> rlevel->log2_prec_width;
                        prcy  -= ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], reducedresno) >> rlevel->log2_prec_height;

1145
                        precno = prcx + rlevel->num_precincts_x * prcy;
1146

1147 1148 1149 1150 1151
                        if (prcx >= rlevel->num_precincts_x || prcy >= rlevel->num_precincts_y) {
                            av_log(s->avctx, AV_LOG_WARNING, "prc %d %d outside limits %d %d\n",
                                   prcx, prcy, rlevel->num_precincts_x, rlevel->num_precincts_y);
                            continue;
                        }
1152

1153
                        for (layno = 0; layno < LYEpoc; layno++) {
1154
                            if ((ret = jpeg2000_decode_packet(s, tile, tp_index, codsty, rlevel,
1155 1156 1157 1158
                                                              precno, layno,
                                                              qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
                                                              qntsty->nguardbits)) < 0)
                                return ret;
1159 1160 1161 1162 1163 1164 1165
                        }
                    }
                }
            }
        }
        break;

1166
    case JPEG2000_PGOD_RPCL:
1167 1168
        av_log(s->avctx, AV_LOG_WARNING, "Progression order RPCL\n");
        ok_reslevel = 1;
1169
        for (reslevelno = RSpoc; ok_reslevel && reslevelno < REpoc; reslevelno++) {
1170
            ok_reslevel = 0;
1171 1172
            step_x = 30;
            step_y = 30;
1173
            for (compno = CSpoc; compno < CEpoc; compno++) {
1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186
                Jpeg2000Component *comp     = tile->comp + compno;
                Jpeg2000CodingStyle *codsty = tile->codsty + compno;

                if (reslevelno < codsty->nreslevels) {
                    uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; //  ==> N_L - r
                    Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
                    step_x = FFMIN(step_x, rlevel->log2_prec_width  + reducedresno);
                    step_y = FFMIN(step_y, rlevel->log2_prec_height + reducedresno);
                }
            }
            step_x = 1<<step_x;
            step_y = 1<<step_y;

1187 1188
            for (y = tile->coord[1][0]; y < tile->coord[1][1]; y = (y/step_y + 1)*step_y) {
                for (x = tile->coord[0][0]; x < tile->coord[0][1]; x = (x/step_x + 1)*step_x) {
1189
                    for (compno = CSpoc; compno < CEpoc; compno++) {
1190 1191 1192 1193 1194 1195 1196 1197 1198 1199
                        Jpeg2000Component *comp     = tile->comp + compno;
                        Jpeg2000CodingStyle *codsty = tile->codsty + compno;
                        Jpeg2000QuantStyle *qntsty  = tile->qntsty + compno;
                        uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; //  ==> N_L - r
                        Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
                        unsigned prcx, prcy;

                        int xc = x / s->cdx[compno];
                        int yc = y / s->cdy[compno];

1200 1201 1202
                        if (reslevelno >= codsty->nreslevels)
                            continue;

1203
                        if (yc % (1 << (rlevel->log2_prec_height + reducedresno)) && y != tile->coord[1][0]) //FIXME this is a subset of the check
1204 1205
                            continue;

1206
                        if (xc % (1 << (rlevel->log2_prec_width + reducedresno)) && x != tile->coord[0][0]) //FIXME this is a subset of the check
1207 1208 1209 1210 1211 1212 1213 1214 1215 1216
                            continue;

                        // check if a precinct exists
                        prcx   = ff_jpeg2000_ceildivpow2(xc, reducedresno) >> rlevel->log2_prec_width;
                        prcy   = ff_jpeg2000_ceildivpow2(yc, reducedresno) >> rlevel->log2_prec_height;
                        prcx  -= ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], reducedresno) >> rlevel->log2_prec_width;
                        prcy  -= ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], reducedresno) >> rlevel->log2_prec_height;

                        precno = prcx + rlevel->num_precincts_x * prcy;

1217
                        ok_reslevel = 1;
1218 1219 1220 1221 1222 1223
                        if (prcx >= rlevel->num_precincts_x || prcy >= rlevel->num_precincts_y) {
                            av_log(s->avctx, AV_LOG_WARNING, "prc %d %d outside limits %d %d\n",
                                   prcx, prcy, rlevel->num_precincts_x, rlevel->num_precincts_y);
                            continue;
                        }

1224
                            for (layno = 0; layno < LYEpoc; layno++) {
1225
                                if ((ret = jpeg2000_decode_packet(s, tile, tp_index,
1226 1227 1228 1229 1230 1231 1232 1233 1234 1235
                                                                codsty, rlevel,
                                                                precno, layno,
                                                                qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
                                                                qntsty->nguardbits)) < 0)
                                    return ret;
                            }
                    }
                }
            }
        }
1236 1237 1238
        break;

    case JPEG2000_PGOD_PCRL:
1239
        av_log(s->avctx, AV_LOG_WARNING, "Progression order PCRL\n");
1240 1241
        step_x = 32;
        step_y = 32;
1242
        for (compno = CSpoc; compno < CEpoc; compno++) {
1243 1244 1245
            Jpeg2000Component *comp     = tile->comp + compno;
            Jpeg2000CodingStyle *codsty = tile->codsty + compno;

1246
            for (reslevelno = RSpoc; reslevelno < FFMIN(codsty->nreslevels, REpoc); reslevelno++) {
1247 1248 1249 1250 1251 1252
                uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; //  ==> N_L - r
                Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
                step_x = FFMIN(step_x, rlevel->log2_prec_width  + reducedresno);
                step_y = FFMIN(step_y, rlevel->log2_prec_height + reducedresno);
            }
        }
1253 1254 1255 1256
        if (step_x >= 31 || step_y >= 31){
            avpriv_request_sample(s->avctx, "PCRL with large step");
            return AVERROR_PATCHWELCOME;
        }
1257 1258 1259
        step_x = 1<<step_x;
        step_y = 1<<step_y;

1260 1261
        for (y = tile->coord[1][0]; y < tile->coord[1][1]; y = (y/step_y + 1)*step_y) {
            for (x = tile->coord[0][0]; x < tile->coord[0][1]; x = (x/step_x + 1)*step_x) {
1262
                for (compno = CSpoc; compno < CEpoc; compno++) {
1263 1264 1265 1266 1267 1268
                    Jpeg2000Component *comp     = tile->comp + compno;
                    Jpeg2000CodingStyle *codsty = tile->codsty + compno;
                    Jpeg2000QuantStyle *qntsty  = tile->qntsty + compno;
                    int xc = x / s->cdx[compno];
                    int yc = y / s->cdy[compno];

1269
                    for (reslevelno = RSpoc; reslevelno < FFMIN(codsty->nreslevels, REpoc); reslevelno++) {
1270 1271 1272 1273
                        unsigned prcx, prcy;
                        uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; //  ==> N_L - r
                        Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;

1274
                        if (yc % (1 << (rlevel->log2_prec_height + reducedresno)) && y != tile->coord[1][0]) //FIXME this is a subset of the check
1275 1276
                            continue;

1277
                        if (xc % (1 << (rlevel->log2_prec_width + reducedresno)) && x != tile->coord[0][0]) //FIXME this is a subset of the check
1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293
                            continue;

                        // check if a precinct exists
                        prcx   = ff_jpeg2000_ceildivpow2(xc, reducedresno) >> rlevel->log2_prec_width;
                        prcy   = ff_jpeg2000_ceildivpow2(yc, reducedresno) >> rlevel->log2_prec_height;
                        prcx  -= ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], reducedresno) >> rlevel->log2_prec_width;
                        prcy  -= ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], reducedresno) >> rlevel->log2_prec_height;

                        precno = prcx + rlevel->num_precincts_x * prcy;

                        if (prcx >= rlevel->num_precincts_x || prcy >= rlevel->num_precincts_y) {
                            av_log(s->avctx, AV_LOG_WARNING, "prc %d %d outside limits %d %d\n",
                                   prcx, prcy, rlevel->num_precincts_x, rlevel->num_precincts_y);
                            continue;
                        }

1294
                        for (layno = 0; layno < LYEpoc; layno++) {
1295
                            if ((ret = jpeg2000_decode_packet(s, tile, tp_index, codsty, rlevel,
1296 1297 1298 1299 1300 1301 1302 1303 1304
                                                              precno, layno,
                                                              qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
                                                              qntsty->nguardbits)) < 0)
                                return ret;
                        }
                    }
                }
            }
        }
1305 1306
        break;

1307 1308 1309 1310
    default:
        break;
    }

1311 1312 1313 1314 1315
    return ret;
}

static int jpeg2000_decode_packets(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
{
1316 1317
    int ret = AVERROR_BUG;
    int i;
1318
    int tp_index = 0;
1319 1320 1321 1322 1323 1324 1325

    s->bit_index = 8;
    if (tile->poc.nb_poc) {
        for (i=0; i<tile->poc.nb_poc; i++) {
            Jpeg2000POCEntry *e = &tile->poc.poc[i];
            ret = jpeg2000_decode_packets_po_iteration(s, tile,
                e->RSpoc, e->CSpoc,
1326 1327 1328
                FFMIN(e->LYEpoc, tile->codsty[0].nlayers),
                e->REpoc,
                FFMIN(e->CEpoc, s->ncomponents),
1329
                e->Ppoc, &tp_index
1330 1331 1332 1333 1334 1335 1336 1337 1338 1339
                );
            if (ret < 0)
                return ret;
        }
    } else {
        ret = jpeg2000_decode_packets_po_iteration(s, tile,
            0, 0,
            tile->codsty[0].nlayers,
            33,
            s->ncomponents,
1340 1341
            tile->codsty[0].prog_order,
            &tp_index
1342 1343
        );
    }
1344
    /* EOC marker reached */
1345
    bytestream2_skip(&s->g, 2);
1346

1347
    return ret;
1348 1349 1350 1351
}

/* TIER-1 routines */
static void decode_sigpass(Jpeg2000T1Context *t1, int width, int height,
1352
                           int bpno, int bandno,
1353
                           int vert_causal_ctx_csty_symbol)
1354 1355 1356 1357 1358
{
    int mask = 3 << (bpno - 1), y0, x, y;

    for (y0 = 0; y0 < height; y0 += 4)
        for (x = 0; x < width; x++)
1359
            for (y = y0; y < height && y < y0 + 4; y++) {
1360 1361 1362
                int flags_mask = -1;
                if (vert_causal_ctx_csty_symbol && y == y0 + 3)
                    flags_mask &= ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE | JPEG2000_T1_SGN_S);
1363 1364 1365 1366
                if ((t1->flags[(y+1) * t1->stride + x+1] & JPEG2000_T1_SIG_NB & flags_mask)
                && !(t1->flags[(y+1) * t1->stride + x+1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS))) {
                    if (ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ff_jpeg2000_getsigctxno(t1->flags[(y+1) * t1->stride + x+1] & flags_mask, bandno))) {
                        int xorbit, ctxno = ff_jpeg2000_getsgnctxno(t1->flags[(y+1) * t1->stride + x+1] & flags_mask, &xorbit);
1367
                        if (t1->mqc.raw)
1368
                             t1->data[(y) * t1->stride + x] = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ctxno) ? -mask : mask;
1369
                        else
1370
                             t1->data[(y) * t1->stride + x] = (ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ctxno) ^ xorbit) ?
1371
                                               -mask : mask;
1372 1373

                        ff_jpeg2000_set_significance(t1, x, y,
1374
                                                     t1->data[(y) * t1->stride + x] < 0);
1375
                    }
1376
                    t1->flags[(y + 1) * t1->stride + x + 1] |= JPEG2000_T1_VIS;
1377
                }
1378
            }
1379 1380 1381
}

static void decode_refpass(Jpeg2000T1Context *t1, int width, int height,
1382
                           int bpno, int vert_causal_ctx_csty_symbol)
1383 1384 1385 1386 1387 1388 1389 1390 1391 1392
{
    int phalf, nhalf;
    int y0, x, y;

    phalf = 1 << (bpno - 1);
    nhalf = -phalf;

    for (y0 = 0; y0 < height; y0 += 4)
        for (x = 0; x < width; x++)
            for (y = y0; y < height && y < y0 + 4; y++)
1393
                if ((t1->flags[(y + 1) * t1->stride + x + 1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS)) == JPEG2000_T1_SIG) {
1394 1395
                    int flags_mask = (vert_causal_ctx_csty_symbol && y == y0 + 3) ?
                        ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE | JPEG2000_T1_SGN_S) : -1;
1396
                    int ctxno = ff_jpeg2000_getrefctxno(t1->flags[(y + 1) * t1->stride + x + 1] & flags_mask);
1397 1398 1399
                    int r     = ff_mqc_decode(&t1->mqc,
                                              t1->mqc.cx_states + ctxno)
                                ? phalf : nhalf;
1400 1401
                    t1->data[(y) * t1->stride + x]          += t1->data[(y) * t1->stride + x] < 0 ? -r : r;
                    t1->flags[(y + 1) * t1->stride + x + 1] |= JPEG2000_T1_REF;
1402 1403 1404 1405 1406
                }
}

static void decode_clnpass(Jpeg2000DecoderContext *s, Jpeg2000T1Context *t1,
                           int width, int height, int bpno, int bandno,
1407
                           int seg_symbols, int vert_causal_ctx_csty_symbol)
1408 1409 1410
{
    int mask = 3 << (bpno - 1), y0, x, y, runlen, dec;

1411
    for (y0 = 0; y0 < height; y0 += 4) {
1412
        for (x = 0; x < width; x++) {
1413 1414 1415
            int flags_mask = -1;
            if (vert_causal_ctx_csty_symbol)
                flags_mask &= ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE | JPEG2000_T1_SGN_S);
1416
            if (y0 + 3 < height &&
1417 1418 1419 1420
                !((t1->flags[(y0 + 1) * t1->stride + x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
                  (t1->flags[(y0 + 2) * t1->stride + x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
                  (t1->flags[(y0 + 3) * t1->stride + x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
                  (t1->flags[(y0 + 4) * t1->stride + x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG) & flags_mask))) {
1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434
                if (!ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_RL))
                    continue;
                runlen = ff_mqc_decode(&t1->mqc,
                                       t1->mqc.cx_states + MQC_CX_UNI);
                runlen = (runlen << 1) | ff_mqc_decode(&t1->mqc,
                                                       t1->mqc.cx_states +
                                                       MQC_CX_UNI);
                dec = 1;
            } else {
                runlen = 0;
                dec    = 0;
            }

            for (y = y0 + runlen; y < y0 + 4 && y < height; y++) {
1435 1436 1437
                int flags_mask = -1;
                if (vert_causal_ctx_csty_symbol && y == y0 + 3)
                    flags_mask &= ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE | JPEG2000_T1_SGN_S);
1438
                if (!dec) {
1439 1440
                    if (!(t1->flags[(y+1) * t1->stride + x+1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS))) {
                        dec = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ff_jpeg2000_getsigctxno(t1->flags[(y+1) * t1->stride + x+1] & flags_mask,
1441 1442
                                                                                             bandno));
                    }
1443 1444 1445
                }
                if (dec) {
                    int xorbit;
1446
                    int ctxno = ff_jpeg2000_getsgnctxno(t1->flags[(y + 1) * t1->stride + x + 1] & flags_mask,
1447
                                                        &xorbit);
1448
                    t1->data[(y) * t1->stride + x] = (ff_mqc_decode(&t1->mqc,
1449 1450 1451
                                                    t1->mqc.cx_states + ctxno) ^
                                      xorbit)
                                     ? -mask : mask;
1452
                    ff_jpeg2000_set_significance(t1, x, y, t1->data[(y) * t1->stride + x] < 0);
1453 1454
                }
                dec = 0;
1455
                t1->flags[(y + 1) * t1->stride + x + 1] &= ~JPEG2000_T1_VIS;
1456 1457
            }
        }
1458
    }
1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474
    if (seg_symbols) {
        int val;
        val = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
        val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
        val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
        val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
        if (val != 0xa)
            av_log(s->avctx, AV_LOG_ERROR,
                   "Segmentation symbol value incorrect\n");
    }
}

static int decode_cblk(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *codsty,
                       Jpeg2000T1Context *t1, Jpeg2000Cblk *cblk,
                       int width, int height, int bandpos)
{
1475
    int passno = cblk->npasses, pass_t = 2, bpno = cblk->nonzerobits - 1;
1476
    int pass_cnt = 0;
1477
    int vert_causal_ctx_csty_symbol = codsty->cblk_style & JPEG2000_CBLK_VSC;
1478 1479
    int term_cnt = 0;
    int coder_type;
1480

1481 1482
    av_assert0(width <= 1024U && height <= 1024U);
    av_assert0(width*height <= 4096);
1483

1484
    memset(t1->data, 0, t1->stride * height * sizeof(*t1->data));
1485

1486
    /* If code-block contains no compressed data: nothing to do. */
1487
    if (!cblk->length)
1488 1489
        return 0;

1490
    memset(t1->flags, 0, t1->stride * (height + 2) * sizeof(*t1->flags));
1491 1492 1493

    cblk->data[cblk->length] = 0xff;
    cblk->data[cblk->length+1] = 0xff;
1494
    ff_mqc_initdec(&t1->mqc, cblk->data, 0, 1);
1495 1496

    while (passno--) {
1497 1498 1499 1500
        if (bpno < 0) {
            av_log(s->avctx, AV_LOG_ERROR, "bpno became negative\n");
            return AVERROR_INVALIDDATA;
        }
1501
        switch(pass_t) {
1502
        case 0:
1503
            decode_sigpass(t1, width, height, bpno + 1, bandpos,
1504
                           vert_causal_ctx_csty_symbol);
1505 1506
            break;
        case 1:
1507
            decode_refpass(t1, width, height, bpno + 1, vert_causal_ctx_csty_symbol);
1508 1509
            break;
        case 2:
1510
            av_assert2(!t1->mqc.raw);
1511
            decode_clnpass(s, t1, width, height, bpno + 1, bandpos,
1512 1513
                           codsty->cblk_style & JPEG2000_CBLK_SEGSYM,
                           vert_causal_ctx_csty_symbol);
1514 1515
            break;
        }
1516 1517 1518
        if (codsty->cblk_style & JPEG2000_CBLK_RESET) // XXX no testcase for just this
            ff_mqc_init_contexts(&t1->mqc);

1519
        if (passno && (coder_type = needs_termination(codsty->cblk_style, pass_cnt))) {
1520
            if (term_cnt >= cblk->nb_terminations) {
1521 1522 1523
                av_log(s->avctx, AV_LOG_ERROR, "Missing needed termination \n");
                return AVERROR_INVALIDDATA;
            }
1524 1525 1526 1527 1528 1529
            if (FFABS(cblk->data + cblk->data_start[term_cnt + 1] - 2 - t1->mqc.bp) > 0) {
                av_log(s->avctx, AV_LOG_WARNING, "Mid mismatch %"PTRDIFF_SPECIFIER" in pass %d of %d\n",
                    cblk->data + cblk->data_start[term_cnt + 1] - 2 - t1->mqc.bp,
                    pass_cnt, cblk->npasses);
            }

1530 1531
            ff_mqc_initdec(&t1->mqc, cblk->data + cblk->data_start[++term_cnt], coder_type == 2, 0);
        }
1532 1533 1534 1535 1536 1537

        pass_t++;
        if (pass_t == 3) {
            bpno--;
            pass_t = 0;
        }
1538
        pass_cnt ++;
1539
    }
1540

1541 1542 1543
    if (cblk->data + cblk->length - 2*(term_cnt < cblk->nb_terminations) != t1->mqc.bp) {
        av_log(s->avctx, AV_LOG_WARNING, "End mismatch %"PTRDIFF_SPECIFIER"\n",
               cblk->data + cblk->length - 2*(term_cnt < cblk->nb_terminations) - t1->mqc.bp);
1544 1545
    }

1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559
    return 0;
}

/* TODO: Verify dequantization for lossless case
 * comp->data can be float or int
 * band->stepsize can be float or int
 * depending on the type of DWT transformation.
 * see ISO/IEC 15444-1:2002 A.6.1 */

/* Float dequantization of a codeblock.*/
static void dequantization_float(int x, int y, Jpeg2000Cblk *cblk,
                                 Jpeg2000Component *comp,
                                 Jpeg2000T1Context *t1, Jpeg2000Band *band)
{
1560 1561 1562 1563
    int i, j;
    int w = cblk->coord[0][1] - cblk->coord[0][0];
    for (j = 0; j < (cblk->coord[1][1] - cblk->coord[1][0]); ++j) {
        float *datap = &comp->f_data[(comp->coord[0][1] - comp->coord[0][0]) * (y + j) + x];
1564
        int *src = t1->data + j*t1->stride;
1565 1566 1567
        for (i = 0; i < w; ++i)
            datap[i] = src[i] * band->f_stepsize;
    }
1568 1569 1570 1571 1572 1573 1574
}

/* Integer dequantization of a codeblock.*/
static void dequantization_int(int x, int y, Jpeg2000Cblk *cblk,
                               Jpeg2000Component *comp,
                               Jpeg2000T1Context *t1, Jpeg2000Band *band)
{
1575 1576 1577 1578
    int i, j;
    int w = cblk->coord[0][1] - cblk->coord[0][0];
    for (j = 0; j < (cblk->coord[1][1] - cblk->coord[1][0]); ++j) {
        int32_t *datap = &comp->i_data[(comp->coord[0][1] - comp->coord[0][0]) * (y + j) + x];
1579
        int *src = t1->data + j*t1->stride;
1580
        if (band->i_stepsize == 32768) {
1581 1582 1583 1584 1585
            for (i = 0; i < w; ++i)
                datap[i] = src[i] / 2;
        } else {
            // This should be VERY uncommon
            for (i = 0; i < w; ++i)
1586
                datap[i] = (src[i] * (int64_t)band->i_stepsize) / 65536;
1587
        }
1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598
    }
}

static void dequantization_int_97(int x, int y, Jpeg2000Cblk *cblk,
                               Jpeg2000Component *comp,
                               Jpeg2000T1Context *t1, Jpeg2000Band *band)
{
    int i, j;
    int w = cblk->coord[0][1] - cblk->coord[0][0];
    for (j = 0; j < (cblk->coord[1][1] - cblk->coord[1][0]); ++j) {
        int32_t *datap = &comp->i_data[(comp->coord[0][1] - comp->coord[0][0]) * (y + j) + x];
1599
        int *src = t1->data + j*t1->stride;
1600
        for (i = 0; i < w; ++i)
1601
            datap[i] = (src[i] * (int64_t)band->i_stepsize + (1<<15)) >> 16;
1602
    }
1603 1604
}

1605
static inline void mct_decode(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
1606 1607
{
    int i, csize = 1;
1608
    void *src[3];
1609

1610
    for (i = 1; i < 3; i++) {
1611 1612 1613 1614
        if (tile->codsty[0].transform != tile->codsty[i].transform) {
            av_log(s->avctx, AV_LOG_ERROR, "Transforms mismatch, MCT not supported\n");
            return;
        }
1615 1616 1617 1618 1619
        if (memcmp(tile->comp[0].coord, tile->comp[i].coord, sizeof(tile->comp[0].coord))) {
            av_log(s->avctx, AV_LOG_ERROR, "Coords mismatch, MCT not supported\n");
            return;
        }
    }
1620

1621 1622
    for (i = 0; i < 3; i++)
        if (tile->codsty[0].transform == FF_DWT97)
1623
            src[i] = tile->comp[i].f_data;
1624
        else
1625
            src[i] = tile->comp[i].i_data;
1626 1627 1628

    for (i = 0; i < 2; i++)
        csize *= tile->comp[0].coord[i][1] - tile->comp[0].coord[i][0];
1629

1630
    s->dsp.mct_decode[tile->codsty[0].transform](src[0], src[1], src[2], csize);
1631 1632
}

1633
static inline void tile_codeblocks(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
1634 1635 1636 1637 1638
{
    Jpeg2000T1Context t1;

    int compno, reslevelno, bandno;

1639
    /* Loop on tile components */
1640 1641 1642
    for (compno = 0; compno < s->ncomponents; compno++) {
        Jpeg2000Component *comp     = tile->comp + compno;
        Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1643

1644 1645
        t1.stride = (1<<codsty->log2_cblk_width) + 2;

1646 1647 1648 1649 1650
        /* Loop on resolution levels */
        for (reslevelno = 0; reslevelno < codsty->nreslevels2decode; reslevelno++) {
            Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
            /* Loop on bands */
            for (bandno = 0; bandno < rlevel->nbands; bandno++) {
1651
                int nb_precincts, precno;
1652 1653
                Jpeg2000Band *band = rlevel->band + bandno;
                int cblkno = 0, bandpos;
1654

1655 1656
                bandpos = bandno + (reslevelno > 0);

1657 1658
                if (band->coord[0][0] == band->coord[0][1] ||
                    band->coord[1][0] == band->coord[1][1])
1659 1660
                    continue;

1661 1662 1663 1664 1665 1666
                nb_precincts = rlevel->num_precincts_x * rlevel->num_precincts_y;
                /* Loop on precincts */
                for (precno = 0; precno < nb_precincts; precno++) {
                    Jpeg2000Prec *prec = band->prec + precno;

                    /* Loop on codeblocks */
1667 1668 1669
                    for (cblkno = 0;
                         cblkno < prec->nb_codeblocks_width * prec->nb_codeblocks_height;
                         cblkno++) {
1670 1671 1672 1673 1674 1675 1676
                        int x, y;
                        Jpeg2000Cblk *cblk = prec->cblk + cblkno;
                        decode_cblk(s, codsty, &t1, cblk,
                                    cblk->coord[0][1] - cblk->coord[0][0],
                                    cblk->coord[1][1] - cblk->coord[1][0],
                                    bandpos);

1677 1678
                        x = cblk->coord[0][0] - band->coord[0][0];
                        y = cblk->coord[1][0] - band->coord[1][0];
1679

1680
                        if (codsty->transform == FF_DWT97)
1681
                            dequantization_float(x, y, cblk, comp, &t1, band);
1682 1683
                        else if (codsty->transform == FF_DWT97_INT)
                            dequantization_int_97(x, y, cblk, comp, &t1, band);
1684 1685
                        else
                            dequantization_int(x, y, cblk, comp, &t1, band);
1686 1687 1688 1689 1690 1691
                   } /* end cblk */
                } /*end prec */
            } /* end band */
        } /* end reslevel */

        /* inverse DWT */
1692
        ff_dwt_decode(&comp->dwt, codsty->transform == FF_DWT97 ? (void*)comp->f_data : (void*)comp->i_data);
1693
    } /*end comp */
1694 1695
}

1696 1697
#define WRITE_FRAME(D, PIXEL)                                                                     \
    static inline void write_frame_ ## D(Jpeg2000DecoderContext * s, Jpeg2000Tile * tile,         \
1698
                                         AVFrame * picture, int precision)                        \
1699
    {                                                                                             \
1700 1701 1702 1703
        const AVPixFmtDescriptor *pixdesc = av_pix_fmt_desc_get(s->avctx->pix_fmt);               \
        int planar    = !!(pixdesc->flags & AV_PIX_FMT_FLAG_PLANAR);                              \
        int pixelsize = planar ? 1 : pixdesc->nb_components;                                      \
                                                                                                  \
1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714
        int compno;                                                                               \
        int x, y;                                                                                 \
                                                                                                  \
        for (compno = 0; compno < s->ncomponents; compno++) {                                     \
            Jpeg2000Component *comp     = tile->comp + compno;                                    \
            Jpeg2000CodingStyle *codsty = tile->codsty + compno;                                  \
            PIXEL *line;                                                                          \
            float *datap     = comp->f_data;                                                      \
            int32_t *i_datap = comp->i_data;                                                      \
            int cbps         = s->cbps[compno];                                                   \
            int w            = tile->comp[compno].coord[0][1] - s->image_offset_x;                \
1715 1716 1717 1718
            int plane        = 0;                                                                 \
                                                                                                  \
            if (planar)                                                                           \
                plane = s->cdef[compno] ? s->cdef[compno]-1 : (s->ncomponents-1);                 \
1719
                                                                                                  \
1720 1721 1722
            y    = tile->comp[compno].coord[1][0] - s->image_offset_y / s->cdy[compno];           \
            line = (PIXEL *)picture->data[plane] + y * (picture->linesize[plane] / sizeof(PIXEL));\
            for (; y < tile->comp[compno].coord[1][1] - s->image_offset_y; y++) {                 \
1723 1724
                PIXEL *dst;                                                                       \
                                                                                                  \
1725 1726
                x   = tile->comp[compno].coord[0][0] - s->image_offset_x / s->cdx[compno];        \
                dst = line + x * pixelsize + compno*!planar;                                      \
1727 1728
                                                                                                  \
                if (codsty->transform == FF_DWT97) {                                              \
1729
                    for (; x < w; x++) {                                                          \
1730 1731 1732
                        int val = lrintf(*datap) + (1 << (cbps - 1));                             \
                        /* DC level shift and clip see ISO 15444-1:2002 G.1.2 */                  \
                        val  = av_clip(val, 0, (1 << cbps) - 1);                                  \
1733
                        *dst = val << (precision - cbps);                                         \
1734
                        datap++;                                                                  \
1735
                        dst += pixelsize;                                                         \
1736 1737
                    }                                                                             \
                } else {                                                                          \
1738
                    for (; x < w; x++) {                                                          \
1739 1740 1741
                        int val = *i_datap + (1 << (cbps - 1));                                   \
                        /* DC level shift and clip see ISO 15444-1:2002 G.1.2 */                  \
                        val  = av_clip(val, 0, (1 << cbps) - 1);                                  \
1742
                        *dst = val << (precision - cbps);                                         \
1743
                        i_datap++;                                                                \
1744
                        dst += pixelsize;                                                         \
1745 1746
                    }                                                                             \
                }                                                                                 \
1747
                line += picture->linesize[plane] / sizeof(PIXEL);                                 \
1748 1749 1750 1751 1752 1753 1754 1755 1756 1757
            }                                                                                     \
        }                                                                                         \
                                                                                                  \
    }

WRITE_FRAME(8, uint8_t)
WRITE_FRAME(16, uint16_t)

#undef WRITE_FRAME

1758 1759
static int jpeg2000_decode_tile(AVCodecContext *avctx, void *td,
                                int jobnr, int threadnr)
1760
{
1761 1762 1763
    Jpeg2000DecoderContext *s = avctx->priv_data;
    AVFrame *picture = td;
    Jpeg2000Tile *tile = s->tile + jobnr;
1764
    int x;
1765 1766

    tile_codeblocks(s, tile);
1767 1768 1769 1770 1771

    /* inverse MCT transformation */
    if (tile->codsty[0].mct)
        mct_decode(s, tile);

1772 1773 1774 1775 1776 1777 1778 1779 1780
    for (x = 0; x < s->ncomponents; x++) {
        if (s->cdef[x] < 0) {
            for (x = 0; x < s->ncomponents; x++) {
                s->cdef[x] = x + 1;
            }
            if ((s->ncomponents & 1) == 0)
                s->cdef[s->ncomponents-1] = 0;
            break;
        }
1781 1782
    }

1783
    if (s->precision <= 8) {
1784
        write_frame_8(s, tile, picture, 8);
1785
    } else {
1786
        int precision = picture->format == AV_PIX_FMT_XYZ12 ||
1787 1788
                        picture->format == AV_PIX_FMT_RGB48 ||
                        picture->format == AV_PIX_FMT_RGBA64 ||
1789
                        picture->format == AV_PIX_FMT_GRAY16 ? 16 : s->precision;
1790

1791
        write_frame_16(s, tile, picture, precision);
1792
    }
1793

1794 1795 1796 1797 1798 1799 1800
    return 0;
}

static void jpeg2000_dec_cleanup(Jpeg2000DecoderContext *s)
{
    int tileno, compno;
    for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++) {
1801 1802 1803 1804
        if (s->tile[tileno].comp) {
            for (compno = 0; compno < s->ncomponents; compno++) {
                Jpeg2000Component *comp     = s->tile[tileno].comp   + compno;
                Jpeg2000CodingStyle *codsty = s->tile[tileno].codsty + compno;
1805

1806 1807 1808
                ff_jpeg2000_cleanup(comp, codsty);
            }
            av_freep(&s->tile[tileno].comp);
1809 1810 1811
        }
    }
    av_freep(&s->tile);
1812 1813
    memset(s->codsty, 0, sizeof(s->codsty));
    memset(s->qntsty, 0, sizeof(s->qntsty));
1814
    memset(s->properties, 0, sizeof(s->properties));
1815
    memset(&s->poc  , 0, sizeof(s->poc));
1816
    s->numXtiles = s->numYtiles = 0;
1817
    s->ncomponents = 0;
1818 1819 1820 1821 1822 1823
}

static int jpeg2000_read_main_headers(Jpeg2000DecoderContext *s)
{
    Jpeg2000CodingStyle *codsty = s->codsty;
    Jpeg2000QuantStyle *qntsty  = s->qntsty;
1824
    Jpeg2000POC         *poc    = &s->poc;
1825 1826 1827 1828 1829
    uint8_t *properties         = s->properties;

    for (;;) {
        int len, ret = 0;
        uint16_t marker;
1830
        int oldpos;
1831

1832
        if (bytestream2_get_bytes_left(&s->g) < 2) {
1833 1834 1835 1836
            av_log(s->avctx, AV_LOG_ERROR, "Missing EOC\n");
            break;
        }

1837 1838
        marker = bytestream2_get_be16u(&s->g);
        oldpos = bytestream2_tell(&s->g);
1839

1840
        if (marker == JPEG2000_SOD) {
1841 1842
            Jpeg2000Tile *tile;
            Jpeg2000TilePart *tp;
1843

1844 1845 1846 1847
            if (!s->tile) {
                av_log(s->avctx, AV_LOG_ERROR, "Missing SIZ\n");
                return AVERROR_INVALIDDATA;
            }
1848 1849 1850 1851
            if (s->curtileno < 0) {
                av_log(s->avctx, AV_LOG_ERROR, "Missing SOT\n");
                return AVERROR_INVALIDDATA;
            }
1852 1853 1854

            tile = s->tile + s->curtileno;
            tp = tile->tile_part + tile->tp_idx;
1855 1856 1857 1858
            if (tp->tp_end < s->g.buffer) {
                av_log(s->avctx, AV_LOG_ERROR, "Invalid tpend\n");
                return AVERROR_INVALIDDATA;
            }
1859 1860 1861 1862 1863
            bytestream2_init(&tp->tpg, s->g.buffer, tp->tp_end - s->g.buffer);
            bytestream2_skip(&s->g, tp->tp_end - s->g.buffer);

            continue;
        }
1864 1865 1866
        if (marker == JPEG2000_EOC)
            break;

1867
        len = bytestream2_get_be16(&s->g);
1868 1869
        if (len < 2 || bytestream2_get_bytes_left(&s->g) < len - 2) {
            av_log(s->avctx, AV_LOG_ERROR, "Invalid len %d left=%d\n", len, bytestream2_get_bytes_left(&s->g));
1870
            return AVERROR_INVALIDDATA;
1871
        }
1872

1873 1874
        switch (marker) {
        case JPEG2000_SIZ:
1875 1876 1877 1878
            if (s->ncomponents) {
                av_log(s->avctx, AV_LOG_ERROR, "Duplicate SIZ\n");
                return AVERROR_INVALIDDATA;
            }
1879
            ret = get_siz(s);
1880 1881
            if (!s->tile)
                s->numXtiles = s->numYtiles = 0;
1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894
            break;
        case JPEG2000_COC:
            ret = get_coc(s, codsty, properties);
            break;
        case JPEG2000_COD:
            ret = get_cod(s, codsty, properties);
            break;
        case JPEG2000_QCC:
            ret = get_qcc(s, len, qntsty, properties);
            break;
        case JPEG2000_QCD:
            ret = get_qcd(s, len, qntsty, properties);
            break;
1895 1896 1897
        case JPEG2000_POC:
            ret = get_poc(s, len, poc);
            break;
1898
        case JPEG2000_SOT:
1899
            if (!(ret = get_sot(s, len))) {
1900
                av_assert1(s->curtileno >= 0);
1901 1902
                codsty = s->tile[s->curtileno].codsty;
                qntsty = s->tile[s->curtileno].qntsty;
1903
                poc    = &s->tile[s->curtileno].poc;
1904 1905
                properties = s->tile[s->curtileno].properties;
            }
1906
            break;
1907 1908
        case JPEG2000_PLM:
            // the PLM marker is ignored
1909 1910
        case JPEG2000_COM:
            // the comment is ignored
1911
            bytestream2_skip(&s->g, len - 2);
1912 1913 1914 1915 1916
            break;
        case JPEG2000_TLM:
            // Tile-part lengths
            ret = get_tlm(s, len);
            break;
1917 1918 1919 1920
        case JPEG2000_PLT:
            // Packet length, tile-part header
            ret = get_plt(s, len);
            break;
1921 1922
        default:
            av_log(s->avctx, AV_LOG_ERROR,
1923
                   "unsupported marker 0x%.4"PRIX16" at pos 0x%X\n",
1924 1925
                   marker, bytestream2_tell(&s->g) - 4);
            bytestream2_skip(&s->g, len - 2);
1926 1927
            break;
        }
1928
        if (bytestream2_tell(&s->g) - oldpos != len || ret) {
1929
            av_log(s->avctx, AV_LOG_ERROR,
1930 1931
                   "error during processing marker segment %.4"PRIx16"\n",
                   marker);
1932 1933 1934 1935 1936 1937 1938 1939 1940 1941
            return ret ? ret : -1;
        }
    }
    return 0;
}

/* Read bit stream packets --> T2 operation. */
static int jpeg2000_read_bitstream_packets(Jpeg2000DecoderContext *s)
{
    int ret = 0;
1942
    int tileno;
1943

1944 1945 1946
    for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++) {
        Jpeg2000Tile *tile = s->tile + tileno;

1947
        if ((ret = init_tile(s, tileno)) < 0)
1948 1949 1950
            return ret;

        s->g = tile->tile_part[0].tpg;
1951
        if ((ret = jpeg2000_decode_packets(s, tile)) < 0)
1952 1953
            return ret;
    }
1954 1955 1956 1957 1958 1959

    return 0;
}

static int jp2_find_codestream(Jpeg2000DecoderContext *s)
{
1960 1961
    uint32_t atom_size, atom, atom_end;
    int search_range = 10;
1962

1963
    while (search_range
1964 1965
           &&
           bytestream2_get_bytes_left(&s->g) >= 8) {
1966 1967
        atom_size = bytestream2_get_be32u(&s->g);
        atom      = bytestream2_get_be32u(&s->g);
1968 1969 1970 1971 1972 1973 1974 1975 1976
        atom_end  = bytestream2_tell(&s->g) + atom_size - 8;

        if (atom == JP2_CODESTREAM)
            return 1;

        if (bytestream2_get_bytes_left(&s->g) < atom_size || atom_end < atom_size)
            return 0;

        if (atom == JP2_HEADER &&
1977
                   atom_size >= 16) {
1978
            uint32_t atom2_size, atom2, atom2_end;
1979 1980 1981
            do {
                atom2_size = bytestream2_get_be32u(&s->g);
                atom2      = bytestream2_get_be32u(&s->g);
1982 1983
                atom2_end  = bytestream2_tell(&s->g) + atom2_size - 8;
                if (atom2_size < 8 || atom2_end > atom_end || atom2_end < atom2_size)
1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011
                    break;
                if (atom2 == JP2_CODESTREAM) {
                    return 1;
                } else if (atom2 == MKBETAG('c','o','l','r') && atom2_size >= 7) {
                    int method = bytestream2_get_byteu(&s->g);
                    bytestream2_skipu(&s->g, 2);
                    if (method == 1) {
                        s->colour_space = bytestream2_get_be32u(&s->g);
                    }
                } else if (atom2 == MKBETAG('p','c','l','r') && atom2_size >= 6) {
                    int i, size, colour_count, colour_channels, colour_depth[3];
                    uint32_t r, g, b;
                    colour_count = bytestream2_get_be16u(&s->g);
                    colour_channels = bytestream2_get_byteu(&s->g);
                    // FIXME: Do not ignore channel_sign
                    colour_depth[0] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1;
                    colour_depth[1] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1;
                    colour_depth[2] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1;
                    size = (colour_depth[0] + 7 >> 3) * colour_count +
                           (colour_depth[1] + 7 >> 3) * colour_count +
                           (colour_depth[2] + 7 >> 3) * colour_count;
                    if (colour_count > 256   ||
                        colour_channels != 3 ||
                        colour_depth[0] > 16 ||
                        colour_depth[1] > 16 ||
                        colour_depth[2] > 16 ||
                        atom2_size < size) {
                        avpriv_request_sample(s->avctx, "Unknown palette");
2012
                        bytestream2_seek(&s->g, atom2_end, SEEK_SET);
2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036
                        continue;
                    }
                    s->pal8 = 1;
                    for (i = 0; i < colour_count; i++) {
                        if (colour_depth[0] <= 8) {
                            r = bytestream2_get_byteu(&s->g) << 8 - colour_depth[0];
                            r |= r >> colour_depth[0];
                        } else {
                            r = bytestream2_get_be16u(&s->g) >> colour_depth[0] - 8;
                        }
                        if (colour_depth[1] <= 8) {
                            g = bytestream2_get_byteu(&s->g) << 8 - colour_depth[1];
                            r |= r >> colour_depth[1];
                        } else {
                            g = bytestream2_get_be16u(&s->g) >> colour_depth[1] - 8;
                        }
                        if (colour_depth[2] <= 8) {
                            b = bytestream2_get_byteu(&s->g) << 8 - colour_depth[2];
                            r |= r >> colour_depth[2];
                        } else {
                            b = bytestream2_get_be16u(&s->g) >> colour_depth[2] - 8;
                        }
                        s->palette[i] = 0xffu << 24 | r << 16 | g << 8 | b;
                    }
2037
                } else if (atom2 == MKBETAG('c','d','e','f') && atom2_size >= 2) {
2038 2039 2040
                    int n = bytestream2_get_be16u(&s->g);
                    for (; n>0; n--) {
                        int cn   = bytestream2_get_be16(&s->g);
2041
                        int av_unused typ  = bytestream2_get_be16(&s->g);
2042
                        int asoc = bytestream2_get_be16(&s->g);
2043
                        if (cn < 4 && asoc < 4)
2044 2045
                            s->cdef[cn] = asoc;
                    }
2046
                }
2047 2048
                bytestream2_seek(&s->g, atom2_end, SEEK_SET);
            } while (atom_end - atom2_end >= 8);
2049 2050 2051
        } else {
            search_range--;
        }
2052
        bytestream2_seek(&s->g, atom_end, SEEK_SET);
2053 2054 2055 2056 2057
    }

    return 0;
}

2058 2059 2060 2061 2062 2063 2064 2065 2066
static av_cold int jpeg2000_decode_init(AVCodecContext *avctx)
{
    Jpeg2000DecoderContext *s = avctx->priv_data;

    ff_jpeg2000dsp_init(&s->dsp);

    return 0;
}

2067 2068 2069 2070
static int jpeg2000_decode_frame(AVCodecContext *avctx, void *data,
                                 int *got_frame, AVPacket *avpkt)
{
    Jpeg2000DecoderContext *s = avctx->priv_data;
2071
    ThreadFrame frame = { .f = data };
2072
    AVFrame *picture = data;
2073
    int ret;
2074 2075

    s->avctx     = avctx;
2076
    bytestream2_init(&s->g, avpkt->data, avpkt->size);
2077
    s->curtileno = -1;
2078
    memset(s->cdef, -1, sizeof(s->cdef));
2079

2080
    if (bytestream2_get_bytes_left(&s->g) < 2) {
2081
        ret = AVERROR_INVALIDDATA;
2082 2083
        goto end;
    }
2084 2085

    // check if the image is in jp2 format
2086 2087 2088 2089
    if (bytestream2_get_bytes_left(&s->g) >= 12 &&
       (bytestream2_get_be32u(&s->g) == 12) &&
       (bytestream2_get_be32u(&s->g) == JP2_SIG_TYPE) &&
       (bytestream2_get_be32u(&s->g) == JP2_SIG_VALUE)) {
2090 2091
        if (!jp2_find_codestream(s)) {
            av_log(avctx, AV_LOG_ERROR,
2092
                   "Could not find Jpeg2000 codestream atom.\n");
2093
            ret = AVERROR_INVALIDDATA;
2094
            goto end;
2095
        }
2096 2097
    } else {
        bytestream2_seek(&s->g, 0, SEEK_SET);
2098 2099
    }

2100 2101 2102
    while (bytestream2_get_bytes_left(&s->g) >= 3 && bytestream2_peek_be16(&s->g) != JPEG2000_SOC)
        bytestream2_skip(&s->g, 1);

2103
    if (bytestream2_get_be16u(&s->g) != JPEG2000_SOC) {
2104
        av_log(avctx, AV_LOG_ERROR, "SOC marker not present\n");
2105
        ret = AVERROR_INVALIDDATA;
2106
        goto end;
2107 2108
    }
    if (ret = jpeg2000_read_main_headers(s))
2109
        goto end;
2110 2111

    /* get picture buffer */
2112
    if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
2113
        goto end;
2114 2115 2116 2117
    picture->pict_type = AV_PICTURE_TYPE_I;
    picture->key_frame = 1;

    if (ret = jpeg2000_read_bitstream_packets(s))
2118
        goto end;
2119

2120
    avctx->execute2(avctx, jpeg2000_decode_tile, picture, NULL, s->numXtiles * s->numYtiles);
2121

2122 2123 2124 2125
    jpeg2000_dec_cleanup(s);

    *got_frame = 1;

2126 2127 2128
    if (s->avctx->pix_fmt == AV_PIX_FMT_PAL8)
        memcpy(picture->data[1], s->palette, 256 * sizeof(uint32_t));

2129
    return bytestream2_tell(&s->g);
2130

2131
end:
2132 2133
    jpeg2000_dec_cleanup(s);
    return ret;
2134 2135
}

2136
static av_cold void jpeg2000_init_static_data(AVCodec *codec)
2137 2138
{
    ff_jpeg2000_init_tier1_luts();
2139
    ff_mqc_init_context_tables();
2140 2141
}

2142 2143 2144 2145 2146
#define OFFSET(x) offsetof(Jpeg2000DecoderContext, x)
#define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM

static const AVOption options[] = {
    { "lowres",  "Lower the decoding resolution by a power of two",
2147
        OFFSET(reduction_factor), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, JPEG2000_MAX_RESLEVELS - 1, VD },
2148 2149 2150
    { NULL },
};

2151
static const AVClass jpeg2000_class = {
2152 2153 2154 2155 2156 2157 2158
    .class_name = "jpeg2000",
    .item_name  = av_default_item_name,
    .option     = options,
    .version    = LIBAVUTIL_VERSION_INT,
};

AVCodec ff_jpeg2000_decoder = {
2159 2160 2161 2162
    .name             = "jpeg2000",
    .long_name        = NULL_IF_CONFIG_SMALL("JPEG 2000"),
    .type             = AVMEDIA_TYPE_VIDEO,
    .id               = AV_CODEC_ID_JPEG2000,
2163
    .capabilities     = AV_CODEC_CAP_SLICE_THREADS | AV_CODEC_CAP_FRAME_THREADS | AV_CODEC_CAP_DR1,
2164 2165
    .priv_data_size   = sizeof(Jpeg2000DecoderContext),
    .init_static_data = jpeg2000_init_static_data,
2166
    .init             = jpeg2000_decode_init,
2167
    .decode           = jpeg2000_decode_frame,
2168
    .priv_class       = &jpeg2000_class,
2169
    .max_lowres       = 5,
2170
    .profiles         = NULL_IF_CONFIG_SMALL(ff_jpeg2000_profiles)
2171
};