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