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