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