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