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