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