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