jpeg2000dec.c 96.3 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
#include <inttypes.h>
29
#include <math.h>
30

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

#define JP2_SIG_TYPE    0x6A502020
#define JP2_SIG_VALUE   0x0D0A870A
#define JP2_CODESTREAM  0x6A703263
49
#define JP2_HEADER      0x6A703268
50 51 52 53

#define HAD_COC 0x01
#define HAD_QCC 0x02

54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70
#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;

71 72
typedef struct Jpeg2000TilePart {
    uint8_t tile_index;                 // Tile index who refers the tile-part
73
    const uint8_t *tp_end;
74
    GetByteContext tpg;                 // bit stream in tile-part
75 76 77 78 79 80 81 82 83
} 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];
84
    Jpeg2000POC         poc;
85
    Jpeg2000TilePart    tile_part[32];
86 87 88 89
    uint8_t             has_ppt;                // whether this tile has a ppt marker
    uint8_t             *packed_headers;        // contains packed headers. Used only along with PPT marker
    int                 packed_headers_size;    // size in bytes of the packed headers
    GetByteContext      packed_headers_stream;  // byte context corresponding to packed headers
90
    uint16_t tp_idx;                    // Tile-part index
91
    int coord[2][2];                    // border coordinates {{x0, x1}, {y0, y1}}
92 93 94 95 96
} Jpeg2000Tile;

typedef struct Jpeg2000DecoderContext {
    AVClass         *class;
    AVCodecContext  *avctx;
97
    GetByteContext  g;
98 99 100 101 102 103 104 105 106 107

    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;
108 109 110
    int             colour_space;
    uint32_t        palette[256];
    int8_t          pal8;
111
    int             cdef[4];
112
    int             tile_width, tile_height;
113
    unsigned        numXtiles, numYtiles;
114
    int             maxtilelen;
115
    AVRational      sar;
116 117 118

    Jpeg2000CodingStyle codsty[4];
    Jpeg2000QuantStyle  qntsty[4];
119
    Jpeg2000POC         poc;
120
    uint8_t             roi_shift[4];
121 122 123

    int             bit_index;

124 125
    int             curtileno;

126
    Jpeg2000Tile    *tile;
127
    Jpeg2000DSPContext dsp;
128 129

    /*options parameters*/
130
    int             reduction_factor;
131 132 133 134 135 136 137 138 139
} 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;
140

141 142 143
    while (--n >= 0) {
        res <<= 1;
        if (s->bit_index == 0) {
144
            s->bit_index = 7 + (bytestream2_get_byte(&s->g) != 0xFFu);
145 146
        }
        s->bit_index--;
147
        res |= (bytestream2_peek_byte(&s->g) >> s->bit_index) & 1;
148 149 150 151 152 153
    }
    return res;
}

static void jpeg2000_flush(Jpeg2000DecoderContext *s)
{
154 155
    if (bytestream2_get_byte(&s->g) == 0xff)
        bytestream2_skip(&s->g, 1);
156 157 158 159 160 161 162 163 164 165
    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;

166 167
    if (!node) {
        av_log(s->avctx, AV_LOG_ERROR, "missing node\n");
168
        return AVERROR_INVALIDDATA;
169
    }
170

171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199
    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;
}

200 201 202 203 204 205
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);

206 207
    av_assert2(desc);

208 209 210 211 212 213
    if (desc->nb_components != components) {
        return 0;
    }

    switch (components) {
    case 4:
214
        match = match && desc->comp[3].depth >= bpc &&
215 216 217
                         (log2_chroma_wh >> 14 & 3) == 0 &&
                         (log2_chroma_wh >> 12 & 3) == 0;
    case 3:
218
        match = match && desc->comp[2].depth >= bpc &&
219 220 221
                         (log2_chroma_wh >> 10 & 3) == desc->log2_chroma_w &&
                         (log2_chroma_wh >>  8 & 3) == desc->log2_chroma_h;
    case 2:
222
        match = match && desc->comp[1].depth >= bpc &&
223 224 225 226
                         (log2_chroma_wh >>  6 & 3) == desc->log2_chroma_w &&
                         (log2_chroma_wh >>  4 & 3) == desc->log2_chroma_h;

    case 1:
227
        match = match && desc->comp[0].depth >= bpc &&
228 229 230 231 232 233 234 235 236 237
                         (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
238
#define GRAY_PIXEL_FORMATS  AV_PIX_FMT_GRAY8,AV_PIX_FMT_GRAY8A,AV_PIX_FMT_GRAY16,AV_PIX_FMT_YA16
239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254
#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};
255 256
static const enum AVPixelFormat xyz_pix_fmts[]  = {XYZ_PIXEL_FORMATS,
                                                   YUV_PIXEL_FORMATS};
257 258 259 260 261
static const enum AVPixelFormat all_pix_fmts[]  = {RGB_PIXEL_FORMATS,
                                                   GRAY_PIXEL_FORMATS,
                                                   YUV_PIXEL_FORMATS,
                                                   XYZ_PIXEL_FORMATS};

262 263 264 265 266
/* marker segments */
/* get sizes and offsets of image, tiles; number of components */
static int get_siz(Jpeg2000DecoderContext *s)
{
    int i;
267
    int ncomponents;
268 269 270
    uint32_t log2_chroma_wh = 0;
    const enum AVPixelFormat *possible_fmts = NULL;
    int possible_fmts_nb = 0;
271
    int ret;
272

273 274
    if (bytestream2_get_bytes_left(&s->g) < 36) {
        av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for SIZ\n");
275
        return AVERROR_INVALIDDATA;
276
    }
277

278 279 280 281 282 283 284 285 286
    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
287
    ncomponents       = bytestream2_get_be16u(&s->g); // CSiz
288

289 290 291 292
    if (s->image_offset_x || s->image_offset_y) {
        avpriv_request_sample(s->avctx, "Support for image offsets");
        return AVERROR_PATCHWELCOME;
    }
293
    if (av_image_check_size2(s->width, s->height, s->avctx->max_pixels, AV_PIX_FMT_NONE, 0, s->avctx)) {
294 295 296
        avpriv_request_sample(s->avctx, "Large Dimensions");
        return AVERROR_PATCHWELCOME;
    }
297

298 299 300
    if (ncomponents <= 0) {
        av_log(s->avctx, AV_LOG_ERROR, "Invalid number of components: %d\n",
               s->ncomponents);
301
        return AVERROR_INVALIDDATA;
302
    }
303

304
    if (ncomponents > 4) {
305
        avpriv_request_sample(s->avctx, "Support for %d components",
306
                              ncomponents);
307 308 309
        return AVERROR_PATCHWELCOME;
    }

310 311
    if (s->tile_offset_x < 0 || s->tile_offset_y < 0 ||
        s->image_offset_x < s->tile_offset_x ||
312 313 314 315
        s->image_offset_y < s->tile_offset_y ||
        s->tile_width  + (int64_t)s->tile_offset_x <= s->image_offset_x ||
        s->tile_height + (int64_t)s->tile_offset_y <= s->image_offset_y
    ) {
316
        av_log(s->avctx, AV_LOG_ERROR, "Tile offsets are invalid\n");
317 318 319
        return AVERROR_INVALIDDATA;
    }

320 321
    s->ncomponents = ncomponents;

322
    if (s->tile_width <= 0 || s->tile_height <= 0) {
323 324
        av_log(s->avctx, AV_LOG_ERROR, "Invalid tile dimension %dx%d.\n",
               s->tile_width, s->tile_height);
325
        return AVERROR_INVALIDDATA;
326
    }
327

328 329
    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);
330
        return AVERROR_INVALIDDATA;
331
    }
332 333

    for (i = 0; i < s->ncomponents; i++) { // Ssiz_i XRsiz_i, YRsiz_i
334
        uint8_t x    = bytestream2_get_byteu(&s->g);
335 336
        s->cbps[i]   = (x & 0x7f) + 1;
        s->precision = FFMAX(s->cbps[i], s->precision);
337
        s->sgnd[i]   = !!(x & 0x80);
338 339
        s->cdx[i]    = bytestream2_get_byteu(&s->g);
        s->cdy[i]    = bytestream2_get_byteu(&s->g);
340 341
        if (   !s->cdx[i] || s->cdx[i] == 3 || s->cdx[i] > 4
            || !s->cdy[i] || s->cdy[i] == 3 || s->cdy[i] > 4) {
342
            av_log(s->avctx, AV_LOG_ERROR, "Invalid sample separation %d/%d\n", s->cdx[i], s->cdy[i]);
343 344
            return AVERROR_INVALIDDATA;
        }
345
        log2_chroma_wh |= s->cdy[i] >> 1 << i * 4 | s->cdx[i] >> 1 << i * 4 + 2;
346 347 348 349 350
    }

    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);

351 352 353 354
    // There must be at least a SOT and SOD per tile, their minimum size is 14
    if (s->numXtiles * (uint64_t)s->numYtiles > INT_MAX/sizeof(*s->tile) ||
        s->numXtiles * s->numYtiles * 14LL > bytestream2_size(&s->g)
    ) {
355
        s->numXtiles = s->numYtiles = 0;
356
        return AVERROR(EINVAL);
357
    }
358

359 360 361
    s->tile = av_mallocz_array(s->numXtiles * s->numYtiles, sizeof(*s->tile));
    if (!s->tile) {
        s->numXtiles = s->numYtiles = 0;
362
        return AVERROR(ENOMEM);
363
    }
364 365 366 367 368 369 370 371 372 373

    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 */
374 375 376 377 378 379 380
    ret = ff_set_dimensions(s->avctx,
            ff_jpeg2000_ceildivpow2(s->width  - s->image_offset_x,
                                               s->reduction_factor),
            ff_jpeg2000_ceildivpow2(s->height - s->image_offset_y,
                                               s->reduction_factor));
    if (ret < 0)
        return ret;
381

382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398
    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);
399
            break;
400
        default:
401 402
            possible_fmts = all_pix_fmts;
            possible_fmts_nb = FF_ARRAY_ELEMS(all_pix_fmts);
403 404
            break;
        }
405
    }
406 407 408 409
    if (   s->avctx->pix_fmt != AV_PIX_FMT_NONE
        && !pix_fmt_match(s->avctx->pix_fmt, ncomponents, s->precision, log2_chroma_wh, s->pal8))
            s->avctx->pix_fmt = AV_PIX_FMT_NONE;
    if (s->avctx->pix_fmt == AV_PIX_FMT_NONE)
410 411 412 413 414
        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;
            }
415
        }
416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433

    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;
            }
        }
    }


434
    if (i == possible_fmts_nb) {
435 436
        av_log(s->avctx, AV_LOG_ERROR,
               "Unknown pix_fmt, profile: %d, colour_space: %d, "
437 438 439 440 441
               "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",
442
               s->avctx->profile, s->colour_space, ncomponents, s->precision,
443 444 445 446
               s->cdx[0],
               s->cdy[0],
               ncomponents > 1 ? s->cdx[1] : 0,
               ncomponents > 1 ? s->cdy[1] : 0,
447
               ncomponents > 2 ? s->cdx[2] : 0,
448 449 450
               ncomponents > 2 ? s->cdy[2] : 0,
               ncomponents > 3 ? s->cdx[3] : 0,
               ncomponents > 3 ? s->cdy[3] : 0);
451
        return AVERROR_PATCHWELCOME;
452
    }
453
    s->avctx->bits_per_raw_sample = s->precision;
454 455 456 457 458 459 460 461
    return 0;
}

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

462 463
    if (bytestream2_get_bytes_left(&s->g) < 5) {
        av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for COX\n");
464
        return AVERROR_INVALIDDATA;
465
    }
466

467 468
    /*  nreslevels = number of resolution levels
                   = number of decomposition level +1 */
469
    c->nreslevels = bytestream2_get_byteu(&s->g) + 1;
470 471 472 473
    if (c->nreslevels >= JPEG2000_MAX_RESLEVELS) {
        av_log(s->avctx, AV_LOG_ERROR, "nreslevels %d is invalid\n", c->nreslevels);
        return AVERROR_INVALIDDATA;
    }
474

475 476 477 478 479 480 481 482 483 484
    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);
    }

485
    /* compute number of resolution levels to decode */
486
    c->nreslevels2decode = c->nreslevels - s->reduction_factor;
487

488 489 490 491
    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 ||
492
        c->log2_cblk_width + c->log2_cblk_height > 12) {
493 494 495
        av_log(s->avctx, AV_LOG_ERROR, "cblk size invalid\n");
        return AVERROR_INVALIDDATA;
    }
496

497
    c->cblk_style = bytestream2_get_byteu(&s->g);
498
    if (c->cblk_style != 0) { // cblk style
499
        av_log(s->avctx, AV_LOG_WARNING, "extra cblk styles %X\n", c->cblk_style);
500 501
        if (c->cblk_style & JPEG2000_CBLK_BYPASS)
            av_log(s->avctx, AV_LOG_WARNING, "Selective arithmetic coding bypass\n");
502
    }
503
    c->transform = bytestream2_get_byteu(&s->g); // DWT transformation type
504
    /* set integer 9/7 DWT in case of BITEXACT flag */
505
    if ((s->avctx->flags & AV_CODEC_FLAG_BITEXACT) && (c->transform == FF_DWT97))
506
        c->transform = FF_DWT97_INT;
507 508 509
    else if (c->transform == FF_DWT53) {
        s->avctx->properties |= FF_CODEC_PROPERTY_LOSSLESS;
    }
510 511 512 513

    if (c->csty & JPEG2000_CSTY_PREC) {
        int i;
        for (i = 0; i < c->nreslevels; i++) {
514
            byte = bytestream2_get_byte(&s->g);
515 516
            c->log2_prec_widths[i]  =  byte       & 0x0F;    // precinct PPx
            c->log2_prec_heights[i] = (byte >> 4) & 0x0F;    // precinct PPy
517 518 519 520 521 522 523
            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;
                }
524
        }
525 526 527
    } else {
        memset(c->log2_prec_widths , 15, sizeof(c->log2_prec_widths ));
        memset(c->log2_prec_heights, 15, sizeof(c->log2_prec_heights));
528 529 530 531 532 533 534 535 536
    }
    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;
537
    int compno, ret;
538

539 540
    if (bytestream2_get_bytes_left(&s->g) < 5) {
        av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for COD\n");
541
        return AVERROR_INVALIDDATA;
542
    }
543

544
    tmp.csty = bytestream2_get_byteu(&s->g);
545 546

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

549 550
    tmp.nlayers    = bytestream2_get_be16u(&s->g);
    tmp.mct        = bytestream2_get_byteu(&s->g); // multiple component transformation
551

552
    if (tmp.mct && s->ncomponents < 3) {
553
        av_log(s->avctx, AV_LOG_ERROR,
554
               "MCT %"PRIu8" with too few components (%d)\n",
555
               tmp.mct, s->ncomponents);
556 557 558
        return AVERROR_INVALIDDATA;
    }

559 560 561
    if ((ret = get_cox(s, &tmp)) < 0)
        return ret;

562 563 564 565 566 567 568 569 570 571 572
    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)
{
573
    int compno, ret;
574
    uint8_t has_eph;
575

576 577
    if (bytestream2_get_bytes_left(&s->g) < 2) {
        av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for COC\n");
578
        return AVERROR_INVALIDDATA;
579
    }
580

581
    compno = bytestream2_get_byteu(&s->g);
582

583
    if (compno >= s->ncomponents) {
584 585 586
        av_log(s->avctx, AV_LOG_ERROR,
               "Invalid compno %d. There are %d components in the image.\n",
               compno, s->ncomponents);
587 588 589
        return AVERROR_INVALIDDATA;
    }

590
    c      += compno;
591
    has_eph = c->csty & JPEG2000_CSTY_EPH;
592
    c->csty = bytestream2_get_byteu(&s->g);
593
    c->csty |= has_eph; //do not override eph present bits from COD
594 595 596

    if ((ret = get_cox(s, c)) < 0)
        return ret;
597 598 599 600 601

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

602 603 604 605 606 607 608 609 610 611 612 613 614
static int get_rgn(Jpeg2000DecoderContext *s, int n)
{
    uint16_t compno;
    compno = (s->ncomponents < 257)? bytestream2_get_byte(&s->g):
                                     bytestream2_get_be16u(&s->g);
    if (bytestream2_get_byte(&s->g)) {
        av_log(s->avctx, AV_LOG_ERROR, "Invalid RGN header.\n");
        return AVERROR_INVALIDDATA; // SRgn field value is 0
    }
    // SPrgn field
    // Currently compno cannot be greater than 4.
    // However, future implementation should support compno up to 65536
    if (compno < s->ncomponents) {
615 616 617 618 619 620 621
        int v;
        if (s->curtileno == -1) {
            v =  bytestream2_get_byte(&s->g);
            if (v > 30)
                return AVERROR_PATCHWELCOME;
            s->roi_shift[compno] = v;
        } else {
622 623
            if (s->tile[s->curtileno].tp_idx != 0)
                return AVERROR_INVALIDDATA; // marker occurs only in first tile part of tile
624 625 626 627
            v = bytestream2_get_byte(&s->g);
            if (v > 30)
                return AVERROR_PATCHWELCOME;
            s->tile[s->curtileno].comp[compno].roi_shift = v;
628 629 630 631 632 633
        }
        return 0;
    }
    return AVERROR_INVALIDDATA;
}

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

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

642
    x = bytestream2_get_byteu(&s->g); // Sqcd
643 644 645 646 647 648

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

    if (q->quantsty == JPEG2000_QSTY_NONE) {
        n -= 3;
649
        if (bytestream2_get_bytes_left(&s->g) < n ||
650
            n > JPEG2000_MAX_DECLEVELS*3)
651
            return AVERROR_INVALIDDATA;
652
        for (i = 0; i < n; i++)
653
            q->expn[i] = bytestream2_get_byteu(&s->g) >> 3;
654
    } else if (q->quantsty == JPEG2000_QSTY_SI) {
655
        if (bytestream2_get_bytes_left(&s->g) < 2)
656
            return AVERROR_INVALIDDATA;
657
        x          = bytestream2_get_be16u(&s->g);
658 659
        q->expn[0] = x >> 11;
        q->mant[0] = x & 0x7ff;
660
        for (i = 1; i < JPEG2000_MAX_DECLEVELS * 3; i++) {
661 662 663 664 665 666
            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;
667
        if (bytestream2_get_bytes_left(&s->g) < 2 * n ||
668
            n > JPEG2000_MAX_DECLEVELS*3)
669
            return AVERROR_INVALIDDATA;
670
        for (i = 0; i < n; i++) {
671
            x          = bytestream2_get_be16u(&s->g);
672 673 674 675 676 677 678 679 680 681 682 683
            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;
684
    int compno, ret;
685

686 687
    memset(&tmp, 0, sizeof(tmp));

688 689
    if ((ret = get_qcx(s, n, &tmp)) < 0)
        return ret;
690 691 692 693 694 695 696 697 698 699 700 701 702
    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;

703
    if (bytestream2_get_bytes_left(&s->g) < 1)
704
        return AVERROR_INVALIDDATA;
705

706 707
    compno = bytestream2_get_byteu(&s->g);

708
    if (compno >= s->ncomponents) {
709 710 711
        av_log(s->avctx, AV_LOG_ERROR,
               "Invalid compno %d. There are %d components in the image.\n",
               compno, s->ncomponents);
712 713 714
        return AVERROR_INVALIDDATA;
    }

715 716 717 718
    properties[compno] |= HAD_QCC;
    return get_qcx(s, n - 1, q + compno);
}

719 720 721 722 723 724 725 726 727 728 729 730
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) {
731
        avpriv_request_sample(s->avctx, "Fat POC not supported");
732 733 734 735 736
        return AVERROR_PATCHWELCOME;
    }

    tmp.nb_poc = (size - 2) / elem_size;
    if (tmp.nb_poc > MAX_POCS) {
737
        avpriv_request_sample(s->avctx, "Too many POCs (%d)", tmp.nb_poc);
738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779
        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;
}


780
/* Get start of tile segment. */
781
static int get_sot(Jpeg2000DecoderContext *s, int n)
782 783 784 785
{
    Jpeg2000TilePart *tp;
    uint16_t Isot;
    uint32_t Psot;
786
    unsigned TPsot;
787

788
    if (bytestream2_get_bytes_left(&s->g) < 8)
789
        return AVERROR_INVALIDDATA;
790

791
    s->curtileno = 0;
792
    Isot = bytestream2_get_be16u(&s->g);        // Isot
793
    if (Isot >= s->numXtiles * s->numYtiles)
794
        return AVERROR_INVALIDDATA;
795

796
    s->curtileno = Isot;
797 798
    Psot  = bytestream2_get_be32u(&s->g);       // Psot
    TPsot = bytestream2_get_byteu(&s->g);       // TPsot
799 800

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

803
    if (!Psot)
804
        Psot = bytestream2_get_bytes_left(&s->g) - 2 + n + 2;
805

806
    if (Psot > bytestream2_get_bytes_left(&s->g) - 2 + n + 2) {
807
        av_log(s->avctx, AV_LOG_ERROR, "Psot %"PRIu32" too big\n", Psot);
808 809
        return AVERROR_INVALIDDATA;
    }
810

811 812 813 814
    if (TPsot >= FF_ARRAY_ELEMS(s->tile[Isot].tile_part)) {
        avpriv_request_sample(s->avctx, "Too many tile parts");
        return AVERROR_PATCHWELCOME;
    }
815

816 817
    s->tile[Isot].tp_idx = TPsot;
    tp             = s->tile[Isot].tile_part + TPsot;
818
    tp->tile_index = Isot;
819 820 821 822
    tp->tp_end     = s->g.buffer + Psot - n - 2;

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

824 825 826
        /* copy defaults */
        memcpy(tile->codsty, s->codsty, s->ncomponents * sizeof(Jpeg2000CodingStyle));
        memcpy(tile->qntsty, s->qntsty, s->ncomponents * sizeof(Jpeg2000QuantStyle));
827 828
        memcpy(&tile->poc  , &s->poc  , sizeof(tile->poc));
        tile->poc.is_default = 1;
829
    }
830 831 832 833

    return 0;
}

834 835 836 837 838 839 840 841 842
static int read_crg(Jpeg2000DecoderContext *s, int n)
{
    if (s->ncomponents*4 != n - 2) {
        av_log(s->avctx, AV_LOG_ERROR, "Invalid CRG marker.\n");
        return AVERROR_INVALIDDATA;
    }
    bytestream2_skip(&s->g, n - 2);
    return 0;
}
843 844 845 846 847 848 849 850
/* 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. */
851
static int get_tlm(Jpeg2000DecoderContext *s, int n)
852 853
{
    uint8_t Stlm, ST, SP, tile_tlm, i;
854 855
    bytestream2_get_byte(&s->g);               /* Ztlm: skipped */
    Stlm = bytestream2_get_byte(&s->g);
856 857 858

    // too complex ? ST = ((Stlm >> 4) & 0x01) + ((Stlm >> 4) & 0x02);
    ST = (Stlm >> 4) & 0x03;
859 860 861 862 863
    if (ST == 0x03) {
        av_log(s->avctx, AV_LOG_ERROR, "TLM marker contains invalid ST value.\n");
        return AVERROR_INVALIDDATA;
    }

864 865 866 867 868 869 870
    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:
871
            bytestream2_get_byte(&s->g);
872 873
            break;
        case 2:
874
            bytestream2_get_be16(&s->g);
875 876
            break;
        case 3:
877
            bytestream2_get_be32(&s->g);
878 879 880
            break;
        }
        if (SP == 0) {
881
            bytestream2_get_be16(&s->g);
882
        } else {
883
            bytestream2_get_be32(&s->g);
884 885 886 887 888
        }
    }
    return 0;
}

889
static int get_plt(Jpeg2000DecoderContext *s, int n)
890 891
{
    int i;
892
    int v;
893

894
    av_log(s->avctx, AV_LOG_DEBUG,
895 896
            "PLT marker at pos 0x%X\n", bytestream2_tell(&s->g) - 4);

897 898 899
    if (n < 4)
        return AVERROR_INVALIDDATA;

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

    for (i = 0; i < n - 3; i++) {
903
        v = bytestream2_get_byte(&s->g);
904
    }
905 906
    if (v & 0x80)
        return AVERROR_INVALIDDATA;
907 908 909 910

    return 0;
}

911 912 913
static int get_ppt(Jpeg2000DecoderContext *s, int n)
{
    Jpeg2000Tile *tile;
914
    void *new;
915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931

    if (n < 3) {
        av_log(s->avctx, AV_LOG_ERROR, "Invalid length for PPT data.\n");
        return AVERROR_INVALIDDATA;
    }
    if (s->curtileno < 0)
        return AVERROR_INVALIDDATA;

    tile = &s->tile[s->curtileno];
    if (tile->tp_idx != 0) {
        av_log(s->avctx, AV_LOG_ERROR,
               "PPT marker can occur only on first tile part of a tile.\n");
        return AVERROR_INVALIDDATA;
    }

    tile->has_ppt = 1;  // this tile has a ppt marker
    bytestream2_get_byte(&s->g); // Zppt is skipped and not used
932 933
    new = av_realloc(tile->packed_headers,
                     tile->packed_headers_size + n - 3);
934 935 936 937
    if (new) {
        tile->packed_headers = new;
    } else
        return AVERROR(ENOMEM);
938
    memset(&tile->packed_headers_stream, 0, sizeof(tile->packed_headers_stream));
939 940 941 942 943 944 945 946
    memcpy(tile->packed_headers + tile->packed_headers_size,
           s->g.buffer, n - 3);
    tile->packed_headers_size += n - 3;
    bytestream2_skip(&s->g, n - 3);

    return 0;
}

947 948 949 950 951 952 953 954 955 956
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);

957 958 959 960
    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);
961

962 963
    for (compno = 0; compno < s->ncomponents; compno++) {
        Jpeg2000Component *comp = tile->comp + compno;
964 965
        Jpeg2000CodingStyle *codsty = tile->codsty + compno;
        Jpeg2000QuantStyle  *qntsty = tile->qntsty + compno;
966 967
        int ret; // global bandno

968 969 970 971
        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];
972 973 974 975 976 977
        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];
        }
978

979 980 981 982
        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);
983

984 985 986
        if (!comp->roi_shift)
            comp->roi_shift = s->roi_shift[compno];

987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021
        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;
}

1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034
static inline void select_stream(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile,
                                 int *tp_index)
{
    s->g = tile->tile_part[*tp_index].tpg;
    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;
        }
    }
    if (bytestream2_peek_be32(&s->g) == JPEG2000_SOP_FIXED_BYTES)
        bytestream2_skip(&s->g, JPEG2000_SOP_BYTE_LENGTH);
}

1035
static int jpeg2000_decode_packet(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile, int *tp_index,
1036 1037 1038 1039 1040
                                  Jpeg2000CodingStyle *codsty,
                                  Jpeg2000ResLevel *rlevel, int precno,
                                  int layno, uint8_t *expn, int numgbits)
{
    int bandno, cblkno, ret, nb_code_blocks;
1041
    int cwsno;
1042

1043 1044 1045
    if (layno < rlevel->band[0].prec[precno].decoded_layers)
        return 0;
    rlevel->band[0].prec[precno].decoded_layers = layno + 1;
1046 1047 1048 1049 1050
    // Select stream to read from
    if (tile->has_ppt)
        s->g = tile->packed_headers_stream;
    else
        select_stream(s, tile, tp_index);
1051

1052 1053
    if (!(ret = get_bits(s, 1))) {
        jpeg2000_flush(s);
1054
        goto skip_data;
1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069
    } 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;
1070
            void *tmp;
1071 1072 1073 1074 1075 1076 1077 1078 1079 1080

            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;

1081 1082
            if (!cblk->npasses) {
                int v = expn[bandno] + numgbits - 1 -
1083
                        tag_tree_decode(s, prec->zerobits + cblkno, 100);
1084
                if (v < 0 || v > 30) {
1085
                    av_log(s->avctx, AV_LOG_ERROR,
1086
                           "nonzerobits %d invalid or unsupported\n", v);
1087 1088 1089 1090
                    return AVERROR_INVALIDDATA;
                }
                cblk->nonzerobits = v;
            }
1091 1092
            if ((newpasses = getnpasses(s)) < 0)
                return newpasses;
1093 1094
            av_assert2(newpasses > 0);
            if (cblk->npasses + newpasses >= JPEG2000_MAX_PASSES) {
1095
                avpriv_request_sample(s->avctx, "Too many passes");
1096 1097
                return AVERROR_PATCHWELCOME;
            }
1098 1099
            if ((llen = getlblockinc(s)) < 0)
                return llen;
1100 1101
            if (cblk->lblock + llen + av_log2(newpasses) > 16) {
                avpriv_request_sample(s->avctx,
1102
                                      "Block with length beyond 16 bits");
1103 1104 1105
                return AVERROR_PATCHWELCOME;
            }

1106
            cblk->lblock += llen;
1107 1108 1109

            cblk->nb_lengthinc = 0;
            cblk->nb_terminationsinc = 0;
1110 1111 1112 1113 1114 1115 1116 1117
            av_free(cblk->lengthinc);
            cblk->lengthinc  = av_mallocz_array(newpasses    , sizeof(*cblk->lengthinc));
            if (!cblk->lengthinc)
                return AVERROR(ENOMEM);
            tmp = av_realloc_array(cblk->data_start, cblk->nb_terminations + newpasses + 1, sizeof(*cblk->data_start));
            if (!tmp)
                return AVERROR(ENOMEM);
            cblk->data_start = tmp;
1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130
            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;
1131 1132 1133 1134 1135 1136 1137 1138 1139
                if (ret > cblk->data_allocated) {
                    size_t new_size = FFMAX(2*cblk->data_allocated, ret);
                    void *new = av_realloc(cblk->data, new_size);
                    if (new) {
                        cblk->data = new;
                        cblk->data_allocated = new_size;
                    }
                }
                if (ret > cblk->data_allocated) {
1140 1141
                    avpriv_request_sample(s->avctx,
                                        "Block with lengthinc greater than %"SIZE_SPECIFIER"",
1142
                                        cblk->data_allocated);
1143 1144 1145 1146 1147 1148
                    return AVERROR_PATCHWELCOME;
                }
                cblk->lengthinc[cblk->nb_lengthinc++] = ret;
                cblk->npasses  += newpasses1;
                newpasses -= newpasses1;
            } while(newpasses);
1149 1150 1151 1152 1153
        }
    }
    jpeg2000_flush(s);

    if (codsty->csty & JPEG2000_CSTY_EPH) {
1154 1155
        if (bytestream2_peek_be16(&s->g) == JPEG2000_EPH)
            bytestream2_skip(&s->g, 2);
1156
        else
1157
            av_log(s->avctx, AV_LOG_ERROR, "EPH marker not found. instead %X\n", bytestream2_peek_be32(&s->g));
1158 1159
    }

1160 1161 1162 1163 1164
    // Save state of stream
    if (tile->has_ppt) {
        tile->packed_headers_stream = s->g;
        select_stream(s, tile, tp_index);
    }
1165 1166 1167 1168 1169 1170 1171
    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;
1172 1173
            if (!cblk->nb_terminationsinc && !cblk->lengthinc)
                continue;
1174
            for (cwsno = 0; cwsno < cblk->nb_lengthinc; cwsno ++) {
1175 1176 1177 1178 1179 1180 1181 1182
                if (cblk->data_allocated < cblk->length + cblk->lengthinc[cwsno] + 4) {
                    size_t new_size = FFMAX(2*cblk->data_allocated, cblk->length + cblk->lengthinc[cwsno] + 4);
                    void *new = av_realloc(cblk->data, new_size);
                    if (new) {
                        cblk->data = new;
                        cblk->data_allocated = new_size;
                    }
                }
1183
                if (   bytestream2_get_bytes_left(&s->g) < cblk->lengthinc[cwsno]
1184
                    || cblk->data_allocated < cblk->length + cblk->lengthinc[cwsno] + 4
1185 1186
                ) {
                    av_log(s->avctx, AV_LOG_ERROR,
1187 1188
                        "Block length %"PRIu16" or lengthinc %d is too large, left %d\n",
                        cblk->length, cblk->lengthinc[cwsno], bytestream2_get_bytes_left(&s->g));
1189 1190
                    return AVERROR_INVALIDDATA;
                }
1191

1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202
                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;
                }
            }
1203
            av_freep(&cblk->lengthinc);
1204 1205
        }
    }
1206 1207 1208 1209 1210 1211 1212 1213 1214
    // Save state of stream
    tile->tile_part[*tp_index].tpg = s->g;
    return 0;

skip_data:
    if (tile->has_ppt)
        tile->packed_headers_stream = s->g;
    else
        tile->tile_part[*tp_index].tpg = s->g;
1215 1216 1217
    return 0;
}

1218 1219 1220
static int jpeg2000_decode_packets_po_iteration(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile,
                                             int RSpoc, int CSpoc,
                                             int LYEpoc, int REpoc, int CEpoc,
1221
                                             int Ppoc, int *tp_index)
1222
{
1223 1224
    int ret = 0;
    int layno, reslevelno, compno, precno, ok_reslevel;
1225
    int x, y;
1226
    int step_x, step_y;
1227

1228
    switch (Ppoc) {
1229
    case JPEG2000_PGOD_RLCP:
1230
        av_log(s->avctx, AV_LOG_DEBUG, "Progression order RLCP\n");
1231
        ok_reslevel = 1;
1232
        for (reslevelno = RSpoc; ok_reslevel && reslevelno < REpoc; reslevelno++) {
1233
            ok_reslevel = 0;
1234 1235
            for (layno = 0; layno < LYEpoc; layno++) {
                for (compno = CSpoc; compno < CEpoc; compno++) {
1236 1237 1238 1239 1240 1241 1242
                    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++)
1243
                            if ((ret = jpeg2000_decode_packet(s, tile, tp_index,
1244 1245 1246 1247 1248 1249 1250 1251 1252 1253
                                                              codsty, rlevel,
                                                              precno, layno,
                                                              qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
                                                              qntsty->nguardbits)) < 0)
                                return ret;
                    }
                }
            }
        }
        break;
1254

1255
    case JPEG2000_PGOD_LRCP:
1256
        av_log(s->avctx, AV_LOG_DEBUG, "Progression order LRCP\n");
1257
        for (layno = 0; layno < LYEpoc; layno++) {
1258
            ok_reslevel = 1;
1259
            for (reslevelno = RSpoc; ok_reslevel && reslevelno < REpoc; reslevelno++) {
1260
                ok_reslevel = 0;
1261
                for (compno = CSpoc; compno < CEpoc; compno++) {
1262 1263 1264 1265
                    Jpeg2000CodingStyle *codsty = tile->codsty + compno;
                    Jpeg2000QuantStyle *qntsty  = tile->qntsty + compno;
                    if (reslevelno < codsty->nreslevels) {
                        Jpeg2000ResLevel *rlevel = tile->comp[compno].reslevel +
1266
                                                reslevelno;
1267 1268
                        ok_reslevel = 1;
                        for (precno = 0; precno < rlevel->num_precincts_x * rlevel->num_precincts_y; precno++)
1269
                            if ((ret = jpeg2000_decode_packet(s, tile, tp_index,
1270 1271 1272 1273 1274
                                                              codsty, rlevel,
                                                              precno, layno,
                                                              qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
                                                              qntsty->nguardbits)) < 0)
                                return ret;
1275 1276 1277 1278 1279 1280 1281
                    }
                }
            }
        }
        break;

    case JPEG2000_PGOD_CPRL:
1282
        av_log(s->avctx, AV_LOG_DEBUG, "Progression order CPRL\n");
1283
        for (compno = CSpoc; compno < CEpoc; compno++) {
1284
            Jpeg2000Component *comp     = tile->comp + compno;
1285 1286
            Jpeg2000CodingStyle *codsty = tile->codsty + compno;
            Jpeg2000QuantStyle *qntsty  = tile->qntsty + compno;
1287 1288
            step_x = 32;
            step_y = 32;
1289

1290
            if (RSpoc >= FFMIN(codsty->nreslevels, REpoc))
1291 1292
                continue;

1293
            for (reslevelno = RSpoc; reslevelno < FFMIN(codsty->nreslevels, REpoc); reslevelno++) {
1294
                uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; //  ==> N_L - r
1295
                Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1296 1297 1298
                step_x = FFMIN(step_x, rlevel->log2_prec_width  + reducedresno);
                step_y = FFMIN(step_y, rlevel->log2_prec_height + reducedresno);
            }
1299 1300 1301 1302
            if (step_x >= 31 || step_y >= 31){
                avpriv_request_sample(s->avctx, "CPRL with large step");
                return AVERROR_PATCHWELCOME;
            }
1303 1304
            step_x = 1<<step_x;
            step_y = 1<<step_y;
1305

1306 1307
            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) {
1308
                    for (reslevelno = RSpoc; reslevelno < FFMIN(codsty->nreslevels, REpoc); reslevelno++) {
1309
                        unsigned prcx, prcy;
1310
                        uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; //  ==> N_L - r
1311
                        Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1312 1313
                        int xc = x / s->cdx[compno];
                        int yc = y / s->cdy[compno];
1314

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

1318
                        if (xc % (1LL << (rlevel->log2_prec_width + reducedresno)) && x != tile->coord[0][0]) //FIXME this is a subset of the check
1319 1320 1321
                            continue;

                        // check if a precinct exists
1322 1323
                        prcx   = ff_jpeg2000_ceildivpow2(xc, reducedresno) >> rlevel->log2_prec_width;
                        prcy   = ff_jpeg2000_ceildivpow2(yc, reducedresno) >> rlevel->log2_prec_height;
1324 1325 1326
                        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;

1327
                        precno = prcx + rlevel->num_precincts_x * prcy;
1328

1329 1330 1331 1332 1333
                        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;
                        }
1334

1335
                        for (layno = 0; layno < LYEpoc; layno++) {
1336
                            if ((ret = jpeg2000_decode_packet(s, tile, tp_index, codsty, rlevel,
1337 1338 1339 1340
                                                              precno, layno,
                                                              qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
                                                              qntsty->nguardbits)) < 0)
                                return ret;
1341 1342 1343 1344 1345 1346 1347
                        }
                    }
                }
            }
        }
        break;

1348
    case JPEG2000_PGOD_RPCL:
1349 1350
        av_log(s->avctx, AV_LOG_WARNING, "Progression order RPCL\n");
        ok_reslevel = 1;
1351
        for (reslevelno = RSpoc; ok_reslevel && reslevelno < REpoc; reslevelno++) {
1352
            ok_reslevel = 0;
1353 1354
            step_x = 30;
            step_y = 30;
1355
            for (compno = CSpoc; compno < CEpoc; compno++) {
1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368
                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;

1369 1370
            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) {
1371
                    for (compno = CSpoc; compno < CEpoc; compno++) {
1372 1373 1374 1375 1376 1377 1378 1379 1380 1381
                        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];

1382 1383 1384
                        if (reslevelno >= codsty->nreslevels)
                            continue;

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

1388
                        if (xc % (1LL << (rlevel->log2_prec_width + reducedresno)) && x != tile->coord[0][0]) //FIXME this is a subset of the check
1389 1390 1391 1392 1393 1394 1395 1396 1397 1398
                            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;

1399
                        ok_reslevel = 1;
1400 1401 1402 1403 1404 1405
                        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;
                        }

1406 1407 1408 1409 1410 1411 1412 1413
                        for (layno = 0; layno < LYEpoc; layno++) {
                            if ((ret = jpeg2000_decode_packet(s, tile, tp_index,
                                                              codsty, rlevel,
                                                              precno, layno,
                                                              qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
                                                              qntsty->nguardbits)) < 0)
                                return ret;
                        }
1414 1415 1416 1417
                    }
                }
            }
        }
1418 1419 1420
        break;

    case JPEG2000_PGOD_PCRL:
1421
        av_log(s->avctx, AV_LOG_WARNING, "Progression order PCRL\n");
1422 1423
        step_x = 32;
        step_y = 32;
1424
        for (compno = CSpoc; compno < CEpoc; compno++) {
1425 1426 1427
            Jpeg2000Component *comp     = tile->comp + compno;
            Jpeg2000CodingStyle *codsty = tile->codsty + compno;

1428
            for (reslevelno = RSpoc; reslevelno < FFMIN(codsty->nreslevels, REpoc); reslevelno++) {
1429 1430 1431 1432 1433 1434
                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);
            }
        }
1435 1436 1437 1438
        if (step_x >= 31 || step_y >= 31){
            avpriv_request_sample(s->avctx, "PCRL with large step");
            return AVERROR_PATCHWELCOME;
        }
1439 1440 1441
        step_x = 1<<step_x;
        step_y = 1<<step_y;

1442 1443
        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) {
1444
                for (compno = CSpoc; compno < CEpoc; compno++) {
1445 1446 1447 1448 1449 1450
                    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];

1451
                    for (reslevelno = RSpoc; reslevelno < FFMIN(codsty->nreslevels, REpoc); reslevelno++) {
1452 1453 1454 1455
                        unsigned prcx, prcy;
                        uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; //  ==> N_L - r
                        Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;

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

1459
                        if (xc % (1LL << (rlevel->log2_prec_width + reducedresno)) && x != tile->coord[0][0]) //FIXME this is a subset of the check
1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475
                            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;
                        }

1476
                        for (layno = 0; layno < LYEpoc; layno++) {
1477
                            if ((ret = jpeg2000_decode_packet(s, tile, tp_index, codsty, rlevel,
1478 1479 1480 1481 1482 1483 1484 1485 1486
                                                              precno, layno,
                                                              qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
                                                              qntsty->nguardbits)) < 0)
                                return ret;
                        }
                    }
                }
            }
        }
1487 1488
        break;

1489 1490 1491 1492
    default:
        break;
    }

1493 1494 1495 1496 1497
    return ret;
}

static int jpeg2000_decode_packets(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
{
1498 1499
    int ret = AVERROR_BUG;
    int i;
1500
    int tp_index = 0;
1501 1502 1503 1504 1505 1506 1507

    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,
1508 1509 1510
                FFMIN(e->LYEpoc, tile->codsty[0].nlayers),
                e->REpoc,
                FFMIN(e->CEpoc, s->ncomponents),
1511
                e->Ppoc, &tp_index
1512 1513 1514 1515 1516 1517 1518 1519 1520 1521
                );
            if (ret < 0)
                return ret;
        }
    } else {
        ret = jpeg2000_decode_packets_po_iteration(s, tile,
            0, 0,
            tile->codsty[0].nlayers,
            33,
            s->ncomponents,
1522 1523
            tile->codsty[0].prog_order,
            &tp_index
1524 1525
        );
    }
1526
    /* EOC marker reached */
1527
    bytestream2_skip(&s->g, 2);
1528

1529
    return ret;
1530 1531 1532 1533
}

/* TIER-1 routines */
static void decode_sigpass(Jpeg2000T1Context *t1, int width, int height,
1534
                           int bpno, int bandno,
1535
                           int vert_causal_ctx_csty_symbol)
1536 1537 1538 1539 1540
{
    int mask = 3 << (bpno - 1), y0, x, y;

    for (y0 = 0; y0 < height; y0 += 4)
        for (x = 0; x < width; x++)
1541
            for (y = y0; y < height && y < y0 + 4; y++) {
1542 1543 1544
                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);
1545 1546 1547 1548
                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);
1549
                        if (t1->mqc.raw)
1550
                             t1->data[(y) * t1->stride + x] = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ctxno) ? -mask : mask;
1551
                        else
1552
                             t1->data[(y) * t1->stride + x] = (ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ctxno) ^ xorbit) ?
1553
                                               -mask : mask;
1554 1555

                        ff_jpeg2000_set_significance(t1, x, y,
1556
                                                     t1->data[(y) * t1->stride + x] < 0);
1557
                    }
1558
                    t1->flags[(y + 1) * t1->stride + x + 1] |= JPEG2000_T1_VIS;
1559
                }
1560
            }
1561 1562 1563
}

static void decode_refpass(Jpeg2000T1Context *t1, int width, int height,
1564
                           int bpno, int vert_causal_ctx_csty_symbol)
1565 1566 1567 1568 1569 1570 1571 1572 1573 1574
{
    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++)
1575
                if ((t1->flags[(y + 1) * t1->stride + x + 1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS)) == JPEG2000_T1_SIG) {
1576 1577
                    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;
1578
                    int ctxno = ff_jpeg2000_getrefctxno(t1->flags[(y + 1) * t1->stride + x + 1] & flags_mask);
1579 1580 1581
                    int r     = ff_mqc_decode(&t1->mqc,
                                              t1->mqc.cx_states + ctxno)
                                ? phalf : nhalf;
1582 1583
                    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;
1584 1585 1586 1587 1588
                }
}

static void decode_clnpass(Jpeg2000DecoderContext *s, Jpeg2000T1Context *t1,
                           int width, int height, int bpno, int bandno,
1589
                           int seg_symbols, int vert_causal_ctx_csty_symbol)
1590 1591 1592
{
    int mask = 3 << (bpno - 1), y0, x, y, runlen, dec;

1593
    for (y0 = 0; y0 < height; y0 += 4) {
1594
        for (x = 0; x < width; x++) {
1595 1596 1597
            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);
1598
            if (y0 + 3 < height &&
1599 1600 1601 1602
                !((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))) {
1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616
                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++) {
1617 1618 1619
                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);
1620
                if (!dec) {
1621 1622
                    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,
1623 1624
                                                                                             bandno));
                    }
1625 1626 1627
                }
                if (dec) {
                    int xorbit;
1628
                    int ctxno = ff_jpeg2000_getsgnctxno(t1->flags[(y + 1) * t1->stride + x + 1] & flags_mask,
1629
                                                        &xorbit);
1630
                    t1->data[(y) * t1->stride + x] = (ff_mqc_decode(&t1->mqc,
1631 1632 1633
                                                    t1->mqc.cx_states + ctxno) ^
                                      xorbit)
                                     ? -mask : mask;
1634
                    ff_jpeg2000_set_significance(t1, x, y, t1->data[(y) * t1->stride + x] < 0);
1635 1636
                }
                dec = 0;
1637
                t1->flags[(y + 1) * t1->stride + x + 1] &= ~JPEG2000_T1_VIS;
1638 1639
            }
        }
1640
    }
1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654
    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,
1655
                       int width, int height, int bandpos, uint8_t roi_shift)
1656
{
1657
    int passno = cblk->npasses, pass_t = 2, bpno = cblk->nonzerobits - 1 + roi_shift;
1658
    int pass_cnt = 0;
1659
    int vert_causal_ctx_csty_symbol = codsty->cblk_style & JPEG2000_CBLK_VSC;
1660 1661
    int term_cnt = 0;
    int coder_type;
1662

1663 1664
    av_assert0(width <= 1024U && height <= 1024U);
    av_assert0(width*height <= 4096);
1665

1666
    memset(t1->data, 0, t1->stride * height * sizeof(*t1->data));
1667

1668
    /* If code-block contains no compressed data: nothing to do. */
1669
    if (!cblk->length)
1670 1671
        return 0;

1672
    memset(t1->flags, 0, t1->stride * (height + 2) * sizeof(*t1->flags));
1673 1674 1675

    cblk->data[cblk->length] = 0xff;
    cblk->data[cblk->length+1] = 0xff;
1676
    ff_mqc_initdec(&t1->mqc, cblk->data, 0, 1);
1677 1678

    while (passno--) {
1679 1680
        if (bpno < 0 || bpno > 29) {
            av_log(s->avctx, AV_LOG_ERROR, "bpno became invalid\n");
1681 1682
            return AVERROR_INVALIDDATA;
        }
1683
        switch(pass_t) {
1684
        case 0:
1685
            decode_sigpass(t1, width, height, bpno + 1, bandpos,
1686
                           vert_causal_ctx_csty_symbol);
1687 1688
            break;
        case 1:
1689
            decode_refpass(t1, width, height, bpno + 1, vert_causal_ctx_csty_symbol);
1690 1691
            break;
        case 2:
1692
            av_assert2(!t1->mqc.raw);
1693
            decode_clnpass(s, t1, width, height, bpno + 1, bandpos,
1694 1695
                           codsty->cblk_style & JPEG2000_CBLK_SEGSYM,
                           vert_causal_ctx_csty_symbol);
1696 1697
            break;
        }
1698 1699 1700
        if (codsty->cblk_style & JPEG2000_CBLK_RESET) // XXX no testcase for just this
            ff_mqc_init_contexts(&t1->mqc);

1701
        if (passno && (coder_type = needs_termination(codsty->cblk_style, pass_cnt))) {
1702
            if (term_cnt >= cblk->nb_terminations) {
1703 1704 1705
                av_log(s->avctx, AV_LOG_ERROR, "Missing needed termination \n");
                return AVERROR_INVALIDDATA;
            }
1706 1707 1708 1709 1710 1711
            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);
            }

1712 1713
            ff_mqc_initdec(&t1->mqc, cblk->data + cblk->data_start[++term_cnt], coder_type == 2, 0);
        }
1714 1715 1716 1717 1718 1719

        pass_t++;
        if (pass_t == 3) {
            bpno--;
            pass_t = 0;
        }
1720
        pass_cnt ++;
1721
    }
1722

1723 1724 1725
    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);
1726 1727
    }

1728
    return 1;
1729 1730
}

1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743
static inline int roi_shift_param(Jpeg2000Component *comp,
                                   int quan_parameter)
{
    uint8_t roi_shift;
    int val;
    roi_shift = comp->roi_shift;
    val = (quan_parameter < 0)?-quan_parameter:quan_parameter;

    if (val > (1 << roi_shift))
        return (quan_parameter < 0)?-(val >> roi_shift):(val >> roi_shift);
    return quan_parameter;
}

1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754
/* 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)
{
1755 1756 1757 1758
    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];
1759
        int *src = t1->data + j*t1->stride;
1760 1761 1762
        for (i = 0; i < w; ++i)
            datap[i] = src[i] * band->f_stepsize;
    }
1763 1764 1765 1766 1767 1768 1769
}

/* Integer dequantization of a codeblock.*/
static void dequantization_int(int x, int y, Jpeg2000Cblk *cblk,
                               Jpeg2000Component *comp,
                               Jpeg2000T1Context *t1, Jpeg2000Band *band)
{
1770 1771 1772 1773
    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];
1774
        int *src = t1->data + j*t1->stride;
1775
        if (band->i_stepsize == 32768) {
1776 1777 1778 1779 1780
            for (i = 0; i < w; ++i)
                datap[i] = src[i] / 2;
        } else {
            // This should be VERY uncommon
            for (i = 0; i < w; ++i)
1781
                datap[i] = (src[i] * (int64_t)band->i_stepsize) / 65536;
1782
        }
1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793
    }
}

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];
1794
        int *src = t1->data + j*t1->stride;
1795
        for (i = 0; i < w; ++i)
1796
            datap[i] = (src[i] * (int64_t)band->i_stepsize + (1<<15)) >> 16;
1797
    }
1798 1799
}

1800
static inline void mct_decode(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
1801 1802
{
    int i, csize = 1;
1803
    void *src[3];
1804

1805
    for (i = 1; i < 3; i++) {
1806 1807 1808 1809
        if (tile->codsty[0].transform != tile->codsty[i].transform) {
            av_log(s->avctx, AV_LOG_ERROR, "Transforms mismatch, MCT not supported\n");
            return;
        }
1810 1811 1812 1813 1814
        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;
        }
    }
1815

1816 1817
    for (i = 0; i < 3; i++)
        if (tile->codsty[0].transform == FF_DWT97)
1818
            src[i] = tile->comp[i].f_data;
1819
        else
1820
            src[i] = tile->comp[i].i_data;
1821 1822 1823

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

1825
    s->dsp.mct_decode[tile->codsty[0].transform](src[0], src[1], src[2], csize);
1826 1827
}

1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840
static inline void roi_scale_cblk(Jpeg2000Cblk *cblk,
                                  Jpeg2000Component *comp,
                                  Jpeg2000T1Context *t1)
{
    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) {
        int *src = t1->data + j*t1->stride;
        for (i = 0; i < w; ++i)
            src[i] = roi_shift_param(comp, src[i]);
    }
}

1841
static inline void tile_codeblocks(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
1842 1843 1844 1845 1846
{
    Jpeg2000T1Context t1;

    int compno, reslevelno, bandno;

1847
    /* Loop on tile components */
1848 1849 1850
    for (compno = 0; compno < s->ncomponents; compno++) {
        Jpeg2000Component *comp     = tile->comp + compno;
        Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1851
        int coded = 0;
1852

1853 1854
        t1.stride = (1<<codsty->log2_cblk_width) + 2;

1855 1856 1857 1858 1859
        /* 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++) {
1860
                int nb_precincts, precno;
1861 1862
                Jpeg2000Band *band = rlevel->band + bandno;
                int cblkno = 0, bandpos;
1863

1864 1865
                bandpos = bandno + (reslevelno > 0);

1866 1867
                if (band->coord[0][0] == band->coord[0][1] ||
                    band->coord[1][0] == band->coord[1][1])
1868 1869
                    continue;

1870 1871 1872 1873 1874 1875
                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 */
1876 1877 1878
                    for (cblkno = 0;
                         cblkno < prec->nb_codeblocks_width * prec->nb_codeblocks_height;
                         cblkno++) {
1879 1880
                        int x, y;
                        Jpeg2000Cblk *cblk = prec->cblk + cblkno;
1881
                        int ret = decode_cblk(s, codsty, &t1, cblk,
1882 1883
                                    cblk->coord[0][1] - cblk->coord[0][0],
                                    cblk->coord[1][1] - cblk->coord[1][0],
1884
                                    bandpos, comp->roi_shift);
1885 1886
                        if (ret)
                            coded = 1;
1887 1888
                        else
                            continue;
1889 1890
                        x = cblk->coord[0][0] - band->coord[0][0];
                        y = cblk->coord[1][0] - band->coord[1][0];
1891

1892 1893
                        if (comp->roi_shift)
                            roi_scale_cblk(cblk, comp, &t1);
1894
                        if (codsty->transform == FF_DWT97)
1895
                            dequantization_float(x, y, cblk, comp, &t1, band);
1896 1897
                        else if (codsty->transform == FF_DWT97_INT)
                            dequantization_int_97(x, y, cblk, comp, &t1, band);
1898 1899
                        else
                            dequantization_int(x, y, cblk, comp, &t1, band);
1900 1901 1902 1903 1904 1905
                   } /* end cblk */
                } /*end prec */
            } /* end band */
        } /* end reslevel */

        /* inverse DWT */
1906 1907 1908
        if (coded)
            ff_dwt_decode(&comp->dwt, codsty->transform == FF_DWT97 ? (void*)comp->f_data : (void*)comp->i_data);

1909
    } /*end comp */
1910 1911
}

1912 1913
#define WRITE_FRAME(D, PIXEL)                                                                     \
    static inline void write_frame_ ## D(Jpeg2000DecoderContext * s, Jpeg2000Tile * tile,         \
1914
                                         AVFrame * picture, int precision)                        \
1915
    {                                                                                             \
1916 1917 1918 1919
        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;                                      \
                                                                                                  \
1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930
        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;                \
1931 1932 1933 1934
            int plane        = 0;                                                                 \
                                                                                                  \
            if (planar)                                                                           \
                plane = s->cdef[compno] ? s->cdef[compno]-1 : (s->ncomponents-1);                 \
1935
                                                                                                  \
1936 1937 1938
            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++) {                 \
1939 1940
                PIXEL *dst;                                                                       \
                                                                                                  \
1941 1942
                x   = tile->comp[compno].coord[0][0] - s->image_offset_x / s->cdx[compno];        \
                dst = line + x * pixelsize + compno*!planar;                                      \
1943 1944
                                                                                                  \
                if (codsty->transform == FF_DWT97) {                                              \
1945
                    for (; x < w; x++) {                                                          \
1946 1947 1948
                        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);                                  \
1949
                        *dst = val << (precision - cbps);                                         \
1950
                        datap++;                                                                  \
1951
                        dst += pixelsize;                                                         \
1952 1953
                    }                                                                             \
                } else {                                                                          \
1954
                    for (; x < w; x++) {                                                          \
1955 1956 1957
                        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);                                  \
1958
                        *dst = val << (precision - cbps);                                         \
1959
                        i_datap++;                                                                \
1960
                        dst += pixelsize;                                                         \
1961 1962
                    }                                                                             \
                }                                                                                 \
1963
                line += picture->linesize[plane] / sizeof(PIXEL);                                 \
1964 1965 1966 1967 1968 1969 1970 1971 1972 1973
            }                                                                                     \
        }                                                                                         \
                                                                                                  \
    }

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

#undef WRITE_FRAME

1974 1975
static int jpeg2000_decode_tile(AVCodecContext *avctx, void *td,
                                int jobnr, int threadnr)
1976
{
1977 1978 1979
    Jpeg2000DecoderContext *s = avctx->priv_data;
    AVFrame *picture = td;
    Jpeg2000Tile *tile = s->tile + jobnr;
1980
    int x;
1981 1982

    tile_codeblocks(s, tile);
1983 1984 1985 1986 1987

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

1988 1989 1990 1991 1992 1993 1994 1995 1996
    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;
        }
1997 1998
    }

1999
    if (s->precision <= 8) {
2000
        write_frame_8(s, tile, picture, 8);
2001
    } else {
2002
        int precision = picture->format == AV_PIX_FMT_XYZ12 ||
2003 2004
                        picture->format == AV_PIX_FMT_RGB48 ||
                        picture->format == AV_PIX_FMT_RGBA64 ||
2005
                        picture->format == AV_PIX_FMT_GRAY16 ? 16 : s->precision;
2006

2007
        write_frame_16(s, tile, picture, precision);
2008
    }
2009

2010 2011 2012 2013 2014 2015 2016
    return 0;
}

static void jpeg2000_dec_cleanup(Jpeg2000DecoderContext *s)
{
    int tileno, compno;
    for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++) {
2017 2018 2019 2020
        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;
2021

2022 2023 2024
                ff_jpeg2000_cleanup(comp, codsty);
            }
            av_freep(&s->tile[tileno].comp);
2025 2026
            av_freep(&s->tile[tileno].packed_headers);
            s->tile[tileno].packed_headers_size = 0;
2027 2028 2029
        }
    }
    av_freep(&s->tile);
2030 2031
    memset(s->codsty, 0, sizeof(s->codsty));
    memset(s->qntsty, 0, sizeof(s->qntsty));
2032
    memset(s->properties, 0, sizeof(s->properties));
2033
    memset(&s->poc  , 0, sizeof(s->poc));
2034
    s->numXtiles = s->numYtiles = 0;
2035
    s->ncomponents = 0;
2036 2037 2038 2039 2040 2041
}

static int jpeg2000_read_main_headers(Jpeg2000DecoderContext *s)
{
    Jpeg2000CodingStyle *codsty = s->codsty;
    Jpeg2000QuantStyle *qntsty  = s->qntsty;
2042
    Jpeg2000POC         *poc    = &s->poc;
2043 2044 2045 2046 2047
    uint8_t *properties         = s->properties;

    for (;;) {
        int len, ret = 0;
        uint16_t marker;
2048
        int oldpos;
2049

2050
        if (bytestream2_get_bytes_left(&s->g) < 2) {
2051 2052 2053 2054
            av_log(s->avctx, AV_LOG_ERROR, "Missing EOC\n");
            break;
        }

2055 2056
        marker = bytestream2_get_be16u(&s->g);
        oldpos = bytestream2_tell(&s->g);
2057

2058
        if (marker == JPEG2000_SOD) {
2059 2060
            Jpeg2000Tile *tile;
            Jpeg2000TilePart *tp;
2061

2062 2063 2064 2065
            if (!s->tile) {
                av_log(s->avctx, AV_LOG_ERROR, "Missing SIZ\n");
                return AVERROR_INVALIDDATA;
            }
2066 2067 2068 2069
            if (s->curtileno < 0) {
                av_log(s->avctx, AV_LOG_ERROR, "Missing SOT\n");
                return AVERROR_INVALIDDATA;
            }
2070 2071 2072

            tile = s->tile + s->curtileno;
            tp = tile->tile_part + tile->tp_idx;
2073 2074 2075 2076
            if (tp->tp_end < s->g.buffer) {
                av_log(s->avctx, AV_LOG_ERROR, "Invalid tpend\n");
                return AVERROR_INVALIDDATA;
            }
2077 2078 2079 2080 2081

            if (tile->has_ppt && tile->tp_idx == 0) {
                bytestream2_init(&tile->packed_headers_stream, tile->packed_headers, tile->packed_headers_size);
            }

2082 2083 2084 2085 2086
            bytestream2_init(&tp->tpg, s->g.buffer, tp->tp_end - s->g.buffer);
            bytestream2_skip(&s->g, tp->tp_end - s->g.buffer);

            continue;
        }
2087 2088 2089
        if (marker == JPEG2000_EOC)
            break;

2090
        len = bytestream2_get_be16(&s->g);
2091
        if (len < 2 || bytestream2_get_bytes_left(&s->g) < len - 2) {
2092 2093 2094 2095 2096 2097
            if (s->avctx->strict_std_compliance >= FF_COMPLIANCE_STRICT) {
                av_log(s->avctx, AV_LOG_ERROR, "Invalid len %d left=%d\n", len, bytestream2_get_bytes_left(&s->g));
                return AVERROR_INVALIDDATA;
            }
            av_log(s->avctx, AV_LOG_WARNING, "Missing EOC Marker.\n");
            break;
2098
        }
2099

2100 2101
        switch (marker) {
        case JPEG2000_SIZ:
2102 2103 2104 2105
            if (s->ncomponents) {
                av_log(s->avctx, AV_LOG_ERROR, "Duplicate SIZ\n");
                return AVERROR_INVALIDDATA;
            }
2106
            ret = get_siz(s);
2107 2108
            if (!s->tile)
                s->numXtiles = s->numYtiles = 0;
2109 2110 2111 2112 2113 2114 2115
            break;
        case JPEG2000_COC:
            ret = get_coc(s, codsty, properties);
            break;
        case JPEG2000_COD:
            ret = get_cod(s, codsty, properties);
            break;
2116 2117 2118
        case JPEG2000_RGN:
            ret = get_rgn(s, len);
            break;
2119 2120 2121 2122 2123 2124
        case JPEG2000_QCC:
            ret = get_qcc(s, len, qntsty, properties);
            break;
        case JPEG2000_QCD:
            ret = get_qcd(s, len, qntsty, properties);
            break;
2125 2126 2127
        case JPEG2000_POC:
            ret = get_poc(s, len, poc);
            break;
2128
        case JPEG2000_SOT:
2129
            if (!(ret = get_sot(s, len))) {
2130
                av_assert1(s->curtileno >= 0);
2131 2132
                codsty = s->tile[s->curtileno].codsty;
                qntsty = s->tile[s->curtileno].qntsty;
2133
                poc    = &s->tile[s->curtileno].poc;
2134 2135
                properties = s->tile[s->curtileno].properties;
            }
2136
            break;
2137 2138
        case JPEG2000_PLM:
            // the PLM marker is ignored
2139 2140
        case JPEG2000_COM:
            // the comment is ignored
2141
            bytestream2_skip(&s->g, len - 2);
2142
            break;
2143 2144 2145
        case JPEG2000_CRG:
            ret = read_crg(s, len);
            break;
2146 2147 2148 2149
        case JPEG2000_TLM:
            // Tile-part lengths
            ret = get_tlm(s, len);
            break;
2150 2151 2152 2153
        case JPEG2000_PLT:
            // Packet length, tile-part header
            ret = get_plt(s, len);
            break;
2154 2155 2156 2157
        case JPEG2000_PPT:
            // Packed headers, tile-part header
            ret = get_ppt(s, len);
            break;
2158 2159
        default:
            av_log(s->avctx, AV_LOG_ERROR,
2160
                   "unsupported marker 0x%.4"PRIX16" at pos 0x%X\n",
2161 2162
                   marker, bytestream2_tell(&s->g) - 4);
            bytestream2_skip(&s->g, len - 2);
2163 2164
            break;
        }
2165
        if (bytestream2_tell(&s->g) - oldpos != len || ret) {
2166
            av_log(s->avctx, AV_LOG_ERROR,
2167 2168
                   "error during processing marker segment %.4"PRIx16"\n",
                   marker);
2169 2170 2171 2172 2173 2174 2175 2176 2177 2178
            return ret ? ret : -1;
        }
    }
    return 0;
}

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

2181 2182 2183
    for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++) {
        Jpeg2000Tile *tile = s->tile + tileno;

2184
        if ((ret = init_tile(s, tileno)) < 0)
2185 2186
            return ret;

2187
        if ((ret = jpeg2000_decode_packets(s, tile)) < 0)
2188 2189
            return ret;
    }
2190 2191 2192 2193 2194 2195

    return 0;
}

static int jp2_find_codestream(Jpeg2000DecoderContext *s)
{
2196 2197
    uint32_t atom_size, atom, atom_end;
    int search_range = 10;
2198

2199
    while (search_range
2200 2201
           &&
           bytestream2_get_bytes_left(&s->g) >= 8) {
2202 2203
        atom_size = bytestream2_get_be32u(&s->g);
        atom      = bytestream2_get_be32u(&s->g);
2204 2205 2206 2207 2208 2209 2210 2211 2212 2213
        if (atom_size == 1) {
            if (bytestream2_get_be32u(&s->g)) {
                avpriv_request_sample(s->avctx, "Huge atom");
                return 0;
            }
            atom_size = bytestream2_get_be32u(&s->g);
            atom_end  = bytestream2_tell(&s->g) + atom_size - 16;
        } else {
            atom_end  = bytestream2_tell(&s->g) + atom_size -  8;
        }
2214 2215 2216 2217 2218 2219 2220 2221

        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 &&
2222
                   atom_size >= 16) {
2223
            uint32_t atom2_size, atom2, atom2_end;
2224 2225 2226
            do {
                atom2_size = bytestream2_get_be32u(&s->g);
                atom2      = bytestream2_get_be32u(&s->g);
2227 2228
                atom2_end  = bytestream2_tell(&s->g) + atom2_size - 8;
                if (atom2_size < 8 || atom2_end > atom_end || atom2_end < atom2_size)
2229
                    break;
2230
                atom2_size -= 8;
2231 2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244 2245 2246 2247 2248 2249
                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];
                    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;
2250
                    if (colour_count > AVPALETTE_COUNT ||
2251 2252 2253 2254 2255 2256
                        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");
2257
                        bytestream2_seek(&s->g, atom2_end, SEEK_SET);
2258 2259 2260 2261
                        continue;
                    }
                    s->pal8 = 1;
                    for (i = 0; i < colour_count; i++) {
2262
                        uint32_t r, g, b;
2263 2264 2265 2266 2267 2268 2269 2270
                        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];
2271
                            g |= g >> colour_depth[1];
2272 2273 2274 2275 2276
                        } 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];
2277
                            b |= b >> colour_depth[2];
2278 2279 2280 2281 2282
                        } else {
                            b = bytestream2_get_be16u(&s->g) >> colour_depth[2] - 8;
                        }
                        s->palette[i] = 0xffu << 24 | r << 16 | g << 8 | b;
                    }
2283
                } else if (atom2 == MKBETAG('c','d','e','f') && atom2_size >= 2) {
2284 2285 2286
                    int n = bytestream2_get_be16u(&s->g);
                    for (; n>0; n--) {
                        int cn   = bytestream2_get_be16(&s->g);
2287
                        int av_unused typ  = bytestream2_get_be16(&s->g);
2288
                        int asoc = bytestream2_get_be16(&s->g);
2289
                        if (cn < 4 && asoc < 4)
2290 2291
                            s->cdef[cn] = asoc;
                    }
2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306
                } else if (atom2 == MKBETAG('r','e','s',' ') && atom2_size >= 18) {
                    int64_t vnum, vden, hnum, hden, vexp, hexp;
                    uint32_t resx;
                    bytestream2_skip(&s->g, 4);
                    resx = bytestream2_get_be32u(&s->g);
                    if (resx != MKBETAG('r','e','s','c') && resx != MKBETAG('r','e','s','d')) {
                        bytestream2_seek(&s->g, atom2_end, SEEK_SET);
                        continue;
                    }
                    vnum = bytestream2_get_be16u(&s->g);
                    vden = bytestream2_get_be16u(&s->g);
                    hnum = bytestream2_get_be16u(&s->g);
                    hden = bytestream2_get_be16u(&s->g);
                    vexp = bytestream2_get_byteu(&s->g);
                    hexp = bytestream2_get_byteu(&s->g);
2307
                    if (!vnum || !vden || !hnum || !hden) {
2308 2309 2310 2311
                        bytestream2_seek(&s->g, atom2_end, SEEK_SET);
                        av_log(s->avctx, AV_LOG_WARNING, "RES box invalid\n");
                        continue;
                    }
2312 2313 2314 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324
                    if (vexp > hexp) {
                        vexp -= hexp;
                        hexp = 0;
                    } else {
                        hexp -= vexp;
                        vexp = 0;
                    }
                    if (   INT64_MAX / (hnum * vden) > pow(10, hexp)
                        && INT64_MAX / (vnum * hden) > pow(10, vexp))
                        av_reduce(&s->sar.den, &s->sar.num,
                                  hnum * vden * pow(10, hexp),
                                  vnum * hden * pow(10, vexp),
                                  INT32_MAX);
2325
                }
2326 2327
                bytestream2_seek(&s->g, atom2_end, SEEK_SET);
            } while (atom_end - atom2_end >= 8);
2328 2329 2330
        } else {
            search_range--;
        }
2331
        bytestream2_seek(&s->g, atom_end, SEEK_SET);
2332 2333 2334 2335 2336
    }

    return 0;
}

2337 2338 2339 2340 2341 2342
static av_cold void jpeg2000_init_static_data(void)
{
    ff_jpeg2000_init_tier1_luts();
    ff_mqc_init_context_tables();
}

2343 2344
static av_cold int jpeg2000_decode_init(AVCodecContext *avctx)
{
2345
    static AVOnce init_static_once = AV_ONCE_INIT;
2346 2347
    Jpeg2000DecoderContext *s = avctx->priv_data;

2348
    ff_thread_once(&init_static_once, jpeg2000_init_static_data);
2349 2350 2351 2352 2353
    ff_jpeg2000dsp_init(&s->dsp);

    return 0;
}

2354 2355 2356 2357
static int jpeg2000_decode_frame(AVCodecContext *avctx, void *data,
                                 int *got_frame, AVPacket *avpkt)
{
    Jpeg2000DecoderContext *s = avctx->priv_data;
2358
    ThreadFrame frame = { .f = data };
2359
    AVFrame *picture = data;
2360
    int ret;
2361 2362

    s->avctx     = avctx;
2363
    bytestream2_init(&s->g, avpkt->data, avpkt->size);
2364
    s->curtileno = -1;
2365
    memset(s->cdef, -1, sizeof(s->cdef));
2366

2367
    if (bytestream2_get_bytes_left(&s->g) < 2) {
2368
        ret = AVERROR_INVALIDDATA;
2369 2370
        goto end;
    }
2371 2372

    // check if the image is in jp2 format
2373 2374 2375 2376
    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)) {
2377 2378
        if (!jp2_find_codestream(s)) {
            av_log(avctx, AV_LOG_ERROR,
2379
                   "Could not find Jpeg2000 codestream atom.\n");
2380
            ret = AVERROR_INVALIDDATA;
2381
            goto end;
2382
        }
2383 2384
    } else {
        bytestream2_seek(&s->g, 0, SEEK_SET);
2385 2386
    }

2387 2388 2389
    while (bytestream2_get_bytes_left(&s->g) >= 3 && bytestream2_peek_be16(&s->g) != JPEG2000_SOC)
        bytestream2_skip(&s->g, 1);

2390
    if (bytestream2_get_be16u(&s->g) != JPEG2000_SOC) {
2391
        av_log(avctx, AV_LOG_ERROR, "SOC marker not present\n");
2392
        ret = AVERROR_INVALIDDATA;
2393
        goto end;
2394 2395
    }
    if (ret = jpeg2000_read_main_headers(s))
2396
        goto end;
2397 2398

    /* get picture buffer */
2399
    if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
2400
        goto end;
2401 2402 2403 2404
    picture->pict_type = AV_PICTURE_TYPE_I;
    picture->key_frame = 1;

    if (ret = jpeg2000_read_bitstream_packets(s))
2405
        goto end;
2406

2407
    avctx->execute2(avctx, jpeg2000_decode_tile, picture, NULL, s->numXtiles * s->numYtiles);
2408

2409 2410 2411 2412
    jpeg2000_dec_cleanup(s);

    *got_frame = 1;

2413 2414
    if (s->avctx->pix_fmt == AV_PIX_FMT_PAL8)
        memcpy(picture->data[1], s->palette, 256 * sizeof(uint32_t));
2415 2416 2417
    if (s->sar.num && s->sar.den)
        avctx->sample_aspect_ratio = s->sar;
    s->sar.num = s->sar.den = 0;
2418

2419
    return bytestream2_tell(&s->g);
2420

2421
end:
2422 2423
    jpeg2000_dec_cleanup(s);
    return ret;
2424 2425 2426 2427 2428 2429 2430
}

#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",
2431
        OFFSET(reduction_factor), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, JPEG2000_MAX_RESLEVELS - 1, VD },
2432 2433 2434
    { NULL },
};

2435
static const AVClass jpeg2000_class = {
2436 2437 2438 2439 2440 2441 2442
    .class_name = "jpeg2000",
    .item_name  = av_default_item_name,
    .option     = options,
    .version    = LIBAVUTIL_VERSION_INT,
};

AVCodec ff_jpeg2000_decoder = {
2443 2444 2445 2446
    .name             = "jpeg2000",
    .long_name        = NULL_IF_CONFIG_SMALL("JPEG 2000"),
    .type             = AVMEDIA_TYPE_VIDEO,
    .id               = AV_CODEC_ID_JPEG2000,
2447
    .capabilities     = AV_CODEC_CAP_SLICE_THREADS | AV_CODEC_CAP_FRAME_THREADS | AV_CODEC_CAP_DR1,
2448
    .priv_data_size   = sizeof(Jpeg2000DecoderContext),
2449
    .init             = jpeg2000_decode_init,
2450
    .decode           = jpeg2000_decode_frame,
2451
    .priv_class       = &jpeg2000_class,
2452
    .max_lowres       = 5,
2453
    .profiles         = NULL_IF_CONFIG_SMALL(ff_jpeg2000_profiles)
2454
};