git.sesse.net Git - ffmpeg/blob - libavcodec/jpeg2000dec.c

   1 /*
   2  * JPEG 2000 image decoder
   3  * Copyright (c) 2007 Kamil Nowosad
   4  * Copyright (c) 2013 Nicolas Bertrand <nicoinattendu@gmail.com>
   5  *
   6  * This file is part of FFmpeg.
   7  *
   8  * FFmpeg is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * FFmpeg is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with FFmpeg; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  21  */
  22
  23 /**
  24  * @file
  25  * JPEG 2000 image decoder
  26  */
  27
  28 #include <inttypes.h>
  29 #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 #include "avcodec.h"
  39 #include "bytestream.h"
  40 #include "internal.h"
  41 #include "thread.h"
  42 #include "jpeg2000.h"
  43 #include "jpeg2000dsp.h"
  44 #include "profiles.h"
  45
  46 #define JP2_SIG_TYPE    0x6A502020
  47 #define JP2_SIG_VALUE   0x0D0A870A
  48 #define JP2_CODESTREAM  0x6A703263
  49 #define JP2_HEADER      0x6A703268
  50
  51 #define HAD_COC 0x01
  52 #define HAD_QCC 0x02
  53
  54 #define MAX_POCS 32
  55
  56 typedef struct Jpeg2000POCEntry {
  57     uint16_t LYEpoc;
  58     uint16_t CSpoc;
  59     uint16_t CEpoc;
  60     uint8_t RSpoc;
  61     uint8_t REpoc;
  62     uint8_t Ppoc;
  63 } Jpeg2000POCEntry;
  64
  65 typedef struct Jpeg2000POC {
  66     Jpeg2000POCEntry poc[MAX_POCS];
  67     int nb_poc;
  68     int is_default;
  69 } Jpeg2000POC;
  70
  71 typedef struct Jpeg2000TilePart {
  72     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 } Jpeg2000TilePart;
  76
  77 /* RMK: For JPEG2000 DCINEMA 3 tile-parts in a tile
  78  * one per component, so tile_part elements have a size of 3 */
  79 typedef struct Jpeg2000Tile {
  80     Jpeg2000Component   *comp;
  81     uint8_t             properties[4];
  82     Jpeg2000CodingStyle codsty[4];
  83     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 } Jpeg2000Tile;
  89
  90 typedef struct Jpeg2000DecoderContext {
  91     AVClass         *class;
  92     AVCodecContext  *avctx;
  93     GetByteContext  g;
  94
  95     int             width, height;
  96     int             image_offset_x, image_offset_y;
  97     int             tile_offset_x, tile_offset_y;
  98     uint8_t         cbps[4];    // bits per sample in particular components
  99     uint8_t         sgnd[4];    // if a component is signed
 100     uint8_t         properties[4];
 101     int             cdx[4], cdy[4];
 102     int             precision;
 103     int             ncomponents;
 104     int             colour_space;
 105     uint32_t        palette[256];
 106     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     Jpeg2000CodingStyle codsty[4];
 114     Jpeg2000QuantStyle  qntsty[4];
 115     Jpeg2000POC         poc;
 116
 117     int             bit_index;
 118
 119     int             curtileno;
 120
 121     Jpeg2000Tile    *tile;
 122     Jpeg2000DSPContext dsp;
 123
 124     /*options parameters*/
 125     int             reduction_factor;
 126 } Jpeg2000DecoderContext;
 127
 128 /* get_bits functions for JPEG2000 packet bitstream
 129  * It is a get_bit function with a bit-stuffing routine. If the value of the
 130  * byte is 0xFF, the next byte includes an extra zero bit stuffed into the MSB.
 131  * cf. ISO-15444-1:2002 / B.10.1 Bit-stuffing routine */
 132 static int get_bits(Jpeg2000DecoderContext *s, int n)
 133 {
 134     int res = 0;
 135
 136     while (--n >= 0) {
 137         res <<= 1;
 138         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     return res;
 145 }
 146
 147 static void jpeg2000_flush(Jpeg2000DecoderContext *s)
 148 {
 149     if (bytestream2_get_byte(&s->g) == 0xff)
 150         bytestream2_skip(&s->g, 1);
 151     s->bit_index = 8;
 152 }
 153
 154 /* decode the value stored in node */
 155 static int tag_tree_decode(Jpeg2000DecoderContext *s, Jpeg2000TgtNode *node,
 156                            int threshold)
 157 {
 158     Jpeg2000TgtNode *stack[30];
 159     int sp = -1, curval = 0;
 160
 161     if (!node) {
 162         av_log(s->avctx, AV_LOG_ERROR, "missing node\n");
 163         return AVERROR_INVALIDDATA;
 164     }
 165
 166     while (node && !node->vis) {
 167         stack[++sp] = node;
 168         node        = node->parent;
 169     }
 170
 171     if (node)
 172         curval = node->val;
 173     else
 174         curval = stack[sp]->val;
 175
 176     while (curval < threshold && sp >= 0) {
 177         if (curval < stack[sp]->val)
 178             curval = stack[sp]->val;
 179         while (curval < threshold) {
 180             int ret;
 181             if ((ret = get_bits(s, 1)) > 0) {
 182                 stack[sp]->vis++;
 183                 break;
 184             } else if (!ret)
 185                 curval++;
 186             else
 187                 return ret;
 188         }
 189         stack[sp]->val = curval;
 190         sp--;
 191     }
 192     return curval;
 193 }
 194
 195 static int pix_fmt_match(enum AVPixelFormat pix_fmt, int components,
 196                          int bpc, uint32_t log2_chroma_wh, int pal8)
 197 {
 198     int match = 1;
 199     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
 200
 201     av_assert2(desc);
 202
 203     if (desc->nb_components != components) {
 204         return 0;
 205     }
 206
 207     switch (components) {
 208     case 4:
 209         match = match && desc->comp[3].depth >= bpc &&
 210                          (log2_chroma_wh >> 14 & 3) == 0 &&
 211                          (log2_chroma_wh >> 12 & 3) == 0;
 212     case 3:
 213         match = match && desc->comp[2].depth >= bpc &&
 214                          (log2_chroma_wh >> 10 & 3) == desc->log2_chroma_w &&
 215                          (log2_chroma_wh >>  8 & 3) == desc->log2_chroma_h;
 216     case 2:
 217         match = match && desc->comp[1].depth >= bpc &&
 218                          (log2_chroma_wh >>  6 & 3) == desc->log2_chroma_w &&
 219                          (log2_chroma_wh >>  4 & 3) == desc->log2_chroma_h;
 220
 221     case 1:
 222         match = match && desc->comp[0].depth >= bpc &&
 223                          (log2_chroma_wh >>  2 & 3) == 0 &&
 224                          (log2_chroma_wh       & 3) == 0 &&
 225                          (desc->flags & AV_PIX_FMT_FLAG_PAL) == pal8 * AV_PIX_FMT_FLAG_PAL;
 226     }
 227     return match;
 228 }
 229
 230 // pix_fmts with lower bpp have to be listed before
 231 // similar pix_fmts with higher bpp.
 232 #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 #define YUV_PIXEL_FORMATS   AV_PIX_FMT_YUV410P,AV_PIX_FMT_YUV411P,AV_PIX_FMT_YUVA420P, \
 235                             AV_PIX_FMT_YUV420P,AV_PIX_FMT_YUV422P,AV_PIX_FMT_YUVA422P, \
 236                             AV_PIX_FMT_YUV440P,AV_PIX_FMT_YUV444P,AV_PIX_FMT_YUVA444P, \
 237                             AV_PIX_FMT_YUV420P9,AV_PIX_FMT_YUV422P9,AV_PIX_FMT_YUV444P9, \
 238                             AV_PIX_FMT_YUVA420P9,AV_PIX_FMT_YUVA422P9,AV_PIX_FMT_YUVA444P9, \
 239                             AV_PIX_FMT_YUV420P10,AV_PIX_FMT_YUV422P10,AV_PIX_FMT_YUV444P10, \
 240                             AV_PIX_FMT_YUVA420P10,AV_PIX_FMT_YUVA422P10,AV_PIX_FMT_YUVA444P10, \
 241                             AV_PIX_FMT_YUV420P12,AV_PIX_FMT_YUV422P12,AV_PIX_FMT_YUV444P12, \
 242                             AV_PIX_FMT_YUV420P14,AV_PIX_FMT_YUV422P14,AV_PIX_FMT_YUV444P14, \
 243                             AV_PIX_FMT_YUV420P16,AV_PIX_FMT_YUV422P16,AV_PIX_FMT_YUV444P16, \
 244                             AV_PIX_FMT_YUVA420P16,AV_PIX_FMT_YUVA422P16,AV_PIX_FMT_YUVA444P16
 245 #define XYZ_PIXEL_FORMATS   AV_PIX_FMT_XYZ12
 246
 247 static const enum AVPixelFormat rgb_pix_fmts[]  = {RGB_PIXEL_FORMATS};
 248 static const enum AVPixelFormat gray_pix_fmts[] = {GRAY_PIXEL_FORMATS};
 249 static const enum AVPixelFormat yuv_pix_fmts[]  = {YUV_PIXEL_FORMATS};
 250 static const enum AVPixelFormat xyz_pix_fmts[]  = {XYZ_PIXEL_FORMATS,
 251                                                    YUV_PIXEL_FORMATS};
 252 static const enum AVPixelFormat all_pix_fmts[]  = {RGB_PIXEL_FORMATS,
 253                                                    GRAY_PIXEL_FORMATS,
 254                                                    YUV_PIXEL_FORMATS,
 255                                                    XYZ_PIXEL_FORMATS};
 256
 257 /* marker segments */
 258 /* get sizes and offsets of image, tiles; number of components */
 259 static int get_siz(Jpeg2000DecoderContext *s)
 260 {
 261     int i;
 262     int ncomponents;
 263     uint32_t log2_chroma_wh = 0;
 264     const enum AVPixelFormat *possible_fmts = NULL;
 265     int possible_fmts_nb = 0;
 266     int ret;
 267
 268     if (bytestream2_get_bytes_left(&s->g) < 36) {
 269         av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for SIZ\n");
 270         return AVERROR_INVALIDDATA;
 271     }
 272
 273     s->avctx->profile = bytestream2_get_be16u(&s->g); // Rsiz
 274     s->width          = bytestream2_get_be32u(&s->g); // Width
 275     s->height         = bytestream2_get_be32u(&s->g); // Height
 276     s->image_offset_x = bytestream2_get_be32u(&s->g); // X0Siz
 277     s->image_offset_y = bytestream2_get_be32u(&s->g); // Y0Siz
 278     s->tile_width     = bytestream2_get_be32u(&s->g); // XTSiz
 279     s->tile_height    = bytestream2_get_be32u(&s->g); // YTSiz
 280     s->tile_offset_x  = bytestream2_get_be32u(&s->g); // XT0Siz
 281     s->tile_offset_y  = bytestream2_get_be32u(&s->g); // YT0Siz
 282     ncomponents       = bytestream2_get_be16u(&s->g); // CSiz
 283
 284     if (s->image_offset_x || s->image_offset_y) {
 285         avpriv_request_sample(s->avctx, "Support for image offsets");
 286         return AVERROR_PATCHWELCOME;
 287     }
 288     if (av_image_check_size2(s->width, s->height, s->avctx->max_pixels, AV_PIX_FMT_NONE, 0, s->avctx)) {
 289         avpriv_request_sample(s->avctx, "Large Dimensions");
 290         return AVERROR_PATCHWELCOME;
 291     }
 292
 293     if (ncomponents <= 0) {
 294         av_log(s->avctx, AV_LOG_ERROR, "Invalid number of components: %d\n",
 295                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         return AVERROR_PATCHWELCOME;
 303     }
 304
 305     if (s->tile_offset_x < 0 || s->tile_offset_y < 0 ||
 306         s->image_offset_x < s->tile_offset_x ||
 307         s->image_offset_y < s->tile_offset_y ||
 308         s->tile_width  + (int64_t)s->tile_offset_x <= s->image_offset_x ||
 309         s->tile_height + (int64_t)s->tile_offset_y <= s->image_offset_y
 310     ) {
 311         av_log(s->avctx, AV_LOG_ERROR, "Tile offsets are invalid\n");
 312         return AVERROR_INVALIDDATA;
 313     }
 314
 315     s->ncomponents = ncomponents;
 316
 317     if (s->tile_width <= 0 || s->tile_height <= 0) {
 318         av_log(s->avctx, AV_LOG_ERROR, "Invalid tile dimension %dx%d.\n",
 319                s->tile_width, s->tile_height);
 320         return AVERROR_INVALIDDATA;
 321     }
 322
 323     if (bytestream2_get_bytes_left(&s->g) < 3 * s->ncomponents) {
 324         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         s->cbps[i]   = (x & 0x7f) + 1;
 331         s->precision = FFMAX(s->cbps[i], s->precision);
 332         s->sgnd[i]   = !!(x & 0x80);
 333         s->cdx[i]    = bytestream2_get_byteu(&s->g);
 334         s->cdy[i]    = bytestream2_get_byteu(&s->g);
 335         if (   !s->cdx[i] || s->cdx[i] == 3 || s->cdx[i] > 4
 336             || !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             return AVERROR_INVALIDDATA;
 339         }
 340         log2_chroma_wh |= s->cdy[i] >> 1 << i * 4 | s->cdx[i] >> 1 << i * 4 + 2;
 341     }
 342
 343     s->numXtiles = ff_jpeg2000_ceildiv(s->width  - s->tile_offset_x, s->tile_width);
 344     s->numYtiles = ff_jpeg2000_ceildiv(s->height - s->tile_offset_y, s->tile_height);
 345
 346     // There must be at least a SOT and SOD per tile, their minimum size is 14
 347     if (s->numXtiles * (uint64_t)s->numYtiles > INT_MAX/sizeof(*s->tile) ||
 348         s->numXtiles * s->numYtiles * 14LL > bytestream2_size(&s->g)
 349     ) {
 350         s->numXtiles = s->numYtiles = 0;
 351         return AVERROR(EINVAL);
 352     }
 353
 354     s->tile = av_mallocz_array(s->numXtiles * s->numYtiles, sizeof(*s->tile));
 355     if (!s->tile) {
 356         s->numXtiles = s->numYtiles = 0;
 357         return AVERROR(ENOMEM);
 358     }
 359
 360     for (i = 0; i < s->numXtiles * s->numYtiles; i++) {
 361         Jpeg2000Tile *tile = s->tile + i;
 362
 363         tile->comp = av_mallocz(s->ncomponents * sizeof(*tile->comp));
 364         if (!tile->comp)
 365             return AVERROR(ENOMEM);
 366     }
 367
 368     /* compute image size with reduction factor */
 369     ret = ff_set_dimensions(s->avctx,
 370             ff_jpeg2000_ceildivpow2(s->width  - s->image_offset_x,
 371                                                s->reduction_factor),
 372             ff_jpeg2000_ceildivpow2(s->height - s->image_offset_y,
 373                                                s->reduction_factor));
 374     if (ret < 0)
 375         return ret;
 376
 377     if (s->avctx->profile == FF_PROFILE_JPEG2000_DCINEMA_2K ||
 378         s->avctx->profile == FF_PROFILE_JPEG2000_DCINEMA_4K) {
 379         possible_fmts = xyz_pix_fmts;
 380         possible_fmts_nb = FF_ARRAY_ELEMS(xyz_pix_fmts);
 381     } else {
 382         switch (s->colour_space) {
 383         case 16:
 384             possible_fmts = rgb_pix_fmts;
 385             possible_fmts_nb = FF_ARRAY_ELEMS(rgb_pix_fmts);
 386             break;
 387         case 17:
 388             possible_fmts = gray_pix_fmts;
 389             possible_fmts_nb = FF_ARRAY_ELEMS(gray_pix_fmts);
 390             break;
 391         case 18:
 392             possible_fmts = yuv_pix_fmts;
 393             possible_fmts_nb = FF_ARRAY_ELEMS(yuv_pix_fmts);
 394             break;
 395         default:
 396             possible_fmts = all_pix_fmts;
 397             possible_fmts_nb = FF_ARRAY_ELEMS(all_pix_fmts);
 398             break;
 399         }
 400     }
 401     for (i = 0; i < possible_fmts_nb; ++i) {
 402         if (pix_fmt_match(possible_fmts[i], ncomponents, s->precision, log2_chroma_wh, s->pal8)) {
 403             s->avctx->pix_fmt = possible_fmts[i];
 404             break;
 405         }
 406     }
 407
 408     if (i == possible_fmts_nb) {
 409         if (ncomponents == 4 &&
 410             s->cdy[0] == 1 && s->cdx[0] == 1 &&
 411             s->cdy[1] == 1 && s->cdx[1] == 1 &&
 412             s->cdy[2] == s->cdy[3] && s->cdx[2] == s->cdx[3]) {
 413             if (s->precision == 8 && s->cdy[2] == 2 && s->cdx[2] == 2 && !s->pal8) {
 414                 s->avctx->pix_fmt = AV_PIX_FMT_YUVA420P;
 415                 s->cdef[0] = 0;
 416                 s->cdef[1] = 1;
 417                 s->cdef[2] = 2;
 418                 s->cdef[3] = 3;
 419                 i = 0;
 420             }
 421         }
 422     }
 423
 424
 425     if (i == possible_fmts_nb) {
 426         av_log(s->avctx, AV_LOG_ERROR,
 427                "Unknown pix_fmt, profile: %d, colour_space: %d, "
 428                "components: %d, precision: %d\n"
 429                "cdx[0]: %d, cdy[0]: %d\n"
 430                "cdx[1]: %d, cdy[1]: %d\n"
 431                "cdx[2]: %d, cdy[2]: %d\n"
 432                "cdx[3]: %d, cdy[3]: %d\n",
 433                s->avctx->profile, s->colour_space, ncomponents, s->precision,
 434                s->cdx[0],
 435                s->cdy[0],
 436                ncomponents > 1 ? s->cdx[1] : 0,
 437                ncomponents > 1 ? s->cdy[1] : 0,
 438                ncomponents > 2 ? s->cdx[2] : 0,
 439                ncomponents > 2 ? s->cdy[2] : 0,
 440                ncomponents > 3 ? s->cdx[3] : 0,
 441                ncomponents > 3 ? s->cdy[3] : 0);
 442         return AVERROR_PATCHWELCOME;
 443     }
 444     s->avctx->bits_per_raw_sample = s->precision;
 445     return 0;
 446 }
 447
 448 /* get common part for COD and COC segments */
 449 static int get_cox(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c)
 450 {
 451     uint8_t byte;
 452
 453     if (bytestream2_get_bytes_left(&s->g) < 5) {
 454         av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for COX\n");
 455         return AVERROR_INVALIDDATA;
 456     }
 457
 458     /*  nreslevels = number of resolution levels
 459                    = number of decomposition level +1 */
 460     c->nreslevels = bytestream2_get_byteu(&s->g) + 1;
 461     if (c->nreslevels >= JPEG2000_MAX_RESLEVELS) {
 462         av_log(s->avctx, AV_LOG_ERROR, "nreslevels %d is invalid\n", c->nreslevels);
 463         return AVERROR_INVALIDDATA;
 464     }
 465
 466     if (c->nreslevels <= s->reduction_factor) {
 467         /* we are forced to update reduction_factor as its requested value is
 468            not compatible with this bitstream, and as we might have used it
 469            already in setup earlier we have to fail this frame until
 470            reinitialization is implemented */
 471         av_log(s->avctx, AV_LOG_ERROR, "reduction_factor too large for this bitstream, max is %d\n", c->nreslevels - 1);
 472         s->reduction_factor = c->nreslevels - 1;
 473         return AVERROR(EINVAL);
 474     }
 475
 476     /* compute number of resolution levels to decode */
 477     c->nreslevels2decode = c->nreslevels - s->reduction_factor;
 478
 479     c->log2_cblk_width  = (bytestream2_get_byteu(&s->g) & 15) + 2; // cblk width
 480     c->log2_cblk_height = (bytestream2_get_byteu(&s->g) & 15) + 2; // cblk height
 481
 482     if (c->log2_cblk_width > 10 || c->log2_cblk_height > 10 ||
 483         c->log2_cblk_width + c->log2_cblk_height > 12) {
 484         av_log(s->avctx, AV_LOG_ERROR, "cblk size invalid\n");
 485         return AVERROR_INVALIDDATA;
 486     }
 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         if (c->cblk_style & JPEG2000_CBLK_BYPASS)
 492             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     else if (c->transform == FF_DWT53) {
 499         s->avctx->properties |= FF_CODEC_PROPERTY_LOSSLESS;
 500     }
 501
 502     if (c->csty & JPEG2000_CSTY_PREC) {
 503         int i;
 504         for (i = 0; i < c->nreslevels; i++) {
 505             byte = bytestream2_get_byte(&s->g);
 506             c->log2_prec_widths[i]  =  byte       & 0x0F;    // precinct PPx
 507             c->log2_prec_heights[i] = (byte >> 4) & 0x0F;    // precinct PPy
 508             if (i)
 509                 if (c->log2_prec_widths[i] == 0 || c->log2_prec_heights[i] == 0) {
 510                     av_log(s->avctx, AV_LOG_ERROR, "PPx %d PPy %d invalid\n",
 511                            c->log2_prec_widths[i], c->log2_prec_heights[i]);
 512                     c->log2_prec_widths[i] = c->log2_prec_heights[i] = 1;
 513                     return AVERROR_INVALIDDATA;
 514                 }
 515         }
 516     } else {
 517         memset(c->log2_prec_widths , 15, sizeof(c->log2_prec_widths ));
 518         memset(c->log2_prec_heights, 15, sizeof(c->log2_prec_heights));
 519     }
 520     return 0;
 521 }
 522
 523 /* get coding parameters for a particular tile or whole image*/
 524 static int get_cod(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c,
 525                    uint8_t *properties)
 526 {
 527     Jpeg2000CodingStyle tmp;
 528     int compno, ret;
 529
 530     if (bytestream2_get_bytes_left(&s->g) < 5) {
 531         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     tmp.nlayers    = bytestream2_get_be16u(&s->g);
 541     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         return AVERROR_INVALIDDATA;
 548     }
 549
 550     if ((ret = get_cox(s, &tmp)) < 0)
 551         return ret;
 552
 553     for (compno = 0; compno < s->ncomponents; compno++)
 554         if (!(properties[compno] & HAD_COC))
 555             memcpy(c + compno, &tmp, sizeof(tmp));
 556     return 0;
 557 }
 558
 559 /* Get coding parameters for a component in the whole image or a
 560  * particular tile. */
 561 static int get_coc(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c,
 562                    uint8_t *properties)
 563 {
 564     int compno, ret;
 565
 566     if (bytestream2_get_bytes_left(&s->g) < 2) {
 567         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         av_log(s->avctx, AV_LOG_ERROR,
 575                "Invalid compno %d. There are %d components in the image.\n",
 576                compno, s->ncomponents);
 577         return AVERROR_INVALIDDATA;
 578     }
 579
 580     c      += compno;
 581     c->csty = bytestream2_get_byteu(&s->g);
 582
 583     if ((ret = get_cox(s, c)) < 0)
 584         return ret;
 585
 586     properties[compno] |= HAD_COC;
 587     return 0;
 588 }
 589
 590 /* Get common part for QCD and QCC segments. */
 591 static int get_qcx(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q)
 592 {
 593     int i, x;
 594
 595     if (bytestream2_get_bytes_left(&s->g) < 1)
 596         return AVERROR_INVALIDDATA;
 597
 598     x = bytestream2_get_byteu(&s->g); // Sqcd
 599
 600     q->nguardbits = x >> 5;
 601     q->quantsty   = x & 0x1f;
 602
 603     if (q->quantsty == JPEG2000_QSTY_NONE) {
 604         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         q->expn[0] = x >> 11;
 615         q->mant[0] = x & 0x7ff;
 616         for (i = 1; i < JPEG2000_MAX_DECLEVELS * 3; i++) {
 617             int curexpn = FFMAX(0, q->expn[0] - (i - 1) / 3);
 618             q->expn[i] = curexpn;
 619             q->mant[i] = q->mant[0];
 620         }
 621     } else {
 622         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             q->expn[i] = x >> 11;
 629             q->mant[i] = x & 0x7ff;
 630         }
 631     }
 632     return 0;
 633 }
 634
 635 /* Get quantization parameters for a particular tile or a whole image. */
 636 static int get_qcd(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q,
 637                    uint8_t *properties)
 638 {
 639     Jpeg2000QuantStyle tmp;
 640     int compno, ret;
 641
 642     memset(&tmp, 0, sizeof(tmp));
 643
 644     if ((ret = get_qcx(s, n, &tmp)) < 0)
 645         return ret;
 646     for (compno = 0; compno < s->ncomponents; compno++)
 647         if (!(properties[compno] & HAD_QCC))
 648             memcpy(q + compno, &tmp, sizeof(tmp));
 649     return 0;
 650 }
 651
 652 /* Get quantization parameters for a component in the whole image
 653  * on in a particular tile. */
 654 static int get_qcc(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q,
 655                    uint8_t *properties)
 656 {
 657     int compno;
 658
 659     if (bytestream2_get_bytes_left(&s->g) < 1)
 660         return AVERROR_INVALIDDATA;
 661
 662     compno = bytestream2_get_byteu(&s->g);
 663
 664     if (compno >= s->ncomponents) {
 665         av_log(s->avctx, AV_LOG_ERROR,
 666                "Invalid compno %d. There are %d components in the image.\n",
 667                compno, s->ncomponents);
 668         return AVERROR_INVALIDDATA;
 669     }
 670
 671     properties[compno] |= HAD_QCC;
 672     return get_qcx(s, n - 1, q + compno);
 673 }
 674
 675 static int get_poc(Jpeg2000DecoderContext *s, int size, Jpeg2000POC *p)
 676 {
 677     int i;
 678     int elem_size = s->ncomponents <= 257 ? 7 : 9;
 679     Jpeg2000POC tmp = {{{0}}};
 680
 681     if (bytestream2_get_bytes_left(&s->g) < 5 || size < 2 + elem_size) {
 682         av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for POC\n");
 683         return AVERROR_INVALIDDATA;
 684     }
 685
 686     if (elem_size > 7) {
 687         avpriv_request_sample(s->avctx, "Fat POC not supported");
 688         return AVERROR_PATCHWELCOME;
 689     }
 690
 691     tmp.nb_poc = (size - 2) / elem_size;
 692     if (tmp.nb_poc > MAX_POCS) {
 693         avpriv_request_sample(s->avctx, "Too many POCs (%d)", tmp.nb_poc);
 694         return AVERROR_PATCHWELCOME;
 695     }
 696
 697     for (i = 0; i<tmp.nb_poc; i++) {
 698         Jpeg2000POCEntry *e = &tmp.poc[i];
 699         e->RSpoc  = bytestream2_get_byteu(&s->g);
 700         e->CSpoc  = bytestream2_get_byteu(&s->g);
 701         e->LYEpoc = bytestream2_get_be16u(&s->g);
 702         e->REpoc  = bytestream2_get_byteu(&s->g);
 703         e->CEpoc  = bytestream2_get_byteu(&s->g);
 704         e->Ppoc   = bytestream2_get_byteu(&s->g);
 705         if (!e->CEpoc)
 706             e->CEpoc = 256;
 707         if (e->CEpoc > s->ncomponents)
 708             e->CEpoc = s->ncomponents;
 709         if (   e->RSpoc >= e->REpoc || e->REpoc > 33
 710             || e->CSpoc >= e->CEpoc || e->CEpoc > s->ncomponents
 711             || !e->LYEpoc) {
 712             av_log(s->avctx, AV_LOG_ERROR, "POC Entry %d is invalid (%d, %d, %d, %d, %d, %d)\n", i,
 713                 e->RSpoc, e->CSpoc, e->LYEpoc, e->REpoc, e->CEpoc, e->Ppoc
 714             );
 715             return AVERROR_INVALIDDATA;
 716         }
 717     }
 718
 719     if (!p->nb_poc || p->is_default) {
 720         *p = tmp;
 721     } else {
 722         if (p->nb_poc + tmp.nb_poc > MAX_POCS) {
 723             av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for POC\n");
 724             return AVERROR_INVALIDDATA;
 725         }
 726         memcpy(p->poc + p->nb_poc, tmp.poc, tmp.nb_poc * sizeof(tmp.poc[0]));
 727         p->nb_poc += tmp.nb_poc;
 728     }
 729
 730     p->is_default = 0;
 731
 732     return 0;
 733 }
 734
 735
 736 /* Get start of tile segment. */
 737 static int get_sot(Jpeg2000DecoderContext *s, int n)
 738 {
 739     Jpeg2000TilePart *tp;
 740     uint16_t Isot;
 741     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     Psot  = bytestream2_get_be32u(&s->g);       // Psot
 754     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         return AVERROR_INVALIDDATA;
 765     }
 766
 767     if (TPsot >= FF_ARRAY_ELEMS(s->tile[Isot].tile_part)) {
 768         avpriv_request_sample(s->avctx, "Too many tile parts");
 769         return AVERROR_PATCHWELCOME;
 770     }
 771
 772     s->tile[Isot].tp_idx = TPsot;
 773     tp             = s->tile[Isot].tile_part + TPsot;
 774     tp->tile_index = Isot;
 775     tp->tp_end     = s->g.buffer + Psot - n - 2;
 776
 777     if (!TPsot) {
 778         Jpeg2000Tile *tile = s->tile + s->curtileno;
 779
 780         /* copy defaults */
 781         memcpy(tile->codsty, s->codsty, s->ncomponents * sizeof(Jpeg2000CodingStyle));
 782         memcpy(tile->qntsty, s->qntsty, s->ncomponents * sizeof(Jpeg2000QuantStyle));
 783         memcpy(&tile->poc  , &s->poc  , sizeof(tile->poc));
 784         tile->poc.is_default = 1;
 785     }
 786
 787     return 0;
 788 }
 789
 790 /* Tile-part lengths: see ISO 15444-1:2002, section A.7.1
 791  * Used to know the number of tile parts and lengths.
 792  * There may be multiple TLMs in the header.
 793  * TODO: The function is not used for tile-parts management, nor anywhere else.
 794  * It can be useful to allocate memory for tile parts, before managing the SOT
 795  * markers. Parsing the TLM header is needed to increment the input header
 796  * buffer.
 797  * This marker is mandatory for DCI. */
 798 static uint8_t get_tlm(Jpeg2000DecoderContext *s, int n)
 799 {
 800     uint8_t Stlm, ST, SP, tile_tlm, i;
 801     bytestream2_get_byte(&s->g);               /* Ztlm: skipped */
 802     Stlm = bytestream2_get_byte(&s->g);
 803
 804     // too complex ? ST = ((Stlm >> 4) & 0x01) + ((Stlm >> 4) & 0x02);
 805     ST = (Stlm >> 4) & 0x03;
 806     // TODO: Manage case of ST = 0b11 --> raise error
 807     SP       = (Stlm >> 6) & 0x01;
 808     tile_tlm = (n - 4) / ((SP + 1) * 2 + ST);
 809     for (i = 0; i < tile_tlm; i++) {
 810         switch (ST) {
 811         case 0:
 812             break;
 813         case 1:
 814             bytestream2_get_byte(&s->g);
 815             break;
 816         case 2:
 817             bytestream2_get_be16(&s->g);
 818             break;
 819         case 3:
 820             bytestream2_get_be32(&s->g);
 821             break;
 822         }
 823         if (SP == 0) {
 824             bytestream2_get_be16(&s->g);
 825         } else {
 826             bytestream2_get_be32(&s->g);
 827         }
 828     }
 829     return 0;
 830 }
 831
 832 static uint8_t get_plt(Jpeg2000DecoderContext *s, int n)
 833 {
 834     int i;
 835
 836     av_log(s->avctx, AV_LOG_DEBUG,
 837             "PLT marker at pos 0x%X\n", bytestream2_tell(&s->g) - 4);
 838
 839     /*Zplt =*/ bytestream2_get_byte(&s->g);
 840
 841     for (i = 0; i < n - 3; i++) {
 842         bytestream2_get_byte(&s->g);
 843     }
 844
 845     return 0;
 846 }
 847
 848 static int init_tile(Jpeg2000DecoderContext *s, int tileno)
 849 {
 850     int compno;
 851     int tilex = tileno % s->numXtiles;
 852     int tiley = tileno / s->numXtiles;
 853     Jpeg2000Tile *tile = s->tile + tileno;
 854
 855     if (!tile->comp)
 856         return AVERROR(ENOMEM);
 857
 858     tile->coord[0][0] = av_clip(tilex       * (int64_t)s->tile_width  + s->tile_offset_x, s->image_offset_x, s->width);
 859     tile->coord[0][1] = av_clip((tilex + 1) * (int64_t)s->tile_width  + s->tile_offset_x, s->image_offset_x, s->width);
 860     tile->coord[1][0] = av_clip(tiley       * (int64_t)s->tile_height + s->tile_offset_y, s->image_offset_y, s->height);
 861     tile->coord[1][1] = av_clip((tiley + 1) * (int64_t)s->tile_height + s->tile_offset_y, s->image_offset_y, s->height);
 862
 863     for (compno = 0; compno < s->ncomponents; compno++) {
 864         Jpeg2000Component *comp = tile->comp + compno;
 865         Jpeg2000CodingStyle *codsty = tile->codsty + compno;
 866         Jpeg2000QuantStyle  *qntsty = tile->qntsty + compno;
 867         int ret; // global bandno
 868
 869         comp->coord_o[0][0] = tile->coord[0][0];
 870         comp->coord_o[0][1] = tile->coord[0][1];
 871         comp->coord_o[1][0] = tile->coord[1][0];
 872         comp->coord_o[1][1] = tile->coord[1][1];
 873         if (compno) {
 874             comp->coord_o[0][0] /= s->cdx[compno];
 875             comp->coord_o[0][1] /= s->cdx[compno];
 876             comp->coord_o[1][0] /= s->cdy[compno];
 877             comp->coord_o[1][1] /= s->cdy[compno];
 878         }
 879
 880         comp->coord[0][0] = ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], s->reduction_factor);
 881         comp->coord[0][1] = ff_jpeg2000_ceildivpow2(comp->coord_o[0][1], s->reduction_factor);
 882         comp->coord[1][0] = ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], s->reduction_factor);
 883         comp->coord[1][1] = ff_jpeg2000_ceildivpow2(comp->coord_o[1][1], s->reduction_factor);
 884
 885         if (ret = ff_jpeg2000_init_component(comp, codsty, qntsty,
 886                                              s->cbps[compno], s->cdx[compno],
 887                                              s->cdy[compno], s->avctx))
 888             return ret;
 889     }
 890     return 0;
 891 }
 892
 893 /* Read the number of coding passes. */
 894 static int getnpasses(Jpeg2000DecoderContext *s)
 895 {
 896     int num;
 897     if (!get_bits(s, 1))
 898         return 1;
 899     if (!get_bits(s, 1))
 900         return 2;
 901     if ((num = get_bits(s, 2)) != 3)
 902         return num < 0 ? num : 3 + num;
 903     if ((num = get_bits(s, 5)) != 31)
 904         return num < 0 ? num : 6 + num;
 905     num = get_bits(s, 7);
 906     return num < 0 ? num : 37 + num;
 907 }
 908
 909 static int getlblockinc(Jpeg2000DecoderContext *s)
 910 {
 911     int res = 0, ret;
 912     while (ret = get_bits(s, 1)) {
 913         if (ret < 0)
 914             return ret;
 915         res++;
 916     }
 917     return res;
 918 }
 919
 920 static int jpeg2000_decode_packet(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile, int *tp_index,
 921                                   Jpeg2000CodingStyle *codsty,
 922                                   Jpeg2000ResLevel *rlevel, int precno,
 923                                   int layno, uint8_t *expn, int numgbits)
 924 {
 925     int bandno, cblkno, ret, nb_code_blocks;
 926     int cwsno;
 927
 928     if (layno < rlevel->band[0].prec[precno].decoded_layers)
 929         return 0;
 930     rlevel->band[0].prec[precno].decoded_layers = layno + 1;
 931
 932     if (bytestream2_get_bytes_left(&s->g) == 0 && s->bit_index == 8) {
 933         if (*tp_index < FF_ARRAY_ELEMS(tile->tile_part) - 1) {
 934             s->g = tile->tile_part[++(*tp_index)].tpg;
 935         }
 936     }
 937
 938     if (bytestream2_peek_be32(&s->g) == JPEG2000_SOP_FIXED_BYTES)
 939         bytestream2_skip(&s->g, JPEG2000_SOP_BYTE_LENGTH);
 940
 941     if (!(ret = get_bits(s, 1))) {
 942         jpeg2000_flush(s);
 943         return 0;
 944     } else if (ret < 0)
 945         return ret;
 946
 947     for (bandno = 0; bandno < rlevel->nbands; bandno++) {
 948         Jpeg2000Band *band = rlevel->band + bandno;
 949         Jpeg2000Prec *prec = band->prec + precno;
 950
 951         if (band->coord[0][0] == band->coord[0][1] ||
 952             band->coord[1][0] == band->coord[1][1])
 953             continue;
 954         nb_code_blocks =  prec->nb_codeblocks_height *
 955                           prec->nb_codeblocks_width;
 956         for (cblkno = 0; cblkno < nb_code_blocks; cblkno++) {
 957             Jpeg2000Cblk *cblk = prec->cblk + cblkno;
 958             int incl, newpasses, llen;
 959             void *tmp;
 960
 961             if (cblk->npasses)
 962                 incl = get_bits(s, 1);
 963             else
 964                 incl = tag_tree_decode(s, prec->cblkincl + cblkno, layno + 1) == layno;
 965             if (!incl)
 966                 continue;
 967             else if (incl < 0)
 968                 return incl;
 969
 970             if (!cblk->npasses) {
 971                 int v = expn[bandno] + numgbits - 1 -
 972                         tag_tree_decode(s, prec->zerobits + cblkno, 100);
 973                 if (v < 0 || v > 30) {
 974                     av_log(s->avctx, AV_LOG_ERROR,
 975                            "nonzerobits %d invalid or unsupported\n", v);
 976                     return AVERROR_INVALIDDATA;
 977                 }
 978                 cblk->nonzerobits = v;
 979             }
 980             if ((newpasses = getnpasses(s)) < 0)
 981                 return newpasses;
 982             av_assert2(newpasses > 0);
 983             if (cblk->npasses + newpasses >= JPEG2000_MAX_PASSES) {
 984                 avpriv_request_sample(s->avctx, "Too many passes");
 985                 return AVERROR_PATCHWELCOME;
 986             }
 987             if ((llen = getlblockinc(s)) < 0)
 988                 return llen;
 989             if (cblk->lblock + llen + av_log2(newpasses) > 16) {
 990                 avpriv_request_sample(s->avctx,
 991                                       "Block with length beyond 16 bits");
 992                 return AVERROR_PATCHWELCOME;
 993             }
 994
 995             cblk->lblock += llen;
 996
 997             cblk->nb_lengthinc = 0;
 998             cblk->nb_terminationsinc = 0;
 999             av_free(cblk->lengthinc);
1000             cblk->lengthinc  = av_mallocz_array(newpasses    , sizeof(*cblk->lengthinc));
1001             if (!cblk->lengthinc)
1002                 return AVERROR(ENOMEM);
1003             tmp = av_realloc_array(cblk->data_start, cblk->nb_terminations + newpasses + 1, sizeof(*cblk->data_start));
1004             if (!tmp)
1005                 return AVERROR(ENOMEM);
1006             cblk->data_start = tmp;
1007             do {
1008                 int newpasses1 = 0;
1009
1010                 while (newpasses1 < newpasses) {
1011                     newpasses1 ++;
1012                     if (needs_termination(codsty->cblk_style, cblk->npasses + newpasses1 - 1)) {
1013                         cblk->nb_terminationsinc ++;
1014                         break;
1015                     }
1016                 }
1017
1018                 if ((ret = get_bits(s, av_log2(newpasses1) + cblk->lblock)) < 0)
1019                     return ret;
1020                 if (ret > cblk->data_allocated) {
1021                     size_t new_size = FFMAX(2*cblk->data_allocated, ret);
1022                     void *new = av_realloc(cblk->data, new_size);
1023                     if (new) {
1024                         cblk->data = new;
1025                         cblk->data_allocated = new_size;
1026                     }
1027                 }
1028                 if (ret > cblk->data_allocated) {
1029                     avpriv_request_sample(s->avctx,
1030                                         "Block with lengthinc greater than %"SIZE_SPECIFIER"",
1031                                         cblk->data_allocated);
1032                     return AVERROR_PATCHWELCOME;
1033                 }
1034                 cblk->lengthinc[cblk->nb_lengthinc++] = ret;
1035                 cblk->npasses  += newpasses1;
1036                 newpasses -= newpasses1;
1037             } while(newpasses);
1038         }
1039     }
1040     jpeg2000_flush(s);
1041
1042     if (codsty->csty & JPEG2000_CSTY_EPH) {
1043         if (bytestream2_peek_be16(&s->g) == JPEG2000_EPH)
1044             bytestream2_skip(&s->g, 2);
1045         else
1046             av_log(s->avctx, AV_LOG_ERROR, "EPH marker not found. instead %X\n", bytestream2_peek_be32(&s->g));
1047     }
1048
1049     for (bandno = 0; bandno < rlevel->nbands; bandno++) {
1050         Jpeg2000Band *band = rlevel->band + bandno;
1051         Jpeg2000Prec *prec = band->prec + precno;
1052
1053         nb_code_blocks = prec->nb_codeblocks_height * prec->nb_codeblocks_width;
1054         for (cblkno = 0; cblkno < nb_code_blocks; cblkno++) {
1055             Jpeg2000Cblk *cblk = prec->cblk + cblkno;
1056             if (!cblk->nb_terminationsinc && !cblk->lengthinc)
1057                 continue;
1058             for (cwsno = 0; cwsno < cblk->nb_lengthinc; cwsno ++) {
1059                 if (cblk->data_allocated < cblk->length + cblk->lengthinc[cwsno] + 4) {
1060                     size_t new_size = FFMAX(2*cblk->data_allocated, cblk->length + cblk->lengthinc[cwsno] + 4);
1061                     void *new = av_realloc(cblk->data, new_size);
1062                     if (new) {
1063                         cblk->data = new;
1064                         cblk->data_allocated = new_size;
1065                     }
1066                 }
1067                 if (   bytestream2_get_bytes_left(&s->g) < cblk->lengthinc[cwsno]
1068                     || cblk->data_allocated < cblk->length + cblk->lengthinc[cwsno] + 4
1069                 ) {
1070                     av_log(s->avctx, AV_LOG_ERROR,
1071                         "Block length %"PRIu16" or lengthinc %d is too large, left %d\n",
1072                         cblk->length, cblk->lengthinc[cwsno], bytestream2_get_bytes_left(&s->g));
1073                     return AVERROR_INVALIDDATA;
1074                 }
1075
1076                 bytestream2_get_bufferu(&s->g, cblk->data + cblk->length, cblk->lengthinc[cwsno]);
1077                 cblk->length   += cblk->lengthinc[cwsno];
1078                 cblk->lengthinc[cwsno] = 0;
1079                 if (cblk->nb_terminationsinc) {
1080                     cblk->nb_terminationsinc--;
1081                     cblk->nb_terminations++;
1082                     cblk->data[cblk->length++] = 0xFF;
1083                     cblk->data[cblk->length++] = 0xFF;
1084                     cblk->data_start[cblk->nb_terminations] = cblk->length;
1085                 }
1086             }
1087             av_freep(&cblk->lengthinc);
1088         }
1089     }
1090     return 0;
1091 }
1092
1093 static int jpeg2000_decode_packets_po_iteration(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile,
1094                                              int RSpoc, int CSpoc,
1095                                              int LYEpoc, int REpoc, int CEpoc,
1096                                              int Ppoc, int *tp_index)
1097 {
1098     int ret = 0;
1099     int layno, reslevelno, compno, precno, ok_reslevel;
1100     int x, y;
1101     int step_x, step_y;
1102
1103     switch (Ppoc) {
1104     case JPEG2000_PGOD_RLCP:
1105         av_log(s->avctx, AV_LOG_DEBUG, "Progression order RLCP\n");
1106         ok_reslevel = 1;
1107         for (reslevelno = RSpoc; ok_reslevel && reslevelno < REpoc; reslevelno++) {
1108             ok_reslevel = 0;
1109             for (layno = 0; layno < LYEpoc; layno++) {
1110                 for (compno = CSpoc; compno < CEpoc; compno++) {
1111                     Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1112                     Jpeg2000QuantStyle *qntsty  = tile->qntsty + compno;
1113                     if (reslevelno < codsty->nreslevels) {
1114                         Jpeg2000ResLevel *rlevel = tile->comp[compno].reslevel +
1115                                                 reslevelno;
1116                         ok_reslevel = 1;
1117                         for (precno = 0; precno < rlevel->num_precincts_x * rlevel->num_precincts_y; precno++)
1118                             if ((ret = jpeg2000_decode_packet(s, tile, tp_index,
1119                                                               codsty, rlevel,
1120                                                               precno, layno,
1121                                                               qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1122                                                               qntsty->nguardbits)) < 0)
1123                                 return ret;
1124                     }
1125                 }
1126             }
1127         }
1128         break;
1129
1130     case JPEG2000_PGOD_LRCP:
1131         av_log(s->avctx, AV_LOG_DEBUG, "Progression order LRCP\n");
1132         for (layno = 0; layno < LYEpoc; layno++) {
1133             ok_reslevel = 1;
1134             for (reslevelno = RSpoc; ok_reslevel && reslevelno < REpoc; reslevelno++) {
1135                 ok_reslevel = 0;
1136                 for (compno = CSpoc; compno < CEpoc; compno++) {
1137                     Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1138                     Jpeg2000QuantStyle *qntsty  = tile->qntsty + compno;
1139                     if (reslevelno < codsty->nreslevels) {
1140                         Jpeg2000ResLevel *rlevel = tile->comp[compno].reslevel +
1141                                                 reslevelno;
1142                         ok_reslevel = 1;
1143                         for (precno = 0; precno < rlevel->num_precincts_x * rlevel->num_precincts_y; precno++)
1144                             if ((ret = jpeg2000_decode_packet(s, tile, tp_index,
1145                                                               codsty, rlevel,
1146                                                               precno, layno,
1147                                                               qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1148                                                               qntsty->nguardbits)) < 0)
1149                                 return ret;
1150                     }
1151                 }
1152             }
1153         }
1154         break;
1155
1156     case JPEG2000_PGOD_CPRL:
1157         av_log(s->avctx, AV_LOG_DEBUG, "Progression order CPRL\n");
1158         for (compno = CSpoc; compno < CEpoc; compno++) {
1159             Jpeg2000Component *comp     = tile->comp + compno;
1160             Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1161             Jpeg2000QuantStyle *qntsty  = tile->qntsty + compno;
1162             step_x = 32;
1163             step_y = 32;
1164
1165             if (RSpoc >= FFMIN(codsty->nreslevels, REpoc))
1166                 continue;
1167
1168             for (reslevelno = RSpoc; reslevelno < FFMIN(codsty->nreslevels, REpoc); reslevelno++) {
1169                 uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; //  ==> N_L - r
1170                 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1171                 step_x = FFMIN(step_x, rlevel->log2_prec_width  + reducedresno);
1172                 step_y = FFMIN(step_y, rlevel->log2_prec_height + reducedresno);
1173             }
1174             av_assert0(step_x < 32 && step_y < 32);
1175             step_x = 1<<step_x;
1176             step_y = 1<<step_y;
1177
1178             for (y = tile->coord[1][0]; y < tile->coord[1][1]; y = (y/step_y + 1)*step_y) {
1179                 for (x = tile->coord[0][0]; x < tile->coord[0][1]; x = (x/step_x + 1)*step_x) {
1180                     for (reslevelno = RSpoc; reslevelno < FFMIN(codsty->nreslevels, REpoc); reslevelno++) {
1181                         unsigned prcx, prcy;
1182                         uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; //  ==> N_L - r
1183                         Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1184                         int xc = x / s->cdx[compno];
1185                         int yc = y / s->cdy[compno];
1186
1187                         if (yc % (1LL << (rlevel->log2_prec_height + reducedresno)) && y != tile->coord[1][0]) //FIXME this is a subset of the check
1188                             continue;
1189
1190                         if (xc % (1LL << (rlevel->log2_prec_width + reducedresno)) && x != tile->coord[0][0]) //FIXME this is a subset of the check
1191                             continue;
1192
1193                         // check if a precinct exists
1194                         prcx   = ff_jpeg2000_ceildivpow2(xc, reducedresno) >> rlevel->log2_prec_width;
1195                         prcy   = ff_jpeg2000_ceildivpow2(yc, reducedresno) >> rlevel->log2_prec_height;
1196                         prcx  -= ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], reducedresno) >> rlevel->log2_prec_width;
1197                         prcy  -= ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], reducedresno) >> rlevel->log2_prec_height;
1198
1199                         precno = prcx + rlevel->num_precincts_x * prcy;
1200
1201                         if (prcx >= rlevel->num_precincts_x || prcy >= rlevel->num_precincts_y) {
1202                             av_log(s->avctx, AV_LOG_WARNING, "prc %d %d outside limits %d %d\n",
1203                                    prcx, prcy, rlevel->num_precincts_x, rlevel->num_precincts_y);
1204                             continue;
1205                         }
1206
1207                         for (layno = 0; layno < LYEpoc; layno++) {
1208                             if ((ret = jpeg2000_decode_packet(s, tile, tp_index, codsty, rlevel,
1209                                                               precno, layno,
1210                                                               qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1211                                                               qntsty->nguardbits)) < 0)
1212                                 return ret;
1213                         }
1214                     }
1215                 }
1216             }
1217         }
1218         break;
1219
1220     case JPEG2000_PGOD_RPCL:
1221         av_log(s->avctx, AV_LOG_WARNING, "Progression order RPCL\n");
1222         ok_reslevel = 1;
1223         for (reslevelno = RSpoc; ok_reslevel && reslevelno < REpoc; reslevelno++) {
1224             ok_reslevel = 0;
1225             step_x = 30;
1226             step_y = 30;
1227             for (compno = CSpoc; compno < CEpoc; compno++) {
1228                 Jpeg2000Component *comp     = tile->comp + compno;
1229                 Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1230
1231                 if (reslevelno < codsty->nreslevels) {
1232                     uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; //  ==> N_L - r
1233                     Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1234                     step_x = FFMIN(step_x, rlevel->log2_prec_width  + reducedresno);
1235                     step_y = FFMIN(step_y, rlevel->log2_prec_height + reducedresno);
1236                 }
1237             }
1238             step_x = 1<<step_x;
1239             step_y = 1<<step_y;
1240
1241             for (y = tile->coord[1][0]; y < tile->coord[1][1]; y = (y/step_y + 1)*step_y) {
1242                 for (x = tile->coord[0][0]; x < tile->coord[0][1]; x = (x/step_x + 1)*step_x) {
1243                     for (compno = CSpoc; compno < CEpoc; compno++) {
1244                         Jpeg2000Component *comp     = tile->comp + compno;
1245                         Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1246                         Jpeg2000QuantStyle *qntsty  = tile->qntsty + compno;
1247                         uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; //  ==> N_L - r
1248                         Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1249                         unsigned prcx, prcy;
1250
1251                         int xc = x / s->cdx[compno];
1252                         int yc = y / s->cdy[compno];
1253
1254                         if (reslevelno >= codsty->nreslevels)
1255                             continue;
1256
1257                         if (yc % (1LL << (rlevel->log2_prec_height + reducedresno)) && y != tile->coord[1][0]) //FIXME this is a subset of the check
1258                             continue;
1259
1260                         if (xc % (1LL << (rlevel->log2_prec_width + reducedresno)) && x != tile->coord[0][0]) //FIXME this is a subset of the check
1261                             continue;
1262
1263                         // check if a precinct exists
1264                         prcx   = ff_jpeg2000_ceildivpow2(xc, reducedresno) >> rlevel->log2_prec_width;
1265                         prcy   = ff_jpeg2000_ceildivpow2(yc, reducedresno) >> rlevel->log2_prec_height;
1266                         prcx  -= ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], reducedresno) >> rlevel->log2_prec_width;
1267                         prcy  -= ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], reducedresno) >> rlevel->log2_prec_height;
1268
1269                         precno = prcx + rlevel->num_precincts_x * prcy;
1270
1271                         ok_reslevel = 1;
1272                         if (prcx >= rlevel->num_precincts_x || prcy >= rlevel->num_precincts_y) {
1273                             av_log(s->avctx, AV_LOG_WARNING, "prc %d %d outside limits %d %d\n",
1274                                    prcx, prcy, rlevel->num_precincts_x, rlevel->num_precincts_y);
1275                             continue;
1276                         }
1277
1278                             for (layno = 0; layno < LYEpoc; layno++) {
1279                                 if ((ret = jpeg2000_decode_packet(s, tile, tp_index,
1280                                                                 codsty, rlevel,
1281                                                                 precno, layno,
1282                                                                 qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1283                                                                 qntsty->nguardbits)) < 0)
1284                                     return ret;
1285                             }
1286                     }
1287                 }
1288             }
1289         }
1290         break;
1291
1292     case JPEG2000_PGOD_PCRL:
1293         av_log(s->avctx, AV_LOG_WARNING, "Progression order PCRL\n");
1294         step_x = 32;
1295         step_y = 32;
1296         for (compno = CSpoc; compno < CEpoc; compno++) {
1297             Jpeg2000Component *comp     = tile->comp + compno;
1298             Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1299
1300             for (reslevelno = RSpoc; reslevelno < FFMIN(codsty->nreslevels, REpoc); reslevelno++) {
1301                 uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; //  ==> N_L - r
1302                 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1303                 step_x = FFMIN(step_x, rlevel->log2_prec_width  + reducedresno);
1304                 step_y = FFMIN(step_y, rlevel->log2_prec_height + reducedresno);
1305             }
1306         }
1307         if (step_x >= 31 || step_y >= 31){
1308             avpriv_request_sample(s->avctx, "PCRL with large step");
1309             return AVERROR_PATCHWELCOME;
1310         }
1311         step_x = 1<<step_x;
1312         step_y = 1<<step_y;
1313
1314         for (y = tile->coord[1][0]; y < tile->coord[1][1]; y = (y/step_y + 1)*step_y) {
1315             for (x = tile->coord[0][0]; x < tile->coord[0][1]; x = (x/step_x + 1)*step_x) {
1316                 for (compno = CSpoc; compno < CEpoc; compno++) {
1317                     Jpeg2000Component *comp     = tile->comp + compno;
1318                     Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1319                     Jpeg2000QuantStyle *qntsty  = tile->qntsty + compno;
1320                     int xc = x / s->cdx[compno];
1321                     int yc = y / s->cdy[compno];
1322
1323                     for (reslevelno = RSpoc; reslevelno < FFMIN(codsty->nreslevels, REpoc); reslevelno++) {
1324                         unsigned prcx, prcy;
1325                         uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; //  ==> N_L - r
1326                         Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1327
1328                         if (yc % (1LL << (rlevel->log2_prec_height + reducedresno)) && y != tile->coord[1][0]) //FIXME this is a subset of the check
1329                             continue;
1330
1331                         if (xc % (1LL << (rlevel->log2_prec_width + reducedresno)) && x != tile->coord[0][0]) //FIXME this is a subset of the check
1332                             continue;
1333
1334                         // check if a precinct exists
1335                         prcx   = ff_jpeg2000_ceildivpow2(xc, reducedresno) >> rlevel->log2_prec_width;
1336                         prcy   = ff_jpeg2000_ceildivpow2(yc, reducedresno) >> rlevel->log2_prec_height;
1337                         prcx  -= ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], reducedresno) >> rlevel->log2_prec_width;
1338                         prcy  -= ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], reducedresno) >> rlevel->log2_prec_height;
1339
1340                         precno = prcx + rlevel->num_precincts_x * prcy;
1341
1342                         if (prcx >= rlevel->num_precincts_x || prcy >= rlevel->num_precincts_y) {
1343                             av_log(s->avctx, AV_LOG_WARNING, "prc %d %d outside limits %d %d\n",
1344                                    prcx, prcy, rlevel->num_precincts_x, rlevel->num_precincts_y);
1345                             continue;
1346                         }
1347
1348                         for (layno = 0; layno < LYEpoc; layno++) {
1349                             if ((ret = jpeg2000_decode_packet(s, tile, tp_index, codsty, rlevel,
1350                                                               precno, layno,
1351                                                               qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1352                                                               qntsty->nguardbits)) < 0)
1353                                 return ret;
1354                         }
1355                     }
1356                 }
1357             }
1358         }
1359         break;
1360
1361     default:
1362         break;
1363     }
1364
1365     return ret;
1366 }
1367
1368 static int jpeg2000_decode_packets(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
1369 {
1370     int ret = AVERROR_BUG;
1371     int i;
1372     int tp_index = 0;
1373
1374     s->bit_index = 8;
1375     if (tile->poc.nb_poc) {
1376         for (i=0; i<tile->poc.nb_poc; i++) {
1377             Jpeg2000POCEntry *e = &tile->poc.poc[i];
1378             ret = jpeg2000_decode_packets_po_iteration(s, tile,
1379                 e->RSpoc, e->CSpoc,
1380                 FFMIN(e->LYEpoc, tile->codsty[0].nlayers),
1381                 e->REpoc,
1382                 FFMIN(e->CEpoc, s->ncomponents),
1383                 e->Ppoc, &tp_index
1384                 );
1385             if (ret < 0)
1386                 return ret;
1387         }
1388     } else {
1389         ret = jpeg2000_decode_packets_po_iteration(s, tile,
1390             0, 0,
1391             tile->codsty[0].nlayers,
1392             33,
1393             s->ncomponents,
1394             tile->codsty[0].prog_order,
1395             &tp_index
1396         );
1397     }
1398     /* EOC marker reached */
1399     bytestream2_skip(&s->g, 2);
1400
1401     return ret;
1402 }
1403
1404 /* TIER-1 routines */
1405 static void decode_sigpass(Jpeg2000T1Context *t1, int width, int height,
1406                            int bpno, int bandno,
1407                            int vert_causal_ctx_csty_symbol)
1408 {
1409     int mask = 3 << (bpno - 1), y0, x, y;
1410
1411     for (y0 = 0; y0 < height; y0 += 4)
1412         for (x = 0; x < width; x++)
1413             for (y = y0; y < height && y < y0 + 4; y++) {
1414                 int flags_mask = -1;
1415                 if (vert_causal_ctx_csty_symbol && y == y0 + 3)
1416                     flags_mask &= ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE | JPEG2000_T1_SGN_S);
1417                 if ((t1->flags[(y+1) * t1->stride + x+1] & JPEG2000_T1_SIG_NB & flags_mask)
1418                 && !(t1->flags[(y+1) * t1->stride + x+1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS))) {
1419                     if (ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ff_jpeg2000_getsigctxno(t1->flags[(y+1) * t1->stride + x+1] & flags_mask, bandno))) {
1420                         int xorbit, ctxno = ff_jpeg2000_getsgnctxno(t1->flags[(y+1) * t1->stride + x+1] & flags_mask, &xorbit);
1421                         if (t1->mqc.raw)
1422                              t1->data[(y) * t1->stride + x] = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ctxno) ? -mask : mask;
1423                         else
1424                              t1->data[(y) * t1->stride + x] = (ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ctxno) ^ xorbit) ?
1425                                                -mask : mask;
1426
1427                         ff_jpeg2000_set_significance(t1, x, y,
1428                                                      t1->data[(y) * t1->stride + x] < 0);
1429                     }
1430                     t1->flags[(y + 1) * t1->stride + x + 1] |= JPEG2000_T1_VIS;
1431                 }
1432             }
1433 }
1434
1435 static void decode_refpass(Jpeg2000T1Context *t1, int width, int height,
1436                            int bpno, int vert_causal_ctx_csty_symbol)
1437 {
1438     int phalf, nhalf;
1439     int y0, x, y;
1440
1441     phalf = 1 << (bpno - 1);
1442     nhalf = -phalf;
1443
1444     for (y0 = 0; y0 < height; y0 += 4)
1445         for (x = 0; x < width; x++)
1446             for (y = y0; y < height && y < y0 + 4; y++)
1447                 if ((t1->flags[(y + 1) * t1->stride + x + 1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS)) == JPEG2000_T1_SIG) {
1448                     int flags_mask = (vert_causal_ctx_csty_symbol && y == y0 + 3) ?
1449                         ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE | JPEG2000_T1_SGN_S) : -1;
1450                     int ctxno = ff_jpeg2000_getrefctxno(t1->flags[(y + 1) * t1->stride + x + 1] & flags_mask);
1451                     int r     = ff_mqc_decode(&t1->mqc,
1452                                               t1->mqc.cx_states + ctxno)
1453                                 ? phalf : nhalf;
1454                     t1->data[(y) * t1->stride + x]          += t1->data[(y) * t1->stride + x] < 0 ? -r : r;
1455                     t1->flags[(y + 1) * t1->stride + x + 1] |= JPEG2000_T1_REF;
1456                 }
1457 }
1458
1459 static void decode_clnpass(Jpeg2000DecoderContext *s, Jpeg2000T1Context *t1,
1460                            int width, int height, int bpno, int bandno,
1461                            int seg_symbols, int vert_causal_ctx_csty_symbol)
1462 {
1463     int mask = 3 << (bpno - 1), y0, x, y, runlen, dec;
1464
1465     for (y0 = 0; y0 < height; y0 += 4) {
1466         for (x = 0; x < width; x++) {
1467             int flags_mask = -1;
1468             if (vert_causal_ctx_csty_symbol)
1469                 flags_mask &= ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE | JPEG2000_T1_SGN_S);
1470             if (y0 + 3 < height &&
1471                 !((t1->flags[(y0 + 1) * t1->stride + x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
1472                   (t1->flags[(y0 + 2) * t1->stride + x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
1473                   (t1->flags[(y0 + 3) * t1->stride + x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
1474                   (t1->flags[(y0 + 4) * t1->stride + x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG) & flags_mask))) {
1475                 if (!ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_RL))
1476                     continue;
1477                 runlen = ff_mqc_decode(&t1->mqc,
1478                                        t1->mqc.cx_states + MQC_CX_UNI);
1479                 runlen = (runlen << 1) | ff_mqc_decode(&t1->mqc,
1480                                                        t1->mqc.cx_states +
1481                                                        MQC_CX_UNI);
1482                 dec = 1;
1483             } else {
1484                 runlen = 0;
1485                 dec    = 0;
1486             }
1487
1488             for (y = y0 + runlen; y < y0 + 4 && y < height; y++) {
1489                 int flags_mask = -1;
1490                 if (vert_causal_ctx_csty_symbol && y == y0 + 3)
1491                     flags_mask &= ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE | JPEG2000_T1_SGN_S);
1492                 if (!dec) {
1493                     if (!(t1->flags[(y+1) * t1->stride + x+1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS))) {
1494                         dec = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ff_jpeg2000_getsigctxno(t1->flags[(y+1) * t1->stride + x+1] & flags_mask,
1495                                                                                              bandno));
1496                     }
1497                 }
1498                 if (dec) {
1499                     int xorbit;
1500                     int ctxno = ff_jpeg2000_getsgnctxno(t1->flags[(y + 1) * t1->stride + x + 1] & flags_mask,
1501                                                         &xorbit);
1502                     t1->data[(y) * t1->stride + x] = (ff_mqc_decode(&t1->mqc,
1503                                                     t1->mqc.cx_states + ctxno) ^
1504                                       xorbit)
1505                                      ? -mask : mask;
1506                     ff_jpeg2000_set_significance(t1, x, y, t1->data[(y) * t1->stride + x] < 0);
1507                 }
1508                 dec = 0;
1509                 t1->flags[(y + 1) * t1->stride + x + 1] &= ~JPEG2000_T1_VIS;
1510             }
1511         }
1512     }
1513     if (seg_symbols) {
1514         int val;
1515         val = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1516         val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1517         val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1518         val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1519         if (val != 0xa)
1520             av_log(s->avctx, AV_LOG_ERROR,
1521                    "Segmentation symbol value incorrect\n");
1522     }
1523 }
1524
1525 static int decode_cblk(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *codsty,
1526                        Jpeg2000T1Context *t1, Jpeg2000Cblk *cblk,
1527                        int width, int height, int bandpos)
1528 {
1529     int passno = cblk->npasses, pass_t = 2, bpno = cblk->nonzerobits - 1;
1530     int pass_cnt = 0;
1531     int vert_causal_ctx_csty_symbol = codsty->cblk_style & JPEG2000_CBLK_VSC;
1532     int term_cnt = 0;
1533     int coder_type;
1534
1535     av_assert0(width <= 1024U && height <= 1024U);
1536     av_assert0(width*height <= 4096);
1537
1538     memset(t1->data, 0, t1->stride * height * sizeof(*t1->data));
1539
1540     /* If code-block contains no compressed data: nothing to do. */
1541     if (!cblk->length)
1542         return 0;
1543
1544     memset(t1->flags, 0, t1->stride * (height + 2) * sizeof(*t1->flags));
1545
1546     cblk->data[cblk->length] = 0xff;
1547     cblk->data[cblk->length+1] = 0xff;
1548     ff_mqc_initdec(&t1->mqc, cblk->data, 0, 1);
1549
1550     while (passno--) {
1551         if (bpno < 0) {
1552             av_log(s->avctx, AV_LOG_ERROR, "bpno became negative\n");
1553             return AVERROR_INVALIDDATA;
1554         }
1555         switch(pass_t) {
1556         case 0:
1557             decode_sigpass(t1, width, height, bpno + 1, bandpos,
1558                            vert_causal_ctx_csty_symbol);
1559             break;
1560         case 1:
1561             decode_refpass(t1, width, height, bpno + 1, vert_causal_ctx_csty_symbol);
1562             break;
1563         case 2:
1564             av_assert2(!t1->mqc.raw);
1565             decode_clnpass(s, t1, width, height, bpno + 1, bandpos,
1566                            codsty->cblk_style & JPEG2000_CBLK_SEGSYM,
1567                            vert_causal_ctx_csty_symbol);
1568             break;
1569         }
1570         if (codsty->cblk_style & JPEG2000_CBLK_RESET) // XXX no testcase for just this
1571             ff_mqc_init_contexts(&t1->mqc);
1572
1573         if (passno && (coder_type = needs_termination(codsty->cblk_style, pass_cnt))) {
1574             if (term_cnt >= cblk->nb_terminations) {
1575                 av_log(s->avctx, AV_LOG_ERROR, "Missing needed termination \n");
1576                 return AVERROR_INVALIDDATA;
1577             }
1578             if (FFABS(cblk->data + cblk->data_start[term_cnt + 1] - 2 - t1->mqc.bp) > 0) {
1579                 av_log(s->avctx, AV_LOG_WARNING, "Mid mismatch %"PTRDIFF_SPECIFIER" in pass %d of %d\n",
1580                     cblk->data + cblk->data_start[term_cnt + 1] - 2 - t1->mqc.bp,
1581                     pass_cnt, cblk->npasses);
1582             }
1583
1584             ff_mqc_initdec(&t1->mqc, cblk->data + cblk->data_start[++term_cnt], coder_type == 2, 0);
1585         }
1586
1587         pass_t++;
1588         if (pass_t == 3) {
1589             bpno--;
1590             pass_t = 0;
1591         }
1592         pass_cnt ++;
1593     }
1594
1595     if (cblk->data + cblk->length - 2*(term_cnt < cblk->nb_terminations) != t1->mqc.bp) {
1596         av_log(s->avctx, AV_LOG_WARNING, "End mismatch %"PTRDIFF_SPECIFIER"\n",
1597                cblk->data + cblk->length - 2*(term_cnt < cblk->nb_terminations) - t1->mqc.bp);
1598     }
1599
1600     return 1;
1601 }
1602
1603 /* TODO: Verify dequantization for lossless case
1604  * comp->data can be float or int
1605  * band->stepsize can be float or int
1606  * depending on the type of DWT transformation.
1607  * see ISO/IEC 15444-1:2002 A.6.1 */
1608
1609 /* Float dequantization of a codeblock.*/
1610 static void dequantization_float(int x, int y, Jpeg2000Cblk *cblk,
1611                                  Jpeg2000Component *comp,
1612                                  Jpeg2000T1Context *t1, Jpeg2000Band *band)
1613 {
1614     int i, j;
1615     int w = cblk->coord[0][1] - cblk->coord[0][0];
1616     for (j = 0; j < (cblk->coord[1][1] - cblk->coord[1][0]); ++j) {
1617         float *datap = &comp->f_data[(comp->coord[0][1] - comp->coord[0][0]) * (y + j) + x];
1618         int *src = t1->data + j*t1->stride;
1619         for (i = 0; i < w; ++i)
1620             datap[i] = src[i] * band->f_stepsize;
1621     }
1622 }
1623
1624 /* Integer dequantization of a codeblock.*/
1625 static void dequantization_int(int x, int y, Jpeg2000Cblk *cblk,
1626                                Jpeg2000Component *comp,
1627                                Jpeg2000T1Context *t1, Jpeg2000Band *band)
1628 {
1629     int i, j;
1630     int w = cblk->coord[0][1] - cblk->coord[0][0];
1631     for (j = 0; j < (cblk->coord[1][1] - cblk->coord[1][0]); ++j) {
1632         int32_t *datap = &comp->i_data[(comp->coord[0][1] - comp->coord[0][0]) * (y + j) + x];
1633         int *src = t1->data + j*t1->stride;
1634         if (band->i_stepsize == 32768) {
1635             for (i = 0; i < w; ++i)
1636                 datap[i] = src[i] / 2;
1637         } else {
1638             // This should be VERY uncommon
1639             for (i = 0; i < w; ++i)
1640                 datap[i] = (src[i] * (int64_t)band->i_stepsize) / 65536;
1641         }
1642     }
1643 }
1644
1645 static void dequantization_int_97(int x, int y, Jpeg2000Cblk *cblk,
1646                                Jpeg2000Component *comp,
1647                                Jpeg2000T1Context *t1, Jpeg2000Band *band)
1648 {
1649     int i, j;
1650     int w = cblk->coord[0][1] - cblk->coord[0][0];
1651     for (j = 0; j < (cblk->coord[1][1] - cblk->coord[1][0]); ++j) {
1652         int32_t *datap = &comp->i_data[(comp->coord[0][1] - comp->coord[0][0]) * (y + j) + x];
1653         int *src = t1->data + j*t1->stride;
1654         for (i = 0; i < w; ++i)
1655             datap[i] = (src[i] * (int64_t)band->i_stepsize + (1<<15)) >> 16;
1656     }
1657 }
1658
1659 static inline void mct_decode(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
1660 {
1661     int i, csize = 1;
1662     void *src[3];
1663
1664     for (i = 1; i < 3; i++) {
1665         if (tile->codsty[0].transform != tile->codsty[i].transform) {
1666             av_log(s->avctx, AV_LOG_ERROR, "Transforms mismatch, MCT not supported\n");
1667             return;
1668         }
1669         if (memcmp(tile->comp[0].coord, tile->comp[i].coord, sizeof(tile->comp[0].coord))) {
1670             av_log(s->avctx, AV_LOG_ERROR, "Coords mismatch, MCT not supported\n");
1671             return;
1672         }
1673     }
1674
1675     for (i = 0; i < 3; i++)
1676         if (tile->codsty[0].transform == FF_DWT97)
1677             src[i] = tile->comp[i].f_data;
1678         else
1679             src[i] = tile->comp[i].i_data;
1680
1681     for (i = 0; i < 2; i++)
1682         csize *= tile->comp[0].coord[i][1] - tile->comp[0].coord[i][0];
1683
1684     s->dsp.mct_decode[tile->codsty[0].transform](src[0], src[1], src[2], csize);
1685 }
1686
1687 static inline void tile_codeblocks(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
1688 {
1689     Jpeg2000T1Context t1;
1690
1691     int compno, reslevelno, bandno;
1692
1693     /* Loop on tile components */
1694     for (compno = 0; compno < s->ncomponents; compno++) {
1695         Jpeg2000Component *comp     = tile->comp + compno;
1696         Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1697         int coded = 0;
1698
1699         t1.stride = (1<<codsty->log2_cblk_width) + 2;
1700
1701         /* Loop on resolution levels */
1702         for (reslevelno = 0; reslevelno < codsty->nreslevels2decode; reslevelno++) {
1703             Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1704             /* Loop on bands */
1705             for (bandno = 0; bandno < rlevel->nbands; bandno++) {
1706                 int nb_precincts, precno;
1707                 Jpeg2000Band *band = rlevel->band + bandno;
1708                 int cblkno = 0, bandpos;
1709
1710                 bandpos = bandno + (reslevelno > 0);
1711
1712                 if (band->coord[0][0] == band->coord[0][1] ||
1713                     band->coord[1][0] == band->coord[1][1])
1714                     continue;
1715
1716                 nb_precincts = rlevel->num_precincts_x * rlevel->num_precincts_y;
1717                 /* Loop on precincts */
1718                 for (precno = 0; precno < nb_precincts; precno++) {
1719                     Jpeg2000Prec *prec = band->prec + precno;
1720
1721                     /* Loop on codeblocks */
1722                     for (cblkno = 0;
1723                          cblkno < prec->nb_codeblocks_width * prec->nb_codeblocks_height;
1724                          cblkno++) {
1725                         int x, y;
1726                         Jpeg2000Cblk *cblk = prec->cblk + cblkno;
1727                         int ret = decode_cblk(s, codsty, &t1, cblk,
1728                                     cblk->coord[0][1] - cblk->coord[0][0],
1729                                     cblk->coord[1][1] - cblk->coord[1][0],
1730                                     bandpos);
1731                         if (ret)
1732                             coded = 1;
1733                         x = cblk->coord[0][0] - band->coord[0][0];
1734                         y = cblk->coord[1][0] - band->coord[1][0];
1735
1736                         if (codsty->transform == FF_DWT97)
1737                             dequantization_float(x, y, cblk, comp, &t1, band);
1738                         else if (codsty->transform == FF_DWT97_INT)
1739                             dequantization_int_97(x, y, cblk, comp, &t1, band);
1740                         else
1741                             dequantization_int(x, y, cblk, comp, &t1, band);
1742                    } /* end cblk */
1743                 } /*end prec */
1744             } /* end band */
1745         } /* end reslevel */
1746
1747         /* inverse DWT */
1748         if (coded)
1749             ff_dwt_decode(&comp->dwt, codsty->transform == FF_DWT97 ? (void*)comp->f_data : (void*)comp->i_data);
1750
1751     } /*end comp */
1752 }
1753
1754 #define WRITE_FRAME(D, PIXEL)                                                                     \
1755     static inline void write_frame_ ## D(Jpeg2000DecoderContext * s, Jpeg2000Tile * tile,         \
1756                                          AVFrame * picture, int precision)                        \
1757     {                                                                                             \
1758         const AVPixFmtDescriptor *pixdesc = av_pix_fmt_desc_get(s->avctx->pix_fmt);               \
1759         int planar    = !!(pixdesc->flags & AV_PIX_FMT_FLAG_PLANAR);                              \
1760         int pixelsize = planar ? 1 : pixdesc->nb_components;                                      \
1761                                                                                                   \
1762         int compno;                                                                               \
1763         int x, y;                                                                                 \
1764                                                                                                   \
1765         for (compno = 0; compno < s->ncomponents; compno++) {                                     \
1766             Jpeg2000Component *comp     = tile->comp + compno;                                    \
1767             Jpeg2000CodingStyle *codsty = tile->codsty + compno;                                  \
1768             PIXEL *line;                                                                          \
1769             float *datap     = comp->f_data;                                                      \
1770             int32_t *i_datap = comp->i_data;                                                      \
1771             int cbps         = s->cbps[compno];                                                   \
1772             int w            = tile->comp[compno].coord[0][1] - s->image_offset_x;                \
1773             int plane        = 0;                                                                 \
1774                                                                                                   \
1775             if (planar)                                                                           \
1776                 plane = s->cdef[compno] ? s->cdef[compno]-1 : (s->ncomponents-1);                 \
1777                                                                                                   \
1778             y    = tile->comp[compno].coord[1][0] - s->image_offset_y / s->cdy[compno];           \
1779             line = (PIXEL *)picture->data[plane] + y * (picture->linesize[plane] / sizeof(PIXEL));\
1780             for (; y < tile->comp[compno].coord[1][1] - s->image_offset_y; y++) {                 \
1781                 PIXEL *dst;                                                                       \
1782                                                                                                   \
1783                 x   = tile->comp[compno].coord[0][0] - s->image_offset_x / s->cdx[compno];        \
1784                 dst = line + x * pixelsize + compno*!planar;                                      \
1785                                                                                                   \
1786                 if (codsty->transform == FF_DWT97) {                                              \
1787                     for (; x < w; x++) {                                                          \
1788                         int val = lrintf(*datap) + (1 << (cbps - 1));                             \
1789                         /* DC level shift and clip see ISO 15444-1:2002 G.1.2 */                  \
1790                         val  = av_clip(val, 0, (1 << cbps) - 1);                                  \
1791                         *dst = val << (precision - cbps);                                         \
1792                         datap++;                                                                  \
1793                         dst += pixelsize;                                                         \
1794                     }                                                                             \
1795                 } else {                                                                          \
1796                     for (; x < w; x++) {                                                          \
1797                         int val = *i_datap + (1 << (cbps - 1));                                   \
1798                         /* DC level shift and clip see ISO 15444-1:2002 G.1.2 */                  \
1799                         val  = av_clip(val, 0, (1 << cbps) - 1);                                  \
1800                         *dst = val << (precision - cbps);                                         \
1801                         i_datap++;                                                                \
1802                         dst += pixelsize;                                                         \
1803                     }                                                                             \
1804                 }                                                                                 \
1805                 line += picture->linesize[plane] / sizeof(PIXEL);                                 \
1806             }                                                                                     \
1807         }                                                                                         \
1808                                                                                                   \
1809     }
1810
1811 WRITE_FRAME(8, uint8_t)
1812 WRITE_FRAME(16, uint16_t)
1813
1814 #undef WRITE_FRAME
1815
1816 static int jpeg2000_decode_tile(AVCodecContext *avctx, void *td,
1817                                 int jobnr, int threadnr)
1818 {
1819     Jpeg2000DecoderContext *s = avctx->priv_data;
1820     AVFrame *picture = td;
1821     Jpeg2000Tile *tile = s->tile + jobnr;
1822     int x;
1823
1824     tile_codeblocks(s, tile);
1825
1826     /* inverse MCT transformation */
1827     if (tile->codsty[0].mct)
1828         mct_decode(s, tile);
1829
1830     for (x = 0; x < s->ncomponents; x++) {
1831         if (s->cdef[x] < 0) {
1832             for (x = 0; x < s->ncomponents; x++) {
1833                 s->cdef[x] = x + 1;
1834             }
1835             if ((s->ncomponents & 1) == 0)
1836                 s->cdef[s->ncomponents-1] = 0;
1837             break;
1838         }
1839     }
1840
1841     if (s->precision <= 8) {
1842         write_frame_8(s, tile, picture, 8);
1843     } else {
1844         int precision = picture->format == AV_PIX_FMT_XYZ12 ||
1845                         picture->format == AV_PIX_FMT_RGB48 ||
1846                         picture->format == AV_PIX_FMT_RGBA64 ||
1847                         picture->format == AV_PIX_FMT_GRAY16 ? 16 : s->precision;
1848
1849         write_frame_16(s, tile, picture, precision);
1850     }
1851
1852     return 0;
1853 }
1854
1855 static void jpeg2000_dec_cleanup(Jpeg2000DecoderContext *s)
1856 {
1857     int tileno, compno;
1858     for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++) {
1859         if (s->tile[tileno].comp) {
1860             for (compno = 0; compno < s->ncomponents; compno++) {
1861                 Jpeg2000Component *comp     = s->tile[tileno].comp   + compno;
1862                 Jpeg2000CodingStyle *codsty = s->tile[tileno].codsty + compno;
1863
1864                 ff_jpeg2000_cleanup(comp, codsty);
1865             }
1866             av_freep(&s->tile[tileno].comp);
1867         }
1868     }
1869     av_freep(&s->tile);
1870     memset(s->codsty, 0, sizeof(s->codsty));
1871     memset(s->qntsty, 0, sizeof(s->qntsty));
1872     memset(s->properties, 0, sizeof(s->properties));
1873     memset(&s->poc  , 0, sizeof(s->poc));
1874     s->numXtiles = s->numYtiles = 0;
1875     s->ncomponents = 0;
1876 }
1877
1878 static int jpeg2000_read_main_headers(Jpeg2000DecoderContext *s)
1879 {
1880     Jpeg2000CodingStyle *codsty = s->codsty;
1881     Jpeg2000QuantStyle *qntsty  = s->qntsty;
1882     Jpeg2000POC         *poc    = &s->poc;
1883     uint8_t *properties         = s->properties;
1884
1885     for (;;) {
1886         int len, ret = 0;
1887         uint16_t marker;
1888         int oldpos;
1889
1890         if (bytestream2_get_bytes_left(&s->g) < 2) {
1891             av_log(s->avctx, AV_LOG_ERROR, "Missing EOC\n");
1892             break;
1893         }
1894
1895         marker = bytestream2_get_be16u(&s->g);
1896         oldpos = bytestream2_tell(&s->g);
1897
1898         if (marker == JPEG2000_SOD) {
1899             Jpeg2000Tile *tile;
1900             Jpeg2000TilePart *tp;
1901
1902             if (!s->tile) {
1903                 av_log(s->avctx, AV_LOG_ERROR, "Missing SIZ\n");
1904                 return AVERROR_INVALIDDATA;
1905             }
1906             if (s->curtileno < 0) {
1907                 av_log(s->avctx, AV_LOG_ERROR, "Missing SOT\n");
1908                 return AVERROR_INVALIDDATA;
1909             }
1910
1911             tile = s->tile + s->curtileno;
1912             tp = tile->tile_part + tile->tp_idx;
1913             if (tp->tp_end < s->g.buffer) {
1914                 av_log(s->avctx, AV_LOG_ERROR, "Invalid tpend\n");
1915                 return AVERROR_INVALIDDATA;
1916             }
1917             bytestream2_init(&tp->tpg, s->g.buffer, tp->tp_end - s->g.buffer);
1918             bytestream2_skip(&s->g, tp->tp_end - s->g.buffer);
1919
1920             continue;
1921         }
1922         if (marker == JPEG2000_EOC)
1923             break;
1924
1925         len = bytestream2_get_be16(&s->g);
1926         if (len < 2 || bytestream2_get_bytes_left(&s->g) < len - 2) {
1927             av_log(s->avctx, AV_LOG_ERROR, "Invalid len %d left=%d\n", len, bytestream2_get_bytes_left(&s->g));
1928             return AVERROR_INVALIDDATA;
1929         }
1930
1931         switch (marker) {
1932         case JPEG2000_SIZ:
1933             if (s->ncomponents) {
1934                 av_log(s->avctx, AV_LOG_ERROR, "Duplicate SIZ\n");
1935                 return AVERROR_INVALIDDATA;
1936             }
1937             ret = get_siz(s);
1938             if (!s->tile)
1939                 s->numXtiles = s->numYtiles = 0;
1940             break;
1941         case JPEG2000_COC:
1942             ret = get_coc(s, codsty, properties);
1943             break;
1944         case JPEG2000_COD:
1945             ret = get_cod(s, codsty, properties);
1946             break;
1947         case JPEG2000_QCC:
1948             ret = get_qcc(s, len, qntsty, properties);
1949             break;
1950         case JPEG2000_QCD:
1951             ret = get_qcd(s, len, qntsty, properties);
1952             break;
1953         case JPEG2000_POC:
1954             ret = get_poc(s, len, poc);
1955             break;
1956         case JPEG2000_SOT:
1957             if (!(ret = get_sot(s, len))) {
1958                 av_assert1(s->curtileno >= 0);
1959                 codsty = s->tile[s->curtileno].codsty;
1960                 qntsty = s->tile[s->curtileno].qntsty;
1961                 poc    = &s->tile[s->curtileno].poc;
1962                 properties = s->tile[s->curtileno].properties;
1963             }
1964             break;
1965         case JPEG2000_PLM:
1966             // the PLM marker is ignored
1967         case JPEG2000_COM:
1968             // the comment is ignored
1969             bytestream2_skip(&s->g, len - 2);
1970             break;
1971         case JPEG2000_TLM:
1972             // Tile-part lengths
1973             ret = get_tlm(s, len);
1974             break;
1975         case JPEG2000_PLT:
1976             // Packet length, tile-part header
1977             ret = get_plt(s, len);
1978             break;
1979         default:
1980             av_log(s->avctx, AV_LOG_ERROR,
1981                    "unsupported marker 0x%.4"PRIX16" at pos 0x%X\n",
1982                    marker, bytestream2_tell(&s->g) - 4);
1983             bytestream2_skip(&s->g, len - 2);
1984             break;
1985         }
1986         if (bytestream2_tell(&s->g) - oldpos != len || ret) {
1987             av_log(s->avctx, AV_LOG_ERROR,
1988                    "error during processing marker segment %.4"PRIx16"\n",
1989                    marker);
1990             return ret ? ret : -1;
1991         }
1992     }
1993     return 0;
1994 }
1995
1996 /* Read bit stream packets --> T2 operation. */
1997 static int jpeg2000_read_bitstream_packets(Jpeg2000DecoderContext *s)
1998 {
1999     int ret = 0;
2000     int tileno;
2001
2002     for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++) {
2003         Jpeg2000Tile *tile = s->tile + tileno;
2004
2005         if ((ret = init_tile(s, tileno)) < 0)
2006             return ret;
2007
2008         s->g = tile->tile_part[0].tpg;
2009         if ((ret = jpeg2000_decode_packets(s, tile)) < 0)
2010             return ret;
2011     }
2012
2013     return 0;
2014 }
2015
2016 static int jp2_find_codestream(Jpeg2000DecoderContext *s)
2017 {
2018     uint32_t atom_size, atom, atom_end;
2019     int search_range = 10;
2020
2021     while (search_range
2022            &&
2023            bytestream2_get_bytes_left(&s->g) >= 8) {
2024         atom_size = bytestream2_get_be32u(&s->g);
2025         atom      = bytestream2_get_be32u(&s->g);
2026         if (atom_size == 1) {
2027             if (bytestream2_get_be32u(&s->g)) {
2028                 avpriv_request_sample(s->avctx, "Huge atom");
2029                 return 0;
2030             }
2031             atom_size = bytestream2_get_be32u(&s->g);
2032             atom_end  = bytestream2_tell(&s->g) + atom_size - 16;
2033         } else {
2034             atom_end  = bytestream2_tell(&s->g) + atom_size -  8;
2035         }
2036
2037         if (atom == JP2_CODESTREAM)
2038             return 1;
2039
2040         if (bytestream2_get_bytes_left(&s->g) < atom_size || atom_end < atom_size)
2041             return 0;
2042
2043         if (atom == JP2_HEADER &&
2044                    atom_size >= 16) {
2045             uint32_t atom2_size, atom2, atom2_end;
2046             do {
2047                 atom2_size = bytestream2_get_be32u(&s->g);
2048                 atom2      = bytestream2_get_be32u(&s->g);
2049                 atom2_end  = bytestream2_tell(&s->g) + atom2_size - 8;
2050                 if (atom2_size < 8 || atom2_end > atom_end || atom2_end < atom2_size)
2051                     break;
2052                 atom2_size -= 8;
2053                 if (atom2 == JP2_CODESTREAM) {
2054                     return 1;
2055                 } else if (atom2 == MKBETAG('c','o','l','r') && atom2_size >= 7) {
2056                     int method = bytestream2_get_byteu(&s->g);
2057                     bytestream2_skipu(&s->g, 2);
2058                     if (method == 1) {
2059                         s->colour_space = bytestream2_get_be32u(&s->g);
2060                     }
2061                 } else if (atom2 == MKBETAG('p','c','l','r') && atom2_size >= 6) {
2062                     int i, size, colour_count, colour_channels, colour_depth[3];
2063                     colour_count = bytestream2_get_be16u(&s->g);
2064                     colour_channels = bytestream2_get_byteu(&s->g);
2065                     // FIXME: Do not ignore channel_sign
2066                     colour_depth[0] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1;
2067                     colour_depth[1] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1;
2068                     colour_depth[2] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1;
2069                     size = (colour_depth[0] + 7 >> 3) * colour_count +
2070                            (colour_depth[1] + 7 >> 3) * colour_count +
2071                            (colour_depth[2] + 7 >> 3) * colour_count;
2072                     if (colour_count > AVPALETTE_COUNT ||
2073                         colour_channels != 3 ||
2074                         colour_depth[0] > 16 ||
2075                         colour_depth[1] > 16 ||
2076                         colour_depth[2] > 16 ||
2077                         atom2_size < size) {
2078                         avpriv_request_sample(s->avctx, "Unknown palette");
2079                         bytestream2_seek(&s->g, atom2_end, SEEK_SET);
2080                         continue;
2081                     }
2082                     s->pal8 = 1;
2083                     for (i = 0; i < colour_count; i++) {
2084                         uint32_t r, g, b;
2085                         if (colour_depth[0] <= 8) {
2086                             r = bytestream2_get_byteu(&s->g) << 8 - colour_depth[0];
2087                             r |= r >> colour_depth[0];
2088                         } else {
2089                             r = bytestream2_get_be16u(&s->g) >> colour_depth[0] - 8;
2090                         }
2091                         if (colour_depth[1] <= 8) {
2092                             g = bytestream2_get_byteu(&s->g) << 8 - colour_depth[1];
2093                             g |= g >> colour_depth[1];
2094                         } else {
2095                             g = bytestream2_get_be16u(&s->g) >> colour_depth[1] - 8;
2096                         }
2097                         if (colour_depth[2] <= 8) {
2098                             b = bytestream2_get_byteu(&s->g) << 8 - colour_depth[2];
2099                             b |= b >> colour_depth[2];
2100                         } else {
2101                             b = bytestream2_get_be16u(&s->g) >> colour_depth[2] - 8;
2102                         }
2103                         s->palette[i] = 0xffu << 24 | r << 16 | g << 8 | b;
2104                     }
2105                 } else if (atom2 == MKBETAG('c','d','e','f') && atom2_size >= 2) {
2106                     int n = bytestream2_get_be16u(&s->g);
2107                     for (; n>0; n--) {
2108                         int cn   = bytestream2_get_be16(&s->g);
2109                         int av_unused typ  = bytestream2_get_be16(&s->g);
2110                         int asoc = bytestream2_get_be16(&s->g);
2111                         if (cn < 4 && asoc < 4)
2112                             s->cdef[cn] = asoc;
2113                     }
2114                 } else if (atom2 == MKBETAG('r','e','s',' ') && atom2_size >= 18) {
2115                     int64_t vnum, vden, hnum, hden, vexp, hexp;
2116                     uint32_t resx;
2117                     bytestream2_skip(&s->g, 4);
2118                     resx = bytestream2_get_be32u(&s->g);
2119                     if (resx != MKBETAG('r','e','s','c') && resx != MKBETAG('r','e','s','d')) {
2120                         bytestream2_seek(&s->g, atom2_end, SEEK_SET);
2121                         continue;
2122                     }
2123                     vnum = bytestream2_get_be16u(&s->g);
2124                     vden = bytestream2_get_be16u(&s->g);
2125                     hnum = bytestream2_get_be16u(&s->g);
2126                     hden = bytestream2_get_be16u(&s->g);
2127                     vexp = bytestream2_get_byteu(&s->g);
2128                     hexp = bytestream2_get_byteu(&s->g);
2129                     if (!vnum || !vden || !hnum || !hden) {
2130                         bytestream2_seek(&s->g, atom2_end, SEEK_SET);
2131                         av_log(s->avctx, AV_LOG_WARNING, "RES box invalid\n");
2132                         continue;
2133                     }
2134                     if (vexp > hexp) {
2135                         vexp -= hexp;
2136                         hexp = 0;
2137                     } else {
2138                         hexp -= vexp;
2139                         vexp = 0;
2140                     }
2141                     if (   INT64_MAX / (hnum * vden) > pow(10, hexp)
2142                         && INT64_MAX / (vnum * hden) > pow(10, vexp))
2143                         av_reduce(&s->sar.den, &s->sar.num,
2144                                   hnum * vden * pow(10, hexp),
2145                                   vnum * hden * pow(10, vexp),
2146                                   INT32_MAX);
2147                 }
2148                 bytestream2_seek(&s->g, atom2_end, SEEK_SET);
2149             } while (atom_end - atom2_end >= 8);
2150         } else {
2151             search_range--;
2152         }
2153         bytestream2_seek(&s->g, atom_end, SEEK_SET);
2154     }
2155
2156     return 0;
2157 }
2158
2159 static av_cold void jpeg2000_init_static_data(void)
2160 {
2161     ff_jpeg2000_init_tier1_luts();
2162     ff_mqc_init_context_tables();
2163 }
2164
2165 static av_cold int jpeg2000_decode_init(AVCodecContext *avctx)
2166 {
2167     static AVOnce init_static_once = AV_ONCE_INIT;
2168     Jpeg2000DecoderContext *s = avctx->priv_data;
2169
2170     ff_thread_once(&init_static_once, jpeg2000_init_static_data);
2171     ff_jpeg2000dsp_init(&s->dsp);
2172
2173     return 0;
2174 }
2175
2176 static int jpeg2000_decode_frame(AVCodecContext *avctx, void *data,
2177                                  int *got_frame, AVPacket *avpkt)
2178 {
2179     Jpeg2000DecoderContext *s = avctx->priv_data;
2180     ThreadFrame frame = { .f = data };
2181     AVFrame *picture = data;
2182     int ret;
2183
2184     s->avctx     = avctx;
2185     bytestream2_init(&s->g, avpkt->data, avpkt->size);
2186     s->curtileno = -1;
2187     memset(s->cdef, -1, sizeof(s->cdef));
2188
2189     if (bytestream2_get_bytes_left(&s->g) < 2) {
2190         ret = AVERROR_INVALIDDATA;
2191         goto end;
2192     }
2193
2194     // check if the image is in jp2 format
2195     if (bytestream2_get_bytes_left(&s->g) >= 12 &&
2196        (bytestream2_get_be32u(&s->g) == 12) &&
2197        (bytestream2_get_be32u(&s->g) == JP2_SIG_TYPE) &&
2198        (bytestream2_get_be32u(&s->g) == JP2_SIG_VALUE)) {
2199         if (!jp2_find_codestream(s)) {
2200             av_log(avctx, AV_LOG_ERROR,
2201                    "Could not find Jpeg2000 codestream atom.\n");
2202             ret = AVERROR_INVALIDDATA;
2203             goto end;
2204         }
2205     } else {
2206         bytestream2_seek(&s->g, 0, SEEK_SET);
2207     }
2208
2209     while (bytestream2_get_bytes_left(&s->g) >= 3 && bytestream2_peek_be16(&s->g) != JPEG2000_SOC)
2210         bytestream2_skip(&s->g, 1);
2211
2212     if (bytestream2_get_be16u(&s->g) != JPEG2000_SOC) {
2213         av_log(avctx, AV_LOG_ERROR, "SOC marker not present\n");
2214         ret = AVERROR_INVALIDDATA;
2215         goto end;
2216     }
2217     if (ret = jpeg2000_read_main_headers(s))
2218         goto end;
2219
2220     /* get picture buffer */
2221     if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
2222         goto end;
2223     picture->pict_type = AV_PICTURE_TYPE_I;
2224     picture->key_frame = 1;
2225
2226     if (ret = jpeg2000_read_bitstream_packets(s))
2227         goto end;
2228
2229     avctx->execute2(avctx, jpeg2000_decode_tile, picture, NULL, s->numXtiles * s->numYtiles);
2230
2231     jpeg2000_dec_cleanup(s);
2232
2233     *got_frame = 1;
2234
2235     if (s->avctx->pix_fmt == AV_PIX_FMT_PAL8)
2236         memcpy(picture->data[1], s->palette, 256 * sizeof(uint32_t));
2237     if (s->sar.num && s->sar.den)
2238         avctx->sample_aspect_ratio = s->sar;
2239     s->sar.num = s->sar.den = 0;
2240
2241     return bytestream2_tell(&s->g);
2242
2243 end:
2244     jpeg2000_dec_cleanup(s);
2245     return ret;
2246 }
2247
2248 #define OFFSET(x) offsetof(Jpeg2000DecoderContext, x)
2249 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
2250
2251 static const AVOption options[] = {
2252     { "lowres",  "Lower the decoding resolution by a power of two",
2253         OFFSET(reduction_factor), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, JPEG2000_MAX_RESLEVELS - 1, VD },
2254     { NULL },
2255 };
2256
2257 static const AVClass jpeg2000_class = {
2258     .class_name = "jpeg2000",
2259     .item_name  = av_default_item_name,
2260     .option     = options,
2261     .version    = LIBAVUTIL_VERSION_INT,
2262 };
2263
2264 AVCodec ff_jpeg2000_decoder = {
2265     .name             = "jpeg2000",
2266     .long_name        = NULL_IF_CONFIG_SMALL("JPEG 2000"),
2267     .type             = AVMEDIA_TYPE_VIDEO,
2268     .id               = AV_CODEC_ID_JPEG2000,
2269     .capabilities     = AV_CODEC_CAP_SLICE_THREADS | AV_CODEC_CAP_FRAME_THREADS | AV_CODEC_CAP_DR1,
2270     .priv_data_size   = sizeof(Jpeg2000DecoderContext),
2271     .init             = jpeg2000_decode_init,
2272     .decode           = jpeg2000_decode_frame,
2273     .priv_class       = &jpeg2000_class,
2274     .max_lowres       = 5,
2275     .profiles         = NULL_IF_CONFIG_SMALL(ff_jpeg2000_profiles)
2276 };