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