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