FFmpeg
jpeg2000dec.c
Go to the documentation of this file.
1 /*
2  * JPEG 2000 image decoder
3  * Copyright (c) 2007 Kamil Nowosad
4  * Copyright (c) 2013 Nicolas Bertrand <nicoinattendu@gmail.com>
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22 
23 /**
24  * @file
25  * JPEG 2000 image decoder
26  */
27 
28 #include <inttypes.h>
29 #include <math.h>
30 
31 #include "libavutil/attributes.h"
32 #include "libavutil/avassert.h"
33 #include "libavutil/common.h"
34 #include "libavutil/imgutils.h"
35 #include "libavutil/opt.h"
36 #include "libavutil/pixdesc.h"
37 #include "avcodec.h"
38 #include "bytestream.h"
39 #include "codec_internal.h"
40 #include "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_calloc(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_calloc(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 
2085  tile_codeblocks(s, tile);
2086 
2087  /* inverse MCT transformation */
2088  if (tile->codsty[0].mct)
2089  mct_decode(s, tile);
2090 
2091  if (s->precision <= 8) {
2092  write_frame_8(s, tile, picture, 8);
2093  } else {
2094  int precision = picture->format == AV_PIX_FMT_XYZ12 ||
2095  picture->format == AV_PIX_FMT_RGB48 ||
2096  picture->format == AV_PIX_FMT_RGBA64 ||
2097  picture->format == AV_PIX_FMT_GRAY16 ? 16 : s->precision;
2098 
2099  write_frame_16(s, tile, picture, precision);
2100  }
2101 
2102  return 0;
2103 }
2104 
2105 static void jpeg2000_dec_cleanup(Jpeg2000DecoderContext *s)
2106 {
2107  int tileno, compno;
2108  for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++) {
2109  if (s->tile[tileno].comp) {
2110  for (compno = 0; compno < s->ncomponents; compno++) {
2111  Jpeg2000Component *comp = s->tile[tileno].comp + compno;
2112  Jpeg2000CodingStyle *codsty = s->tile[tileno].codsty + compno;
2113 
2114  ff_jpeg2000_cleanup(comp, codsty);
2115  }
2116  av_freep(&s->tile[tileno].comp);
2117  av_freep(&s->tile[tileno].packed_headers);
2118  s->tile[tileno].packed_headers_size = 0;
2119  }
2120  }
2121  av_freep(&s->packed_headers);
2122  s->packed_headers_size = 0;
2123  memset(&s->packed_headers_stream, 0, sizeof(s->packed_headers_stream));
2124  av_freep(&s->tile);
2125  memset(s->codsty, 0, sizeof(s->codsty));
2126  memset(s->qntsty, 0, sizeof(s->qntsty));
2127  memset(s->properties, 0, sizeof(s->properties));
2128  memset(&s->poc , 0, sizeof(s->poc));
2129  s->numXtiles = s->numYtiles = 0;
2130  s->ncomponents = 0;
2131 }
2132 
2133 static int jpeg2000_read_main_headers(Jpeg2000DecoderContext *s)
2134 {
2135  Jpeg2000CodingStyle *codsty = s->codsty;
2136  Jpeg2000QuantStyle *qntsty = s->qntsty;
2137  Jpeg2000POC *poc = &s->poc;
2138  uint8_t *properties = s->properties;
2139 
2140  for (;;) {
2141  int len, ret = 0;
2142  uint16_t marker;
2143  int oldpos;
2144 
2145  if (bytestream2_get_bytes_left(&s->g) < 2) {
2146  av_log(s->avctx, AV_LOG_ERROR, "Missing EOC\n");
2147  break;
2148  }
2149 
2150  marker = bytestream2_get_be16u(&s->g);
2151  oldpos = bytestream2_tell(&s->g);
2152  if (marker >= 0xFF30 && marker <= 0xFF3F)
2153  continue;
2154  if (marker == JPEG2000_SOD) {
2155  Jpeg2000Tile *tile;
2156  Jpeg2000TilePart *tp;
2157 
2158  if (!s->tile) {
2159  av_log(s->avctx, AV_LOG_ERROR, "Missing SIZ\n");
2160  return AVERROR_INVALIDDATA;
2161  }
2162  if (s->curtileno < 0) {
2163  av_log(s->avctx, AV_LOG_ERROR, "Missing SOT\n");
2164  return AVERROR_INVALIDDATA;
2165  }
2166 
2167  tile = s->tile + s->curtileno;
2168  tp = tile->tile_part + tile->tp_idx;
2169  if (tp->tp_end < s->g.buffer) {
2170  av_log(s->avctx, AV_LOG_ERROR, "Invalid tpend\n");
2171  return AVERROR_INVALIDDATA;
2172  }
2173 
2174  if (s->has_ppm) {
2175  uint32_t tp_header_size = bytestream2_get_be32(&s->packed_headers_stream);
2176  if (bytestream2_get_bytes_left(&s->packed_headers_stream) < tp_header_size)
2177  return AVERROR_INVALIDDATA;
2178  bytestream2_init(&tp->header_tpg, s->packed_headers_stream.buffer, tp_header_size);
2179  bytestream2_skip(&s->packed_headers_stream, tp_header_size);
2180  }
2181  if (tile->has_ppt && tile->tp_idx == 0) {
2182  bytestream2_init(&tile->packed_headers_stream, tile->packed_headers, tile->packed_headers_size);
2183  }
2184 
2185  bytestream2_init(&tp->tpg, s->g.buffer, tp->tp_end - s->g.buffer);
2186  bytestream2_skip(&s->g, tp->tp_end - s->g.buffer);
2187 
2188  continue;
2189  }
2190  if (marker == JPEG2000_EOC)
2191  break;
2192 
2193  len = bytestream2_get_be16(&s->g);
2194  if (len < 2 || bytestream2_get_bytes_left(&s->g) < len - 2) {
2195  if (s->avctx->strict_std_compliance >= FF_COMPLIANCE_STRICT) {
2196  av_log(s->avctx, AV_LOG_ERROR, "Invalid len %d left=%d\n", len, bytestream2_get_bytes_left(&s->g));
2197  return AVERROR_INVALIDDATA;
2198  }
2199  av_log(s->avctx, AV_LOG_WARNING, "Missing EOC Marker.\n");
2200  break;
2201  }
2202 
2203  switch (marker) {
2204  case JPEG2000_SIZ:
2205  if (s->ncomponents) {
2206  av_log(s->avctx, AV_LOG_ERROR, "Duplicate SIZ\n");
2207  return AVERROR_INVALIDDATA;
2208  }
2209  ret = get_siz(s);
2210  if (!s->tile)
2211  s->numXtiles = s->numYtiles = 0;
2212  break;
2213  case JPEG2000_COC:
2214  ret = get_coc(s, codsty, properties);
2215  break;
2216  case JPEG2000_COD:
2217  ret = get_cod(s, codsty, properties);
2218  break;
2219  case JPEG2000_RGN:
2220  ret = get_rgn(s, len);
2221  break;
2222  case JPEG2000_QCC:
2223  ret = get_qcc(s, len, qntsty, properties);
2224  break;
2225  case JPEG2000_QCD:
2226  ret = get_qcd(s, len, qntsty, properties);
2227  break;
2228  case JPEG2000_POC:
2229  ret = get_poc(s, len, poc);
2230  break;
2231  case JPEG2000_SOT:
2232  if (!s->in_tile_headers) {
2233  s->in_tile_headers = 1;
2234  if (s->has_ppm) {
2235  bytestream2_init(&s->packed_headers_stream, s->packed_headers, s->packed_headers_size);
2236  }
2237  }
2238  if (!(ret = get_sot(s, len))) {
2239  av_assert1(s->curtileno >= 0);
2240  codsty = s->tile[s->curtileno].codsty;
2241  qntsty = s->tile[s->curtileno].qntsty;
2242  poc = &s->tile[s->curtileno].poc;
2243  properties = s->tile[s->curtileno].properties;
2244  }
2245  break;
2246  case JPEG2000_PLM:
2247  // the PLM marker is ignored
2248  case JPEG2000_COM:
2249  // the comment is ignored
2250  bytestream2_skip(&s->g, len - 2);
2251  break;
2252  case JPEG2000_CRG:
2253  ret = read_crg(s, len);
2254  break;
2255  case JPEG2000_TLM:
2256  // Tile-part lengths
2257  ret = get_tlm(s, len);
2258  break;
2259  case JPEG2000_PLT:
2260  // Packet length, tile-part header
2261  ret = get_plt(s, len);
2262  break;
2263  case JPEG2000_PPM:
2264  // Packed headers, main header
2265  if (s->in_tile_headers) {
2266  av_log(s->avctx, AV_LOG_ERROR, "PPM Marker can only be in Main header\n");
2267  return AVERROR_INVALIDDATA;
2268  }
2269  ret = get_ppm(s, len);
2270  break;
2271  case JPEG2000_PPT:
2272  // Packed headers, tile-part header
2273  if (s->has_ppm) {
2274  av_log(s->avctx, AV_LOG_ERROR,
2275  "Cannot have both PPT and PPM marker.\n");
2276  return AVERROR_INVALIDDATA;
2277  }
2278 
2279  ret = get_ppt(s, len);
2280  break;
2281  default:
2282  av_log(s->avctx, AV_LOG_ERROR,
2283  "unsupported marker 0x%.4"PRIX16" at pos 0x%X\n",
2284  marker, bytestream2_tell(&s->g) - 4);
2285  bytestream2_skip(&s->g, len - 2);
2286  break;
2287  }
2288  if (bytestream2_tell(&s->g) - oldpos != len || ret) {
2289  av_log(s->avctx, AV_LOG_ERROR,
2290  "error during processing marker segment %.4"PRIx16"\n",
2291  marker);
2292  return ret ? ret : -1;
2293  }
2294  }
2295  return 0;
2296 }
2297 
2298 /* Read bit stream packets --> T2 operation. */
2299 static int jpeg2000_read_bitstream_packets(Jpeg2000DecoderContext *s)
2300 {
2301  int ret = 0;
2302  int tileno;
2303 
2304  for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++) {
2305  Jpeg2000Tile *tile = s->tile + tileno;
2306 
2307  if ((ret = init_tile(s, tileno)) < 0)
2308  return ret;
2309 
2310  if ((ret = jpeg2000_decode_packets(s, tile)) < 0)
2311  return ret;
2312  }
2313 
2314  return 0;
2315 }
2316 
2317 static int jp2_find_codestream(Jpeg2000DecoderContext *s)
2318 {
2319  uint32_t atom_size, atom, atom_end;
2320  int search_range = 10;
2321 
2322  while (search_range
2323  &&
2324  bytestream2_get_bytes_left(&s->g) >= 8) {
2325  atom_size = bytestream2_get_be32u(&s->g);
2326  atom = bytestream2_get_be32u(&s->g);
2327  if (atom_size == 1) {
2328  if (bytestream2_get_be32u(&s->g)) {
2329  avpriv_request_sample(s->avctx, "Huge atom");
2330  return 0;
2331  }
2332  atom_size = bytestream2_get_be32u(&s->g);
2333  if (atom_size < 16 || (int64_t)bytestream2_tell(&s->g) + atom_size - 16 > INT_MAX)
2334  return AVERROR_INVALIDDATA;
2335  atom_end = bytestream2_tell(&s->g) + atom_size - 16;
2336  } else {
2337  if (atom_size < 8 || (int64_t)bytestream2_tell(&s->g) + atom_size - 8 > INT_MAX)
2338  return AVERROR_INVALIDDATA;
2339  atom_end = bytestream2_tell(&s->g) + atom_size - 8;
2340  }
2341 
2342  if (atom == JP2_CODESTREAM)
2343  return 1;
2344 
2345  if (bytestream2_get_bytes_left(&s->g) < atom_size || atom_end < atom_size)
2346  return 0;
2347 
2348  if (atom == JP2_HEADER &&
2349  atom_size >= 16) {
2350  uint32_t atom2_size, atom2, atom2_end;
2351  do {
2352  if (bytestream2_get_bytes_left(&s->g) < 8)
2353  break;
2354  atom2_size = bytestream2_get_be32u(&s->g);
2355  atom2 = bytestream2_get_be32u(&s->g);
2356  atom2_end = bytestream2_tell(&s->g) + atom2_size - 8;
2357  if (atom2_size < 8 || atom2_end > atom_end || atom2_end < atom2_size)
2358  break;
2359  atom2_size -= 8;
2360  if (atom2 == JP2_CODESTREAM) {
2361  return 1;
2362  } else if (atom2 == MKBETAG('c','o','l','r') && atom2_size >= 7) {
2363  int method = bytestream2_get_byteu(&s->g);
2364  bytestream2_skipu(&s->g, 2);
2365  if (method == 1) {
2366  s->colour_space = bytestream2_get_be32u(&s->g);
2367  }
2368  } else if (atom2 == MKBETAG('p','c','l','r') && atom2_size >= 6) {
2369  int i, size, colour_count, colour_channels, colour_depth[3];
2370  colour_count = bytestream2_get_be16u(&s->g);
2371  colour_channels = bytestream2_get_byteu(&s->g);
2372  // FIXME: Do not ignore channel_sign
2373  colour_depth[0] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1;
2374  colour_depth[1] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1;
2375  colour_depth[2] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1;
2376  size = (colour_depth[0] + 7 >> 3) * colour_count +
2377  (colour_depth[1] + 7 >> 3) * colour_count +
2378  (colour_depth[2] + 7 >> 3) * colour_count;
2379  if (colour_count > AVPALETTE_COUNT ||
2380  colour_channels != 3 ||
2381  colour_depth[0] > 16 ||
2382  colour_depth[1] > 16 ||
2383  colour_depth[2] > 16 ||
2384  atom2_size < size) {
2385  avpriv_request_sample(s->avctx, "Unknown palette");
2386  bytestream2_seek(&s->g, atom2_end, SEEK_SET);
2387  continue;
2388  }
2389  s->pal8 = 1;
2390  for (i = 0; i < colour_count; i++) {
2391  uint32_t r, g, b;
2392  if (colour_depth[0] <= 8) {
2393  r = bytestream2_get_byteu(&s->g) << 8 - colour_depth[0];
2394  r |= r >> colour_depth[0];
2395  } else {
2396  r = bytestream2_get_be16u(&s->g) >> colour_depth[0] - 8;
2397  }
2398  if (colour_depth[1] <= 8) {
2399  g = bytestream2_get_byteu(&s->g) << 8 - colour_depth[1];
2400  g |= g >> colour_depth[1];
2401  } else {
2402  g = bytestream2_get_be16u(&s->g) >> colour_depth[1] - 8;
2403  }
2404  if (colour_depth[2] <= 8) {
2405  b = bytestream2_get_byteu(&s->g) << 8 - colour_depth[2];
2406  b |= b >> colour_depth[2];
2407  } else {
2408  b = bytestream2_get_be16u(&s->g) >> colour_depth[2] - 8;
2409  }
2410  s->palette[i] = 0xffu << 24 | r << 16 | g << 8 | b;
2411  }
2412  } else if (atom2 == MKBETAG('c','d','e','f') && atom2_size >= 2) {
2413  int n = bytestream2_get_be16u(&s->g);
2414  for (; n>0; n--) {
2415  int cn = bytestream2_get_be16(&s->g);
2416  int av_unused typ = bytestream2_get_be16(&s->g);
2417  int asoc = bytestream2_get_be16(&s->g);
2418  if (cn < 4 && asoc < 4)
2419  s->cdef[cn] = asoc;
2420  }
2421  } else if (atom2 == MKBETAG('r','e','s',' ') && atom2_size >= 18) {
2422  int64_t vnum, vden, hnum, hden, vexp, hexp;
2423  uint32_t resx;
2424  bytestream2_skip(&s->g, 4);
2425  resx = bytestream2_get_be32u(&s->g);
2426  if (resx != MKBETAG('r','e','s','c') && resx != MKBETAG('r','e','s','d')) {
2427  bytestream2_seek(&s->g, atom2_end, SEEK_SET);
2428  continue;
2429  }
2430  vnum = bytestream2_get_be16u(&s->g);
2431  vden = bytestream2_get_be16u(&s->g);
2432  hnum = bytestream2_get_be16u(&s->g);
2433  hden = bytestream2_get_be16u(&s->g);
2434  vexp = bytestream2_get_byteu(&s->g);
2435  hexp = bytestream2_get_byteu(&s->g);
2436  if (!vnum || !vden || !hnum || !hden) {
2437  bytestream2_seek(&s->g, atom2_end, SEEK_SET);
2438  av_log(s->avctx, AV_LOG_WARNING, "RES box invalid\n");
2439  continue;
2440  }
2441  if (vexp > hexp) {
2442  vexp -= hexp;
2443  hexp = 0;
2444  } else {
2445  hexp -= vexp;
2446  vexp = 0;
2447  }
2448  if ( INT64_MAX / (hnum * vden) > pow(10, hexp)
2449  && INT64_MAX / (vnum * hden) > pow(10, vexp))
2450  av_reduce(&s->sar.den, &s->sar.num,
2451  hnum * vden * pow(10, hexp),
2452  vnum * hden * pow(10, vexp),
2453  INT32_MAX);
2454  }
2455  bytestream2_seek(&s->g, atom2_end, SEEK_SET);
2456  } while (atom_end - atom2_end >= 8);
2457  } else {
2458  search_range--;
2459  }
2460  bytestream2_seek(&s->g, atom_end, SEEK_SET);
2461  }
2462 
2463  return 0;
2464 }
2465 
2466 static av_cold int jpeg2000_decode_init(AVCodecContext *avctx)
2467 {
2468  Jpeg2000DecoderContext *s = avctx->priv_data;
2469 
2470  ff_jpeg2000dsp_init(&s->dsp);
2471  ff_jpeg2000_init_tier1_luts();
2472 
2473  return 0;
2474 }
2475 
2476 static int jpeg2000_decode_frame(AVCodecContext *avctx, AVFrame *picture,
2477  int *got_frame, AVPacket *avpkt)
2478 {
2479  Jpeg2000DecoderContext *s = avctx->priv_data;
2480  int ret;
2481 
2482  s->avctx = avctx;
2483  bytestream2_init(&s->g, avpkt->data, avpkt->size);
2484  s->curtileno = -1;
2485  memset(s->cdef, -1, sizeof(s->cdef));
2486 
2487  if (bytestream2_get_bytes_left(&s->g) < 2) {
2488  ret = AVERROR_INVALIDDATA;
2489  goto end;
2490  }
2491 
2492  // check if the image is in jp2 format
2493  if (bytestream2_get_bytes_left(&s->g) >= 12 &&
2494  (bytestream2_get_be32u(&s->g) == 12) &&
2495  (bytestream2_get_be32u(&s->g) == JP2_SIG_TYPE) &&
2496  (bytestream2_get_be32u(&s->g) == JP2_SIG_VALUE)) {
2497  if (!jp2_find_codestream(s)) {
2498  av_log(avctx, AV_LOG_ERROR,
2499  "Could not find Jpeg2000 codestream atom.\n");
2500  ret = AVERROR_INVALIDDATA;
2501  goto end;
2502  }
2503  } else {
2504  bytestream2_seek(&s->g, 0, SEEK_SET);
2505  }
2506 
2507  while (bytestream2_get_bytes_left(&s->g) >= 3 && bytestream2_peek_be16(&s->g) != JPEG2000_SOC)
2508  bytestream2_skip(&s->g, 1);
2509 
2510  if (bytestream2_get_be16u(&s->g) != JPEG2000_SOC) {
2511  av_log(avctx, AV_LOG_ERROR, "SOC marker not present\n");
2512  ret = AVERROR_INVALIDDATA;
2513  goto end;
2514  }
2515  if (ret = jpeg2000_read_main_headers(s))
2516  goto end;
2517 
2518  /* get picture buffer */
2519  if ((ret = ff_thread_get_buffer(avctx, picture, 0)) < 0)
2520  goto end;
2521  picture->pict_type = AV_PICTURE_TYPE_I;
2522  picture->key_frame = 1;
2523 
2524  if (ret = jpeg2000_read_bitstream_packets(s))
2525  goto end;
2526 
2527  for (int x = 0; x < s->ncomponents; x++) {
2528  if (s->cdef[x] < 0) {
2529  for (x = 0; x < s->ncomponents; x++) {
2530  s->cdef[x] = x + 1;
2531  }
2532  if ((s->ncomponents & 1) == 0)
2533  s->cdef[s->ncomponents-1] = 0;
2534  break;
2535  }
2536  }
2537 
2538  avctx->execute2(avctx, jpeg2000_decode_tile, picture, NULL, s->numXtiles * s->numYtiles);
2539 
2540  jpeg2000_dec_cleanup(s);
2541 
2542  *got_frame = 1;
2543 
2544  if (s->avctx->pix_fmt == AV_PIX_FMT_PAL8)
2545  memcpy(picture->data[1], s->palette, 256 * sizeof(uint32_t));
2546  if (s->sar.num && s->sar.den)
2547  avctx->sample_aspect_ratio = s->sar;
2548  s->sar.num = s->sar.den = 0;
2549 
2550  return bytestream2_tell(&s->g);
2551 
2552 end:
2553  jpeg2000_dec_cleanup(s);
2554  return ret;
2555 }
2556 
2557 #define OFFSET(x) offsetof(Jpeg2000DecoderContext, x)
2558 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
2559 
2560 static const AVOption options[] = {
2561  { "lowres", "Lower the decoding resolution by a power of two",
2562  OFFSET(reduction_factor), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, JPEG2000_MAX_RESLEVELS - 1, VD },
2563  { NULL },
2564 };
2565 
2566 static const AVClass jpeg2000_class = {
2567  .class_name = "jpeg2000",
2568  .item_name = av_default_item_name,
2569  .option = options,
2570  .version = LIBAVUTIL_VERSION_INT,
2571 };
2572 
2573 const FFCodec ff_jpeg2000_decoder = {
2574  .p.name = "jpeg2000",
2575  .p.long_name = NULL_IF_CONFIG_SMALL("JPEG 2000"),
2576  .p.type = AVMEDIA_TYPE_VIDEO,
2577  .p.id = AV_CODEC_ID_JPEG2000,
2578  .p.capabilities = AV_CODEC_CAP_SLICE_THREADS | AV_CODEC_CAP_FRAME_THREADS | AV_CODEC_CAP_DR1,
2579  .priv_data_size = sizeof(Jpeg2000DecoderContext),
2580  .init = jpeg2000_decode_init,
2581  FF_CODEC_DECODE_CB(jpeg2000_decode_frame),
2582  .p.priv_class = &jpeg2000_class,
2583  .p.max_lowres = 5,
2584  .p.profiles = NULL_IF_CONFIG_SMALL(ff_jpeg2000_profiles),
2585  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,
2586 };
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
Jpeg2000POCEntry::CEpoc
uint16_t CEpoc
Definition: jpeg2000dec.c:59
td
#define td
Definition: regdef.h:70
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
options
static const AVOption options[]
Definition: jpeg2000dec.c:2560
Jpeg2000Cblk::nb_terminationsinc
int nb_terminationsinc
Definition: jpeg2000.h:185
av_clip
#define av_clip
Definition: common.h:95
Jpeg2000DecoderContext::packed_headers_size
int packed_headers_size
Definition: jpeg2000dec.c:109
ff_dwt_decode
int ff_dwt_decode(DWTContext *s, void *t)
Definition: jpeg2000dwt.c:598
Jpeg2000DecoderContext::palette
uint32_t palette[256]
Definition: jpeg2000dec.c:117
r
const char * r
Definition: vf_curves.c:116
JPEG2000_POC
@ JPEG2000_POC
Definition: jpeg2000.h:49
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
opt.h
HAD_COC
#define HAD_COC
Definition: jpeg2000dec.c:51
AV_PIX_FMT_YA8
@ AV_PIX_FMT_YA8
8 bits gray, 8 bits alpha
Definition: pixfmt.h:133
JP2_HEADER
#define JP2_HEADER
Definition: jpeg2000dec.c:49
Jpeg2000QuantStyle::quantsty
uint8_t quantsty
Definition: jpeg2000.h:154
Jpeg2000Prec::decoded_layers
int decoded_layers
Definition: jpeg2000.h:198
JPEG2000_EOC
@ JPEG2000_EOC
Definition: jpeg2000.h:58
Jpeg2000POC::is_default
int is_default
Definition: jpeg2000dec.c:68
comp
static void comp(unsigned char *dst, ptrdiff_t dst_stride, unsigned char *src, ptrdiff_t src_stride, int add)
Definition: eamad.c:86
GetByteContext
Definition: bytestream.h:33
JPEG2000_MAX_RESLEVELS
#define JPEG2000_MAX_RESLEVELS
Definition: jpeg2000.h:71
u
#define u(width, name, range_min, range_max)
Definition: cbs_h2645.c:262
ff_jpeg2000_init_component
int ff_jpeg2000_init_component(Jpeg2000Component *comp, Jpeg2000CodingStyle *codsty, Jpeg2000QuantStyle *qntsty, int cbps, int dx, int dy, AVCodecContext *avctx)
Definition: jpeg2000.c:466
JPEG2000_QSTY_NONE
@ JPEG2000_QSTY_NONE
Definition: jpeg2000.h:65
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2662
Jpeg2000CodingStyle::prog_order
uint8_t prog_order
Definition: jpeg2000.h:145
JPEG2000_QCD
@ JPEG2000_QCD
Definition: jpeg2000.h:46
Jpeg2000Prec::nb_codeblocks_height
int nb_codeblocks_height
Definition: jpeg2000.h:194
Jpeg2000Cblk::coord
int coord[2][2]
Definition: jpeg2000.h:189
Jpeg2000CodingStyle::mct
uint8_t mct
Definition: jpeg2000.h:143
bytestream2_skipu
static av_always_inline void bytestream2_skipu(GetByteContext *g, unsigned int size)
Definition: bytestream.h:174
av_unused
#define av_unused
Definition: attributes.h:131
Jpeg2000Band::i_stepsize
int i_stepsize
Definition: jpeg2000.h:205
needs_termination
static int needs_termination(int style, int passno)
Definition: jpeg2000.h:287
Jpeg2000Cblk::nb_lengthinc
uint8_t nb_lengthinc
Definition: jpeg2000.h:180
decode_refpass
static void decode_refpass(Jpeg2000T1Context *t1, int width, int height, int bpno, int vert_causal_ctx_csty_symbol)
Definition: jpeg2000dec.c:1658
bytestream2_seek
static av_always_inline int bytestream2_seek(GetByteContext *g, int offset, int whence)
Definition: bytestream.h:212
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:325
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
YUV_PIXEL_FORMATS
#define YUV_PIXEL_FORMATS
Definition: jpeg2000dec.c:247
pixdesc.h
w
uint8_t w
Definition: llviddspenc.c:38
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:374
Jpeg2000Prec::zerobits
Jpeg2000TgtNode * zerobits
Definition: jpeg2000.h:195
AVOption
AVOption.
Definition: opt.h:251
Jpeg2000POCEntry::REpoc
uint8_t REpoc
Definition: jpeg2000dec.c:61
JPEG2000_SOD
@ JPEG2000_SOD
Definition: jpeg2000.h:57
b
#define b
Definition: input.c:34
JPEG2000_SOC
@ JPEG2000_SOC
Definition: jpeg2000.h:39
JPEG2000_CSTY_PREC
#define JPEG2000_CSTY_PREC
Definition: jpeg2000.h:110
getlblockinc
static int getlblockinc(Jpeg2000DecoderContext *s)
Definition: jpeg2000dec.c:1063
JPEG2000_PPM
@ JPEG2000_PPM
Definition: jpeg2000.h:50
Jpeg2000DecoderContext::width
int width
Definition: jpeg2000dec.c:100
ff_jpeg2000_ceildiv
static int ff_jpeg2000_ceildiv(int a, int64_t b)
Definition: jpeg2000.h:234
FFCodec
Definition: codec_internal.h:112
ff_jpeg2000_profiles
const AVProfile ff_jpeg2000_profiles[]
Definition: profiles.c:91
Jpeg2000Prec
Definition: jpeg2000.h:192
Jpeg2000DecoderContext::tile_width
int tile_width
Definition: jpeg2000dec.c:120
Jpeg2000DecoderContext::curtileno
int curtileno
Definition: jpeg2000dec.c:132
JPEG2000_SOT
@ JPEG2000_SOT
Definition: jpeg2000.h:54
Jpeg2000POCEntry
Definition: jpeg2000dec.c:56
Jpeg2000TgtNode::parent
struct Jpeg2000TgtNode * parent
Definition: jpeg2000.h:132
Jpeg2000Band
Definition: jpeg2000.h:202
t1
#define t1
Definition: regdef.h:29
FF_DWT97
@ FF_DWT97
Definition: jpeg2000dwt.h:37
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
Jpeg2000DecoderContext::numXtiles
unsigned numXtiles
Definition: jpeg2000dec.c:121
jpeg2000_decode_tile
static int jpeg2000_decode_tile(AVCodecContext *avctx, void *td, int jobnr, int threadnr)
Definition: jpeg2000dec.c:2078
JPEG2000_CSTY_SOP
#define JPEG2000_CSTY_SOP
Definition: jpeg2000.h:111
Jpeg2000POCEntry::CSpoc
uint16_t CSpoc
Definition: jpeg2000dec.c:58
Jpeg2000Tile
Definition: j2kenc.c:106
ff_jpeg2000_getrefctxno
static int ff_jpeg2000_getrefctxno(int flag)
Definition: jpeg2000.h:262
thread.h
getnpasses
static int getnpasses(Jpeg2000DecoderContext *s)
Definition: jpeg2000dec.c:1048
Jpeg2000Tile::packed_headers
uint8_t * packed_headers
Definition: jpeg2000dec.c:88
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:346
Jpeg2000DecoderContext::in_tile_headers
uint8_t in_tile_headers
Definition: jpeg2000dec.c:111
select_header
static void select_header(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile, int *tp_index)
Definition: jpeg2000dec.c:1074
Jpeg2000CodingStyle::init
uint8_t init
Definition: jpeg2000.h:148
init
static int init
Definition: av_tx.c:47
jpeg2000_read_main_headers
static int jpeg2000_read_main_headers(Jpeg2000DecoderContext *s)
Definition: jpeg2000dec.c:2133
bytestream2_skip
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
Definition: bytestream.h:168
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:116
Jpeg2000CodingStyle::log2_cblk_width
uint8_t log2_cblk_width
Definition: jpeg2000.h:138
tile_codeblocks
static void tile_codeblocks(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
Definition: jpeg2000dec.c:1940
Jpeg2000DecoderContext::cdef
int cdef[4]
Definition: jpeg2000dec.c:119
U
#define U(x)
Definition: vp56_arith.h:37
Jpeg2000DecoderContext::sgnd
uint8_t sgnd[4]
Definition: jpeg2000dec.c:104
ff_mqc_initdec
void ff_mqc_initdec(MqcState *mqc, uint8_t *bp, int raw, int reset)
Initialize MQ-decoder.
Definition: mqcdec.c:71
Jpeg2000DecoderContext::image_offset_x
int image_offset_x
Definition: jpeg2000dec.c:101
ff_thread_get_buffer
the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across will not work because their bitstreams cannot be decoded in parallel *The contents of buffers must not be read before as well as code calling up to before the decode process starts Call have so the codec calls ff_thread_report set FF_CODEC_CAP_ALLOCATE_PROGRESS in AVCodec caps_internal and use ff_thread_get_buffer() to allocate frames. The frames must then be freed with ff_thread_release_buffer(). Otherwise decode directly into the user-supplied frames. Call ff_thread_report_progress() after some part of the current picture has decoded. A good place to put this is where draw_horiz_band() is called - add this if it isn 't called anywhere
get_poc
static int get_poc(Jpeg2000DecoderContext *s, int size, Jpeg2000POC *p)
Definition: jpeg2000dec.c:747
Jpeg2000DecoderContext::maxtilelen
int maxtilelen
Definition: jpeg2000dec.c:122
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
Jpeg2000DecoderContext::g
GetByteContext g
Definition: jpeg2000dec.c:98
AVFrame::key_frame
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:417
Jpeg2000DecoderContext::precision
int precision
Definition: jpeg2000dec.c:114
Jpeg2000DecoderContext::cdx
int cdx[4]
Definition: jpeg2000dec.c:113
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
val
static double val(void *priv, double ch)
Definition: aeval.c:77
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
MQC_CX_UNI
#define MQC_CX_UNI
Definition: mqc.h:33
AV_PIX_FMT_GRAY16
#define AV_PIX_FMT_GRAY16
Definition: pixfmt.h:390
av_reduce
int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max)
Reduce a fraction.
Definition: rational.c:35
Jpeg2000DecoderContext::poc
Jpeg2000POC poc
Definition: jpeg2000dec.c:127
Jpeg2000T1Context
Definition: jpeg2000.h:121
jpeg2000_read_bitstream_packets
static int jpeg2000_read_bitstream_packets(Jpeg2000DecoderContext *s)
Definition: jpeg2000dec.c:2299
av_image_check_size2
int av_image_check_size2(unsigned int w, unsigned int h, int64_t max_pixels, enum AVPixelFormat pix_fmt, int log_offset, void *log_ctx)
Check if the given dimension of an image is valid, meaning that all bytes of a plane of an image with...
Definition: imgutils.c:289
jpeg2000_class
static const AVClass jpeg2000_class
Definition: jpeg2000dec.c:2566
Jpeg2000DecoderContext::reduction_factor
int reduction_factor
Definition: jpeg2000dec.c:138
read_crg
static int read_crg(Jpeg2000DecoderContext *s, int n)
Definition: jpeg2000dec.c:862
avassert.h
Jpeg2000DecoderContext::roi_shift
uint8_t roi_shift[4]
Definition: jpeg2000dec.c:128
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
Jpeg2000DecoderContext::avctx
AVCodecContext * avctx
Definition: jpeg2000dec.c:97
Jpeg2000ResLevel
Definition: jpeg2000.h:210
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_cold
#define av_cold
Definition: attributes.h:90
Jpeg2000DecoderContext::ncomponents
int ncomponents
Definition: jpeg2000dec.c:115
FF_CODEC_PROPERTY_LOSSLESS
#define FF_CODEC_PROPERTY_LOSSLESS
Definition: avcodec.h:1845
get_siz
static int get_siz(Jpeg2000DecoderContext *s)
Definition: jpeg2000dec.c:272
jpeg2000_dec_cleanup
static void jpeg2000_dec_cleanup(Jpeg2000DecoderContext *s)
Definition: jpeg2000dec.c:2105
Jpeg2000CodingStyle::cblk_style
uint8_t cblk_style
Definition: jpeg2000.h:144
mask
static const uint16_t mask[17]
Definition: lzw.c:38
Jpeg2000QuantStyle::nguardbits
uint8_t nguardbits
Definition: jpeg2000.h:155
Jpeg2000Tile::comp
Jpeg2000Component * comp
Definition: j2kenc.c:107
Jpeg2000POCEntry::Ppoc
uint8_t Ppoc
Definition: jpeg2000dec.c:62
width
#define width
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:254
Jpeg2000CodingStyle::transform
uint8_t transform
Definition: jpeg2000.h:140
s
#define s(width, name)
Definition: cbs_vp9.c:256
AV_PIX_FMT_YUVA420P
@ AV_PIX_FMT_YUVA420P
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
Definition: pixfmt.h:101
Jpeg2000DecoderContext::codsty
Jpeg2000CodingStyle codsty[4]
Definition: jpeg2000dec.c:125
av_realloc_array
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
Definition: mem.c:225
Jpeg2000ResLevel::band
Jpeg2000Band * band
Definition: jpeg2000.h:215
Jpeg2000Tile::packed_headers_stream
GetByteContext packed_headers_stream
Definition: jpeg2000dec.c:90
g
const char * g
Definition: vf_curves.c:117
get_cox
static int get_cox(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c)
Definition: jpeg2000dec.c:483
jpeg2000.h
roi_shift_param
static int roi_shift_param(Jpeg2000Component *comp, int quan_parameter)
Definition: jpeg2000dec.c:1830
JPEG2000_PGOD_RPCL
#define JPEG2000_PGOD_RPCL
Definition: jpeg2000.h:117
ff_jpeg2000dsp_init
av_cold void ff_jpeg2000dsp_init(Jpeg2000DSPContext *c)
Definition: jpeg2000dsp.c:93
Jpeg2000Cblk::data
uint8_t * data
Definition: jpeg2000.h:182
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
Jpeg2000Band::coord
int coord[2][2]
Definition: jpeg2000.h:203
Jpeg2000DSPContext
Definition: jpeg2000dsp.h:29
pix_fmt
static enum AVPixelFormat pix_fmt
Definition: demuxing_decoding.c:41
mct_decode
static void mct_decode(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
Definition: jpeg2000dec.c:1899
JP2_CODESTREAM
#define JP2_CODESTREAM
Definition: jpeg2000dec.c:48
Jpeg2000Band::f_stepsize
float f_stepsize
Definition: jpeg2000.h:206
JPEG2000_COM
@ JPEG2000_COM
Definition: jpeg2000.h:53
JPEG2000_PGOD_CPRL
#define JPEG2000_PGOD_CPRL
Definition: jpeg2000.h:119
JPEG2000_QSTY_SI
@ JPEG2000_QSTY_SI
Definition: jpeg2000.h:66
JPEG2000_CRG
@ JPEG2000_CRG
Definition: jpeg2000.h:52
gray_pix_fmts
static enum AVPixelFormat gray_pix_fmts[]
Definition: jpeg2000dec.c:261
Jpeg2000Component::reslevel
Jpeg2000ResLevel * reslevel
Definition: jpeg2000.h:219
JPEG2000_CBLK_BYPASS
#define JPEG2000_CBLK_BYPASS
Definition: jpeg2000.h:102
Jpeg2000POC::nb_poc
int nb_poc
Definition: jpeg2000dec.c:67
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:64
init_tile
static int init_tile(Jpeg2000DecoderContext *s, int tileno)
Definition: jpeg2000dec.c:999
get_qcd
static int get_qcd(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q, uint8_t *properties)
Definition: jpeg2000dec.c:708
AV_CODEC_CAP_FRAME_THREADS
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: codec.h:113
JPEG2000_T1_SIG_S
#define JPEG2000_T1_SIG_S
Definition: jpeg2000.h:80
Jpeg2000Cblk::lblock
uint8_t lblock
Definition: jpeg2000.h:181
Jpeg2000Tile::has_ppt
uint8_t has_ppt
Definition: jpeg2000dec.c:87
AV_PIX_FMT_RGBA64
#define AV_PIX_FMT_RGBA64
Definition: pixfmt.h:396
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
Jpeg2000Cblk::length
uint16_t length
Definition: jpeg2000.h:178
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
jpeg2000_decode_init
static av_cold int jpeg2000_decode_init(AVCodecContext *avctx)
Definition: jpeg2000dec.c:2466
PTRDIFF_SPECIFIER
#define PTRDIFF_SPECIFIER
Definition: internal.h:194
NULL
#define NULL
Definition: coverity.c:32
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
av_realloc
void * av_realloc(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory.
Definition: mem.c:153
Jpeg2000DecoderContext::sar
AVRational sar
Definition: jpeg2000dec.c:123
Jpeg2000POC
Definition: jpeg2000dec.c:65
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
Jpeg2000DecoderContext::tile
Jpeg2000Tile * tile
Definition: jpeg2000dec.c:134
get_ppm
static int get_ppm(Jpeg2000DecoderContext *s, int n)
Definition: jpeg2000dec.c:939
JP2_SIG_TYPE
#define JP2_SIG_TYPE
Definition: jpeg2000dec.c:46
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
JPEG2000_PLM
@ JPEG2000_PLM
Definition: jpeg2000.h:44
profiles.h
Jpeg2000Band::prec
Jpeg2000Prec * prec
Definition: jpeg2000.h:207
JPEG2000_T1_VIS
#define JPEG2000_T1_VIS
Definition: jpeg2000.h:95
Jpeg2000ResLevel::num_precincts_y
int num_precincts_y
Definition: jpeg2000.h:213
get_ppt
static int get_ppt(Jpeg2000DecoderContext *s, int n)
Definition: jpeg2000dec.c:963
Jpeg2000DecoderContext::tile_offset_y
int tile_offset_y
Definition: jpeg2000dec.c:102
JPEG2000_EPH
@ JPEG2000_EPH
Definition: jpeg2000.h:56
JPEG2000_PPT
@ JPEG2000_PPT
Definition: jpeg2000.h:51
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:74
JPEG2000_CBLK_RESET
#define JPEG2000_CBLK_RESET
Definition: jpeg2000.h:103
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
AVPALETTE_COUNT
#define AVPALETTE_COUNT
Definition: pixfmt.h:33
bytestream2_get_bytes_left
static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:158
JPEG2000_T1_SIG_NB
#define JPEG2000_T1_SIG_NB
Definition: jpeg2000.h:85
bytestream2_tell
static av_always_inline int bytestream2_tell(GetByteContext *g)
Definition: bytestream.h:192
Jpeg2000Prec::nb_codeblocks_width
int nb_codeblocks_width
Definition: jpeg2000.h:193
tag_tree_decode
static int tag_tree_decode(Jpeg2000DecoderContext *s, Jpeg2000TgtNode *node, int threshold)
Definition: jpeg2000dec.c:168
JPEG2000_T1_SIG_SE
#define JPEG2000_T1_SIG_SE
Definition: jpeg2000.h:83
Jpeg2000TilePart::tp_end
const uint8_t * tp_end
Definition: jpeg2000dec.c:73
Jpeg2000ResLevel::log2_prec_height
uint8_t log2_prec_height
Definition: jpeg2000.h:214
ff_jpeg2000_cleanup
void ff_jpeg2000_cleanup(Jpeg2000Component *comp, Jpeg2000CodingStyle *codsty)
Definition: jpeg2000.c:597
Jpeg2000Component
Definition: jpeg2000.h:218
JPEG2000_T1_SIG_SW
#define JPEG2000_T1_SIG_SW
Definition: jpeg2000.h:84
Jpeg2000Tile::codsty
Jpeg2000CodingStyle codsty[4]
Definition: jpeg2000dec.c:83
AVFrame::pict_type
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:422
AV_PIX_FMT_RGB24
@ AV_PIX_FMT_RGB24
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:68
Jpeg2000Prec::cblkincl
Jpeg2000TgtNode * cblkincl
Definition: jpeg2000.h:196
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
OFFSET
#define OFFSET(x)
Definition: jpeg2000dec.c:2557
Jpeg2000Component::i_data
int * i_data
Definition: jpeg2000.h:222
AVPacket::size
int size
Definition: packet.h:375
get_qcc
static int get_qcc(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q, uint8_t *properties)
Definition: jpeg2000dec.c:726
Jpeg2000Tile::tp_idx
uint16_t tp_idx
Definition: jpeg2000dec.c:91
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
byte
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_WB16 unsigned int_TMPL byte
Definition: bytestream.h:99
bytestream2_size
static av_always_inline int bytestream2_size(GetByteContext *g)
Definition: bytestream.h:202
codec_internal.h
Jpeg2000POC::poc
Jpeg2000POCEntry poc[MAX_POCS]
Definition: jpeg2000dec.c:66
Jpeg2000ResLevel::nbands
uint8_t nbands
Definition: jpeg2000.h:211
FF_COMPLIANCE_STRICT
#define FF_COMPLIANCE_STRICT
Strictly conform to all the things in the spec no matter what consequences.
Definition: avcodec.h:1302
sp
#define sp
Definition: regdef.h:63
Jpeg2000DecoderContext::image_offset_y
int image_offset_y
Definition: jpeg2000dec.c:101
roi_scale_cblk
static void roi_scale_cblk(Jpeg2000Cblk *cblk, Jpeg2000Component *comp, Jpeg2000T1Context *t1)
Definition: jpeg2000dec.c:1927
Jpeg2000DecoderContext::height
int height
Definition: jpeg2000dec.c:100
AV_PIX_FMT_RGB48
#define AV_PIX_FMT_RGB48
Definition: pixfmt.h:392
size
int size
Definition: twinvq_data.h:10344
Jpeg2000Cblk
Definition: jpeg2000.h:173
Jpeg2000DecoderContext::tile_height
int tile_height
Definition: jpeg2000dec.c:120
MKBETAG
#define MKBETAG(a, b, c, d)
Definition: macros.h:56
Jpeg2000DecoderContext::qntsty
Jpeg2000QuantStyle qntsty[4]
Definition: jpeg2000dec.c:126
Jpeg2000Component::f_data
float * f_data
Definition: jpeg2000.h:221
xyz_pix_fmts
static enum AVPixelFormat xyz_pix_fmts[]
Definition: jpeg2000dec.c:263
AVFrame::format
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames,...
Definition: frame.h:412
Jpeg2000Tile::coord
int coord[2][2]
Definition: jpeg2000dec.c:92
jpeg2000_decode_frame
static int jpeg2000_decode_frame(AVCodecContext *avctx, AVFrame *picture, int *got_frame, AVPacket *avpkt)
Definition: jpeg2000dec.c:2476
height
#define height
Jpeg2000Tile::properties
uint8_t properties[4]
Definition: jpeg2000dec.c:82
get_rgn
static int get_rgn(Jpeg2000DecoderContext *s, int n)
Definition: jpeg2000dec.c:630
Jpeg2000TilePart::tile_index
uint8_t tile_index
Definition: jpeg2000dec.c:72
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_CODEC_CAP_SLICE_THREADS
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: codec.h:117
get_cod
static int get_cod(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c, uint8_t *properties)
Definition: jpeg2000dec.c:558
JPEG2000_COD
@ JPEG2000_COD
Definition: jpeg2000.h:41
ff_jpeg2000_getsgnctxno
static int ff_jpeg2000_getsgnctxno(int flag, int *xorbit)
Definition: jpeg2000.h:271
attributes.h
all_pix_fmts
static enum AVPixelFormat all_pix_fmts[]
Definition: jpeg2000dec.c:265
Jpeg2000DecoderContext::tile_offset_x
int tile_offset_x
Definition: jpeg2000dec.c:102
JPEG2000_PGOD_LRCP
#define JPEG2000_PGOD_LRCP
Definition: jpeg2000.h:115
Jpeg2000TgtNode
Definition: jpeg2000.h:128
HAD_QCC
#define HAD_QCC
Definition: jpeg2000dec.c:52
Jpeg2000Cblk::data_start
int * data_start
Definition: jpeg2000.h:186
Jpeg2000CodingStyle::csty
uint8_t csty
Definition: jpeg2000.h:141
Jpeg2000CodingStyle::nlayers
uint8_t nlayers
Definition: jpeg2000.h:142
Jpeg2000CodingStyle::nreslevels
int nreslevels
Definition: jpeg2000.h:136
Jpeg2000DecoderContext::bit_index
int bit_index
Definition: jpeg2000dec.c:130
Jpeg2000DecoderContext::properties
uint8_t properties[4]
Definition: jpeg2000dec.c:105
AV_PIX_FMT_XYZ12
#define AV_PIX_FMT_XYZ12
Definition: pixfmt.h:452
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:64
pix_fmt_match
static int pix_fmt_match(enum AVPixelFormat pix_fmt, int components, int bpc, uint32_t log2_chroma_wh, int pal8)
Definition: jpeg2000dec.c:208
JPEG2000_PGOD_RLCP
#define JPEG2000_PGOD_RLCP
Definition: jpeg2000.h:116
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
get_plt
static int get_plt(Jpeg2000DecoderContext *s, int n)
Definition: jpeg2000dec.c:917
Jpeg2000ResLevel::num_precincts_x
int num_precincts_x
Definition: jpeg2000.h:213
JPEG2000_RGN
@ JPEG2000_RGN
Definition: jpeg2000.h:48
jp2_find_codestream
static int jp2_find_codestream(Jpeg2000DecoderContext *s)
Definition: jpeg2000dec.c:2317
JPEG2000_T1_REF
#define JPEG2000_T1_REF
Definition: jpeg2000.h:97
Jpeg2000QuantStyle::expn
uint8_t expn[JPEG2000_MAX_DECLEVELS *3]
Definition: jpeg2000.h:152
get_coc
static int get_coc(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c, uint8_t *properties)
Definition: jpeg2000dec.c:595
Jpeg2000DecoderContext::cdy
int cdy[4]
Definition: jpeg2000dec.c:113
common.h
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
JP2_SIG_VALUE
#define JP2_SIG_VALUE
Definition: jpeg2000dec.c:47
JPEG2000_SOP_FIXED_BYTES
#define JPEG2000_SOP_FIXED_BYTES
Definition: jpeg2000.h:61
FF_PROFILE_JPEG2000_DCINEMA_4K
#define FF_PROFILE_JPEG2000_DCINEMA_4K
Definition: avcodec.h:1628
select_stream
static void select_stream(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile, int *tp_index, Jpeg2000CodingStyle *codsty)
Definition: jpeg2000dec.c:1085
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
FF_CODEC_CAP_INIT_THREADSAFE
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
Definition: codec_internal.h:31
JPEG2000_SIZ
@ JPEG2000_SIZ
Definition: jpeg2000.h:40
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:264
Jpeg2000TilePart
Definition: jpeg2000dec.c:71
WRITE_FRAME
#define WRITE_FRAME(D, PIXEL)
Definition: jpeg2000dec.c:2011
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:203
ff_jpeg2000_getsigctxno
static int ff_jpeg2000_getsigctxno(int flag, int bandno)
Definition: jpeg2000.h:253
VD
#define VD
Definition: jpeg2000dec.c:2558
len
int len
Definition: vorbis_enc_data.h:426
AV_CODEC_ID_JPEG2000
@ AV_CODEC_ID_JPEG2000
Definition: codec_id.h:138
dequantization_int
static void dequantization_int(int x, int y, Jpeg2000Cblk *cblk, Jpeg2000Component *comp, Jpeg2000T1Context *t1, Jpeg2000Band *band)
Definition: jpeg2000dec.c:1865
JPEG2000_MAX_PASSES
#define JPEG2000_MAX_PASSES
Definition: jpeg2000.h:73
GRAY_PIXEL_FORMATS
#define GRAY_PIXEL_FORMATS
Definition: jpeg2000dec.c:246
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:272
Jpeg2000DecoderContext::packed_headers
uint8_t * packed_headers
Definition: jpeg2000dec.c:108
Jpeg2000QuantStyle::mant
uint16_t mant[JPEG2000_MAX_DECLEVELS *3]
Definition: jpeg2000.h:153
avcodec.h
Jpeg2000Tile::poc
Jpeg2000POC poc
Definition: jpeg2000dec.c:85
bytestream_get_buffer
static av_always_inline unsigned int bytestream_get_buffer(const uint8_t **b, uint8_t *dst, unsigned int size)
Definition: bytestream.h:363
JPEG2000_T1_SIG
#define JPEG2000_T1_SIG
Definition: jpeg2000.h:96
AV_PIX_FMT_PAL8
@ AV_PIX_FMT_PAL8
8 bits with AV_PIX_FMT_RGB32 palette
Definition: pixfmt.h:77
JPEG2000_PLT
@ JPEG2000_PLT
Definition: jpeg2000.h:45
ret
ret
Definition: filter_design.txt:187
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:71
Jpeg2000DecoderContext::cbps
uint8_t cbps[4]
Definition: jpeg2000dec.c:103
MQC_CX_RL
#define MQC_CX_RL
Definition: mqc.h:34
SIZE_SPECIFIER
#define SIZE_SPECIFIER
Definition: internal.h:195
Jpeg2000TilePart::tpg
GetByteContext tpg
Definition: jpeg2000dec.c:75
Jpeg2000Component::coord
int coord[2][2]
Definition: jpeg2000.h:223
AVCodecContext
main external API structure.
Definition: avcodec.h:389
FF_DWT53
@ FF_DWT53
Definition: jpeg2000dwt.h:38
JPEG2000_CBLK_VSC
#define JPEG2000_CBLK_VSC
Definition: jpeg2000.h:105
ff_jpeg2000_ceildivpow2
static int ff_jpeg2000_ceildivpow2(int a, int b)
Definition: jpeg2000.h:229
jpeg2000dsp.h
Jpeg2000ResLevel::log2_prec_width
uint8_t log2_prec_width
Definition: jpeg2000.h:214
jpeg2000_flush
static void jpeg2000_flush(Jpeg2000DecoderContext *s)
Definition: jpeg2000dec.c:160
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
RGB_PIXEL_FORMATS
#define RGB_PIXEL_FORMATS
Definition: jpeg2000dec.c:245
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:225
ff_jpeg2000_init_tier1_luts
void av_cold ff_jpeg2000_init_tier1_luts(void)
Definition: jpeg2000.c:173
Jpeg2000POCEntry::LYEpoc
uint16_t LYEpoc
Definition: jpeg2000dec.c:57
Jpeg2000DecoderContext::dsp
Jpeg2000DSPContext dsp
Definition: jpeg2000dec.c:135
JPEG2000_T1_SGN_S
#define JPEG2000_T1_SGN_S
Definition: jpeg2000.h:91
Jpeg2000DecoderContext::colour_space
int colour_space
Definition: jpeg2000dec.c:116
JPEG2000_CSTY_EPH
#define JPEG2000_CSTY_EPH
Definition: jpeg2000.h:112
Jpeg2000DecoderContext::has_ppm
uint8_t has_ppm
Definition: jpeg2000dec.c:107
XYZ_PIXEL_FORMATS
#define XYZ_PIXEL_FORMATS
Definition: jpeg2000dec.c:258
Jpeg2000Cblk::nb_terminations
int nb_terminations
Definition: jpeg2000.h:184
Jpeg2000DecoderContext::pal8
int8_t pal8
Definition: jpeg2000dec.c:118
Jpeg2000POCEntry::RSpoc
uint8_t RSpoc
Definition: jpeg2000dec.c:60
Jpeg2000Tile::packed_headers_size
int packed_headers_size
Definition: jpeg2000dec.c:89
desc
const char * desc
Definition: libsvtav1.c:83
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
Jpeg2000Tile::tile_part
Jpeg2000TilePart tile_part[32]
Definition: jpeg2000dec.c:86
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:90
bytestream2_get_bufferu
static av_always_inline unsigned int bytestream2_get_bufferu(GetByteContext *g, uint8_t *dst, unsigned int size)
Definition: bytestream.h:277
JPEG2000_COC
@ JPEG2000_COC
Definition: jpeg2000.h:42
JPEG2000_PGOD_PCRL
#define JPEG2000_PGOD_PCRL
Definition: jpeg2000.h:118
AV_CODEC_FLAG_BITEXACT
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:278
JPEG2000_MAX_DECLEVELS
#define JPEG2000_MAX_DECLEVELS
Definition: jpeg2000.h:70
ff_mqc_decode
int ff_mqc_decode(MqcState *mqc, uint8_t *cxstate)
MQ decoder.
Definition: mqcdec.c:93
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:36
jpeg2000_decode_packets
static int jpeg2000_decode_packets(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
Definition: jpeg2000dec.c:1591
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
ff_jpeg2000_decoder
const FFCodec ff_jpeg2000_decoder
Definition: jpeg2000dec.c:2573
get_sot
static int get_sot(Jpeg2000DecoderContext *s, int n)
Definition: jpeg2000dec.c:809
Jpeg2000Cblk::npasses
uint8_t npasses
Definition: jpeg2000.h:174
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
yuv_pix_fmts
static enum AVPixelFormat yuv_pix_fmts[]
Definition: jpeg2000dec.c:262
Jpeg2000CodingStyle::nreslevels2decode
int nreslevels2decode
Definition: jpeg2000.h:137
AVPacket
This structure stores compressed data.
Definition: packet.h:351
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:416
JPEG2000_QCC
@ JPEG2000_QCC
Definition: jpeg2000.h:47
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
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
Jpeg2000DecoderContext::numYtiles
unsigned numYtiles
Definition: jpeg2000dec.c:121
ff_jpeg2000_set_significance
void ff_jpeg2000_set_significance(Jpeg2000T1Context *t1, int x, int y, int negative)
Definition: jpeg2000.c:179
int32_t
int32_t
Definition: audioconvert.c:56
bytestream.h
imgutils.h
bytestream2_init
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:137
AVERROR_BUG
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
Definition: error.h:52
Jpeg2000TgtNode::val
uint8_t val
Definition: jpeg2000.h:129
Jpeg2000TgtNode::vis
uint8_t vis
Definition: jpeg2000.h:131
Jpeg2000DecoderContext::packed_headers_stream
GetByteContext packed_headers_stream
Definition: jpeg2000dec.c:110
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
Jpeg2000CodingStyle
Definition: jpeg2000.h:135
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
SP
static uint64_t SP[8][256]
Definition: camellia.c:44
Jpeg2000Cblk::lengthinc
uint16_t * lengthinc
Definition: jpeg2000.h:179
Jpeg2000QuantStyle
Definition: jpeg2000.h:151
JPEG2000_SOP_BYTE_LENGTH
#define JPEG2000_SOP_BYTE_LENGTH
Definition: jpeg2000.h:62
rgb_pix_fmts
static enum AVPixelFormat rgb_pix_fmts[]
Definition: jpeg2000dec.c:260
Jpeg2000DecoderContext
Definition: jpeg2000dec.c:95
FF_PROFILE_JPEG2000_DCINEMA_2K
#define FF_PROFILE_JPEG2000_DCINEMA_2K
Definition: avcodec.h:1627
Jpeg2000Cblk::nonzerobits
uint8_t nonzerobits
Definition: jpeg2000.h:176
get_qcx
static int get_qcx(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q)
Definition: jpeg2000dec.c:663
Jpeg2000Prec::cblk
Jpeg2000Cblk * cblk
Definition: jpeg2000.h:197
AV_PIX_FMT_FLAG_PAL
#define AV_PIX_FMT_FLAG_PAL
Pixel format has a palette in data[1], values are indexes in this palette.
Definition: pixdesc.h:120
Jpeg2000Tile::qntsty
Jpeg2000QuantStyle qntsty[4]
Definition: jpeg2000dec.c:84
get_tlm
static int get_tlm(Jpeg2000DecoderContext *s, int n)
Definition: jpeg2000dec.c:879
dequantization_float
static void dequantization_float(int x, int y, Jpeg2000Cblk *cblk, Jpeg2000Component *comp, Jpeg2000T1Context *t1, Jpeg2000Band *band)
Definition: jpeg2000dec.c:1850
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:1533
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
ff_mqc_init_contexts
void ff_mqc_init_contexts(MqcState *mqc)
MQ-coder context initialisations.
Definition: mqc.c:64
get_bits
static int get_bits(Jpeg2000DecoderContext *s, int n)
Definition: jpeg2000dec.c:145
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:759
MAX_POCS
#define MAX_POCS
Definition: jpeg2000dec.c:54
JPEG2000_CBLK_SEGSYM
#define JPEG2000_CBLK_SEGSYM
Definition: jpeg2000.h:107
FF_DWT97_INT
@ FF_DWT97_INT
Definition: jpeg2000dwt.h:39
dequantization_int_97
static void dequantization_int_97(int x, int y, Jpeg2000Cblk *cblk, Jpeg2000Component *comp, Jpeg2000T1Context *t1, Jpeg2000Band *band)
Definition: jpeg2000dec.c:1885
Jpeg2000Cblk::data_allocated
size_t data_allocated
Definition: jpeg2000.h:183
JPEG2000_TLM
@ JPEG2000_TLM
Definition: jpeg2000.h:43
Jpeg2000TilePart::header_tpg
GetByteContext header_tpg
Definition: jpeg2000dec.c:74
Generated on Wed Aug 24 2022 21:41:30 for FFmpeg by   doxygen 1.8.17