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