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