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