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