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