FFmpeg
jpeg2000dec.c
Go to the documentation of this file.
1 /*
2  * JPEG 2000 image decoder
3  * Copyright (c) 2007 Kamil Nowosad
4  * Copyright (c) 2013 Nicolas Bertrand <nicoinattendu@gmail.com>
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22 
23 /**
24  * @file
25  * JPEG 2000 image decoder
26  */
27 
28 #include <inttypes.h>
29 #include <math.h>
30 
31 #include "libavutil/attributes.h"
32 #include "libavutil/avassert.h"
33 #include "libavutil/common.h"
34 #include "libavutil/imgutils.h"
35 #include "libavutil/mem.h"
36 #include "libavutil/opt.h"
37 #include "libavutil/pixdesc.h"
38 #include "avcodec.h"
39 #include "bytestream.h"
40 #include "codec_internal.h"
41 #include "decode.h"
42 #include "thread.h"
43 #include "jpeg2000.h"
44 #include "jpeg2000dsp.h"
45 #include "profiles.h"
46 #include "jpeg2000dec.h"
47 #include "jpeg2000htdec.h"
48 
49 #define JP2_SIG_TYPE 0x6A502020
50 #define JP2_SIG_VALUE 0x0D0A870A
51 #define JP2_CODESTREAM 0x6A703263
52 #define JP2_HEADER 0x6A703268
53 
54 #define HAD_COC 0x01
55 #define HAD_QCC 0x02
56 
57 // Values of flag for placeholder passes
58 enum HT_PLHD_STATUS {
59  HT_PLHD_OFF,
60  HT_PLHD_ON
61 };
62 
63 #define HT_MIXED 0x80 // bit 7 of SPcod/SPcoc
64 
65 
66 /* get_bits functions for JPEG2000 packet bitstream
67  * It is a get_bit function with a bit-stuffing routine. If the value of the
68  * byte is 0xFF, the next byte includes an extra zero bit stuffed into the MSB.
69  * cf. ISO-15444-1:2002 / B.10.1 Bit-stuffing routine */
70 static int get_bits(Jpeg2000DecoderContext *s, int n)
71 {
72  int res = 0;
73 
74  while (--n >= 0) {
75  res <<= 1;
76  if (s->bit_index == 0) {
77  s->bit_index = 7 + (bytestream2_get_byte(&s->g) != 0xFFu);
78  }
79  s->bit_index--;
80  res |= (bytestream2_peek_byte(&s->g) >> s->bit_index) & 1;
81  }
82  return res;
83 }
84 
85 static void jpeg2000_flush(Jpeg2000DecoderContext *s)
86 {
87  if (bytestream2_get_byte(&s->g) == 0xff)
88  bytestream2_skip(&s->g, 1);
89  s->bit_index = 8;
90 }
91 
92 /* decode the value stored in node */
93 static int tag_tree_decode(Jpeg2000DecoderContext *s, Jpeg2000TgtNode *node,
94  int threshold)
95 {
96  Jpeg2000TgtNode *stack[30];
97  int sp = -1, curval = 0;
98 
99  if (!node) {
100  av_log(s->avctx, AV_LOG_ERROR, "missing node\n");
101  return AVERROR_INVALIDDATA;
102  }
103 
104  while (node && !node->vis) {
105  stack[++sp] = node;
106  node = node->parent;
107  }
108 
109  if (node)
110  curval = node->val;
111  else
112  curval = stack[sp]->val;
113 
114  while (curval < threshold && sp >= 0) {
115  if (curval < stack[sp]->val)
116  curval = stack[sp]->val;
117  while (curval < threshold) {
118  int ret;
119  if ((ret = get_bits(s, 1)) > 0) {
120  stack[sp]->vis++;
121  break;
122  } else if (!ret)
123  curval++;
124  else
125  return ret;
126  }
127  stack[sp]->val = curval;
128  sp--;
129  }
130  return curval;
131 }
132 
133 static int pix_fmt_match(enum AVPixelFormat pix_fmt, int components,
134  int bpc, uint32_t log2_chroma_wh, int pal8)
135 {
136  int match = 1;
137  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
138 
139  av_assert2(desc);
140 
141  if (desc->nb_components != components) {
142  return 0;
143  }
144 
145  switch (components) {
146  case 4:
147  match = match && desc->comp[3].depth >= bpc &&
148  (log2_chroma_wh >> 14 & 3) == 0 &&
149  (log2_chroma_wh >> 12 & 3) == 0;
150  av_fallthrough;
151  case 3:
152  match = match && desc->comp[2].depth >= bpc &&
153  (log2_chroma_wh >> 10 & 3) == desc->log2_chroma_w &&
154  (log2_chroma_wh >> 8 & 3) == desc->log2_chroma_h;
155  av_fallthrough;
156  case 2:
157  match = match && desc->comp[1].depth >= bpc &&
158  (log2_chroma_wh >> 6 & 3) == desc->log2_chroma_w &&
159  (log2_chroma_wh >> 4 & 3) == desc->log2_chroma_h;
160  av_fallthrough;
161 
162  case 1:
163  match = match && desc->comp[0].depth >= bpc &&
164  (log2_chroma_wh >> 2 & 3) == 0 &&
165  (log2_chroma_wh & 3) == 0 &&
166  (desc->flags & AV_PIX_FMT_FLAG_PAL) == pal8 * AV_PIX_FMT_FLAG_PAL;
167  }
168  return match;
169 }
170 
171 // pix_fmts with lower bpp have to be listed before
172 // similar pix_fmts with higher bpp.
173 #define RGB_PIXEL_FORMATS AV_PIX_FMT_PAL8,AV_PIX_FMT_RGB24,AV_PIX_FMT_RGBA,AV_PIX_FMT_RGB48,AV_PIX_FMT_RGBA64
174 #define GRAY_PIXEL_FORMATS AV_PIX_FMT_GRAY8,AV_PIX_FMT_GRAY8A,AV_PIX_FMT_GRAY16,AV_PIX_FMT_YA16
175 #define YUV_PIXEL_FORMATS AV_PIX_FMT_YUV410P,AV_PIX_FMT_YUV411P,AV_PIX_FMT_YUVA420P, \
176  AV_PIX_FMT_YUV420P,AV_PIX_FMT_YUV422P,AV_PIX_FMT_YUVA422P, \
177  AV_PIX_FMT_YUV440P,AV_PIX_FMT_YUV444P,AV_PIX_FMT_YUVA444P, \
178  AV_PIX_FMT_YUV420P9,AV_PIX_FMT_YUV422P9,AV_PIX_FMT_YUV444P9, \
179  AV_PIX_FMT_YUVA420P9,AV_PIX_FMT_YUVA422P9,AV_PIX_FMT_YUVA444P9, \
180  AV_PIX_FMT_YUV420P10,AV_PIX_FMT_YUV422P10,AV_PIX_FMT_YUV444P10, \
181  AV_PIX_FMT_YUVA420P10,AV_PIX_FMT_YUVA422P10,AV_PIX_FMT_YUVA444P10, \
182  AV_PIX_FMT_YUV420P12,AV_PIX_FMT_YUV422P12,AV_PIX_FMT_YUV444P12, \
183  AV_PIX_FMT_YUV420P14,AV_PIX_FMT_YUV422P14,AV_PIX_FMT_YUV444P14, \
184  AV_PIX_FMT_YUV420P16,AV_PIX_FMT_YUV422P16,AV_PIX_FMT_YUV444P16, \
185  AV_PIX_FMT_YUVA420P16,AV_PIX_FMT_YUVA422P16,AV_PIX_FMT_YUVA444P16
186 #define XYZ_PIXEL_FORMATS AV_PIX_FMT_XYZ12
187 
188 static const enum AVPixelFormat rgb_pix_fmts[] = {RGB_PIXEL_FORMATS};
189 static const enum AVPixelFormat gray_pix_fmts[] = {GRAY_PIXEL_FORMATS};
190 static const enum AVPixelFormat yuv_pix_fmts[] = {YUV_PIXEL_FORMATS};
191 static const enum AVPixelFormat xyz_pix_fmts[] = {XYZ_PIXEL_FORMATS,
192  YUV_PIXEL_FORMATS};
193 static const enum AVPixelFormat all_pix_fmts[] = {RGB_PIXEL_FORMATS,
194  GRAY_PIXEL_FORMATS,
195  YUV_PIXEL_FORMATS,
196  XYZ_PIXEL_FORMATS};
197 
198 /* marker segments */
199 /* get sizes and offsets of image, tiles; number of components */
200 static int get_siz(Jpeg2000DecoderContext *s)
201 {
202  int i;
203  int ncomponents;
204  uint32_t log2_chroma_wh = 0;
205  const enum AVPixelFormat *possible_fmts = NULL;
206  int possible_fmts_nb = 0;
207  int ret;
208  int o_dimx, o_dimy; //original image dimensions.
209  int dimx, dimy;
210 
211  if (bytestream2_get_bytes_left(&s->g) < 36) {
212  av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for SIZ\n");
213  return AVERROR_INVALIDDATA;
214  }
215 
216  s->avctx->profile = bytestream2_get_be16u(&s->g); // Rsiz
217  s->width = bytestream2_get_be32u(&s->g); // Width
218  s->height = bytestream2_get_be32u(&s->g); // Height
219  s->image_offset_x = bytestream2_get_be32u(&s->g); // X0Siz
220  s->image_offset_y = bytestream2_get_be32u(&s->g); // Y0Siz
221  s->tile_width = bytestream2_get_be32u(&s->g); // XTSiz
222  s->tile_height = bytestream2_get_be32u(&s->g); // YTSiz
223  s->tile_offset_x = bytestream2_get_be32u(&s->g); // XT0Siz
224  s->tile_offset_y = bytestream2_get_be32u(&s->g); // YT0Siz
225  ncomponents = bytestream2_get_be16u(&s->g); // CSiz
226 
227  if (av_image_check_size2(s->width, s->height, s->avctx->max_pixels, AV_PIX_FMT_NONE, 0, s->avctx)) {
228  avpriv_request_sample(s->avctx, "Large Dimensions");
229  return AVERROR_PATCHWELCOME;
230  }
231 
232  if (ncomponents <= 0) {
233  av_log(s->avctx, AV_LOG_ERROR, "Invalid number of components: %d\n",
234  s->ncomponents);
235  return AVERROR_INVALIDDATA;
236  }
237 
238  if (ncomponents > 4) {
239  avpriv_request_sample(s->avctx, "Support for %d components",
240  ncomponents);
241  return AVERROR_PATCHWELCOME;
242  }
243 
244  if (s->tile_offset_x < 0 || s->tile_offset_y < 0 ||
245  s->image_offset_x < s->tile_offset_x ||
246  s->image_offset_y < s->tile_offset_y ||
247  s->tile_width + (int64_t)s->tile_offset_x <= s->image_offset_x ||
248  s->tile_height + (int64_t)s->tile_offset_y <= s->image_offset_y
249  ) {
250  av_log(s->avctx, AV_LOG_ERROR, "Tile offsets are invalid\n");
251  return AVERROR_INVALIDDATA;
252  }
253 
254  if (s->image_offset_x >= s->width || s->image_offset_y >= s->height) {
255  av_log(s->avctx, AV_LOG_ERROR, "image offsets outside image");
256  return AVERROR_INVALIDDATA;
257  }
258 
259  if (s->reduction_factor && (s->image_offset_x || s->image_offset_y) ){
260  av_log(s->avctx, AV_LOG_ERROR, "reduction factor with image offsets is not fully implemented");
261  return AVERROR_PATCHWELCOME;
262  }
263 
264  s->ncomponents = ncomponents;
265 
266  if (s->tile_width <= 0 || s->tile_height <= 0) {
267  av_log(s->avctx, AV_LOG_ERROR, "Invalid tile dimension %dx%d.\n",
268  s->tile_width, s->tile_height);
269  return AVERROR_INVALIDDATA;
270  }
271 
272  if (bytestream2_get_bytes_left(&s->g) < 3 * s->ncomponents) {
273  av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for %d components in SIZ\n", s->ncomponents);
274  return AVERROR_INVALIDDATA;
275  }
276 
277  for (i = 0; i < s->ncomponents; i++) {
278  if (s->cdef[i] < 0) {
279  for (i = 0; i < s->ncomponents; i++) {
280  s->cdef[i] = i + 1;
281  }
282  if ((s->ncomponents & 1) == 0)
283  s->cdef[s->ncomponents-1] = 0;
284  }
285  }
286  // after here we no longer have to consider negative cdef
287 
288  int cdef_used = 0;
289  for (i = 0; i < s->ncomponents; i++)
290  cdef_used |= 1<<s->cdef[i];
291 
292  // Check that the channels we have are what we expect for the number of components
293  if (cdef_used != ((int[]){0,2,3,14,15})[s->ncomponents])
294  return AVERROR_INVALIDDATA;
295 
296  for (i = 0; i < s->ncomponents; i++) { // Ssiz_i XRsiz_i, YRsiz_i
297  uint8_t x = bytestream2_get_byteu(&s->g);
298  s->cbps[i] = (x & 0x7f) + 1;
299  s->precision = FFMAX(s->cbps[i], s->precision);
300  s->sgnd[i] = !!(x & 0x80);
301  s->cdx[i] = bytestream2_get_byteu(&s->g);
302  s->cdy[i] = bytestream2_get_byteu(&s->g);
303  if ( !s->cdx[i] || s->cdx[i] == 3 || s->cdx[i] > 4
304  || !s->cdy[i] || s->cdy[i] == 3 || s->cdy[i] > 4) {
305  av_log(s->avctx, AV_LOG_ERROR, "Invalid sample separation %d/%d\n", s->cdx[i], s->cdy[i]);
306  return AVERROR_INVALIDDATA;
307  }
308  int i_remapped = s->cdef[i] ? s->cdef[i]-1 : (s->ncomponents-1);
309 
310  log2_chroma_wh |= s->cdy[i] >> 1 << i_remapped * 4 | s->cdx[i] >> 1 << i_remapped * 4 + 2;
311  }
312 
313  s->numXtiles = ff_jpeg2000_ceildiv(s->width - s->tile_offset_x, s->tile_width);
314  s->numYtiles = ff_jpeg2000_ceildiv(s->height - s->tile_offset_y, s->tile_height);
315 
316  // There must be at least a SOT and SOD per tile, their minimum size is 14
317  if (s->numXtiles * (uint64_t)s->numYtiles > INT_MAX/sizeof(*s->tile) ||
318  s->numXtiles * s->numYtiles * 14LL > bytestream2_size(&s->g)
319  ) {
320  s->numXtiles = s->numYtiles = 0;
321  return AVERROR(EINVAL);
322  }
323 
324  s->tile = av_calloc(s->numXtiles * s->numYtiles, sizeof(*s->tile));
325  if (!s->tile) {
326  s->numXtiles = s->numYtiles = 0;
327  return AVERROR(ENOMEM);
328  }
329 
330  for (i = 0; i < s->numXtiles * s->numYtiles; i++) {
331  Jpeg2000Tile *tile = s->tile + i;
332 
333  tile->comp = av_mallocz(s->ncomponents * sizeof(*tile->comp));
334  if (!tile->comp)
335  return AVERROR(ENOMEM);
336  }
337 
338  /* compute image size with reduction factor */
339  o_dimx = ff_jpeg2000_ceildivpow2(s->width - s->image_offset_x,
340  s->reduction_factor);
341  o_dimy = ff_jpeg2000_ceildivpow2(s->height - s->image_offset_y,
342  s->reduction_factor);
343  dimx = ff_jpeg2000_ceildiv(o_dimx, s->cdx[0]);
344  dimy = ff_jpeg2000_ceildiv(o_dimy, s->cdy[0]);
345  for (i = 1; i < s->ncomponents; i++) {
346  dimx = FFMAX(dimx, ff_jpeg2000_ceildiv(o_dimx, s->cdx[i]));
347  dimy = FFMAX(dimy, ff_jpeg2000_ceildiv(o_dimy, s->cdy[i]));
348  }
349 
350  ret = ff_set_dimensions(s->avctx, dimx << s->avctx->lowres, dimy << s->avctx->lowres);
351  if (ret < 0)
352  return ret;
353 
354  if (s->avctx->profile == AV_PROFILE_JPEG2000_DCINEMA_2K ||
355  s->avctx->profile == AV_PROFILE_JPEG2000_DCINEMA_4K) {
356  possible_fmts = xyz_pix_fmts;
357  possible_fmts_nb = FF_ARRAY_ELEMS(xyz_pix_fmts);
358  } else {
359  switch (s->colour_space) {
360  case 16:
361  possible_fmts = rgb_pix_fmts;
362  possible_fmts_nb = FF_ARRAY_ELEMS(rgb_pix_fmts);
363  break;
364  case 17:
365  possible_fmts = gray_pix_fmts;
366  possible_fmts_nb = FF_ARRAY_ELEMS(gray_pix_fmts);
367  break;
368  case 18:
369  possible_fmts = yuv_pix_fmts;
370  possible_fmts_nb = FF_ARRAY_ELEMS(yuv_pix_fmts);
371  break;
372  default:
373  possible_fmts = all_pix_fmts;
374  possible_fmts_nb = FF_ARRAY_ELEMS(all_pix_fmts);
375  break;
376  }
377  }
378  if ( s->avctx->pix_fmt != AV_PIX_FMT_NONE
379  && !pix_fmt_match(s->avctx->pix_fmt, ncomponents, s->precision, log2_chroma_wh, s->pal8))
380  s->avctx->pix_fmt = AV_PIX_FMT_NONE;
381  if (s->avctx->pix_fmt == AV_PIX_FMT_NONE)
382  for (i = 0; i < possible_fmts_nb; ++i) {
383  if (pix_fmt_match(possible_fmts[i], ncomponents, s->precision, log2_chroma_wh, s->pal8)) {
384  s->avctx->pix_fmt = possible_fmts[i];
385  break;
386  }
387  }
388 
389  if (i == possible_fmts_nb) {
390  if (ncomponents == 4 &&
391  s->cdy[0] == 1 && s->cdx[0] == 1 &&
392  s->cdy[1] == 1 && s->cdx[1] == 1 &&
393  s->cdy[2] == s->cdy[3] && s->cdx[2] == s->cdx[3]) {
394  if (s->precision == 8 && s->cdy[2] == 2 && s->cdx[2] == 2 && !s->pal8) {
395  s->avctx->pix_fmt = AV_PIX_FMT_YUVA420P;
396  s->cdef[0] = 0;
397  s->cdef[1] = 1;
398  s->cdef[2] = 2;
399  s->cdef[3] = 3;
400  i = 0;
401  }
402  } else if (ncomponents == 3 && s->precision == 8 &&
403  s->cdx[0] == s->cdx[1] && s->cdx[0] == s->cdx[2] &&
404  s->cdy[0] == s->cdy[1] && s->cdy[0] == s->cdy[2]) {
405  s->avctx->pix_fmt = AV_PIX_FMT_RGB24;
406  i = 0;
407  } else if (ncomponents == 2 && s->precision == 8 &&
408  s->cdx[0] == s->cdx[1] && s->cdy[0] == s->cdy[1]) {
409  s->avctx->pix_fmt = AV_PIX_FMT_YA8;
410  i = 0;
411  } else if (ncomponents == 2 && s->precision == 16 &&
412  s->cdx[0] == s->cdx[1] && s->cdy[0] == s->cdy[1]) {
413  s->avctx->pix_fmt = AV_PIX_FMT_YA16;
414  i = 0;
415  } else if (ncomponents == 1 && s->precision == 8) {
416  s->avctx->pix_fmt = AV_PIX_FMT_GRAY8;
417  i = 0;
418  } else if (ncomponents == 1 && s->precision == 12) {
419  s->avctx->pix_fmt = AV_PIX_FMT_GRAY16LE;
420  i = 0;
421  }
422  }
423 
424 
425  if (i == possible_fmts_nb) {
426  av_log(s->avctx, AV_LOG_ERROR,
427  "Unknown pix_fmt, profile: %d, colour_space: %d, "
428  "components: %d, precision: %d\n"
429  "cdx[0]: %d, cdy[0]: %d\n"
430  "cdx[1]: %d, cdy[1]: %d\n"
431  "cdx[2]: %d, cdy[2]: %d\n"
432  "cdx[3]: %d, cdy[3]: %d\n",
433  s->avctx->profile, s->colour_space, ncomponents, s->precision,
434  s->cdx[0],
435  s->cdy[0],
436  ncomponents > 1 ? s->cdx[1] : 0,
437  ncomponents > 1 ? s->cdy[1] : 0,
438  ncomponents > 2 ? s->cdx[2] : 0,
439  ncomponents > 2 ? s->cdy[2] : 0,
440  ncomponents > 3 ? s->cdx[3] : 0,
441  ncomponents > 3 ? s->cdy[3] : 0);
442  return AVERROR_PATCHWELCOME;
443  }
444  s->avctx->bits_per_raw_sample = s->precision;
445  return 0;
446 }
447 /* get extended capabilities (CAP) marker segment */
448 static int get_cap(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c)
449 {
450  uint32_t Pcap;
451  uint16_t Ccap_i[32] = { 0 };
452  uint16_t Ccap_15;
453  uint8_t P;
454 
455  if (bytestream2_get_bytes_left(&s->g) < 6) {
456  av_log(s->avctx, AV_LOG_ERROR, "Underflow while parsing the CAP marker\n");
457  return AVERROR_INVALIDDATA;
458  }
459 
460  Pcap = bytestream2_get_be32u(&s->g);
461  s->isHT = (Pcap >> (31 - (15 - 1))) & 1;
462  for (int i = 0; i < 32; i++) {
463  if ((Pcap >> (31 - i)) & 1)
464  Ccap_i[i] = bytestream2_get_be16u(&s->g);
465  }
466  Ccap_15 = Ccap_i[14];
467  if (s->isHT == 1) {
468  av_log(s->avctx, AV_LOG_INFO, "This codestream uses the HT block coder.\n");
469  // Bits 14-15
470  switch ((Ccap_15 >> 14) & 0x3) {
471  case 0x3:
472  s->Ccap15_b14_15 = HTJ2K_MIXED;
473  break;
474  case 0x1:
475  s->Ccap15_b14_15 = HTJ2K_HTDECLARED;
476  break;
477  case 0x0:
478  s->Ccap15_b14_15 = HTJ2K_HTONLY;
479  break;
480  default:
481  av_log(s->avctx, AV_LOG_ERROR, "Unknown CCap value.\n");
482  return AVERROR(EINVAL);
483  break;
484  }
485  // Bit 13
486  if ((Ccap_15 >> 13) & 1) {
487  av_log(s->avctx, AV_LOG_ERROR, "MULTIHT set is not supported.\n");
488  return AVERROR_PATCHWELCOME;
489  }
490  // Bit 12
491  s->Ccap15_b12 = (Ccap_15 >> 12) & 1;
492  // Bit 11
493  s->Ccap15_b11 = (Ccap_15 >> 11) & 1;
494  // Bit 5
495  s->Ccap15_b05 = (Ccap_15 >> 5) & 1;
496  // Bit 0-4
497  P = Ccap_15 & 0x1F;
498  if (!P)
499  s->HT_B = 8;
500  else if (P < 20)
501  s->HT_B = P + 8;
502  else if (P < 31)
503  s->HT_B = 4 * (P - 19) + 27;
504  else
505  s->HT_B = 74;
506 
507  if (s->HT_B > 31) {
508  av_log(s->avctx, AV_LOG_ERROR, "Codestream exceeds available precision (B > 31).\n");
509  return AVERROR_PATCHWELCOME;
510  }
511  }
512  return 0;
513 }
514 
515 /* get common part for COD and COC segments */
516 static int get_cox(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c)
517 {
518  uint8_t byte;
519 
520  if (bytestream2_get_bytes_left(&s->g) < 5) {
521  av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for COX\n");
522  return AVERROR_INVALIDDATA;
523  }
524 
525  /* nreslevels = number of resolution levels
526  = number of decomposition level +1 */
527  c->nreslevels = bytestream2_get_byteu(&s->g) + 1;
528  if (c->nreslevels >= JPEG2000_MAX_RESLEVELS) {
529  av_log(s->avctx, AV_LOG_ERROR, "nreslevels %d is invalid\n", c->nreslevels);
530  return AVERROR_INVALIDDATA;
531  }
532 
533  if (c->nreslevels <= s->reduction_factor) {
534  /* we are forced to update reduction_factor as its requested value is
535  not compatible with this bitstream, and as we might have used it
536  already in setup earlier we have to fail this frame until
537  reinitialization is implemented */
538  av_log(s->avctx, AV_LOG_ERROR, "reduction_factor too large for this bitstream, max is %d\n", c->nreslevels - 1);
539  s->reduction_factor = c->nreslevels - 1;
540  return AVERROR(EINVAL);
541  }
542 
543  /* compute number of resolution levels to decode */
544  c->nreslevels2decode = c->nreslevels - s->reduction_factor;
545 
546  c->log2_cblk_width = (bytestream2_get_byteu(&s->g) & 15) + 2; // cblk width
547  c->log2_cblk_height = (bytestream2_get_byteu(&s->g) & 15) + 2; // cblk height
548 
549  if (c->log2_cblk_width > 10 || c->log2_cblk_height > 10 ||
550  c->log2_cblk_width + c->log2_cblk_height > 12) {
551  av_log(s->avctx, AV_LOG_ERROR, "cblk size invalid\n");
552  return AVERROR_INVALIDDATA;
553  }
554 
555  c->cblk_style = bytestream2_get_byteu(&s->g);
556  if (c->cblk_style != 0) { // cblk style
557  if (c->cblk_style & JPEG2000_CTSY_HTJ2K_M || c->cblk_style & JPEG2000_CTSY_HTJ2K_F) {
558  av_log(s->avctx,AV_LOG_TRACE,"High Throughput jpeg 2000 codestream.\n");
559  } else {
560  av_log(s->avctx, AV_LOG_WARNING, "extra cblk styles %X\n", c->cblk_style);
561  if (c->cblk_style & JPEG2000_CBLK_BYPASS)
562  av_log(s->avctx, AV_LOG_WARNING, "Selective arithmetic coding bypass\n");
563  }
564  }
565  c->transform = bytestream2_get_byteu(&s->g); // DWT transformation type
566  /* set integer 9/7 DWT in case of BITEXACT flag */
567  if ((s->avctx->flags & AV_CODEC_FLAG_BITEXACT) && (c->transform == FF_DWT97))
568  c->transform = FF_DWT97_INT;
569 #if FF_API_CODEC_PROPS
570  else if (c->transform == FF_DWT53) {
571 FF_DISABLE_DEPRECATION_WARNINGS
572  s->avctx->properties |= FF_CODEC_PROPERTY_LOSSLESS;
573 FF_ENABLE_DEPRECATION_WARNINGS
574  }
575 #endif
576 
577  if (c->csty & JPEG2000_CSTY_PREC) {
578  int i;
579  for (i = 0; i < c->nreslevels; i++) {
580  byte = bytestream2_get_byte(&s->g);
581  c->log2_prec_widths[i] = byte & 0x0F; // precinct PPx
582  c->log2_prec_heights[i] = (byte >> 4) & 0x0F; // precinct PPy
583  if (i)
584  if (c->log2_prec_widths[i] == 0 || c->log2_prec_heights[i] == 0) {
585  av_log(s->avctx, AV_LOG_ERROR, "PPx %d PPy %d invalid\n",
586  c->log2_prec_widths[i], c->log2_prec_heights[i]);
587  c->log2_prec_widths[i] = c->log2_prec_heights[i] = 1;
588  return AVERROR_INVALIDDATA;
589  }
590  }
591  } else {
592  memset(c->log2_prec_widths , 15, sizeof(c->log2_prec_widths ));
593  memset(c->log2_prec_heights, 15, sizeof(c->log2_prec_heights));
594  }
595  return 0;
596 }
597 
598 /* get coding parameters for a particular tile or whole image*/
599 static int get_cod(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c,
600  const uint8_t *properties)
601 {
602  Jpeg2000CodingStyle tmp;
603  int compno, ret;
604 
605  if (bytestream2_get_bytes_left(&s->g) < 5) {
606  av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for COD\n");
607  return AVERROR_INVALIDDATA;
608  }
609 
610  tmp.csty = bytestream2_get_byteu(&s->g);
611 
612  // get progression order
613  tmp.prog_order = bytestream2_get_byteu(&s->g);
614 
615  tmp.nlayers = bytestream2_get_be16u(&s->g);
616  tmp.mct = bytestream2_get_byteu(&s->g); // multiple component transformation
617 
618  if (tmp.mct && s->ncomponents < 3) {
619  av_log(s->avctx, AV_LOG_ERROR,
620  "MCT %"PRIu8" with too few components (%d)\n",
621  tmp.mct, s->ncomponents);
622  return AVERROR_INVALIDDATA;
623  }
624 
625  if ((ret = get_cox(s, &tmp)) < 0)
626  return ret;
627  tmp.init = 1;
628  for (compno = 0; compno < s->ncomponents; compno++)
629  if (!(properties[compno] & HAD_COC))
630  memcpy(c + compno, &tmp, sizeof(tmp));
631  return 0;
632 }
633 
634 /* Get coding parameters for a component in the whole image or a
635  * particular tile. */
636 static int get_coc(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c,
637  uint8_t *properties)
638 {
639  int compno, ret;
640  uint8_t has_eph, has_sop;
641 
642  if (bytestream2_get_bytes_left(&s->g) < 2) {
643  av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for COC\n");
644  return AVERROR_INVALIDDATA;
645  }
646 
647  compno = bytestream2_get_byteu(&s->g);
648 
649  if (compno >= s->ncomponents) {
650  av_log(s->avctx, AV_LOG_ERROR,
651  "Invalid compno %d. There are %d components in the image.\n",
652  compno, s->ncomponents);
653  return AVERROR_INVALIDDATA;
654  }
655 
656  c += compno;
657  has_eph = c->csty & JPEG2000_CSTY_EPH;
658  has_sop = c->csty & JPEG2000_CSTY_SOP;
659  c->csty = bytestream2_get_byteu(&s->g);
660  c->csty |= has_eph; //do not override eph present bits from COD
661  c->csty |= has_sop; //do not override sop present bits from COD
662 
663  if ((ret = get_cox(s, c)) < 0)
664  return ret;
665 
666  properties[compno] |= HAD_COC;
667  c->init = 1;
668  return 0;
669 }
670 
671 static int get_rgn(Jpeg2000DecoderContext *s, int n)
672 {
673  uint16_t compno;
674  compno = (s->ncomponents < 257)? bytestream2_get_byte(&s->g):
675  bytestream2_get_be16u(&s->g);
676  if (bytestream2_get_byte(&s->g)) {
677  av_log(s->avctx, AV_LOG_ERROR, "Invalid RGN header.\n");
678  return AVERROR_INVALIDDATA; // SRgn field value is 0
679  }
680  // SPrgn field
681  // Currently compno cannot be greater than 4.
682  // However, future implementation should support compno up to 65536
683  if (compno < s->ncomponents) {
684  int v;
685  if (s->curtileno == -1) {
686  v = bytestream2_get_byte(&s->g);
687  if (v > 30)
688  return AVERROR_PATCHWELCOME;
689  s->roi_shift[compno] = v;
690  } else {
691  if (s->tile[s->curtileno].tp_idx != 0)
692  return AVERROR_INVALIDDATA; // marker occurs only in first tile part of tile
693  v = bytestream2_get_byte(&s->g);
694  if (v > 30)
695  return AVERROR_PATCHWELCOME;
696  s->tile[s->curtileno].comp[compno].roi_shift = v;
697  }
698  return 0;
699  }
700  return AVERROR_INVALIDDATA;
701 }
702 
703 /* Get common part for QCD and QCC segments. */
704 static int get_qcx(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q)
705 {
706  int i, x;
707 
708  if (bytestream2_get_bytes_left(&s->g) < 1)
709  return AVERROR_INVALIDDATA;
710 
711  x = bytestream2_get_byteu(&s->g); // Sqcd
712 
713  q->nguardbits = x >> 5;
714  q->quantsty = x & 0x1f;
715 
716  if (q->quantsty == JPEG2000_QSTY_NONE) {
717  n -= 3;
718  if (bytestream2_get_bytes_left(&s->g) < n ||
719  n > JPEG2000_MAX_DECLEVELS*3)
720  return AVERROR_INVALIDDATA;
721  for (i = 0; i < n; i++)
722  q->expn[i] = bytestream2_get_byteu(&s->g) >> 3;
723  } else if (q->quantsty == JPEG2000_QSTY_SI) {
724  if (bytestream2_get_bytes_left(&s->g) < 2)
725  return AVERROR_INVALIDDATA;
726  x = bytestream2_get_be16u(&s->g);
727  q->expn[0] = x >> 11;
728  q->mant[0] = x & 0x7ff;
729  for (i = 1; i < JPEG2000_MAX_DECLEVELS * 3; i++) {
730  int curexpn = FFMAX(0, q->expn[0] - (i - 1) / 3);
731  q->expn[i] = curexpn;
732  q->mant[i] = q->mant[0];
733  }
734  } else {
735  n = (n - 3) >> 1;
736  if (bytestream2_get_bytes_left(&s->g) < 2 * n ||
737  n > JPEG2000_MAX_DECLEVELS*3)
738  return AVERROR_INVALIDDATA;
739  for (i = 0; i < n; i++) {
740  x = bytestream2_get_be16u(&s->g);
741  q->expn[i] = x >> 11;
742  q->mant[i] = x & 0x7ff;
743  }
744  }
745  return 0;
746 }
747 
748 /* Get quantization parameters for a particular tile or a whole image. */
749 static int get_qcd(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q,
750  const uint8_t *properties)
751 {
752  Jpeg2000QuantStyle tmp;
753  int compno, ret;
754 
755  memset(&tmp, 0, sizeof(tmp));
756 
757  if ((ret = get_qcx(s, n, &tmp)) < 0)
758  return ret;
759  for (compno = 0; compno < s->ncomponents; compno++)
760  if (!(properties[compno] & HAD_QCC))
761  memcpy(q + compno, &tmp, sizeof(tmp));
762  return 0;
763 }
764 
765 /* Get quantization parameters for a component in the whole image
766  * on in a particular tile. */
767 static int get_qcc(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q,
768  uint8_t *properties)
769 {
770  int compno;
771 
772  if (bytestream2_get_bytes_left(&s->g) < 1)
773  return AVERROR_INVALIDDATA;
774 
775  compno = bytestream2_get_byteu(&s->g);
776 
777  if (compno >= s->ncomponents) {
778  av_log(s->avctx, AV_LOG_ERROR,
779  "Invalid compno %d. There are %d components in the image.\n",
780  compno, s->ncomponents);
781  return AVERROR_INVALIDDATA;
782  }
783 
784  properties[compno] |= HAD_QCC;
785  return get_qcx(s, n - 1, q + compno);
786 }
787 
788 static int get_poc(Jpeg2000DecoderContext *s, int size, Jpeg2000POC *p)
789 {
790  int i;
791  int elem_size = s->ncomponents <= 257 ? 7 : 9;
792  Jpeg2000POC tmp = {{{0}}};
793 
794  if (bytestream2_get_bytes_left(&s->g) < 5 || size < 2 + elem_size) {
795  av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for POC\n");
796  return AVERROR_INVALIDDATA;
797  }
798 
799  if (elem_size > 7) {
800  avpriv_request_sample(s->avctx, "Fat POC not supported");
801  return AVERROR_PATCHWELCOME;
802  }
803 
804  tmp.nb_poc = (size - 2) / elem_size;
805  if (tmp.nb_poc > MAX_POCS) {
806  avpriv_request_sample(s->avctx, "Too many POCs (%d)", tmp.nb_poc);
807  return AVERROR_PATCHWELCOME;
808  }
809 
810  for (i = 0; i<tmp.nb_poc; i++) {
811  Jpeg2000POCEntry *e = &tmp.poc[i];
812  e->RSpoc = bytestream2_get_byteu(&s->g);
813  e->CSpoc = bytestream2_get_byteu(&s->g);
814  e->LYEpoc = bytestream2_get_be16u(&s->g);
815  e->REpoc = bytestream2_get_byteu(&s->g);
816  e->CEpoc = bytestream2_get_byteu(&s->g);
817  e->Ppoc = bytestream2_get_byteu(&s->g);
818  if (!e->CEpoc)
819  e->CEpoc = 256;
820  if (e->CEpoc > s->ncomponents)
821  e->CEpoc = s->ncomponents;
822  if ( e->RSpoc >= e->REpoc || e->REpoc > 33
823  || e->CSpoc >= e->CEpoc || e->CEpoc > s->ncomponents
824  || !e->LYEpoc) {
825  av_log(s->avctx, AV_LOG_ERROR, "POC Entry %d is invalid (%d, %d, %d, %d, %d, %d)\n", i,
826  e->RSpoc, e->CSpoc, e->LYEpoc, e->REpoc, e->CEpoc, e->Ppoc
827  );
828  return AVERROR_INVALIDDATA;
829  }
830  }
831 
832  if (!p->nb_poc || p->is_default) {
833  *p = tmp;
834  } else {
835  if (p->nb_poc + tmp.nb_poc > MAX_POCS) {
836  av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for POC\n");
837  return AVERROR_INVALIDDATA;
838  }
839  memcpy(p->poc + p->nb_poc, tmp.poc, tmp.nb_poc * sizeof(tmp.poc[0]));
840  p->nb_poc += tmp.nb_poc;
841  }
842 
843  p->is_default = 0;
844 
845  return 0;
846 }
847 
848 
849 /* Get start of tile segment. */
850 static int get_sot(Jpeg2000DecoderContext *s, int n)
851 {
852  Jpeg2000TilePart *tp;
853  uint16_t Isot;
854  uint32_t Psot;
855  unsigned TPsot;
856 
857  if (bytestream2_get_bytes_left(&s->g) < 8)
858  return AVERROR_INVALIDDATA;
859 
860  s->curtileno = 0;
861  Isot = bytestream2_get_be16u(&s->g); // Isot
862  if (Isot >= s->numXtiles * s->numYtiles)
863  return AVERROR_INVALIDDATA;
864 
865  s->curtileno = Isot;
866  Psot = bytestream2_get_be32u(&s->g); // Psot
867  TPsot = bytestream2_get_byteu(&s->g); // TPsot
868 
869  /* Read TNSot but not used */
870  bytestream2_get_byteu(&s->g); // TNsot
871 
872  if (!Psot)
873  Psot = bytestream2_get_bytes_left(&s->g) - 2 + n + 2;
874 
875  if (Psot > bytestream2_get_bytes_left(&s->g) - 2 + n + 2) {
876  av_log(s->avctx, AV_LOG_ERROR, "Psot %"PRIu32" too big\n", Psot);
877  return AVERROR_INVALIDDATA;
878  }
879 
880  if (TPsot >= FF_ARRAY_ELEMS(s->tile[Isot].tile_part)) {
881  avpriv_request_sample(s->avctx, "Too many tile parts");
882  return AVERROR_PATCHWELCOME;
883  }
884 
885  s->tile[Isot].tp_idx = TPsot;
886  tp = s->tile[Isot].tile_part + TPsot;
887  tp->tile_index = Isot;
888  tp->tp_end = s->g.buffer + Psot - n - 2;
889 
890  if (!TPsot) {
891  Jpeg2000Tile *tile = s->tile + s->curtileno;
892 
893  /* copy defaults */
894  memcpy(tile->codsty, s->codsty, s->ncomponents * sizeof(Jpeg2000CodingStyle));
895  memcpy(tile->qntsty, s->qntsty, s->ncomponents * sizeof(Jpeg2000QuantStyle));
896  memcpy(&tile->poc , &s->poc , sizeof(tile->poc));
897  tile->poc.is_default = 1;
898  }
899 
900  return 0;
901 }
902 
903 static int read_crg(Jpeg2000DecoderContext *s, int n)
904 {
905  if (s->ncomponents*4 != n - 2) {
906  av_log(s->avctx, AV_LOG_ERROR, "Invalid CRG marker.\n");
907  return AVERROR_INVALIDDATA;
908  }
909  bytestream2_skip(&s->g, n - 2);
910  return 0;
911 }
912 
913 static int read_cpf(Jpeg2000DecoderContext *s, int n)
914 {
915  if (bytestream2_get_bytes_left(&s->g) < (n - 2))
916  return AVERROR_INVALIDDATA;
917  bytestream2_skip(&s->g, n - 2);
918  return 0;
919 }
920 
921 /* Tile-part lengths: see ISO 15444-1:2002, section A.7.1
922  * Used to know the number of tile parts and lengths.
923  * There may be multiple TLMs in the header.
924  * TODO: The function is not used for tile-parts management, nor anywhere else.
925  * It can be useful to allocate memory for tile parts, before managing the SOT
926  * markers. Parsing the TLM header is needed to increment the input header
927  * buffer.
928  * This marker is mandatory for DCI. */
929 static int get_tlm(Jpeg2000DecoderContext *s, int n)
930 {
931  uint8_t Stlm, ST, SP, tile_tlm, i;
932  bytestream2_get_byte(&s->g); /* Ztlm: skipped */
933  Stlm = bytestream2_get_byte(&s->g);
934 
935  // too complex ? ST = ((Stlm >> 4) & 0x01) + ((Stlm >> 4) & 0x02);
936  ST = (Stlm >> 4) & 0x03;
937  if (ST == 0x03) {
938  av_log(s->avctx, AV_LOG_ERROR, "TLM marker contains invalid ST value.\n");
939  return AVERROR_INVALIDDATA;
940  }
941 
942  SP = (Stlm >> 6) & 0x01;
943  tile_tlm = (n - 4) / ((SP + 1) * 2 + ST);
944  for (i = 0; i < tile_tlm; i++) {
945  switch (ST) {
946  case 0:
947  break;
948  case 1:
949  bytestream2_get_byte(&s->g);
950  break;
951  case 2:
952  bytestream2_get_be16(&s->g);
953  break;
954  }
955  if (SP == 0) {
956  bytestream2_get_be16(&s->g);
957  } else {
958  bytestream2_get_be32(&s->g);
959  }
960  }
961  return 0;
962 }
963 
964 static int get_plt(Jpeg2000DecoderContext *s, int n)
965 {
966  int i;
967  int v;
968 
969  av_log(s->avctx, AV_LOG_DEBUG,
970  "PLT marker at pos 0x%X\n", bytestream2_tell(&s->g) - 4);
971 
972  if (n < 4)
973  return AVERROR_INVALIDDATA;
974 
975  /*Zplt =*/ bytestream2_get_byte(&s->g);
976 
977  for (i = 0; i < n - 3; i++) {
978  v = bytestream2_get_byte(&s->g);
979  }
980  if (v & 0x80)
981  return AVERROR_INVALIDDATA;
982 
983  return 0;
984 }
985 
986 static int get_ppm(Jpeg2000DecoderContext *s, int n)
987 {
988  void *new;
989 
990  if (n < 3) {
991  av_log(s->avctx, AV_LOG_ERROR, "Invalid length for PPM data.\n");
992  return AVERROR_INVALIDDATA;
993  }
994  bytestream2_get_byte(&s->g); //Zppm is skipped and not used
995  new = av_realloc(s->packed_headers,
996  s->packed_headers_size + n - 3);
997  if (new) {
998  s->packed_headers = new;
999  } else
1000  return AVERROR(ENOMEM);
1001  s->has_ppm = 1;
1002  memset(&s->packed_headers_stream, 0, sizeof(s->packed_headers_stream));
1003  bytestream2_get_bufferu(&s->g, s->packed_headers + s->packed_headers_size,
1004  n - 3);
1005  s->packed_headers_size += n - 3;
1006 
1007  return 0;
1008 }
1009 
1010 static int get_ppt(Jpeg2000DecoderContext *s, int n)
1011 {
1012  Jpeg2000Tile *tile;
1013  void *new;
1014 
1015  if (n < 3) {
1016  av_log(s->avctx, AV_LOG_ERROR, "Invalid length for PPT data.\n");
1017  return AVERROR_INVALIDDATA;
1018  }
1019  if (s->curtileno < 0)
1020  return AVERROR_INVALIDDATA;
1021 
1022  tile = &s->tile[s->curtileno];
1023  if (tile->tp_idx != 0) {
1024  av_log(s->avctx, AV_LOG_ERROR,
1025  "PPT marker can occur only on first tile part of a tile.\n");
1026  return AVERROR_INVALIDDATA;
1027  }
1028 
1029  tile->has_ppt = 1; // this tile has a ppt marker
1030  bytestream2_get_byte(&s->g); // Zppt is skipped and not used
1031  new = av_realloc(tile->packed_headers,
1032  tile->packed_headers_size + n - 3);
1033  if (new) {
1034  tile->packed_headers = new;
1035  } else
1036  return AVERROR(ENOMEM);
1037  memset(&tile->packed_headers_stream, 0, sizeof(tile->packed_headers_stream));
1038  bytestream2_get_bufferu(&s->g, tile->packed_headers + tile->packed_headers_size, n - 3);
1039  tile->packed_headers_size += n - 3;
1040 
1041  return 0;
1042 }
1043 
1044 static int init_tile(Jpeg2000DecoderContext *s, int tileno)
1045 {
1046  int compno;
1047  int tilex = tileno % s->numXtiles;
1048  int tiley = tileno / s->numXtiles;
1049  Jpeg2000Tile *tile = s->tile + tileno;
1050 
1051  if (!tile->comp)
1052  return AVERROR(ENOMEM);
1053 
1054  tile->coord[0][0] = av_clip(tilex * (int64_t)s->tile_width + s->tile_offset_x, s->image_offset_x, s->width);
1055  tile->coord[0][1] = av_clip((tilex + 1) * (int64_t)s->tile_width + s->tile_offset_x, s->image_offset_x, s->width);
1056  tile->coord[1][0] = av_clip(tiley * (int64_t)s->tile_height + s->tile_offset_y, s->image_offset_y, s->height);
1057  tile->coord[1][1] = av_clip((tiley + 1) * (int64_t)s->tile_height + s->tile_offset_y, s->image_offset_y, s->height);
1058 
1059  for (compno = 0; compno < s->ncomponents; compno++) {
1060  Jpeg2000Component *comp = tile->comp + compno;
1061  Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1062  Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
1063  int ret; // global bandno
1064 
1065  comp->coord_o[0][0] = tile->coord[0][0];
1066  comp->coord_o[0][1] = tile->coord[0][1];
1067  comp->coord_o[1][0] = tile->coord[1][0];
1068  comp->coord_o[1][1] = tile->coord[1][1];
1069 
1070  comp->coord_o[0][0] = ff_jpeg2000_ceildiv(comp->coord_o[0][0], s->cdx[compno]);
1071  comp->coord_o[0][1] = ff_jpeg2000_ceildiv(comp->coord_o[0][1], s->cdx[compno]);
1072  comp->coord_o[1][0] = ff_jpeg2000_ceildiv(comp->coord_o[1][0], s->cdy[compno]);
1073  comp->coord_o[1][1] = ff_jpeg2000_ceildiv(comp->coord_o[1][1], s->cdy[compno]);
1074 
1075  comp->coord[0][0] = ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], s->reduction_factor);
1076  comp->coord[0][1] = ff_jpeg2000_ceildivpow2(comp->coord_o[0][1], s->reduction_factor);
1077  comp->coord[1][0] = ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], s->reduction_factor);
1078  comp->coord[1][1] = ff_jpeg2000_ceildivpow2(comp->coord_o[1][1], s->reduction_factor);
1079 
1080  if (!comp->roi_shift)
1081  comp->roi_shift = s->roi_shift[compno];
1082  if (!codsty->init)
1083  return AVERROR_INVALIDDATA;
1084  if (s->isHT && (!s->Ccap15_b05) && (!codsty->transform)) {
1085  av_log(s->avctx, AV_LOG_ERROR, "Transformation = 0 (lossy DWT) is found in HTREV HT set\n");
1086  return AVERROR_INVALIDDATA;
1087  }
1088  if (s->isHT && s->Ccap15_b14_15 != (codsty->cblk_style >> 6) && s->Ccap15_b14_15 != HTJ2K_HTONLY) {
1089  av_log(s->avctx, AV_LOG_ERROR, "SPcod/SPcoc value does not match bit 14-15 values of Ccap15\n");
1090  return AVERROR_INVALIDDATA;
1091  }
1092  if (ret = ff_jpeg2000_init_component(comp, codsty, qntsty,
1093  s->cbps[compno], s->cdx[compno],
1094  s->cdy[compno], s->avctx))
1095  return ret;
1096  }
1097  return 0;
1098 }
1099 
1100 /* Read the number of coding passes. */
1101 static int getnpasses(Jpeg2000DecoderContext *s)
1102 {
1103  int num;
1104  if (!get_bits(s, 1))
1105  return 1;
1106  if (!get_bits(s, 1))
1107  return 2;
1108  if ((num = get_bits(s, 2)) != 3)
1109  return num < 0 ? num : 3 + num;
1110  if ((num = get_bits(s, 5)) != 31)
1111  return num < 0 ? num : 6 + num;
1112  num = get_bits(s, 7);
1113  return num < 0 ? num : 37 + num;
1114 }
1115 
1116 static int getlblockinc(Jpeg2000DecoderContext *s)
1117 {
1118  int res = 0, ret;
1119  while (ret = get_bits(s, 1)) {
1120  if (ret < 0)
1121  return ret;
1122  res++;
1123  }
1124  return res;
1125 }
1126 
1127 static inline void select_header(Jpeg2000DecoderContext *s, const Jpeg2000Tile *tile,
1128  int *tp_index)
1129 {
1130  s->g = tile->tile_part[*tp_index].header_tpg;
1131  if (bytestream2_get_bytes_left(&s->g) == 0 && s->bit_index == 8) {
1132  av_log(s->avctx, AV_LOG_WARNING, "Packet header bytes in PPM marker segment is too short.\n");
1133  if (*tp_index < FF_ARRAY_ELEMS(tile->tile_part) - 1) {
1134  s->g = tile->tile_part[++(*tp_index)].tpg;
1135  }
1136  }
1137 }
1138 
1139 static inline void select_stream(Jpeg2000DecoderContext *s, const Jpeg2000Tile *tile,
1140  int *tp_index, const Jpeg2000CodingStyle *codsty)
1141 {
1142  int32_t is_endof_tp;
1143 
1144  s->g = tile->tile_part[*tp_index].tpg;
1145  is_endof_tp = bytestream2_get_bytes_left(&s->g) == 0 && s->bit_index == 8;
1146  // Following while loop is necessary because a tilepart may include only SOD marker.
1147  // Such a tilepart has neither packet header nor compressed data.
1148  while (is_endof_tp) {
1149  if (*tp_index < FF_ARRAY_ELEMS(tile->tile_part) - 1) {
1150  s->g = tile->tile_part[++(*tp_index)].tpg;
1151  is_endof_tp = bytestream2_get_bytes_left(&s->g) == 0 && s->bit_index == 8;
1152  } else {
1153  is_endof_tp = 0;
1154  }
1155  }
1156  if (codsty->csty & JPEG2000_CSTY_SOP) {
1157  if (bytestream2_peek_be32(&s->g) == JPEG2000_SOP_FIXED_BYTES)
1158  bytestream2_skip(&s->g, JPEG2000_SOP_BYTE_LENGTH);
1159  else
1160  av_log(s->avctx, AV_LOG_ERROR, "SOP marker not found. instead %X\n", bytestream2_peek_be32(&s->g));
1161  }
1162 }
1163 
1164 static int jpeg2000_decode_packet(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile, int *tp_index,
1165  const Jpeg2000CodingStyle *codsty,
1166  Jpeg2000ResLevel *rlevel, int precno,
1167  int layno, const uint8_t *expn, int numgbits)
1168 {
1169  int bandno, cblkno, ret, nb_code_blocks;
1170  int cwsno;
1171 
1172  if (layno < rlevel->band[0].prec[precno].decoded_layers)
1173  return 0;
1174  rlevel->band[0].prec[precno].decoded_layers = layno + 1;
1175  // Select stream to read from
1176  if (s->has_ppm)
1177  select_header(s, tile, tp_index);
1178  else if (tile->has_ppt)
1179  s->g = tile->packed_headers_stream;
1180  else
1181  select_stream(s, tile, tp_index, codsty);
1182 
1183  if (!(ret = get_bits(s, 1))) {
1184  jpeg2000_flush(s);
1185  goto skip_data;
1186  } else if (ret < 0)
1187  return ret;
1188 
1189  for (bandno = 0; bandno < rlevel->nbands; bandno++) {
1190  Jpeg2000Band *band = rlevel->band + bandno;
1191  Jpeg2000Prec *prec = band->prec + precno;
1192 
1193  if (band->coord[0][0] == band->coord[0][1] ||
1194  band->coord[1][0] == band->coord[1][1])
1195  continue;
1196  nb_code_blocks = prec->nb_codeblocks_height *
1197  prec->nb_codeblocks_width;
1198  for (cblkno = 0; cblkno < nb_code_blocks; cblkno++) {
1199  Jpeg2000Cblk *cblk = prec->cblk + cblkno;
1200  int incl, newpasses, llen;
1201  void *tmp;
1202 
1203  if (!cblk->incl) {
1204  incl = 0;
1205  cblk->modes = codsty->cblk_style;
1206  if (cblk->modes >= JPEG2000_CTSY_HTJ2K_F)
1207  cblk->ht_plhd = HT_PLHD_ON;
1208  if (layno > 0)
1209  incl = tag_tree_decode(s, prec->cblkincl + cblkno, 0 + 1) == 0;
1210  incl = tag_tree_decode(s, prec->cblkincl + cblkno, layno + 1) == layno;
1211 
1212  if (incl) {
1213  int zbp = tag_tree_decode(s, prec->zerobits + cblkno, 100);
1214  int v = expn[bandno] + numgbits - 1 - (zbp - tile->comp->roi_shift);
1215  if (v < 0 || v > 30) {
1216  av_log(s->avctx, AV_LOG_ERROR,
1217  "nonzerobits %d invalid or unsupported\n", v);
1218  return AVERROR_INVALIDDATA;
1219  }
1220  cblk->incl = 1;
1221  cblk->nonzerobits = v;
1222  cblk->zbp = zbp;
1223  cblk->lblock = 3;
1224  }
1225  } else {
1226  incl = get_bits(s, 1);
1227  }
1228 
1229  if (incl) {
1230  uint8_t bypass_term_threshold = 0;
1231  uint8_t bits_to_read = 0;
1232  uint32_t segment_bytes = 0;
1233  int32_t segment_passes = 0;
1234  uint8_t next_segment_passes = 0;
1235  int32_t href_passes, pass_bound;
1236  uint32_t tmp_length = 0;
1237  int32_t newpasses_copy, npasses_copy;
1238 
1239  if ((newpasses = getnpasses(s)) <= 0)
1240  return newpasses;
1241  if (cblk->npasses + newpasses >= JPEG2000_MAX_PASSES) {
1242  avpriv_request_sample(s->avctx, "Too many passes");
1243  return AVERROR_PATCHWELCOME;
1244  }
1245  if ((llen = getlblockinc(s)) < 0)
1246  return llen;
1247  if (cblk->lblock + llen + av_log2(newpasses) > 16) {
1248  avpriv_request_sample(s->avctx,
1249  "Block with length beyond 16 bits");
1250  return AVERROR_PATCHWELCOME;
1251  }
1252  cblk->nb_lengthinc = 0;
1253  cblk->nb_terminationsinc = 0;
1254  av_free(cblk->lengthinc);
1255  cblk->lengthinc = av_calloc(newpasses, sizeof(*cblk->lengthinc));
1256  if (!cblk->lengthinc)
1257  return AVERROR(ENOMEM);
1258  tmp = av_realloc_array(cblk->data_start, cblk->nb_terminations + newpasses + 1,
1259  sizeof(*cblk->data_start));
1260  if (!tmp)
1261  return AVERROR(ENOMEM);
1262  cblk->data_start = tmp;
1263  cblk->lblock += llen;
1264 
1265  // Count number of necessary terminations for non HT code block
1266  newpasses_copy = newpasses;
1267  npasses_copy = cblk->npasses;
1268  if (!(cblk->modes & JPEG2000_CTSY_HTJ2K_F)) {
1269  do {
1270  int newpasses1 = 0;
1271 
1272  while (newpasses1 < newpasses_copy) {
1273  newpasses1++;
1274  if (needs_termination(codsty->cblk_style, npasses_copy + newpasses1 - 1)) {
1275  cblk->nb_terminationsinc++;
1276  break;
1277  }
1278  }
1279  npasses_copy += newpasses1;
1280  newpasses_copy -= newpasses1;
1281  } while (newpasses_copy);
1282  }
1283 
1284  if (cblk->ht_plhd) {
1285  href_passes = (cblk->npasses + newpasses - 1) % 3;
1286  segment_passes = newpasses - href_passes;
1287  pass_bound = 2;
1288  bits_to_read = cblk->lblock;
1289  if (segment_passes < 1) {
1290  // No possible HT Cleanup pass here; may have placeholder passes
1291  // or an original J2K block bit-stream (in MIXED mode).
1292  segment_passes = newpasses;
1293  while (pass_bound <= segment_passes) {
1294  bits_to_read++;
1295  pass_bound += pass_bound;
1296  }
1297  segment_bytes = get_bits(s, bits_to_read);
1298  if (segment_bytes) {
1299  if (cblk->modes & HT_MIXED) {
1300  cblk->ht_plhd = HT_PLHD_OFF;
1301  cblk->modes &= (uint8_t) (~(JPEG2000_CTSY_HTJ2K_F));
1302  }
1303  else {
1304  av_log(s->avctx, AV_LOG_WARNING, "Length information for a HT-codeblock is invalid\n");
1305  }
1306  }
1307  } else {
1308  while (pass_bound <= segment_passes) {
1309  bits_to_read++;
1310  pass_bound += pass_bound;
1311  }
1312  segment_bytes = get_bits(s, bits_to_read);
1313  if (segment_bytes) {
1314  // No more placeholder passes
1315  if (!(cblk->modes & HT_MIXED)) {
1316  // Must be the first HT Cleanup pass
1317  if (segment_bytes < 2)
1318  av_log(s->avctx, AV_LOG_WARNING, "Length information for a HT-codeblock is invalid\n");
1319  next_segment_passes = 2;
1320  cblk->ht_plhd = HT_PLHD_OFF;
1321  // Write length information for HT CleanUp segment
1322  cblk->pass_lengths[0] = segment_bytes;
1323  } else if (cblk->lblock > 3 && segment_bytes > 1
1324  && (segment_bytes >> (bits_to_read - 1)) == 0) {
1325  // Must be the first HT Cleanup pass, since length MSB is 0
1326  next_segment_passes = 2;
1327  cblk->ht_plhd = HT_PLHD_OFF;
1328  // Write length information for HT CleanUp segment
1329  cblk->pass_lengths[0] = segment_bytes;
1330  } else {
1331  // Must have an original (non-HT) block coding pass
1332  cblk->modes &= (uint8_t) (~(JPEG2000_CTSY_HTJ2K_F));
1333  cblk->ht_plhd = HT_PLHD_OFF;
1334  segment_passes = newpasses;
1335  while (pass_bound <= segment_passes) {
1336  bits_to_read++;
1337  pass_bound += pass_bound;
1338  segment_bytes <<= 1;
1339  segment_bytes += get_bits(s, 1);
1340  }
1341  }
1342  } else {
1343  // Probably parsing placeholder passes, but we need to read an
1344  // extra length bit to verify this, since prior to the first
1345  // HT Cleanup pass, the number of length bits read for a
1346  // contributing code-block is dependent on the number of passes
1347  // being included, as if it were a non-HT code-block.
1348  segment_passes = newpasses;
1349  if (pass_bound <= segment_passes) {
1350  while (1) {
1351  bits_to_read++;
1352  pass_bound += pass_bound;
1353  segment_bytes <<= 1;
1354  segment_bytes += get_bits(s, 1);
1355  if (pass_bound > segment_passes)
1356  break;
1357  }
1358  if (segment_bytes) {
1359  if (cblk->modes & HT_MIXED) {
1360  cblk->modes &= (uint8_t) (~(JPEG2000_CTSY_HTJ2K_F));
1361  cblk->ht_plhd = HT_PLHD_OFF;
1362  } else {
1363  av_log(s->avctx, AV_LOG_WARNING, "Length information for a HT-codeblock is invalid\n");
1364  }
1365  }
1366  }
1367  }
1368  }
1369  } else if (cblk->modes & JPEG2000_CTSY_HTJ2K_F) {
1370  // Quality layer commences with a non-initial HT coding pass
1371  if(bits_to_read != 0)
1372  av_log(s->avctx, AV_LOG_WARNING, "Length information for a HT-codeblock is invalid\n");
1373  segment_passes = cblk->npasses % 3;
1374  if (segment_passes == 0) {
1375  // newpasses is a HT Cleanup pass; next segment has refinement passes
1376  segment_passes = 1;
1377  next_segment_passes = 2;
1378  if (segment_bytes == 1)
1379  av_log(s->avctx, AV_LOG_WARNING, "Length information for a HT-codeblock is invalid\n");
1380  } else {
1381  // newpasses = 1 means npasses is HT SigProp; 2 means newpasses is
1382  // HT MagRef pass
1383  segment_passes = newpasses > 1 ? 3 - segment_passes : 1;
1384  next_segment_passes = 1;
1385  bits_to_read = av_log2(segment_passes);
1386  }
1387  bits_to_read = (uint8_t) (bits_to_read + cblk->lblock);
1388  segment_bytes = get_bits(s, bits_to_read);
1389  // Write length information for HT Refinement segment
1390  cblk->pass_lengths[1] += segment_bytes;
1391  } else if (!(cblk->modes & (JPEG2000_CBLK_TERMALL | JPEG2000_CBLK_BYPASS))) {
1392  // Common case for non-HT code-blocks; we have only one segment
1393  bits_to_read = (uint8_t) cblk->lblock + av_log2((uint8_t) newpasses);
1394  segment_bytes = get_bits(s, bits_to_read);
1395  segment_passes = newpasses;
1396  } else if (cblk->modes & JPEG2000_CBLK_TERMALL) {
1397  // RESTART MODE
1398  bits_to_read = cblk->lblock;
1399  segment_bytes = get_bits(s, bits_to_read);
1400  segment_passes = 1;
1401  next_segment_passes = 1;
1402  } else {
1403  // BYPASS MODE
1404  bypass_term_threshold = 10;
1405  if(bits_to_read != 0)
1406  av_log(s->avctx, AV_LOG_WARNING, "Length information for a codeblock is invalid\n");
1407  if (cblk->npasses < bypass_term_threshold) {
1408  // May have from 1 to 10 uninterrupted passes before 1st RAW SigProp
1409  segment_passes = bypass_term_threshold - cblk->npasses;
1410  if (segment_passes > newpasses)
1411  segment_passes = newpasses;
1412  while ((2 << bits_to_read) <= segment_passes)
1413  bits_to_read++;
1414  next_segment_passes = 2;
1415  } else if ((cblk->npasses - bypass_term_threshold) % 3 < 2) {
1416  // 0 means newpasses is a RAW SigProp; 1 means newpasses is a RAW MagRef pass
1417  segment_passes = newpasses > 1 ? 2 - (cblk->npasses - bypass_term_threshold) % 3 : 1;
1418  bits_to_read = av_log2(segment_passes);
1419  next_segment_passes = 1;
1420  } else {
1421  // newpasses is an isolated Cleanup pass that precedes a RAW SigProp pass
1422  segment_passes = 1;
1423  next_segment_passes = 2;
1424  }
1425  bits_to_read = (uint8_t) (bits_to_read + cblk->lblock);
1426  segment_bytes = get_bits(s, bits_to_read);
1427  }
1428  // Update cblk->npasses and write length information
1429  cblk->npasses = (uint8_t) (cblk->npasses + segment_passes);
1430  cblk->lengthinc[cblk->nb_lengthinc++] = segment_bytes;
1431 
1432  if ((cblk->modes & JPEG2000_CTSY_HTJ2K_F) && cblk->ht_plhd == HT_PLHD_OFF) {
1433  newpasses -= (uint8_t) segment_passes;
1434  while (newpasses > 0) {
1435  segment_passes = newpasses > 1 ? next_segment_passes : 1;
1436  next_segment_passes = (uint8_t) (3 - next_segment_passes);
1437  bits_to_read = (uint8_t) (cblk->lblock + av_log2(segment_passes));
1438  segment_bytes = get_bits(s, bits_to_read);
1439  newpasses -= (uint8_t) (segment_passes);
1440  // This is a FAST Refinement pass
1441  // Write length information for HT Refinement segment
1442  cblk->pass_lengths[1] += segment_bytes;
1443  // Update cblk->npasses and write length information
1444  cblk->npasses = (uint8_t) (cblk->npasses + segment_passes);
1445  cblk->lengthinc[cblk->nb_lengthinc++] = segment_bytes;
1446  }
1447  } else {
1448  newpasses -= (uint8_t) (segment_passes);
1449  while (newpasses > 0) {
1450  if (bypass_term_threshold != 0) {
1451  segment_passes = newpasses > 1 ? next_segment_passes : 1;
1452  next_segment_passes = (uint8_t) (3 - next_segment_passes);
1453  bits_to_read = (uint8_t) (cblk->lblock + av_log2(segment_passes));
1454  } else {
1455  if ((cblk->modes & JPEG2000_CBLK_TERMALL) == 0)
1456  av_log(s->avctx, AV_LOG_WARNING, "Corrupted packet header is found.\n");
1457  segment_passes = 1;
1458  bits_to_read = cblk->lblock;
1459  }
1460  segment_bytes = get_bits(s, bits_to_read);
1461  newpasses -= (uint8_t) (segment_passes);
1462 
1463  // Update cblk->npasses and write length information
1464  cblk->npasses = (uint8_t) (cblk->npasses + segment_passes);
1465  cblk->lengthinc[cblk->nb_lengthinc++] = segment_bytes;
1466  }
1467  }
1468 
1469  for (int i = 0; i < cblk->nb_lengthinc; ++i)
1470  tmp_length = (tmp_length < cblk->lengthinc[i]) ? cblk->lengthinc[i] : tmp_length;
1471 
1472  if (tmp_length > cblk->data_allocated) {
1473  size_t new_size = FFMAX(2 * cblk->data_allocated, tmp_length);
1474  void *new = av_realloc(cblk->data, new_size);
1475  if (new) {
1476  cblk->data = new;
1477  cblk->data_allocated = new_size;
1478  }
1479  }
1480  if (tmp_length > cblk->data_allocated) {
1481  avpriv_request_sample(s->avctx,
1482  "Block with lengthinc greater than %zu",
1483  cblk->data_allocated);
1484  return AVERROR_PATCHWELCOME;
1485  }
1486  } else {
1487  // This codeblock has no contribution to the current packet
1488  continue;
1489  }
1490  }
1491  }
1492  jpeg2000_flush(s);
1493 
1494  if (codsty->csty & JPEG2000_CSTY_EPH) {
1495  if (bytestream2_peek_be16(&s->g) == JPEG2000_EPH)
1496  bytestream2_skip(&s->g, 2);
1497  else
1498  av_log(s->avctx, AV_LOG_ERROR, "EPH marker not found. instead %X\n", bytestream2_peek_be32(&s->g));
1499  }
1500 
1501  // Save state of stream
1502  if (s->has_ppm) {
1503  tile->tile_part[*tp_index].header_tpg = s->g;
1504  select_stream(s, tile, tp_index, codsty);
1505  } else if (tile->has_ppt) {
1506  tile->packed_headers_stream = s->g;
1507  select_stream(s, tile, tp_index, codsty);
1508  }
1509  for (bandno = 0; bandno < rlevel->nbands; bandno++) {
1510  Jpeg2000Band *band = rlevel->band + bandno;
1511  Jpeg2000Prec *prec = band->prec + precno;
1512 
1513  nb_code_blocks = prec->nb_codeblocks_height * prec->nb_codeblocks_width;
1514  for (cblkno = 0; cblkno < nb_code_blocks; cblkno++) {
1515  Jpeg2000Cblk *cblk = prec->cblk + cblkno;
1516  if (!cblk->nb_terminationsinc && !cblk->lengthinc)
1517  continue;
1518  for (cwsno = 0; cwsno < cblk->nb_lengthinc; cwsno ++) {
1519  if (cblk->data_allocated < cblk->length + cblk->lengthinc[cwsno] + 4) {
1520  size_t new_size = FFMAX(2*cblk->data_allocated, cblk->length + cblk->lengthinc[cwsno] + 4);
1521  void *new = av_realloc(cblk->data, new_size);
1522  if (new) {
1523  cblk->data = new;
1524  cblk->data_allocated = new_size;
1525  }
1526  }
1527  if ( bytestream2_get_bytes_left(&s->g) < cblk->lengthinc[cwsno]
1528  || cblk->data_allocated < cblk->length + cblk->lengthinc[cwsno] + 4
1529  ) {
1530  av_log(s->avctx, AV_LOG_ERROR,
1531  "Block length %"PRIu16" or lengthinc %d is too large, left %d\n",
1532  cblk->length, cblk->lengthinc[cwsno], bytestream2_get_bytes_left(&s->g));
1533  return AVERROR_INVALIDDATA;
1534  }
1535 
1536  bytestream2_get_bufferu(&s->g, cblk->data + cblk->length, cblk->lengthinc[cwsno]);
1537  cblk->length += cblk->lengthinc[cwsno];
1538  memset(cblk->data + cblk->length, 0, 4);
1539  cblk->lengthinc[cwsno] = 0;
1540  if (cblk->nb_terminationsinc) {
1541  cblk->nb_terminationsinc--;
1542  cblk->nb_terminations++;
1543  cblk->data[cblk->length++] = 0xFF;
1544  cblk->data[cblk->length++] = 0xFF;
1545  cblk->data_start[cblk->nb_terminations] = cblk->length;
1546  }
1547  }
1548  av_freep(&cblk->lengthinc);
1549  cblk->nb_lengthinc = 0;
1550  }
1551  }
1552  // Save state of stream
1553  tile->tile_part[*tp_index].tpg = s->g;
1554  return 0;
1555 
1556 skip_data:
1557  if (codsty->csty & JPEG2000_CSTY_EPH) {
1558  if (bytestream2_peek_be16(&s->g) == JPEG2000_EPH)
1559  bytestream2_skip(&s->g, 2);
1560  else
1561  av_log(s->avctx, AV_LOG_ERROR, "EPH marker not found. instead %X\n", bytestream2_peek_be32(&s->g));
1562  }
1563  if (s->has_ppm) {
1564  tile->tile_part[*tp_index].header_tpg = s->g;
1565  select_stream(s, tile, tp_index, codsty);
1566  } else if (tile->has_ppt) {
1567  tile->packed_headers_stream = s->g;
1568  select_stream(s, tile, tp_index, codsty);
1569  }
1570  tile->tile_part[*tp_index].tpg = s->g;
1571  return 0;
1572 }
1573 
1574 static int jpeg2000_decode_packets_po_iteration(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile,
1575  int RSpoc, int CSpoc,
1576  int LYEpoc, int REpoc, int CEpoc,
1577  int Ppoc, int *tp_index)
1578 {
1579  int ret = 0;
1580  int layno, reslevelno, compno, precno, ok_reslevel;
1581  int x, y;
1582  int step_x, step_y;
1583 
1584  switch (Ppoc) {
1585  case JPEG2000_PGOD_RLCP:
1586  av_log(s->avctx, AV_LOG_DEBUG, "Progression order RLCP\n");
1587  ok_reslevel = 1;
1588  for (reslevelno = RSpoc; ok_reslevel && reslevelno < REpoc; reslevelno++) {
1589  ok_reslevel = 0;
1590  for (layno = 0; layno < LYEpoc; layno++) {
1591  for (compno = CSpoc; compno < CEpoc; compno++) {
1592  Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1593  Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
1594  if (reslevelno < codsty->nreslevels) {
1595  Jpeg2000ResLevel *rlevel = tile->comp[compno].reslevel +
1596  reslevelno;
1597  ok_reslevel = 1;
1598  for (precno = 0; precno < rlevel->num_precincts_x * rlevel->num_precincts_y; precno++)
1599  if ((ret = jpeg2000_decode_packet(s, tile, tp_index,
1600  codsty, rlevel,
1601  precno, layno,
1602  qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1603  qntsty->nguardbits)) < 0)
1604  return ret;
1605  }
1606  }
1607  }
1608  }
1609  break;
1610 
1611  case JPEG2000_PGOD_LRCP:
1612  av_log(s->avctx, AV_LOG_DEBUG, "Progression order LRCP\n");
1613  for (layno = 0; layno < LYEpoc; layno++) {
1614  ok_reslevel = 1;
1615  for (reslevelno = RSpoc; ok_reslevel && reslevelno < REpoc; reslevelno++) {
1616  ok_reslevel = 0;
1617  for (compno = CSpoc; compno < CEpoc; compno++) {
1618  Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1619  Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
1620  if (reslevelno < codsty->nreslevels) {
1621  Jpeg2000ResLevel *rlevel = tile->comp[compno].reslevel +
1622  reslevelno;
1623  ok_reslevel = 1;
1624  for (precno = 0; precno < rlevel->num_precincts_x * rlevel->num_precincts_y; precno++)
1625  if ((ret = jpeg2000_decode_packet(s, tile, tp_index,
1626  codsty, rlevel,
1627  precno, layno,
1628  qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1629  qntsty->nguardbits)) < 0)
1630  return ret;
1631  }
1632  }
1633  }
1634  }
1635  break;
1636 
1637  case JPEG2000_PGOD_CPRL:
1638  av_log(s->avctx, AV_LOG_DEBUG, "Progression order CPRL\n");
1639  for (compno = CSpoc; compno < CEpoc; compno++) {
1640  Jpeg2000Component *comp = tile->comp + compno;
1641  Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1642  Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
1643  step_x = 32;
1644  step_y = 32;
1645 
1646  if (RSpoc >= FFMIN(codsty->nreslevels, REpoc))
1647  continue;
1648 
1649  for (reslevelno = RSpoc; reslevelno < FFMIN(codsty->nreslevels, REpoc); reslevelno++) {
1650  uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1651  Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1652  step_x = FFMIN(step_x, rlevel->log2_prec_width + reducedresno);
1653  step_y = FFMIN(step_y, rlevel->log2_prec_height + reducedresno);
1654  }
1655  if (step_x >= 31 || step_y >= 31){
1656  avpriv_request_sample(s->avctx, "CPRL with large step");
1657  return AVERROR_PATCHWELCOME;
1658  }
1659  step_x = 1<<step_x;
1660  step_y = 1<<step_y;
1661 
1662  for (y = tile->coord[1][0]; y < tile->coord[1][1]; y = (y/step_y + 1)*step_y) {
1663  for (x = tile->coord[0][0]; x < tile->coord[0][1]; x = (x/step_x + 1)*step_x) {
1664  for (reslevelno = RSpoc; reslevelno < FFMIN(codsty->nreslevels, REpoc); reslevelno++) {
1665  unsigned prcx, prcy;
1666  uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1667  Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1668  int xc = x / s->cdx[compno];
1669  int yc = y / s->cdy[compno];
1670 
1671  if (yc % (1LL << (rlevel->log2_prec_height + reducedresno)) && y != tile->coord[1][0]) //FIXME this is a subset of the check
1672  continue;
1673 
1674  if (xc % (1LL << (rlevel->log2_prec_width + reducedresno)) && x != tile->coord[0][0]) //FIXME this is a subset of the check
1675  continue;
1676 
1677  // check if a precinct exists
1678  prcx = ff_jpeg2000_ceildivpow2(xc, reducedresno) >> rlevel->log2_prec_width;
1679  prcy = ff_jpeg2000_ceildivpow2(yc, reducedresno) >> rlevel->log2_prec_height;
1680  prcx -= ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], reducedresno) >> rlevel->log2_prec_width;
1681  prcy -= ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], reducedresno) >> rlevel->log2_prec_height;
1682 
1683  precno = prcx + rlevel->num_precincts_x * prcy;
1684 
1685  if (prcx >= rlevel->num_precincts_x || prcy >= rlevel->num_precincts_y) {
1686  av_log(s->avctx, AV_LOG_WARNING, "prc %d %d outside limits %d %d\n",
1687  prcx, prcy, rlevel->num_precincts_x, rlevel->num_precincts_y);
1688  continue;
1689  }
1690 
1691  for (layno = 0; layno < LYEpoc; layno++) {
1692  if ((ret = jpeg2000_decode_packet(s, tile, tp_index, codsty, rlevel,
1693  precno, layno,
1694  qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1695  qntsty->nguardbits)) < 0)
1696  return ret;
1697  }
1698  }
1699  }
1700  }
1701  }
1702  break;
1703 
1704  case JPEG2000_PGOD_RPCL:
1705  av_log(s->avctx, AV_LOG_WARNING, "Progression order RPCL\n");
1706  ok_reslevel = 1;
1707  for (reslevelno = RSpoc; ok_reslevel && reslevelno < REpoc; reslevelno++) {
1708  ok_reslevel = 0;
1709  step_x = 30;
1710  step_y = 30;
1711  for (compno = CSpoc; compno < CEpoc; compno++) {
1712  Jpeg2000Component *comp = tile->comp + compno;
1713  Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1714 
1715  if (reslevelno < codsty->nreslevels) {
1716  uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1717  Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1718  step_x = FFMIN(step_x, rlevel->log2_prec_width + reducedresno);
1719  step_y = FFMIN(step_y, rlevel->log2_prec_height + reducedresno);
1720  }
1721  }
1722  step_x = 1<<step_x;
1723  step_y = 1<<step_y;
1724 
1725  for (y = tile->coord[1][0]; y < tile->coord[1][1]; y = (y/step_y + 1)*step_y) {
1726  for (x = tile->coord[0][0]; x < tile->coord[0][1]; x = (x/step_x + 1)*step_x) {
1727  for (compno = CSpoc; compno < CEpoc; compno++) {
1728  Jpeg2000Component *comp = tile->comp + compno;
1729  Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1730  Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
1731  uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1732  Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1733  unsigned prcx, prcy;
1734  int trx0, try0;
1735 
1736  if (!s->cdx[compno] || !s->cdy[compno])
1737  return AVERROR_INVALIDDATA;
1738 
1739  if (reslevelno >= codsty->nreslevels)
1740  continue;
1741 
1742  trx0 = ff_jpeg2000_ceildiv(tile->coord[0][0], (int64_t)s->cdx[compno] << reducedresno);
1743  try0 = ff_jpeg2000_ceildiv(tile->coord[1][0], (int64_t)s->cdy[compno] << reducedresno);
1744 
1745  if (!(y % ((uint64_t)s->cdy[compno] << (rlevel->log2_prec_height + reducedresno)) == 0 ||
1746  (y == tile->coord[1][0] && ((int64_t)try0 << reducedresno) % (1ULL << (reducedresno + rlevel->log2_prec_height)))))
1747  continue;
1748 
1749  if (!(x % ((uint64_t)s->cdx[compno] << (rlevel->log2_prec_width + reducedresno)) == 0 ||
1750  (x == tile->coord[0][0] && ((int64_t)trx0 << reducedresno) % (1ULL << (reducedresno + rlevel->log2_prec_width)))))
1751  continue;
1752 
1753  // check if a precinct exists
1754  prcx = ff_jpeg2000_ceildiv(x, (int64_t)s->cdx[compno] << reducedresno) >> rlevel->log2_prec_width;
1755  prcy = ff_jpeg2000_ceildiv(y, (int64_t)s->cdy[compno] << reducedresno) >> rlevel->log2_prec_height;
1756  prcx -= ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], reducedresno) >> rlevel->log2_prec_width;
1757  prcy -= ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], reducedresno) >> rlevel->log2_prec_height;
1758 
1759  precno = prcx + rlevel->num_precincts_x * prcy;
1760 
1761  ok_reslevel = 1;
1762  if (prcx >= rlevel->num_precincts_x || prcy >= rlevel->num_precincts_y) {
1763  av_log(s->avctx, AV_LOG_WARNING, "prc %d %d outside limits %d %d\n",
1764  prcx, prcy, rlevel->num_precincts_x, rlevel->num_precincts_y);
1765  continue;
1766  }
1767 
1768  for (layno = 0; layno < LYEpoc; layno++) {
1769  if ((ret = jpeg2000_decode_packet(s, tile, tp_index,
1770  codsty, rlevel,
1771  precno, layno,
1772  qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1773  qntsty->nguardbits)) < 0)
1774  return ret;
1775  }
1776  }
1777  }
1778  }
1779  }
1780  break;
1781 
1782  case JPEG2000_PGOD_PCRL:
1783  av_log(s->avctx, AV_LOG_WARNING, "Progression order PCRL\n");
1784  step_x = 32;
1785  step_y = 32;
1786  for (compno = CSpoc; compno < CEpoc; compno++) {
1787  Jpeg2000Component *comp = tile->comp + compno;
1788  Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1789 
1790  for (reslevelno = RSpoc; reslevelno < FFMIN(codsty->nreslevels, REpoc); reslevelno++) {
1791  uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1792  Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1793  step_x = FFMIN(step_x, rlevel->log2_prec_width + reducedresno);
1794  step_y = FFMIN(step_y, rlevel->log2_prec_height + reducedresno);
1795  }
1796  }
1797  if (step_x >= 31 || step_y >= 31){
1798  avpriv_request_sample(s->avctx, "PCRL with large step");
1799  return AVERROR_PATCHWELCOME;
1800  }
1801  step_x = 1<<step_x;
1802  step_y = 1<<step_y;
1803 
1804  for (y = tile->coord[1][0]; y < tile->coord[1][1]; y = (y/step_y + 1)*step_y) {
1805  for (x = tile->coord[0][0]; x < tile->coord[0][1]; x = (x/step_x + 1)*step_x) {
1806  for (compno = CSpoc; compno < CEpoc; compno++) {
1807  Jpeg2000Component *comp = tile->comp + compno;
1808  Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1809  Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
1810 
1811  if (!s->cdx[compno] || !s->cdy[compno])
1812  return AVERROR_INVALIDDATA;
1813 
1814  for (reslevelno = RSpoc; reslevelno < FFMIN(codsty->nreslevels, REpoc); reslevelno++) {
1815  unsigned prcx, prcy;
1816  uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1817  Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1818  int trx0, try0;
1819 
1820  trx0 = ff_jpeg2000_ceildiv(tile->coord[0][0], (int64_t)s->cdx[compno] << reducedresno);
1821  try0 = ff_jpeg2000_ceildiv(tile->coord[1][0], (int64_t)s->cdy[compno] << reducedresno);
1822 
1823  if (!(y % ((uint64_t)s->cdy[compno] << (rlevel->log2_prec_height + reducedresno)) == 0 ||
1824  (y == tile->coord[1][0] && ((int64_t)try0 << reducedresno) % (1ULL << (reducedresno + rlevel->log2_prec_height)))))
1825  continue;
1826 
1827  if (!(x % ((uint64_t)s->cdx[compno] << (rlevel->log2_prec_width + reducedresno)) == 0 ||
1828  (x == tile->coord[0][0] && ((int64_t)trx0 << reducedresno) % (1ULL << (reducedresno + rlevel->log2_prec_width)))))
1829  continue;
1830 
1831  // check if a precinct exists
1832  prcx = ff_jpeg2000_ceildiv(x, (int64_t)s->cdx[compno] << reducedresno) >> rlevel->log2_prec_width;
1833  prcy = ff_jpeg2000_ceildiv(y, (int64_t)s->cdy[compno] << reducedresno) >> rlevel->log2_prec_height;
1834  prcx -= ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], reducedresno) >> rlevel->log2_prec_width;
1835  prcy -= ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], reducedresno) >> rlevel->log2_prec_height;
1836 
1837  precno = prcx + rlevel->num_precincts_x * prcy;
1838 
1839  if (prcx >= rlevel->num_precincts_x || prcy >= rlevel->num_precincts_y) {
1840  av_log(s->avctx, AV_LOG_WARNING, "prc %d %d outside limits %d %d\n",
1841  prcx, prcy, rlevel->num_precincts_x, rlevel->num_precincts_y);
1842  continue;
1843  }
1844 
1845  for (layno = 0; layno < LYEpoc; layno++) {
1846  if ((ret = jpeg2000_decode_packet(s, tile, tp_index, codsty, rlevel,
1847  precno, layno,
1848  qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1849  qntsty->nguardbits)) < 0)
1850  return ret;
1851  }
1852  }
1853  }
1854  }
1855  }
1856  break;
1857 
1858  default:
1859  break;
1860  }
1861 
1862  return ret;
1863 }
1864 
1865 static int jpeg2000_decode_packets(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
1866 {
1867  int ret = AVERROR_BUG;
1868  int i;
1869  int tp_index = 0;
1870 
1871  s->bit_index = 8;
1872  if (tile->poc.nb_poc) {
1873  for (i=0; i<tile->poc.nb_poc; i++) {
1874  Jpeg2000POCEntry *e = &tile->poc.poc[i];
1875  ret = jpeg2000_decode_packets_po_iteration(s, tile,
1876  e->RSpoc, e->CSpoc,
1877  FFMIN(e->LYEpoc, tile->codsty[0].nlayers),
1878  e->REpoc,
1879  FFMIN(e->CEpoc, s->ncomponents),
1880  e->Ppoc, &tp_index
1881  );
1882  if (ret < 0)
1883  return ret;
1884  }
1885  } else {
1886  ret = jpeg2000_decode_packets_po_iteration(s, tile,
1887  0, 0,
1888  tile->codsty[0].nlayers,
1889  33,
1890  s->ncomponents,
1891  tile->codsty[0].prog_order,
1892  &tp_index
1893  );
1894  }
1895  /* EOC marker reached */
1896  bytestream2_skip(&s->g, 2);
1897 
1898  return ret;
1899 }
1900 
1901 /* TIER-1 routines */
1902 static void decode_sigpass(Jpeg2000T1Context *t1, int width, int height,
1903  int bpno, int bandno,
1904  int vert_causal_ctx_csty_symbol)
1905 {
1906  int mask = (3u << bpno)>>1, y0, x, y;
1907 
1908  for (y0 = 0; y0 < height; y0 += 4)
1909  for (x = 0; x < width; x++)
1910  for (y = y0; y < height && y < y0 + 4; y++) {
1911  int flags_mask = -1;
1912  if (vert_causal_ctx_csty_symbol && y == y0 + 3)
1913  flags_mask &= ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE | JPEG2000_T1_SGN_S);
1914  if ((t1->flags[(y+1) * t1->stride + x+1] & JPEG2000_T1_SIG_NB & flags_mask)
1915  && !(t1->flags[(y+1) * t1->stride + x+1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS))) {
1916  if (ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ff_jpeg2000_getsigctxno(t1->flags[(y+1) * t1->stride + x+1] & flags_mask, bandno))) {
1917  int xorbit, ctxno = ff_jpeg2000_getsgnctxno(t1->flags[(y+1) * t1->stride + x+1] & flags_mask, &xorbit);
1918  if (t1->mqc.raw) {
1919  t1->data[(y) * t1->stride + x] |= (uint32_t)(ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ctxno)) << 31;
1920  t1->data[(y) * t1->stride + x] |= mask;
1921  } else {
1922  t1->data[(y) * t1->stride + x] |= (uint32_t)(ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ctxno) ^ xorbit) << 31;
1923  t1->data[(y) * t1->stride + x] |= mask;
1924  }
1925  ff_jpeg2000_set_significance(t1, x, y,
1926  t1->data[(y) * t1->stride + x] & INT32_MIN);
1927  }
1928  t1->flags[(y + 1) * t1->stride + x + 1] |= JPEG2000_T1_VIS;
1929  }
1930  }
1931 }
1932 
1933 static void decode_refpass(Jpeg2000T1Context *t1, int width, int height,
1934  int bpno, int vert_causal_ctx_csty_symbol)
1935 {
1936  int phalf;
1937  int y0, x, y;
1938 
1939  phalf = 1 << bpno;
1940 
1941  for (y0 = 0; y0 < height; y0 += 4)
1942  for (x = 0; x < width; x++)
1943  for (y = y0; y < height && y < y0 + 4; y++)
1944  if ((t1->flags[(y + 1) * t1->stride + x + 1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS)) == JPEG2000_T1_SIG) {
1945  int flags_mask = (vert_causal_ctx_csty_symbol && y == y0 + 3) ?
1946  ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE | JPEG2000_T1_SGN_S) : -1;
1947  int ctxno = ff_jpeg2000_getrefctxno(t1->flags[(y + 1) * t1->stride + x + 1] & flags_mask);
1948  t1->data[(y) * t1->stride + x] |= phalf >> 1;
1949  if (ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ctxno))
1950  t1->data[(y) * t1->stride + x] |= phalf;
1951  else {
1952  t1->data[(y) * t1->stride + x] &= ~(phalf);
1953 
1954  }
1955  t1->flags[(y + 1) * t1->stride + x + 1] |= JPEG2000_T1_REF;
1956  }
1957 }
1958 
1959 static void decode_clnpass(const Jpeg2000DecoderContext *s, Jpeg2000T1Context *t1,
1960  int width, int height, int bpno, int bandno,
1961  int seg_symbols, int vert_causal_ctx_csty_symbol)
1962 {
1963  int mask = 3 << (bpno - 1), y0, x, y, runlen, dec;
1964 
1965  for (y0 = 0; y0 < height; y0 += 4) {
1966  for (x = 0; x < width; x++) {
1967  int flags_mask = -1;
1968  if (vert_causal_ctx_csty_symbol)
1969  flags_mask &= ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE | JPEG2000_T1_SGN_S);
1970  if (y0 + 3 < height &&
1971  !((t1->flags[(y0 + 1) * t1->stride + x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
1972  (t1->flags[(y0 + 2) * t1->stride + x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
1973  (t1->flags[(y0 + 3) * t1->stride + x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
1974  (t1->flags[(y0 + 4) * t1->stride + x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG) & flags_mask))) {
1975  if (!ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_RL))
1976  continue;
1977  runlen = ff_mqc_decode(&t1->mqc,
1978  t1->mqc.cx_states + MQC_CX_UNI);
1979  runlen = (runlen << 1) | ff_mqc_decode(&t1->mqc,
1980  t1->mqc.cx_states +
1981  MQC_CX_UNI);
1982  dec = 1;
1983  } else {
1984  runlen = 0;
1985  dec = 0;
1986  }
1987 
1988  for (y = y0 + runlen; y < y0 + 4 && y < height; y++) {
1989  int flags_mask = -1;
1990  if (vert_causal_ctx_csty_symbol && y == y0 + 3)
1991  flags_mask &= ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE | JPEG2000_T1_SGN_S);
1992  if (!dec) {
1993  if (!(t1->flags[(y+1) * t1->stride + x+1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS))) {
1994  dec = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ff_jpeg2000_getsigctxno(t1->flags[(y+1) * t1->stride + x+1] & flags_mask,
1995  bandno));
1996  }
1997  }
1998  if (dec) {
1999  int xorbit;
2000  int ctxno = ff_jpeg2000_getsgnctxno(t1->flags[(y + 1) * t1->stride + x + 1] & flags_mask,
2001  &xorbit);
2002  t1->data[(y) * t1->stride + x] |= (uint32_t)(ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ctxno) ^ xorbit) << 31;
2003  t1->data[(y) * t1->stride + x] |= mask;
2004  ff_jpeg2000_set_significance(t1, x, y, t1->data[(y) * t1->stride + x] & INT32_MIN);
2005  }
2006  dec = 0;
2007  t1->flags[(y + 1) * t1->stride + x + 1] &= ~JPEG2000_T1_VIS;
2008  }
2009  }
2010  }
2011  if (seg_symbols) {
2012  int val;
2013  val = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
2014  val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
2015  val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
2016  val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
2017  if (val != 0xa)
2018  av_log(s->avctx, AV_LOG_ERROR,
2019  "Segmentation symbol value incorrect\n");
2020  }
2021 }
2022 
2023 static int decode_cblk(const Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *codsty,
2024  Jpeg2000T1Context *t1, Jpeg2000Cblk *cblk,
2025  int width, int height, int bandpos, uint8_t roi_shift, const int M_b)
2026 {
2027  int passno = cblk->npasses, pass_t = 2, bpno = cblk->nonzerobits - 1 + 31 - M_b - 1 - roi_shift;
2028  int pass_cnt = 0;
2029  int vert_causal_ctx_csty_symbol = codsty->cblk_style & JPEG2000_CBLK_VSC;
2030  int term_cnt = 0;
2031  int coder_type;
2032 
2033  av_assert0(width <= 1024U && height <= 1024U);
2034  av_assert0(width*height <= 4096);
2035 
2036  memset(t1->data, 0, t1->stride * height * sizeof(*t1->data));
2037 
2038  /* If code-block contains no compressed data: nothing to do. */
2039  if (!cblk->length)
2040  return 0;
2041 
2042  memset(t1->flags, 0, t1->stride * (height + 2) * sizeof(*t1->flags));
2043 
2044  cblk->data[cblk->length] = 0xff;
2045  cblk->data[cblk->length+1] = 0xff;
2046  ff_mqc_initdec(&t1->mqc, cblk->data, 0, 1);
2047 
2048  while (passno--) {
2049  if (bpno < -1 || bpno > 29) {
2050  av_log(s->avctx, AV_LOG_ERROR, "bpno (%d) became invalid\n", bpno);
2051  return AVERROR_INVALIDDATA;
2052  }
2053  switch(pass_t) {
2054  case 0:
2055  decode_sigpass(t1, width, height, bpno + 1, bandpos,
2056  vert_causal_ctx_csty_symbol);
2057  break;
2058  case 1:
2059  decode_refpass(t1, width, height, bpno + 1, vert_causal_ctx_csty_symbol);
2060  break;
2061  case 2:
2062  av_assert2(!t1->mqc.raw);
2063  decode_clnpass(s, t1, width, height, bpno + 1, bandpos,
2064  codsty->cblk_style & JPEG2000_CBLK_SEGSYM,
2065  vert_causal_ctx_csty_symbol);
2066  break;
2067  }
2068  if (codsty->cblk_style & JPEG2000_CBLK_RESET) // XXX no testcase for just this
2069  ff_mqc_init_contexts(&t1->mqc);
2070 
2071  if (passno && (coder_type = needs_termination(codsty->cblk_style, pass_cnt))) {
2072  if (term_cnt >= cblk->nb_terminations) {
2073  av_log(s->avctx, AV_LOG_ERROR, "Missing needed termination \n");
2074  return AVERROR_INVALIDDATA;
2075  }
2076  if (FFABS(cblk->data + cblk->data_start[term_cnt + 1] - 2 - t1->mqc.bp) > 0) {
2077  av_log(s->avctx, AV_LOG_WARNING, "Mid mismatch %td in pass %d of %d\n",
2078  cblk->data + cblk->data_start[term_cnt + 1] - 2 - t1->mqc.bp,
2079  pass_cnt, cblk->npasses);
2080  }
2081 
2082  ff_mqc_initdec(&t1->mqc, cblk->data + cblk->data_start[++term_cnt], coder_type == 2, 0);
2083  }
2084 
2085  pass_t++;
2086  if (pass_t == 3) {
2087  bpno--;
2088  pass_t = 0;
2089  }
2090  pass_cnt ++;
2091  }
2092 
2093  if (cblk->data + cblk->length - 2 > t1->mqc.bp) {
2094  av_log(s->avctx, AV_LOG_WARNING, "End mismatch %td\n",
2095  cblk->data + cblk->length - 2 - t1->mqc.bp);
2096  }
2097 
2098  if (cblk->data + cblk->length < t1->mqc.bp) {
2099  av_log(s->avctx, AV_LOG_WARNING, "Synthetic End of Stream Marker Read.\n");
2100  }
2101 
2102  /* Reconstruct the sample values */
2103  for (int y = 0; y < height; y++) {
2104  for (int x = 0; x < width; x++) {
2105  int32_t sign, n, val;
2106  const uint32_t mask = (int64_t)UINT32_MAX >> (M_b + 1); // bit mask for ROI detection
2107 
2108  n = x + (y * t1->stride);
2109  val = t1->data[n];
2110  sign = val & INT32_MIN;
2111  val &= INT32_MAX;
2112  /* ROI shift, if necessary */
2113  if (roi_shift && (((uint32_t)val & ~mask) == 0))
2114  val <<= roi_shift;
2115  t1->data[n] = val | sign; /* NOTE: Binary point for reconstruction value is located in 31 - M_b */
2116  }
2117  }
2118  return 1;
2119 }
2120 
2121 /* TODO: Verify dequantization for lossless case
2122  * comp->data can be float or int
2123  * band->stepsize can be float or int
2124  * depending on the type of DWT transformation.
2125  * see ISO/IEC 15444-1:2002 A.6.1 */
2126 
2127 /* Float dequantization of a codeblock.*/
2128 static void dequantization_float(int x, int y, Jpeg2000Cblk *cblk,
2129  Jpeg2000Component *comp,
2130  Jpeg2000T1Context *t1, Jpeg2000Band *band, const int M_b)
2131 {
2132  int i, j;
2133  int w = cblk->coord[0][1] - cblk->coord[0][0];
2134  const int downshift = 31 - M_b;
2135  float fscale = band->f_stepsize;
2136  fscale /= (float)(1LL << downshift);
2137  for (j = 0; j < (cblk->coord[1][1] - cblk->coord[1][0]); ++j) {
2138  float *datap = &comp->f_data[(comp->coord[0][1] - comp->coord[0][0]) * (y + j) + x];
2139  int *src = t1->data + j*t1->stride;
2140  for (i = 0; i < w; ++i) {
2141  int val = src[i];
2142  if (val < 0) // Convert sign-magnitude to two's complement
2143  val = -(val & INT32_MAX);
2144  datap[i] = (float)val * fscale;
2145  }
2146  }
2147 }
2148 
2149 /* Integer dequantization of a codeblock.*/
2150 static void dequantization_int(int x, int y, Jpeg2000Cblk *cblk,
2151  Jpeg2000Component *comp,
2152  Jpeg2000T1Context *t1, Jpeg2000Band *band, const int M_b)
2153 {
2154  int i, j;
2155  const int downshift = FFMIN(31 - M_b, 31);
2156  int w = cblk->coord[0][1] - cblk->coord[0][0];
2157  for (j = 0; j < (cblk->coord[1][1] - cblk->coord[1][0]); ++j) {
2158  int32_t *datap = &comp->i_data[(comp->coord[0][1] - comp->coord[0][0]) * (y + j) + x];
2159  int *src = t1->data + j*t1->stride;
2160  if (band->i_stepsize == 32768) {
2161  for (i = 0; i < w; ++i) {
2162  int val = src[i];
2163  if (val < 0) // Convert sign-magnitude to two's complement
2164  val = -((val & INT32_MAX) >> downshift);
2165  else
2166  val >>= downshift;
2167  datap[i] = val;
2168  }
2169  } else {
2170  // This should be VERY uncommon
2171  for (i = 0; i < w; ++i) {
2172  int val = src[i];
2173  if (val < 0) // Convert sign-magnitude to two's complement
2174  val = -((val & INT32_MAX) >> downshift);
2175  else
2176  val >>= downshift;
2177  datap[i] = (val * (int64_t)band->i_stepsize) / 65536;
2178  }
2179  }
2180  }
2181 }
2182 
2183 static void dequantization_int_97(int x, int y, Jpeg2000Cblk *cblk,
2184  Jpeg2000Component *comp,
2185  Jpeg2000T1Context *t1, Jpeg2000Band *band, const int M_b)
2186 {
2187  int i, j;
2188  int w = cblk->coord[0][1] - cblk->coord[0][0];
2189  float fscale = band->f_stepsize;
2190  const int downshift = 31 - M_b;
2191  const int PRESCALE = 6; // At least 6 is required to pass the conformance tests in ISO/IEC 15444-4
2192  int scale;
2193 
2194  fscale /= (float)(1LL << downshift);
2195  fscale *= (float)(1 << PRESCALE);
2196  fscale *= (float)(1 << (16 + I_PRESHIFT));
2197  scale = (int)(fscale + 0.5);
2198  band->i_stepsize = scale;
2199  for (j = 0; j < (cblk->coord[1][1] - cblk->coord[1][0]); ++j) {
2200  int32_t *datap = &comp->i_data[(comp->coord[0][1] - comp->coord[0][0]) * (y + j) + x];
2201  int *src = t1->data + j*t1->stride;
2202  for (i = 0; i < w; ++i) {
2203  int val = src[i];
2204  if (val < 0) // Convert sign-magnitude to two's complement
2205  val = -(val & INT32_MAX);
2206  // Shifting down to prevent overflow in dequantization
2207  val = (val + (1LL << (PRESCALE - 1))) >> PRESCALE;
2208  datap[i] = RSHIFT(val * (int64_t)band->i_stepsize, 16);
2209  }
2210  }
2211 }
2212 
2213 static inline void mct_decode(const Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
2214 {
2215  int i, csize = 1;
2216  void *src[3];
2217 
2218  for (i = 1; i < 3; i++) {
2219  if (tile->codsty[0].transform != tile->codsty[i].transform) {
2220  av_log(s->avctx, AV_LOG_ERROR, "Transforms mismatch, MCT not supported\n");
2221  return;
2222  }
2223  if (memcmp(tile->comp[0].coord, tile->comp[i].coord, sizeof(tile->comp[0].coord))) {
2224  av_log(s->avctx, AV_LOG_ERROR, "Coords mismatch, MCT not supported\n");
2225  return;
2226  }
2227  }
2228 
2229  for (i = 0; i < 3; i++)
2230  if (tile->codsty[0].transform == FF_DWT97)
2231  src[i] = tile->comp[i].f_data;
2232  else
2233  src[i] = tile->comp[i].i_data;
2234 
2235  for (i = 0; i < 2; i++)
2236  csize *= tile->comp[0].coord[i][1] - tile->comp[0].coord[i][0];
2237 
2238  s->dsp.mct_decode[tile->codsty[0].transform](src[0], src[1], src[2], csize);
2239 }
2240 
2241 
2242 static inline int tile_codeblocks(const Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
2243 {
2244  Jpeg2000T1Context t1;
2245 
2246  int compno, reslevelno, bandno;
2247 
2248  /* Loop on tile components */
2249  for (compno = 0; compno < s->ncomponents; compno++) {
2250  Jpeg2000Component *comp = tile->comp + compno;
2251  Jpeg2000CodingStyle *codsty = tile->codsty + compno;
2252  Jpeg2000QuantStyle *quantsty = tile->qntsty + compno;
2253 
2254  int coded = 0;
2255  int subbandno = 0;
2256 
2257  t1.stride = (1<<codsty->log2_cblk_width) + 2;
2258 
2259  /* Loop on resolution levels */
2260  for (reslevelno = 0; reslevelno < codsty->nreslevels2decode; reslevelno++) {
2261  Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
2262  /* Loop on bands */
2263  for (bandno = 0; bandno < rlevel->nbands; bandno++, subbandno++) {
2264  int nb_precincts, precno;
2265  Jpeg2000Band *band = rlevel->band + bandno;
2266  int cblkno = 0, bandpos;
2267  /* See Rec. ITU-T T.800, Equation E-2 */
2268  int M_b = quantsty->expn[subbandno] + quantsty->nguardbits - 1;
2269 
2270  bandpos = bandno + (reslevelno > 0);
2271 
2272  if (band->coord[0][0] == band->coord[0][1] ||
2273  band->coord[1][0] == band->coord[1][1])
2274  continue;
2275 
2276  if (M_b > 31) {
2277  avpriv_request_sample(s->avctx, "M_b (%d) > 31", M_b);
2278  return AVERROR_PATCHWELCOME;
2279  }
2280 
2281  nb_precincts = rlevel->num_precincts_x * rlevel->num_precincts_y;
2282  /* Loop on precincts */
2283  for (precno = 0; precno < nb_precincts; precno++) {
2284  Jpeg2000Prec *prec = band->prec + precno;
2285 
2286  /* Loop on codeblocks */
2287  for (cblkno = 0;
2288  cblkno < prec->nb_codeblocks_width * prec->nb_codeblocks_height;
2289  cblkno++) {
2290  int x, y, ret;
2291 
2292  Jpeg2000Cblk *cblk = prec->cblk + cblkno;
2293 
2294  if (cblk->modes & JPEG2000_CTSY_HTJ2K_F)
2295  ret = ff_jpeg2000_decode_htj2k(s, codsty, &t1, cblk,
2296  cblk->coord[0][1] - cblk->coord[0][0],
2297  cblk->coord[1][1] - cblk->coord[1][0],
2298  M_b, comp->roi_shift);
2299  else
2300  ret = decode_cblk(s, codsty, &t1, cblk,
2301  cblk->coord[0][1] - cblk->coord[0][0],
2302  cblk->coord[1][1] - cblk->coord[1][0],
2303  bandpos, comp->roi_shift, M_b);
2304 
2305  if (ret)
2306  coded = 1;
2307  else
2308  continue;
2309  x = cblk->coord[0][0] - band->coord[0][0];
2310  y = cblk->coord[1][0] - band->coord[1][0];
2311 
2312  if (codsty->transform == FF_DWT97)
2313  dequantization_float(x, y, cblk, comp, &t1, band, M_b);
2314  else if (codsty->transform == FF_DWT97_INT)
2315  dequantization_int_97(x, y, cblk, comp, &t1, band, M_b);
2316  else
2317  dequantization_int(x, y, cblk, comp, &t1, band, M_b);
2318  } /* end cblk */
2319  } /*end prec */
2320  } /* end band */
2321  } /* end reslevel */
2322 
2323  /* inverse DWT */
2324  if (coded)
2325  ff_dwt_decode(&comp->dwt, codsty->transform == FF_DWT97 ? (void*)comp->f_data : (void*)comp->i_data);
2326 
2327  } /*end comp */
2328  return 0;
2329 }
2330 
2331 #define WRITE_FRAME(D, PIXEL) \
2332  static inline void write_frame_ ## D(const Jpeg2000DecoderContext * s, Jpeg2000Tile * tile, \
2333  AVFrame * picture, int precision) \
2334  { \
2335  const AVPixFmtDescriptor *pixdesc = av_pix_fmt_desc_get(s->avctx->pix_fmt); \
2336  int planar = !!(pixdesc->flags & AV_PIX_FMT_FLAG_PLANAR); \
2337  int pixelsize = planar ? 1 : pixdesc->nb_components; \
2338  \
2339  int compno; \
2340  int x, y; \
2341  \
2342  for (compno = 0; compno < s->ncomponents; compno++) { \
2343  Jpeg2000Component *comp = tile->comp + compno; \
2344  Jpeg2000CodingStyle *codsty = tile->codsty + compno; \
2345  PIXEL *line; \
2346  float *datap = comp->f_data; \
2347  int32_t *i_datap = comp->i_data; \
2348  int cbps = s->cbps[compno]; \
2349  int w = tile->comp[compno].coord[0][1] - \
2350  ff_jpeg2000_ceildiv(s->image_offset_x, s->cdx[compno]); \
2351  int h = tile->comp[compno].coord[1][1] - \
2352  ff_jpeg2000_ceildiv(s->image_offset_y, s->cdy[compno]); \
2353  int plane = 0; \
2354  ptrdiff_t dstoffset = 0; \
2355  \
2356  if (planar) \
2357  plane = s->cdef[compno] ? s->cdef[compno]-1 : (s->ncomponents-1); \
2358  else \
2359  dstoffset = s->cdef[compno] ? s->cdef[compno] - 1 : compno; \
2360  \
2361  y = tile->comp[compno].coord[1][0] - \
2362  ff_jpeg2000_ceildiv(s->image_offset_y, s->cdy[compno]); \
2363  line = (PIXEL *)picture->data[plane] + y * (picture->linesize[plane] / sizeof(PIXEL));\
2364  for (; y < h; y++) { \
2365  PIXEL *dst; \
2366  \
2367  x = tile->comp[compno].coord[0][0] - \
2368  ff_jpeg2000_ceildiv(s->image_offset_x, s->cdx[compno]); \
2369  dst = line + x * pixelsize + dstoffset; \
2370  \
2371  if (codsty->transform == FF_DWT97) { \
2372  for (; x < w; x++) { \
2373  int val = lrintf(*datap) + (1 << (cbps - 1)); \
2374  /* DC level shift and clip see ISO 15444-1:2002 G.1.2 */ \
2375  val = av_clip(val, 0, (1 << cbps) - 1); \
2376  *dst = val << (precision - cbps); \
2377  datap++; \
2378  dst += pixelsize; \
2379  } \
2380  } else { \
2381  for (; x < w; x++) { \
2382  int val = *i_datap + (1 << (cbps - 1)); \
2383  /* DC level shift and clip see ISO 15444-1:2002 G.1.2 */ \
2384  val = av_clip(val, 0, (1 << cbps) - 1); \
2385  *dst = val << (precision - cbps); \
2386  i_datap++; \
2387  dst += pixelsize; \
2388  } \
2389  } \
2390  line += picture->linesize[plane] / sizeof(PIXEL); \
2391  } \
2392  } \
2393  \
2394  }
2395 
2396 WRITE_FRAME(8, uint8_t)
2397 WRITE_FRAME(16, uint16_t)
2398 
2399 #undef WRITE_FRAME
2400 
2401 static int jpeg2000_decode_tile(AVCodecContext *avctx, void *td,
2402  int jobnr, int threadnr)
2403 {
2404  const Jpeg2000DecoderContext *s = avctx->priv_data;
2405  AVFrame *picture = td;
2406  Jpeg2000Tile *tile = s->tile + jobnr;
2407 
2408  int ret = tile_codeblocks(s, tile);
2409  if (ret < 0)
2410  return ret;
2411 
2412  /* inverse MCT transformation */
2413  if (tile->codsty[0].mct)
2414  mct_decode(s, tile);
2415 
2416  if (s->precision <= 8) {
2417  write_frame_8(s, tile, picture, 8);
2418  } else {
2419  int precision = picture->format == AV_PIX_FMT_XYZ12 ||
2420  picture->format == AV_PIX_FMT_RGB48 ||
2421  picture->format == AV_PIX_FMT_RGBA64 ||
2422  picture->format == AV_PIX_FMT_GRAY16 ? 16 : s->precision;
2423 
2424  write_frame_16(s, tile, picture, precision);
2425  }
2426 
2427  return 0;
2428 }
2429 
2430 static void jpeg2000_dec_cleanup(Jpeg2000DecoderContext *s)
2431 {
2432  int tileno, compno;
2433  for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++) {
2434  if (s->tile[tileno].comp) {
2435  for (compno = 0; compno < s->ncomponents; compno++) {
2436  Jpeg2000Component *comp = s->tile[tileno].comp + compno;
2437  Jpeg2000CodingStyle *codsty = s->tile[tileno].codsty + compno;
2438 
2439  ff_jpeg2000_cleanup(comp, codsty);
2440  }
2441  av_freep(&s->tile[tileno].comp);
2442  av_freep(&s->tile[tileno].packed_headers);
2443  s->tile[tileno].packed_headers_size = 0;
2444  }
2445  }
2446  av_freep(&s->packed_headers);
2447  s->packed_headers_size = 0;
2448  memset(&s->packed_headers_stream, 0, sizeof(s->packed_headers_stream));
2449  av_freep(&s->tile);
2450  memset(s->codsty, 0, sizeof(s->codsty));
2451  memset(s->qntsty, 0, sizeof(s->qntsty));
2452  memset(s->properties, 0, sizeof(s->properties));
2453  memset(&s->poc , 0, sizeof(s->poc));
2454  s->numXtiles = s->numYtiles = 0;
2455  s->ncomponents = 0;
2456 }
2457 
2458 static int jpeg2000_read_main_headers(Jpeg2000DecoderContext *s)
2459 {
2460  Jpeg2000CodingStyle *codsty = s->codsty;
2461  Jpeg2000QuantStyle *qntsty = s->qntsty;
2462  Jpeg2000POC *poc = &s->poc;
2463  uint8_t *properties = s->properties;
2464  uint8_t in_tile_headers = 0;
2465 
2466  for (;;) {
2467  int len, ret = 0;
2468  uint16_t marker;
2469  int oldpos;
2470 
2471  if (bytestream2_get_bytes_left(&s->g) < 2) {
2472  av_log(s->avctx, AV_LOG_ERROR, "Missing EOC\n");
2473  break;
2474  }
2475 
2476  marker = bytestream2_get_be16u(&s->g);
2477  oldpos = bytestream2_tell(&s->g);
2478  if (marker >= 0xFF30 && marker <= 0xFF3F)
2479  continue;
2480  if (marker == JPEG2000_SOD) {
2481  Jpeg2000Tile *tile;
2482  Jpeg2000TilePart *tp;
2483 
2484  if (!s->tile) {
2485  av_log(s->avctx, AV_LOG_ERROR, "Missing SIZ\n");
2486  return AVERROR_INVALIDDATA;
2487  }
2488  if (s->curtileno < 0) {
2489  av_log(s->avctx, AV_LOG_ERROR, "Missing SOT\n");
2490  return AVERROR_INVALIDDATA;
2491  }
2492 
2493  tile = s->tile + s->curtileno;
2494  tp = tile->tile_part + tile->tp_idx;
2495  if (tp->tp_end < s->g.buffer) {
2496  av_log(s->avctx, AV_LOG_ERROR, "Invalid tpend\n");
2497  return AVERROR_INVALIDDATA;
2498  }
2499 
2500  if (s->has_ppm) {
2501  uint32_t tp_header_size = bytestream2_get_be32(&s->packed_headers_stream);
2502  if (bytestream2_get_bytes_left(&s->packed_headers_stream) < tp_header_size)
2503  return AVERROR_INVALIDDATA;
2504  bytestream2_init(&tp->header_tpg, s->packed_headers_stream.buffer, tp_header_size);
2505  bytestream2_skip(&s->packed_headers_stream, tp_header_size);
2506  }
2507  if (tile->has_ppt && tile->tp_idx == 0) {
2508  bytestream2_init(&tile->packed_headers_stream, tile->packed_headers, tile->packed_headers_size);
2509  }
2510 
2511  bytestream2_init(&tp->tpg, s->g.buffer, tp->tp_end - s->g.buffer);
2512  bytestream2_skip(&s->g, tp->tp_end - s->g.buffer);
2513 
2514  continue;
2515  }
2516  if (marker == JPEG2000_EOC)
2517  break;
2518 
2519  len = bytestream2_get_be16(&s->g);
2520  if (len < 2 || bytestream2_get_bytes_left(&s->g) < len - 2) {
2521  if (s->avctx->strict_std_compliance >= FF_COMPLIANCE_STRICT) {
2522  av_log(s->avctx, AV_LOG_ERROR, "Invalid len %d left=%d\n", len, bytestream2_get_bytes_left(&s->g));
2523  return AVERROR_INVALIDDATA;
2524  }
2525  av_log(s->avctx, AV_LOG_WARNING, "Missing EOC Marker.\n");
2526  break;
2527  }
2528 
2529  switch (marker) {
2530  case JPEG2000_SIZ:
2531  if (s->ncomponents) {
2532  av_log(s->avctx, AV_LOG_ERROR, "Duplicate SIZ\n");
2533  return AVERROR_INVALIDDATA;
2534  }
2535  ret = get_siz(s);
2536  if (!s->tile)
2537  s->numXtiles = s->numYtiles = 0;
2538  break;
2539  case JPEG2000_CAP:
2540  if (!s->ncomponents) {
2541  av_log(s->avctx, AV_LOG_ERROR, "CAP marker segment shall come after SIZ\n");
2542  return AVERROR_INVALIDDATA;
2543  }
2544  ret = get_cap(s, codsty);
2545  break;
2546  case JPEG2000_COC:
2547  if (in_tile_headers == 1 && s->isHT && (!s->Ccap15_b11)) {
2548  av_log(s->avctx, AV_LOG_ERROR,
2549  "COC marker found in a tile header but the codestream belongs to the HOMOGENEOUS set\n");
2550  return AVERROR_INVALIDDATA;
2551  }
2552  ret = get_coc(s, codsty, properties);
2553  break;
2554  case JPEG2000_COD:
2555  if (in_tile_headers == 1 && s->isHT && (!s->Ccap15_b11)) {
2556  av_log(s->avctx, AV_LOG_ERROR,
2557  "COD marker found in a tile header but the codestream belongs to the HOMOGENEOUS set\n");
2558  return AVERROR_INVALIDDATA;
2559  }
2560  ret = get_cod(s, codsty, properties);
2561  break;
2562  case JPEG2000_RGN:
2563  if (in_tile_headers == 1 && s->isHT && (!s->Ccap15_b11)) {
2564  av_log(s->avctx, AV_LOG_ERROR,
2565  "RGN marker found in a tile header but the codestream belongs to the HOMOGENEOUS set\n");
2566  return AVERROR_INVALIDDATA;
2567  }
2568  ret = get_rgn(s, len);
2569  if ((!s->Ccap15_b12) && s->isHT) {
2570  av_log(s->avctx, AV_LOG_ERROR, "RGN marker found but the codestream belongs to the RGNFREE set\n");
2571  return AVERROR_INVALIDDATA;
2572  }
2573  break;
2574  case JPEG2000_QCC:
2575  if (in_tile_headers == 1 && s->isHT && (!s->Ccap15_b11)) {
2576  av_log(s->avctx, AV_LOG_ERROR,
2577  "QCC marker found in a tile header but the codestream belongs to the HOMOGENEOUS set\n");
2578  return AVERROR_INVALIDDATA;
2579  }
2580  ret = get_qcc(s, len, qntsty, properties);
2581  break;
2582  case JPEG2000_QCD:
2583  if (in_tile_headers == 1 && s->isHT && (!s->Ccap15_b11)) {
2584  av_log(s->avctx, AV_LOG_ERROR,
2585  "QCD marker found in a tile header but the codestream belongs to the HOMOGENEOUS set\n");
2586  return AVERROR_INVALIDDATA;
2587  }
2588  ret = get_qcd(s, len, qntsty, properties);
2589  break;
2590  case JPEG2000_POC:
2591  if (in_tile_headers == 1 && s->isHT && (!s->Ccap15_b11)) {
2592  av_log(s->avctx, AV_LOG_ERROR,
2593  "POC marker found in a tile header but the codestream belongs to the HOMOGENEOUS set\n");
2594  return AVERROR_INVALIDDATA;
2595  }
2596  ret = get_poc(s, len, poc);
2597  break;
2598  case JPEG2000_SOT:
2599  if (!in_tile_headers) {
2600  in_tile_headers = 1;
2601  if (s->has_ppm) {
2602  bytestream2_init(&s->packed_headers_stream, s->packed_headers, s->packed_headers_size);
2603  }
2604  }
2605  if (!(ret = get_sot(s, len))) {
2606  av_assert1(s->curtileno >= 0);
2607  codsty = s->tile[s->curtileno].codsty;
2608  qntsty = s->tile[s->curtileno].qntsty;
2609  poc = &s->tile[s->curtileno].poc;
2610  properties = s->tile[s->curtileno].properties;
2611  }
2612  break;
2613  case JPEG2000_PLM:
2614  // the PLM marker is ignored
2615  case JPEG2000_COM:
2616  // the comment is ignored
2617  bytestream2_skip(&s->g, len - 2);
2618  break;
2619  case JPEG2000_CRG:
2620  ret = read_crg(s, len);
2621  break;
2622  case JPEG2000_TLM:
2623  // Tile-part lengths
2624  ret = get_tlm(s, len);
2625  break;
2626  case JPEG2000_PLT:
2627  // Packet length, tile-part header
2628  ret = get_plt(s, len);
2629  break;
2630  case JPEG2000_PPM:
2631  // Packed headers, main header
2632  if (in_tile_headers) {
2633  av_log(s->avctx, AV_LOG_ERROR, "PPM Marker can only be in Main header\n");
2634  return AVERROR_INVALIDDATA;
2635  }
2636  ret = get_ppm(s, len);
2637  break;
2638  case JPEG2000_PPT:
2639  // Packed headers, tile-part header
2640  if (s->has_ppm) {
2641  av_log(s->avctx, AV_LOG_ERROR,
2642  "Cannot have both PPT and PPM marker.\n");
2643  return AVERROR_INVALIDDATA;
2644  }
2645  if ((!s->Ccap15_b11) && s->isHT) {
2646  av_log(s->avctx, AV_LOG_ERROR, "PPT marker found but the codestream belongs to the HOMOGENEOUS set\n");
2647  return AVERROR_INVALIDDATA;
2648  }
2649  ret = get_ppt(s, len);
2650  break;
2651  case JPEG2000_CPF:
2652  // Corresponding profile marker
2653  ret = read_cpf(s, len);
2654  break;
2655  default:
2656  av_log(s->avctx, AV_LOG_ERROR,
2657  "unsupported marker 0x%.4"PRIX16" at pos 0x%X\n",
2658  marker, bytestream2_tell(&s->g) - 4);
2659  bytestream2_skip(&s->g, len - 2);
2660  break;
2661  }
2662  if (bytestream2_tell(&s->g) - oldpos != len || ret) {
2663  av_log(s->avctx, AV_LOG_ERROR,
2664  "error during processing marker segment %.4"PRIx16"\n",
2665  marker);
2666  return ret ? ret : -1;
2667  }
2668  }
2669  return 0;
2670 }
2671 
2672 /* Read bit stream packets --> T2 operation. */
2673 static int jpeg2000_read_bitstream_packets(Jpeg2000DecoderContext *s)
2674 {
2675  int ret = 0;
2676  int tileno;
2677 
2678  for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++) {
2679  Jpeg2000Tile *tile = s->tile + tileno;
2680 
2681  if ((ret = init_tile(s, tileno)) < 0)
2682  return ret;
2683 
2684  if ((ret = jpeg2000_decode_packets(s, tile)) < 0)
2685  return ret;
2686  }
2687 
2688  return 0;
2689 }
2690 
2691 static int jp2_find_codestream(Jpeg2000DecoderContext *s)
2692 {
2693  uint32_t atom_size, atom, atom_end;
2694  int search_range = 10;
2695 
2696  while (search_range
2697  &&
2698  bytestream2_get_bytes_left(&s->g) >= 8) {
2699  atom_size = bytestream2_get_be32u(&s->g);
2700  atom = bytestream2_get_be32u(&s->g);
2701  if (atom_size == 1) {
2702  if (bytestream2_get_be32u(&s->g)) {
2703  avpriv_request_sample(s->avctx, "Huge atom");
2704  return 0;
2705  }
2706  atom_size = bytestream2_get_be32u(&s->g);
2707  if (atom_size < 16 || (int64_t)bytestream2_tell(&s->g) + atom_size - 16 > INT_MAX)
2708  return AVERROR_INVALIDDATA;
2709  atom_end = bytestream2_tell(&s->g) + atom_size - 16;
2710  } else {
2711  if (atom_size < 8 || (int64_t)bytestream2_tell(&s->g) + atom_size - 8 > INT_MAX)
2712  return AVERROR_INVALIDDATA;
2713  atom_end = bytestream2_tell(&s->g) + atom_size - 8;
2714  }
2715 
2716  if (atom == JP2_CODESTREAM)
2717  return 1;
2718 
2719  if (bytestream2_get_bytes_left(&s->g) < atom_size || atom_end < atom_size)
2720  return 0;
2721 
2722  if (atom == JP2_HEADER &&
2723  atom_size >= 16) {
2724  uint32_t atom2_size, atom2, atom2_end;
2725  do {
2726  if (bytestream2_get_bytes_left(&s->g) < 8)
2727  break;
2728  atom2_size = bytestream2_get_be32u(&s->g);
2729  atom2 = bytestream2_get_be32u(&s->g);
2730  atom2_end = bytestream2_tell(&s->g) + atom2_size - 8;
2731  if (atom2_size < 8 || atom2_end > atom_end || atom2_end < atom2_size)
2732  break;
2733  atom2_size -= 8;
2734  if (atom2 == JP2_CODESTREAM) {
2735  return 1;
2736  } else if (atom2 == MKBETAG('c','o','l','r') && atom2_size >= 7) {
2737  int method = bytestream2_get_byteu(&s->g);
2738  bytestream2_skipu(&s->g, 2);
2739  if (method == 1) {
2740  s->colour_space = bytestream2_get_be32u(&s->g);
2741  }
2742  } else if (atom2 == MKBETAG('p','c','l','r') && atom2_size >= 6) {
2743  int i, size, colour_count, colour_channels, colour_depth[3];
2744  colour_count = bytestream2_get_be16u(&s->g);
2745  colour_channels = bytestream2_get_byteu(&s->g);
2746  // FIXME: Do not ignore channel_sign
2747  colour_depth[0] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1;
2748  colour_depth[1] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1;
2749  colour_depth[2] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1;
2750  size = (colour_depth[0] + 7 >> 3) * colour_count +
2751  (colour_depth[1] + 7 >> 3) * colour_count +
2752  (colour_depth[2] + 7 >> 3) * colour_count;
2753  if (colour_count > AVPALETTE_COUNT ||
2754  colour_channels != 3 ||
2755  colour_depth[0] > 16 ||
2756  colour_depth[1] > 16 ||
2757  colour_depth[2] > 16 ||
2758  atom2_size < size) {
2759  avpriv_request_sample(s->avctx, "Unknown palette");
2760  bytestream2_seek(&s->g, atom2_end, SEEK_SET);
2761  continue;
2762  }
2763  s->pal8 = 1;
2764  for (i = 0; i < colour_count; i++) {
2765  uint32_t r, g, b;
2766  if (colour_depth[0] <= 8) {
2767  r = bytestream2_get_byteu(&s->g) << 8 - colour_depth[0];
2768  r |= r >> colour_depth[0];
2769  } else {
2770  r = bytestream2_get_be16u(&s->g) >> colour_depth[0] - 8;
2771  }
2772  if (colour_depth[1] <= 8) {
2773  g = bytestream2_get_byteu(&s->g) << 8 - colour_depth[1];
2774  g |= g >> colour_depth[1];
2775  } else {
2776  g = bytestream2_get_be16u(&s->g) >> colour_depth[1] - 8;
2777  }
2778  if (colour_depth[2] <= 8) {
2779  b = bytestream2_get_byteu(&s->g) << 8 - colour_depth[2];
2780  b |= b >> colour_depth[2];
2781  } else {
2782  b = bytestream2_get_be16u(&s->g) >> colour_depth[2] - 8;
2783  }
2784  s->palette[i] = 0xffu << 24 | r << 16 | g << 8 | b;
2785  }
2786  } else if (atom2 == MKBETAG('c','d','e','f') && atom2_size >= 2) {
2787  int n = bytestream2_get_be16u(&s->g);
2788  for (; n>0; n--) {
2789  int cn = bytestream2_get_be16(&s->g);
2790  av_unused int typ = bytestream2_get_be16(&s->g);
2791  int asoc = bytestream2_get_be16(&s->g);
2792  if (cn < 4 && asoc < 4)
2793  s->cdef[cn] = asoc;
2794  }
2795  } else if (atom2 == MKBETAG('r','e','s',' ') && atom2_size >= 18) {
2796  int64_t vnum, vden, hnum, hden, vexp, hexp;
2797  uint32_t resx;
2798  bytestream2_skip(&s->g, 4);
2799  resx = bytestream2_get_be32u(&s->g);
2800  if (resx != MKBETAG('r','e','s','c') && resx != MKBETAG('r','e','s','d')) {
2801  bytestream2_seek(&s->g, atom2_end, SEEK_SET);
2802  continue;
2803  }
2804  vnum = bytestream2_get_be16u(&s->g);
2805  vden = bytestream2_get_be16u(&s->g);
2806  hnum = bytestream2_get_be16u(&s->g);
2807  hden = bytestream2_get_be16u(&s->g);
2808  vexp = bytestream2_get_byteu(&s->g);
2809  hexp = bytestream2_get_byteu(&s->g);
2810  if (!vnum || !vden || !hnum || !hden) {
2811  bytestream2_seek(&s->g, atom2_end, SEEK_SET);
2812  av_log(s->avctx, AV_LOG_WARNING, "RES box invalid\n");
2813  continue;
2814  }
2815  if (vexp > hexp) {
2816  vexp -= hexp;
2817  hexp = 0;
2818  } else {
2819  hexp -= vexp;
2820  vexp = 0;
2821  }
2822  if ( INT64_MAX / (hnum * vden) > pow(10, hexp)
2823  && INT64_MAX / (vnum * hden) > pow(10, vexp))
2824  av_reduce(&s->sar.den, &s->sar.num,
2825  hnum * vden * pow(10, hexp),
2826  vnum * hden * pow(10, vexp),
2827  INT32_MAX);
2828  }
2829  bytestream2_seek(&s->g, atom2_end, SEEK_SET);
2830  } while (atom_end - atom2_end >= 8);
2831  } else {
2832  search_range--;
2833  }
2834  bytestream2_seek(&s->g, atom_end, SEEK_SET);
2835  }
2836 
2837  return 0;
2838 }
2839 
2840 static av_cold int jpeg2000_decode_init(AVCodecContext *avctx)
2841 {
2842  Jpeg2000DecoderContext *s = avctx->priv_data;
2843 
2844  if (avctx->lowres)
2845  av_log(avctx, AV_LOG_WARNING, "lowres is overridden by reduction_factor but set anyway\n");
2846  if (!s->reduction_factor && avctx->lowres < JPEG2000_MAX_RESLEVELS) {
2847  s->reduction_factor = avctx->lowres;
2848  }
2849  if (avctx->lowres != s->reduction_factor && avctx->lowres)
2850  return AVERROR(EINVAL);
2851 
2852  ff_jpeg2000dsp_init(&s->dsp);
2853  ff_jpeg2000_init_tier1_luts();
2854 
2855  return 0;
2856 }
2857 
2858 static int jpeg2000_decode_frame(AVCodecContext *avctx, AVFrame *picture,
2859  int *got_frame, AVPacket *avpkt)
2860 {
2861  Jpeg2000DecoderContext *s = avctx->priv_data;
2862  int ret;
2863 
2864  s->avctx = avctx;
2865  bytestream2_init(&s->g, avpkt->data, avpkt->size);
2866  s->curtileno = -1;
2867  memset(s->cdef, -1, sizeof(s->cdef));
2868 
2869  if (bytestream2_get_bytes_left(&s->g) < 2) {
2870  ret = AVERROR_INVALIDDATA;
2871  goto end;
2872  }
2873 
2874  // check if the image is in jp2 format
2875  if (bytestream2_get_bytes_left(&s->g) >= 12 &&
2876  (bytestream2_get_be32u(&s->g) == 12) &&
2877  (bytestream2_get_be32u(&s->g) == JP2_SIG_TYPE) &&
2878  (bytestream2_get_be32u(&s->g) == JP2_SIG_VALUE)) {
2879  if (!jp2_find_codestream(s)) {
2880  av_log(avctx, AV_LOG_ERROR,
2881  "Could not find Jpeg2000 codestream atom.\n");
2882  ret = AVERROR_INVALIDDATA;
2883  goto end;
2884  }
2885  } else {
2886  bytestream2_seek(&s->g, 0, SEEK_SET);
2887  }
2888 
2889  while (bytestream2_get_bytes_left(&s->g) >= 3 && bytestream2_peek_be16(&s->g) != JPEG2000_SOC)
2890  bytestream2_skip(&s->g, 1);
2891 
2892  if (bytestream2_get_be16u(&s->g) != JPEG2000_SOC) {
2893  av_log(avctx, AV_LOG_ERROR, "SOC marker not present\n");
2894  ret = AVERROR_INVALIDDATA;
2895  goto end;
2896  }
2897  if (ret = jpeg2000_read_main_headers(s))
2898  goto end;
2899 
2900  if (s->sar.num && s->sar.den)
2901  avctx->sample_aspect_ratio = s->sar;
2902  s->sar.num = s->sar.den = 0;
2903 
2904  if (avctx->skip_frame >= AVDISCARD_ALL) {
2905  jpeg2000_dec_cleanup(s);
2906  return avpkt->size;
2907  }
2908 
2909  /* get picture buffer */
2910  if ((ret = ff_thread_get_buffer(avctx, picture, 0)) < 0)
2911  goto end;
2912 
2913  if (ret = jpeg2000_read_bitstream_packets(s))
2914  goto end;
2915 
2916  for (int x = 0; x < s->ncomponents && s->codsty[x].transform == FF_DWT53;)
2917  if (++x == s->ncomponents)
2918  picture->flags |= AV_FRAME_FLAG_LOSSLESS;
2919 
2920  avctx->execute2(avctx, jpeg2000_decode_tile, picture, NULL, s->numXtiles * s->numYtiles);
2921 
2922  jpeg2000_dec_cleanup(s);
2923 
2924  *got_frame = 1;
2925 
2926  if (s->avctx->pix_fmt == AV_PIX_FMT_PAL8)
2927  memcpy(picture->data[1], s->palette, 256 * sizeof(uint32_t));
2928 
2929  return bytestream2_tell(&s->g);
2930 
2931 end:
2932  jpeg2000_dec_cleanup(s);
2933  return ret;
2934 }
2935 
2936 #define OFFSET(x) offsetof(Jpeg2000DecoderContext, x)
2937 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
2938 
2939 static const AVOption options[] = {
2940  { "lowres", "Lower the decoding resolution by a power of two",
2941  OFFSET(reduction_factor), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, JPEG2000_MAX_RESLEVELS - 1, VD },
2942  { NULL },
2943 };
2944 
2945 static const AVClass jpeg2000_class = {
2946  .class_name = "jpeg2000",
2947  .item_name = av_default_item_name,
2948  .option = options,
2949  .version = LIBAVUTIL_VERSION_INT,
2950 };
2951 
2952 const FFCodec ff_jpeg2000_decoder = {
2953  .p.name = "jpeg2000",
2954  CODEC_LONG_NAME("JPEG 2000"),
2955  .p.type = AVMEDIA_TYPE_VIDEO,
2956  .p.id = AV_CODEC_ID_JPEG2000,
2957  .p.capabilities = AV_CODEC_CAP_SLICE_THREADS | AV_CODEC_CAP_FRAME_THREADS | AV_CODEC_CAP_DR1,
2958  .priv_data_size = sizeof(Jpeg2000DecoderContext),
2959  .init = jpeg2000_decode_init,
2960  FF_CODEC_DECODE_CB(jpeg2000_decode_frame),
2961  .p.priv_class = &jpeg2000_class,
2962  .p.max_lowres = 5,
2963  .p.profiles = NULL_IF_CONFIG_SMALL(ff_jpeg2000_profiles),
2964  .caps_internal = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
2965 };
tile_codeblocks
static int tile_codeblocks(const Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
Definition: jpeg2000dec.c:2242
FF_ENABLE_DEPRECATION_WARNINGS
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:73
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:216
Jpeg2000POCEntry::CEpoc
uint16_t CEpoc
Definition: jpeg2000dec.h:37
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
options
static const AVOption options[]
Definition: jpeg2000dec.c:2939
Jpeg2000Cblk::nb_terminationsinc
int nb_terminationsinc
Definition: jpeg2000.h:195
av_clip
#define av_clip
Definition: common.h:100
ff_dwt_decode
int ff_dwt_decode(DWTContext *s, void *t)
Definition: jpeg2000dwt.c:601
r
const char * r
Definition: vf_curves.c:127
JPEG2000_POC
@ JPEG2000_POC
Definition: jpeg2000.h:51
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
opt.h
HAD_COC
#define HAD_COC
Definition: jpeg2000dec.c:54
AV_PIX_FMT_YA8
@ AV_PIX_FMT_YA8
8 bits gray, 8 bits alpha
Definition: pixfmt.h:140
JP2_HEADER
#define JP2_HEADER
Definition: jpeg2000dec.c:52
Jpeg2000Cblk::pass_lengths
int pass_lengths[2]
Definition: jpeg2000.h:202
Jpeg2000QuantStyle::quantsty
uint8_t quantsty
Definition: jpeg2000.h:164
bytestream2_get_bytes_left
static av_always_inline int bytestream2_get_bytes_left(const GetByteContext *g)
Definition: bytestream.h:158
Jpeg2000Prec::decoded_layers
int decoded_layers
Definition: jpeg2000.h:213
AV_PROFILE_JPEG2000_DCINEMA_4K
#define AV_PROFILE_JPEG2000_DCINEMA_4K
Definition: defs.h:152
JPEG2000_EOC
@ JPEG2000_EOC
Definition: jpeg2000.h:60
comp
static void comp(unsigned char *dst, ptrdiff_t dst_stride, unsigned char *src, ptrdiff_t src_stride, int add)
Definition: eamad.c:79
JPEG2000_MAX_RESLEVELS
#define JPEG2000_MAX_RESLEVELS
Definition: jpeg2000.h:79
bytestream2_tell
static av_always_inline int bytestream2_tell(const GetByteContext *g)
Definition: bytestream.h:192
JPEG2000_QSTY_NONE
@ JPEG2000_QSTY_NONE
Definition: jpeg2000.h:73
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:3456
JPEG2000_QCD
@ JPEG2000_QCD
Definition: jpeg2000.h:48
Jpeg2000Prec::nb_codeblocks_height
int nb_codeblocks_height
Definition: jpeg2000.h:209
Jpeg2000Cblk::coord
int coord[2][2]
Definition: jpeg2000.h:199
bytestream2_skipu
static av_always_inline void bytestream2_skipu(GetByteContext *g, unsigned int size)
Definition: bytestream.h:174
int64_t
long long int64_t
Definition: coverity.c:34
av_unused
#define av_unused
Definition: attributes.h:164
mask
int mask
Definition: mediacodecdec_common.c:154
HTJ2K_HTONLY
@ HTJ2K_HTONLY
Definition: jpeg2000.h:64
Jpeg2000Band::i_stepsize
int i_stepsize
Definition: jpeg2000.h:220
needs_termination
static int needs_termination(int style, int passno)
Definition: jpeg2000.h:302
Jpeg2000Cblk::nb_lengthinc
uint8_t nb_lengthinc
Definition: jpeg2000.h:190
decode_refpass
static void decode_refpass(Jpeg2000T1Context *t1, int width, int height, int bpno, int vert_causal_ctx_csty_symbol)
Definition: jpeg2000dec.c:1933
bytestream2_seek
static av_always_inline int bytestream2_seek(GetByteContext *g, int offset, int whence)
Definition: bytestream.h:212
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:435
YUV_PIXEL_FORMATS
#define YUV_PIXEL_FORMATS
Definition: jpeg2000dec.c:175
pixdesc.h
u
#define u(width, name, range_min, range_max)
Definition: cbs_apv.c:68
AVPacket::data
uint8_t * data
Definition: packet.h:595
Jpeg2000Prec::zerobits
Jpeg2000TgtNode * zerobits
Definition: jpeg2000.h:210
AVOption
AVOption.
Definition: opt.h:429
Jpeg2000POCEntry::REpoc
uint8_t REpoc
Definition: jpeg2000dec.h:39
JPEG2000_SOD
@ JPEG2000_SOD
Definition: jpeg2000.h:59
b
#define b
Definition: input.c:43
JPEG2000_SOC
@ JPEG2000_SOC
Definition: jpeg2000.h:39
JPEG2000_CSTY_PREC
#define JPEG2000_CSTY_PREC
Definition: jpeg2000.h:118
getlblockinc
static int getlblockinc(Jpeg2000DecoderContext *s)
Definition: jpeg2000dec.c:1116
HTJ2K_MIXED
@ HTJ2K_MIXED
Definition: jpeg2000.h:66
JPEG2000_PPM
@ JPEG2000_PPM
Definition: jpeg2000.h:52
FF_COMPLIANCE_STRICT
#define FF_COMPLIANCE_STRICT
Strictly conform to all the things in the spec no matter what consequences.
Definition: defs.h:59
ff_jpeg2000_ceildiv
static int ff_jpeg2000_ceildiv(int a, int64_t b)
Definition: jpeg2000.h:249
FFCodec
Definition: codec_internal.h:127
dequantization_float
static void dequantization_float(int x, int y, Jpeg2000Cblk *cblk, Jpeg2000Component *comp, Jpeg2000T1Context *t1, Jpeg2000Band *band, const int M_b)
Definition: jpeg2000dec.c:2128
ff_jpeg2000_profiles
const AVProfile ff_jpeg2000_profiles[]
Definition: profiles.c:107
Jpeg2000Prec
Definition: jpeg2000.h:207
JPEG2000_CBLK_TERMALL
#define JPEG2000_CBLK_TERMALL
Definition: jpeg2000.h:112
JPEG2000_SOT
@ JPEG2000_SOT
Definition: jpeg2000.h:56
Jpeg2000POCEntry
Definition: jpeg2000dec.h:34
Jpeg2000TgtNode::parent
struct Jpeg2000TgtNode * parent
Definition: jpeg2000.h:142
Jpeg2000Band
Definition: jpeg2000.h:217
FF_DWT97
@ FF_DWT97
Definition: jpeg2000dwt.h:38
AVFrame::flags
int flags
Frame flags, a combination of AV_FRAME_FLAGS.
Definition: frame.h:679
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
jpeg2000_decode_tile
static int jpeg2000_decode_tile(AVCodecContext *avctx, void *td, int jobnr, int threadnr)
Definition: jpeg2000dec.c:2401
JPEG2000_CSTY_SOP
#define JPEG2000_CSTY_SOP
Definition: jpeg2000.h:119
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:91
Jpeg2000POCEntry::CSpoc
uint16_t CSpoc
Definition: jpeg2000dec.h:36
Jpeg2000Tile
Definition: j2kenc.c:108
ff_jpeg2000_getrefctxno
static int ff_jpeg2000_getrefctxno(int flag)
Definition: jpeg2000.h:277
thread.h
getnpasses
static int getnpasses(Jpeg2000DecoderContext *s)
Definition: jpeg2000dec.c:1101
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:456
Jpeg2000T1Context::mqc
MqcState mqc
Definition: jpeg2000.h:134
Jpeg2000Cblk::incl
uint8_t incl
Definition: jpeg2000.h:187
Jpeg2000CodingStyle::init
uint8_t init
Definition: jpeg2000.h:158
jpeg2000_read_main_headers
static int jpeg2000_read_main_headers(Jpeg2000DecoderContext *s)
Definition: jpeg2000dec.c:2458
bytestream2_skip
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
Definition: bytestream.h:168
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
Jpeg2000CodingStyle::log2_cblk_width
uint8_t log2_cblk_width
Definition: jpeg2000.h:148
jpeg2000htdec.h
AVCodecContext::skip_frame
enum AVDiscard skip_frame
Skip decoding for selected frames.
Definition: avcodec.h:1674
ff_mqc_initdec
void ff_mqc_initdec(MqcState *mqc, uint8_t *bp, int raw, int reset)
Initialize MQ-decoder.
Definition: mqcdec.c:71
get_poc
static int get_poc(Jpeg2000DecoderContext *s, int size, Jpeg2000POC *p)
Definition: jpeg2000dec.c:788
HT_MIXED
#define HT_MIXED
Definition: jpeg2000dec.c:63
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:1902
val
static double val(void *priv, double ch)
Definition: aeval.c:77
Jpeg2000Cblk::zbp
int zbp
Definition: jpeg2000.h:201
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:1574
MQC_CX_UNI
#define MQC_CX_UNI
Definition: mqc.h:33
AV_PIX_FMT_GRAY16
#define AV_PIX_FMT_GRAY16
Definition: pixfmt.h:522
dequantization_int
static void dequantization_int(int x, int y, Jpeg2000Cblk *cblk, Jpeg2000Component *comp, Jpeg2000T1Context *t1, Jpeg2000Band *band, const int M_b)
Definition: jpeg2000dec.c:2150
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
Jpeg2000T1Context
Definition: jpeg2000.h:131
jpeg2000_read_bitstream_packets
static int jpeg2000_read_bitstream_packets(Jpeg2000DecoderContext *s)
Definition: jpeg2000dec.c:2673
av_image_check_size2
int av_image_check_size2(unsigned int w, unsigned int h, int64_t max_pixels, enum AVPixelFormat pix_fmt, int log_offset, void *log_ctx)
Check if the given dimension of an image is valid, meaning that all bytes of a plane of an image with...
Definition: imgutils.c:289
jpeg2000_class
static const AVClass jpeg2000_class
Definition: jpeg2000dec.c:2945
JPEG2000_CPF
@ JPEG2000_CPF
Definition: jpeg2000.h:47
read_crg
static int read_crg(Jpeg2000DecoderContext *s, int n)
Definition: jpeg2000dec.c:903
avassert.h
AV_LOG_TRACE
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
Definition: log.h:236
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:210
Jpeg2000ResLevel
Definition: jpeg2000.h:225
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_cold
#define av_cold
Definition: attributes.h:119
FF_CODEC_PROPERTY_LOSSLESS
#define FF_CODEC_PROPERTY_LOSSLESS
Definition: avcodec.h:1650
get_siz
static int get_siz(Jpeg2000DecoderContext *s)
Definition: jpeg2000dec.c:200
jpeg2000_dec_cleanup
static void jpeg2000_dec_cleanup(Jpeg2000DecoderContext *s)
Definition: jpeg2000dec.c:2430
Jpeg2000CodingStyle::cblk_style
uint8_t cblk_style
Definition: jpeg2000.h:154
Jpeg2000QuantStyle::nguardbits
uint8_t nguardbits
Definition: jpeg2000.h:165
float
float
Definition: af_crystalizer.c:122
Jpeg2000POCEntry::Ppoc
uint8_t Ppoc
Definition: jpeg2000dec.h:40
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:347
read_cpf
static int read_cpf(Jpeg2000DecoderContext *s, int n)
Definition: jpeg2000dec.c:913
Jpeg2000CodingStyle::transform
uint8_t transform
Definition: jpeg2000.h:150
s
#define s(width, name)
Definition: cbs_vp9.c:198
I_PRESHIFT
#define I_PRESHIFT
Definition: jpeg2000dwt.h:35
AV_PIX_FMT_YUVA420P
@ AV_PIX_FMT_YUVA420P
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
Definition: pixfmt.h:108
av_realloc_array
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
Definition: mem.c:217
Jpeg2000ResLevel::band
Jpeg2000Band * band
Definition: jpeg2000.h:230
g
const char * g
Definition: vf_curves.c:128
pix_fmt
static enum AVPixelFormat pix_fmt
Definition: demux_decode.c:41
get_cox
static int get_cox(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c)
Definition: jpeg2000dec.c:516
jpeg2000.h
ff_thread_get_buffer
int ff_thread_get_buffer(AVCodecContext *avctx, AVFrame *f, int flags)
Wrapper around get_buffer() for frame-multithreaded codecs.
Definition: pthread_frame.c:1044
JPEG2000_PGOD_RPCL
#define JPEG2000_PGOD_RPCL
Definition: jpeg2000.h:127
ff_jpeg2000dsp_init
av_cold void ff_jpeg2000dsp_init(Jpeg2000DSPContext *c)
Definition: jpeg2000dsp.c:93
Jpeg2000Cblk::data
uint8_t * data
Definition: jpeg2000.h:192
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:42
P
#define P
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:231
Jpeg2000Band::coord
int coord[2][2]
Definition: jpeg2000.h:218
decode.h
JP2_CODESTREAM
#define JP2_CODESTREAM
Definition: jpeg2000dec.c:51
Jpeg2000Band::f_stepsize
float f_stepsize
Definition: jpeg2000.h:221
av_mallocz
#define av_mallocz(s)
Definition: tableprint_vlc.h:31
get_cap
static int get_cap(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c)
Definition: jpeg2000dec.c:448
RSHIFT
#define RSHIFT(a, b)
Definition: common.h:56
JPEG2000_COM
@ JPEG2000_COM
Definition: jpeg2000.h:55
JPEG2000_PGOD_CPRL
#define JPEG2000_PGOD_CPRL
Definition: jpeg2000.h:129
JPEG2000_QSTY_SI
@ JPEG2000_QSTY_SI
Definition: jpeg2000.h:74
av_fallthrough
#define av_fallthrough
Definition: attributes.h:67
dequantization_int_97
static void dequantization_int_97(int x, int y, Jpeg2000Cblk *cblk, Jpeg2000Component *comp, Jpeg2000T1Context *t1, Jpeg2000Band *band, const int M_b)
Definition: jpeg2000dec.c:2183
JPEG2000_CRG
@ JPEG2000_CRG
Definition: jpeg2000.h:54
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:332
tmp
static uint8_t tmp[40]
Definition: aes_ctr.c:52
gray_pix_fmts
static enum AVPixelFormat gray_pix_fmts[]
Definition: jpeg2000dec.c:189
JPEG2000_CBLK_BYPASS
#define JPEG2000_CBLK_BYPASS
Definition: jpeg2000.h:110
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:74
if
if(ret)
Definition: filter_design.txt:179
init_tile
static int init_tile(Jpeg2000DecoderContext *s, int tileno)
Definition: jpeg2000dec.c:1044
AV_CODEC_CAP_FRAME_THREADS
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: codec.h:95
AVDISCARD_ALL
@ AVDISCARD_ALL
discard all
Definition: defs.h:232
JPEG2000_T1_SIG_S
#define JPEG2000_T1_SIG_S
Definition: jpeg2000.h:88
Jpeg2000Cblk::lblock
uint8_t lblock
Definition: jpeg2000.h:191
AV_PIX_FMT_RGBA64
#define AV_PIX_FMT_RGBA64
Definition: pixfmt.h:529
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
Jpeg2000Cblk::length
uint16_t length
Definition: jpeg2000.h:188
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:76
jpeg2000_decode_init
static av_cold int jpeg2000_decode_init(AVCodecContext *avctx)
Definition: jpeg2000dec.c:2840
NULL
#define NULL
Definition: coverity.c:32
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
Jpeg2000POC
Definition: jpeg2000dec.h:43
get_ppm
static int get_ppm(Jpeg2000DecoderContext *s, int n)
Definition: jpeg2000dec.c:986
JP2_SIG_TYPE
#define JP2_SIG_TYPE
Definition: jpeg2000dec.c:49
MqcState::bp
uint8_t * bp
Definition: mqc.h:41
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:242
JPEG2000_PLM
@ JPEG2000_PLM
Definition: jpeg2000.h:45
profiles.h
Jpeg2000Band::prec
Jpeg2000Prec * prec
Definition: jpeg2000.h:222
options
Definition: swscale.c:45
JPEG2000_T1_VIS
#define JPEG2000_T1_VIS
Definition: jpeg2000.h:103
Jpeg2000ResLevel::num_precincts_y
int num_precincts_y
Definition: jpeg2000.h:228
get_ppt
static int get_ppt(Jpeg2000DecoderContext *s, int n)
Definition: jpeg2000dec.c:1010
JPEG2000_EPH
@ JPEG2000_EPH
Definition: jpeg2000.h:58
JPEG2000_PPT
@ JPEG2000_PPT
Definition: jpeg2000.h:53
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:81
JPEG2000_CBLK_RESET
#define JPEG2000_CBLK_RESET
Definition: jpeg2000.h:111
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
AVPALETTE_COUNT
#define AVPALETTE_COUNT
Definition: pixfmt.h:33
JPEG2000_T1_SIG_NB
#define JPEG2000_T1_SIG_NB
Definition: jpeg2000.h:93
Jpeg2000Prec::nb_codeblocks_width
int nb_codeblocks_width
Definition: jpeg2000.h:208
ff_jpeg2000_decode_htj2k
int ff_jpeg2000_decode_htj2k(const Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *codsty, Jpeg2000T1Context *t1, Jpeg2000Cblk *cblk, int width, int height, int M_b, uint8_t roi_shift)
HT Block decoder as specified in Rec.
Definition: jpeg2000htdec.c:1189
tag_tree_decode
static int tag_tree_decode(Jpeg2000DecoderContext *s, Jpeg2000TgtNode *node, int threshold)
Definition: jpeg2000dec.c:93
JPEG2000_T1_SIG_SE
#define JPEG2000_T1_SIG_SE
Definition: jpeg2000.h:91
Jpeg2000TilePart::tp_end
const uint8_t * tp_end
Definition: jpeg2000dec.h:51
decode_cblk
static int decode_cblk(const Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *codsty, Jpeg2000T1Context *t1, Jpeg2000Cblk *cblk, int width, int height, int bandpos, uint8_t roi_shift, const int M_b)
Definition: jpeg2000dec.c:2023
Jpeg2000ResLevel::log2_prec_height
uint8_t log2_prec_height
Definition: jpeg2000.h:229
AVCodecContext::lowres
int lowres
low resolution decoding, 1-> 1/2 size, 2->1/4 size
Definition: avcodec.h:1709
ff_jpeg2000_cleanup
void ff_jpeg2000_cleanup(Jpeg2000Component *comp, Jpeg2000CodingStyle *codsty)
Definition: jpeg2000.c:601
Jpeg2000Cblk::modes
uint8_t modes
Definition: jpeg2000.h:203
ff_jpeg2000_init_component
int ff_jpeg2000_init_component(Jpeg2000Component *comp, Jpeg2000CodingStyle *codsty, Jpeg2000QuantStyle *qntsty, const int cbps, int dx, int dy, AVCodecContext *avctx)
Definition: jpeg2000.c:470
get_qcd
static int get_qcd(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q, const uint8_t *properties)
Definition: jpeg2000dec.c:749
Jpeg2000Component
Definition: jpeg2000.h:233
JPEG2000_T1_SIG_SW
#define JPEG2000_T1_SIG_SW
Definition: jpeg2000.h:92
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:551
AV_PIX_FMT_RGB24
@ AV_PIX_FMT_RGB24
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:75
Jpeg2000Prec::cblkincl
Jpeg2000TgtNode * cblkincl
Definition: jpeg2000.h:211
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
OFFSET
#define OFFSET(x)
Definition: jpeg2000dec.c:2936
AVPacket::size
int size
Definition: packet.h:596
JPEG2000_CTSY_HTJ2K_M
#define JPEG2000_CTSY_HTJ2K_M
Definition: jpeg2000.h:122
get_qcc
static int get_qcc(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q, uint8_t *properties)
Definition: jpeg2000dec.c:767
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:94
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:99
height
#define height
Definition: dsp.h:89
codec_internal.h
i
#define i(width, name, range_min, range_max)
Definition: cbs_h264.c:63
Jpeg2000ResLevel::nbands
uint8_t nbands
Definition: jpeg2000.h:226
AV_PIX_FMT_RGB48
#define AV_PIX_FMT_RGB48
Definition: pixfmt.h:525
size
int size
Definition: twinvq_data.h:10344
Jpeg2000Cblk
Definition: jpeg2000.h:183
MKBETAG
#define MKBETAG(a, b, c, d)
Definition: macros.h:56
FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM
#define FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM
The decoder extracts and fills its parameters even if the frame is skipped due to the skip_frame sett...
Definition: codec_internal.h:55
xyz_pix_fmts
static enum AVPixelFormat xyz_pix_fmts[]
Definition: jpeg2000dec.c:191
AVFrame::format
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames,...
Definition: frame.h:522
jpeg2000_decode_frame
static int jpeg2000_decode_frame(AVCodecContext *avctx, AVFrame *picture, int *got_frame, AVPacket *avpkt)
Definition: jpeg2000dec.c:2858
HT_PLHD_OFF
@ HT_PLHD_OFF
Definition: jpeg2000dec.c:59
get_rgn
static int get_rgn(Jpeg2000DecoderContext *s, int n)
Definition: jpeg2000dec.c:671
Jpeg2000TilePart::tile_index
uint8_t tile_index
Definition: jpeg2000dec.h:50
HT_PLHD_STATUS
HT_PLHD_STATUS
Definition: jpeg2000dec.c:58
AV_CODEC_CAP_SLICE_THREADS
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: codec.h:99
JPEG2000_COD
@ JPEG2000_COD
Definition: jpeg2000.h:42
ff_jpeg2000_getsgnctxno
static int ff_jpeg2000_getsgnctxno(int flag, int *xorbit)
Definition: jpeg2000.h:286
attributes.h
all_pix_fmts
static enum AVPixelFormat all_pix_fmts[]
Definition: jpeg2000dec.c:193
Jpeg2000T1Context::stride
int stride
Definition: jpeg2000.h:135
JPEG2000_PGOD_LRCP
#define JPEG2000_PGOD_LRCP
Definition: jpeg2000.h:125
Jpeg2000TgtNode
Definition: jpeg2000.h:138
HAD_QCC
#define HAD_QCC
Definition: jpeg2000dec.c:55
Jpeg2000Cblk::data_start
int * data_start
Definition: jpeg2000.h:196
Jpeg2000CodingStyle::csty
uint8_t csty
Definition: jpeg2000.h:151
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:221
Jpeg2000CodingStyle::nreslevels
int nreslevels
Definition: jpeg2000.h:146
jpeg2000_decode_packet
static int jpeg2000_decode_packet(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile, int *tp_index, const Jpeg2000CodingStyle *codsty, Jpeg2000ResLevel *rlevel, int precno, int layno, const uint8_t *expn, int numgbits)
Definition: jpeg2000dec.c:1164
AV_PIX_FMT_XYZ12
#define AV_PIX_FMT_XYZ12
Definition: pixfmt.h:599
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:68
jpeg2000dec.h
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:133
JPEG2000_PGOD_RLCP
#define JPEG2000_PGOD_RLCP
Definition: jpeg2000.h:126
AV_PIX_FMT_YA16
#define AV_PIX_FMT_YA16
Definition: pixfmt.h:524
get_plt
static int get_plt(Jpeg2000DecoderContext *s, int n)
Definition: jpeg2000dec.c:964
HTJ2K_HTDECLARED
@ HTJ2K_HTDECLARED
Definition: jpeg2000.h:65
Jpeg2000ResLevel::num_precincts_x
int num_precincts_x
Definition: jpeg2000.h:228
JPEG2000_RGN
@ JPEG2000_RGN
Definition: jpeg2000.h:50
jp2_find_codestream
static int jp2_find_codestream(Jpeg2000DecoderContext *s)
Definition: jpeg2000dec.c:2691
JPEG2000_T1_REF
#define JPEG2000_T1_REF
Definition: jpeg2000.h:105
Jpeg2000QuantStyle::expn
uint8_t expn[JPEG2000_MAX_DECLEVELS *3]
Definition: jpeg2000.h:162
get_coc
static int get_coc(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c, uint8_t *properties)
Definition: jpeg2000dec.c:636
bytestream2_size
static av_always_inline int bytestream2_size(const GetByteContext *g)
Definition: bytestream.h:202
common.h
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:58
JP2_SIG_VALUE
#define JP2_SIG_VALUE
Definition: jpeg2000dec.c:50
JPEG2000_CAP
@ JPEG2000_CAP
Definition: jpeg2000.h:40
JPEG2000_SOP_FIXED_BYTES
#define JPEG2000_SOP_FIXED_BYTES
Definition: jpeg2000.h:69
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
JPEG2000_SIZ
@ JPEG2000_SIZ
Definition: jpeg2000.h:41
Jpeg2000T1Context::data
int data[6144]
Definition: jpeg2000.h:132
Jpeg2000TilePart
Definition: jpeg2000dec.h:49
WRITE_FRAME
#define WRITE_FRAME(D, PIXEL)
Definition: jpeg2000dec.c:2331
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:179
ff_jpeg2000_getsigctxno
static int ff_jpeg2000_getsigctxno(int flag, int bandno)
Definition: jpeg2000.h:268
VD
#define VD
Definition: jpeg2000dec.c:2937
len
int len
Definition: vorbis_enc_data.h:426
AV_CODEC_ID_JPEG2000
@ AV_CODEC_ID_JPEG2000
Definition: codec_id.h:140
JPEG2000_MAX_PASSES
#define JPEG2000_MAX_PASSES
Definition: jpeg2000.h:81
GRAY_PIXEL_FORMATS
#define GRAY_PIXEL_FORMATS
Definition: jpeg2000dec.c:174
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:264
Jpeg2000QuantStyle::mant
uint16_t mant[JPEG2000_MAX_DECLEVELS *3]
Definition: jpeg2000.h:163
avcodec.h
JPEG2000_T1_SIG
#define JPEG2000_T1_SIG
Definition: jpeg2000.h:104
AV_PIX_FMT_PAL8
@ AV_PIX_FMT_PAL8
8 bits with AV_PIX_FMT_RGB32 palette
Definition: pixfmt.h:84
JPEG2000_PLT
@ JPEG2000_PLT
Definition: jpeg2000.h:46
ret
ret
Definition: filter_design.txt:187
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:81
AV_PROFILE_JPEG2000_DCINEMA_2K
#define AV_PROFILE_JPEG2000_DCINEMA_2K
Definition: defs.h:151
tile
static int FUNC() tile(CodedBitstreamContext *ctx, RWContext *rw, APVRawTile *current, int tile_idx, uint32_t tile_size)
Definition: cbs_apv_syntax_template.c:224
U
#define U(x)
Definition: vpx_arith.h:37
MQC_CX_RL
#define MQC_CX_RL
Definition: mqc.h:34
Jpeg2000T1Context::flags
uint16_t flags[6156]
Definition: jpeg2000.h:133
Jpeg2000TilePart::tpg
GetByteContext tpg
Definition: jpeg2000dec.h:53
AVCodecContext
main external API structure.
Definition: avcodec.h:439
FF_DWT53
@ FF_DWT53
Definition: jpeg2000dwt.h:39
JPEG2000_CBLK_VSC
#define JPEG2000_CBLK_VSC
Definition: jpeg2000.h:113
ff_jpeg2000_ceildivpow2
static int ff_jpeg2000_ceildivpow2(int a, int b)
Definition: jpeg2000.h:244
jpeg2000dsp.h
Jpeg2000ResLevel::log2_prec_width
uint8_t log2_prec_width
Definition: jpeg2000.h:229
jpeg2000_flush
static void jpeg2000_flush(Jpeg2000DecoderContext *s)
Definition: jpeg2000dec.c:85
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
RGB_PIXEL_FORMATS
#define RGB_PIXEL_FORMATS
Definition: jpeg2000dec.c:173
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Underlying C type is int.
Definition: opt.h:259
ff_jpeg2000_init_tier1_luts
void av_cold ff_jpeg2000_init_tier1_luts(void)
Definition: jpeg2000.c:173
Jpeg2000POCEntry::LYEpoc
uint16_t LYEpoc
Definition: jpeg2000dec.h:35
JPEG2000_T1_SGN_S
#define JPEG2000_T1_SGN_S
Definition: jpeg2000.h:99
JPEG2000_CSTY_EPH
#define JPEG2000_CSTY_EPH
Definition: jpeg2000.h:120
Windows::Graphics::DirectX::Direct3D11::p
IDirect3DDxgiInterfaceAccess _COM_Outptr_ void ** p
Definition: vsrc_gfxcapture_winrt.hpp:53
XYZ_PIXEL_FORMATS
#define XYZ_PIXEL_FORMATS
Definition: jpeg2000dec.c:186
Jpeg2000Cblk::nb_terminations
int nb_terminations
Definition: jpeg2000.h:194
av_realloc
#define av_realloc(p, s)
Definition: ops_asmgen.c:46
FF_DISABLE_DEPRECATION_WARNINGS
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:72
Jpeg2000POCEntry::RSpoc
uint8_t RSpoc
Definition: jpeg2000dec.h:38
desc
const char * desc
Definition: libsvtav1.c:83
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:200
AV_PIX_FMT_GRAY16LE
@ AV_PIX_FMT_GRAY16LE
Y , 16bpp, little-endian.
Definition: pixfmt.h:105
mem.h
bytestream2_get_bufferu
static av_always_inline unsigned int bytestream2_get_bufferu(GetByteContext *g, uint8_t *dst, unsigned int size)
Definition: bytestream.h:277
JPEG2000_COC
@ JPEG2000_COC
Definition: jpeg2000.h:43
JPEG2000_PGOD_PCRL
#define JPEG2000_PGOD_PCRL
Definition: jpeg2000.h:128
AV_CODEC_FLAG_BITEXACT
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:322
JPEG2000_MAX_DECLEVELS
#define JPEG2000_MAX_DECLEVELS
Definition: jpeg2000.h:78
ff_mqc_decode
int ff_mqc_decode(MqcState *mqc, uint8_t *cxstate)
MQ decoder.
Definition: mqcdec.c:93
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:37
jpeg2000_decode_packets
static int jpeg2000_decode_packets(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
Definition: jpeg2000dec.c:1865
mct_decode
static void mct_decode(const Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
Definition: jpeg2000dec.c:2213
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
MqcState::cx_states
uint8_t cx_states[19]
Definition: mqc.h:45
w
uint8_t w
Definition: llvidencdsp.c:39
ff_jpeg2000_decoder
const FFCodec ff_jpeg2000_decoder
Definition: jpeg2000dec.c:2952
get_sot
static int get_sot(Jpeg2000DecoderContext *s, int n)
Definition: jpeg2000dec.c:850
Jpeg2000Cblk::npasses
uint8_t npasses
Definition: jpeg2000.h:184
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
scale
static void scale(int *out, const int *in, const int w, const int h, const int shift)
Definition: intra.c:278
yuv_pix_fmts
static enum AVPixelFormat yuv_pix_fmts[]
Definition: jpeg2000dec.c:190
Jpeg2000CodingStyle::nreslevels2decode
int nreslevels2decode
Definition: jpeg2000.h:147
AVPacket
This structure stores compressed data.
Definition: packet.h:572
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:466
JPEG2000_QCC
@ JPEG2000_QCC
Definition: jpeg2000.h:49
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
ff_jpeg2000_set_significance
void ff_jpeg2000_set_significance(Jpeg2000T1Context *t1, int x, int y, int negative)
Definition: jpeg2000.c:179
int32_t
int32_t
Definition: audioconvert.c:56
bytestream.h
imgutils.h
bytestream2_init
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:137
AVERROR_BUG
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
Definition: error.h:52
Jpeg2000TgtNode::val
uint8_t val
Definition: jpeg2000.h:139
MqcState::raw
int raw
Definition: mqc.h:46
Jpeg2000TgtNode::vis
uint8_t vis
Definition: jpeg2000.h:141
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
MAX_POCS
#define MAX_POCS
Definition: jpeg2000dec.h:32
Jpeg2000CodingStyle
Definition: jpeg2000.h:145
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
SP
static uint64_t SP[8][256]
Definition: camellia.c:44
Jpeg2000Cblk::lengthinc
uint16_t * lengthinc
Definition: jpeg2000.h:189
select_stream
static void select_stream(Jpeg2000DecoderContext *s, const Jpeg2000Tile *tile, int *tp_index, const Jpeg2000CodingStyle *codsty)
Definition: jpeg2000dec.c:1139
Jpeg2000QuantStyle
Definition: jpeg2000.h:161
JPEG2000_SOP_BYTE_LENGTH
#define JPEG2000_SOP_BYTE_LENGTH
Definition: jpeg2000.h:70
rgb_pix_fmts
static enum AVPixelFormat rgb_pix_fmts[]
Definition: jpeg2000dec.c:188
Jpeg2000DecoderContext
Definition: jpeg2000dec.h:73
width
#define width
Definition: dsp.h:89
Jpeg2000Cblk::ht_plhd
uint8_t ht_plhd
Definition: jpeg2000.h:204
decode_clnpass
static void decode_clnpass(const Jpeg2000DecoderContext *s, Jpeg2000T1Context *t1, int width, int height, int bpno, int bandno, int seg_symbols, int vert_causal_ctx_csty_symbol)
Definition: jpeg2000dec.c:1959
Jpeg2000Cblk::nonzerobits
uint8_t nonzerobits
Definition: jpeg2000.h:186
get_qcx
static int get_qcx(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q)
Definition: jpeg2000dec.c:704
Jpeg2000Prec::cblk
Jpeg2000Cblk * cblk
Definition: jpeg2000.h:212
JPEG2000_CTSY_HTJ2K_F
#define JPEG2000_CTSY_HTJ2K_F
Definition: jpeg2000.h:121
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:120
get_tlm
static int get_tlm(Jpeg2000DecoderContext *s, int n)
Definition: jpeg2000dec.c:929
AV_FRAME_FLAG_LOSSLESS
#define AV_FRAME_FLAG_LOSSLESS
A decoder can use this flag to mark frames which were originally encoded losslessly.
Definition: frame.h:671
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:1622
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
ff_mqc_init_contexts
void ff_mqc_init_contexts(MqcState *mqc)
MQ-coder context initialisations.
Definition: mqc.c:64
get_bits
static int get_bits(Jpeg2000DecoderContext *s, int n)
Definition: jpeg2000dec.c:70
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:624
JPEG2000_CBLK_SEGSYM
#define JPEG2000_CBLK_SEGSYM
Definition: jpeg2000.h:115
FF_DWT97_INT
@ FF_DWT97_INT
Definition: jpeg2000dwt.h:40
select_header
static void select_header(Jpeg2000DecoderContext *s, const Jpeg2000Tile *tile, int *tp_index)
Definition: jpeg2000dec.c:1127
src
#define src
Definition: vp8dsp.c:248
get_cod
static int get_cod(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c, const uint8_t *properties)
Definition: jpeg2000dec.c:599
Jpeg2000Cblk::data_allocated
size_t data_allocated
Definition: jpeg2000.h:193
JPEG2000_TLM
@ JPEG2000_TLM
Definition: jpeg2000.h:44
Jpeg2000TilePart::header_tpg
GetByteContext header_tpg
Definition: jpeg2000dec.h:52
HT_PLHD_ON
@ HT_PLHD_ON
Definition: jpeg2000dec.c:60
Generated on Sat May 2 2026 19:22:31 for FFmpeg by   doxygen 1.8.17