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