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