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

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

28
#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
    uint16_t tp_idx;                    // Tile-part index
87
    int coord[2][2];                    // border coordinates {{x0, x1}, {y0, y1}}
88 89 90 91 92
} Jpeg2000Tile;

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

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

    Jpeg2000CodingStyle codsty[4];
    Jpeg2000QuantStyle  qntsty[4];
115
    Jpeg2000POC         poc;
116 117 118

    int             bit_index;

119 120
    int             curtileno;

121
    Jpeg2000Tile    *tile;
122
    Jpeg2000DSPContext dsp;
123 124

    /*options parameters*/
125
    int             reduction_factor;
126 127 128 129 130 131 132 133 134
} 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;
135

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

static void jpeg2000_flush(Jpeg2000DecoderContext *s)
{
149 150
    if (bytestream2_get_byte(&s->g) == 0xff)
        bytestream2_skip(&s->g, 1);
151 152 153 154 155 156 157 158 159 160
    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;

161 162
    if (!node) {
        av_log(s->avctx, AV_LOG_ERROR, "missing node\n");
163
        return AVERROR_INVALIDDATA;
164
    }
165

166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194
    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;
}

195 196 197 198 199 200
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);

201 202
    av_assert2(desc);

203 204 205 206 207 208
    if (desc->nb_components != components) {
        return 0;
    }

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

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

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

268 269
    if (bytestream2_get_bytes_left(&s->g) < 36) {
        av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for SIZ\n");
270
        return AVERROR_INVALIDDATA;
271
    }
272

273 274 275 276 277 278 279 280 281
    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
282
    ncomponents       = bytestream2_get_be16u(&s->g); // CSiz
283

284 285 286 287
    if (s->image_offset_x || s->image_offset_y) {
        avpriv_request_sample(s->avctx, "Support for image offsets");
        return AVERROR_PATCHWELCOME;
    }
288
    if (av_image_check_size2(s->width, s->height, s->avctx->max_pixels, AV_PIX_FMT_NONE, 0, s->avctx)) {
289 290 291
        avpriv_request_sample(s->avctx, "Large Dimensions");
        return AVERROR_PATCHWELCOME;
    }
292

293 294 295
    if (ncomponents <= 0) {
        av_log(s->avctx, AV_LOG_ERROR, "Invalid number of components: %d\n",
               s->ncomponents);
296
        return AVERROR_INVALIDDATA;
297
    }
298

299
    if (ncomponents > 4) {
300
        avpriv_request_sample(s->avctx, "Support for %d components",
301
                              ncomponents);
302 303 304
        return AVERROR_PATCHWELCOME;
    }

305 306
    if (s->tile_offset_x < 0 || s->tile_offset_y < 0 ||
        s->image_offset_x < s->tile_offset_x ||
307 308 309 310
        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
    ) {
311
        av_log(s->avctx, AV_LOG_ERROR, "Tile offsets are invalid\n");
312 313 314
        return AVERROR_INVALIDDATA;
    }

315 316
    s->ncomponents = ncomponents;

317
    if (s->tile_width <= 0 || s->tile_height <= 0) {
318 319
        av_log(s->avctx, AV_LOG_ERROR, "Invalid tile dimension %dx%d.\n",
               s->tile_width, s->tile_height);
320
        return AVERROR_INVALIDDATA;
321
    }
322

323 324
    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);
325
        return AVERROR_INVALIDDATA;
326
    }
327 328

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

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

346 347 348 349
    // 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)
    ) {
350
        s->numXtiles = s->numYtiles = 0;
351
        return AVERROR(EINVAL);
352
    }
353

354 355 356
    s->tile = av_mallocz_array(s->numXtiles * s->numYtiles, sizeof(*s->tile));
    if (!s->tile) {
        s->numXtiles = s->numYtiles = 0;
357
        return AVERROR(ENOMEM);
358
    }
359 360 361 362 363 364 365 366 367 368

    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 */
369 370 371 372 373 374 375
    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;
376

377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393
    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);
394
            break;
395
        default:
396 397
            possible_fmts = all_pix_fmts;
            possible_fmts_nb = FF_ARRAY_ELEMS(all_pix_fmts);
398 399
            break;
        }
400 401 402 403 404 405 406
    }
    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;
        }
    }
407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424

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


425
    if (i == possible_fmts_nb) {
426 427
        av_log(s->avctx, AV_LOG_ERROR,
               "Unknown pix_fmt, profile: %d, colour_space: %d, "
428 429 430 431 432
               "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",
433
               s->avctx->profile, s->colour_space, ncomponents, s->precision,
434 435 436 437
               s->cdx[0],
               s->cdy[0],
               ncomponents > 1 ? s->cdx[1] : 0,
               ncomponents > 1 ? s->cdy[1] : 0,
438
               ncomponents > 2 ? s->cdx[2] : 0,
439 440 441
               ncomponents > 2 ? s->cdy[2] : 0,
               ncomponents > 3 ? s->cdx[3] : 0,
               ncomponents > 3 ? s->cdy[3] : 0);
442
        return AVERROR_PATCHWELCOME;
443
    }
444
    s->avctx->bits_per_raw_sample = s->precision;
445 446 447 448 449 450 451 452
    return 0;
}

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

453 454
    if (bytestream2_get_bytes_left(&s->g) < 5) {
        av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for COX\n");
455
        return AVERROR_INVALIDDATA;
456
    }
457

458 459
    /*  nreslevels = number of resolution levels
                   = number of decomposition level +1 */
460
    c->nreslevels = bytestream2_get_byteu(&s->g) + 1;
461 462 463 464
    if (c->nreslevels >= JPEG2000_MAX_RESLEVELS) {
        av_log(s->avctx, AV_LOG_ERROR, "nreslevels %d is invalid\n", c->nreslevels);
        return AVERROR_INVALIDDATA;
    }
465

466 467 468 469 470 471 472 473 474 475
    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);
    }

476
    /* compute number of resolution levels to decode */
477
    c->nreslevels2decode = c->nreslevels - s->reduction_factor;
478

479 480 481 482
    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 ||
483
        c->log2_cblk_width + c->log2_cblk_height > 12) {
484 485 486
        av_log(s->avctx, AV_LOG_ERROR, "cblk size invalid\n");
        return AVERROR_INVALIDDATA;
    }
487

488
    c->cblk_style = bytestream2_get_byteu(&s->g);
489
    if (c->cblk_style != 0) { // cblk style
490
        av_log(s->avctx, AV_LOG_WARNING, "extra cblk styles %X\n", c->cblk_style);
491 492
        if (c->cblk_style & JPEG2000_CBLK_BYPASS)
            av_log(s->avctx, AV_LOG_WARNING, "Selective arithmetic coding bypass\n");
493
    }
494
    c->transform = bytestream2_get_byteu(&s->g); // DWT transformation type
495
    /* set integer 9/7 DWT in case of BITEXACT flag */
496
    if ((s->avctx->flags & AV_CODEC_FLAG_BITEXACT) && (c->transform == FF_DWT97))
497
        c->transform = FF_DWT97_INT;
498 499 500
    else if (c->transform == FF_DWT53) {
        s->avctx->properties |= FF_CODEC_PROPERTY_LOSSLESS;
    }
501 502 503 504

    if (c->csty & JPEG2000_CSTY_PREC) {
        int i;
        for (i = 0; i < c->nreslevels; i++) {
505
            byte = bytestream2_get_byte(&s->g);
506 507
            c->log2_prec_widths[i]  =  byte       & 0x0F;    // precinct PPx
            c->log2_prec_heights[i] = (byte >> 4) & 0x0F;    // precinct PPy
508 509 510 511 512 513 514
            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;
                }
515
        }
516 517 518
    } else {
        memset(c->log2_prec_widths , 15, sizeof(c->log2_prec_widths ));
        memset(c->log2_prec_heights, 15, sizeof(c->log2_prec_heights));
519 520 521 522 523 524 525 526 527
    }
    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;
528
    int compno, ret;
529

530 531
    if (bytestream2_get_bytes_left(&s->g) < 5) {
        av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for COD\n");
532
        return AVERROR_INVALIDDATA;
533
    }
534

535
    tmp.csty = bytestream2_get_byteu(&s->g);
536 537

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

540 541
    tmp.nlayers    = bytestream2_get_be16u(&s->g);
    tmp.mct        = bytestream2_get_byteu(&s->g); // multiple component transformation
542

543
    if (tmp.mct && s->ncomponents < 3) {
544
        av_log(s->avctx, AV_LOG_ERROR,
545
               "MCT %"PRIu8" with too few components (%d)\n",
546
               tmp.mct, s->ncomponents);
547 548 549
        return AVERROR_INVALIDDATA;
    }

550 551 552
    if ((ret = get_cox(s, &tmp)) < 0)
        return ret;

553 554 555 556 557 558 559 560 561 562 563
    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)
{
564
    int compno, ret;
565

566 567
    if (bytestream2_get_bytes_left(&s->g) < 2) {
        av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for COC\n");
568
        return AVERROR_INVALIDDATA;
569
    }
570

571
    compno = bytestream2_get_byteu(&s->g);
572

573
    if (compno >= s->ncomponents) {
574 575 576
        av_log(s->avctx, AV_LOG_ERROR,
               "Invalid compno %d. There are %d components in the image.\n",
               compno, s->ncomponents);
577 578 579
        return AVERROR_INVALIDDATA;
    }

580
    c      += compno;
581
    c->csty = bytestream2_get_byteu(&s->g);
582 583 584

    if ((ret = get_cox(s, c)) < 0)
        return ret;
585 586 587 588 589 590 591 592 593 594

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

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

595
    if (bytestream2_get_bytes_left(&s->g) < 1)
596
        return AVERROR_INVALIDDATA;
597

598
    x = bytestream2_get_byteu(&s->g); // Sqcd
599 600 601 602 603 604

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

    if (q->quantsty == JPEG2000_QSTY_NONE) {
        n -= 3;
605
        if (bytestream2_get_bytes_left(&s->g) < n ||
606
            n > JPEG2000_MAX_DECLEVELS*3)
607
            return AVERROR_INVALIDDATA;
608
        for (i = 0; i < n; i++)
609
            q->expn[i] = bytestream2_get_byteu(&s->g) >> 3;
610
    } else if (q->quantsty == JPEG2000_QSTY_SI) {
611
        if (bytestream2_get_bytes_left(&s->g) < 2)
612
            return AVERROR_INVALIDDATA;
613
        x          = bytestream2_get_be16u(&s->g);
614 615
        q->expn[0] = x >> 11;
        q->mant[0] = x & 0x7ff;
616
        for (i = 1; i < JPEG2000_MAX_DECLEVELS * 3; i++) {
617 618 619 620 621 622
            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;
623
        if (bytestream2_get_bytes_left(&s->g) < 2 * n ||
624
            n > JPEG2000_MAX_DECLEVELS*3)
625
            return AVERROR_INVALIDDATA;
626
        for (i = 0; i < n; i++) {
627
            x          = bytestream2_get_be16u(&s->g);
628 629 630 631 632 633 634 635 636 637 638 639
            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;
640
    int compno, ret;
641

642 643
    memset(&tmp, 0, sizeof(tmp));

644 645
    if ((ret = get_qcx(s, n, &tmp)) < 0)
        return ret;
646 647 648 649 650 651 652 653 654 655 656 657 658
    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;

659
    if (bytestream2_get_bytes_left(&s->g) < 1)
660
        return AVERROR_INVALIDDATA;
661

662 663
    compno = bytestream2_get_byteu(&s->g);

664
    if (compno >= s->ncomponents) {
665 666 667
        av_log(s->avctx, AV_LOG_ERROR,
               "Invalid compno %d. There are %d components in the image.\n",
               compno, s->ncomponents);
668 669 670
        return AVERROR_INVALIDDATA;
    }

671 672 673 674
    properties[compno] |= HAD_QCC;
    return get_qcx(s, n - 1, q + compno);
}

675 676 677 678 679 680 681 682 683 684 685 686
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) {
687
        avpriv_request_sample(s->avctx, "Fat POC not supported");
688 689 690 691 692
        return AVERROR_PATCHWELCOME;
    }

    tmp.nb_poc = (size - 2) / elem_size;
    if (tmp.nb_poc > MAX_POCS) {
693
        avpriv_request_sample(s->avctx, "Too many POCs (%d)", tmp.nb_poc);
694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735
        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;
}


736
/* Get start of tile segment. */
737
static int get_sot(Jpeg2000DecoderContext *s, int n)
738 739 740 741
{
    Jpeg2000TilePart *tp;
    uint16_t Isot;
    uint32_t Psot;
742
    unsigned TPsot;
743

744
    if (bytestream2_get_bytes_left(&s->g) < 8)
745
        return AVERROR_INVALIDDATA;
746

747
    s->curtileno = 0;
748
    Isot = bytestream2_get_be16u(&s->g);        // Isot
749
    if (Isot >= s->numXtiles * s->numYtiles)
750
        return AVERROR_INVALIDDATA;
751

752
    s->curtileno = Isot;
753 754
    Psot  = bytestream2_get_be32u(&s->g);       // Psot
    TPsot = bytestream2_get_byteu(&s->g);       // TPsot
755 756

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

759
    if (!Psot)
760
        Psot = bytestream2_get_bytes_left(&s->g) - 2 + n + 2;
761

762
    if (Psot > bytestream2_get_bytes_left(&s->g) - 2 + n + 2) {
763
        av_log(s->avctx, AV_LOG_ERROR, "Psot %"PRIu32" too big\n", Psot);
764 765
        return AVERROR_INVALIDDATA;
    }
766

767 768 769 770
    if (TPsot >= FF_ARRAY_ELEMS(s->tile[Isot].tile_part)) {
        avpriv_request_sample(s->avctx, "Too many tile parts");
        return AVERROR_PATCHWELCOME;
    }
771

772 773
    s->tile[Isot].tp_idx = TPsot;
    tp             = s->tile[Isot].tile_part + TPsot;
774
    tp->tile_index = Isot;
775 776 777 778
    tp->tp_end     = s->g.buffer + Psot - n - 2;

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

780 781 782
        /* copy defaults */
        memcpy(tile->codsty, s->codsty, s->ncomponents * sizeof(Jpeg2000CodingStyle));
        memcpy(tile->qntsty, s->qntsty, s->ncomponents * sizeof(Jpeg2000QuantStyle));
783 784
        memcpy(&tile->poc  , &s->poc  , sizeof(tile->poc));
        tile->poc.is_default = 1;
785
    }
786 787 788 789 790 791 792 793 794 795 796 797 798 799 800

    return 0;
}

/* Tile-part lengths: see ISO 15444-1:2002, section A.7.1
 * Used to know the number of tile parts and lengths.
 * There may be multiple TLMs in the header.
 * TODO: The function is not used for tile-parts management, nor anywhere else.
 * It can be useful to allocate memory for tile parts, before managing the SOT
 * markers. Parsing the TLM header is needed to increment the input header
 * buffer.
 * This marker is mandatory for DCI. */
static uint8_t get_tlm(Jpeg2000DecoderContext *s, int n)
{
    uint8_t Stlm, ST, SP, tile_tlm, i;
801 802
    bytestream2_get_byte(&s->g);               /* Ztlm: skipped */
    Stlm = bytestream2_get_byte(&s->g);
803 804 805 806 807 808 809 810 811 812 813

    // too complex ? ST = ((Stlm >> 4) & 0x01) + ((Stlm >> 4) & 0x02);
    ST = (Stlm >> 4) & 0x03;
    // TODO: Manage case of ST = 0b11 --> raise error
    SP       = (Stlm >> 6) & 0x01;
    tile_tlm = (n - 4) / ((SP + 1) * 2 + ST);
    for (i = 0; i < tile_tlm; i++) {
        switch (ST) {
        case 0:
            break;
        case 1:
814
            bytestream2_get_byte(&s->g);
815 816
            break;
        case 2:
817
            bytestream2_get_be16(&s->g);
818 819
            break;
        case 3:
820
            bytestream2_get_be32(&s->g);
821 822 823
            break;
        }
        if (SP == 0) {
824
            bytestream2_get_be16(&s->g);
825
        } else {
826
            bytestream2_get_be32(&s->g);
827 828 829 830 831
        }
    }
    return 0;
}

832
static int get_plt(Jpeg2000DecoderContext *s, int n)
833 834
{
    int i;
835
    int v;
836

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

840 841 842
    if (n < 4)
        return AVERROR_INVALIDDATA;

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

    for (i = 0; i < n - 3; i++) {
846
        v = bytestream2_get_byte(&s->g);
847
    }
848 849
    if (v & 0x80)
        return AVERROR_INVALIDDATA;
850 851 852 853

    return 0;
}

854 855 856 857 858 859 860 861 862 863
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);

864 865 866 867
    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);
868

869 870
    for (compno = 0; compno < s->ncomponents; compno++) {
        Jpeg2000Component *comp = tile->comp + compno;
871 872
        Jpeg2000CodingStyle *codsty = tile->codsty + compno;
        Jpeg2000QuantStyle  *qntsty = tile->qntsty + compno;
873 874
        int ret; // global bandno

875 876 877 878
        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];
879 880 881 882 883 884
        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];
        }
885

886 887 888 889
        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);
890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925

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

926
static int jpeg2000_decode_packet(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile, int *tp_index,
927 928 929 930 931
                                  Jpeg2000CodingStyle *codsty,
                                  Jpeg2000ResLevel *rlevel, int precno,
                                  int layno, uint8_t *expn, int numgbits)
{
    int bandno, cblkno, ret, nb_code_blocks;
932
    int cwsno;
933

934 935 936 937
    if (layno < rlevel->band[0].prec[precno].decoded_layers)
        return 0;
    rlevel->band[0].prec[precno].decoded_layers = layno + 1;

938 939 940 941 942 943
    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;
        }
    }

944 945
    if (bytestream2_peek_be32(&s->g) == JPEG2000_SOP_FIXED_BYTES)
        bytestream2_skip(&s->g, JPEG2000_SOP_BYTE_LENGTH);
946

947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964
    if (!(ret = get_bits(s, 1))) {
        jpeg2000_flush(s);
        return 0;
    } else if (ret < 0)
        return ret;

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

        if (band->coord[0][0] == band->coord[0][1] ||
            band->coord[1][0] == band->coord[1][1])
            continue;
        nb_code_blocks =  prec->nb_codeblocks_height *
                          prec->nb_codeblocks_width;
        for (cblkno = 0; cblkno < nb_code_blocks; cblkno++) {
            Jpeg2000Cblk *cblk = prec->cblk + cblkno;
            int incl, newpasses, llen;
965
            void *tmp;
966 967 968 969 970 971 972 973 974 975

            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;

976 977
            if (!cblk->npasses) {
                int v = expn[bandno] + numgbits - 1 -
978
                        tag_tree_decode(s, prec->zerobits + cblkno, 100);
979
                if (v < 0 || v > 30) {
980
                    av_log(s->avctx, AV_LOG_ERROR,
981
                           "nonzerobits %d invalid or unsupported\n", v);
982 983 984 985
                    return AVERROR_INVALIDDATA;
                }
                cblk->nonzerobits = v;
            }
986 987
            if ((newpasses = getnpasses(s)) < 0)
                return newpasses;
988 989
            av_assert2(newpasses > 0);
            if (cblk->npasses + newpasses >= JPEG2000_MAX_PASSES) {
990
                avpriv_request_sample(s->avctx, "Too many passes");
991 992
                return AVERROR_PATCHWELCOME;
            }
993 994
            if ((llen = getlblockinc(s)) < 0)
                return llen;
995 996
            if (cblk->lblock + llen + av_log2(newpasses) > 16) {
                avpriv_request_sample(s->avctx,
997
                                      "Block with length beyond 16 bits");
998 999 1000
                return AVERROR_PATCHWELCOME;
            }

1001
            cblk->lblock += llen;
1002 1003 1004

            cblk->nb_lengthinc = 0;
            cblk->nb_terminationsinc = 0;
1005 1006 1007 1008 1009 1010 1011 1012
            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;
1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025
            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;
1026 1027 1028 1029 1030 1031 1032 1033 1034
                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) {
1035 1036
                    avpriv_request_sample(s->avctx,
                                        "Block with lengthinc greater than %"SIZE_SPECIFIER"",
1037
                                        cblk->data_allocated);
1038 1039 1040 1041 1042 1043
                    return AVERROR_PATCHWELCOME;
                }
                cblk->lengthinc[cblk->nb_lengthinc++] = ret;
                cblk->npasses  += newpasses1;
                newpasses -= newpasses1;
            } while(newpasses);
1044 1045 1046 1047 1048
        }
    }
    jpeg2000_flush(s);

    if (codsty->csty & JPEG2000_CSTY_EPH) {
1049 1050
        if (bytestream2_peek_be16(&s->g) == JPEG2000_EPH)
            bytestream2_skip(&s->g, 2);
1051
        else
1052
            av_log(s->avctx, AV_LOG_ERROR, "EPH marker not found. instead %X\n", bytestream2_peek_be32(&s->g));
1053 1054 1055 1056 1057 1058 1059 1060 1061
    }

    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;
1062 1063
            if (!cblk->nb_terminationsinc && !cblk->lengthinc)
                continue;
1064
            for (cwsno = 0; cwsno < cblk->nb_lengthinc; cwsno ++) {
1065 1066 1067 1068 1069 1070 1071 1072
                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;
                    }
                }
1073
                if (   bytestream2_get_bytes_left(&s->g) < cblk->lengthinc[cwsno]
1074
                    || cblk->data_allocated < cblk->length + cblk->lengthinc[cwsno] + 4
1075 1076
                ) {
                    av_log(s->avctx, AV_LOG_ERROR,
1077 1078
                        "Block length %"PRIu16" or lengthinc %d is too large, left %d\n",
                        cblk->length, cblk->lengthinc[cwsno], bytestream2_get_bytes_left(&s->g));
1079 1080
                    return AVERROR_INVALIDDATA;
                }
1081

1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092
                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;
                }
            }
1093
            av_freep(&cblk->lengthinc);
1094 1095 1096 1097 1098
        }
    }
    return 0;
}

1099 1100 1101
static int jpeg2000_decode_packets_po_iteration(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile,
                                             int RSpoc, int CSpoc,
                                             int LYEpoc, int REpoc, int CEpoc,
1102
                                             int Ppoc, int *tp_index)
1103
{
1104 1105
    int ret = 0;
    int layno, reslevelno, compno, precno, ok_reslevel;
1106
    int x, y;
1107
    int step_x, step_y;
1108

1109
    switch (Ppoc) {
1110
    case JPEG2000_PGOD_RLCP:
1111
        av_log(s->avctx, AV_LOG_DEBUG, "Progression order RLCP\n");
1112
        ok_reslevel = 1;
1113
        for (reslevelno = RSpoc; ok_reslevel && reslevelno < REpoc; reslevelno++) {
1114
            ok_reslevel = 0;
1115 1116
            for (layno = 0; layno < LYEpoc; layno++) {
                for (compno = CSpoc; compno < CEpoc; compno++) {
1117 1118 1119 1120 1121 1122 1123
                    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++)
1124
                            if ((ret = jpeg2000_decode_packet(s, tile, tp_index,
1125 1126 1127 1128 1129 1130 1131 1132 1133 1134
                                                              codsty, rlevel,
                                                              precno, layno,
                                                              qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
                                                              qntsty->nguardbits)) < 0)
                                return ret;
                    }
                }
            }
        }
        break;
1135

1136
    case JPEG2000_PGOD_LRCP:
1137
        av_log(s->avctx, AV_LOG_DEBUG, "Progression order LRCP\n");
1138
        for (layno = 0; layno < LYEpoc; layno++) {
1139
            ok_reslevel = 1;
1140
            for (reslevelno = RSpoc; ok_reslevel && reslevelno < REpoc; reslevelno++) {
1141
                ok_reslevel = 0;
1142
                for (compno = CSpoc; compno < CEpoc; compno++) {
1143 1144 1145 1146
                    Jpeg2000CodingStyle *codsty = tile->codsty + compno;
                    Jpeg2000QuantStyle *qntsty  = tile->qntsty + compno;
                    if (reslevelno < codsty->nreslevels) {
                        Jpeg2000ResLevel *rlevel = tile->comp[compno].reslevel +
1147
                                                reslevelno;
1148 1149
                        ok_reslevel = 1;
                        for (precno = 0; precno < rlevel->num_precincts_x * rlevel->num_precincts_y; precno++)
1150
                            if ((ret = jpeg2000_decode_packet(s, tile, tp_index,
1151 1152 1153 1154 1155
                                                              codsty, rlevel,
                                                              precno, layno,
                                                              qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
                                                              qntsty->nguardbits)) < 0)
                                return ret;
1156 1157 1158 1159 1160 1161 1162
                    }
                }
            }
        }
        break;

    case JPEG2000_PGOD_CPRL:
1163
        av_log(s->avctx, AV_LOG_DEBUG, "Progression order CPRL\n");
1164
        for (compno = CSpoc; compno < CEpoc; compno++) {
1165
            Jpeg2000Component *comp     = tile->comp + compno;
1166 1167
            Jpeg2000CodingStyle *codsty = tile->codsty + compno;
            Jpeg2000QuantStyle *qntsty  = tile->qntsty + compno;
1168 1169
            step_x = 32;
            step_y = 32;
1170

1171
            if (RSpoc >= FFMIN(codsty->nreslevels, REpoc))
1172 1173
                continue;

1174
            for (reslevelno = RSpoc; reslevelno < FFMIN(codsty->nreslevels, REpoc); reslevelno++) {
1175
                uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; //  ==> N_L - r
1176
                Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1177 1178 1179
                step_x = FFMIN(step_x, rlevel->log2_prec_width  + reducedresno);
                step_y = FFMIN(step_y, rlevel->log2_prec_height + reducedresno);
            }
1180 1181 1182 1183
            if (step_x >= 31 || step_y >= 31){
                avpriv_request_sample(s->avctx, "CPRL with large step");
                return AVERROR_PATCHWELCOME;
            }
1184 1185
            step_x = 1<<step_x;
            step_y = 1<<step_y;
1186

1187 1188
            for (y = tile->coord[1][0]; y < tile->coord[1][1]; y = (y/step_y + 1)*step_y) {
                for (x = tile->coord[0][0]; x < tile->coord[0][1]; x = (x/step_x + 1)*step_x) {
1189
                    for (reslevelno = RSpoc; reslevelno < FFMIN(codsty->nreslevels, REpoc); reslevelno++) {
1190
                        unsigned prcx, prcy;
1191
                        uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; //  ==> N_L - r
1192
                        Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1193 1194
                        int xc = x / s->cdx[compno];
                        int yc = y / s->cdy[compno];
1195

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

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

                        // check if a precinct exists
1203 1204
                        prcx   = ff_jpeg2000_ceildivpow2(xc, reducedresno) >> rlevel->log2_prec_width;
                        prcy   = ff_jpeg2000_ceildivpow2(yc, reducedresno) >> rlevel->log2_prec_height;
1205 1206 1207
                        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;

1208
                        precno = prcx + rlevel->num_precincts_x * prcy;
1209

1210 1211 1212 1213 1214
                        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;
                        }
1215

1216
                        for (layno = 0; layno < LYEpoc; layno++) {
1217
                            if ((ret = jpeg2000_decode_packet(s, tile, tp_index, codsty, rlevel,
1218 1219 1220 1221
                                                              precno, layno,
                                                              qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
                                                              qntsty->nguardbits)) < 0)
                                return ret;
1222 1223 1224 1225 1226 1227 1228
                        }
                    }
                }
            }
        }
        break;

1229
    case JPEG2000_PGOD_RPCL:
1230 1231
        av_log(s->avctx, AV_LOG_WARNING, "Progression order RPCL\n");
        ok_reslevel = 1;
1232
        for (reslevelno = RSpoc; ok_reslevel && reslevelno < REpoc; reslevelno++) {
1233
            ok_reslevel = 0;
1234 1235
            step_x = 30;
            step_y = 30;
1236
            for (compno = CSpoc; compno < CEpoc; compno++) {
1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249
                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;

1250 1251
            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) {
1252
                    for (compno = CSpoc; compno < CEpoc; compno++) {
1253 1254 1255 1256 1257 1258 1259 1260 1261 1262
                        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];

1263 1264 1265
                        if (reslevelno >= codsty->nreslevels)
                            continue;

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

1269
                        if (xc % (1LL << (rlevel->log2_prec_width + reducedresno)) && x != tile->coord[0][0]) //FIXME this is a subset of the check
1270 1271 1272 1273 1274 1275 1276 1277 1278 1279
                            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;

1280
                        ok_reslevel = 1;
1281 1282 1283 1284 1285 1286
                        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;
                        }

1287
                            for (layno = 0; layno < LYEpoc; layno++) {
1288
                                if ((ret = jpeg2000_decode_packet(s, tile, tp_index,
1289 1290 1291 1292 1293 1294 1295 1296 1297 1298
                                                                codsty, rlevel,
                                                                precno, layno,
                                                                qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
                                                                qntsty->nguardbits)) < 0)
                                    return ret;
                            }
                    }
                }
            }
        }
1299 1300 1301
        break;

    case JPEG2000_PGOD_PCRL:
1302
        av_log(s->avctx, AV_LOG_WARNING, "Progression order PCRL\n");
1303 1304
        step_x = 32;
        step_y = 32;
1305
        for (compno = CSpoc; compno < CEpoc; compno++) {
1306 1307 1308
            Jpeg2000Component *comp     = tile->comp + compno;
            Jpeg2000CodingStyle *codsty = tile->codsty + compno;

1309
            for (reslevelno = RSpoc; reslevelno < FFMIN(codsty->nreslevels, REpoc); reslevelno++) {
1310 1311 1312 1313 1314 1315
                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);
            }
        }
1316 1317 1318 1319
        if (step_x >= 31 || step_y >= 31){
            avpriv_request_sample(s->avctx, "PCRL with large step");
            return AVERROR_PATCHWELCOME;
        }
1320 1321 1322
        step_x = 1<<step_x;
        step_y = 1<<step_y;

1323 1324
        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) {
1325
                for (compno = CSpoc; compno < CEpoc; compno++) {
1326 1327 1328 1329 1330 1331
                    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];

1332
                    for (reslevelno = RSpoc; reslevelno < FFMIN(codsty->nreslevels, REpoc); reslevelno++) {
1333 1334 1335 1336
                        unsigned prcx, prcy;
                        uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; //  ==> N_L - r
                        Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;

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

1340
                        if (xc % (1LL << (rlevel->log2_prec_width + reducedresno)) && x != tile->coord[0][0]) //FIXME this is a subset of the check
1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356
                            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;
                        }

1357
                        for (layno = 0; layno < LYEpoc; layno++) {
1358
                            if ((ret = jpeg2000_decode_packet(s, tile, tp_index, codsty, rlevel,
1359 1360 1361 1362 1363 1364 1365 1366 1367
                                                              precno, layno,
                                                              qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
                                                              qntsty->nguardbits)) < 0)
                                return ret;
                        }
                    }
                }
            }
        }
1368 1369
        break;

1370 1371 1372 1373
    default:
        break;
    }

1374 1375 1376 1377 1378
    return ret;
}

static int jpeg2000_decode_packets(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
{
1379 1380
    int ret = AVERROR_BUG;
    int i;
1381
    int tp_index = 0;
1382 1383 1384 1385 1386 1387 1388

    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,
1389 1390 1391
                FFMIN(e->LYEpoc, tile->codsty[0].nlayers),
                e->REpoc,
                FFMIN(e->CEpoc, s->ncomponents),
1392
                e->Ppoc, &tp_index
1393 1394 1395 1396 1397 1398 1399 1400 1401 1402
                );
            if (ret < 0)
                return ret;
        }
    } else {
        ret = jpeg2000_decode_packets_po_iteration(s, tile,
            0, 0,
            tile->codsty[0].nlayers,
            33,
            s->ncomponents,
1403 1404
            tile->codsty[0].prog_order,
            &tp_index
1405 1406
        );
    }
1407
    /* EOC marker reached */
1408
    bytestream2_skip(&s->g, 2);
1409

1410
    return ret;
1411 1412 1413 1414
}

/* TIER-1 routines */
static void decode_sigpass(Jpeg2000T1Context *t1, int width, int height,
1415
                           int bpno, int bandno,
1416
                           int vert_causal_ctx_csty_symbol)
1417 1418 1419 1420 1421
{
    int mask = 3 << (bpno - 1), y0, x, y;

    for (y0 = 0; y0 < height; y0 += 4)
        for (x = 0; x < width; x++)
1422
            for (y = y0; y < height && y < y0 + 4; y++) {
1423 1424 1425
                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);
1426 1427 1428 1429
                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);
1430
                        if (t1->mqc.raw)
1431
                             t1->data[(y) * t1->stride + x] = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ctxno) ? -mask : mask;
1432
                        else
1433
                             t1->data[(y) * t1->stride + x] = (ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ctxno) ^ xorbit) ?
1434
                                               -mask : mask;
1435 1436

                        ff_jpeg2000_set_significance(t1, x, y,
1437
                                                     t1->data[(y) * t1->stride + x] < 0);
1438
                    }
1439
                    t1->flags[(y + 1) * t1->stride + x + 1] |= JPEG2000_T1_VIS;
1440
                }
1441
            }
1442 1443 1444
}

static void decode_refpass(Jpeg2000T1Context *t1, int width, int height,
1445
                           int bpno, int vert_causal_ctx_csty_symbol)
1446 1447 1448 1449 1450 1451 1452 1453 1454 1455
{
    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++)
1456
                if ((t1->flags[(y + 1) * t1->stride + x + 1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS)) == JPEG2000_T1_SIG) {
1457 1458
                    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;
1459
                    int ctxno = ff_jpeg2000_getrefctxno(t1->flags[(y + 1) * t1->stride + x + 1] & flags_mask);
1460 1461 1462
                    int r     = ff_mqc_decode(&t1->mqc,
                                              t1->mqc.cx_states + ctxno)
                                ? phalf : nhalf;
1463 1464
                    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;
1465 1466 1467 1468 1469
                }
}

static void decode_clnpass(Jpeg2000DecoderContext *s, Jpeg2000T1Context *t1,
                           int width, int height, int bpno, int bandno,
1470
                           int seg_symbols, int vert_causal_ctx_csty_symbol)
1471 1472 1473
{
    int mask = 3 << (bpno - 1), y0, x, y, runlen, dec;

1474
    for (y0 = 0; y0 < height; y0 += 4) {
1475
        for (x = 0; x < width; x++) {
1476 1477 1478
            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);
1479
            if (y0 + 3 < height &&
1480 1481 1482 1483
                !((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))) {
1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497
                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++) {
1498 1499 1500
                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);
1501
                if (!dec) {
1502 1503
                    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,
1504 1505
                                                                                             bandno));
                    }
1506 1507 1508
                }
                if (dec) {
                    int xorbit;
1509
                    int ctxno = ff_jpeg2000_getsgnctxno(t1->flags[(y + 1) * t1->stride + x + 1] & flags_mask,
1510
                                                        &xorbit);
1511
                    t1->data[(y) * t1->stride + x] = (ff_mqc_decode(&t1->mqc,
1512 1513 1514
                                                    t1->mqc.cx_states + ctxno) ^
                                      xorbit)
                                     ? -mask : mask;
1515
                    ff_jpeg2000_set_significance(t1, x, y, t1->data[(y) * t1->stride + x] < 0);
1516 1517
                }
                dec = 0;
1518
                t1->flags[(y + 1) * t1->stride + x + 1] &= ~JPEG2000_T1_VIS;
1519 1520
            }
        }
1521
    }
1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537
    if (seg_symbols) {
        int val;
        val = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
        val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
        val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
        val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
        if (val != 0xa)
            av_log(s->avctx, AV_LOG_ERROR,
                   "Segmentation symbol value incorrect\n");
    }
}

static int decode_cblk(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *codsty,
                       Jpeg2000T1Context *t1, Jpeg2000Cblk *cblk,
                       int width, int height, int bandpos)
{
1538
    int passno = cblk->npasses, pass_t = 2, bpno = cblk->nonzerobits - 1;
1539
    int pass_cnt = 0;
1540
    int vert_causal_ctx_csty_symbol = codsty->cblk_style & JPEG2000_CBLK_VSC;
1541 1542
    int term_cnt = 0;
    int coder_type;
1543

1544 1545
    av_assert0(width <= 1024U && height <= 1024U);
    av_assert0(width*height <= 4096);
1546

1547
    memset(t1->data, 0, t1->stride * height * sizeof(*t1->data));
1548

1549
    /* If code-block contains no compressed data: nothing to do. */
1550
    if (!cblk->length)
1551 1552
        return 0;

1553
    memset(t1->flags, 0, t1->stride * (height + 2) * sizeof(*t1->flags));
1554 1555 1556

    cblk->data[cblk->length] = 0xff;
    cblk->data[cblk->length+1] = 0xff;
1557
    ff_mqc_initdec(&t1->mqc, cblk->data, 0, 1);
1558 1559

    while (passno--) {
1560 1561 1562 1563
        if (bpno < 0) {
            av_log(s->avctx, AV_LOG_ERROR, "bpno became negative\n");
            return AVERROR_INVALIDDATA;
        }
1564
        switch(pass_t) {
1565
        case 0:
1566
            decode_sigpass(t1, width, height, bpno + 1, bandpos,
1567
                           vert_causal_ctx_csty_symbol);
1568 1569
            break;
        case 1:
1570
            decode_refpass(t1, width, height, bpno + 1, vert_causal_ctx_csty_symbol);
1571 1572
            break;
        case 2:
1573
            av_assert2(!t1->mqc.raw);
1574
            decode_clnpass(s, t1, width, height, bpno + 1, bandpos,
1575 1576
                           codsty->cblk_style & JPEG2000_CBLK_SEGSYM,
                           vert_causal_ctx_csty_symbol);
1577 1578
            break;
        }
1579 1580 1581
        if (codsty->cblk_style & JPEG2000_CBLK_RESET) // XXX no testcase for just this
            ff_mqc_init_contexts(&t1->mqc);

1582
        if (passno && (coder_type = needs_termination(codsty->cblk_style, pass_cnt))) {
1583
            if (term_cnt >= cblk->nb_terminations) {
1584 1585 1586
                av_log(s->avctx, AV_LOG_ERROR, "Missing needed termination \n");
                return AVERROR_INVALIDDATA;
            }
1587 1588 1589 1590 1591 1592
            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);
            }

1593 1594
            ff_mqc_initdec(&t1->mqc, cblk->data + cblk->data_start[++term_cnt], coder_type == 2, 0);
        }
1595 1596 1597 1598 1599 1600

        pass_t++;
        if (pass_t == 3) {
            bpno--;
            pass_t = 0;
        }
1601
        pass_cnt ++;
1602
    }
1603

1604 1605 1606
    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);
1607 1608
    }

1609
    return 1;
1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622
}

/* 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)
{
1623 1624 1625 1626
    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];
1627
        int *src = t1->data + j*t1->stride;
1628 1629 1630
        for (i = 0; i < w; ++i)
            datap[i] = src[i] * band->f_stepsize;
    }
1631 1632 1633 1634 1635 1636 1637
}

/* Integer dequantization of a codeblock.*/
static void dequantization_int(int x, int y, Jpeg2000Cblk *cblk,
                               Jpeg2000Component *comp,
                               Jpeg2000T1Context *t1, Jpeg2000Band *band)
{
1638 1639 1640 1641
    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];
1642
        int *src = t1->data + j*t1->stride;
1643
        if (band->i_stepsize == 32768) {
1644 1645 1646 1647 1648
            for (i = 0; i < w; ++i)
                datap[i] = src[i] / 2;
        } else {
            // This should be VERY uncommon
            for (i = 0; i < w; ++i)
1649
                datap[i] = (src[i] * (int64_t)band->i_stepsize) / 65536;
1650
        }
1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661
    }
}

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];
1662
        int *src = t1->data + j*t1->stride;
1663
        for (i = 0; i < w; ++i)
1664
            datap[i] = (src[i] * (int64_t)band->i_stepsize + (1<<15)) >> 16;
1665
    }
1666 1667
}

1668
static inline void mct_decode(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
1669 1670
{
    int i, csize = 1;
1671
    void *src[3];
1672

1673
    for (i = 1; i < 3; i++) {
1674 1675 1676 1677
        if (tile->codsty[0].transform != tile->codsty[i].transform) {
            av_log(s->avctx, AV_LOG_ERROR, "Transforms mismatch, MCT not supported\n");
            return;
        }
1678 1679 1680 1681 1682
        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;
        }
    }
1683

1684 1685
    for (i = 0; i < 3; i++)
        if (tile->codsty[0].transform == FF_DWT97)
1686
            src[i] = tile->comp[i].f_data;
1687
        else
1688
            src[i] = tile->comp[i].i_data;
1689 1690 1691

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

1693
    s->dsp.mct_decode[tile->codsty[0].transform](src[0], src[1], src[2], csize);
1694 1695
}

1696
static inline void tile_codeblocks(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
1697 1698 1699 1700 1701
{
    Jpeg2000T1Context t1;

    int compno, reslevelno, bandno;

1702
    /* Loop on tile components */
1703 1704 1705
    for (compno = 0; compno < s->ncomponents; compno++) {
        Jpeg2000Component *comp     = tile->comp + compno;
        Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1706
        int coded = 0;
1707

1708 1709
        t1.stride = (1<<codsty->log2_cblk_width) + 2;

1710 1711 1712 1713 1714
        /* 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++) {
1715
                int nb_precincts, precno;
1716 1717
                Jpeg2000Band *band = rlevel->band + bandno;
                int cblkno = 0, bandpos;
1718

1719 1720
                bandpos = bandno + (reslevelno > 0);

1721 1722
                if (band->coord[0][0] == band->coord[0][1] ||
                    band->coord[1][0] == band->coord[1][1])
1723 1724
                    continue;

1725 1726 1727 1728 1729 1730
                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 */
1731 1732 1733
                    for (cblkno = 0;
                         cblkno < prec->nb_codeblocks_width * prec->nb_codeblocks_height;
                         cblkno++) {
1734 1735
                        int x, y;
                        Jpeg2000Cblk *cblk = prec->cblk + cblkno;
1736
                        int ret = decode_cblk(s, codsty, &t1, cblk,
1737 1738 1739
                                    cblk->coord[0][1] - cblk->coord[0][0],
                                    cblk->coord[1][1] - cblk->coord[1][0],
                                    bandpos);
1740 1741
                        if (ret)
                            coded = 1;
1742 1743
                        else
                            continue;
1744 1745
                        x = cblk->coord[0][0] - band->coord[0][0];
                        y = cblk->coord[1][0] - band->coord[1][0];
1746

1747
                        if (codsty->transform == FF_DWT97)
1748
                            dequantization_float(x, y, cblk, comp, &t1, band);
1749 1750
                        else if (codsty->transform == FF_DWT97_INT)
                            dequantization_int_97(x, y, cblk, comp, &t1, band);
1751 1752
                        else
                            dequantization_int(x, y, cblk, comp, &t1, band);
1753 1754 1755 1756 1757 1758
                   } /* end cblk */
                } /*end prec */
            } /* end band */
        } /* end reslevel */

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

1762
    } /*end comp */
1763 1764
}

1765 1766
#define WRITE_FRAME(D, PIXEL)                                                                     \
    static inline void write_frame_ ## D(Jpeg2000DecoderContext * s, Jpeg2000Tile * tile,         \
1767
                                         AVFrame * picture, int precision)                        \
1768
    {                                                                                             \
1769 1770 1771 1772
        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;                                      \
                                                                                                  \
1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783
        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;                \
1784 1785 1786 1787
            int plane        = 0;                                                                 \
                                                                                                  \
            if (planar)                                                                           \
                plane = s->cdef[compno] ? s->cdef[compno]-1 : (s->ncomponents-1);                 \
1788
                                                                                                  \
1789 1790 1791
            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++) {                 \
1792 1793
                PIXEL *dst;                                                                       \
                                                                                                  \
1794 1795
                x   = tile->comp[compno].coord[0][0] - s->image_offset_x / s->cdx[compno];        \
                dst = line + x * pixelsize + compno*!planar;                                      \
1796 1797
                                                                                                  \
                if (codsty->transform == FF_DWT97) {                                              \
1798
                    for (; x < w; x++) {                                                          \
1799 1800 1801
                        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);                                  \
1802
                        *dst = val << (precision - cbps);                                         \
1803
                        datap++;                                                                  \
1804
                        dst += pixelsize;                                                         \
1805 1806
                    }                                                                             \
                } else {                                                                          \
1807
                    for (; x < w; x++) {                                                          \
1808 1809 1810
                        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);                                  \
1811
                        *dst = val << (precision - cbps);                                         \
1812
                        i_datap++;                                                                \
1813
                        dst += pixelsize;                                                         \
1814 1815
                    }                                                                             \
                }                                                                                 \
1816
                line += picture->linesize[plane] / sizeof(PIXEL);                                 \
1817 1818 1819 1820 1821 1822 1823 1824 1825 1826
            }                                                                                     \
        }                                                                                         \
                                                                                                  \
    }

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

#undef WRITE_FRAME

1827 1828
static int jpeg2000_decode_tile(AVCodecContext *avctx, void *td,
                                int jobnr, int threadnr)
1829
{
1830 1831 1832
    Jpeg2000DecoderContext *s = avctx->priv_data;
    AVFrame *picture = td;
    Jpeg2000Tile *tile = s->tile + jobnr;
1833
    int x;
1834 1835

    tile_codeblocks(s, tile);
1836 1837 1838 1839 1840

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

1841 1842 1843 1844 1845 1846 1847 1848 1849
    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;
        }
1850 1851
    }

1852
    if (s->precision <= 8) {
1853
        write_frame_8(s, tile, picture, 8);
1854
    } else {
1855
        int precision = picture->format == AV_PIX_FMT_XYZ12 ||
1856 1857
                        picture->format == AV_PIX_FMT_RGB48 ||
                        picture->format == AV_PIX_FMT_RGBA64 ||
1858
                        picture->format == AV_PIX_FMT_GRAY16 ? 16 : s->precision;
1859

1860
        write_frame_16(s, tile, picture, precision);
1861
    }
1862

1863 1864 1865 1866 1867 1868 1869
    return 0;
}

static void jpeg2000_dec_cleanup(Jpeg2000DecoderContext *s)
{
    int tileno, compno;
    for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++) {
1870 1871 1872 1873
        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;
1874

1875 1876 1877
                ff_jpeg2000_cleanup(comp, codsty);
            }
            av_freep(&s->tile[tileno].comp);
1878 1879 1880
        }
    }
    av_freep(&s->tile);
1881 1882
    memset(s->codsty, 0, sizeof(s->codsty));
    memset(s->qntsty, 0, sizeof(s->qntsty));
1883
    memset(s->properties, 0, sizeof(s->properties));
1884
    memset(&s->poc  , 0, sizeof(s->poc));
1885
    s->numXtiles = s->numYtiles = 0;
1886
    s->ncomponents = 0;
1887 1888 1889 1890 1891 1892
}

static int jpeg2000_read_main_headers(Jpeg2000DecoderContext *s)
{
    Jpeg2000CodingStyle *codsty = s->codsty;
    Jpeg2000QuantStyle *qntsty  = s->qntsty;
1893
    Jpeg2000POC         *poc    = &s->poc;
1894 1895 1896 1897 1898
    uint8_t *properties         = s->properties;

    for (;;) {
        int len, ret = 0;
        uint16_t marker;
1899
        int oldpos;
1900

1901
        if (bytestream2_get_bytes_left(&s->g) < 2) {
1902 1903 1904 1905
            av_log(s->avctx, AV_LOG_ERROR, "Missing EOC\n");
            break;
        }

1906 1907
        marker = bytestream2_get_be16u(&s->g);
        oldpos = bytestream2_tell(&s->g);
1908

1909
        if (marker == JPEG2000_SOD) {
1910 1911
            Jpeg2000Tile *tile;
            Jpeg2000TilePart *tp;
1912

1913 1914 1915 1916
            if (!s->tile) {
                av_log(s->avctx, AV_LOG_ERROR, "Missing SIZ\n");
                return AVERROR_INVALIDDATA;
            }
1917 1918 1919 1920
            if (s->curtileno < 0) {
                av_log(s->avctx, AV_LOG_ERROR, "Missing SOT\n");
                return AVERROR_INVALIDDATA;
            }
1921 1922 1923

            tile = s->tile + s->curtileno;
            tp = tile->tile_part + tile->tp_idx;
1924 1925 1926 1927
            if (tp->tp_end < s->g.buffer) {
                av_log(s->avctx, AV_LOG_ERROR, "Invalid tpend\n");
                return AVERROR_INVALIDDATA;
            }
1928 1929 1930 1931 1932
            bytestream2_init(&tp->tpg, s->g.buffer, tp->tp_end - s->g.buffer);
            bytestream2_skip(&s->g, tp->tp_end - s->g.buffer);

            continue;
        }
1933 1934 1935
        if (marker == JPEG2000_EOC)
            break;

1936
        len = bytestream2_get_be16(&s->g);
1937 1938
        if (len < 2 || bytestream2_get_bytes_left(&s->g) < len - 2) {
            av_log(s->avctx, AV_LOG_ERROR, "Invalid len %d left=%d\n", len, bytestream2_get_bytes_left(&s->g));
1939
            return AVERROR_INVALIDDATA;
1940
        }
1941

1942 1943
        switch (marker) {
        case JPEG2000_SIZ:
1944 1945 1946 1947
            if (s->ncomponents) {
                av_log(s->avctx, AV_LOG_ERROR, "Duplicate SIZ\n");
                return AVERROR_INVALIDDATA;
            }
1948
            ret = get_siz(s);
1949 1950
            if (!s->tile)
                s->numXtiles = s->numYtiles = 0;
1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963
            break;
        case JPEG2000_COC:
            ret = get_coc(s, codsty, properties);
            break;
        case JPEG2000_COD:
            ret = get_cod(s, codsty, properties);
            break;
        case JPEG2000_QCC:
            ret = get_qcc(s, len, qntsty, properties);
            break;
        case JPEG2000_QCD:
            ret = get_qcd(s, len, qntsty, properties);
            break;
1964 1965 1966
        case JPEG2000_POC:
            ret = get_poc(s, len, poc);
            break;
1967
        case JPEG2000_SOT:
1968
            if (!(ret = get_sot(s, len))) {
1969
                av_assert1(s->curtileno >= 0);
1970 1971
                codsty = s->tile[s->curtileno].codsty;
                qntsty = s->tile[s->curtileno].qntsty;
1972
                poc    = &s->tile[s->curtileno].poc;
1973 1974
                properties = s->tile[s->curtileno].properties;
            }
1975
            break;
1976 1977
        case JPEG2000_PLM:
            // the PLM marker is ignored
1978 1979
        case JPEG2000_COM:
            // the comment is ignored
1980
            bytestream2_skip(&s->g, len - 2);
1981 1982 1983 1984 1985
            break;
        case JPEG2000_TLM:
            // Tile-part lengths
            ret = get_tlm(s, len);
            break;
1986 1987 1988 1989
        case JPEG2000_PLT:
            // Packet length, tile-part header
            ret = get_plt(s, len);
            break;
1990 1991
        default:
            av_log(s->avctx, AV_LOG_ERROR,
1992
                   "unsupported marker 0x%.4"PRIX16" at pos 0x%X\n",
1993 1994
                   marker, bytestream2_tell(&s->g) - 4);
            bytestream2_skip(&s->g, len - 2);
1995 1996
            break;
        }
1997
        if (bytestream2_tell(&s->g) - oldpos != len || ret) {
1998
            av_log(s->avctx, AV_LOG_ERROR,
1999 2000
                   "error during processing marker segment %.4"PRIx16"\n",
                   marker);
2001 2002 2003 2004 2005 2006 2007 2008 2009 2010
            return ret ? ret : -1;
        }
    }
    return 0;
}

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

2013 2014 2015
    for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++) {
        Jpeg2000Tile *tile = s->tile + tileno;

2016
        if ((ret = init_tile(s, tileno)) < 0)
2017 2018 2019
            return ret;

        s->g = tile->tile_part[0].tpg;
2020
        if ((ret = jpeg2000_decode_packets(s, tile)) < 0)
2021 2022
            return ret;
    }
2023 2024 2025 2026 2027 2028

    return 0;
}

static int jp2_find_codestream(Jpeg2000DecoderContext *s)
{
2029 2030
    uint32_t atom_size, atom, atom_end;
    int search_range = 10;
2031

2032
    while (search_range
2033 2034
           &&
           bytestream2_get_bytes_left(&s->g) >= 8) {
2035 2036
        atom_size = bytestream2_get_be32u(&s->g);
        atom      = bytestream2_get_be32u(&s->g);
2037 2038 2039 2040 2041 2042 2043 2044 2045 2046
        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;
        }
2047 2048 2049 2050 2051 2052 2053 2054

        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 &&
2055
                   atom_size >= 16) {
2056
            uint32_t atom2_size, atom2, atom2_end;
2057 2058 2059
            do {
                atom2_size = bytestream2_get_be32u(&s->g);
                atom2      = bytestream2_get_be32u(&s->g);
2060 2061
                atom2_end  = bytestream2_tell(&s->g) + atom2_size - 8;
                if (atom2_size < 8 || atom2_end > atom_end || atom2_end < atom2_size)
2062
                    break;
2063
                atom2_size -= 8;
2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082
                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;
2083
                    if (colour_count > AVPALETTE_COUNT ||
2084 2085 2086 2087 2088 2089
                        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");
2090
                        bytestream2_seek(&s->g, atom2_end, SEEK_SET);
2091 2092 2093 2094
                        continue;
                    }
                    s->pal8 = 1;
                    for (i = 0; i < colour_count; i++) {
2095
                        uint32_t r, g, b;
2096 2097 2098 2099 2100 2101 2102 2103
                        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];
2104
                            g |= g >> colour_depth[1];
2105 2106 2107 2108 2109
                        } 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];
2110
                            b |= b >> colour_depth[2];
2111 2112 2113 2114 2115
                        } else {
                            b = bytestream2_get_be16u(&s->g) >> colour_depth[2] - 8;
                        }
                        s->palette[i] = 0xffu << 24 | r << 16 | g << 8 | b;
                    }
2116
                } else if (atom2 == MKBETAG('c','d','e','f') && atom2_size >= 2) {
2117 2118 2119
                    int n = bytestream2_get_be16u(&s->g);
                    for (; n>0; n--) {
                        int cn   = bytestream2_get_be16(&s->g);
2120
                        int av_unused typ  = bytestream2_get_be16(&s->g);
2121
                        int asoc = bytestream2_get_be16(&s->g);
2122
                        if (cn < 4 && asoc < 4)
2123 2124
                            s->cdef[cn] = asoc;
                    }
2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139
                } 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);
2140
                    if (!vnum || !vden || !hnum || !hden) {
2141 2142 2143 2144
                        bytestream2_seek(&s->g, atom2_end, SEEK_SET);
                        av_log(s->avctx, AV_LOG_WARNING, "RES box invalid\n");
                        continue;
                    }
2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157
                    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);
2158
                }
2159 2160
                bytestream2_seek(&s->g, atom2_end, SEEK_SET);
            } while (atom_end - atom2_end >= 8);
2161 2162 2163
        } else {
            search_range--;
        }
2164
        bytestream2_seek(&s->g, atom_end, SEEK_SET);
2165 2166 2167 2168 2169
    }

    return 0;
}

2170 2171 2172 2173 2174 2175
static av_cold void jpeg2000_init_static_data(void)
{
    ff_jpeg2000_init_tier1_luts();
    ff_mqc_init_context_tables();
}

2176 2177
static av_cold int jpeg2000_decode_init(AVCodecContext *avctx)
{
2178
    static AVOnce init_static_once = AV_ONCE_INIT;
2179 2180
    Jpeg2000DecoderContext *s = avctx->priv_data;

2181
    ff_thread_once(&init_static_once, jpeg2000_init_static_data);
2182 2183 2184 2185 2186
    ff_jpeg2000dsp_init(&s->dsp);

    return 0;
}

2187 2188 2189 2190
static int jpeg2000_decode_frame(AVCodecContext *avctx, void *data,
                                 int *got_frame, AVPacket *avpkt)
{
    Jpeg2000DecoderContext *s = avctx->priv_data;
2191
    ThreadFrame frame = { .f = data };
2192
    AVFrame *picture = data;
2193
    int ret;
2194 2195

    s->avctx     = avctx;
2196
    bytestream2_init(&s->g, avpkt->data, avpkt->size);
2197
    s->curtileno = -1;
2198
    memset(s->cdef, -1, sizeof(s->cdef));
2199

2200
    if (bytestream2_get_bytes_left(&s->g) < 2) {
2201
        ret = AVERROR_INVALIDDATA;
2202 2203
        goto end;
    }
2204 2205

    // check if the image is in jp2 format
2206 2207 2208 2209
    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)) {
2210 2211
        if (!jp2_find_codestream(s)) {
            av_log(avctx, AV_LOG_ERROR,
2212
                   "Could not find Jpeg2000 codestream atom.\n");
2213
            ret = AVERROR_INVALIDDATA;
2214
            goto end;
2215
        }
2216 2217
    } else {
        bytestream2_seek(&s->g, 0, SEEK_SET);
2218 2219
    }

2220 2221 2222
    while (bytestream2_get_bytes_left(&s->g) >= 3 && bytestream2_peek_be16(&s->g) != JPEG2000_SOC)
        bytestream2_skip(&s->g, 1);

2223
    if (bytestream2_get_be16u(&s->g) != JPEG2000_SOC) {
2224
        av_log(avctx, AV_LOG_ERROR, "SOC marker not present\n");
2225
        ret = AVERROR_INVALIDDATA;
2226
        goto end;
2227 2228
    }
    if (ret = jpeg2000_read_main_headers(s))
2229
        goto end;
2230 2231

    /* get picture buffer */
2232
    if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
2233
        goto end;
2234 2235 2236 2237
    picture->pict_type = AV_PICTURE_TYPE_I;
    picture->key_frame = 1;

    if (ret = jpeg2000_read_bitstream_packets(s))
2238
        goto end;
2239

2240
    avctx->execute2(avctx, jpeg2000_decode_tile, picture, NULL, s->numXtiles * s->numYtiles);
2241

2242 2243 2244 2245
    jpeg2000_dec_cleanup(s);

    *got_frame = 1;

2246 2247
    if (s->avctx->pix_fmt == AV_PIX_FMT_PAL8)
        memcpy(picture->data[1], s->palette, 256 * sizeof(uint32_t));
2248 2249 2250
    if (s->sar.num && s->sar.den)
        avctx->sample_aspect_ratio = s->sar;
    s->sar.num = s->sar.den = 0;
2251

2252
    return bytestream2_tell(&s->g);
2253

2254
end:
2255 2256
    jpeg2000_dec_cleanup(s);
    return ret;
2257 2258 2259 2260 2261 2262 2263
}

#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",
2264
        OFFSET(reduction_factor), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, JPEG2000_MAX_RESLEVELS - 1, VD },
2265 2266 2267
    { NULL },
};

2268
static const AVClass jpeg2000_class = {
2269 2270 2271 2272 2273 2274 2275
    .class_name = "jpeg2000",
    .item_name  = av_default_item_name,
    .option     = options,
    .version    = LIBAVUTIL_VERSION_INT,
};

AVCodec ff_jpeg2000_decoder = {
2276 2277 2278 2279
    .name             = "jpeg2000",
    .long_name        = NULL_IF_CONFIG_SMALL("JPEG 2000"),
    .type             = AVMEDIA_TYPE_VIDEO,
    .id               = AV_CODEC_ID_JPEG2000,
2280
    .capabilities     = AV_CODEC_CAP_SLICE_THREADS | AV_CODEC_CAP_FRAME_THREADS | AV_CODEC_CAP_DR1,
2281
    .priv_data_size   = sizeof(Jpeg2000DecoderContext),
2282
    .init             = jpeg2000_decode_init,
2283
    .decode           = jpeg2000_decode_frame,
2284
    .priv_class       = &jpeg2000_class,
2285
    .max_lowres       = 5,
2286
    .profiles         = NULL_IF_CONFIG_SMALL(ff_jpeg2000_profiles)
2287
};