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