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 */
132 static int get_bits(Jpeg2000DecoderContext *s, int n)
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. */
737 static int get_sot(Jpeg2000DecoderContext *s, int n)
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. */
798 static int get_tlm(Jpeg2000DecoderContext *s, int n)
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  if (ST == 0x03) {
807  av_log(s->avctx, AV_LOG_ERROR, "TLM marker contains invalid ST value.\n");
808  return AVERROR_INVALIDDATA;
809  }
810 
811  SP = (Stlm >> 6) & 0x01;
812  tile_tlm = (n - 4) / ((SP + 1) * 2 + ST);
813  for (i = 0; i < tile_tlm; i++) {
814  switch (ST) {
815  case 0:
816  break;
817  case 1:
818  bytestream2_get_byte(&s->g);
819  break;
820  case 2:
821  bytestream2_get_be16(&s->g);
822  break;
823  case 3:
824  bytestream2_get_be32(&s->g);
825  break;
826  }
827  if (SP == 0) {
828  bytestream2_get_be16(&s->g);
829  } else {
830  bytestream2_get_be32(&s->g);
831  }
832  }
833  return 0;
834 }
835 
836 static int get_plt(Jpeg2000DecoderContext *s, int n)
837 {
838  int i;
839  int v;
840 
842  "PLT marker at pos 0x%X\n", bytestream2_tell(&s->g) - 4);
843 
844  if (n < 4)
845  return AVERROR_INVALIDDATA;
846 
847  /*Zplt =*/ bytestream2_get_byte(&s->g);
848 
849  for (i = 0; i < n - 3; i++) {
850  v = bytestream2_get_byte(&s->g);
851  }
852  if (v & 0x80)
853  return AVERROR_INVALIDDATA;
854 
855  return 0;
856 }
857 
858 static int init_tile(Jpeg2000DecoderContext *s, int tileno)
859 {
860  int compno;
861  int tilex = tileno % s->numXtiles;
862  int tiley = tileno / s->numXtiles;
863  Jpeg2000Tile *tile = s->tile + tileno;
864 
865  if (!tile->comp)
866  return AVERROR(ENOMEM);
867 
868  tile->coord[0][0] = av_clip(tilex * (int64_t)s->tile_width + s->tile_offset_x, s->image_offset_x, s->width);
869  tile->coord[0][1] = av_clip((tilex + 1) * (int64_t)s->tile_width + s->tile_offset_x, s->image_offset_x, s->width);
870  tile->coord[1][0] = av_clip(tiley * (int64_t)s->tile_height + s->tile_offset_y, s->image_offset_y, s->height);
871  tile->coord[1][1] = av_clip((tiley + 1) * (int64_t)s->tile_height + s->tile_offset_y, s->image_offset_y, s->height);
872 
873  for (compno = 0; compno < s->ncomponents; compno++) {
874  Jpeg2000Component *comp = tile->comp + compno;
875  Jpeg2000CodingStyle *codsty = tile->codsty + compno;
876  Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
877  int ret; // global bandno
878 
879  comp->coord_o[0][0] = tile->coord[0][0];
880  comp->coord_o[0][1] = tile->coord[0][1];
881  comp->coord_o[1][0] = tile->coord[1][0];
882  comp->coord_o[1][1] = tile->coord[1][1];
883  if (compno) {
884  comp->coord_o[0][0] /= s->cdx[compno];
885  comp->coord_o[0][1] /= s->cdx[compno];
886  comp->coord_o[1][0] /= s->cdy[compno];
887  comp->coord_o[1][1] /= s->cdy[compno];
888  }
889 
890  comp->coord[0][0] = ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], s->reduction_factor);
891  comp->coord[0][1] = ff_jpeg2000_ceildivpow2(comp->coord_o[0][1], s->reduction_factor);
892  comp->coord[1][0] = ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], s->reduction_factor);
893  comp->coord[1][1] = ff_jpeg2000_ceildivpow2(comp->coord_o[1][1], s->reduction_factor);
894 
895  if (ret = ff_jpeg2000_init_component(comp, codsty, qntsty,
896  s->cbps[compno], s->cdx[compno],
897  s->cdy[compno], s->avctx))
898  return ret;
899  }
900  return 0;
901 }
902 
903 /* Read the number of coding passes. */
905 {
906  int num;
907  if (!get_bits(s, 1))
908  return 1;
909  if (!get_bits(s, 1))
910  return 2;
911  if ((num = get_bits(s, 2)) != 3)
912  return num < 0 ? num : 3 + num;
913  if ((num = get_bits(s, 5)) != 31)
914  return num < 0 ? num : 6 + num;
915  num = get_bits(s, 7);
916  return num < 0 ? num : 37 + num;
917 }
918 
920 {
921  int res = 0, ret;
922  while (ret = get_bits(s, 1)) {
923  if (ret < 0)
924  return ret;
925  res++;
926  }
927  return res;
928 }
929 
931  Jpeg2000CodingStyle *codsty,
932  Jpeg2000ResLevel *rlevel, int precno,
933  int layno, uint8_t *expn, int numgbits)
934 {
935  int bandno, cblkno, ret, nb_code_blocks;
936  int cwsno;
937 
938  if (layno < rlevel->band[0].prec[precno].decoded_layers)
939  return 0;
940  rlevel->band[0].prec[precno].decoded_layers = layno + 1;
941 
942  if (bytestream2_get_bytes_left(&s->g) == 0 && s->bit_index == 8) {
943  if (*tp_index < FF_ARRAY_ELEMS(tile->tile_part) - 1) {
944  s->g = tile->tile_part[++(*tp_index)].tpg;
945  }
946  }
947 
948  if (bytestream2_peek_be32(&s->g) == JPEG2000_SOP_FIXED_BYTES)
950 
951  if (!(ret = get_bits(s, 1))) {
952  jpeg2000_flush(s);
953  return 0;
954  } else if (ret < 0)
955  return ret;
956 
957  for (bandno = 0; bandno < rlevel->nbands; bandno++) {
958  Jpeg2000Band *band = rlevel->band + bandno;
959  Jpeg2000Prec *prec = band->prec + precno;
960 
961  if (band->coord[0][0] == band->coord[0][1] ||
962  band->coord[1][0] == band->coord[1][1])
963  continue;
964  nb_code_blocks = prec->nb_codeblocks_height *
965  prec->nb_codeblocks_width;
966  for (cblkno = 0; cblkno < nb_code_blocks; cblkno++) {
967  Jpeg2000Cblk *cblk = prec->cblk + cblkno;
968  int incl, newpasses, llen;
969  void *tmp;
970 
971  if (cblk->npasses)
972  incl = get_bits(s, 1);
973  else
974  incl = tag_tree_decode(s, prec->cblkincl + cblkno, layno + 1) == layno;
975  if (!incl)
976  continue;
977  else if (incl < 0)
978  return incl;
979 
980  if (!cblk->npasses) {
981  int v = expn[bandno] + numgbits - 1 -
982  tag_tree_decode(s, prec->zerobits + cblkno, 100);
983  if (v < 0 || v > 30) {
985  "nonzerobits %d invalid or unsupported\n", v);
986  return AVERROR_INVALIDDATA;
987  }
988  cblk->nonzerobits = v;
989  }
990  if ((newpasses = getnpasses(s)) < 0)
991  return newpasses;
992  av_assert2(newpasses > 0);
993  if (cblk->npasses + newpasses >= JPEG2000_MAX_PASSES) {
994  avpriv_request_sample(s->avctx, "Too many passes");
995  return AVERROR_PATCHWELCOME;
996  }
997  if ((llen = getlblockinc(s)) < 0)
998  return llen;
999  if (cblk->lblock + llen + av_log2(newpasses) > 16) {
1001  "Block with length beyond 16 bits");
1002  return AVERROR_PATCHWELCOME;
1003  }
1004 
1005  cblk->lblock += llen;
1006 
1007  cblk->nb_lengthinc = 0;
1008  cblk->nb_terminationsinc = 0;
1009  av_free(cblk->lengthinc);
1010  cblk->lengthinc = av_mallocz_array(newpasses , sizeof(*cblk->lengthinc));
1011  if (!cblk->lengthinc)
1012  return AVERROR(ENOMEM);
1013  tmp = av_realloc_array(cblk->data_start, cblk->nb_terminations + newpasses + 1, sizeof(*cblk->data_start));
1014  if (!tmp)
1015  return AVERROR(ENOMEM);
1016  cblk->data_start = tmp;
1017  do {
1018  int newpasses1 = 0;
1019 
1020  while (newpasses1 < newpasses) {
1021  newpasses1 ++;
1022  if (needs_termination(codsty->cblk_style, cblk->npasses + newpasses1 - 1)) {
1023  cblk->nb_terminationsinc ++;
1024  break;
1025  }
1026  }
1027 
1028  if ((ret = get_bits(s, av_log2(newpasses1) + cblk->lblock)) < 0)
1029  return ret;
1030  if (ret > cblk->data_allocated) {
1031  size_t new_size = FFMAX(2*cblk->data_allocated, ret);
1032  void *new = av_realloc(cblk->data, new_size);
1033  if (new) {
1034  cblk->data = new;
1035  cblk->data_allocated = new_size;
1036  }
1037  }
1038  if (ret > cblk->data_allocated) {
1040  "Block with lengthinc greater than %"SIZE_SPECIFIER"",
1041  cblk->data_allocated);
1042  return AVERROR_PATCHWELCOME;
1043  }
1044  cblk->lengthinc[cblk->nb_lengthinc++] = ret;
1045  cblk->npasses += newpasses1;
1046  newpasses -= newpasses1;
1047  } while(newpasses);
1048  }
1049  }
1050  jpeg2000_flush(s);
1051 
1052  if (codsty->csty & JPEG2000_CSTY_EPH) {
1053  if (bytestream2_peek_be16(&s->g) == JPEG2000_EPH)
1054  bytestream2_skip(&s->g, 2);
1055  else
1056  av_log(s->avctx, AV_LOG_ERROR, "EPH marker not found. instead %X\n", bytestream2_peek_be32(&s->g));
1057  }
1058 
1059  for (bandno = 0; bandno < rlevel->nbands; bandno++) {
1060  Jpeg2000Band *band = rlevel->band + bandno;
1061  Jpeg2000Prec *prec = band->prec + precno;
1062 
1063  nb_code_blocks = prec->nb_codeblocks_height * prec->nb_codeblocks_width;
1064  for (cblkno = 0; cblkno < nb_code_blocks; cblkno++) {
1065  Jpeg2000Cblk *cblk = prec->cblk + cblkno;
1066  if (!cblk->nb_terminationsinc && !cblk->lengthinc)
1067  continue;
1068  for (cwsno = 0; cwsno < cblk->nb_lengthinc; cwsno ++) {
1069  if (cblk->data_allocated < cblk->length + cblk->lengthinc[cwsno] + 4) {
1070  size_t new_size = FFMAX(2*cblk->data_allocated, cblk->length + cblk->lengthinc[cwsno] + 4);
1071  void *new = av_realloc(cblk->data, new_size);
1072  if (new) {
1073  cblk->data = new;
1074  cblk->data_allocated = new_size;
1075  }
1076  }
1077  if ( bytestream2_get_bytes_left(&s->g) < cblk->lengthinc[cwsno]
1078  || cblk->data_allocated < cblk->length + cblk->lengthinc[cwsno] + 4
1079  ) {
1081  "Block length %"PRIu16" or lengthinc %d is too large, left %d\n",
1082  cblk->length, cblk->lengthinc[cwsno], bytestream2_get_bytes_left(&s->g));
1083  return AVERROR_INVALIDDATA;
1084  }
1085 
1086  bytestream2_get_bufferu(&s->g, cblk->data + cblk->length, cblk->lengthinc[cwsno]);
1087  cblk->length += cblk->lengthinc[cwsno];
1088  cblk->lengthinc[cwsno] = 0;
1089  if (cblk->nb_terminationsinc) {
1090  cblk->nb_terminationsinc--;
1091  cblk->nb_terminations++;
1092  cblk->data[cblk->length++] = 0xFF;
1093  cblk->data[cblk->length++] = 0xFF;
1094  cblk->data_start[cblk->nb_terminations] = cblk->length;
1095  }
1096  }
1097  av_freep(&cblk->lengthinc);
1098  }
1099  }
1100  return 0;
1101 }
1102 
1104  int RSpoc, int CSpoc,
1105  int LYEpoc, int REpoc, int CEpoc,
1106  int Ppoc, int *tp_index)
1107 {
1108  int ret = 0;
1109  int layno, reslevelno, compno, precno, ok_reslevel;
1110  int x, y;
1111  int step_x, step_y;
1112 
1113  switch (Ppoc) {
1114  case JPEG2000_PGOD_RLCP:
1115  av_log(s->avctx, AV_LOG_DEBUG, "Progression order RLCP\n");
1116  ok_reslevel = 1;
1117  for (reslevelno = RSpoc; ok_reslevel && reslevelno < REpoc; reslevelno++) {
1118  ok_reslevel = 0;
1119  for (layno = 0; layno < LYEpoc; layno++) {
1120  for (compno = CSpoc; compno < CEpoc; compno++) {
1121  Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1122  Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
1123  if (reslevelno < codsty->nreslevels) {
1124  Jpeg2000ResLevel *rlevel = tile->comp[compno].reslevel +
1125  reslevelno;
1126  ok_reslevel = 1;
1127  for (precno = 0; precno < rlevel->num_precincts_x * rlevel->num_precincts_y; precno++)
1128  if ((ret = jpeg2000_decode_packet(s, tile, tp_index,
1129  codsty, rlevel,
1130  precno, layno,
1131  qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1132  qntsty->nguardbits)) < 0)
1133  return ret;
1134  }
1135  }
1136  }
1137  }
1138  break;
1139 
1140  case JPEG2000_PGOD_LRCP:
1141  av_log(s->avctx, AV_LOG_DEBUG, "Progression order LRCP\n");
1142  for (layno = 0; layno < LYEpoc; layno++) {
1143  ok_reslevel = 1;
1144  for (reslevelno = RSpoc; ok_reslevel && reslevelno < REpoc; reslevelno++) {
1145  ok_reslevel = 0;
1146  for (compno = CSpoc; compno < CEpoc; compno++) {
1147  Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1148  Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
1149  if (reslevelno < codsty->nreslevels) {
1150  Jpeg2000ResLevel *rlevel = tile->comp[compno].reslevel +
1151  reslevelno;
1152  ok_reslevel = 1;
1153  for (precno = 0; precno < rlevel->num_precincts_x * rlevel->num_precincts_y; precno++)
1154  if ((ret = jpeg2000_decode_packet(s, tile, tp_index,
1155  codsty, rlevel,
1156  precno, layno,
1157  qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1158  qntsty->nguardbits)) < 0)
1159  return ret;
1160  }
1161  }
1162  }
1163  }
1164  break;
1165 
1166  case JPEG2000_PGOD_CPRL:
1167  av_log(s->avctx, AV_LOG_DEBUG, "Progression order CPRL\n");
1168  for (compno = CSpoc; compno < CEpoc; compno++) {
1169  Jpeg2000Component *comp = tile->comp + compno;
1170  Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1171  Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
1172  step_x = 32;
1173  step_y = 32;
1174 
1175  if (RSpoc >= FFMIN(codsty->nreslevels, REpoc))
1176  continue;
1177 
1178  for (reslevelno = RSpoc; reslevelno < FFMIN(codsty->nreslevels, REpoc); reslevelno++) {
1179  uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1180  Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1181  step_x = FFMIN(step_x, rlevel->log2_prec_width + reducedresno);
1182  step_y = FFMIN(step_y, rlevel->log2_prec_height + reducedresno);
1183  }
1184  if (step_x >= 31 || step_y >= 31){
1185  avpriv_request_sample(s->avctx, "CPRL with large step");
1186  return AVERROR_PATCHWELCOME;
1187  }
1188  step_x = 1<<step_x;
1189  step_y = 1<<step_y;
1190 
1191  for (y = tile->coord[1][0]; y < tile->coord[1][1]; y = (y/step_y + 1)*step_y) {
1192  for (x = tile->coord[0][0]; x < tile->coord[0][1]; x = (x/step_x + 1)*step_x) {
1193  for (reslevelno = RSpoc; reslevelno < FFMIN(codsty->nreslevels, REpoc); reslevelno++) {
1194  unsigned prcx, prcy;
1195  uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1196  Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1197  int xc = x / s->cdx[compno];
1198  int yc = y / s->cdy[compno];
1199 
1200  if (yc % (1LL << (rlevel->log2_prec_height + reducedresno)) && y != tile->coord[1][0]) //FIXME this is a subset of the check
1201  continue;
1202 
1203  if (xc % (1LL << (rlevel->log2_prec_width + reducedresno)) && x != tile->coord[0][0]) //FIXME this is a subset of the check
1204  continue;
1205 
1206  // check if a precinct exists
1207  prcx = ff_jpeg2000_ceildivpow2(xc, reducedresno) >> rlevel->log2_prec_width;
1208  prcy = ff_jpeg2000_ceildivpow2(yc, reducedresno) >> rlevel->log2_prec_height;
1209  prcx -= ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], reducedresno) >> rlevel->log2_prec_width;
1210  prcy -= ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], reducedresno) >> rlevel->log2_prec_height;
1211 
1212  precno = prcx + rlevel->num_precincts_x * prcy;
1213 
1214  if (prcx >= rlevel->num_precincts_x || prcy >= rlevel->num_precincts_y) {
1215  av_log(s->avctx, AV_LOG_WARNING, "prc %d %d outside limits %d %d\n",
1216  prcx, prcy, rlevel->num_precincts_x, rlevel->num_precincts_y);
1217  continue;
1218  }
1219 
1220  for (layno = 0; layno < LYEpoc; layno++) {
1221  if ((ret = jpeg2000_decode_packet(s, tile, tp_index, codsty, rlevel,
1222  precno, layno,
1223  qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1224  qntsty->nguardbits)) < 0)
1225  return ret;
1226  }
1227  }
1228  }
1229  }
1230  }
1231  break;
1232 
1233  case JPEG2000_PGOD_RPCL:
1234  av_log(s->avctx, AV_LOG_WARNING, "Progression order RPCL\n");
1235  ok_reslevel = 1;
1236  for (reslevelno = RSpoc; ok_reslevel && reslevelno < REpoc; reslevelno++) {
1237  ok_reslevel = 0;
1238  step_x = 30;
1239  step_y = 30;
1240  for (compno = CSpoc; compno < CEpoc; compno++) {
1241  Jpeg2000Component *comp = tile->comp + compno;
1242  Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1243 
1244  if (reslevelno < codsty->nreslevels) {
1245  uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1246  Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1247  step_x = FFMIN(step_x, rlevel->log2_prec_width + reducedresno);
1248  step_y = FFMIN(step_y, rlevel->log2_prec_height + reducedresno);
1249  }
1250  }
1251  step_x = 1<<step_x;
1252  step_y = 1<<step_y;
1253 
1254  for (y = tile->coord[1][0]; y < tile->coord[1][1]; y = (y/step_y + 1)*step_y) {
1255  for (x = tile->coord[0][0]; x < tile->coord[0][1]; x = (x/step_x + 1)*step_x) {
1256  for (compno = CSpoc; compno < CEpoc; compno++) {
1257  Jpeg2000Component *comp = tile->comp + compno;
1258  Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1259  Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
1260  uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1261  Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1262  unsigned prcx, prcy;
1263 
1264  int xc = x / s->cdx[compno];
1265  int yc = y / s->cdy[compno];
1266 
1267  if (reslevelno >= codsty->nreslevels)
1268  continue;
1269 
1270  if (yc % (1LL << (rlevel->log2_prec_height + reducedresno)) && y != tile->coord[1][0]) //FIXME this is a subset of the check
1271  continue;
1272 
1273  if (xc % (1LL << (rlevel->log2_prec_width + reducedresno)) && x != tile->coord[0][0]) //FIXME this is a subset of the check
1274  continue;
1275 
1276  // check if a precinct exists
1277  prcx = ff_jpeg2000_ceildivpow2(xc, reducedresno) >> rlevel->log2_prec_width;
1278  prcy = ff_jpeg2000_ceildivpow2(yc, reducedresno) >> rlevel->log2_prec_height;
1279  prcx -= ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], reducedresno) >> rlevel->log2_prec_width;
1280  prcy -= ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], reducedresno) >> rlevel->log2_prec_height;
1281 
1282  precno = prcx + rlevel->num_precincts_x * prcy;
1283 
1284  ok_reslevel = 1;
1285  if (prcx >= rlevel->num_precincts_x || prcy >= rlevel->num_precincts_y) {
1286  av_log(s->avctx, AV_LOG_WARNING, "prc %d %d outside limits %d %d\n",
1287  prcx, prcy, rlevel->num_precincts_x, rlevel->num_precincts_y);
1288  continue;
1289  }
1290 
1291  for (layno = 0; layno < LYEpoc; layno++) {
1292  if ((ret = jpeg2000_decode_packet(s, tile, tp_index,
1293  codsty, rlevel,
1294  precno, layno,
1295  qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1296  qntsty->nguardbits)) < 0)
1297  return ret;
1298  }
1299  }
1300  }
1301  }
1302  }
1303  break;
1304 
1305  case JPEG2000_PGOD_PCRL:
1306  av_log(s->avctx, AV_LOG_WARNING, "Progression order PCRL\n");
1307  step_x = 32;
1308  step_y = 32;
1309  for (compno = CSpoc; compno < CEpoc; compno++) {
1310  Jpeg2000Component *comp = tile->comp + compno;
1311  Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1312 
1313  for (reslevelno = RSpoc; reslevelno < FFMIN(codsty->nreslevels, REpoc); reslevelno++) {
1314  uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1315  Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1316  step_x = FFMIN(step_x, rlevel->log2_prec_width + reducedresno);
1317  step_y = FFMIN(step_y, rlevel->log2_prec_height + reducedresno);
1318  }
1319  }
1320  if (step_x >= 31 || step_y >= 31){
1321  avpriv_request_sample(s->avctx, "PCRL with large step");
1322  return AVERROR_PATCHWELCOME;
1323  }
1324  step_x = 1<<step_x;
1325  step_y = 1<<step_y;
1326 
1327  for (y = tile->coord[1][0]; y < tile->coord[1][1]; y = (y/step_y + 1)*step_y) {
1328  for (x = tile->coord[0][0]; x < tile->coord[0][1]; x = (x/step_x + 1)*step_x) {
1329  for (compno = CSpoc; compno < CEpoc; compno++) {
1330  Jpeg2000Component *comp = tile->comp + compno;
1331  Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1332  Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
1333  int xc = x / s->cdx[compno];
1334  int yc = y / s->cdy[compno];
1335 
1336  for (reslevelno = RSpoc; reslevelno < FFMIN(codsty->nreslevels, REpoc); reslevelno++) {
1337  unsigned prcx, prcy;
1338  uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1339  Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1340 
1341  if (yc % (1LL << (rlevel->log2_prec_height + reducedresno)) && y != tile->coord[1][0]) //FIXME this is a subset of the check
1342  continue;
1343 
1344  if (xc % (1LL << (rlevel->log2_prec_width + reducedresno)) && x != tile->coord[0][0]) //FIXME this is a subset of the check
1345  continue;
1346 
1347  // check if a precinct exists
1348  prcx = ff_jpeg2000_ceildivpow2(xc, reducedresno) >> rlevel->log2_prec_width;
1349  prcy = ff_jpeg2000_ceildivpow2(yc, reducedresno) >> rlevel->log2_prec_height;
1350  prcx -= ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], reducedresno) >> rlevel->log2_prec_width;
1351  prcy -= ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], reducedresno) >> rlevel->log2_prec_height;
1352 
1353  precno = prcx + rlevel->num_precincts_x * prcy;
1354 
1355  if (prcx >= rlevel->num_precincts_x || prcy >= rlevel->num_precincts_y) {
1356  av_log(s->avctx, AV_LOG_WARNING, "prc %d %d outside limits %d %d\n",
1357  prcx, prcy, rlevel->num_precincts_x, rlevel->num_precincts_y);
1358  continue;
1359  }
1360 
1361  for (layno = 0; layno < LYEpoc; layno++) {
1362  if ((ret = jpeg2000_decode_packet(s, tile, tp_index, codsty, rlevel,
1363  precno, layno,
1364  qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1365  qntsty->nguardbits)) < 0)
1366  return ret;
1367  }
1368  }
1369  }
1370  }
1371  }
1372  break;
1373 
1374  default:
1375  break;
1376  }
1377 
1378  return ret;
1379 }
1380 
1382 {
1383  int ret = AVERROR_BUG;
1384  int i;
1385  int tp_index = 0;
1386 
1387  s->bit_index = 8;
1388  if (tile->poc.nb_poc) {
1389  for (i=0; i<tile->poc.nb_poc; i++) {
1390  Jpeg2000POCEntry *e = &tile->poc.poc[i];
1392  e->RSpoc, e->CSpoc,
1393  FFMIN(e->LYEpoc, tile->codsty[0].nlayers),
1394  e->REpoc,
1395  FFMIN(e->CEpoc, s->ncomponents),
1396  e->Ppoc, &tp_index
1397  );
1398  if (ret < 0)
1399  return ret;
1400  }
1401  } else {
1403  0, 0,
1404  tile->codsty[0].nlayers,
1405  33,
1406  s->ncomponents,
1407  tile->codsty[0].prog_order,
1408  &tp_index
1409  );
1410  }
1411  /* EOC marker reached */
1412  bytestream2_skip(&s->g, 2);
1413 
1414  return ret;
1415 }
1416 
1417 /* TIER-1 routines */
1419  int bpno, int bandno,
1420  int vert_causal_ctx_csty_symbol)
1421 {
1422  int mask = 3 << (bpno - 1), y0, x, y;
1423 
1424  for (y0 = 0; y0 < height; y0 += 4)
1425  for (x = 0; x < width; x++)
1426  for (y = y0; y < height && y < y0 + 4; y++) {
1427  int flags_mask = -1;
1428  if (vert_causal_ctx_csty_symbol && y == y0 + 3)
1430  if ((t1->flags[(y+1) * t1->stride + x+1] & JPEG2000_T1_SIG_NB & flags_mask)
1431  && !(t1->flags[(y+1) * t1->stride + x+1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS))) {
1432  if (ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ff_jpeg2000_getsigctxno(t1->flags[(y+1) * t1->stride + x+1] & flags_mask, bandno))) {
1433  int xorbit, ctxno = ff_jpeg2000_getsgnctxno(t1->flags[(y+1) * t1->stride + x+1] & flags_mask, &xorbit);
1434  if (t1->mqc.raw)
1435  t1->data[(y) * t1->stride + x] = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ctxno) ? -mask : mask;
1436  else
1437  t1->data[(y) * t1->stride + x] = (ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ctxno) ^ xorbit) ?
1438  -mask : mask;
1439 
1441  t1->data[(y) * t1->stride + x] < 0);
1442  }
1443  t1->flags[(y + 1) * t1->stride + x + 1] |= JPEG2000_T1_VIS;
1444  }
1445  }
1446 }
1447 
1449  int bpno, int vert_causal_ctx_csty_symbol)
1450 {
1451  int phalf, nhalf;
1452  int y0, x, y;
1453 
1454  phalf = 1 << (bpno - 1);
1455  nhalf = -phalf;
1456 
1457  for (y0 = 0; y0 < height; y0 += 4)
1458  for (x = 0; x < width; x++)
1459  for (y = y0; y < height && y < y0 + 4; y++)
1460  if ((t1->flags[(y + 1) * t1->stride + x + 1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS)) == JPEG2000_T1_SIG) {
1461  int flags_mask = (vert_causal_ctx_csty_symbol && y == y0 + 3) ?
1463  int ctxno = ff_jpeg2000_getrefctxno(t1->flags[(y + 1) * t1->stride + x + 1] & flags_mask);
1464  int r = ff_mqc_decode(&t1->mqc,
1465  t1->mqc.cx_states + ctxno)
1466  ? phalf : nhalf;
1467  t1->data[(y) * t1->stride + x] += t1->data[(y) * t1->stride + x] < 0 ? -r : r;
1468  t1->flags[(y + 1) * t1->stride + x + 1] |= JPEG2000_T1_REF;
1469  }
1470 }
1471 
1473  int width, int height, int bpno, int bandno,
1474  int seg_symbols, int vert_causal_ctx_csty_symbol)
1475 {
1476  int mask = 3 << (bpno - 1), y0, x, y, runlen, dec;
1477 
1478  for (y0 = 0; y0 < height; y0 += 4) {
1479  for (x = 0; x < width; x++) {
1480  int flags_mask = -1;
1481  if (vert_causal_ctx_csty_symbol)
1483  if (y0 + 3 < height &&
1484  !((t1->flags[(y0 + 1) * t1->stride + x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
1485  (t1->flags[(y0 + 2) * t1->stride + x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
1486  (t1->flags[(y0 + 3) * t1->stride + x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
1487  (t1->flags[(y0 + 4) * t1->stride + x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG) & flags_mask))) {
1488  if (!ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_RL))
1489  continue;
1490  runlen = ff_mqc_decode(&t1->mqc,
1491  t1->mqc.cx_states + MQC_CX_UNI);
1492  runlen = (runlen << 1) | ff_mqc_decode(&t1->mqc,
1493  t1->mqc.cx_states +
1494  MQC_CX_UNI);
1495  dec = 1;
1496  } else {
1497  runlen = 0;
1498  dec = 0;
1499  }
1500 
1501  for (y = y0 + runlen; y < y0 + 4 && y < height; y++) {
1502  int flags_mask = -1;
1503  if (vert_causal_ctx_csty_symbol && y == y0 + 3)
1505  if (!dec) {
1506  if (!(t1->flags[(y+1) * t1->stride + x+1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS))) {
1507  dec = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ff_jpeg2000_getsigctxno(t1->flags[(y+1) * t1->stride + x+1] & flags_mask,
1508  bandno));
1509  }
1510  }
1511  if (dec) {
1512  int xorbit;
1513  int ctxno = ff_jpeg2000_getsgnctxno(t1->flags[(y + 1) * t1->stride + x + 1] & flags_mask,
1514  &xorbit);
1515  t1->data[(y) * t1->stride + x] = (ff_mqc_decode(&t1->mqc,
1516  t1->mqc.cx_states + ctxno) ^
1517  xorbit)
1518  ? -mask : mask;
1519  ff_jpeg2000_set_significance(t1, x, y, t1->data[(y) * t1->stride + x] < 0);
1520  }
1521  dec = 0;
1522  t1->flags[(y + 1) * t1->stride + x + 1] &= ~JPEG2000_T1_VIS;
1523  }
1524  }
1525  }
1526  if (seg_symbols) {
1527  int val;
1528  val = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1529  val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1530  val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1531  val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1532  if (val != 0xa)
1534  "Segmentation symbol value incorrect\n");
1535  }
1536 }
1537 
1540  int width, int height, int bandpos)
1541 {
1542  int passno = cblk->npasses, pass_t = 2, bpno = cblk->nonzerobits - 1;
1543  int pass_cnt = 0;
1544  int vert_causal_ctx_csty_symbol = codsty->cblk_style & JPEG2000_CBLK_VSC;
1545  int term_cnt = 0;
1546  int coder_type;
1547 
1548  av_assert0(width <= 1024U && height <= 1024U);
1549  av_assert0(width*height <= 4096);
1550 
1551  memset(t1->data, 0, t1->stride * height * sizeof(*t1->data));
1552 
1553  /* If code-block contains no compressed data: nothing to do. */
1554  if (!cblk->length)
1555  return 0;
1556 
1557  memset(t1->flags, 0, t1->stride * (height + 2) * sizeof(*t1->flags));
1558 
1559  cblk->data[cblk->length] = 0xff;
1560  cblk->data[cblk->length+1] = 0xff;
1561  ff_mqc_initdec(&t1->mqc, cblk->data, 0, 1);
1562 
1563  while (passno--) {
1564  if (bpno < 0) {
1565  av_log(s->avctx, AV_LOG_ERROR, "bpno became negative\n");
1566  return AVERROR_INVALIDDATA;
1567  }
1568  switch(pass_t) {
1569  case 0:
1570  decode_sigpass(t1, width, height, bpno + 1, bandpos,
1571  vert_causal_ctx_csty_symbol);
1572  break;
1573  case 1:
1574  decode_refpass(t1, width, height, bpno + 1, vert_causal_ctx_csty_symbol);
1575  break;
1576  case 2:
1577  av_assert2(!t1->mqc.raw);
1578  decode_clnpass(s, t1, width, height, bpno + 1, bandpos,
1579  codsty->cblk_style & JPEG2000_CBLK_SEGSYM,
1580  vert_causal_ctx_csty_symbol);
1581  break;
1582  }
1583  if (codsty->cblk_style & JPEG2000_CBLK_RESET) // XXX no testcase for just this
1584  ff_mqc_init_contexts(&t1->mqc);
1585 
1586  if (passno && (coder_type = needs_termination(codsty->cblk_style, pass_cnt))) {
1587  if (term_cnt >= cblk->nb_terminations) {
1588  av_log(s->avctx, AV_LOG_ERROR, "Missing needed termination \n");
1589  return AVERROR_INVALIDDATA;
1590  }
1591  if (FFABS(cblk->data + cblk->data_start[term_cnt + 1] - 2 - t1->mqc.bp) > 0) {
1592  av_log(s->avctx, AV_LOG_WARNING, "Mid mismatch %"PTRDIFF_SPECIFIER" in pass %d of %d\n",
1593  cblk->data + cblk->data_start[term_cnt + 1] - 2 - t1->mqc.bp,
1594  pass_cnt, cblk->npasses);
1595  }
1596 
1597  ff_mqc_initdec(&t1->mqc, cblk->data + cblk->data_start[++term_cnt], coder_type == 2, 0);
1598  }
1599 
1600  pass_t++;
1601  if (pass_t == 3) {
1602  bpno--;
1603  pass_t = 0;
1604  }
1605  pass_cnt ++;
1606  }
1607 
1608  if (cblk->data + cblk->length - 2*(term_cnt < cblk->nb_terminations) != t1->mqc.bp) {
1609  av_log(s->avctx, AV_LOG_WARNING, "End mismatch %"PTRDIFF_SPECIFIER"\n",
1610  cblk->data + cblk->length - 2*(term_cnt < cblk->nb_terminations) - t1->mqc.bp);
1611  }
1612 
1613  return 1;
1614 }
1615 
1616 /* TODO: Verify dequantization for lossless case
1617  * comp->data can be float or int
1618  * band->stepsize can be float or int
1619  * depending on the type of DWT transformation.
1620  * see ISO/IEC 15444-1:2002 A.6.1 */
1621 
1622 /* Float dequantization of a codeblock.*/
1623 static void dequantization_float(int x, int y, Jpeg2000Cblk *cblk,
1626 {
1627  int i, j;
1628  int w = cblk->coord[0][1] - cblk->coord[0][0];
1629  for (j = 0; j < (cblk->coord[1][1] - cblk->coord[1][0]); ++j) {
1630  float *datap = &comp->f_data[(comp->coord[0][1] - comp->coord[0][0]) * (y + j) + x];
1631  int *src = t1->data + j*t1->stride;
1632  for (i = 0; i < w; ++i)
1633  datap[i] = src[i] * band->f_stepsize;
1634  }
1635 }
1636 
1637 /* Integer dequantization of a codeblock.*/
1638 static void dequantization_int(int x, int y, Jpeg2000Cblk *cblk,
1641 {
1642  int i, j;
1643  int w = cblk->coord[0][1] - cblk->coord[0][0];
1644  for (j = 0; j < (cblk->coord[1][1] - cblk->coord[1][0]); ++j) {
1645  int32_t *datap = &comp->i_data[(comp->coord[0][1] - comp->coord[0][0]) * (y + j) + x];
1646  int *src = t1->data + j*t1->stride;
1647  if (band->i_stepsize == 32768) {
1648  for (i = 0; i < w; ++i)
1649  datap[i] = src[i] / 2;
1650  } else {
1651  // This should be VERY uncommon
1652  for (i = 0; i < w; ++i)
1653  datap[i] = (src[i] * (int64_t)band->i_stepsize) / 65536;
1654  }
1655  }
1656 }
1657 
1658 static void dequantization_int_97(int x, int y, Jpeg2000Cblk *cblk,
1661 {
1662  int i, j;
1663  int w = cblk->coord[0][1] - cblk->coord[0][0];
1664  for (j = 0; j < (cblk->coord[1][1] - cblk->coord[1][0]); ++j) {
1665  int32_t *datap = &comp->i_data[(comp->coord[0][1] - comp->coord[0][0]) * (y + j) + x];
1666  int *src = t1->data + j*t1->stride;
1667  for (i = 0; i < w; ++i)
1668  datap[i] = (src[i] * (int64_t)band->i_stepsize + (1<<15)) >> 16;
1669  }
1670 }
1671 
1673 {
1674  int i, csize = 1;
1675  void *src[3];
1676 
1677  for (i = 1; i < 3; i++) {
1678  if (tile->codsty[0].transform != tile->codsty[i].transform) {
1679  av_log(s->avctx, AV_LOG_ERROR, "Transforms mismatch, MCT not supported\n");
1680  return;
1681  }
1682  if (memcmp(tile->comp[0].coord, tile->comp[i].coord, sizeof(tile->comp[0].coord))) {
1683  av_log(s->avctx, AV_LOG_ERROR, "Coords mismatch, MCT not supported\n");
1684  return;
1685  }
1686  }
1687 
1688  for (i = 0; i < 3; i++)
1689  if (tile->codsty[0].transform == FF_DWT97)
1690  src[i] = tile->comp[i].f_data;
1691  else
1692  src[i] = tile->comp[i].i_data;
1693 
1694  for (i = 0; i < 2; i++)
1695  csize *= tile->comp[0].coord[i][1] - tile->comp[0].coord[i][0];
1696 
1697  s->dsp.mct_decode[tile->codsty[0].transform](src[0], src[1], src[2], csize);
1698 }
1699 
1701 {
1703 
1704  int compno, reslevelno, bandno;
1705 
1706  /* Loop on tile components */
1707  for (compno = 0; compno < s->ncomponents; compno++) {
1708  Jpeg2000Component *comp = tile->comp + compno;
1709  Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1710  int coded = 0;
1711 
1712  t1.stride = (1<<codsty->log2_cblk_width) + 2;
1713 
1714  /* Loop on resolution levels */
1715  for (reslevelno = 0; reslevelno < codsty->nreslevels2decode; reslevelno++) {
1716  Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1717  /* Loop on bands */
1718  for (bandno = 0; bandno < rlevel->nbands; bandno++) {
1719  int nb_precincts, precno;
1720  Jpeg2000Band *band = rlevel->band + bandno;
1721  int cblkno = 0, bandpos;
1722 
1723  bandpos = bandno + (reslevelno > 0);
1724 
1725  if (band->coord[0][0] == band->coord[0][1] ||
1726  band->coord[1][0] == band->coord[1][1])
1727  continue;
1728 
1729  nb_precincts = rlevel->num_precincts_x * rlevel->num_precincts_y;
1730  /* Loop on precincts */
1731  for (precno = 0; precno < nb_precincts; precno++) {
1732  Jpeg2000Prec *prec = band->prec + precno;
1733 
1734  /* Loop on codeblocks */
1735  for (cblkno = 0;
1736  cblkno < prec->nb_codeblocks_width * prec->nb_codeblocks_height;
1737  cblkno++) {
1738  int x, y;
1739  Jpeg2000Cblk *cblk = prec->cblk + cblkno;
1740  int ret = decode_cblk(s, codsty, &t1, cblk,
1741  cblk->coord[0][1] - cblk->coord[0][0],
1742  cblk->coord[1][1] - cblk->coord[1][0],
1743  bandpos);
1744  if (ret)
1745  coded = 1;
1746  else
1747  continue;
1748  x = cblk->coord[0][0] - band->coord[0][0];
1749  y = cblk->coord[1][0] - band->coord[1][0];
1750 
1751  if (codsty->transform == FF_DWT97)
1752  dequantization_float(x, y, cblk, comp, &t1, band);
1753  else if (codsty->transform == FF_DWT97_INT)
1754  dequantization_int_97(x, y, cblk, comp, &t1, band);
1755  else
1756  dequantization_int(x, y, cblk, comp, &t1, band);
1757  } /* end cblk */
1758  } /*end prec */
1759  } /* end band */
1760  } /* end reslevel */
1761 
1762  /* inverse DWT */
1763  if (coded)
1764  ff_dwt_decode(&comp->dwt, codsty->transform == FF_DWT97 ? (void*)comp->f_data : (void*)comp->i_data);
1765 
1766  } /*end comp */
1767 }
1768 
1769 #define WRITE_FRAME(D, PIXEL) \
1770  static inline void write_frame_ ## D(Jpeg2000DecoderContext * s, Jpeg2000Tile * tile, \
1771  AVFrame * picture, int precision) \
1772  { \
1773  const AVPixFmtDescriptor *pixdesc = av_pix_fmt_desc_get(s->avctx->pix_fmt); \
1774  int planar = !!(pixdesc->flags & AV_PIX_FMT_FLAG_PLANAR); \
1775  int pixelsize = planar ? 1 : pixdesc->nb_components; \
1776  \
1777  int compno; \
1778  int x, y; \
1779  \
1780  for (compno = 0; compno < s->ncomponents; compno++) { \
1781  Jpeg2000Component *comp = tile->comp + compno; \
1782  Jpeg2000CodingStyle *codsty = tile->codsty + compno; \
1783  PIXEL *line; \
1784  float *datap = comp->f_data; \
1785  int32_t *i_datap = comp->i_data; \
1786  int cbps = s->cbps[compno]; \
1787  int w = tile->comp[compno].coord[0][1] - s->image_offset_x; \
1788  int plane = 0; \
1789  \
1790  if (planar) \
1791  plane = s->cdef[compno] ? s->cdef[compno]-1 : (s->ncomponents-1); \
1792  \
1793  y = tile->comp[compno].coord[1][0] - s->image_offset_y / s->cdy[compno]; \
1794  line = (PIXEL *)picture->data[plane] + y * (picture->linesize[plane] / sizeof(PIXEL));\
1795  for (; y < tile->comp[compno].coord[1][1] - s->image_offset_y; y++) { \
1796  PIXEL *dst; \
1797  \
1798  x = tile->comp[compno].coord[0][0] - s->image_offset_x / s->cdx[compno]; \
1799  dst = line + x * pixelsize + compno*!planar; \
1800  \
1801  if (codsty->transform == FF_DWT97) { \
1802  for (; x < w; x++) { \
1803  int val = lrintf(*datap) + (1 << (cbps - 1)); \
1804  /* DC level shift and clip see ISO 15444-1:2002 G.1.2 */ \
1805  val = av_clip(val, 0, (1 << cbps) - 1); \
1806  *dst = val << (precision - cbps); \
1807  datap++; \
1808  dst += pixelsize; \
1809  } \
1810  } else { \
1811  for (; x < w; x++) { \
1812  int val = *i_datap + (1 << (cbps - 1)); \
1813  /* DC level shift and clip see ISO 15444-1:2002 G.1.2 */ \
1814  val = av_clip(val, 0, (1 << cbps) - 1); \
1815  *dst = val << (precision - cbps); \
1816  i_datap++; \
1817  dst += pixelsize; \
1818  } \
1819  } \
1820  line += picture->linesize[plane] / sizeof(PIXEL); \
1821  } \
1822  } \
1823  \
1824  }
1825 
1826 WRITE_FRAME(8, uint8_t)
1827 WRITE_FRAME(16, uint16_t)
1828 
1829 #undef WRITE_FRAME
1830 
1831 static int jpeg2000_decode_tile(AVCodecContext *avctx, void *td,
1832  int jobnr, int threadnr)
1833 {
1835  AVFrame *picture = td;
1836  Jpeg2000Tile *tile = s->tile + jobnr;
1837  int x;
1838 
1839  tile_codeblocks(s, tile);
1840 
1841  /* inverse MCT transformation */
1842  if (tile->codsty[0].mct)
1843  mct_decode(s, tile);
1844 
1845  for (x = 0; x < s->ncomponents; x++) {
1846  if (s->cdef[x] < 0) {
1847  for (x = 0; x < s->ncomponents; x++) {
1848  s->cdef[x] = x + 1;
1849  }
1850  if ((s->ncomponents & 1) == 0)
1851  s->cdef[s->ncomponents-1] = 0;
1852  break;
1853  }
1854  }
1855 
1856  if (s->precision <= 8) {
1857  write_frame_8(s, tile, picture, 8);
1858  } else {
1859  int precision = picture->format == AV_PIX_FMT_XYZ12 ||
1860  picture->format == AV_PIX_FMT_RGB48 ||
1861  picture->format == AV_PIX_FMT_RGBA64 ||
1862  picture->format == AV_PIX_FMT_GRAY16 ? 16 : s->precision;
1863 
1864  write_frame_16(s, tile, picture, precision);
1865  }
1866 
1867  return 0;
1868 }
1869 
1871 {
1872  int tileno, compno;
1873  for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++) {
1874  if (s->tile[tileno].comp) {
1875  for (compno = 0; compno < s->ncomponents; compno++) {
1876  Jpeg2000Component *comp = s->tile[tileno].comp + compno;
1877  Jpeg2000CodingStyle *codsty = s->tile[tileno].codsty + compno;
1878 
1879  ff_jpeg2000_cleanup(comp, codsty);
1880  }
1881  av_freep(&s->tile[tileno].comp);
1882  }
1883  }
1884  av_freep(&s->tile);
1885  memset(s->codsty, 0, sizeof(s->codsty));
1886  memset(s->qntsty, 0, sizeof(s->qntsty));
1887  memset(s->properties, 0, sizeof(s->properties));
1888  memset(&s->poc , 0, sizeof(s->poc));
1889  s->numXtiles = s->numYtiles = 0;
1890  s->ncomponents = 0;
1891 }
1892 
1894 {
1895  Jpeg2000CodingStyle *codsty = s->codsty;
1896  Jpeg2000QuantStyle *qntsty = s->qntsty;
1897  Jpeg2000POC *poc = &s->poc;
1898  uint8_t *properties = s->properties;
1899 
1900  for (;;) {
1901  int len, ret = 0;
1902  uint16_t marker;
1903  int oldpos;
1904 
1905  if (bytestream2_get_bytes_left(&s->g) < 2) {
1906  av_log(s->avctx, AV_LOG_ERROR, "Missing EOC\n");
1907  break;
1908  }
1909 
1910  marker = bytestream2_get_be16u(&s->g);
1911  oldpos = bytestream2_tell(&s->g);
1912 
1913  if (marker == JPEG2000_SOD) {
1914  Jpeg2000Tile *tile;
1915  Jpeg2000TilePart *tp;
1916 
1917  if (!s->tile) {
1918  av_log(s->avctx, AV_LOG_ERROR, "Missing SIZ\n");
1919  return AVERROR_INVALIDDATA;
1920  }
1921  if (s->curtileno < 0) {
1922  av_log(s->avctx, AV_LOG_ERROR, "Missing SOT\n");
1923  return AVERROR_INVALIDDATA;
1924  }
1925 
1926  tile = s->tile + s->curtileno;
1927  tp = tile->tile_part + tile->tp_idx;
1928  if (tp->tp_end < s->g.buffer) {
1929  av_log(s->avctx, AV_LOG_ERROR, "Invalid tpend\n");
1930  return AVERROR_INVALIDDATA;
1931  }
1932  bytestream2_init(&tp->tpg, s->g.buffer, tp->tp_end - s->g.buffer);
1933  bytestream2_skip(&s->g, tp->tp_end - s->g.buffer);
1934 
1935  continue;
1936  }
1937  if (marker == JPEG2000_EOC)
1938  break;
1939 
1940  len = bytestream2_get_be16(&s->g);
1941  if (len < 2 || bytestream2_get_bytes_left(&s->g) < len - 2) {
1943  av_log(s->avctx, AV_LOG_ERROR, "Invalid len %d left=%d\n", len, bytestream2_get_bytes_left(&s->g));
1944  return AVERROR_INVALIDDATA;
1945  }
1946  av_log(s->avctx, AV_LOG_WARNING, "Missing EOC Marker.\n");
1947  break;
1948  }
1949 
1950  switch (marker) {
1951  case JPEG2000_SIZ:
1952  if (s->ncomponents) {
1953  av_log(s->avctx, AV_LOG_ERROR, "Duplicate SIZ\n");
1954  return AVERROR_INVALIDDATA;
1955  }
1956  ret = get_siz(s);
1957  if (!s->tile)
1958  s->numXtiles = s->numYtiles = 0;
1959  break;
1960  case JPEG2000_COC:
1961  ret = get_coc(s, codsty, properties);
1962  break;
1963  case JPEG2000_COD:
1964  ret = get_cod(s, codsty, properties);
1965  break;
1966  case JPEG2000_QCC:
1967  ret = get_qcc(s, len, qntsty, properties);
1968  break;
1969  case JPEG2000_QCD:
1970  ret = get_qcd(s, len, qntsty, properties);
1971  break;
1972  case JPEG2000_POC:
1973  ret = get_poc(s, len, poc);
1974  break;
1975  case JPEG2000_SOT:
1976  if (!(ret = get_sot(s, len))) {
1977  av_assert1(s->curtileno >= 0);
1978  codsty = s->tile[s->curtileno].codsty;
1979  qntsty = s->tile[s->curtileno].qntsty;
1980  poc = &s->tile[s->curtileno].poc;
1981  properties = s->tile[s->curtileno].properties;
1982  }
1983  break;
1984  case JPEG2000_PLM:
1985  // the PLM marker is ignored
1986  case JPEG2000_COM:
1987  // the comment is ignored
1988  bytestream2_skip(&s->g, len - 2);
1989  break;
1990  case JPEG2000_TLM:
1991  // Tile-part lengths
1992  ret = get_tlm(s, len);
1993  break;
1994  case JPEG2000_PLT:
1995  // Packet length, tile-part header
1996  ret = get_plt(s, len);
1997  break;
1998  default:
2000  "unsupported marker 0x%.4"PRIX16" at pos 0x%X\n",
2001  marker, bytestream2_tell(&s->g) - 4);
2002  bytestream2_skip(&s->g, len - 2);
2003  break;
2004  }
2005  if (bytestream2_tell(&s->g) - oldpos != len || ret) {
2007  "error during processing marker segment %.4"PRIx16"\n",
2008  marker);
2009  return ret ? ret : -1;
2010  }
2011  }
2012  return 0;
2013 }
2014 
2015 /* Read bit stream packets --> T2 operation. */
2017 {
2018  int ret = 0;
2019  int tileno;
2020 
2021  for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++) {
2022  Jpeg2000Tile *tile = s->tile + tileno;
2023 
2024  if ((ret = init_tile(s, tileno)) < 0)
2025  return ret;
2026 
2027  s->g = tile->tile_part[0].tpg;
2028  if ((ret = jpeg2000_decode_packets(s, tile)) < 0)
2029  return ret;
2030  }
2031 
2032  return 0;
2033 }
2034 
2036 {
2037  uint32_t atom_size, atom, atom_end;
2038  int search_range = 10;
2039 
2040  while (search_range
2041  &&
2042  bytestream2_get_bytes_left(&s->g) >= 8) {
2043  atom_size = bytestream2_get_be32u(&s->g);
2044  atom = bytestream2_get_be32u(&s->g);
2045  if (atom_size == 1) {
2046  if (bytestream2_get_be32u(&s->g)) {
2047  avpriv_request_sample(s->avctx, "Huge atom");
2048  return 0;
2049  }
2050  atom_size = bytestream2_get_be32u(&s->g);
2051  atom_end = bytestream2_tell(&s->g) + atom_size - 16;
2052  } else {
2053  atom_end = bytestream2_tell(&s->g) + atom_size - 8;
2054  }
2055 
2056  if (atom == JP2_CODESTREAM)
2057  return 1;
2058 
2059  if (bytestream2_get_bytes_left(&s->g) < atom_size || atom_end < atom_size)
2060  return 0;
2061 
2062  if (atom == JP2_HEADER &&
2063  atom_size >= 16) {
2064  uint32_t atom2_size, atom2, atom2_end;
2065  do {
2066  atom2_size = bytestream2_get_be32u(&s->g);
2067  atom2 = bytestream2_get_be32u(&s->g);
2068  atom2_end = bytestream2_tell(&s->g) + atom2_size - 8;
2069  if (atom2_size < 8 || atom2_end > atom_end || atom2_end < atom2_size)
2070  break;
2071  atom2_size -= 8;
2072  if (atom2 == JP2_CODESTREAM) {
2073  return 1;
2074  } else if (atom2 == MKBETAG('c','o','l','r') && atom2_size >= 7) {
2075  int method = bytestream2_get_byteu(&s->g);
2076  bytestream2_skipu(&s->g, 2);
2077  if (method == 1) {
2078  s->colour_space = bytestream2_get_be32u(&s->g);
2079  }
2080  } else if (atom2 == MKBETAG('p','c','l','r') && atom2_size >= 6) {
2081  int i, size, colour_count, colour_channels, colour_depth[3];
2082  colour_count = bytestream2_get_be16u(&s->g);
2083  colour_channels = bytestream2_get_byteu(&s->g);
2084  // FIXME: Do not ignore channel_sign
2085  colour_depth[0] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1;
2086  colour_depth[1] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1;
2087  colour_depth[2] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1;
2088  size = (colour_depth[0] + 7 >> 3) * colour_count +
2089  (colour_depth[1] + 7 >> 3) * colour_count +
2090  (colour_depth[2] + 7 >> 3) * colour_count;
2091  if (colour_count > AVPALETTE_COUNT ||
2092  colour_channels != 3 ||
2093  colour_depth[0] > 16 ||
2094  colour_depth[1] > 16 ||
2095  colour_depth[2] > 16 ||
2096  atom2_size < size) {
2097  avpriv_request_sample(s->avctx, "Unknown palette");
2098  bytestream2_seek(&s->g, atom2_end, SEEK_SET);
2099  continue;
2100  }
2101  s->pal8 = 1;
2102  for (i = 0; i < colour_count; i++) {
2103  uint32_t r, g, b;
2104  if (colour_depth[0] <= 8) {
2105  r = bytestream2_get_byteu(&s->g) << 8 - colour_depth[0];
2106  r |= r >> colour_depth[0];
2107  } else {
2108  r = bytestream2_get_be16u(&s->g) >> colour_depth[0] - 8;
2109  }
2110  if (colour_depth[1] <= 8) {
2111  g = bytestream2_get_byteu(&s->g) << 8 - colour_depth[1];
2112  g |= g >> colour_depth[1];
2113  } else {
2114  g = bytestream2_get_be16u(&s->g) >> colour_depth[1] - 8;
2115  }
2116  if (colour_depth[2] <= 8) {
2117  b = bytestream2_get_byteu(&s->g) << 8 - colour_depth[2];
2118  b |= b >> colour_depth[2];
2119  } else {
2120  b = bytestream2_get_be16u(&s->g) >> colour_depth[2] - 8;
2121  }
2122  s->palette[i] = 0xffu << 24 | r << 16 | g << 8 | b;
2123  }
2124  } else if (atom2 == MKBETAG('c','d','e','f') && atom2_size >= 2) {
2125  int n = bytestream2_get_be16u(&s->g);
2126  for (; n>0; n--) {
2127  int cn = bytestream2_get_be16(&s->g);
2128  int av_unused typ = bytestream2_get_be16(&s->g);
2129  int asoc = bytestream2_get_be16(&s->g);
2130  if (cn < 4 && asoc < 4)
2131  s->cdef[cn] = asoc;
2132  }
2133  } else if (atom2 == MKBETAG('r','e','s',' ') && atom2_size >= 18) {
2134  int64_t vnum, vden, hnum, hden, vexp, hexp;
2135  uint32_t resx;
2136  bytestream2_skip(&s->g, 4);
2137  resx = bytestream2_get_be32u(&s->g);
2138  if (resx != MKBETAG('r','e','s','c') && resx != MKBETAG('r','e','s','d')) {
2139  bytestream2_seek(&s->g, atom2_end, SEEK_SET);
2140  continue;
2141  }
2142  vnum = bytestream2_get_be16u(&s->g);
2143  vden = bytestream2_get_be16u(&s->g);
2144  hnum = bytestream2_get_be16u(&s->g);
2145  hden = bytestream2_get_be16u(&s->g);
2146  vexp = bytestream2_get_byteu(&s->g);
2147  hexp = bytestream2_get_byteu(&s->g);
2148  if (!vnum || !vden || !hnum || !hden) {
2149  bytestream2_seek(&s->g, atom2_end, SEEK_SET);
2150  av_log(s->avctx, AV_LOG_WARNING, "RES box invalid\n");
2151  continue;
2152  }
2153  if (vexp > hexp) {
2154  vexp -= hexp;
2155  hexp = 0;
2156  } else {
2157  hexp -= vexp;
2158  vexp = 0;
2159  }
2160  if ( INT64_MAX / (hnum * vden) > pow(10, hexp)
2161  && INT64_MAX / (vnum * hden) > pow(10, vexp))
2162  av_reduce(&s->sar.den, &s->sar.num,
2163  hnum * vden * pow(10, hexp),
2164  vnum * hden * pow(10, vexp),
2165  INT32_MAX);
2166  }
2167  bytestream2_seek(&s->g, atom2_end, SEEK_SET);
2168  } while (atom_end - atom2_end >= 8);
2169  } else {
2170  search_range--;
2171  }
2172  bytestream2_seek(&s->g, atom_end, SEEK_SET);
2173  }
2174 
2175  return 0;
2176 }
2177 
2179 {
2182 }
2183 
2185 {
2186  static AVOnce init_static_once = AV_ONCE_INIT;
2188 
2189  ff_thread_once(&init_static_once, jpeg2000_init_static_data);
2190  ff_jpeg2000dsp_init(&s->dsp);
2191 
2192  return 0;
2193 }
2194 
2195 static int jpeg2000_decode_frame(AVCodecContext *avctx, void *data,
2196  int *got_frame, AVPacket *avpkt)
2197 {
2199  ThreadFrame frame = { .f = data };
2200  AVFrame *picture = data;
2201  int ret;
2202 
2203  s->avctx = avctx;
2204  bytestream2_init(&s->g, avpkt->data, avpkt->size);
2205  s->curtileno = -1;
2206  memset(s->cdef, -1, sizeof(s->cdef));
2207 
2208  if (bytestream2_get_bytes_left(&s->g) < 2) {
2209  ret = AVERROR_INVALIDDATA;
2210  goto end;
2211  }
2212 
2213  // check if the image is in jp2 format
2214  if (bytestream2_get_bytes_left(&s->g) >= 12 &&
2215  (bytestream2_get_be32u(&s->g) == 12) &&
2216  (bytestream2_get_be32u(&s->g) == JP2_SIG_TYPE) &&
2217  (bytestream2_get_be32u(&s->g) == JP2_SIG_VALUE)) {
2218  if (!jp2_find_codestream(s)) {
2219  av_log(avctx, AV_LOG_ERROR,
2220  "Could not find Jpeg2000 codestream atom.\n");
2221  ret = AVERROR_INVALIDDATA;
2222  goto end;
2223  }
2224  } else {
2225  bytestream2_seek(&s->g, 0, SEEK_SET);
2226  }
2227 
2228  while (bytestream2_get_bytes_left(&s->g) >= 3 && bytestream2_peek_be16(&s->g) != JPEG2000_SOC)
2229  bytestream2_skip(&s->g, 1);
2230 
2231  if (bytestream2_get_be16u(&s->g) != JPEG2000_SOC) {
2232  av_log(avctx, AV_LOG_ERROR, "SOC marker not present\n");
2233  ret = AVERROR_INVALIDDATA;
2234  goto end;
2235  }
2236  if (ret = jpeg2000_read_main_headers(s))
2237  goto end;
2238 
2239  /* get picture buffer */
2240  if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
2241  goto end;
2242  picture->pict_type = AV_PICTURE_TYPE_I;
2243  picture->key_frame = 1;
2244 
2245  if (ret = jpeg2000_read_bitstream_packets(s))
2246  goto end;
2247 
2248  avctx->execute2(avctx, jpeg2000_decode_tile, picture, NULL, s->numXtiles * s->numYtiles);
2249 
2251 
2252  *got_frame = 1;
2253 
2254  if (s->avctx->pix_fmt == AV_PIX_FMT_PAL8)
2255  memcpy(picture->data[1], s->palette, 256 * sizeof(uint32_t));
2256  if (s->sar.num && s->sar.den)
2257  avctx->sample_aspect_ratio = s->sar;
2258  s->sar.num = s->sar.den = 0;
2259 
2260  return bytestream2_tell(&s->g);
2261 
2262 end:
2264  return ret;
2265 }
2266 
2267 #define OFFSET(x) offsetof(Jpeg2000DecoderContext, x)
2268 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
2269 
2270 static const AVOption options[] = {
2271  { "lowres", "Lower the decoding resolution by a power of two",
2272  OFFSET(reduction_factor), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, JPEG2000_MAX_RESLEVELS - 1, VD },
2273  { NULL },
2274 };
2275 
2276 static const AVClass jpeg2000_class = {
2277  .class_name = "jpeg2000",
2278  .item_name = av_default_item_name,
2279  .option = options,
2280  .version = LIBAVUTIL_VERSION_INT,
2281 };
2282 
2284  .name = "jpeg2000",
2285  .long_name = NULL_IF_CONFIG_SMALL("JPEG 2000"),
2286  .type = AVMEDIA_TYPE_VIDEO,
2287  .id = AV_CODEC_ID_JPEG2000,
2289  .priv_data_size = sizeof(Jpeg2000DecoderContext),
2292  .priv_class = &jpeg2000_class,
2293  .max_lowres = 5,
2295 };
#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:1472
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
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:2267
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:2549
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
static int jpeg2000_read_main_headers(Jpeg2000DecoderContext *s)
Definition: jpeg2000dec.c:1893
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:387
static void decode_refpass(Jpeg2000T1Context *t1, int width, int height, int bpno, int vert_causal_ctx_csty_symbol)
Definition: jpeg2000dec.c:1448
#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:1534
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:235
static void mct_decode(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
Definition: jpeg2000dec.c:1672
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:2000
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1831
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 int get_tlm(Jpeg2000DecoderContext *s, int n)
Definition: jpeg2000dec.c:798
static av_cold int jpeg2000_decode_init(AVCodecContext *avctx)
Definition: jpeg2000dec.c:2184
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:2852
uint16_t CSpoc
Definition: jpeg2000dec.c:58
static int init_tile(Jpeg2000DecoderContext *s, int tileno)
Definition: jpeg2000dec.c:858
Jpeg2000CodingStyle codsty[4]
Definition: jpeg2000dec.c:113
int profile
profile
Definition: avcodec.h:2954
AVCodec.
Definition: avcodec.h:3555
float f_stepsize
Definition: jpeg2000.h:194
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
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:1638
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:2016
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:1623
static int jpeg2000_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: jpeg2000dec.c:2195
#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:1700
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:1769
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:3284
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:252
uint8_t val
Definition: jpeg2000.h:129
int coord[2][2]
Definition: jpeg2000.h:211
#define height
uint8_t * data
Definition: avcodec.h:1533
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:172
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
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
static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:154
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
#define src
Definition: vp8dsp.c:254
int nb_terminations
Definition: jpeg2000.h:173
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
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:930
#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:904
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
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:1701
#define JPEG2000_MAX_PASSES
Definition: jpeg2000.h:73
#define AV_PIX_FMT_RGB48
Definition: pixfmt.h:383
simple assert() macros that are a bit more flexible than ISO C assert().
const char * name
Name of the codec implementation.
Definition: avcodec.h:3562
int64_t max_pixels
The number of pixels per image to maximally accept.
Definition: avcodec.h:3348
#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:1055
#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:2276
#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:378
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:926
#define AV_PIX_FMT_GRAY16
Definition: pixfmt.h:381
#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:2268
#define FF_PROFILE_JPEG2000_DCINEMA_4K
Definition: avcodec.h:3035
#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:1103
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:836
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:1059
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:368
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:2940
uint16_t tp_idx
Definition: jpeg2000dec.c:86
#define AV_ONCE_INIT
Definition: thread.h:173
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:1621
AVCodec ff_jpeg2000_decoder
Definition: jpeg2000dec.c:2283
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:919
#define AV_PIX_FMT_XYZ12
Definition: pixfmt.h:443
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:2178
const uint8_t * tp_end
Definition: jpeg2000dec.c:73
int decoded_layers
Definition: jpeg2000.h:186
#define FF_COMPLIANCE_STRICT
Strictly conform to all the things in the spec no matter what consequences.
Definition: avcodec.h:2686
#define JPEG2000_SOP_BYTE_LENGTH
Definition: jpeg2000.h:62
static const AVOption options[]
Definition: jpeg2000dec.c:2270
#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:309
uint8_t expn[JPEG2000_MAX_DECLEVELS *3]
Definition: jpeg2000.h:150
static int jpeg2000_decode_packets(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
Definition: jpeg2000dec.c:1381
static int get_sot(Jpeg2000DecoderContext *s, int n)
Definition: jpeg2000dec.c:737
static int jp2_find_codestream(Jpeg2000DecoderContext *s)
Definition: jpeg2000dec.c:2035
static void jpeg2000_dec_cleanup(Jpeg2000DecoderContext *s)
Definition: jpeg2000dec.c:1870
static void decode_sigpass(Jpeg2000T1Context *t1, int width, int height, int bpno, int bandno, int vert_causal_ctx_csty_symbol)
Definition: jpeg2000dec.c:1418
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:1658
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:3283
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:1648
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:175
#define FF_PROFILE_JPEG2000_DCINEMA_2K
Definition: avcodec.h:3034
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:373
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
static double val(void *priv, double ch)
Definition: aeval.c:76
This structure stores compressed data.
Definition: avcodec.h:1510
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:999
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
Definition: avcodec.h:2684
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:1538
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:1831
static uint8_t tmp[11]
Definition: aes_ctr.c:26