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

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