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

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