FFmpeg  2.1.1
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 "libavutil/avassert.h"
29 #include "libavutil/common.h"
30 #include "libavutil/opt.h"
31 #include "libavutil/pixdesc.h"
32 #include "avcodec.h"
33 #include "bytestream.h"
34 #include "internal.h"
35 #include "thread.h"
36 #include "jpeg2000.h"
37 
38 #define JP2_SIG_TYPE 0x6A502020
39 #define JP2_SIG_VALUE 0x0D0A870A
40 #define JP2_CODESTREAM 0x6A703263
41 #define JP2_HEADER 0x6A703268
42 
43 #define HAD_COC 0x01
44 #define HAD_QCC 0x02
45 
46 typedef struct Jpeg2000TilePart {
47  uint8_t tile_index; // Tile index who refers the tile-part
48  const uint8_t *tp_end;
49  GetByteContext tpg; // bit stream in tile-part
51 
52 /* RMK: For JPEG2000 DCINEMA 3 tile-parts in a tile
53  * one per component, so tile_part elements have a size of 3 */
54 typedef struct Jpeg2000Tile {
60  uint16_t tp_idx; // Tile-part index
61 } Jpeg2000Tile;
62 
63 typedef struct Jpeg2000DecoderContext {
64  AVClass *class;
67 
68  int width, height;
71  uint8_t cbps[4]; // bits per sample in particular components
72  uint8_t sgnd[4]; // if a component is signed
74  int cdx[4], cdy[4];
75  int precision;
78  uint32_t palette[256];
79  int8_t pal8;
80  int cdef[4];
82  unsigned numXtiles, numYtiles;
84 
87 
88  int bit_index;
89 
90  int curtileno;
91 
93 
94  /*options parameters*/
97 
98 /* get_bits functions for JPEG2000 packet bitstream
99  * It is a get_bit function with a bit-stuffing routine. If the value of the
100  * byte is 0xFF, the next byte includes an extra zero bit stuffed into the MSB.
101  * cf. ISO-15444-1:2002 / B.10.1 Bit-stuffing routine */
103 {
104  int res = 0;
105 
106  while (--n >= 0) {
107  res <<= 1;
108  if (s->bit_index == 0) {
109  s->bit_index = 7 + (bytestream2_get_byte(&s->g) != 0xFFu);
110  }
111  s->bit_index--;
112  res |= (bytestream2_peek_byte(&s->g) >> s->bit_index) & 1;
113  }
114  return res;
115 }
116 
118 {
119  if (bytestream2_get_byte(&s->g) == 0xff)
120  bytestream2_skip(&s->g, 1);
121  s->bit_index = 8;
122 }
123 
124 /* decode the value stored in node */
126  int threshold)
127 {
128  Jpeg2000TgtNode *stack[30];
129  int sp = -1, curval = 0;
130 
131  if (!node)
132  return AVERROR_INVALIDDATA;
133 
134  while (node && !node->vis) {
135  stack[++sp] = node;
136  node = node->parent;
137  }
138 
139  if (node)
140  curval = node->val;
141  else
142  curval = stack[sp]->val;
143 
144  while (curval < threshold && sp >= 0) {
145  if (curval < stack[sp]->val)
146  curval = stack[sp]->val;
147  while (curval < threshold) {
148  int ret;
149  if ((ret = get_bits(s, 1)) > 0) {
150  stack[sp]->vis++;
151  break;
152  } else if (!ret)
153  curval++;
154  else
155  return ret;
156  }
157  stack[sp]->val = curval;
158  sp--;
159  }
160  return curval;
161 }
162 
163 static int pix_fmt_match(enum AVPixelFormat pix_fmt, int components,
164  int bpc, uint32_t log2_chroma_wh, int pal8)
165 {
166  int match = 1;
167  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
168 
169  if (desc->nb_components != components) {
170  return 0;
171  }
172 
173  switch (components) {
174  case 4:
175  match = match && desc->comp[3].depth_minus1 + 1 >= bpc &&
176  (log2_chroma_wh >> 14 & 3) == 0 &&
177  (log2_chroma_wh >> 12 & 3) == 0;
178  case 3:
179  match = match && desc->comp[2].depth_minus1 + 1 >= bpc &&
180  (log2_chroma_wh >> 10 & 3) == desc->log2_chroma_w &&
181  (log2_chroma_wh >> 8 & 3) == desc->log2_chroma_h;
182  case 2:
183  match = match && desc->comp[1].depth_minus1 + 1 >= bpc &&
184  (log2_chroma_wh >> 6 & 3) == desc->log2_chroma_w &&
185  (log2_chroma_wh >> 4 & 3) == desc->log2_chroma_h;
186 
187  case 1:
188  match = match && desc->comp[0].depth_minus1 + 1 >= bpc &&
189  (log2_chroma_wh >> 2 & 3) == 0 &&
190  (log2_chroma_wh & 3) == 0 &&
191  (desc->flags & AV_PIX_FMT_FLAG_PAL) == pal8 * AV_PIX_FMT_FLAG_PAL;
192  }
193  return match;
194 }
195 
196 // pix_fmts with lower bpp have to be listed before
197 // similar pix_fmts with higher bpp.
198 #define RGB_PIXEL_FORMATS AV_PIX_FMT_PAL8,AV_PIX_FMT_RGB24,AV_PIX_FMT_RGBA,AV_PIX_FMT_RGB48,AV_PIX_FMT_RGBA64
199 #define GRAY_PIXEL_FORMATS AV_PIX_FMT_GRAY8,AV_PIX_FMT_GRAY8A,AV_PIX_FMT_GRAY16
200 #define YUV_PIXEL_FORMATS AV_PIX_FMT_YUV410P,AV_PIX_FMT_YUV411P,AV_PIX_FMT_YUVA420P, \
201  AV_PIX_FMT_YUV420P,AV_PIX_FMT_YUV422P,AV_PIX_FMT_YUVA422P, \
202  AV_PIX_FMT_YUV440P,AV_PIX_FMT_YUV444P,AV_PIX_FMT_YUVA444P, \
203  AV_PIX_FMT_YUV420P9,AV_PIX_FMT_YUV422P9,AV_PIX_FMT_YUV444P9, \
204  AV_PIX_FMT_YUVA420P9,AV_PIX_FMT_YUVA422P9,AV_PIX_FMT_YUVA444P9, \
205  AV_PIX_FMT_YUV420P10,AV_PIX_FMT_YUV422P10,AV_PIX_FMT_YUV444P10, \
206  AV_PIX_FMT_YUVA420P10,AV_PIX_FMT_YUVA422P10,AV_PIX_FMT_YUVA444P10, \
207  AV_PIX_FMT_YUV420P12,AV_PIX_FMT_YUV422P12,AV_PIX_FMT_YUV444P12, \
208  AV_PIX_FMT_YUV420P14,AV_PIX_FMT_YUV422P14,AV_PIX_FMT_YUV444P14, \
209  AV_PIX_FMT_YUV420P16,AV_PIX_FMT_YUV422P16,AV_PIX_FMT_YUV444P16, \
210  AV_PIX_FMT_YUVA420P16,AV_PIX_FMT_YUVA422P16,AV_PIX_FMT_YUVA444P16
211 #define XYZ_PIXEL_FORMATS AV_PIX_FMT_XYZ12
212 
221 
222 /* marker segments */
223 /* get sizes and offsets of image, tiles; number of components */
225 {
226  int i;
227  int ncomponents;
228  uint32_t log2_chroma_wh = 0;
229  const enum AVPixelFormat *possible_fmts = NULL;
230  int possible_fmts_nb = 0;
231 
232  if (bytestream2_get_bytes_left(&s->g) < 36)
233  return AVERROR_INVALIDDATA;
234 
235  s->avctx->profile = bytestream2_get_be16u(&s->g); // Rsiz
236  s->width = bytestream2_get_be32u(&s->g); // Width
237  s->height = bytestream2_get_be32u(&s->g); // Height
238  s->image_offset_x = bytestream2_get_be32u(&s->g); // X0Siz
239  s->image_offset_y = bytestream2_get_be32u(&s->g); // Y0Siz
240  s->tile_width = bytestream2_get_be32u(&s->g); // XTSiz
241  s->tile_height = bytestream2_get_be32u(&s->g); // YTSiz
242  s->tile_offset_x = bytestream2_get_be32u(&s->g); // XT0Siz
243  s->tile_offset_y = bytestream2_get_be32u(&s->g); // YT0Siz
244  ncomponents = bytestream2_get_be16u(&s->g); // CSiz
245 
246  if (s->image_offset_x || s->image_offset_y) {
247  avpriv_request_sample(s->avctx, "Support for image offsets");
248  return AVERROR_PATCHWELCOME;
249  }
250 
251  if (ncomponents <= 0) {
252  av_log(s->avctx, AV_LOG_ERROR, "Invalid number of components: %d\n",
253  s->ncomponents);
254  return AVERROR_INVALIDDATA;
255  }
256 
257  if (ncomponents > 4) {
258  avpriv_request_sample(s->avctx, "Support for %d components",
259  s->ncomponents);
260  return AVERROR_PATCHWELCOME;
261  }
262 
263  s->ncomponents = ncomponents;
264 
265  if (s->tile_width <= 0 || s->tile_height <= 0) {
266  av_log(s->avctx, AV_LOG_ERROR, "Invalid tile dimension %dx%d.\n",
267  s->tile_width, s->tile_height);
268  return AVERROR_INVALIDDATA;
269  }
270 
271  if (bytestream2_get_bytes_left(&s->g) < 3 * s->ncomponents)
272  return AVERROR_INVALIDDATA;
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 
291 
292  if (s->numXtiles * (uint64_t)s->numYtiles > INT_MAX/sizeof(*s->tile)) {
293  s->numXtiles = s->numYtiles = 0;
294  return AVERROR(EINVAL);
295  }
296 
297  s->tile = av_mallocz_array(s->numXtiles * s->numYtiles, sizeof(*s->tile));
298  if (!s->tile) {
299  s->numXtiles = s->numYtiles = 0;
300  return AVERROR(ENOMEM);
301  }
302 
303  for (i = 0; i < s->numXtiles * s->numYtiles; i++) {
304  Jpeg2000Tile *tile = s->tile + i;
305 
306  tile->comp = av_mallocz(s->ncomponents * sizeof(*tile->comp));
307  if (!tile->comp)
308  return AVERROR(ENOMEM);
309  }
310 
311  /* compute image size with reduction factor */
313  s->reduction_factor);
315  s->reduction_factor);
316 
319  possible_fmts = xyz_pix_fmts;
320  possible_fmts_nb = FF_ARRAY_ELEMS(xyz_pix_fmts);
321  } else {
322  switch (s->colour_space) {
323  case 16:
324  possible_fmts = rgb_pix_fmts;
325  possible_fmts_nb = FF_ARRAY_ELEMS(rgb_pix_fmts);
326  break;
327  case 17:
328  possible_fmts = gray_pix_fmts;
329  possible_fmts_nb = FF_ARRAY_ELEMS(gray_pix_fmts);
330  break;
331  case 18:
332  possible_fmts = yuv_pix_fmts;
333  possible_fmts_nb = FF_ARRAY_ELEMS(yuv_pix_fmts);
334  break;
335  default:
336  possible_fmts = all_pix_fmts;
337  possible_fmts_nb = FF_ARRAY_ELEMS(all_pix_fmts);
338  break;
339  }
340  }
341  for (i = 0; i < possible_fmts_nb; ++i) {
342  if (pix_fmt_match(possible_fmts[i], ncomponents, s->precision, log2_chroma_wh, s->pal8)) {
343  s->avctx->pix_fmt = possible_fmts[i];
344  break;
345  }
346  }
347  if (s->avctx->pix_fmt == AV_PIX_FMT_NONE) {
349  "Unknown pix_fmt, profile: %d, colour_space: %d, "
350  "components: %d, precision: %d, "
351  "cdx[1]: %d, cdy[1]: %d, cdx[2]: %d, cdy[2]: %d\n",
352  s->avctx->profile, s->colour_space, ncomponents, s->precision,
353  ncomponents > 2 ? s->cdx[1] : 0,
354  ncomponents > 2 ? s->cdy[1] : 0,
355  ncomponents > 2 ? s->cdx[2] : 0,
356  ncomponents > 2 ? s->cdy[2] : 0);
357  }
359  return 0;
360 }
361 
362 /* get common part for COD and COC segments */
364 {
365  uint8_t byte;
366 
367  if (bytestream2_get_bytes_left(&s->g) < 5)
368  return AVERROR_INVALIDDATA;
369 
370  /* nreslevels = number of resolution levels
371  = number of decomposition level +1 */
372  c->nreslevels = bytestream2_get_byteu(&s->g) + 1;
374  av_log(s->avctx, AV_LOG_ERROR, "nreslevels %d is invalid\n", c->nreslevels);
375  return AVERROR_INVALIDDATA;
376  }
377 
378  if (c->nreslevels <= s->reduction_factor) {
379  /* we are forced to update reduction_factor as its requested value is
380  not compatible with this bitstream, and as we might have used it
381  already in setup earlier we have to fail this frame until
382  reinitialization is implemented */
383  av_log(s->avctx, AV_LOG_ERROR, "reduction_factor too large for this bitstream, max is %d\n", c->nreslevels - 1);
384  s->reduction_factor = c->nreslevels - 1;
385  return AVERROR(EINVAL);
386  }
387 
388  /* compute number of resolution levels to decode */
390 
391  c->log2_cblk_width = (bytestream2_get_byteu(&s->g) & 15) + 2; // cblk width
392  c->log2_cblk_height = (bytestream2_get_byteu(&s->g) & 15) + 2; // cblk height
393 
394  if (c->log2_cblk_width > 10 || c->log2_cblk_height > 10 ||
395  c->log2_cblk_width + c->log2_cblk_height > 12) {
396  av_log(s->avctx, AV_LOG_ERROR, "cblk size invalid\n");
397  return AVERROR_INVALIDDATA;
398  }
399 
400  if (c->log2_cblk_width > 6 || c->log2_cblk_height > 6) {
401  avpriv_request_sample(s->avctx, "cblk size > 64");
402  return AVERROR_PATCHWELCOME;
403  }
404 
405  c->cblk_style = bytestream2_get_byteu(&s->g);
406  if (c->cblk_style != 0) { // cblk style
407  av_log(s->avctx, AV_LOG_WARNING, "extra cblk styles %X\n", c->cblk_style);
408  }
409  c->transform = bytestream2_get_byteu(&s->g); // DWT transformation type
410  /* set integer 9/7 DWT in case of BITEXACT flag */
411  if ((s->avctx->flags & CODEC_FLAG_BITEXACT) && (c->transform == FF_DWT97))
412  c->transform = FF_DWT97_INT;
413 
414  if (c->csty & JPEG2000_CSTY_PREC) {
415  int i;
416  for (i = 0; i < c->nreslevels; i++) {
417  byte = bytestream2_get_byte(&s->g);
418  c->log2_prec_widths[i] = byte & 0x0F; // precinct PPx
419  c->log2_prec_heights[i] = (byte >> 4) & 0x0F; // precinct PPy
420  }
421  } else {
422  memset(c->log2_prec_widths , 15, sizeof(c->log2_prec_widths ));
423  memset(c->log2_prec_heights, 15, sizeof(c->log2_prec_heights));
424  }
425  return 0;
426 }
427 
428 /* get coding parameters for a particular tile or whole image*/
430  uint8_t *properties)
431 {
433  int compno, ret;
434 
435  if (bytestream2_get_bytes_left(&s->g) < 5)
436  return AVERROR_INVALIDDATA;
437 
438  tmp.csty = bytestream2_get_byteu(&s->g);
439 
440  // get progression order
441  tmp.prog_order = bytestream2_get_byteu(&s->g);
442 
443  tmp.nlayers = bytestream2_get_be16u(&s->g);
444  tmp.mct = bytestream2_get_byteu(&s->g); // multiple component transformation
445 
446  if (tmp.mct && s->ncomponents < 3) {
448  "MCT %d with too few components (%d)\n",
449  tmp.mct, s->ncomponents);
450  return AVERROR_INVALIDDATA;
451  }
452 
453  if ((ret = get_cox(s, &tmp)) < 0)
454  return ret;
455 
456  for (compno = 0; compno < s->ncomponents; compno++)
457  if (!(properties[compno] & HAD_COC))
458  memcpy(c + compno, &tmp, sizeof(tmp));
459  return 0;
460 }
461 
462 /* Get coding parameters for a component in the whole image or a
463  * particular tile. */
465  uint8_t *properties)
466 {
467  int compno, ret;
468 
469  if (bytestream2_get_bytes_left(&s->g) < 2)
470  return AVERROR_INVALIDDATA;
471 
472  compno = bytestream2_get_byteu(&s->g);
473 
474  if (compno >= s->ncomponents) {
476  "Invalid compno %d. There are %d components in the image.\n",
477  compno, s->ncomponents);
478  return AVERROR_INVALIDDATA;
479  }
480 
481  c += compno;
482  c->csty = bytestream2_get_byteu(&s->g);
483 
484  if ((ret = get_cox(s, c)) < 0)
485  return ret;
486 
487  properties[compno] |= HAD_COC;
488  return 0;
489 }
490 
491 /* Get common part for QCD and QCC segments. */
493 {
494  int i, x;
495 
496  if (bytestream2_get_bytes_left(&s->g) < 1)
497  return AVERROR_INVALIDDATA;
498 
499  x = bytestream2_get_byteu(&s->g); // Sqcd
500 
501  q->nguardbits = x >> 5;
502  q->quantsty = x & 0x1f;
503 
504  if (q->quantsty == JPEG2000_QSTY_NONE) {
505  n -= 3;
506  if (bytestream2_get_bytes_left(&s->g) < n ||
508  return AVERROR_INVALIDDATA;
509  for (i = 0; i < n; i++)
510  q->expn[i] = bytestream2_get_byteu(&s->g) >> 3;
511  } else if (q->quantsty == JPEG2000_QSTY_SI) {
512  if (bytestream2_get_bytes_left(&s->g) < 2)
513  return AVERROR_INVALIDDATA;
514  x = bytestream2_get_be16u(&s->g);
515  q->expn[0] = x >> 11;
516  q->mant[0] = x & 0x7ff;
517  for (i = 1; i < JPEG2000_MAX_DECLEVELS * 3; i++) {
518  int curexpn = FFMAX(0, q->expn[0] - (i - 1) / 3);
519  q->expn[i] = curexpn;
520  q->mant[i] = q->mant[0];
521  }
522  } else {
523  n = (n - 3) >> 1;
524  if (bytestream2_get_bytes_left(&s->g) < 2 * n ||
526  return AVERROR_INVALIDDATA;
527  for (i = 0; i < n; i++) {
528  x = bytestream2_get_be16u(&s->g);
529  q->expn[i] = x >> 11;
530  q->mant[i] = x & 0x7ff;
531  }
532  }
533  return 0;
534 }
535 
536 /* Get quantization parameters for a particular tile or a whole image. */
538  uint8_t *properties)
539 {
540  Jpeg2000QuantStyle tmp;
541  int compno, ret;
542 
543  if ((ret = get_qcx(s, n, &tmp)) < 0)
544  return ret;
545  for (compno = 0; compno < s->ncomponents; compno++)
546  if (!(properties[compno] & HAD_QCC))
547  memcpy(q + compno, &tmp, sizeof(tmp));
548  return 0;
549 }
550 
551 /* Get quantization parameters for a component in the whole image
552  * on in a particular tile. */
554  uint8_t *properties)
555 {
556  int compno;
557 
558  if (bytestream2_get_bytes_left(&s->g) < 1)
559  return AVERROR_INVALIDDATA;
560 
561  compno = bytestream2_get_byteu(&s->g);
562 
563  if (compno >= s->ncomponents) {
565  "Invalid compno %d. There are %d components in the image.\n",
566  compno, s->ncomponents);
567  return AVERROR_INVALIDDATA;
568  }
569 
570  properties[compno] |= HAD_QCC;
571  return get_qcx(s, n - 1, q + compno);
572 }
573 
574 /* Get start of tile segment. */
576 {
577  Jpeg2000TilePart *tp;
578  uint16_t Isot;
579  uint32_t Psot;
580  uint8_t TPsot;
581 
582  if (bytestream2_get_bytes_left(&s->g) < 8)
583  return AVERROR_INVALIDDATA;
584 
585  s->curtileno = 0;
586  Isot = bytestream2_get_be16u(&s->g); // Isot
587  if (Isot >= s->numXtiles * s->numYtiles)
588  return AVERROR_INVALIDDATA;
589 
590  s->curtileno = Isot;
591  Psot = bytestream2_get_be32u(&s->g); // Psot
592  TPsot = bytestream2_get_byteu(&s->g); // TPsot
593 
594  /* Read TNSot but not used */
595  bytestream2_get_byteu(&s->g); // TNsot
596 
597  if (Psot > bytestream2_get_bytes_left(&s->g) + n + 2) {
598  av_log(s->avctx, AV_LOG_ERROR, "Psot %d too big\n", Psot);
599  return AVERROR_INVALIDDATA;
600  }
601 
602  if (TPsot >= FF_ARRAY_ELEMS(s->tile[Isot].tile_part)) {
603  avpriv_request_sample(s->avctx, "Support for %d components", TPsot);
604  return AVERROR_PATCHWELCOME;
605  }
606 
607  s->tile[Isot].tp_idx = TPsot;
608  tp = s->tile[Isot].tile_part + TPsot;
609  tp->tile_index = Isot;
610  tp->tp_end = s->g.buffer + Psot - n - 2;
611 
612  if (!TPsot) {
613  Jpeg2000Tile *tile = s->tile + s->curtileno;
614 
615  /* copy defaults */
616  memcpy(tile->codsty, s->codsty, s->ncomponents * sizeof(Jpeg2000CodingStyle));
617  memcpy(tile->qntsty, s->qntsty, s->ncomponents * sizeof(Jpeg2000QuantStyle));
618  }
619 
620  return 0;
621 }
622 
623 /* Tile-part lengths: see ISO 15444-1:2002, section A.7.1
624  * Used to know the number of tile parts and lengths.
625  * There may be multiple TLMs in the header.
626  * TODO: The function is not used for tile-parts management, nor anywhere else.
627  * It can be useful to allocate memory for tile parts, before managing the SOT
628  * markers. Parsing the TLM header is needed to increment the input header
629  * buffer.
630  * This marker is mandatory for DCI. */
632 {
633  uint8_t Stlm, ST, SP, tile_tlm, i;
634  bytestream2_get_byte(&s->g); /* Ztlm: skipped */
635  Stlm = bytestream2_get_byte(&s->g);
636 
637  // too complex ? ST = ((Stlm >> 4) & 0x01) + ((Stlm >> 4) & 0x02);
638  ST = (Stlm >> 4) & 0x03;
639  // TODO: Manage case of ST = 0b11 --> raise error
640  SP = (Stlm >> 6) & 0x01;
641  tile_tlm = (n - 4) / ((SP + 1) * 2 + ST);
642  for (i = 0; i < tile_tlm; i++) {
643  switch (ST) {
644  case 0:
645  break;
646  case 1:
647  bytestream2_get_byte(&s->g);
648  break;
649  case 2:
650  bytestream2_get_be16(&s->g);
651  break;
652  case 3:
653  bytestream2_get_be32(&s->g);
654  break;
655  }
656  if (SP == 0) {
657  bytestream2_get_be16(&s->g);
658  } else {
659  bytestream2_get_be32(&s->g);
660  }
661  }
662  return 0;
663 }
664 
665 static int init_tile(Jpeg2000DecoderContext *s, int tileno)
666 {
667  int compno;
668  int tilex = tileno % s->numXtiles;
669  int tiley = tileno / s->numXtiles;
670  Jpeg2000Tile *tile = s->tile + tileno;
671 
672  if (!tile->comp)
673  return AVERROR(ENOMEM);
674 
675  for (compno = 0; compno < s->ncomponents; compno++) {
676  Jpeg2000Component *comp = tile->comp + compno;
677  Jpeg2000CodingStyle *codsty = tile->codsty + compno;
678  Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
679  int ret; // global bandno
680 
681  comp->coord_o[0][0] = FFMAX(tilex * s->tile_width + s->tile_offset_x, s->image_offset_x);
682  comp->coord_o[0][1] = FFMIN((tilex + 1) * s->tile_width + s->tile_offset_x, s->width);
683  comp->coord_o[1][0] = FFMAX(tiley * s->tile_height + s->tile_offset_y, s->image_offset_y);
684  comp->coord_o[1][1] = FFMIN((tiley + 1) * s->tile_height + s->tile_offset_y, s->height);
685 
686  comp->coord[0][0] = ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], s->reduction_factor);
687  comp->coord[0][1] = ff_jpeg2000_ceildivpow2(comp->coord_o[0][1], s->reduction_factor);
688  comp->coord[1][0] = ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], s->reduction_factor);
689  comp->coord[1][1] = ff_jpeg2000_ceildivpow2(comp->coord_o[1][1], s->reduction_factor);
690 
691  if (ret = ff_jpeg2000_init_component(comp, codsty, qntsty,
692  s->cbps[compno], s->cdx[compno],
693  s->cdy[compno], s->avctx))
694  return ret;
695  }
696  return 0;
697 }
698 
699 /* Read the number of coding passes. */
701 {
702  int num;
703  if (!get_bits(s, 1))
704  return 1;
705  if (!get_bits(s, 1))
706  return 2;
707  if ((num = get_bits(s, 2)) != 3)
708  return num < 0 ? num : 3 + num;
709  if ((num = get_bits(s, 5)) != 31)
710  return num < 0 ? num : 6 + num;
711  num = get_bits(s, 7);
712  return num < 0 ? num : 37 + num;
713 }
714 
716 {
717  int res = 0, ret;
718  while (ret = get_bits(s, 1)) {
719  if (ret < 0)
720  return ret;
721  res++;
722  }
723  return res;
724 }
725 
727  Jpeg2000CodingStyle *codsty,
728  Jpeg2000ResLevel *rlevel, int precno,
729  int layno, uint8_t *expn, int numgbits)
730 {
731  int bandno, cblkno, ret, nb_code_blocks;
732 
733  if (!(ret = get_bits(s, 1))) {
734  jpeg2000_flush(s);
735  return 0;
736  } else if (ret < 0)
737  return ret;
738 
739  for (bandno = 0; bandno < rlevel->nbands; bandno++) {
740  Jpeg2000Band *band = rlevel->band + bandno;
741  Jpeg2000Prec *prec = band->prec + precno;
742 
743  if (band->coord[0][0] == band->coord[0][1] ||
744  band->coord[1][0] == band->coord[1][1])
745  continue;
746  nb_code_blocks = prec->nb_codeblocks_height *
747  prec->nb_codeblocks_width;
748  for (cblkno = 0; cblkno < nb_code_blocks; cblkno++) {
749  Jpeg2000Cblk *cblk = prec->cblk + cblkno;
750  int incl, newpasses, llen;
751 
752  if (cblk->npasses)
753  incl = get_bits(s, 1);
754  else
755  incl = tag_tree_decode(s, prec->cblkincl + cblkno, layno + 1) == layno;
756  if (!incl)
757  continue;
758  else if (incl < 0)
759  return incl;
760 
761  if (!cblk->npasses) {
762  int v = expn[bandno] + numgbits - 1 -
763  tag_tree_decode(s, prec->zerobits + cblkno, 100);
764  if (v < 0) {
766  "nonzerobits %d invalid\n", v);
767  return AVERROR_INVALIDDATA;
768  }
769  cblk->nonzerobits = v;
770  }
771  if ((newpasses = getnpasses(s)) < 0)
772  return newpasses;
773  if ((llen = getlblockinc(s)) < 0)
774  return llen;
775  cblk->lblock += llen;
776  if ((ret = get_bits(s, av_log2(newpasses) + cblk->lblock)) < 0)
777  return ret;
778  if (ret > sizeof(cblk->data)) {
780  "Block with lengthinc greater than %zu",
781  sizeof(cblk->data));
782  return AVERROR_PATCHWELCOME;
783  }
784  cblk->lengthinc = ret;
785  cblk->npasses += newpasses;
786  }
787  }
788  jpeg2000_flush(s);
789 
790  if (codsty->csty & JPEG2000_CSTY_EPH) {
791  if (bytestream2_peek_be16(&s->g) == JPEG2000_EPH)
792  bytestream2_skip(&s->g, 2);
793  else
794  av_log(s->avctx, AV_LOG_ERROR, "EPH marker not found.\n");
795  }
796 
797  for (bandno = 0; bandno < rlevel->nbands; bandno++) {
798  Jpeg2000Band *band = rlevel->band + bandno;
799  Jpeg2000Prec *prec = band->prec + precno;
800 
801  nb_code_blocks = prec->nb_codeblocks_height * prec->nb_codeblocks_width;
802  for (cblkno = 0; cblkno < nb_code_blocks; cblkno++) {
803  Jpeg2000Cblk *cblk = prec->cblk + cblkno;
804  if ( bytestream2_get_bytes_left(&s->g) < cblk->lengthinc
805  || sizeof(cblk->data) < cblk->length + cblk->lengthinc + 2
806  ) {
808  "Block length %d or lengthinc %d is too large\n",
809  cblk->length, cblk->lengthinc);
810  return AVERROR_INVALIDDATA;
811  }
812 
813  bytestream2_get_bufferu(&s->g, cblk->data + cblk->length, cblk->lengthinc);
814  cblk->length += cblk->lengthinc;
815  cblk->lengthinc = 0;
816  }
817  }
818  return 0;
819 }
820 
822 {
823  int ret = 0;
824  int layno, reslevelno, compno, precno, ok_reslevel;
825  int x, y;
826 
827  s->bit_index = 8;
828  switch (tile->codsty[0].prog_order) {
829  case JPEG2000_PGOD_RLCP:
830  avpriv_request_sample(s->avctx, "Progression order RLCP");
831 
832  case JPEG2000_PGOD_LRCP:
833  for (layno = 0; layno < tile->codsty[0].nlayers; layno++) {
834  ok_reslevel = 1;
835  for (reslevelno = 0; ok_reslevel; reslevelno++) {
836  ok_reslevel = 0;
837  for (compno = 0; compno < s->ncomponents; compno++) {
838  Jpeg2000CodingStyle *codsty = tile->codsty + compno;
839  Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
840  if (reslevelno < codsty->nreslevels) {
841  Jpeg2000ResLevel *rlevel = tile->comp[compno].reslevel +
842  reslevelno;
843  ok_reslevel = 1;
844  for (precno = 0; precno < rlevel->num_precincts_x * rlevel->num_precincts_y; precno++)
845  if ((ret = jpeg2000_decode_packet(s,
846  codsty, rlevel,
847  precno, layno,
848  qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
849  qntsty->nguardbits)) < 0)
850  return ret;
851  }
852  }
853  }
854  }
855  break;
856 
857  case JPEG2000_PGOD_CPRL:
858  for (compno = 0; compno < s->ncomponents; compno++) {
859  Jpeg2000CodingStyle *codsty = tile->codsty + compno;
860  Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
861 
862  /* Set bit stream buffer address according to tile-part.
863  * For DCinema one tile-part per component, so can be
864  * indexed by component. */
865  s->g = tile->tile_part[compno].tpg;
866 
867  /* Position loop (y axis)
868  * TODO: Automate computing of step 256.
869  * Fixed here, but to be computed before entering here. */
870  for (y = 0; y < s->height; y += 256) {
871  /* Position loop (y axis)
872  * TODO: automate computing of step 256.
873  * Fixed here, but to be computed before entering here. */
874  for (x = 0; x < s->width; x += 256) {
875  for (reslevelno = 0; reslevelno < codsty->nreslevels; reslevelno++) {
876  uint16_t prcx, prcy;
877  uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
878  Jpeg2000ResLevel *rlevel = tile->comp[compno].reslevel + reslevelno;
879 
880  if (!((y % (1 << (rlevel->log2_prec_height + reducedresno)) == 0) ||
881  (y == 0))) // TODO: 2nd condition simplified as try0 always =0 for dcinema
882  continue;
883 
884  if (!((x % (1 << (rlevel->log2_prec_width + reducedresno)) == 0) ||
885  (x == 0))) // TODO: 2nd condition simplified as try0 always =0 for dcinema
886  continue;
887 
888  // check if a precinct exists
889  prcx = ff_jpeg2000_ceildivpow2(x, reducedresno) >> rlevel->log2_prec_width;
890  prcy = ff_jpeg2000_ceildivpow2(y, reducedresno) >> rlevel->log2_prec_height;
891  precno = prcx + rlevel->num_precincts_x * prcy;
892  for (layno = 0; layno < tile->codsty[0].nlayers; layno++) {
893  if ((ret = jpeg2000_decode_packet(s, codsty, rlevel,
894  precno, layno,
895  qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
896  qntsty->nguardbits)) < 0)
897  return ret;
898  }
899  }
900  }
901  }
902  }
903  break;
904 
905  case JPEG2000_PGOD_RPCL:
906  avpriv_request_sample(s->avctx, "Progression order RPCL");
907  ret = AVERROR_PATCHWELCOME;
908  break;
909 
910  case JPEG2000_PGOD_PCRL:
911  avpriv_request_sample(s->avctx, "Progression order PCRL");
912  ret = AVERROR_PATCHWELCOME;
913  break;
914 
915  default:
916  break;
917  }
918 
919  /* EOC marker reached */
920  bytestream2_skip(&s->g, 2);
921 
922  return ret;
923 }
924 
925 /* TIER-1 routines */
927  int bpno, int bandno, int bpass_csty_symbol,
928  int vert_causal_ctx_csty_symbol)
929 {
930  int mask = 3 << (bpno - 1), y0, x, y;
931 
932  for (y0 = 0; y0 < height; y0 += 4)
933  for (x = 0; x < width; x++)
934  for (y = y0; y < height && y < y0 + 4; y++) {
935  if ((t1->flags[y+1][x+1] & JPEG2000_T1_SIG_NB)
936  && !(t1->flags[y+1][x+1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS))) {
937  int flags_mask = -1;
938  if (vert_causal_ctx_csty_symbol && y == y0 + 3)
940  if (ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ff_jpeg2000_getsigctxno(t1->flags[y+1][x+1] & flags_mask, bandno))) {
941  int xorbit, ctxno = ff_jpeg2000_getsgnctxno(t1->flags[y+1][x+1], &xorbit);
942  if (bpass_csty_symbol)
943  t1->data[y][x] = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ctxno) ? -mask : mask;
944  else
945  t1->data[y][x] = (ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ctxno) ^ xorbit) ?
946  -mask : mask;
947 
949  t1->data[y][x] < 0);
950  }
951  t1->flags[y + 1][x + 1] |= JPEG2000_T1_VIS;
952  }
953  }
954 }
955 
957  int bpno)
958 {
959  int phalf, nhalf;
960  int y0, x, y;
961 
962  phalf = 1 << (bpno - 1);
963  nhalf = -phalf;
964 
965  for (y0 = 0; y0 < height; y0 += 4)
966  for (x = 0; x < width; x++)
967  for (y = y0; y < height && y < y0 + 4; y++)
968  if ((t1->flags[y + 1][x + 1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS)) == JPEG2000_T1_SIG) {
969  int ctxno = ff_jpeg2000_getrefctxno(t1->flags[y + 1][x + 1]);
970  int r = ff_mqc_decode(&t1->mqc,
971  t1->mqc.cx_states + ctxno)
972  ? phalf : nhalf;
973  t1->data[y][x] += t1->data[y][x] < 0 ? -r : r;
974  t1->flags[y + 1][x + 1] |= JPEG2000_T1_REF;
975  }
976 }
977 
979  int width, int height, int bpno, int bandno,
980  int seg_symbols, int vert_causal_ctx_csty_symbol)
981 {
982  int mask = 3 << (bpno - 1), y0, x, y, runlen, dec;
983 
984  for (y0 = 0; y0 < height; y0 += 4) {
985  for (x = 0; x < width; x++) {
986  if (y0 + 3 < height &&
987  !((t1->flags[y0 + 1][x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
988  (t1->flags[y0 + 2][x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
989  (t1->flags[y0 + 3][x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
990  (t1->flags[y0 + 4][x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)))) {
991  if (!ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_RL))
992  continue;
993  runlen = ff_mqc_decode(&t1->mqc,
994  t1->mqc.cx_states + MQC_CX_UNI);
995  runlen = (runlen << 1) | ff_mqc_decode(&t1->mqc,
996  t1->mqc.cx_states +
997  MQC_CX_UNI);
998  dec = 1;
999  } else {
1000  runlen = 0;
1001  dec = 0;
1002  }
1003 
1004  for (y = y0 + runlen; y < y0 + 4 && y < height; y++) {
1005  if (!dec) {
1006  if (!(t1->flags[y+1][x+1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS))) {
1007  int flags_mask = -1;
1008  if (vert_causal_ctx_csty_symbol && y == y0 + 3)
1010  dec = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ff_jpeg2000_getsigctxno(t1->flags[y+1][x+1] & flags_mask,
1011  bandno));
1012  }
1013  }
1014  if (dec) {
1015  int xorbit;
1016  int ctxno = ff_jpeg2000_getsgnctxno(t1->flags[y + 1][x + 1],
1017  &xorbit);
1018  t1->data[y][x] = (ff_mqc_decode(&t1->mqc,
1019  t1->mqc.cx_states + ctxno) ^
1020  xorbit)
1021  ? -mask : mask;
1022  ff_jpeg2000_set_significance(t1, x, y, t1->data[y][x] < 0);
1023  }
1024  dec = 0;
1025  t1->flags[y + 1][x + 1] &= ~JPEG2000_T1_VIS;
1026  }
1027  }
1028  }
1029  if (seg_symbols) {
1030  int val;
1031  val = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1032  val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1033  val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1034  val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1035  if (val != 0xa)
1037  "Segmentation symbol value incorrect\n");
1038  }
1039 }
1040 
1043  int width, int height, int bandpos)
1044 {
1045  int passno = cblk->npasses, pass_t = 2, bpno = cblk->nonzerobits - 1, y;
1046  int clnpass_cnt = 0;
1047  int bpass_csty_symbol = codsty->cblk_style & JPEG2000_CBLK_BYPASS;
1048  int vert_causal_ctx_csty_symbol = codsty->cblk_style & JPEG2000_CBLK_VSC;
1049 
1050  av_assert0(width <= JPEG2000_MAX_CBLKW);
1051  av_assert0(height <= JPEG2000_MAX_CBLKH);
1052 
1053  for (y = 0; y < height; y++)
1054  memset(t1->data[y], 0, width * sizeof(**t1->data));
1055 
1056  /* If code-block contains no compressed data: nothing to do. */
1057  if (!cblk->length)
1058  return 0;
1059 
1060  for (y = 0; y < height + 2; y++)
1061  memset(t1->flags[y], 0, (width + 2) * sizeof(**t1->flags));
1062 
1063  cblk->data[cblk->length] = 0xff;
1064  cblk->data[cblk->length+1] = 0xff;
1065  ff_mqc_initdec(&t1->mqc, cblk->data);
1066 
1067  while (passno--) {
1068  switch(pass_t) {
1069  case 0:
1070  decode_sigpass(t1, width, height, bpno + 1, bandpos,
1071  bpass_csty_symbol && (clnpass_cnt >= 4),
1072  vert_causal_ctx_csty_symbol);
1073  break;
1074  case 1:
1075  decode_refpass(t1, width, height, bpno + 1);
1076  if (bpass_csty_symbol && clnpass_cnt >= 4)
1077  ff_mqc_initdec(&t1->mqc, cblk->data);
1078  break;
1079  case 2:
1080  decode_clnpass(s, t1, width, height, bpno + 1, bandpos,
1081  codsty->cblk_style & JPEG2000_CBLK_SEGSYM,
1082  vert_causal_ctx_csty_symbol);
1083  clnpass_cnt = clnpass_cnt + 1;
1084  if (bpass_csty_symbol && clnpass_cnt >= 4)
1085  ff_mqc_initdec(&t1->mqc, cblk->data);
1086  break;
1087  }
1088 
1089  pass_t++;
1090  if (pass_t == 3) {
1091  bpno--;
1092  pass_t = 0;
1093  }
1094  }
1095  return 0;
1096 }
1097 
1098 /* TODO: Verify dequantization for lossless case
1099  * comp->data can be float or int
1100  * band->stepsize can be float or int
1101  * depending on the type of DWT transformation.
1102  * see ISO/IEC 15444-1:2002 A.6.1 */
1103 
1104 /* Float dequantization of a codeblock.*/
1105 static void dequantization_float(int x, int y, Jpeg2000Cblk *cblk,
1108 {
1109  int i, j;
1110  int w = cblk->coord[0][1] - cblk->coord[0][0];
1111  for (j = 0; j < (cblk->coord[1][1] - cblk->coord[1][0]); ++j) {
1112  float *datap = &comp->f_data[(comp->coord[0][1] - comp->coord[0][0]) * (y + j) + x];
1113  int *src = t1->data[j];
1114  for (i = 0; i < w; ++i)
1115  datap[i] = src[i] * band->f_stepsize;
1116  }
1117 }
1118 
1119 /* Integer dequantization of a codeblock.*/
1120 static void dequantization_int(int x, int y, Jpeg2000Cblk *cblk,
1123 {
1124  int i, j;
1125  int w = cblk->coord[0][1] - cblk->coord[0][0];
1126  for (j = 0; j < (cblk->coord[1][1] - cblk->coord[1][0]); ++j) {
1127  int32_t *datap = &comp->i_data[(comp->coord[0][1] - comp->coord[0][0]) * (y + j) + x];
1128  int *src = t1->data[j];
1129  for (i = 0; i < w; ++i)
1130  datap[i] = (src[i] * band->i_stepsize + (1 << 14)) >> 15;
1131  }
1132 }
1133 
1134 /* Inverse ICT parameters in float and integer.
1135  * int value = (float value) * (1<<16) */
1136 static const float f_ict_params[4] = {
1137  1.402f,
1138  0.34413f,
1139  0.71414f,
1140  1.772f
1141 };
1142 static const int i_ict_params[4] = {
1143  91881,
1144  22553,
1145  46802,
1146  116130
1147 };
1148 
1150 {
1151  int i, csize = 1;
1152  int32_t *src[3], i0, i1, i2;
1153  float *srcf[3], i0f, i1f, i2f;
1154 
1155  for (i = 1; i < 3; i++)
1156  if (tile->codsty[0].transform != tile->codsty[i].transform) {
1157  av_log(s->avctx, AV_LOG_ERROR, "Transforms mismatch, MCT not supported\n");
1158  return;
1159  }
1160 
1161  for (i = 0; i < 3; i++)
1162  if (tile->codsty[0].transform == FF_DWT97)
1163  srcf[i] = tile->comp[i].f_data;
1164  else
1165  src [i] = tile->comp[i].i_data;
1166 
1167  for (i = 0; i < 2; i++)
1168  csize *= tile->comp[0].coord[i][1] - tile->comp[0].coord[i][0];
1169 
1170  switch (tile->codsty[0].transform) {
1171  case FF_DWT97:
1172  for (i = 0; i < csize; i++) {
1173  i0f = *srcf[0] + (f_ict_params[0] * *srcf[2]);
1174  i1f = *srcf[0] - (f_ict_params[1] * *srcf[1])
1175  - (f_ict_params[2] * *srcf[2]);
1176  i2f = *srcf[0] + (f_ict_params[3] * *srcf[1]);
1177  *srcf[0]++ = i0f;
1178  *srcf[1]++ = i1f;
1179  *srcf[2]++ = i2f;
1180  }
1181  break;
1182  case FF_DWT97_INT:
1183  for (i = 0; i < csize; i++) {
1184  i0 = *src[0] + (((i_ict_params[0] * *src[2]) + (1 << 15)) >> 16);
1185  i1 = *src[0] - (((i_ict_params[1] * *src[1]) + (1 << 15)) >> 16)
1186  - (((i_ict_params[2] * *src[2]) + (1 << 15)) >> 16);
1187  i2 = *src[0] + (((i_ict_params[3] * *src[1]) + (1 << 15)) >> 16);
1188  *src[0]++ = i0;
1189  *src[1]++ = i1;
1190  *src[2]++ = i2;
1191  }
1192  break;
1193  case FF_DWT53:
1194  for (i = 0; i < csize; i++) {
1195  i1 = *src[0] - (*src[2] + *src[1] >> 2);
1196  i0 = i1 + *src[2];
1197  i2 = i1 + *src[1];
1198  *src[0]++ = i0;
1199  *src[1]++ = i1;
1200  *src[2]++ = i2;
1201  }
1202  break;
1203  }
1204 }
1205 
1207  AVFrame *picture)
1208 {
1209  int compno, reslevelno, bandno;
1210  int x, y;
1211 
1212  uint8_t *line;
1214 
1215  /* Loop on tile components */
1216  for (compno = 0; compno < s->ncomponents; compno++) {
1217  Jpeg2000Component *comp = tile->comp + compno;
1218  Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1219 
1220  /* Loop on resolution levels */
1221  for (reslevelno = 0; reslevelno < codsty->nreslevels2decode; reslevelno++) {
1222  Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1223  /* Loop on bands */
1224  for (bandno = 0; bandno < rlevel->nbands; bandno++) {
1225  int nb_precincts, precno;
1226  Jpeg2000Band *band = rlevel->band + bandno;
1227  int cblkno = 0, bandpos;
1228 
1229  bandpos = bandno + (reslevelno > 0);
1230 
1231  if (band->coord[0][0] == band->coord[0][1] ||
1232  band->coord[1][0] == band->coord[1][1])
1233  continue;
1234 
1235  nb_precincts = rlevel->num_precincts_x * rlevel->num_precincts_y;
1236  /* Loop on precincts */
1237  for (precno = 0; precno < nb_precincts; precno++) {
1238  Jpeg2000Prec *prec = band->prec + precno;
1239 
1240  /* Loop on codeblocks */
1241  for (cblkno = 0; cblkno < prec->nb_codeblocks_width * prec->nb_codeblocks_height; cblkno++) {
1242  int x, y;
1243  Jpeg2000Cblk *cblk = prec->cblk + cblkno;
1244  decode_cblk(s, codsty, &t1, cblk,
1245  cblk->coord[0][1] - cblk->coord[0][0],
1246  cblk->coord[1][1] - cblk->coord[1][0],
1247  bandpos);
1248 
1249  x = cblk->coord[0][0];
1250  y = cblk->coord[1][0];
1251 
1252  if (codsty->transform == FF_DWT97)
1253  dequantization_float(x, y, cblk, comp, &t1, band);
1254  else
1255  dequantization_int(x, y, cblk, comp, &t1, band);
1256  } /* end cblk */
1257  } /*end prec */
1258  } /* end band */
1259  } /* end reslevel */
1260 
1261  /* inverse DWT */
1262  ff_dwt_decode(&comp->dwt, codsty->transform == FF_DWT97 ? (void*)comp->f_data : (void*)comp->i_data);
1263  } /*end comp */
1264 
1265  /* inverse MCT transformation */
1266  if (tile->codsty[0].mct)
1267  mct_decode(s, tile);
1268 
1269  if (s->cdef[0] < 0) {
1270  for (x = 0; x < s->ncomponents; x++)
1271  s->cdef[x] = x + 1;
1272  if ((s->ncomponents & 1) == 0)
1273  s->cdef[s->ncomponents-1] = 0;
1274  }
1275 
1276  if (s->precision <= 8) {
1277  for (compno = 0; compno < s->ncomponents; compno++) {
1278  Jpeg2000Component *comp = tile->comp + compno;
1279  Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1280  float *datap = comp->f_data;
1281  int32_t *i_datap = comp->i_data;
1282  int cbps = s->cbps[compno];
1283  int w = tile->comp[compno].coord[0][1] - s->image_offset_x;
1284  int planar = !!picture->data[2];
1285  int pixelsize = planar ? 1 : s->ncomponents;
1286  int plane = 0;
1287 
1288  if (planar)
1289  plane = s->cdef[compno] ? s->cdef[compno]-1 : (s->ncomponents-1);
1290 
1291 
1292  y = tile->comp[compno].coord[1][0] - s->image_offset_y;
1293  line = picture->data[plane] + y / s->cdy[compno] * picture->linesize[plane];
1294  for (; y < tile->comp[compno].coord[1][1] - s->image_offset_y; y += s->cdy[compno]) {
1295  uint8_t *dst;
1296 
1297  x = tile->comp[compno].coord[0][0] - s->image_offset_x;
1298  dst = line + x / s->cdx[compno] * pixelsize + compno*!planar;
1299 
1300  if (codsty->transform == FF_DWT97) {
1301  for (; x < w; x += s->cdx[compno]) {
1302  int val = lrintf(*datap) + (1 << (cbps - 1));
1303  /* DC level shift and clip see ISO 15444-1:2002 G.1.2 */
1304  val = av_clip(val, 0, (1 << cbps) - 1);
1305  *dst = val << (8 - cbps);
1306  datap++;
1307  dst += pixelsize;
1308  }
1309  } else {
1310  for (; x < w; x += s->cdx[compno]) {
1311  int val = *i_datap + (1 << (cbps - 1));
1312  /* DC level shift and clip see ISO 15444-1:2002 G.1.2 */
1313  val = av_clip(val, 0, (1 << cbps) - 1);
1314  *dst = val << (8 - cbps);
1315  i_datap++;
1316  dst += pixelsize;
1317  }
1318  }
1319  line += picture->linesize[plane];
1320  }
1321  }
1322  } else {
1323  for (compno = 0; compno < s->ncomponents; compno++) {
1324  Jpeg2000Component *comp = tile->comp + compno;
1325  Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1326  float *datap = comp->f_data;
1327  int32_t *i_datap = comp->i_data;
1328  uint16_t *linel;
1329  int cbps = s->cbps[compno];
1330  int w = tile->comp[compno].coord[0][1] - s->image_offset_x;
1331  int planar = !!picture->data[2];
1332  int pixelsize = planar ? 1 : s->ncomponents;
1333  int plane = 0;
1334 
1335  if (planar)
1336  plane = s->cdef[compno] ? s->cdef[compno]-1 : (s->ncomponents-1);
1337 
1338  y = tile->comp[compno].coord[1][0] - s->image_offset_y;
1339  linel = (uint16_t *)picture->data[plane] + y / s->cdy[compno] * (picture->linesize[plane] >> 1);
1340  for (; y < tile->comp[compno].coord[1][1] - s->image_offset_y; y += s->cdy[compno]) {
1341  uint16_t *dst;
1342 
1343  x = tile->comp[compno].coord[0][0] - s->image_offset_x;
1344  dst = linel + (x / s->cdx[compno] * pixelsize + compno*!planar);
1345  if (codsty->transform == FF_DWT97) {
1346  for (; x < w; x += s-> cdx[compno]) {
1347  int val = lrintf(*datap) + (1 << (cbps - 1));
1348  /* DC level shift and clip see ISO 15444-1:2002 G.1.2 */
1349  val = av_clip(val, 0, (1 << cbps) - 1);
1350  /* align 12 bit values in little-endian mode */
1351  *dst = val << (16 - cbps);
1352  datap++;
1353  dst += pixelsize;
1354  }
1355  } else {
1356  for (; x < w; x += s-> cdx[compno]) {
1357  int val = *i_datap + (1 << (cbps - 1));
1358  /* DC level shift and clip see ISO 15444-1:2002 G.1.2 */
1359  val = av_clip(val, 0, (1 << cbps) - 1);
1360  /* align 12 bit values in little-endian mode */
1361  *dst = val << (16 - cbps);
1362  i_datap++;
1363  dst += pixelsize;
1364  }
1365  }
1366  linel += picture->linesize[plane] >> 1;
1367  }
1368  }
1369  }
1370 
1371  return 0;
1372 }
1373 
1375 {
1376  int tileno, compno;
1377  for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++) {
1378  if (s->tile[tileno].comp) {
1379  for (compno = 0; compno < s->ncomponents; compno++) {
1380  Jpeg2000Component *comp = s->tile[tileno].comp + compno;
1381  Jpeg2000CodingStyle *codsty = s->tile[tileno].codsty + compno;
1382 
1383  ff_jpeg2000_cleanup(comp, codsty);
1384  }
1385  av_freep(&s->tile[tileno].comp);
1386  }
1387  }
1388  av_freep(&s->tile);
1389  memset(s->codsty, 0, sizeof(s->codsty));
1390  memset(s->qntsty, 0, sizeof(s->qntsty));
1391  s->numXtiles = s->numYtiles = 0;
1392 }
1393 
1395 {
1396  Jpeg2000CodingStyle *codsty = s->codsty;
1397  Jpeg2000QuantStyle *qntsty = s->qntsty;
1398  uint8_t *properties = s->properties;
1399 
1400  for (;;) {
1401  int len, ret = 0;
1402  uint16_t marker;
1403  int oldpos;
1404 
1405  if (bytestream2_get_bytes_left(&s->g) < 2) {
1406  av_log(s->avctx, AV_LOG_ERROR, "Missing EOC\n");
1407  break;
1408  }
1409 
1410  marker = bytestream2_get_be16u(&s->g);
1411  oldpos = bytestream2_tell(&s->g);
1412 
1413  if (marker == JPEG2000_SOD) {
1414  Jpeg2000Tile *tile;
1415  Jpeg2000TilePart *tp;
1416 
1417  if (!s->tile) {
1418  av_log(s->avctx, AV_LOG_ERROR, "Missing SIZ\n");
1419  return AVERROR_INVALIDDATA;
1420  }
1421  if (s->curtileno < 0) {
1422  av_log(s->avctx, AV_LOG_ERROR, "Missing SOT\n");
1423  return AVERROR_INVALIDDATA;
1424  }
1425 
1426  tile = s->tile + s->curtileno;
1427  tp = tile->tile_part + tile->tp_idx;
1428  if (tp->tp_end < s->g.buffer) {
1429  av_log(s->avctx, AV_LOG_ERROR, "Invalid tpend\n");
1430  return AVERROR_INVALIDDATA;
1431  }
1432  bytestream2_init(&tp->tpg, s->g.buffer, tp->tp_end - s->g.buffer);
1433  bytestream2_skip(&s->g, tp->tp_end - s->g.buffer);
1434 
1435  continue;
1436  }
1437  if (marker == JPEG2000_EOC)
1438  break;
1439 
1440  len = bytestream2_get_be16(&s->g);
1441  if (len < 2 || bytestream2_get_bytes_left(&s->g) < len - 2)
1442  return AVERROR_INVALIDDATA;
1443 
1444  switch (marker) {
1445  case JPEG2000_SIZ:
1446  ret = get_siz(s);
1447  if (!s->tile)
1448  s->numXtiles = s->numYtiles = 0;
1449  break;
1450  case JPEG2000_COC:
1451  ret = get_coc(s, codsty, properties);
1452  break;
1453  case JPEG2000_COD:
1454  ret = get_cod(s, codsty, properties);
1455  break;
1456  case JPEG2000_QCC:
1457  ret = get_qcc(s, len, qntsty, properties);
1458  break;
1459  case JPEG2000_QCD:
1460  ret = get_qcd(s, len, qntsty, properties);
1461  break;
1462  case JPEG2000_SOT:
1463  if (!(ret = get_sot(s, len))) {
1464  av_assert1(s->curtileno >= 0);
1465  codsty = s->tile[s->curtileno].codsty;
1466  qntsty = s->tile[s->curtileno].qntsty;
1467  properties = s->tile[s->curtileno].properties;
1468  }
1469  break;
1470  case JPEG2000_COM:
1471  // the comment is ignored
1472  bytestream2_skip(&s->g, len - 2);
1473  break;
1474  case JPEG2000_TLM:
1475  // Tile-part lengths
1476  ret = get_tlm(s, len);
1477  break;
1478  default:
1480  "unsupported marker 0x%.4X at pos 0x%X\n",
1481  marker, bytestream2_tell(&s->g) - 4);
1482  bytestream2_skip(&s->g, len - 2);
1483  break;
1484  }
1485  if (bytestream2_tell(&s->g) - oldpos != len || ret) {
1487  "error during processing marker segment %.4x\n", marker);
1488  return ret ? ret : -1;
1489  }
1490  }
1491  return 0;
1492 }
1493 
1494 /* Read bit stream packets --> T2 operation. */
1496 {
1497  int ret = 0;
1498  int tileno;
1499 
1500  for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++) {
1501  Jpeg2000Tile *tile = s->tile + tileno;
1502 
1503  if (ret = init_tile(s, tileno))
1504  return ret;
1505 
1506  s->g = tile->tile_part[0].tpg;
1507  if (ret = jpeg2000_decode_packets(s, tile))
1508  return ret;
1509  }
1510 
1511  return 0;
1512 }
1513 
1515 {
1516  uint32_t atom_size, atom, atom_end;
1517  int search_range = 10;
1518 
1519  while (search_range
1520  &&
1521  bytestream2_get_bytes_left(&s->g) >= 8) {
1522  atom_size = bytestream2_get_be32u(&s->g);
1523  atom = bytestream2_get_be32u(&s->g);
1524  atom_end = bytestream2_tell(&s->g) + atom_size - 8;
1525 
1526  if (atom == JP2_CODESTREAM)
1527  return 1;
1528 
1529  if (bytestream2_get_bytes_left(&s->g) < atom_size || atom_end < atom_size)
1530  return 0;
1531 
1532  if (atom == JP2_HEADER &&
1533  atom_size >= 16) {
1534  uint32_t atom2_size, atom2, atom2_end;
1535  do {
1536  atom2_size = bytestream2_get_be32u(&s->g);
1537  atom2 = bytestream2_get_be32u(&s->g);
1538  atom2_end = bytestream2_tell(&s->g) + atom2_size - 8;
1539  if (atom2_size < 8 || atom2_end > atom_end || atom2_end < atom2_size)
1540  break;
1541  if (atom2 == JP2_CODESTREAM) {
1542  return 1;
1543  } else if (atom2 == MKBETAG('c','o','l','r') && atom2_size >= 7) {
1544  int method = bytestream2_get_byteu(&s->g);
1545  bytestream2_skipu(&s->g, 2);
1546  if (method == 1) {
1547  s->colour_space = bytestream2_get_be32u(&s->g);
1548  }
1549  } else if (atom2 == MKBETAG('p','c','l','r') && atom2_size >= 6) {
1550  int i, size, colour_count, colour_channels, colour_depth[3];
1551  uint32_t r, g, b;
1552  colour_count = bytestream2_get_be16u(&s->g);
1553  colour_channels = bytestream2_get_byteu(&s->g);
1554  // FIXME: Do not ignore channel_sign
1555  colour_depth[0] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1;
1556  colour_depth[1] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1;
1557  colour_depth[2] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1;
1558  size = (colour_depth[0] + 7 >> 3) * colour_count +
1559  (colour_depth[1] + 7 >> 3) * colour_count +
1560  (colour_depth[2] + 7 >> 3) * colour_count;
1561  if (colour_count > 256 ||
1562  colour_channels != 3 ||
1563  colour_depth[0] > 16 ||
1564  colour_depth[1] > 16 ||
1565  colour_depth[2] > 16 ||
1566  atom2_size < size) {
1567  avpriv_request_sample(s->avctx, "Unknown palette");
1568  bytestream2_seek(&s->g, atom2_end, SEEK_SET);
1569  continue;
1570  }
1571  s->pal8 = 1;
1572  for (i = 0; i < colour_count; i++) {
1573  if (colour_depth[0] <= 8) {
1574  r = bytestream2_get_byteu(&s->g) << 8 - colour_depth[0];
1575  r |= r >> colour_depth[0];
1576  } else {
1577  r = bytestream2_get_be16u(&s->g) >> colour_depth[0] - 8;
1578  }
1579  if (colour_depth[1] <= 8) {
1580  g = bytestream2_get_byteu(&s->g) << 8 - colour_depth[1];
1581  r |= r >> colour_depth[1];
1582  } else {
1583  g = bytestream2_get_be16u(&s->g) >> colour_depth[1] - 8;
1584  }
1585  if (colour_depth[2] <= 8) {
1586  b = bytestream2_get_byteu(&s->g) << 8 - colour_depth[2];
1587  r |= r >> colour_depth[2];
1588  } else {
1589  b = bytestream2_get_be16u(&s->g) >> colour_depth[2] - 8;
1590  }
1591  s->palette[i] = 0xffu << 24 | r << 16 | g << 8 | b;
1592  }
1593  } else if (atom2 == MKBETAG('c','d','e','f') && atom2_size >= 2) {
1594  int n = bytestream2_get_be16u(&s->g);
1595  for (; n>0; n--) {
1596  int cn = bytestream2_get_be16(&s->g);
1597  int av_unused typ = bytestream2_get_be16(&s->g);
1598  int asoc = bytestream2_get_be16(&s->g);
1599  if (cn < 4 || asoc < 4)
1600  s->cdef[cn] = asoc;
1601  }
1602  }
1603  bytestream2_seek(&s->g, atom2_end, SEEK_SET);
1604  } while (atom_end - atom2_end >= 8);
1605  } else {
1606  search_range--;
1607  }
1608  bytestream2_seek(&s->g, atom_end, SEEK_SET);
1609  }
1610 
1611  return 0;
1612 }
1613 
1614 static int jpeg2000_decode_frame(AVCodecContext *avctx, void *data,
1615  int *got_frame, AVPacket *avpkt)
1616 {
1618  ThreadFrame frame = { .f = data };
1619  AVFrame *picture = data;
1620  int tileno, ret;
1621 
1622  s->avctx = avctx;
1623  bytestream2_init(&s->g, avpkt->data, avpkt->size);
1624  s->curtileno = -1;
1625  memset(s->cdef, -1, sizeof(s->cdef));
1626 
1627  if (bytestream2_get_bytes_left(&s->g) < 2) {
1628  ret = AVERROR_INVALIDDATA;
1629  goto end;
1630  }
1631 
1632  // check if the image is in jp2 format
1633  if (bytestream2_get_bytes_left(&s->g) >= 12 &&
1634  (bytestream2_get_be32u(&s->g) == 12) &&
1635  (bytestream2_get_be32u(&s->g) == JP2_SIG_TYPE) &&
1636  (bytestream2_get_be32u(&s->g) == JP2_SIG_VALUE)) {
1637  if (!jp2_find_codestream(s)) {
1638  av_log(avctx, AV_LOG_ERROR,
1639  "Could not find Jpeg2000 codestream atom.\n");
1640  ret = AVERROR_INVALIDDATA;
1641  goto end;
1642  }
1643  } else {
1644  bytestream2_seek(&s->g, 0, SEEK_SET);
1645  }
1646 
1647  while (bytestream2_get_bytes_left(&s->g) >= 3 && bytestream2_peek_be16(&s->g) != JPEG2000_SOC)
1648  bytestream2_skip(&s->g, 1);
1649 
1650  if (bytestream2_get_be16u(&s->g) != JPEG2000_SOC) {
1651  av_log(avctx, AV_LOG_ERROR, "SOC marker not present\n");
1652  ret = AVERROR_INVALIDDATA;
1653  goto end;
1654  }
1655  if (ret = jpeg2000_read_main_headers(s))
1656  goto end;
1657 
1658  /* get picture buffer */
1659  if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
1660  goto end;
1661  picture->pict_type = AV_PICTURE_TYPE_I;
1662  picture->key_frame = 1;
1663 
1664  if (ret = jpeg2000_read_bitstream_packets(s))
1665  goto end;
1666 
1667  for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++)
1668  if (ret = jpeg2000_decode_tile(s, s->tile + tileno, picture))
1669  goto end;
1670 
1672 
1673  *got_frame = 1;
1674 
1675  if (s->avctx->pix_fmt == AV_PIX_FMT_PAL8)
1676  memcpy(picture->data[1], s->palette, 256 * sizeof(uint32_t));
1677 
1678  return bytestream2_tell(&s->g);
1679 
1680 end:
1682  return ret;
1683 }
1684 
1686 {
1689 }
1690 
1691 #define OFFSET(x) offsetof(Jpeg2000DecoderContext, x)
1692 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
1693 
1694 static const AVOption options[] = {
1695  { "lowres", "Lower the decoding resolution by a power of two",
1696  OFFSET(reduction_factor), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, JPEG2000_MAX_RESLEVELS - 1, VD },
1697  { NULL },
1698 };
1699 
1700 static const AVProfile profiles[] = {
1701  { FF_PROFILE_JPEG2000_CSTREAM_RESTRICTION_0, "JPEG 2000 codestream restriction 0" },
1702  { FF_PROFILE_JPEG2000_CSTREAM_RESTRICTION_1, "JPEG 2000 codestream restriction 1" },
1703  { FF_PROFILE_JPEG2000_CSTREAM_NO_RESTRICTION, "JPEG 2000 no codestream restrictions" },
1704  { FF_PROFILE_JPEG2000_DCINEMA_2K, "JPEG 2000 digital cinema 2K" },
1705  { FF_PROFILE_JPEG2000_DCINEMA_4K, "JPEG 2000 digital cinema 4K" },
1706  { FF_PROFILE_UNKNOWN },
1707 };
1708 
1709 static const AVClass jpeg2000_class = {
1710  .class_name = "jpeg2000",
1711  .item_name = av_default_item_name,
1712  .option = options,
1713  .version = LIBAVUTIL_VERSION_INT,
1714 };
1715 
1717  .name = "jpeg2000",
1718  .long_name = NULL_IF_CONFIG_SMALL("JPEG 2000"),
1719  .type = AVMEDIA_TYPE_VIDEO,
1720  .id = AV_CODEC_ID_JPEG2000,
1721  .capabilities = CODEC_CAP_FRAME_THREADS,
1722  .priv_data_size = sizeof(Jpeg2000DecoderContext),
1723  .init_static_data = jpeg2000_init_static_data,
1725  .priv_class = &jpeg2000_class,
1726  .max_lowres = 5,
1727  .profiles = NULL_IF_CONFIG_SMALL(profiles)
1728 };
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:978
uint8_t nguardbits
Definition: jpeg2000.h:151
#define JPEG2000_CBLK_VSC
Definition: jpeg2000.h:104
const char const char void * val
Definition: avisynth_c.h:671
float v
const char * s
Definition: avisynth_c.h:668
#define OFFSET(x)
Definition: jpeg2000dec.c:1691
#define AVERROR_PATCHWELCOME
int flags[JPEG2000_MAX_CBLKW+2][JPEG2000_MAX_CBLKH+2]
Definition: jpeg2000.h:122
GetByteContext g
Definition: jpeg2000dec.c:66
void ff_jpeg2000_cleanup(Jpeg2000Component *comp, Jpeg2000CodingStyle *codsty)
Definition: jpeg2000.c:501
AVCodecContext * avctx
Definition: jpeg2000dec.c:65
int size
This structure describes decoded (raw) audio or video data.
Definition: frame.h:96
static int jpeg2000_read_main_headers(Jpeg2000DecoderContext *s)
Definition: jpeg2000dec.c:1394
DWTContext dwt
Definition: jpeg2000.h:199
AVOption.
Definition: opt.h:253
Jpeg2000TgtNode * cblkincl
Definition: jpeg2000.h:176
#define HAD_COC
Definition: jpeg2000dec.c:43
static enum AVPixelFormat xyz_pix_fmts[]
Definition: jpeg2000dec.c:216
static int jpeg2000_decode_tile(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile, AVFrame *picture)
Definition: jpeg2000dec.c:1206
#define JPEG2000_T1_SIG_NB
Definition: jpeg2000.h:84
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: avcodec.h:4153
#define LIBAVUTIL_VERSION_INT
Definition: avcodec.h:820
#define RGB_PIXEL_FORMATS
Definition: jpeg2000dec.c:198
#define JPEG2000_PGOD_PCRL
Definition: jpeg2000.h:117
float * f_data
Definition: jpeg2000.h:200
#define JPEG2000_MAX_CBLKH
Definition: jpeg2000.h:68
const char * g
Definition: vf_curves.c:104
static enum AVPixelFormat all_pix_fmts[]
Definition: jpeg2000dec.c:217
#define FF_PROFILE_JPEG2000_DCINEMA_4K
Definition: avcodec.h:2749
#define JPEG2000_PGOD_RLCP
Definition: jpeg2000.h:115
static void jpeg2000_flush(Jpeg2000DecoderContext *s)
Definition: jpeg2000dec.c:117
#define JP2_CODESTREAM
Definition: jpeg2000dec.c:40
static Float11 * i2f(int i, Float11 *f)
Definition: g726.c:46
int size
Definition: avcodec.h:1064
static int get_qcc(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q, uint8_t *properties)
Definition: jpeg2000dec.c:553
Jpeg2000QuantStyle qntsty[4]
Definition: jpeg2000dec.c:58
const char * b
Definition: vf_curves.c:105
static void mct_decode(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
Definition: jpeg2000dec.c:1149
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
Definition: pixdesc.h:88
void av_log(void *avcl, int level, const char *fmt,...) av_printf_format(3
Send the specified message to the log if the level is less than or equal to the current av_log_level...
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1342
uint16_t mant[JPEG2000_MAX_DECLEVELS *3]
Definition: jpeg2000.h:149
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:131
static int get_qcd(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q, uint8_t *properties)
Definition: jpeg2000dec.c:537
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:2570
Pixel format.
Definition: avcodec.h:4533
static int init_tile(Jpeg2000DecoderContext *s, int tileno)
Definition: jpeg2000dec.c:665
Jpeg2000CodingStyle codsty[4]
Definition: jpeg2000dec.c:85
int profile
profile
Definition: avcodec.h:2678
AVCodec.
Definition: avcodec.h:2922
float f_stepsize
Definition: jpeg2000.h:185
uint16_t nb_codeblocks_height
Definition: jpeg2000.h:174
uint8_t log2_chroma_w
Amount to shift the luma width right to find the chroma width.
Definition: pixdesc.h:68
static void dequantization_int(int x, int y, Jpeg2000Cblk *cblk, Jpeg2000Component *comp, Jpeg2000T1Context *t1, Jpeg2000Band *band)
Definition: jpeg2000dec.c:1120
static int get_cod(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c, uint8_t *properties)
Definition: jpeg2000dec.c:429
static av_always_inline unsigned int bytestream2_get_bufferu(GetByteContext *g, uint8_t *dst, unsigned int size)
Definition: bytestream.h:271
static int jpeg2000_read_bitstream_packets(Jpeg2000DecoderContext *s)
Definition: jpeg2000dec.c:1495
static enum AVPixelFormat rgb_pix_fmts[]
Definition: jpeg2000dec.c:213
void av_freep(void *ptr)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc() and set the pointer ...
Definition: mem.c:234
if((e=av_dict_get(options,"", NULL, AV_DICT_IGNORE_SUFFIX)))
Definition: avfilter.c:965
uint8_t npasses
Definition: jpeg2000.h:160
uint32_t palette[256]
Definition: jpeg2000dec.c:78
static void dequantization_float(int x, int y, Jpeg2000Cblk *cblk, Jpeg2000Component *comp, Jpeg2000T1Context *t1, Jpeg2000Band *band)
Definition: jpeg2000dec.c:1105
static int jpeg2000_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: jpeg2000dec.c:1614
static uint8_t * res
Definition: ffhash.c:43
void void avpriv_request_sample(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
const char * av_default_item_name(void *ctx)
Return the context name.
Definition: log.c:145
uint8_t
#define JP2_SIG_VALUE
Definition: jpeg2000dec.c:39
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:55
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:67
Multithreading support functions.
Jpeg2000TgtNode * zerobits
Definition: jpeg2000.h:175
const char * name
Name of the codec implementation.
Definition: avcodec.h:2929
#define AV_PIX_FMT_FLAG_PAL
Pixel format has a palette in data[1], values are indexes in this palette.
Definition: pixdesc.h:98
Jpeg2000Band * band
Definition: jpeg2000.h:194
static int tag_tree_decode(Jpeg2000DecoderContext *s, Jpeg2000TgtNode *node, int threshold)
Definition: jpeg2000dec.c:125
uint8_t val
Definition: jpeg2000.h:127
const char data[16]
Definition: mxf.c:68
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:192
#define sp
Definition: regdef.h:63
#define lrintf(x)
Definition: libm_mips.h:70
enum AVPixelFormat pix_fmt
Definition: v4l.c:62
#define CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:714
#define JPEG2000_T1_VIS
Definition: jpeg2000.h:94
#define JPEG2000_T1_SIG_SE
Definition: jpeg2000.h:82
static uint8_t get_tlm(Jpeg2000DecoderContext *s, int n)
Definition: jpeg2000dec.c:631
const OptionDef options[]
Definition: ffserver.c:4682
#define JPEG2000_CBLK_SEGSYM
Definition: jpeg2000.h:106
Jpeg2000Tile * tile
Definition: jpeg2000dec.c:92
uint8_t nonzerobits
Definition: jpeg2000.h:162
static AVFrame * frame
Definition: demuxing.c:51
uint8_t log2_prec_widths[JPEG2000_MAX_RESLEVELS]
Definition: jpeg2000.h:143
#define JPEG2000_CSTY_EPH
Definition: jpeg2000.h:111
uint16_t depth_minus1
number of bits in the component minus 1
Definition: pixdesc.h:45
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: avcodec.h:4147
static int getnpasses(Jpeg2000DecoderContext *s)
Definition: jpeg2000dec.c:700
uint8_t log2_chroma_h
Amount to shift the luma height right to find the chroma height.
Definition: pixdesc.h:77
static void decode_sigpass(Jpeg2000T1Context *t1, int width, int height, int bpno, int bandno, int bpass_csty_symbol, int vert_causal_ctx_csty_symbol)
Definition: jpeg2000dec.c:926
static const uint16_t mask[17]
Definition: lzw.c:37
#define YUV_PIXEL_FORMATS
Definition: jpeg2000dec.c:200
void ff_jpeg2000_set_significance(Jpeg2000T1Context *t1, int x, int y, int negative)
Definition: jpeg2000.c:168
int data[JPEG2000_MAX_CBLKW][JPEG2000_MAX_CBLKH]
Definition: jpeg2000.h:121
void ff_mqc_initdec(MqcState *mqc, uint8_t *bp)
Initialize MQ-decoder.
Definition: mqcdec.c:71
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:214
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:151
#define JPEG2000_PGOD_CPRL
Definition: jpeg2000.h:118
const char * r
Definition: vf_curves.c:103
static int get_coc(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c, uint8_t *properties)
Definition: jpeg2000dec.c:464
uint8_t log2_prec_heights[JPEG2000_MAX_RESLEVELS]
Definition: jpeg2000.h:144
static void jpeg2000_init_static_data(AVCodec *codec)
Definition: jpeg2000dec.c:1685
#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:1234
Definition: graph2dot.c:48
Jpeg2000Cblk * cblk
Definition: jpeg2000.h:177
uint8_t tile_index
Definition: jpeg2000dec.c:47
uint8_t cblk_style
Definition: jpeg2000.h:141
Libavcodec external API header.
AVPixelFormat
Pixel format.
Definition: pixfmt.h:66
#define av_unused
Disable warnings about deprecated features This is useful for sections of code kept for backward comp...
Definition: avcodec.h:697
static int get_cox(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c)
Definition: jpeg2000dec.c:363
static const AVClass jpeg2000_class
Definition: jpeg2000dec.c:1709
#define JPEG2000_T1_REF
Definition: jpeg2000.h:96
#define FF_ARRAY_ELEMS(a)
Definition: avcodec.h:929
Jpeg2000TilePart tile_part[4]
Definition: jpeg2000dec.c:59
uint8_t lblock
Definition: jpeg2000.h:165
uint8_t nb_components
The number of components each pixel has, (1-4)
Definition: pixdesc.h:59
#define JP2_SIG_TYPE
Definition: jpeg2000dec.c:38
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:167
uint8_t data[8192]
Definition: jpeg2000.h:167
struct Jpeg2000TgtNode * parent
Definition: jpeg2000.h:129
void ff_jpeg2000_init_tier1_luts(void)
Definition: jpeg2000.c:156
float y
int ff_thread_get_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags)
Wrapper around get_buffer() for frame-multithreaded codecs.
Definition: pthread.c:1021
ret
Definition: avfilter.c:961
int width
picture width / height.
Definition: avcodec.h:1314
JPEG 2000 structures and defines common to encoder and decoder.
int i_stepsize
Definition: jpeg2000.h:184
#define FF_PROFILE_JPEG2000_CSTREAM_RESTRICTION_0
Definition: avcodec.h:2745
#define JPEG2000_MAX_RESLEVELS
Definition: jpeg2000.h:72
int32_t
#define HAD_QCC
Definition: jpeg2000dec.c:44
#define FFMIN(a, b)
Definition: avcodec.h:925
#define MQC_CX_RL
Definition: mqc.h:34
uint16_t num_precincts_y
Definition: jpeg2000.h:192
static int ff_jpeg2000_getsigctxno(int flag, int bandno)
Definition: jpeg2000.h:231
#define VD
Definition: jpeg2000dec.c:1692
float u
int n
Definition: avisynth_c.h:588
uint16_t lengthinc
Definition: jpeg2000.h:164
#define JPEG2000_MAX_DECLEVELS
Definition: jpeg2000.h:71
#define FF_PROFILE_UNKNOWN
Definition: avcodec.h:2679
static int get_siz(Jpeg2000DecoderContext *s)
Definition: jpeg2000dec.c:224
static const AVProfile profiles[]
Definition: jpeg2000dec.c:1700
#define JP2_HEADER
Definition: jpeg2000dec.c:41
static const float f_ict_params[4]
Definition: jpeg2000dec.c:1136
#define JPEG2000_PGOD_RPCL
Definition: jpeg2000.h:116
static int ff_jpeg2000_ceildivpow2(int a, int b)
Definition: jpeg2000.h:207
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:1938
static av_always_inline int bytestream2_tell(GetByteContext *g)
Definition: bytestream.h:186
GetByteContext tpg
Definition: jpeg2000dec.c:49
uint16_t tp_idx
Definition: jpeg2000dec.c:60
uint16_t coord[2][2]
Definition: jpeg2000.h:182
static int width
Definition: utils.c:158
void ff_mqc_init_context_tables(void)
MQ-coder Initialize context tables (QE, NLPS, NMPS)
Definition: mqc.c:95
AVS_Value src
Definition: avisynth_c.h:523
static enum AVPixelFormat yuv_pix_fmts[]
Definition: jpeg2000dec.c:215
#define FFMAX(a, b)
Definition: avcodec.h:923
uint16_t coord[2][2]
Definition: jpeg2000.h:169
int ff_mqc_decode(MqcState *mqc, uint8_t *cxstate)
MQ decoder.
Definition: mqcdec.c:81
uint8_t flags
Definition: pixdesc.h:78
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:57
main external API structure.
Definition: avcodec.h:1146
AVCodec ff_jpeg2000_decoder
Definition: jpeg2000dec.c:1716
static int pix_fmt_match(enum AVPixelFormat pix_fmt, int components, int bpc, uint32_t log2_chroma_wh, int pal8)
Definition: jpeg2000dec.c:163
uint8_t vis
Definition: jpeg2000.h:128
#define FF_PROFILE_JPEG2000_CSTREAM_NO_RESTRICTION
Definition: avcodec.h:2747
uint8_t log2_prec_height
Definition: jpeg2000.h:193
uint16_t length
Definition: jpeg2000.h:163
uint8_t properties[4]
Definition: jpeg2000dec.c:56
BYTE int const BYTE int int int height
Definition: avisynth_c.h:713
static int getlblockinc(Jpeg2000DecoderContext *s)
Definition: jpeg2000dec.c:715
Describe the class of an AVClass context structure.
Definition: log.h:50
uint8_t nbands
Definition: jpeg2000.h:190
uint8_t * data
Definition: avcodec.h:1063
const uint8_t * tp_end
Definition: jpeg2000dec.c:48
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:124
#define FF_PROFILE_JPEG2000_DCINEMA_2K
Definition: avcodec.h:2748
uint16_t nb_codeblocks_width
Definition: jpeg2000.h:173
uint16_t coord[2][2]
Definition: jpeg2000.h:202
#define MKBETAG(a, b, c, d)
#define JPEG2000_T1_SIG_S
Definition: jpeg2000.h:79
Jpeg2000ResLevel * reslevel
Definition: jpeg2000.h:198
static int ff_jpeg2000_ceildiv(int a, int b)
Definition: jpeg2000.h:212
Jpeg2000Component * comp
Definition: j2kenc.c:58
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
void * priv_data
Definition: avcodec.h:1182
uint8_t expn[JPEG2000_MAX_DECLEVELS *3]
Definition: jpeg2000.h:148
static int jpeg2000_decode_packets(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
Definition: jpeg2000dec.c:821
static int get_sot(Jpeg2000DecoderContext *s, int n)
Definition: jpeg2000dec.c:575
static int jp2_find_codestream(Jpeg2000DecoderContext *s)
Definition: jpeg2000dec.c:1514
static void jpeg2000_dec_cleanup(Jpeg2000DecoderContext *s)
Definition: jpeg2000dec.c:1374
uint8_t prog_order
Definition: jpeg2000.h:142
uint8_t quantsty
Definition: jpeg2000.h:150
common internal api header.
#define CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: avcodec.h:811
uint8_t log2_cblk_width
Definition: jpeg2000.h:135
static double c[64]
Jpeg2000QuantStyle qntsty[4]
Definition: jpeg2000dec.c:86
int ff_dwt_decode(DWTContext *s, void *t)
Definition: jpeg2000dwt.c:556
uint16_t coord_o[2][2]
Definition: jpeg2000.h:203
AVProfile.
Definition: avcodec.h:2910
#define XYZ_PIXEL_FORMATS
Definition: jpeg2000dec.c:211
#define GRAY_PIXEL_FORMATS
Definition: jpeg2000dec.c:199
#define JPEG2000_CBLK_BYPASS
Definition: jpeg2000.h:101
#define MQC_CX_UNI
Definition: mqc.h:33
int ff_jpeg2000_init_component(Jpeg2000Component *comp, Jpeg2000CodingStyle *codsty, Jpeg2000QuantStyle *qntsty, int cbps, int dx, int dy, AVCodecContext *avctx)
Definition: jpeg2000.c:193
#define JPEG2000_T1_SIG_SW
Definition: jpeg2000.h:83
#define JPEG2000_PGOD_LRCP
Definition: jpeg2000.h:114
#define FF_PROFILE_JPEG2000_CSTREAM_RESTRICTION_1
Definition: avcodec.h:2746
static int get_bits(Jpeg2000DecoderContext *s, int n)
Definition: jpeg2000dec.c:102
static const int i_ict_params[4]
Definition: jpeg2000dec.c:1142
#define AVERROR_INVALIDDATA
int len
#define av_log2
Definition: intmath.h:89
static int jpeg2000_decode_packet(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *codsty, Jpeg2000ResLevel *rlevel, int precno, int layno, uint8_t *expn, int numgbits)
Definition: jpeg2000dec.c:726
int key_frame
1 -&gt; keyframe, 0-&gt; not
Definition: frame.h:162
Jpeg2000Prec * prec
Definition: jpeg2000.h:186
static av_always_inline int bytestream2_seek(GetByteContext *g, int offset, int whence)
Definition: bytestream.h:206
#define AVERROR(e)
#define JPEG2000_T1_SIG
Definition: jpeg2000.h:95
static void * av_mallocz_array(size_t nmemb, size_t size)
Definition: mem.h:228
static void comp(unsigned char *dst, int dst_stride, unsigned char *src, int src_stride, int add)
Definition: eamad.c:71
MqcState mqc
Definition: jpeg2000.h:123
static int ff_jpeg2000_getrefctxno(int flag)
Definition: jpeg2000.h:240
static int decode(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: crystalhd.c:868
#define JPEG2000_CSTY_PREC
Definition: jpeg2000.h:109
uint8_t log2_cblk_height
Definition: jpeg2000.h:135
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
#define JPEG2000_MAX_CBLKW
Definition: jpeg2000.h:67
8 bit with PIX_FMT_RGB32 palette
Definition: avcodec.h:4545
uint8_t log2_prec_width
Definition: jpeg2000.h:193
static void decode_refpass(Jpeg2000T1Context *t1, int width, int height, int bpno)
Definition: jpeg2000dec.c:956
This structure stores compressed data.
Definition: avcodec.h:1040
static int get_qcx(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q)
Definition: jpeg2000dec.c:492
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:107
Jpeg2000CodingStyle codsty[4]
Definition: jpeg2000dec.c:57
static int decode_cblk(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *codsty, Jpeg2000T1Context *t1, Jpeg2000Cblk *cblk, int width, int height, int bandpos)
Definition: jpeg2000dec.c:1041
uint8_t cx_states[19]
Definition: mqc.h:45
void * av_mallocz(size_t size) av_malloc_attrib 1(1)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
Definition: mem.c:241
static int ff_jpeg2000_getsgnctxno(int flag, int *xorbit)
Definition: jpeg2000.h:249