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