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