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;
59  uint8_t RSpoc;
60  uint8_t REpoc;
61  uint8_t Ppoc;
62 } Jpeg2000POCEntry;
63 
64 typedef struct Jpeg2000POC {
65  Jpeg2000POCEntry poc[MAX_POCS];
66  int nb_poc;
67  int is_default;
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
74 } Jpeg2000TilePart;
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 {
79  Jpeg2000Component *comp;
80  uint8_t properties[4];
81  Jpeg2000CodingStyle codsty[4];
82  Jpeg2000QuantStyle qntsty[4];
83  Jpeg2000POC poc;
84  Jpeg2000TilePart tile_part[256];
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;
91  AVCodecContext *avctx;
92  GetByteContext g;
93 
94  int width, height;
95  int image_offset_x, image_offset_y;
96  int tile_offset_x, tile_offset_y;
97  uint8_t cbps[4]; // bits per sample in particular components
98  uint8_t sgnd[4]; // if a component is signed
99  uint8_t properties[4];
100  int cdx[4], cdy[4];
101  int precision;
102  int ncomponents;
103  int colour_space;
104  uint32_t palette[256];
105  int8_t pal8;
106  int cdef[4];
107  int tile_width, tile_height;
108  unsigned numXtiles, numYtiles;
109  int maxtilelen;
110  AVRational sar;
111 
112  Jpeg2000CodingStyle codsty[4];
113  Jpeg2000QuantStyle qntsty[4];
114  Jpeg2000POC poc;
115 
116  int bit_index;
117 
118  int curtileno;
119 
120  Jpeg2000Tile *tile;
121  Jpeg2000DSPContext dsp;
122 
123  /*options parameters*/
124  int reduction_factor;
125 } Jpeg2000DecoderContext;
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 */
131 static int get_bits(Jpeg2000DecoderContext *s, int n)
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 
146 static void jpeg2000_flush(Jpeg2000DecoderContext *s)
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 */
154 static int tag_tree_decode(Jpeg2000DecoderContext *s, Jpeg2000TgtNode *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 
246 static const enum AVPixelFormat rgb_pix_fmts[] = {RGB_PIXEL_FORMATS};
247 static const enum AVPixelFormat gray_pix_fmts[] = {GRAY_PIXEL_FORMATS};
248 static const enum AVPixelFormat yuv_pix_fmts[] = {YUV_PIXEL_FORMATS};
249 static const enum AVPixelFormat xyz_pix_fmts[] = {XYZ_PIXEL_FORMATS,
250  YUV_PIXEL_FORMATS};
251 static const enum AVPixelFormat all_pix_fmts[] = {RGB_PIXEL_FORMATS,
252  GRAY_PIXEL_FORMATS,
253  YUV_PIXEL_FORMATS,
254  XYZ_PIXEL_FORMATS};
255 
256 /* marker segments */
257 /* get sizes and offsets of image, tiles; number of components */
258 static int get_siz(Jpeg2000DecoderContext *s)
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 
342  s->numXtiles = ff_jpeg2000_ceildiv(s->width - s->tile_offset_x, s->tile_width);
343  s->numYtiles = ff_jpeg2000_ceildiv(s->height - s->tile_offset_y, s->tile_height);
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,
366  ff_jpeg2000_ceildivpow2(s->width - s->image_offset_x,
367  s->reduction_factor),
368  ff_jpeg2000_ceildivpow2(s->height - s->image_offset_y,
369  s->reduction_factor));
370  if (ret < 0)
371  return ret;
372 
373  if (s->avctx->profile == FF_PROFILE_JPEG2000_DCINEMA_2K ||
374  s->avctx->profile == FF_PROFILE_JPEG2000_DCINEMA_4K) {
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) {
410  s->avctx->pix_fmt = AV_PIX_FMT_YUVA420P;
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) {
422  av_log(s->avctx, AV_LOG_ERROR,
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  }
440  s->avctx->bits_per_raw_sample = s->precision;
441  return 0;
442 }
443 
444 /* get common part for COD and COC segments */
445 static int get_cox(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c)
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;
457  if (c->nreslevels >= JPEG2000_MAX_RESLEVELS) {
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 */
473  c->nreslevels2decode = c->nreslevels - s->reduction_factor;
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);
487  if (c->cblk_style & JPEG2000_CBLK_BYPASS)
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) {
495  s->avctx->properties |= FF_CODEC_PROPERTY_LOSSLESS;
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*/
520 static int get_cod(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c,
521  uint8_t *properties)
522 {
523  Jpeg2000CodingStyle tmp;
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) {
540  av_log(s->avctx, AV_LOG_ERROR,
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. */
557 static int get_coc(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c,
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) {
570  av_log(s->avctx, AV_LOG_ERROR,
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. */
587 static int get_qcx(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q)
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 ||
602  n > JPEG2000_MAX_DECLEVELS*3)
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 ||
620  n > JPEG2000_MAX_DECLEVELS*3)
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. */
632 static int get_qcd(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q,
633  uint8_t *properties)
634 {
635  Jpeg2000QuantStyle tmp;
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. */
650 static int get_qcc(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q,
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) {
661  av_log(s->avctx, AV_LOG_ERROR,
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 
671 static int get_poc(Jpeg2000DecoderContext *s, int size, Jpeg2000POC *p)
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. */
733 static int get_sot(Jpeg2000DecoderContext *s, int n)
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. */
791 static uint8_t get_tlm(Jpeg2000DecoderContext *s, int n)
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 
825 static uint8_t get_plt(Jpeg2000DecoderContext *s, int n)
826 {
827  int i;
828 
829  av_log(s->avctx, AV_LOG_DEBUG,
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. */
887 static int getnpasses(Jpeg2000DecoderContext *s)
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 
902 static int getlblockinc(Jpeg2000DecoderContext *s)
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 
913 static int jpeg2000_decode_packet(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile, int *tp_index,
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)
932  bytestream2_skip(&s->g, JPEG2000_SOP_BYTE_LENGTH);
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) {
966  av_log(s->avctx, AV_LOG_ERROR,
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) {
982  avpriv_request_sample(s->avctx,
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 > sizeof(cblk->data)) {
1005  avpriv_request_sample(s->avctx,
1006  "Block with lengthinc greater than %"SIZE_SPECIFIER"",
1007  sizeof(cblk->data));
1008  return AVERROR_PATCHWELCOME;
1009  }
1010  cblk->lengthinc[cblk->nb_lengthinc++] = ret;
1011  cblk->npasses += newpasses1;
1012  newpasses -= newpasses1;
1013  } while(newpasses);
1014  }
1015  }
1016  jpeg2000_flush(s);
1017 
1018  if (codsty->csty & JPEG2000_CSTY_EPH) {
1019  if (bytestream2_peek_be16(&s->g) == JPEG2000_EPH)
1020  bytestream2_skip(&s->g, 2);
1021  else
1022  av_log(s->avctx, AV_LOG_ERROR, "EPH marker not found. instead %X\n", bytestream2_peek_be32(&s->g));
1023  }
1024 
1025  for (bandno = 0; bandno < rlevel->nbands; bandno++) {
1026  Jpeg2000Band *band = rlevel->band + bandno;
1027  Jpeg2000Prec *prec = band->prec + precno;
1028 
1029  nb_code_blocks = prec->nb_codeblocks_height * prec->nb_codeblocks_width;
1030  for (cblkno = 0; cblkno < nb_code_blocks; cblkno++) {
1031  Jpeg2000Cblk *cblk = prec->cblk + cblkno;
1032  for (cwsno = 0; cwsno < cblk->nb_lengthinc; cwsno ++) {
1033  if ( bytestream2_get_bytes_left(&s->g) < cblk->lengthinc[cwsno]
1034  || sizeof(cblk->data) < cblk->length + cblk->lengthinc[cwsno] + 4
1035  ) {
1036  av_log(s->avctx, AV_LOG_ERROR,
1037  "Block length %"PRIu16" or lengthinc %d is too large, left %d\n",
1038  cblk->length, cblk->lengthinc[cwsno], bytestream2_get_bytes_left(&s->g));
1039  return AVERROR_INVALIDDATA;
1040  }
1041 
1042  bytestream2_get_bufferu(&s->g, cblk->data + cblk->length, cblk->lengthinc[cwsno]);
1043  cblk->length += cblk->lengthinc[cwsno];
1044  cblk->lengthinc[cwsno] = 0;
1045  if (cblk->nb_terminationsinc) {
1046  cblk->nb_terminationsinc--;
1047  cblk->nb_terminations++;
1048  cblk->data[cblk->length++] = 0xFF;
1049  cblk->data[cblk->length++] = 0xFF;
1050  cblk->data_start[cblk->nb_terminations] = cblk->length;
1051  }
1052  }
1053  }
1054  }
1055  return 0;
1056 }
1057 
1058 static int jpeg2000_decode_packets_po_iteration(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile,
1059  int RSpoc, int CSpoc,
1060  int LYEpoc, int REpoc, int CEpoc,
1061  int Ppoc, int *tp_index)
1062 {
1063  int ret = 0;
1064  int layno, reslevelno, compno, precno, ok_reslevel;
1065  int x, y;
1066  int step_x, step_y;
1067 
1068  switch (Ppoc) {
1069  case JPEG2000_PGOD_RLCP:
1070  av_log(s->avctx, AV_LOG_DEBUG, "Progression order RLCP\n");
1071  ok_reslevel = 1;
1072  for (reslevelno = RSpoc; ok_reslevel && reslevelno < REpoc; reslevelno++) {
1073  ok_reslevel = 0;
1074  for (layno = 0; layno < LYEpoc; layno++) {
1075  for (compno = CSpoc; compno < CEpoc; compno++) {
1076  Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1077  Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
1078  if (reslevelno < codsty->nreslevels) {
1079  Jpeg2000ResLevel *rlevel = tile->comp[compno].reslevel +
1080  reslevelno;
1081  ok_reslevel = 1;
1082  for (precno = 0; precno < rlevel->num_precincts_x * rlevel->num_precincts_y; precno++)
1083  if ((ret = jpeg2000_decode_packet(s, tile, tp_index,
1084  codsty, rlevel,
1085  precno, layno,
1086  qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1087  qntsty->nguardbits)) < 0)
1088  return ret;
1089  }
1090  }
1091  }
1092  }
1093  break;
1094 
1095  case JPEG2000_PGOD_LRCP:
1096  av_log(s->avctx, AV_LOG_DEBUG, "Progression order LRCP\n");
1097  for (layno = 0; layno < LYEpoc; layno++) {
1098  ok_reslevel = 1;
1099  for (reslevelno = RSpoc; ok_reslevel && reslevelno < REpoc; reslevelno++) {
1100  ok_reslevel = 0;
1101  for (compno = CSpoc; compno < CEpoc; compno++) {
1102  Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1103  Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
1104  if (reslevelno < codsty->nreslevels) {
1105  Jpeg2000ResLevel *rlevel = tile->comp[compno].reslevel +
1106  reslevelno;
1107  ok_reslevel = 1;
1108  for (precno = 0; precno < rlevel->num_precincts_x * rlevel->num_precincts_y; precno++)
1109  if ((ret = jpeg2000_decode_packet(s, tile, tp_index,
1110  codsty, rlevel,
1111  precno, layno,
1112  qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1113  qntsty->nguardbits)) < 0)
1114  return ret;
1115  }
1116  }
1117  }
1118  }
1119  break;
1120 
1121  case JPEG2000_PGOD_CPRL:
1122  av_log(s->avctx, AV_LOG_DEBUG, "Progression order CPRL\n");
1123  for (compno = CSpoc; compno < CEpoc; compno++) {
1124  Jpeg2000Component *comp = tile->comp + compno;
1125  Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1126  Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
1127  step_x = 32;
1128  step_y = 32;
1129 
1130  for (reslevelno = RSpoc; reslevelno < FFMIN(codsty->nreslevels, REpoc); reslevelno++) {
1131  uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1132  Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1133  step_x = FFMIN(step_x, rlevel->log2_prec_width + reducedresno);
1134  step_y = FFMIN(step_y, rlevel->log2_prec_height + reducedresno);
1135  }
1136  av_assert0(step_x < 32 && step_y < 32);
1137  step_x = 1<<step_x;
1138  step_y = 1<<step_y;
1139 
1140  for (y = tile->coord[1][0]; y < tile->coord[1][1]; y = (y/step_y + 1)*step_y) {
1141  for (x = tile->coord[0][0]; x < tile->coord[0][1]; x = (x/step_x + 1)*step_x) {
1142  for (reslevelno = RSpoc; reslevelno < FFMIN(codsty->nreslevels, REpoc); reslevelno++) {
1143  unsigned prcx, prcy;
1144  uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1145  Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1146  int xc = x / s->cdx[compno];
1147  int yc = y / s->cdy[compno];
1148 
1149  if (yc % (1 << (rlevel->log2_prec_height + reducedresno)) && y != tile->coord[1][0]) //FIXME this is a subset of the check
1150  continue;
1151 
1152  if (xc % (1 << (rlevel->log2_prec_width + reducedresno)) && x != tile->coord[0][0]) //FIXME this is a subset of the check
1153  continue;
1154 
1155  // check if a precinct exists
1156  prcx = ff_jpeg2000_ceildivpow2(xc, reducedresno) >> rlevel->log2_prec_width;
1157  prcy = ff_jpeg2000_ceildivpow2(yc, reducedresno) >> rlevel->log2_prec_height;
1158  prcx -= ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], reducedresno) >> rlevel->log2_prec_width;
1159  prcy -= ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], reducedresno) >> rlevel->log2_prec_height;
1160 
1161  precno = prcx + rlevel->num_precincts_x * prcy;
1162 
1163  if (prcx >= rlevel->num_precincts_x || prcy >= rlevel->num_precincts_y) {
1164  av_log(s->avctx, AV_LOG_WARNING, "prc %d %d outside limits %d %d\n",
1165  prcx, prcy, rlevel->num_precincts_x, rlevel->num_precincts_y);
1166  continue;
1167  }
1168 
1169  for (layno = 0; layno < LYEpoc; layno++) {
1170  if ((ret = jpeg2000_decode_packet(s, tile, tp_index, codsty, rlevel,
1171  precno, layno,
1172  qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1173  qntsty->nguardbits)) < 0)
1174  return ret;
1175  }
1176  }
1177  }
1178  }
1179  }
1180  break;
1181 
1182  case JPEG2000_PGOD_RPCL:
1183  av_log(s->avctx, AV_LOG_WARNING, "Progression order RPCL\n");
1184  ok_reslevel = 1;
1185  for (reslevelno = RSpoc; ok_reslevel && reslevelno < REpoc; reslevelno++) {
1186  ok_reslevel = 0;
1187  step_x = 30;
1188  step_y = 30;
1189  for (compno = CSpoc; compno < CEpoc; compno++) {
1190  Jpeg2000Component *comp = tile->comp + compno;
1191  Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1192 
1193  if (reslevelno < codsty->nreslevels) {
1194  uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1195  Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1196  step_x = FFMIN(step_x, rlevel->log2_prec_width + reducedresno);
1197  step_y = FFMIN(step_y, rlevel->log2_prec_height + reducedresno);
1198  }
1199  }
1200  step_x = 1<<step_x;
1201  step_y = 1<<step_y;
1202 
1203  for (y = tile->coord[1][0]; y < tile->coord[1][1]; y = (y/step_y + 1)*step_y) {
1204  for (x = tile->coord[0][0]; x < tile->coord[0][1]; x = (x/step_x + 1)*step_x) {
1205  for (compno = CSpoc; compno < CEpoc; compno++) {
1206  Jpeg2000Component *comp = tile->comp + compno;
1207  Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1208  Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
1209  uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1210  Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1211  unsigned prcx, prcy;
1212 
1213  int xc = x / s->cdx[compno];
1214  int yc = y / s->cdy[compno];
1215 
1216  if (reslevelno >= codsty->nreslevels)
1217  continue;
1218 
1219  if (yc % (1 << (rlevel->log2_prec_height + reducedresno)) && y != tile->coord[1][0]) //FIXME this is a subset of the check
1220  continue;
1221 
1222  if (xc % (1 << (rlevel->log2_prec_width + reducedresno)) && x != tile->coord[0][0]) //FIXME this is a subset of the check
1223  continue;
1224 
1225  // check if a precinct exists
1226  prcx = ff_jpeg2000_ceildivpow2(xc, reducedresno) >> rlevel->log2_prec_width;
1227  prcy = ff_jpeg2000_ceildivpow2(yc, reducedresno) >> rlevel->log2_prec_height;
1228  prcx -= ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], reducedresno) >> rlevel->log2_prec_width;
1229  prcy -= ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], reducedresno) >> rlevel->log2_prec_height;
1230 
1231  precno = prcx + rlevel->num_precincts_x * prcy;
1232 
1233  ok_reslevel = 1;
1234  if (prcx >= rlevel->num_precincts_x || prcy >= rlevel->num_precincts_y) {
1235  av_log(s->avctx, AV_LOG_WARNING, "prc %d %d outside limits %d %d\n",
1236  prcx, prcy, rlevel->num_precincts_x, rlevel->num_precincts_y);
1237  continue;
1238  }
1239 
1240  for (layno = 0; layno < LYEpoc; layno++) {
1241  if ((ret = jpeg2000_decode_packet(s, tile, tp_index,
1242  codsty, rlevel,
1243  precno, layno,
1244  qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1245  qntsty->nguardbits)) < 0)
1246  return ret;
1247  }
1248  }
1249  }
1250  }
1251  }
1252  break;
1253 
1254  case JPEG2000_PGOD_PCRL:
1255  av_log(s->avctx, AV_LOG_WARNING, "Progression order PCRL\n");
1256  step_x = 32;
1257  step_y = 32;
1258  for (compno = CSpoc; compno < CEpoc; compno++) {
1259  Jpeg2000Component *comp = tile->comp + compno;
1260  Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1261 
1262  for (reslevelno = RSpoc; reslevelno < FFMIN(codsty->nreslevels, REpoc); reslevelno++) {
1263  uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1264  Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1265  step_x = FFMIN(step_x, rlevel->log2_prec_width + reducedresno);
1266  step_y = FFMIN(step_y, rlevel->log2_prec_height + reducedresno);
1267  }
1268  }
1269  if (step_x >= 31 || step_y >= 31){
1270  avpriv_request_sample(s->avctx, "PCRL with large step");
1271  return AVERROR_PATCHWELCOME;
1272  }
1273  step_x = 1<<step_x;
1274  step_y = 1<<step_y;
1275 
1276  for (y = tile->coord[1][0]; y < tile->coord[1][1]; y = (y/step_y + 1)*step_y) {
1277  for (x = tile->coord[0][0]; x < tile->coord[0][1]; x = (x/step_x + 1)*step_x) {
1278  for (compno = CSpoc; compno < CEpoc; compno++) {
1279  Jpeg2000Component *comp = tile->comp + compno;
1280  Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1281  Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
1282  int xc = x / s->cdx[compno];
1283  int yc = y / s->cdy[compno];
1284 
1285  for (reslevelno = RSpoc; reslevelno < FFMIN(codsty->nreslevels, REpoc); reslevelno++) {
1286  unsigned prcx, prcy;
1287  uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1288  Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1289 
1290  if (yc % (1 << (rlevel->log2_prec_height + reducedresno)) && y != tile->coord[1][0]) //FIXME this is a subset of the check
1291  continue;
1292 
1293  if (xc % (1 << (rlevel->log2_prec_width + reducedresno)) && x != tile->coord[0][0]) //FIXME this is a subset of the check
1294  continue;
1295 
1296  // check if a precinct exists
1297  prcx = ff_jpeg2000_ceildivpow2(xc, reducedresno) >> rlevel->log2_prec_width;
1298  prcy = ff_jpeg2000_ceildivpow2(yc, reducedresno) >> rlevel->log2_prec_height;
1299  prcx -= ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], reducedresno) >> rlevel->log2_prec_width;
1300  prcy -= ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], reducedresno) >> rlevel->log2_prec_height;
1301 
1302  precno = prcx + rlevel->num_precincts_x * prcy;
1303 
1304  if (prcx >= rlevel->num_precincts_x || prcy >= rlevel->num_precincts_y) {
1305  av_log(s->avctx, AV_LOG_WARNING, "prc %d %d outside limits %d %d\n",
1306  prcx, prcy, rlevel->num_precincts_x, rlevel->num_precincts_y);
1307  continue;
1308  }
1309 
1310  for (layno = 0; layno < LYEpoc; layno++) {
1311  if ((ret = jpeg2000_decode_packet(s, tile, tp_index, codsty, rlevel,
1312  precno, layno,
1313  qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1314  qntsty->nguardbits)) < 0)
1315  return ret;
1316  }
1317  }
1318  }
1319  }
1320  }
1321  break;
1322 
1323  default:
1324  break;
1325  }
1326 
1327  return ret;
1328 }
1329 
1330 static int jpeg2000_decode_packets(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
1331 {
1332  int ret = AVERROR_BUG;
1333  int i;
1334  int tp_index = 0;
1335 
1336  s->bit_index = 8;
1337  if (tile->poc.nb_poc) {
1338  for (i=0; i<tile->poc.nb_poc; i++) {
1339  Jpeg2000POCEntry *e = &tile->poc.poc[i];
1340  ret = jpeg2000_decode_packets_po_iteration(s, tile,
1341  e->RSpoc, e->CSpoc,
1342  FFMIN(e->LYEpoc, tile->codsty[0].nlayers),
1343  e->REpoc,
1344  FFMIN(e->CEpoc, s->ncomponents),
1345  e->Ppoc, &tp_index
1346  );
1347  if (ret < 0)
1348  return ret;
1349  }
1350  } else {
1351  ret = jpeg2000_decode_packets_po_iteration(s, tile,
1352  0, 0,
1353  tile->codsty[0].nlayers,
1354  33,
1355  s->ncomponents,
1356  tile->codsty[0].prog_order,
1357  &tp_index
1358  );
1359  }
1360  /* EOC marker reached */
1361  bytestream2_skip(&s->g, 2);
1362 
1363  return ret;
1364 }
1365 
1366 /* TIER-1 routines */
1367 static void decode_sigpass(Jpeg2000T1Context *t1, int width, int height,
1368  int bpno, int bandno,
1369  int vert_causal_ctx_csty_symbol)
1370 {
1371  int mask = 3 << (bpno - 1), y0, x, y;
1372 
1373  for (y0 = 0; y0 < height; y0 += 4)
1374  for (x = 0; x < width; x++)
1375  for (y = y0; y < height && y < y0 + 4; y++) {
1376  int flags_mask = -1;
1377  if (vert_causal_ctx_csty_symbol && y == y0 + 3)
1378  flags_mask &= ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE | JPEG2000_T1_SGN_S);
1379  if ((t1->flags[(y+1) * t1->stride + x+1] & JPEG2000_T1_SIG_NB & flags_mask)
1380  && !(t1->flags[(y+1) * t1->stride + x+1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS))) {
1381  if (ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ff_jpeg2000_getsigctxno(t1->flags[(y+1) * t1->stride + x+1] & flags_mask, bandno))) {
1382  int xorbit, ctxno = ff_jpeg2000_getsgnctxno(t1->flags[(y+1) * t1->stride + x+1] & flags_mask, &xorbit);
1383  if (t1->mqc.raw)
1384  t1->data[(y) * t1->stride + x] = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ctxno) ? -mask : mask;
1385  else
1386  t1->data[(y) * t1->stride + x] = (ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ctxno) ^ xorbit) ?
1387  -mask : mask;
1388 
1389  ff_jpeg2000_set_significance(t1, x, y,
1390  t1->data[(y) * t1->stride + x] < 0);
1391  }
1392  t1->flags[(y + 1) * t1->stride + x + 1] |= JPEG2000_T1_VIS;
1393  }
1394  }
1395 }
1396 
1397 static void decode_refpass(Jpeg2000T1Context *t1, int width, int height,
1398  int bpno, int vert_causal_ctx_csty_symbol)
1399 {
1400  int phalf, nhalf;
1401  int y0, x, y;
1402 
1403  phalf = 1 << (bpno - 1);
1404  nhalf = -phalf;
1405 
1406  for (y0 = 0; y0 < height; y0 += 4)
1407  for (x = 0; x < width; x++)
1408  for (y = y0; y < height && y < y0 + 4; y++)
1409  if ((t1->flags[(y + 1) * t1->stride + x + 1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS)) == JPEG2000_T1_SIG) {
1410  int flags_mask = (vert_causal_ctx_csty_symbol && y == y0 + 3) ?
1411  ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE | JPEG2000_T1_SGN_S) : -1;
1412  int ctxno = ff_jpeg2000_getrefctxno(t1->flags[(y + 1) * t1->stride + x + 1] & flags_mask);
1413  int r = ff_mqc_decode(&t1->mqc,
1414  t1->mqc.cx_states + ctxno)
1415  ? phalf : nhalf;
1416  t1->data[(y) * t1->stride + x] += t1->data[(y) * t1->stride + x] < 0 ? -r : r;
1417  t1->flags[(y + 1) * t1->stride + x + 1] |= JPEG2000_T1_REF;
1418  }
1419 }
1420 
1421 static void decode_clnpass(Jpeg2000DecoderContext *s, Jpeg2000T1Context *t1,
1422  int width, int height, int bpno, int bandno,
1423  int seg_symbols, int vert_causal_ctx_csty_symbol)
1424 {
1425  int mask = 3 << (bpno - 1), y0, x, y, runlen, dec;
1426 
1427  for (y0 = 0; y0 < height; y0 += 4) {
1428  for (x = 0; x < width; x++) {
1429  int flags_mask = -1;
1430  if (vert_causal_ctx_csty_symbol)
1431  flags_mask &= ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE | JPEG2000_T1_SGN_S);
1432  if (y0 + 3 < height &&
1433  !((t1->flags[(y0 + 1) * t1->stride + x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
1434  (t1->flags[(y0 + 2) * t1->stride + x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
1435  (t1->flags[(y0 + 3) * t1->stride + x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
1436  (t1->flags[(y0 + 4) * t1->stride + x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG) & flags_mask))) {
1437  if (!ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_RL))
1438  continue;
1439  runlen = ff_mqc_decode(&t1->mqc,
1440  t1->mqc.cx_states + MQC_CX_UNI);
1441  runlen = (runlen << 1) | ff_mqc_decode(&t1->mqc,
1442  t1->mqc.cx_states +
1443  MQC_CX_UNI);
1444  dec = 1;
1445  } else {
1446  runlen = 0;
1447  dec = 0;
1448  }
1449 
1450  for (y = y0 + runlen; y < y0 + 4 && y < height; y++) {
1451  int flags_mask = -1;
1452  if (vert_causal_ctx_csty_symbol && y == y0 + 3)
1453  flags_mask &= ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE | JPEG2000_T1_SGN_S);
1454  if (!dec) {
1455  if (!(t1->flags[(y+1) * t1->stride + x+1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS))) {
1456  dec = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ff_jpeg2000_getsigctxno(t1->flags[(y+1) * t1->stride + x+1] & flags_mask,
1457  bandno));
1458  }
1459  }
1460  if (dec) {
1461  int xorbit;
1462  int ctxno = ff_jpeg2000_getsgnctxno(t1->flags[(y + 1) * t1->stride + x + 1] & flags_mask,
1463  &xorbit);
1464  t1->data[(y) * t1->stride + x] = (ff_mqc_decode(&t1->mqc,
1465  t1->mqc.cx_states + ctxno) ^
1466  xorbit)
1467  ? -mask : mask;
1468  ff_jpeg2000_set_significance(t1, x, y, t1->data[(y) * t1->stride + x] < 0);
1469  }
1470  dec = 0;
1471  t1->flags[(y + 1) * t1->stride + x + 1] &= ~JPEG2000_T1_VIS;
1472  }
1473  }
1474  }
1475  if (seg_symbols) {
1476  int val;
1477  val = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1478  val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1479  val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1480  val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1481  if (val != 0xa)
1482  av_log(s->avctx, AV_LOG_ERROR,
1483  "Segmentation symbol value incorrect\n");
1484  }
1485 }
1486 
1487 static int decode_cblk(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *codsty,
1488  Jpeg2000T1Context *t1, Jpeg2000Cblk *cblk,
1489  int width, int height, int bandpos)
1490 {
1491  int passno = cblk->npasses, pass_t = 2, bpno = cblk->nonzerobits - 1;
1492  int pass_cnt = 0;
1493  int vert_causal_ctx_csty_symbol = codsty->cblk_style & JPEG2000_CBLK_VSC;
1494  int term_cnt = 0;
1495  int coder_type;
1496 
1497  av_assert0(width <= 1024U && height <= 1024U);
1498  av_assert0(width*height <= 4096);
1499 
1500  memset(t1->data, 0, t1->stride * height * sizeof(*t1->data));
1501 
1502  /* If code-block contains no compressed data: nothing to do. */
1503  if (!cblk->length)
1504  return 0;
1505 
1506  memset(t1->flags, 0, t1->stride * (height + 2) * sizeof(*t1->flags));
1507 
1508  cblk->data[cblk->length] = 0xff;
1509  cblk->data[cblk->length+1] = 0xff;
1510  ff_mqc_initdec(&t1->mqc, cblk->data, 0, 1);
1511 
1512  while (passno--) {
1513  if (bpno < 0) {
1514  av_log(s->avctx, AV_LOG_ERROR, "bpno became negative\n");
1515  return AVERROR_INVALIDDATA;
1516  }
1517  switch(pass_t) {
1518  case 0:
1519  decode_sigpass(t1, width, height, bpno + 1, bandpos,
1520  vert_causal_ctx_csty_symbol);
1521  break;
1522  case 1:
1523  decode_refpass(t1, width, height, bpno + 1, vert_causal_ctx_csty_symbol);
1524  break;
1525  case 2:
1526  av_assert2(!t1->mqc.raw);
1527  decode_clnpass(s, t1, width, height, bpno + 1, bandpos,
1528  codsty->cblk_style & JPEG2000_CBLK_SEGSYM,
1529  vert_causal_ctx_csty_symbol);
1530  break;
1531  }
1532  if (codsty->cblk_style & JPEG2000_CBLK_RESET) // XXX no testcase for just this
1533  ff_mqc_init_contexts(&t1->mqc);
1534 
1535  if (passno && (coder_type = needs_termination(codsty->cblk_style, pass_cnt))) {
1536  if (term_cnt >= cblk->nb_terminations) {
1537  av_log(s->avctx, AV_LOG_ERROR, "Missing needed termination \n");
1538  return AVERROR_INVALIDDATA;
1539  }
1540  if (FFABS(cblk->data + cblk->data_start[term_cnt + 1] - 2 - t1->mqc.bp) > 0) {
1541  av_log(s->avctx, AV_LOG_WARNING, "Mid mismatch %"PTRDIFF_SPECIFIER" in pass %d of %d\n",
1542  cblk->data + cblk->data_start[term_cnt + 1] - 2 - t1->mqc.bp,
1543  pass_cnt, cblk->npasses);
1544  }
1545 
1546  ff_mqc_initdec(&t1->mqc, cblk->data + cblk->data_start[++term_cnt], coder_type == 2, 0);
1547  }
1548 
1549  pass_t++;
1550  if (pass_t == 3) {
1551  bpno--;
1552  pass_t = 0;
1553  }
1554  pass_cnt ++;
1555  }
1556 
1557  if (cblk->data + cblk->length - 2*(term_cnt < cblk->nb_terminations) != t1->mqc.bp) {
1558  av_log(s->avctx, AV_LOG_WARNING, "End mismatch %"PTRDIFF_SPECIFIER"\n",
1559  cblk->data + cblk->length - 2*(term_cnt < cblk->nb_terminations) - t1->mqc.bp);
1560  }
1561 
1562  return 0;
1563 }
1564 
1565 /* TODO: Verify dequantization for lossless case
1566  * comp->data can be float or int
1567  * band->stepsize can be float or int
1568  * depending on the type of DWT transformation.
1569  * see ISO/IEC 15444-1:2002 A.6.1 */
1570 
1571 /* Float dequantization of a codeblock.*/
1572 static void dequantization_float(int x, int y, Jpeg2000Cblk *cblk,
1573  Jpeg2000Component *comp,
1574  Jpeg2000T1Context *t1, Jpeg2000Band *band)
1575 {
1576  int i, j;
1577  int w = cblk->coord[0][1] - cblk->coord[0][0];
1578  for (j = 0; j < (cblk->coord[1][1] - cblk->coord[1][0]); ++j) {
1579  float *datap = &comp->f_data[(comp->coord[0][1] - comp->coord[0][0]) * (y + j) + x];
1580  int *src = t1->data + j*t1->stride;
1581  for (i = 0; i < w; ++i)
1582  datap[i] = src[i] * band->f_stepsize;
1583  }
1584 }
1585 
1586 /* Integer dequantization of a codeblock.*/
1587 static void dequantization_int(int x, int y, Jpeg2000Cblk *cblk,
1588  Jpeg2000Component *comp,
1589  Jpeg2000T1Context *t1, Jpeg2000Band *band)
1590 {
1591  int i, j;
1592  int w = cblk->coord[0][1] - cblk->coord[0][0];
1593  for (j = 0; j < (cblk->coord[1][1] - cblk->coord[1][0]); ++j) {
1594  int32_t *datap = &comp->i_data[(comp->coord[0][1] - comp->coord[0][0]) * (y + j) + x];
1595  int *src = t1->data + j*t1->stride;
1596  if (band->i_stepsize == 32768) {
1597  for (i = 0; i < w; ++i)
1598  datap[i] = src[i] / 2;
1599  } else {
1600  // This should be VERY uncommon
1601  for (i = 0; i < w; ++i)
1602  datap[i] = (src[i] * (int64_t)band->i_stepsize) / 65536;
1603  }
1604  }
1605 }
1606 
1607 static void dequantization_int_97(int x, int y, Jpeg2000Cblk *cblk,
1608  Jpeg2000Component *comp,
1609  Jpeg2000T1Context *t1, Jpeg2000Band *band)
1610 {
1611  int i, j;
1612  int w = cblk->coord[0][1] - cblk->coord[0][0];
1613  for (j = 0; j < (cblk->coord[1][1] - cblk->coord[1][0]); ++j) {
1614  int32_t *datap = &comp->i_data[(comp->coord[0][1] - comp->coord[0][0]) * (y + j) + x];
1615  int *src = t1->data + j*t1->stride;
1616  for (i = 0; i < w; ++i)
1617  datap[i] = (src[i] * (int64_t)band->i_stepsize + (1<<15)) >> 16;
1618  }
1619 }
1620 
1621 static inline void mct_decode(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
1622 {
1623  int i, csize = 1;
1624  void *src[3];
1625 
1626  for (i = 1; i < 3; i++) {
1627  if (tile->codsty[0].transform != tile->codsty[i].transform) {
1628  av_log(s->avctx, AV_LOG_ERROR, "Transforms mismatch, MCT not supported\n");
1629  return;
1630  }
1631  if (memcmp(tile->comp[0].coord, tile->comp[i].coord, sizeof(tile->comp[0].coord))) {
1632  av_log(s->avctx, AV_LOG_ERROR, "Coords mismatch, MCT not supported\n");
1633  return;
1634  }
1635  }
1636 
1637  for (i = 0; i < 3; i++)
1638  if (tile->codsty[0].transform == FF_DWT97)
1639  src[i] = tile->comp[i].f_data;
1640  else
1641  src[i] = tile->comp[i].i_data;
1642 
1643  for (i = 0; i < 2; i++)
1644  csize *= tile->comp[0].coord[i][1] - tile->comp[0].coord[i][0];
1645 
1646  s->dsp.mct_decode[tile->codsty[0].transform](src[0], src[1], src[2], csize);
1647 }
1648 
1649 static inline void tile_codeblocks(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
1650 {
1651  Jpeg2000T1Context t1;
1652 
1653  int compno, reslevelno, bandno;
1654 
1655  /* Loop on tile components */
1656  for (compno = 0; compno < s->ncomponents; compno++) {
1657  Jpeg2000Component *comp = tile->comp + compno;
1658  Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1659 
1660  t1.stride = (1<<codsty->log2_cblk_width) + 2;
1661 
1662  /* Loop on resolution levels */
1663  for (reslevelno = 0; reslevelno < codsty->nreslevels2decode; reslevelno++) {
1664  Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1665  /* Loop on bands */
1666  for (bandno = 0; bandno < rlevel->nbands; bandno++) {
1667  int nb_precincts, precno;
1668  Jpeg2000Band *band = rlevel->band + bandno;
1669  int cblkno = 0, bandpos;
1670 
1671  bandpos = bandno + (reslevelno > 0);
1672 
1673  if (band->coord[0][0] == band->coord[0][1] ||
1674  band->coord[1][0] == band->coord[1][1])
1675  continue;
1676 
1677  nb_precincts = rlevel->num_precincts_x * rlevel->num_precincts_y;
1678  /* Loop on precincts */
1679  for (precno = 0; precno < nb_precincts; precno++) {
1680  Jpeg2000Prec *prec = band->prec + precno;
1681 
1682  /* Loop on codeblocks */
1683  for (cblkno = 0;
1684  cblkno < prec->nb_codeblocks_width * prec->nb_codeblocks_height;
1685  cblkno++) {
1686  int x, y;
1687  Jpeg2000Cblk *cblk = prec->cblk + cblkno;
1688  decode_cblk(s, codsty, &t1, cblk,
1689  cblk->coord[0][1] - cblk->coord[0][0],
1690  cblk->coord[1][1] - cblk->coord[1][0],
1691  bandpos);
1692 
1693  x = cblk->coord[0][0] - band->coord[0][0];
1694  y = cblk->coord[1][0] - band->coord[1][0];
1695 
1696  if (codsty->transform == FF_DWT97)
1697  dequantization_float(x, y, cblk, comp, &t1, band);
1698  else if (codsty->transform == FF_DWT97_INT)
1699  dequantization_int_97(x, y, cblk, comp, &t1, band);
1700  else
1701  dequantization_int(x, y, cblk, comp, &t1, band);
1702  } /* end cblk */
1703  } /*end prec */
1704  } /* end band */
1705  } /* end reslevel */
1706 
1707  /* inverse DWT */
1708  ff_dwt_decode(&comp->dwt, codsty->transform == FF_DWT97 ? (void*)comp->f_data : (void*)comp->i_data);
1709  } /*end comp */
1710 }
1711 
1712 #define WRITE_FRAME(D, PIXEL) \
1713  static inline void write_frame_ ## D(Jpeg2000DecoderContext * s, Jpeg2000Tile * tile, \
1714  AVFrame * picture, int precision) \
1715  { \
1716  const AVPixFmtDescriptor *pixdesc = av_pix_fmt_desc_get(s->avctx->pix_fmt); \
1717  int planar = !!(pixdesc->flags & AV_PIX_FMT_FLAG_PLANAR); \
1718  int pixelsize = planar ? 1 : pixdesc->nb_components; \
1719  \
1720  int compno; \
1721  int x, y; \
1722  \
1723  for (compno = 0; compno < s->ncomponents; compno++) { \
1724  Jpeg2000Component *comp = tile->comp + compno; \
1725  Jpeg2000CodingStyle *codsty = tile->codsty + compno; \
1726  PIXEL *line; \
1727  float *datap = comp->f_data; \
1728  int32_t *i_datap = comp->i_data; \
1729  int cbps = s->cbps[compno]; \
1730  int w = tile->comp[compno].coord[0][1] - s->image_offset_x; \
1731  int plane = 0; \
1732  \
1733  if (planar) \
1734  plane = s->cdef[compno] ? s->cdef[compno]-1 : (s->ncomponents-1); \
1735  \
1736  y = tile->comp[compno].coord[1][0] - s->image_offset_y / s->cdy[compno]; \
1737  line = (PIXEL *)picture->data[plane] + y * (picture->linesize[plane] / sizeof(PIXEL));\
1738  for (; y < tile->comp[compno].coord[1][1] - s->image_offset_y; y++) { \
1739  PIXEL *dst; \
1740  \
1741  x = tile->comp[compno].coord[0][0] - s->image_offset_x / s->cdx[compno]; \
1742  dst = line + x * pixelsize + compno*!planar; \
1743  \
1744  if (codsty->transform == FF_DWT97) { \
1745  for (; x < w; x++) { \
1746  int val = lrintf(*datap) + (1 << (cbps - 1)); \
1747  /* DC level shift and clip see ISO 15444-1:2002 G.1.2 */ \
1748  val = av_clip(val, 0, (1 << cbps) - 1); \
1749  *dst = val << (precision - cbps); \
1750  datap++; \
1751  dst += pixelsize; \
1752  } \
1753  } else { \
1754  for (; x < w; x++) { \
1755  int val = *i_datap + (1 << (cbps - 1)); \
1756  /* DC level shift and clip see ISO 15444-1:2002 G.1.2 */ \
1757  val = av_clip(val, 0, (1 << cbps) - 1); \
1758  *dst = val << (precision - cbps); \
1759  i_datap++; \
1760  dst += pixelsize; \
1761  } \
1762  } \
1763  line += picture->linesize[plane] / sizeof(PIXEL); \
1764  } \
1765  } \
1766  \
1767  }
1768 
1769 WRITE_FRAME(8, uint8_t)
1770 WRITE_FRAME(16, uint16_t)
1771 
1772 #undef WRITE_FRAME
1773 
1774 static int jpeg2000_decode_tile(AVCodecContext *avctx, void *td,
1775  int jobnr, int threadnr)
1776 {
1777  Jpeg2000DecoderContext *s = avctx->priv_data;
1778  AVFrame *picture = td;
1779  Jpeg2000Tile *tile = s->tile + jobnr;
1780  int x;
1781 
1782  tile_codeblocks(s, tile);
1783 
1784  /* inverse MCT transformation */
1785  if (tile->codsty[0].mct)
1786  mct_decode(s, tile);
1787 
1788  for (x = 0; x < s->ncomponents; x++) {
1789  if (s->cdef[x] < 0) {
1790  for (x = 0; x < s->ncomponents; x++) {
1791  s->cdef[x] = x + 1;
1792  }
1793  if ((s->ncomponents & 1) == 0)
1794  s->cdef[s->ncomponents-1] = 0;
1795  break;
1796  }
1797  }
1798 
1799  if (s->precision <= 8) {
1800  write_frame_8(s, tile, picture, 8);
1801  } else {
1802  int precision = picture->format == AV_PIX_FMT_XYZ12 ||
1803  picture->format == AV_PIX_FMT_RGB48 ||
1804  picture->format == AV_PIX_FMT_RGBA64 ||
1805  picture->format == AV_PIX_FMT_GRAY16 ? 16 : s->precision;
1806 
1807  write_frame_16(s, tile, picture, precision);
1808  }
1809 
1810  return 0;
1811 }
1812 
1813 static void jpeg2000_dec_cleanup(Jpeg2000DecoderContext *s)
1814 {
1815  int tileno, compno;
1816  for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++) {
1817  if (s->tile[tileno].comp) {
1818  for (compno = 0; compno < s->ncomponents; compno++) {
1819  Jpeg2000Component *comp = s->tile[tileno].comp + compno;
1820  Jpeg2000CodingStyle *codsty = s->tile[tileno].codsty + compno;
1821 
1822  ff_jpeg2000_cleanup(comp, codsty);
1823  }
1824  av_freep(&s->tile[tileno].comp);
1825  }
1826  }
1827  av_freep(&s->tile);
1828  memset(s->codsty, 0, sizeof(s->codsty));
1829  memset(s->qntsty, 0, sizeof(s->qntsty));
1830  memset(s->properties, 0, sizeof(s->properties));
1831  memset(&s->poc , 0, sizeof(s->poc));
1832  s->numXtiles = s->numYtiles = 0;
1833  s->ncomponents = 0;
1834 }
1835 
1836 static int jpeg2000_read_main_headers(Jpeg2000DecoderContext *s)
1837 {
1838  Jpeg2000CodingStyle *codsty = s->codsty;
1839  Jpeg2000QuantStyle *qntsty = s->qntsty;
1840  Jpeg2000POC *poc = &s->poc;
1841  uint8_t *properties = s->properties;
1842 
1843  for (;;) {
1844  int len, ret = 0;
1845  uint16_t marker;
1846  int oldpos;
1847 
1848  if (bytestream2_get_bytes_left(&s->g) < 2) {
1849  av_log(s->avctx, AV_LOG_ERROR, "Missing EOC\n");
1850  break;
1851  }
1852 
1853  marker = bytestream2_get_be16u(&s->g);
1854  oldpos = bytestream2_tell(&s->g);
1855 
1856  if (marker == JPEG2000_SOD) {
1857  Jpeg2000Tile *tile;
1858  Jpeg2000TilePart *tp;
1859 
1860  if (!s->tile) {
1861  av_log(s->avctx, AV_LOG_ERROR, "Missing SIZ\n");
1862  return AVERROR_INVALIDDATA;
1863  }
1864  if (s->curtileno < 0) {
1865  av_log(s->avctx, AV_LOG_ERROR, "Missing SOT\n");
1866  return AVERROR_INVALIDDATA;
1867  }
1868 
1869  tile = s->tile + s->curtileno;
1870  tp = tile->tile_part + tile->tp_idx;
1871  if (tp->tp_end < s->g.buffer) {
1872  av_log(s->avctx, AV_LOG_ERROR, "Invalid tpend\n");
1873  return AVERROR_INVALIDDATA;
1874  }
1875  bytestream2_init(&tp->tpg, s->g.buffer, tp->tp_end - s->g.buffer);
1876  bytestream2_skip(&s->g, tp->tp_end - s->g.buffer);
1877 
1878  continue;
1879  }
1880  if (marker == JPEG2000_EOC)
1881  break;
1882 
1883  len = bytestream2_get_be16(&s->g);
1884  if (len < 2 || bytestream2_get_bytes_left(&s->g) < len - 2) {
1885  av_log(s->avctx, AV_LOG_ERROR, "Invalid len %d left=%d\n", len, bytestream2_get_bytes_left(&s->g));
1886  return AVERROR_INVALIDDATA;
1887  }
1888 
1889  switch (marker) {
1890  case JPEG2000_SIZ:
1891  if (s->ncomponents) {
1892  av_log(s->avctx, AV_LOG_ERROR, "Duplicate SIZ\n");
1893  return AVERROR_INVALIDDATA;
1894  }
1895  ret = get_siz(s);
1896  if (!s->tile)
1897  s->numXtiles = s->numYtiles = 0;
1898  break;
1899  case JPEG2000_COC:
1900  ret = get_coc(s, codsty, properties);
1901  break;
1902  case JPEG2000_COD:
1903  ret = get_cod(s, codsty, properties);
1904  break;
1905  case JPEG2000_QCC:
1906  ret = get_qcc(s, len, qntsty, properties);
1907  break;
1908  case JPEG2000_QCD:
1909  ret = get_qcd(s, len, qntsty, properties);
1910  break;
1911  case JPEG2000_POC:
1912  ret = get_poc(s, len, poc);
1913  break;
1914  case JPEG2000_SOT:
1915  if (!(ret = get_sot(s, len))) {
1916  av_assert1(s->curtileno >= 0);
1917  codsty = s->tile[s->curtileno].codsty;
1918  qntsty = s->tile[s->curtileno].qntsty;
1919  poc = &s->tile[s->curtileno].poc;
1920  properties = s->tile[s->curtileno].properties;
1921  }
1922  break;
1923  case JPEG2000_PLM:
1924  // the PLM marker is ignored
1925  case JPEG2000_COM:
1926  // the comment is ignored
1927  bytestream2_skip(&s->g, len - 2);
1928  break;
1929  case JPEG2000_TLM:
1930  // Tile-part lengths
1931  ret = get_tlm(s, len);
1932  break;
1933  case JPEG2000_PLT:
1934  // Packet length, tile-part header
1935  ret = get_plt(s, len);
1936  break;
1937  default:
1938  av_log(s->avctx, AV_LOG_ERROR,
1939  "unsupported marker 0x%.4"PRIX16" at pos 0x%X\n",
1940  marker, bytestream2_tell(&s->g) - 4);
1941  bytestream2_skip(&s->g, len - 2);
1942  break;
1943  }
1944  if (bytestream2_tell(&s->g) - oldpos != len || ret) {
1945  av_log(s->avctx, AV_LOG_ERROR,
1946  "error during processing marker segment %.4"PRIx16"\n",
1947  marker);
1948  return ret ? ret : -1;
1949  }
1950  }
1951  return 0;
1952 }
1953 
1954 /* Read bit stream packets --> T2 operation. */
1955 static int jpeg2000_read_bitstream_packets(Jpeg2000DecoderContext *s)
1956 {
1957  int ret = 0;
1958  int tileno;
1959 
1960  for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++) {
1961  Jpeg2000Tile *tile = s->tile + tileno;
1962 
1963  if ((ret = init_tile(s, tileno)) < 0)
1964  return ret;
1965 
1966  s->g = tile->tile_part[0].tpg;
1967  if ((ret = jpeg2000_decode_packets(s, tile)) < 0)
1968  return ret;
1969  }
1970 
1971  return 0;
1972 }
1973 
1974 static int jp2_find_codestream(Jpeg2000DecoderContext *s)
1975 {
1976  uint32_t atom_size, atom, atom_end;
1977  int search_range = 10;
1978 
1979  while (search_range
1980  &&
1981  bytestream2_get_bytes_left(&s->g) >= 8) {
1982  atom_size = bytestream2_get_be32u(&s->g);
1983  atom = bytestream2_get_be32u(&s->g);
1984  atom_end = bytestream2_tell(&s->g) + atom_size - 8;
1985 
1986  if (atom == JP2_CODESTREAM)
1987  return 1;
1988 
1989  if (bytestream2_get_bytes_left(&s->g) < atom_size || atom_end < atom_size)
1990  return 0;
1991 
1992  if (atom == JP2_HEADER &&
1993  atom_size >= 16) {
1994  uint32_t atom2_size, atom2, atom2_end;
1995  do {
1996  atom2_size = bytestream2_get_be32u(&s->g);
1997  atom2 = bytestream2_get_be32u(&s->g);
1998  atom2_end = bytestream2_tell(&s->g) + atom2_size - 8;
1999  if (atom2_size < 8 || atom2_end > atom_end || atom2_end < atom2_size)
2000  break;
2001  atom2_size -= 8;
2002  if (atom2 == JP2_CODESTREAM) {
2003  return 1;
2004  } else if (atom2 == MKBETAG('c','o','l','r') && atom2_size >= 7) {
2005  int method = bytestream2_get_byteu(&s->g);
2006  bytestream2_skipu(&s->g, 2);
2007  if (method == 1) {
2008  s->colour_space = bytestream2_get_be32u(&s->g);
2009  }
2010  } else if (atom2 == MKBETAG('p','c','l','r') && atom2_size >= 6) {
2011  int i, size, colour_count, colour_channels, colour_depth[3];
2012  uint32_t r, g, b;
2013  colour_count = bytestream2_get_be16u(&s->g);
2014  colour_channels = bytestream2_get_byteu(&s->g);
2015  // FIXME: Do not ignore channel_sign
2016  colour_depth[0] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1;
2017  colour_depth[1] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1;
2018  colour_depth[2] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1;
2019  size = (colour_depth[0] + 7 >> 3) * colour_count +
2020  (colour_depth[1] + 7 >> 3) * colour_count +
2021  (colour_depth[2] + 7 >> 3) * colour_count;
2022  if (colour_count > 256 ||
2023  colour_channels != 3 ||
2024  colour_depth[0] > 16 ||
2025  colour_depth[1] > 16 ||
2026  colour_depth[2] > 16 ||
2027  atom2_size < size) {
2028  avpriv_request_sample(s->avctx, "Unknown palette");
2029  bytestream2_seek(&s->g, atom2_end, SEEK_SET);
2030  continue;
2031  }
2032  s->pal8 = 1;
2033  for (i = 0; i < colour_count; i++) {
2034  if (colour_depth[0] <= 8) {
2035  r = bytestream2_get_byteu(&s->g) << 8 - colour_depth[0];
2036  r |= r >> colour_depth[0];
2037  } else {
2038  r = bytestream2_get_be16u(&s->g) >> colour_depth[0] - 8;
2039  }
2040  if (colour_depth[1] <= 8) {
2041  g = bytestream2_get_byteu(&s->g) << 8 - colour_depth[1];
2042  r |= r >> colour_depth[1];
2043  } else {
2044  g = bytestream2_get_be16u(&s->g) >> colour_depth[1] - 8;
2045  }
2046  if (colour_depth[2] <= 8) {
2047  b = bytestream2_get_byteu(&s->g) << 8 - colour_depth[2];
2048  r |= r >> colour_depth[2];
2049  } else {
2050  b = bytestream2_get_be16u(&s->g) >> colour_depth[2] - 8;
2051  }
2052  s->palette[i] = 0xffu << 24 | r << 16 | g << 8 | b;
2053  }
2054  } else if (atom2 == MKBETAG('c','d','e','f') && atom2_size >= 2) {
2055  int n = bytestream2_get_be16u(&s->g);
2056  for (; n>0; n--) {
2057  int cn = bytestream2_get_be16(&s->g);
2058  int av_unused typ = bytestream2_get_be16(&s->g);
2059  int asoc = bytestream2_get_be16(&s->g);
2060  if (cn < 4 && asoc < 4)
2061  s->cdef[cn] = asoc;
2062  }
2063  } else if (atom2 == MKBETAG('r','e','s',' ') && atom2_size >= 18) {
2064  int64_t vnum, vden, hnum, hden, vexp, hexp;
2065  uint32_t resx;
2066  bytestream2_skip(&s->g, 4);
2067  resx = bytestream2_get_be32u(&s->g);
2068  if (resx != MKBETAG('r','e','s','c') && resx != MKBETAG('r','e','s','d')) {
2069  bytestream2_seek(&s->g, atom2_end, SEEK_SET);
2070  continue;
2071  }
2072  vnum = bytestream2_get_be16u(&s->g);
2073  vden = bytestream2_get_be16u(&s->g);
2074  hnum = bytestream2_get_be16u(&s->g);
2075  hden = bytestream2_get_be16u(&s->g);
2076  vexp = bytestream2_get_byteu(&s->g);
2077  hexp = bytestream2_get_byteu(&s->g);
2078  if (!vnum || !vden || !hnum || !hden) {
2079  bytestream2_seek(&s->g, atom2_end, SEEK_SET);
2080  av_log(s->avctx, AV_LOG_WARNING, "RES box invalid\n");
2081  continue;
2082  }
2083  if (vexp > hexp) {
2084  vexp -= hexp;
2085  hexp = 0;
2086  } else {
2087  hexp -= vexp;
2088  vexp = 0;
2089  }
2090  if ( INT64_MAX / (hnum * vden) > pow(10, hexp)
2091  && INT64_MAX / (vnum * hden) > pow(10, vexp))
2092  av_reduce(&s->sar.den, &s->sar.num,
2093  hnum * vden * pow(10, hexp),
2094  vnum * hden * pow(10, vexp),
2095  INT32_MAX);
2096  }
2097  bytestream2_seek(&s->g, atom2_end, SEEK_SET);
2098  } while (atom_end - atom2_end >= 8);
2099  } else {
2100  search_range--;
2101  }
2102  bytestream2_seek(&s->g, atom_end, SEEK_SET);
2103  }
2104 
2105  return 0;
2106 }
2107 
2108 static av_cold int jpeg2000_decode_init(AVCodecContext *avctx)
2109 {
2110  Jpeg2000DecoderContext *s = avctx->priv_data;
2111 
2112  ff_jpeg2000dsp_init(&s->dsp);
2113 
2114  return 0;
2115 }
2116 
2117 static int jpeg2000_decode_frame(AVCodecContext *avctx, void *data,
2118  int *got_frame, AVPacket *avpkt)
2119 {
2120  Jpeg2000DecoderContext *s = avctx->priv_data;
2121  ThreadFrame frame = { .f = data };
2122  AVFrame *picture = data;
2123  int ret;
2124 
2125  s->avctx = avctx;
2126  bytestream2_init(&s->g, avpkt->data, avpkt->size);
2127  s->curtileno = -1;
2128  memset(s->cdef, -1, sizeof(s->cdef));
2129 
2130  if (bytestream2_get_bytes_left(&s->g) < 2) {
2131  ret = AVERROR_INVALIDDATA;
2132  goto end;
2133  }
2134 
2135  // check if the image is in jp2 format
2136  if (bytestream2_get_bytes_left(&s->g) >= 12 &&
2137  (bytestream2_get_be32u(&s->g) == 12) &&
2138  (bytestream2_get_be32u(&s->g) == JP2_SIG_TYPE) &&
2139  (bytestream2_get_be32u(&s->g) == JP2_SIG_VALUE)) {
2140  if (!jp2_find_codestream(s)) {
2141  av_log(avctx, AV_LOG_ERROR,
2142  "Could not find Jpeg2000 codestream atom.\n");
2143  ret = AVERROR_INVALIDDATA;
2144  goto end;
2145  }
2146  } else {
2147  bytestream2_seek(&s->g, 0, SEEK_SET);
2148  }
2149 
2150  while (bytestream2_get_bytes_left(&s->g) >= 3 && bytestream2_peek_be16(&s->g) != JPEG2000_SOC)
2151  bytestream2_skip(&s->g, 1);
2152 
2153  if (bytestream2_get_be16u(&s->g) != JPEG2000_SOC) {
2154  av_log(avctx, AV_LOG_ERROR, "SOC marker not present\n");
2155  ret = AVERROR_INVALIDDATA;
2156  goto end;
2157  }
2158  if (ret = jpeg2000_read_main_headers(s))
2159  goto end;
2160 
2161  /* get picture buffer */
2162  if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
2163  goto end;
2164  picture->pict_type = AV_PICTURE_TYPE_I;
2165  picture->key_frame = 1;
2166 
2167  if (ret = jpeg2000_read_bitstream_packets(s))
2168  goto end;
2169 
2170  avctx->execute2(avctx, jpeg2000_decode_tile, picture, NULL, s->numXtiles * s->numYtiles);
2171 
2172  jpeg2000_dec_cleanup(s);
2173 
2174  *got_frame = 1;
2175 
2176  if (s->avctx->pix_fmt == AV_PIX_FMT_PAL8)
2177  memcpy(picture->data[1], s->palette, 256 * sizeof(uint32_t));
2178  if (s->sar.num && s->sar.den)
2179  avctx->sample_aspect_ratio = s->sar;
2180  s->sar.num = s->sar.den = 0;
2181 
2182  return bytestream2_tell(&s->g);
2183 
2184 end:
2185  jpeg2000_dec_cleanup(s);
2186  return ret;
2187 }
2188 
2189 static av_cold void jpeg2000_init_static_data(AVCodec *codec)
2190 {
2191  ff_jpeg2000_init_tier1_luts();
2192  ff_mqc_init_context_tables();
2193 }
2194 
2195 #define OFFSET(x) offsetof(Jpeg2000DecoderContext, x)
2196 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
2197 
2198 static const AVOption options[] = {
2199  { "lowres", "Lower the decoding resolution by a power of two",
2200  OFFSET(reduction_factor), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, JPEG2000_MAX_RESLEVELS - 1, VD },
2201  { NULL },
2202 };
2203 
2204 static const AVClass jpeg2000_class = {
2205  .class_name = "jpeg2000",
2206  .item_name = av_default_item_name,
2207  .option = options,
2208  .version = LIBAVUTIL_VERSION_INT,
2209 };
2210 
2211 AVCodec ff_jpeg2000_decoder = {
2212  .name = "jpeg2000",
2213  .long_name = NULL_IF_CONFIG_SMALL("JPEG 2000"),
2214  .type = AVMEDIA_TYPE_VIDEO,
2215  .id = AV_CODEC_ID_JPEG2000,
2216  .capabilities = AV_CODEC_CAP_SLICE_THREADS | AV_CODEC_CAP_FRAME_THREADS | AV_CODEC_CAP_DR1,
2217  .priv_data_size = sizeof(Jpeg2000DecoderContext),
2218  .init_static_data = jpeg2000_init_static_data,
2219  .init = jpeg2000_decode_init,
2220  .decode = jpeg2000_decode_frame,
2221  .priv_class = &jpeg2000_class,
2222  .max_lowres = 5,
2223  .profiles = NULL_IF_CONFIG_SMALL(ff_jpeg2000_profiles)
2224 };
AV_PIX_FMT_FLAG_PAL
#define AV_PIX_FMT_FLAG_PAL
Pixel format has a palette in data[1], values are indexes in this palette.
Definition: pixdesc.h:132
decode_clnpass
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:1421
ff_mqc_initdec
void ff_mqc_initdec(MqcState *mqc, uint8_t *bp, int raw, int reset)
Initialize MQ-decoder.
Definition: mqcdec.c:71
Jpeg2000QuantStyle::nguardbits
uint8_t nguardbits
Definition: jpeg2000.h:153
NULL
#define NULL
Definition: coverity.c:32
JPEG2000_CBLK_VSC
#define JPEG2000_CBLK_VSC
Definition: jpeg2000.h:105
val
const char const char void * val
Definition: avisynth_c.h:771
Jpeg2000DSPContext::mct_decode
void(* mct_decode[FF_DWT_NB])(void *src0, void *src1, void *src2, int csize)
Definition: jpeg2000dsp.h:30
s
const char * s
Definition: avisynth_c.h:768
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
OFFSET
#define OFFSET(x)
Definition: jpeg2000dec.c:2195
ff_jpeg2000_init_tier1_luts
void av_cold ff_jpeg2000_init_tier1_luts(void)
Definition: jpeg2000.c:159
pix_fmt
static enum AVPixelFormat pix_fmt
Definition: demuxing_decoding.c:40
Jpeg2000DecoderContext::g
GetByteContext g
Definition: jpeg2000dec.c:92
ff_jpeg2000_cleanup
void ff_jpeg2000_cleanup(Jpeg2000Component *comp, Jpeg2000CodingStyle *codsty)
Definition: jpeg2000.c:579
Jpeg2000DecoderContext::avctx
AVCodecContext * avctx
Definition: jpeg2000dec.c:91
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2419
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:201
jpeg2000_read_main_headers
static int jpeg2000_read_main_headers(Jpeg2000DecoderContext *s)
Definition: jpeg2000dec.c:1836
Jpeg2000Component::dwt
DWTContext dwt
Definition: jpeg2000.h:208
AVOption
AVOption.
Definition: opt.h:246
data
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:101
Jpeg2000Prec::cblkincl
Jpeg2000TgtNode * cblkincl
Definition: jpeg2000.h:184
HAD_COC
#define HAD_COC
Definition: jpeg2000dec.c:50
xyz_pix_fmts
static enum AVPixelFormat xyz_pix_fmts[]
Definition: jpeg2000dec.c:249
ff_jpeg2000dsp_init
av_cold void ff_jpeg2000dsp_init(Jpeg2000DSPContext *c)
Definition: jpeg2000dsp.c:93
JPEG2000_T1_SIG_NB
#define JPEG2000_T1_SIG_NB
Definition: jpeg2000.h:85
imgutils.h
misc image utilities
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:86
RGB_PIXEL_FORMATS
#define RGB_PIXEL_FORMATS
Definition: jpeg2000dec.c:231
JPEG2000_PGOD_PCRL
#define JPEG2000_PGOD_PCRL
Definition: jpeg2000.h:118
Jpeg2000Component::f_data
float * f_data
Definition: jpeg2000.h:209
ff_set_dimensions
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:211
g
const char * g
Definition: vf_curves.c:112
desc
const char * desc
Definition: nvenc.c:60
all_pix_fmts
static enum AVPixelFormat all_pix_fmts[]
Definition: jpeg2000dec.c:251
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
AV_OPT_TYPE_INT
Definition: opt.h:223
SP
static uint64_t SP[8][256]
Definition: camellia.c:40
AV_PIX_FMT_RGBA64
#define AV_PIX_FMT_RGBA64
Definition: pixfmt.h:369
decode_refpass
static void decode_refpass(Jpeg2000T1Context *t1, int width, int height, int bpno, int vert_causal_ctx_csty_symbol)
Definition: jpeg2000dec.c:1397
JPEG2000_PGOD_RLCP
#define JPEG2000_PGOD_RLCP
Definition: jpeg2000.h:116
jpeg2000_flush
static void jpeg2000_flush(Jpeg2000DecoderContext *s)
Definition: jpeg2000dec.c:146
JP2_CODESTREAM
#define JP2_CODESTREAM
Definition: jpeg2000dec.c:47
AVRational::num
int num
Numerator.
Definition: rational.h:59
Jpeg2000DecoderContext::dsp
Jpeg2000DSPContext dsp
Definition: jpeg2000dec.c:121
AVPacket::size
int size
Definition: avcodec.h:1680
get_qcc
static int get_qcc(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q, uint8_t *properties)
Definition: jpeg2000dec.c:650
Jpeg2000Tile::qntsty
Jpeg2000QuantStyle qntsty[4]
Definition: jpeg2000dec.c:82
b
const char * b
Definition: vf_curves.c:113
mct_decode
static void mct_decode(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
Definition: jpeg2000dec.c:1621
ff_mqc_init_contexts
void ff_mqc_init_contexts(MqcState *mqc)
MQ-coder context initialisations.
Definition: mqc.c:111
Jpeg2000Prec::nb_codeblocks_width
int nb_codeblocks_width
Definition: jpeg2000.h:181
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
AVCodecContext::sample_aspect_ratio
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:2172
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1989
Jpeg2000QuantStyle::mant
uint16_t mant[JPEG2000_MAX_DECLEVELS *3]
Definition: jpeg2000.h:151
bytestream2_init
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:133
Jpeg2000POC::is_default
int is_default
Definition: jpeg2000dec.c:67
jpeg2000_decode_init
static av_cold int jpeg2000_decode_init(AVCodecContext *avctx)
Definition: jpeg2000dec.c:2108
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:222
get_qcd
static int get_qcd(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q, uint8_t *properties)
Definition: jpeg2000dec.c:632
AVCodecContext::bits_per_raw_sample
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:3164
Jpeg2000POCEntry::CSpoc
uint16_t CSpoc
Definition: jpeg2000dec.c:57
init_tile
static int init_tile(Jpeg2000DecoderContext *s, int tileno)
Definition: jpeg2000dec.c:841
Jpeg2000DecoderContext::codsty
Jpeg2000CodingStyle codsty[4]
Definition: jpeg2000dec.c:112
src
#define src
Definition: vp8dsp.c:254
AVCodecContext::profile
int profile
profile
Definition: avcodec.h:3266
AVCodec
AVCodec.
Definition: avcodec.h:3739
Jpeg2000Band::f_stepsize
float f_stepsize
Definition: jpeg2000.h:194
decode
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:42
AVPixFmtDescriptor::log2_chroma_w
uint8_t log2_chroma_w
Amount to shift the luma width right to find the chroma width.
Definition: pixdesc.h:92
dequantization_int
static void dequantization_int(int x, int y, Jpeg2000Cblk *cblk, Jpeg2000Component *comp, Jpeg2000T1Context *t1, Jpeg2000Band *band)
Definition: jpeg2000dec.c:1587
get_cod
static int get_cod(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c, uint8_t *properties)
Definition: jpeg2000dec.c:520
bytestream2_get_bufferu
static av_always_inline unsigned int bytestream2_get_bufferu(GetByteContext *g, uint8_t *dst, unsigned int size)
Definition: bytestream.h:273
attributes.h
Macro definitions for various function/variable attributes.
jpeg2000_read_bitstream_packets
static int jpeg2000_read_bitstream_packets(Jpeg2000DecoderContext *s)
Definition: jpeg2000dec.c:1955
rgb_pix_fmts
static enum AVPixelFormat rgb_pix_fmts[]
Definition: jpeg2000dec.c:246
Jpeg2000Cblk::npasses
uint8_t npasses
Definition: jpeg2000.h:164
band
Definition: af_biquads.c:76
AVClass::class_name
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
Jpeg2000DecoderContext::palette
uint32_t palette[256]
Definition: jpeg2000dec.c:104
dequantization_float
static void dequantization_float(int x, int y, Jpeg2000Cblk *cblk, Jpeg2000Component *comp, Jpeg2000T1Context *t1, Jpeg2000Band *band)
Definition: jpeg2000dec.c:1572
jpeg2000_decode_frame
static int jpeg2000_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: jpeg2000dec.c:2117
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
tile_codeblocks
static void tile_codeblocks(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
Definition: jpeg2000dec.c:1649
avpriv_request_sample
void void avpriv_request_sample(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
AV_PIX_FMT_YUVA420P
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
Definition: pixfmt.h:102
AVPixFmtDescriptor::comp
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
Definition: pixdesc.h:117
uint8_t
uint8_t
Definition: audio_convert.c:194
av_cold
#define av_cold
Definition: attributes.h:82
JP2_SIG_VALUE
#define JP2_SIG_VALUE
Definition: jpeg2000dec.c:46
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:64
AV_PIX_FMT_PAL8
8 bits with AV_PIX_FMT_RGB32 palette
Definition: pixfmt.h:73
opt.h
AVOptions.
Jpeg2000Cblk::nb_lengthinc
uint8_t nb_lengthinc
Definition: jpeg2000.h:169
WRITE_FRAME
#define WRITE_FRAME(D, PIXEL)
Definition: jpeg2000dec.c:1712
end
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
thread.h
Multithreading support functions.
Jpeg2000Prec::zerobits
Jpeg2000TgtNode * zerobits
Definition: jpeg2000.h:183
FF_CODEC_PROPERTY_LOSSLESS
#define FF_CODEC_PROPERTY_LOSSLESS
Definition: avcodec.h:3582
Jpeg2000ResLevel::band
Jpeg2000Band * band
Definition: jpeg2000.h:203
tag_tree_decode
static int tag_tree_decode(Jpeg2000DecoderContext *s, Jpeg2000TgtNode *node, int threshold)
Definition: jpeg2000dec.c:154
Jpeg2000TgtNode::val
uint8_t val
Definition: jpeg2000.h:129
Jpeg2000Component::coord
int coord[2][2]
Definition: jpeg2000.h:211
frame
static AVFrame * frame
Definition: demuxing_decoding.c:53
height
#define height
AVPacket::data
uint8_t * data
Definition: avcodec.h:1679
GetByteContext::buffer
const uint8_t * buffer
Definition: bytestream.h:34
bytestream2_skipu
static av_always_inline void bytestream2_skipu(GetByteContext *g, unsigned int size)
Definition: bytestream.h:170
sp
#define sp
Definition: regdef.h:63
JPEG2000_T1_VIS
#define JPEG2000_T1_VIS
Definition: jpeg2000.h:95
size
ptrdiff_t size
Definition: opengl_enc.c:101
av_reduce
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
Jpeg2000POC::poc
Jpeg2000POCEntry poc[MAX_POCS]
Definition: jpeg2000dec.c:65
JPEG2000_T1_SIG_SE
#define JPEG2000_T1_SIG_SE
Definition: jpeg2000.h:83
get_tlm
static uint8_t get_tlm(Jpeg2000DecoderContext *s, int n)
Definition: jpeg2000dec.c:791
Jpeg2000T1Context::flags
uint16_t flags[6156]
Definition: jpeg2000.h:123
JPEG2000_CBLK_SEGSYM
#define JPEG2000_CBLK_SEGSYM
Definition: jpeg2000.h:107
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
Jpeg2000DecoderContext::tile
Jpeg2000Tile * tile
Definition: jpeg2000dec.c:120
Jpeg2000Cblk::nonzerobits
uint8_t nonzerobits
Definition: jpeg2000.h:166
Jpeg2000CodingStyle::log2_prec_widths
uint8_t log2_prec_widths[JPEG2000_MAX_RESLEVELS]
Definition: jpeg2000.h:145
get_poc
static int get_poc(Jpeg2000DecoderContext *s, int size, Jpeg2000POC *p)
Definition: jpeg2000dec.c:671
JPEG2000_CSTY_EPH
#define JPEG2000_CSTY_EPH
Definition: jpeg2000.h:112
U
#define U(x)
Definition: vp56_arith.h:37
Jpeg2000Cblk::nb_terminations
int nb_terminations
Definition: jpeg2000.h:173
jpeg2000_decode_packet
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
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
td
#define td
Definition: regdef.h:70
getnpasses
static int getnpasses(Jpeg2000DecoderContext *s)
Definition: jpeg2000dec.c:887
AVPixFmtDescriptor::log2_chroma_h
uint8_t log2_chroma_h
Amount to shift the luma height right to find the chroma height.
Definition: pixdesc.h:101
mask
static const uint16_t mask[17]
Definition: lzw.c:38
PTRDIFF_SPECIFIER
#define PTRDIFF_SPECIFIER
Definition: internal.h:254
YUV_PIXEL_FORMATS
#define YUV_PIXEL_FORMATS
Definition: jpeg2000dec.c:233
ff_jpeg2000_set_significance
void ff_jpeg2000_set_significance(Jpeg2000T1Context *t1, int x, int y, int negative)
Definition: jpeg2000.c:171
av_default_item_name
av_default_item_name
Definition: libopenh264enc.c:78
AVERROR
#define AVERROR(e)
Definition: error.h:43
bytestream2_skip
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
Definition: bytestream.h:164
gray_pix_fmts
static enum AVPixelFormat gray_pix_fmts[]
Definition: jpeg2000dec.c:247
Jpeg2000Prec::nb_codeblocks_height
int nb_codeblocks_height
Definition: jpeg2000.h:182
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:179
JPEG2000_PGOD_CPRL
#define JPEG2000_PGOD_CPRL
Definition: jpeg2000.h:119
r
const char * r
Definition: vf_curves.c:111
get_coc
static int get_coc(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c, uint8_t *properties)
Definition: jpeg2000dec.c:557
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
Jpeg2000CodingStyle::log2_prec_heights
uint8_t log2_prec_heights[JPEG2000_MAX_RESLEVELS]
Definition: jpeg2000.h:146
t1
#define t1
Definition: regdef.h:29
bytestream2_get_bytes_left
static av_always_inline unsigned int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:154
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:1856
JPEG2000_MAX_PASSES
#define JPEG2000_MAX_PASSES
Definition: jpeg2000.h:73
width
uint16_t width
Definition: gdv.c:47
AV_PIX_FMT_RGB48
#define AV_PIX_FMT_RGB48
Definition: pixfmt.h:365
avassert.h
simple assert() macros that are a bit more flexible than ISO C assert().
AVCodec::name
const char * name
Name of the codec implementation.
Definition: avcodec.h:3746
JPEG2000_CBLK_RESET
#define JPEG2000_CBLK_RESET
Definition: jpeg2000.h:103
get_plt
static uint8_t get_plt(Jpeg2000DecoderContext *s, int n)
Definition: jpeg2000dec.c:825
Jpeg2000Prec::cblk
Jpeg2000Cblk * cblk
Definition: jpeg2000.h:185
FFMAX
#define FFMAX(a, b)
Definition: common.h:94
Jpeg2000TilePart::tile_index
uint8_t tile_index
Definition: jpeg2000dec.c:71
Jpeg2000CodingStyle::cblk_style
uint8_t cblk_style
Definition: jpeg2000.h:143
av_mallocz_array
static void * av_mallocz_array(size_t nmemb, size_t size)
Definition: mem.h:229
AV_CODEC_CAP_FRAME_THREADS
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: avcodec.h:1065
JPEG2000_SOP_FIXED_BYTES
#define JPEG2000_SOP_FIXED_BYTES
Definition: jpeg2000.h:61
get_cox
static int get_cox(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c)
Definition: jpeg2000dec.c:445
jpeg2000_class
static const AVClass jpeg2000_class
Definition: jpeg2000dec.c:2204
JPEG2000_T1_REF
#define JPEG2000_T1_REF
Definition: jpeg2000.h:97
AVPixFmtDescriptor::flags
uint64_t flags
Combination of AV_PIX_FMT_FLAG_...
Definition: pixdesc.h:106
av_image_check_size
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:281
Jpeg2000Cblk::lblock
uint8_t lblock
Definition: jpeg2000.h:170
AVPixFmtDescriptor::nb_components
uint8_t nb_components
The number of components each pixel has, (1-4)
Definition: pixdesc.h:83
JP2_SIG_TYPE
#define JP2_SIG_TYPE
Definition: jpeg2000dec.c:45
AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
AVFrame::pict_type
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:284
AV_CODEC_FLAG_BITEXACT
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:929
AV_PIX_FMT_GRAY16
#define AV_PIX_FMT_GRAY16
Definition: pixfmt.h:363
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
FFMIN
#define FFMIN(a, b)
Definition: common.h:96
Jpeg2000Cblk::data
uint8_t data[8192]
Definition: jpeg2000.h:172
Jpeg2000TgtNode::parent
struct Jpeg2000TgtNode * parent
Definition: jpeg2000.h:131
JPEG2000_T1_SGN_S
#define JPEG2000_T1_SGN_S
Definition: jpeg2000.h:91
jpeg2000.h
JPEG 2000 structures and defines common to encoder and decoder.
Jpeg2000Band::i_stepsize
int i_stepsize
Definition: jpeg2000.h:193
Jpeg2000Cblk::nb_terminationsinc
int nb_terminationsinc
Definition: jpeg2000.h:174
JPEG2000_MAX_RESLEVELS
#define JPEG2000_MAX_RESLEVELS
Definition: jpeg2000.h:71
int32_t
int32_t
Definition: audio_convert.c:194
needs_termination
static int needs_termination(int style, int passno)
Definition: jpeg2000.h:274
HAD_QCC
#define HAD_QCC
Definition: jpeg2000dec.c:51
MQC_CX_RL
#define MQC_CX_RL
Definition: mqc.h:34
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
jpeg2000_init_static_data
static av_cold void jpeg2000_init_static_data(AVCodec *codec)
Definition: jpeg2000dec.c:2189
ff_jpeg2000_getsigctxno
static int ff_jpeg2000_getsigctxno(int flag, int bandno)
Definition: jpeg2000.h:240
VD
#define VD
Definition: jpeg2000dec.c:2196
n
int n
Definition: avisynth_c.h:684
FF_PROFILE_JPEG2000_DCINEMA_4K
#define FF_PROFILE_JPEG2000_DCINEMA_4K
Definition: avcodec.h:3347
JPEG2000_MAX_DECLEVELS
#define JPEG2000_MAX_DECLEVELS
Definition: jpeg2000.h:70
jpeg2000_decode_packets_po_iteration
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:1058
Jpeg2000Tile::tile_part
Jpeg2000TilePart tile_part[256]
Definition: jpeg2000dec.c:84
get_siz
static int get_siz(Jpeg2000DecoderContext *s)
Definition: jpeg2000dec.c:258
Jpeg2000Cblk::coord
int coord[2][2]
Definition: jpeg2000.h:177
JP2_HEADER
#define JP2_HEADER
Definition: jpeg2000dec.c:48
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen_template.c:36
Jpeg2000Cblk::lengthinc
uint16_t lengthinc[JPEG2000_MAX_PASSES]
Definition: jpeg2000.h:168
JPEG2000_PGOD_RPCL
#define JPEG2000_PGOD_RPCL
Definition: jpeg2000.h:117
ff_jpeg2000_ceildivpow2
static int ff_jpeg2000_ceildivpow2(int a, int b)
Definition: jpeg2000.h:216
comp
static void comp(unsigned char *dst, ptrdiff_t dst_stride, unsigned char *src, ptrdiff_t src_stride, int add)
Definition: eamad.c:83
Jpeg2000Band::coord
int coord[2][2]
Definition: jpeg2000.h:191
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
AV_CODEC_CAP_SLICE_THREADS
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: avcodec.h:1069
bytestream2_tell
static av_always_inline int bytestream2_tell(GetByteContext *g)
Definition: bytestream.h:188
AVFrame::format
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames...
Definition: frame.h:274
Jpeg2000TilePart::tpg
GetByteContext tpg
Definition: jpeg2000dec.c:73
Jpeg2000Tile::tp_idx
uint16_t tp_idx
Definition: jpeg2000dec.c:85
Jpeg2000Cblk::data_start
int data_start[JPEG2000_MAX_PASSES]
Definition: jpeg2000.h:175
Jpeg2000Component::coord_o
int coord_o[2][2]
Definition: jpeg2000.h:212
avcodec.h
Libavcodec external API header.
yuv_pix_fmts
static enum AVPixelFormat yuv_pix_fmts[]
Definition: jpeg2000dec.c:248
byte
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
ff_mqc_decode
int ff_mqc_decode(MqcState *mqc, uint8_t *cxstate)
MQ decoder.
Definition: mqcdec.c:93
Jpeg2000POCEntry::LYEpoc
uint16_t LYEpoc
Definition: jpeg2000dec.c:56
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:81
ff_thread_get_buffer
int ff_thread_get_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags)
Wrapper around get_buffer() for frame-multithreaded codecs.
Definition: pthread_frame.c:976
AVCodecContext
main external API structure.
Definition: avcodec.h:1761
ff_jpeg2000_decoder
AVCodec ff_jpeg2000_decoder
Definition: jpeg2000dec.c:2211
pix_fmt_match
static int pix_fmt_match(enum AVPixelFormat pix_fmt, int components, int bpc, uint32_t log2_chroma_wh, int pal8)
Definition: jpeg2000dec.c:194
Jpeg2000TgtNode::vis
uint8_t vis
Definition: jpeg2000.h:130
Jpeg2000Tile::coord
int coord[2][2]
Definition: jpeg2000dec.c:86
Jpeg2000ResLevel::log2_prec_height
uint8_t log2_prec_height
Definition: jpeg2000.h:202
ff_mqc_init_context_tables
void av_cold ff_mqc_init_context_tables(void)
MQ-coder Initialize context tables (QE, NLPS, NMPS)
Definition: mqc.c:97
Jpeg2000Cblk::length
uint16_t length
Definition: jpeg2000.h:167
Jpeg2000Tile::properties
uint8_t properties[4]
Definition: jpeg2000dec.c:80
AVERROR_BUG
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
Definition: error.h:50
getlblockinc
static int getlblockinc(Jpeg2000DecoderContext *s)
Definition: jpeg2000dec.c:902
AV_PIX_FMT_XYZ12
#define AV_PIX_FMT_XYZ12
Definition: pixfmt.h:421
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:67
profiles
static const AVProfile profiles[]
Definition: libfdk-aacenc.c:378
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
Jpeg2000ResLevel::nbands
uint8_t nbands
Definition: jpeg2000.h:199
Jpeg2000TilePart::tp_end
const uint8_t * tp_end
Definition: jpeg2000dec.c:72
Jpeg2000Prec::decoded_layers
int decoded_layers
Definition: jpeg2000.h:186
JPEG2000_SOP_BYTE_LENGTH
#define JPEG2000_SOP_BYTE_LENGTH
Definition: jpeg2000.h:62
options
static const AVOption options[]
Definition: jpeg2000dec.c:2198
u
#define u(width,...)
Definition: vaapi_encode_h26x.h:36
JPEG2000_T1_SIG_S
#define JPEG2000_T1_SIG_S
Definition: jpeg2000.h:80
Jpeg2000Component::reslevel
Jpeg2000ResLevel * reslevel
Definition: jpeg2000.h:207
ff_jpeg2000_ceildiv
static int ff_jpeg2000_ceildiv(int a, int b)
Definition: jpeg2000.h:221
Jpeg2000Tile::comp
Jpeg2000Component * comp
Definition: j2kenc.c:100
SIZE_SPECIFIER
#define SIZE_SPECIFIER
Definition: internal.h:255
AV_CODEC_ID_JPEG2000
Definition: avcodec.h:308
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:215
Jpeg2000QuantStyle::expn
uint8_t expn[JPEG2000_MAX_DECLEVELS *3]
Definition: jpeg2000.h:150
jpeg2000_decode_packets
static int jpeg2000_decode_packets(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
Definition: jpeg2000dec.c:1330
get_sot
static int get_sot(Jpeg2000DecoderContext *s, int n)
Definition: jpeg2000dec.c:733
jp2_find_codestream
static int jp2_find_codestream(Jpeg2000DecoderContext *s)
Definition: jpeg2000dec.c:1974
jpeg2000_dec_cleanup
static void jpeg2000_dec_cleanup(Jpeg2000DecoderContext *s)
Definition: jpeg2000dec.c:1813
decode_sigpass
static void decode_sigpass(Jpeg2000T1Context *t1, int width, int height, int bpno, int bandno, int vert_causal_ctx_csty_symbol)
Definition: jpeg2000dec.c:1367
Jpeg2000CodingStyle::prog_order
uint8_t prog_order
Definition: jpeg2000.h:144
Jpeg2000Tile::poc
Jpeg2000POC poc
Definition: jpeg2000dec.c:83
dequantization_int_97
static void dequantization_int_97(int x, int y, Jpeg2000Cblk *cblk, Jpeg2000Component *comp, Jpeg2000T1Context *t1, Jpeg2000Band *band)
Definition: jpeg2000dec.c:1607
Jpeg2000QuantStyle::quantsty
uint8_t quantsty
Definition: jpeg2000.h:152
internal.h
common internal api header.
common.h
common internal and external API header
Jpeg2000CodingStyle::log2_cblk_width
uint8_t log2_cblk_width
Definition: jpeg2000.h:137
c
static double c[64]
Definition: vsrc_mptestsrc.c:87
Jpeg2000DecoderContext::qntsty
Jpeg2000QuantStyle qntsty[4]
Definition: jpeg2000dec.c:113
ff_dwt_decode
int ff_dwt_decode(DWTContext *s, void *t)
Definition: jpeg2000dwt.c:599
Jpeg2000T1Context::data
int data[6144]
Definition: jpeg2000.h:122
XYZ_PIXEL_FORMATS
#define XYZ_PIXEL_FORMATS
Definition: jpeg2000dec.c:244
GRAY_PIXEL_FORMATS
#define GRAY_PIXEL_FORMATS
Definition: jpeg2000dec.c:232
AVCodecContext::properties
unsigned properties
Properties of the stream that gets decoded.
Definition: avcodec.h:3581
AVRational::den
int den
Denominator.
Definition: rational.h:60
MKBETAG
#define MKBETAG(a, b, c, d)
Definition: common.h:343
JPEG2000_CBLK_BYPASS
#define JPEG2000_CBLK_BYPASS
Definition: jpeg2000.h:102
MQC_CX_UNI
#define MQC_CX_UNI
Definition: mqc.h:33
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:1803
ff_jpeg2000_init_component
int ff_jpeg2000_init_component(Jpeg2000Component *comp, Jpeg2000CodingStyle *codsty, Jpeg2000QuantStyle *qntsty, int cbps, int dx, int dy, AVCodecContext *avctx)
Definition: jpeg2000.c:448
JPEG2000_T1_SIG_SW
#define JPEG2000_T1_SIG_SW
Definition: jpeg2000.h:84
JPEG2000_PGOD_LRCP
#define JPEG2000_PGOD_LRCP
Definition: jpeg2000.h:115
get_bits
static int get_bits(Jpeg2000DecoderContext *s, int n)
Definition: jpeg2000dec.c:131
MAX_POCS
#define MAX_POCS
Definition: jpeg2000dec.c:53
len
int len
Definition: vorbis_enc_data.h:452
AVCodecContext::execute2
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:3252
MqcState::raw
int raw
Definition: mqc.h:46
FF_PROFILE_JPEG2000_DCINEMA_2K
#define FF_PROFILE_JPEG2000_DCINEMA_2K
Definition: avcodec.h:3346
AVFrame::key_frame
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:279
Jpeg2000Band::prec
Jpeg2000Prec * prec
Definition: jpeg2000.h:195
bytestream2_seek
static av_always_inline int bytestream2_seek(GetByteContext *g, int offset, int whence)
Definition: bytestream.h:208
JPEG2000_T1_SIG
#define JPEG2000_T1_SIG
Definition: jpeg2000.h:96
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
Jpeg2000T1Context::mqc
MqcState mqc
Definition: jpeg2000.h:124
AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
ff_jpeg2000_getrefctxno
static int ff_jpeg2000_getrefctxno(int flag)
Definition: jpeg2000.h:249
JPEG2000_CSTY_PREC
#define JPEG2000_CSTY_PREC
Definition: jpeg2000.h:110
Jpeg2000CodingStyle::log2_cblk_height
uint8_t log2_cblk_height
Definition: jpeg2000.h:137
Jpeg2000POCEntry::CEpoc
uint16_t CEpoc
Definition: jpeg2000dec.c:58
MqcState::bp
uint8_t * bp
Definition: mqc.h:41
Jpeg2000ResLevel::log2_prec_width
uint8_t log2_prec_width
Definition: jpeg2000.h:202
AVComponentDescriptor::depth
int depth
Number of bits in the component.
Definition: pixdesc.h:58
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:60
AVPacket
This structure stores compressed data.
Definition: avcodec.h:1656
get_qcx
static int get_qcx(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q)
Definition: jpeg2000dec.c:587
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:1002
Jpeg2000Tile::codsty
Jpeg2000CodingStyle codsty[4]
Definition: jpeg2000dec.c:81
decode_cblk
static int decode_cblk(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *codsty, Jpeg2000T1Context *t1, Jpeg2000Cblk *cblk, int width, int height, int bandpos)
Definition: jpeg2000dec.c:1487
MqcState::cx_states
uint8_t cx_states[19]
Definition: mqc.h:45
av_unused
#define av_unused
Definition: attributes.h:125
ff_jpeg2000_profiles
const AVProfile ff_jpeg2000_profiles[]
Definition: profiles.c:86
ff_jpeg2000_getsgnctxno
static int ff_jpeg2000_getsgnctxno(int flag, int *xorbit)
Definition: jpeg2000.h:258
jpeg2000_decode_tile
static int jpeg2000_decode_tile(AVCodecContext *avctx, void *td, int jobnr, int threadnr)
Definition: jpeg2000dec.c:1774
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:26
Generated on Fri Jan 12 2018 01:47:43 for FFmpeg by   doxygen 1.8.6