Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

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