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