Libav
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 Libav.
7  *
8  * Libav 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  * Libav 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 Libav; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22 
28 #include "libavutil/common.h"
29 #include "libavutil/opt.h"
30 #include "avcodec.h"
31 #include "bytestream.h"
32 #include "internal.h"
33 #include "thread.h"
34 #include "jpeg2000.h"
35 
36 #define JP2_SIG_TYPE 0x6A502020
37 #define JP2_SIG_VALUE 0x0D0A870A
38 #define JP2_CODESTREAM 0x6A703263
39 
40 #define HAD_COC 0x01
41 #define HAD_QCC 0x02
42 
43 typedef struct Jpeg2000TilePart {
44  uint8_t tile_index; // Tile index who refers the tile-part
45  const uint8_t *tp_end;
46  GetByteContext tpg; // bit stream in tile-part
48 
49 /* RMK: For JPEG2000 DCINEMA 3 tile-parts in a tile
50  * one per component, so tile_part elements have a size of 3 */
51 typedef struct Jpeg2000Tile {
57  uint16_t tp_idx; // Tile-part index
58 } Jpeg2000Tile;
59 
60 typedef struct Jpeg2000DecoderContext {
61  AVClass *class;
64 
65  int width, height;
68  uint8_t cbps[4]; // bits per sample in particular components
69  uint8_t sgnd[4]; // if a component is signed
71  int cdx[4], cdy[4];
72  int precision;
75  unsigned numXtiles, numYtiles;
77 
80 
81  int bit_index;
82 
83  int16_t curtileno;
85 
86  /*options parameters*/
89 
90 /* get_bits functions for JPEG2000 packet bitstream
91  * It is a get_bit function with a bit-stuffing routine. If the value of the
92  * byte is 0xFF, the next byte includes an extra zero bit stuffed into the MSB.
93  * cf. ISO-15444-1:2002 / B.10.1 Bit-stuffing routine */
94 static int get_bits(Jpeg2000DecoderContext *s, int n)
95 {
96  int res = 0;
97  while (--n >= 0) {
98  res <<= 1;
99  if (s->bit_index == 0) {
100  s->bit_index = 7 + (bytestream2_get_byte(&s->g) != 0xFFu);
101  }
102  s->bit_index--;
103  res |= (bytestream2_peek_byte(&s->g) >> s->bit_index) & 1;
104  }
105  return res;
106 }
107 
109 {
110  if (bytestream2_get_byte(&s->g) == 0xff)
111  bytestream2_skip(&s->g, 1);
112  s->bit_index = 8;
113 }
114 
115 /* decode the value stored in node */
117  int threshold)
118 {
119  Jpeg2000TgtNode *stack[30];
120  int sp = -1, curval = 0;
121 
122  if (!node)
123  return AVERROR_INVALIDDATA;
124 
125  while (node && !node->vis) {
126  stack[++sp] = node;
127  node = node->parent;
128  }
129 
130  if (node)
131  curval = node->val;
132  else
133  curval = stack[sp]->val;
134 
135  while (curval < threshold && sp >= 0) {
136  if (curval < stack[sp]->val)
137  curval = stack[sp]->val;
138  while (curval < threshold) {
139  int ret;
140  if ((ret = get_bits(s, 1)) > 0) {
141  stack[sp]->vis++;
142  break;
143  } else if (!ret)
144  curval++;
145  else
146  return ret;
147  }
148  stack[sp]->val = curval;
149  sp--;
150  }
151  return curval;
152 }
153 
154 /* marker segments */
155 /* get sizes and offsets of image, tiles; number of components */
157 {
158  int i;
159  int ncomponents;
160 
161  if (bytestream2_get_bytes_left(&s->g) < 36)
162  return AVERROR_INVALIDDATA;
163 
164  s->avctx->profile = bytestream2_get_be16u(&s->g); // Rsiz
165  s->width = bytestream2_get_be32u(&s->g); // Width
166  s->height = bytestream2_get_be32u(&s->g); // Height
167  s->image_offset_x = bytestream2_get_be32u(&s->g); // X0Siz
168  s->image_offset_y = bytestream2_get_be32u(&s->g); // Y0Siz
169  s->tile_width = bytestream2_get_be32u(&s->g); // XTSiz
170  s->tile_height = bytestream2_get_be32u(&s->g); // YTSiz
171  s->tile_offset_x = bytestream2_get_be32u(&s->g); // XT0Siz
172  s->tile_offset_y = bytestream2_get_be32u(&s->g); // YT0Siz
173  ncomponents = bytestream2_get_be16u(&s->g); // CSiz
174 
175  if (ncomponents <= 0) {
176  av_log(s->avctx, AV_LOG_ERROR, "Invalid number of components: %d\n",
177  s->ncomponents);
178  return AVERROR_INVALIDDATA;
179  }
180 
181  if (ncomponents > 3) {
182  avpriv_request_sample(s->avctx, "Support for %d components",
183  s->ncomponents);
184  return AVERROR_PATCHWELCOME;
185  }
186 
187  s->ncomponents = ncomponents;
188 
189  if (s->tile_width <= 0 || s->tile_height <= 0 ||
190  s->tile_width > s->width || s->tile_height > s->height) {
191  av_log(s->avctx, AV_LOG_ERROR, "Invalid tile dimension %dx%d.\n",
192  s->tile_width, s->tile_height);
193  return AVERROR_INVALIDDATA;
194  }
195 
196  if (bytestream2_get_bytes_left(&s->g) < 3 * s->ncomponents)
197  return AVERROR_INVALIDDATA;
198 
199  for (i = 0; i < s->ncomponents; i++) { // Ssiz_i XRsiz_i, YRsiz_i
200  uint8_t x = bytestream2_get_byteu(&s->g);
201  s->cbps[i] = (x & 0x7f) + 1;
202  s->precision = FFMAX(s->cbps[i], s->precision);
203  s->sgnd[i] = !!(x & 0x80);
204  s->cdx[i] = bytestream2_get_byteu(&s->g);
205  s->cdy[i] = bytestream2_get_byteu(&s->g);
206 
207  if (s->cdx[i] != 1 || s->cdy[i] != 1) {
209  "CDxy values %d %d for component %d",
210  s->cdx[i], s->cdy[i], i);
211  if (!s->cdx[i] || !s->cdy[i])
212  return AVERROR_INVALIDDATA;
213  else
214  return AVERROR_PATCHWELCOME;
215  }
216  }
217 
220 
221  s->tile = av_mallocz_array(s->numXtiles * s->numYtiles, sizeof(*s->tile));
222  if (!s->tile) {
223  s->numXtiles = s->numYtiles = 0;
224  return AVERROR(ENOMEM);
225  }
226 
227  for (i = 0; i < s->numXtiles * s->numYtiles; i++) {
228  Jpeg2000Tile *tile = s->tile + i;
229 
230  tile->comp = av_mallocz(s->ncomponents * sizeof(*tile->comp));
231  if (!tile->comp)
232  return AVERROR(ENOMEM);
233  }
234 
235  /* compute image size with reduction factor */
237  s->reduction_factor);
239  s->reduction_factor);
240 
241  switch (s->ncomponents) {
242  case 1:
243  if (s->precision > 8)
245  else
247  break;
248  case 3:
249  switch (s->avctx->profile) {
252  /* XYZ color-space for digital cinema profiles */
254  break;
255  default:
256  if (s->precision > 8)
258  else
260  break;
261  }
262  break;
263  case 4:
265  break;
266  default:
267  /* pixel format can not be identified */
269  break;
270  }
271  return 0;
272 }
273 
274 /* get common part for COD and COC segments */
276 {
277  uint8_t byte;
278 
279  if (bytestream2_get_bytes_left(&s->g) < 5)
280  return AVERROR_INVALIDDATA;
281 
282  /* nreslevels = number of resolution levels
283  = number of decomposition level +1 */
284  c->nreslevels = bytestream2_get_byteu(&s->g) + 1;
285 
287  return AVERROR_INVALIDDATA;
288 
289  /* compute number of resolution levels to decode */
290  if (c->nreslevels < s->reduction_factor)
291  c->nreslevels2decode = 1;
292  else
294 
295  c->log2_cblk_width = bytestream2_get_byteu(&s->g) + 2; // cblk width
296  c->log2_cblk_height = bytestream2_get_byteu(&s->g) + 2; // cblk height
297 
298  if (c->log2_cblk_width > 10 || c->log2_cblk_height > 10 ||
299  c->log2_cblk_width + c->log2_cblk_height > 12) {
300  av_log(s->avctx, AV_LOG_ERROR, "cblk size invalid\n");
301  return AVERROR_INVALIDDATA;
302  }
303 
304  c->cblk_style = bytestream2_get_byteu(&s->g);
305  if (c->cblk_style != 0) { // cblk style
306  avpriv_request_sample(s->avctx, "Support for extra cblk styles");
307  return AVERROR_PATCHWELCOME;
308  }
309  c->transform = bytestream2_get_byteu(&s->g); // DWT transformation type
310  /* set integer 9/7 DWT in case of BITEXACT flag */
311  if ((s->avctx->flags & CODEC_FLAG_BITEXACT) && (c->transform == FF_DWT97))
312  c->transform = FF_DWT97_INT;
313 
314  if (c->csty & JPEG2000_CSTY_PREC) {
315  int i;
316  for (i = 0; i < c->nreslevels; i++) {
317  byte = bytestream2_get_byte(&s->g);
318  c->log2_prec_widths[i] = byte & 0x0F; // precinct PPx
319  c->log2_prec_heights[i] = (byte >> 4) & 0x0F; // precinct PPy
320  }
321  } else {
322  memset(c->log2_prec_widths , 15, sizeof(c->log2_prec_widths ));
323  memset(c->log2_prec_heights, 15, sizeof(c->log2_prec_heights));
324  }
325  return 0;
326 }
327 
328 /* get coding parameters for a particular tile or whole image*/
330  uint8_t *properties)
331 {
333  int compno, ret;
334 
335  if (bytestream2_get_bytes_left(&s->g) < 5)
336  return AVERROR_INVALIDDATA;
337 
338  tmp.csty = bytestream2_get_byteu(&s->g);
339 
340  // get progression order
341  tmp.prog_order = bytestream2_get_byteu(&s->g);
342 
343  tmp.nlayers = bytestream2_get_be16u(&s->g);
344  tmp.mct = bytestream2_get_byteu(&s->g); // multiple component transformation
345 
346  if (tmp.mct && s->ncomponents < 3) {
348  "MCT %d with too few components (%d)\n",
349  tmp.mct, s->ncomponents);
350  return AVERROR_INVALIDDATA;
351  }
352 
353  if ((ret = get_cox(s, &tmp)) < 0)
354  return ret;
355 
356  for (compno = 0; compno < s->ncomponents; compno++)
357  if (!(properties[compno] & HAD_COC))
358  memcpy(c + compno, &tmp, sizeof(tmp));
359  return 0;
360 }
361 
362 /* Get coding parameters for a component in the whole image or a
363  * particular tile. */
365  uint8_t *properties)
366 {
367  int compno, ret;
368 
369  if (bytestream2_get_bytes_left(&s->g) < 2)
370  return AVERROR_INVALIDDATA;
371 
372  compno = bytestream2_get_byteu(&s->g);
373 
374  if (compno >= s->ncomponents) {
376  "Invalid compno %d. There are %d components in the image.\n",
377  compno, s->ncomponents);
378  return AVERROR_INVALIDDATA;
379  }
380 
381  c += compno;
382  c->csty = bytestream2_get_byteu(&s->g);
383 
384  if ((ret = get_cox(s, c)) < 0)
385  return ret;
386 
387  properties[compno] |= HAD_COC;
388  return 0;
389 }
390 
391 /* Get common part for QCD and QCC segments. */
393 {
394  int i, x;
395 
396  if (bytestream2_get_bytes_left(&s->g) < 1)
397  return AVERROR_INVALIDDATA;
398 
399  x = bytestream2_get_byteu(&s->g); // Sqcd
400 
401  q->nguardbits = x >> 5;
402  q->quantsty = x & 0x1f;
403 
404  if (q->quantsty == JPEG2000_QSTY_NONE) {
405  n -= 3;
406  if (bytestream2_get_bytes_left(&s->g) < n ||
408  return AVERROR_INVALIDDATA;
409  for (i = 0; i < n; i++)
410  q->expn[i] = bytestream2_get_byteu(&s->g) >> 3;
411  } else if (q->quantsty == JPEG2000_QSTY_SI) {
412  if (bytestream2_get_bytes_left(&s->g) < 2)
413  return AVERROR_INVALIDDATA;
414  x = bytestream2_get_be16u(&s->g);
415  q->expn[0] = x >> 11;
416  q->mant[0] = x & 0x7ff;
417  for (i = 1; i < JPEG2000_MAX_DECLEVELS * 3; i++) {
418  int curexpn = FFMAX(0, q->expn[0] - (i - 1) / 3);
419  q->expn[i] = curexpn;
420  q->mant[i] = q->mant[0];
421  }
422  } else {
423  n = (n - 3) >> 1;
424  if (bytestream2_get_bytes_left(&s->g) < 2 * n ||
426  return AVERROR_INVALIDDATA;
427  for (i = 0; i < n; i++) {
428  x = bytestream2_get_be16u(&s->g);
429  q->expn[i] = x >> 11;
430  q->mant[i] = x & 0x7ff;
431  }
432  }
433  return 0;
434 }
435 
436 /* Get quantization parameters for a particular tile or a whole image. */
438  uint8_t *properties)
439 {
440  Jpeg2000QuantStyle tmp;
441  int compno, ret;
442 
443  if ((ret = get_qcx(s, n, &tmp)) < 0)
444  return ret;
445  for (compno = 0; compno < s->ncomponents; compno++)
446  if (!(properties[compno] & HAD_QCC))
447  memcpy(q + compno, &tmp, sizeof(tmp));
448  return 0;
449 }
450 
451 /* Get quantization parameters for a component in the whole image
452  * on in a particular tile. */
454  uint8_t *properties)
455 {
456  int compno;
457 
458  if (bytestream2_get_bytes_left(&s->g) < 1)
459  return AVERROR_INVALIDDATA;
460 
461  compno = bytestream2_get_byteu(&s->g);
462 
463  if (compno >= s->ncomponents) {
465  "Invalid compno %d. There are %d components in the image.\n",
466  compno, s->ncomponents);
467  return AVERROR_INVALIDDATA;
468  }
469 
470  properties[compno] |= HAD_QCC;
471  return get_qcx(s, n - 1, q + compno);
472 }
473 
474 /* Get start of tile segment. */
475 static int get_sot(Jpeg2000DecoderContext *s, int n)
476 {
477  Jpeg2000TilePart *tp;
478  uint16_t Isot;
479  uint32_t Psot;
480  uint8_t TPsot;
481 
482  if (bytestream2_get_bytes_left(&s->g) < 8)
483  return AVERROR_INVALIDDATA;
484 
485  Isot = bytestream2_get_be16u(&s->g); // Isot
486  if (Isot >= s->numXtiles * s->numYtiles)
487  return AVERROR_INVALIDDATA;
488 
489  if (Isot) {
490  avpriv_request_sample(s->avctx, "Support for more than one tile");
491  return AVERROR_PATCHWELCOME;
492  }
493  Psot = bytestream2_get_be32u(&s->g); // Psot
494  TPsot = bytestream2_get_byteu(&s->g); // TPsot
495 
496  /* Read TNSot but not used */
497  bytestream2_get_byteu(&s->g); // TNsot
498 
499  if (Psot > bytestream2_get_bytes_left(&s->g) + n + 2) {
500  av_log(s->avctx, AV_LOG_ERROR, "Psot %d too big\n", Psot);
501  return AVERROR_INVALIDDATA;
502  }
503 
504  if (TPsot >= FF_ARRAY_ELEMS(s->tile[Isot].tile_part)) {
505  avpriv_request_sample(s->avctx, "Support for %d components", TPsot);
506  return AVERROR_PATCHWELCOME;
507  }
508 
509  s->tile[Isot].tp_idx = TPsot;
510  tp = s->tile[Isot].tile_part + TPsot;
511  tp->tile_index = Isot;
512  tp->tp_end = s->g.buffer + Psot - n - 2;
513 
514  if (!TPsot) {
515  Jpeg2000Tile *tile = s->tile + s->curtileno;
516 
517  /* copy defaults */
518  memcpy(tile->codsty, s->codsty, s->ncomponents * sizeof(Jpeg2000CodingStyle));
519  memcpy(tile->qntsty, s->qntsty, s->ncomponents * sizeof(Jpeg2000QuantStyle));
520  }
521 
522  return 0;
523 }
524 
525 /* Tile-part lengths: see ISO 15444-1:2002, section A.7.1
526  * Used to know the number of tile parts and lengths.
527  * There may be multiple TLMs in the header.
528  * TODO: The function is not used for tile-parts management, nor anywhere else.
529  * It can be useful to allocate memory for tile parts, before managing the SOT
530  * markers. Parsing the TLM header is needed to increment the input header
531  * buffer.
532  * This marker is mandatory for DCI. */
534 {
535  uint8_t Stlm, ST, SP, tile_tlm, i;
536  bytestream2_get_byte(&s->g); /* Ztlm: skipped */
537  Stlm = bytestream2_get_byte(&s->g);
538 
539  // too complex ? ST = ((Stlm >> 4) & 0x01) + ((Stlm >> 4) & 0x02);
540  ST = (Stlm >> 4) & 0x03;
541  // TODO: Manage case of ST = 0b11 --> raise error
542  SP = (Stlm >> 6) & 0x01;
543  tile_tlm = (n - 4) / ((SP + 1) * 2 + ST);
544  for (i = 0; i < tile_tlm; i++) {
545  switch (ST) {
546  case 0:
547  break;
548  case 1:
549  bytestream2_get_byte(&s->g);
550  break;
551  case 2:
552  bytestream2_get_be16(&s->g);
553  break;
554  case 3:
555  bytestream2_get_be32(&s->g);
556  break;
557  }
558  if (SP == 0) {
559  bytestream2_get_be16(&s->g);
560  } else {
561  bytestream2_get_be32(&s->g);
562  }
563  }
564  return 0;
565 }
566 
567 static int init_tile(Jpeg2000DecoderContext *s, int tileno)
568 {
569  int compno;
570  int tilex = tileno % s->numXtiles;
571  int tiley = tileno / s->numXtiles;
572  Jpeg2000Tile *tile = s->tile + tileno;
573 
574  if (!tile->comp)
575  return AVERROR(ENOMEM);
576 
577  for (compno = 0; compno < s->ncomponents; compno++) {
578  Jpeg2000Component *comp = tile->comp + compno;
579  Jpeg2000CodingStyle *codsty = tile->codsty + compno;
580  Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
581  int ret; // global bandno
582 
583  comp->coord_o[0][0] = FFMAX(tilex * s->tile_width + s->tile_offset_x, s->image_offset_x);
584  comp->coord_o[0][1] = FFMIN((tilex + 1) * s->tile_width + s->tile_offset_x, s->width);
585  comp->coord_o[1][0] = FFMAX(tiley * s->tile_height + s->tile_offset_y, s->image_offset_y);
586  comp->coord_o[1][1] = FFMIN((tiley + 1) * s->tile_height + s->tile_offset_y, s->height);
587 
588  comp->coord[0][0] = ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], s->reduction_factor);
589  comp->coord[0][1] = ff_jpeg2000_ceildivpow2(comp->coord_o[0][1], s->reduction_factor);
590  comp->coord[1][0] = ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], s->reduction_factor);
591  comp->coord[1][1] = ff_jpeg2000_ceildivpow2(comp->coord_o[1][1], s->reduction_factor);
592 
593  if (ret = ff_jpeg2000_init_component(comp, codsty, qntsty,
594  s->cbps[compno], s->cdx[compno],
595  s->cdy[compno], s->avctx))
596  return ret;
597  }
598  return 0;
599 }
600 
601 /* Read the number of coding passes. */
603 {
604  int num;
605  if (!get_bits(s, 1))
606  return 1;
607  if (!get_bits(s, 1))
608  return 2;
609  if ((num = get_bits(s, 2)) != 3)
610  return num < 0 ? num : 3 + num;
611  if ((num = get_bits(s, 5)) != 31)
612  return num < 0 ? num : 6 + num;
613  num = get_bits(s, 7);
614  return num < 0 ? num : 37 + num;
615 }
616 
618 {
619  int res = 0, ret;
620  while (ret = get_bits(s, 1)) {
621  if (ret < 0)
622  return ret;
623  res++;
624  }
625  return res;
626 }
627 
629  Jpeg2000CodingStyle *codsty,
630  Jpeg2000ResLevel *rlevel, int precno,
631  int layno, uint8_t *expn, int numgbits)
632 {
633  int bandno, cblkno, ret, nb_code_blocks;
634 
635  if (!(ret = get_bits(s, 1))) {
636  jpeg2000_flush(s);
637  return 0;
638  } else if (ret < 0)
639  return ret;
640 
641  for (bandno = 0; bandno < rlevel->nbands; bandno++) {
642  Jpeg2000Band *band = rlevel->band + bandno;
643  Jpeg2000Prec *prec = band->prec + precno;
644 
645  if (band->coord[0][0] == band->coord[0][1] ||
646  band->coord[1][0] == band->coord[1][1])
647  continue;
648  nb_code_blocks = prec->nb_codeblocks_height *
649  prec->nb_codeblocks_width;
650  for (cblkno = 0; cblkno < nb_code_blocks; cblkno++) {
651  Jpeg2000Cblk *cblk = prec->cblk + cblkno;
652  int incl, newpasses, llen;
653 
654  if (cblk->npasses)
655  incl = get_bits(s, 1);
656  else
657  incl = tag_tree_decode(s, prec->cblkincl + cblkno, layno + 1) == layno;
658  if (!incl)
659  continue;
660  else if (incl < 0)
661  return incl;
662 
663  if (!cblk->npasses) {
664  int v = expn[bandno] + numgbits - 1 -
665  tag_tree_decode(s, prec->zerobits + cblkno, 100);
666  if (v < 0) {
668  "nonzerobits %d invalid\n", v);
669  return AVERROR_INVALIDDATA;
670  }
671  cblk->nonzerobits = v;
672  }
673  if ((newpasses = getnpasses(s)) < 0)
674  return newpasses;
675  if ((llen = getlblockinc(s)) < 0)
676  return llen;
677  cblk->lblock += llen;
678  if ((ret = get_bits(s, av_log2(newpasses) + cblk->lblock)) < 0)
679  return ret;
680  if (ret > sizeof(cblk->data)) {
682  "Block with lengthinc greater than %zu",
683  sizeof(cblk->data));
684  return AVERROR_PATCHWELCOME;
685  }
686  cblk->lengthinc = ret;
687  cblk->npasses += newpasses;
688  }
689  }
690  jpeg2000_flush(s);
691 
692  if (codsty->csty & JPEG2000_CSTY_EPH) {
693  if (bytestream2_peek_be16(&s->g) == JPEG2000_EPH)
694  bytestream2_skip(&s->g, 2);
695  else
696  av_log(s->avctx, AV_LOG_ERROR, "EPH marker not found.\n");
697  }
698 
699  for (bandno = 0; bandno < rlevel->nbands; bandno++) {
700  Jpeg2000Band *band = rlevel->band + bandno;
701  Jpeg2000Prec *prec = band->prec + precno;
702 
703  nb_code_blocks = prec->nb_codeblocks_height * prec->nb_codeblocks_width;
704  for (cblkno = 0; cblkno < nb_code_blocks; cblkno++) {
705  Jpeg2000Cblk *cblk = prec->cblk + cblkno;
706  if (bytestream2_get_bytes_left(&s->g) < cblk->lengthinc)
707  return AVERROR_INVALIDDATA;
708  /* Code-block data can be empty. In that case initialize data
709  * with 0xFFFF. */
710  if (cblk->lengthinc > 0) {
711  bytestream2_get_bufferu(&s->g, cblk->data, cblk->lengthinc);
712  } else {
713  cblk->data[0] = 0xFF;
714  cblk->data[1] = 0xFF;
715  }
716  cblk->length += cblk->lengthinc;
717  cblk->lengthinc = 0;
718 
719  if (cblk->length > sizeof(cblk->data)) {
721  "Block length %d > data size %zd\n",
722  cblk->length, sizeof(cblk->data));
723  return AVERROR_INVALIDDATA;
724  }
725  }
726  }
727  return 0;
728 }
729 
731 {
732  int ret = 0;
733  int layno, reslevelno, compno, precno, ok_reslevel;
734  int x, y;
735 
736  s->bit_index = 8;
737  switch (tile->codsty[0].prog_order) {
738  case JPEG2000_PGOD_LRCP:
739  for (layno = 0; layno < tile->codsty[0].nlayers; layno++) {
740  ok_reslevel = 1;
741  for (reslevelno = 0; ok_reslevel; reslevelno++) {
742  ok_reslevel = 0;
743  for (compno = 0; compno < s->ncomponents; compno++) {
744  Jpeg2000CodingStyle *codsty = tile->codsty + compno;
745  Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
746  if (reslevelno < codsty->nreslevels) {
747  Jpeg2000ResLevel *rlevel = tile->comp[compno].reslevel +
748  reslevelno;
749  ok_reslevel = 1;
750  for (precno = 0; precno < rlevel->num_precincts_x * rlevel->num_precincts_y; precno++)
751  if ((ret = jpeg2000_decode_packet(s,
752  codsty, rlevel,
753  precno, layno,
754  qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
755  qntsty->nguardbits)) < 0)
756  return ret;
757  }
758  }
759  }
760  }
761  break;
762 
763  case JPEG2000_PGOD_CPRL:
764  for (compno = 0; compno < s->ncomponents; compno++) {
765  Jpeg2000CodingStyle *codsty = tile->codsty + compno;
766  Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
767 
768  /* Set bit stream buffer address according to tile-part.
769  * For DCinema one tile-part per component, so can be
770  * indexed by component. */
771  s->g = tile->tile_part[compno].tpg;
772 
773  /* Position loop (y axis)
774  * TODO: Automate computing of step 256.
775  * Fixed here, but to be computed before entering here. */
776  for (y = 0; y < s->height; y += 256) {
777  /* Position loop (y axis)
778  * TODO: automate computing of step 256.
779  * Fixed here, but to be computed before entering here. */
780  for (x = 0; x < s->width; x += 256) {
781  for (reslevelno = 0; reslevelno < codsty->nreslevels; reslevelno++) {
782  uint16_t prcx, prcy;
783  uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
784  Jpeg2000ResLevel *rlevel = tile->comp[compno].reslevel + reslevelno;
785 
786  if (!((y % (1 << (rlevel->log2_prec_height + reducedresno)) == 0) ||
787  (y == 0))) // TODO: 2nd condition simplified as try0 always =0 for dcinema
788  continue;
789 
790  if (!((x % (1 << (rlevel->log2_prec_width + reducedresno)) == 0) ||
791  (x == 0))) // TODO: 2nd condition simplified as try0 always =0 for dcinema
792  continue;
793 
794  // check if a precinct exists
795  prcx = ff_jpeg2000_ceildivpow2(x, reducedresno) >> rlevel->log2_prec_width;
796  prcy = ff_jpeg2000_ceildivpow2(y, reducedresno) >> rlevel->log2_prec_height;
797  precno = prcx + rlevel->num_precincts_x * prcy;
798  for (layno = 0; layno < tile->codsty[0].nlayers; layno++) {
799  if ((ret = jpeg2000_decode_packet(s, codsty, rlevel,
800  precno, layno,
801  qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
802  qntsty->nguardbits)) < 0)
803  return ret;
804  }
805  }
806  }
807  }
808  }
809  break;
810 
811  case JPEG2000_PGOD_RLCP:
812  avpriv_request_sample(s->avctx, "Progression order RLCP");
813  ret = AVERROR_PATCHWELCOME;
814  break;
815 
816  case JPEG2000_PGOD_RPCL:
817  avpriv_request_sample(s->avctx, "Progression order RPCL");
818  ret = AVERROR_PATCHWELCOME;
819  break;
820 
821  case JPEG2000_PGOD_PCRL:
822  avpriv_request_sample(s->avctx, "Progression order PCRL");
823  ret = AVERROR_PATCHWELCOME;
824  break;
825 
826  default:
827  break;
828  }
829 
830  /* EOC marker reached */
831  bytestream2_skip(&s->g, 2);
832 
833  return ret;
834 }
835 
836 /* TIER-1 routines */
837 static void decode_sigpass(Jpeg2000T1Context *t1, int width, int height,
838  int bpno, int bandno, int bpass_csty_symbol,
839  int vert_causal_ctx_csty_symbol)
840 {
841  int mask = 3 << (bpno - 1), y0, x, y;
842 
843  for (y0 = 0; y0 < height; y0 += 4)
844  for (x = 0; x < width; x++)
845  for (y = y0; y < height && y < y0 + 4; y++) {
846  if ((t1->flags[y+1][x+1] & JPEG2000_T1_SIG_NB)
847  && !(t1->flags[y+1][x+1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS))) {
848  int flags_mask = -1;
849  if (vert_causal_ctx_csty_symbol && y == y0 + 3)
851  if (ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ff_jpeg2000_getsigctxno(t1->flags[y+1][x+1] & flags_mask, bandno))) {
852  int xorbit, ctxno = ff_jpeg2000_getsgnctxno(t1->flags[y+1][x+1], &xorbit);
853  if (bpass_csty_symbol)
854  t1->data[y][x] = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ctxno) ? -mask : mask;
855  else
856  t1->data[y][x] = (ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ctxno) ^ xorbit) ?
857  -mask : mask;
858 
860  t1->data[y][x] < 0);
861  }
862  t1->flags[y + 1][x + 1] |= JPEG2000_T1_VIS;
863  }
864  }
865 }
866 
867 static void decode_refpass(Jpeg2000T1Context *t1, int width, int height,
868  int bpno)
869 {
870  int phalf, nhalf;
871  int y0, x, y;
872 
873  phalf = 1 << (bpno - 1);
874  nhalf = -phalf;
875 
876  for (y0 = 0; y0 < height; y0 += 4)
877  for (x = 0; x < width; x++)
878  for (y = y0; y < height && y < y0 + 4; y++)
879  if ((t1->flags[y + 1][x + 1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS)) == JPEG2000_T1_SIG) {
880  int ctxno = ff_jpeg2000_getrefctxno(t1->flags[y + 1][x + 1]);
881  int r = ff_mqc_decode(&t1->mqc,
882  t1->mqc.cx_states + ctxno)
883  ? phalf : nhalf;
884  t1->data[y][x] += t1->data[y][x] < 0 ? -r : r;
885  t1->flags[y + 1][x + 1] |= JPEG2000_T1_REF;
886  }
887 }
888 
890  int width, int height, int bpno, int bandno,
891  int seg_symbols, int vert_causal_ctx_csty_symbol)
892 {
893  int mask = 3 << (bpno - 1), y0, x, y, runlen, dec;
894 
895  for (y0 = 0; y0 < height; y0 += 4) {
896  for (x = 0; x < width; x++) {
897  if (y0 + 3 < height &&
898  !((t1->flags[y0 + 1][x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
899  (t1->flags[y0 + 2][x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
900  (t1->flags[y0 + 3][x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
901  (t1->flags[y0 + 4][x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)))) {
902  if (!ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_RL))
903  continue;
904  runlen = ff_mqc_decode(&t1->mqc,
905  t1->mqc.cx_states + MQC_CX_UNI);
906  runlen = (runlen << 1) | ff_mqc_decode(&t1->mqc,
907  t1->mqc.cx_states +
908  MQC_CX_UNI);
909  dec = 1;
910  } else {
911  runlen = 0;
912  dec = 0;
913  }
914 
915  for (y = y0 + runlen; y < y0 + 4 && y < height; y++) {
916  if (!dec) {
917  if (!(t1->flags[y+1][x+1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS))) {
918  int flags_mask = -1;
919  if (vert_causal_ctx_csty_symbol && y == y0 + 3)
921  dec = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ff_jpeg2000_getsigctxno(t1->flags[y+1][x+1] & flags_mask,
922  bandno));
923  }
924  }
925  if (dec) {
926  int xorbit;
927  int ctxno = ff_jpeg2000_getsgnctxno(t1->flags[y + 1][x + 1],
928  &xorbit);
929  t1->data[y][x] = (ff_mqc_decode(&t1->mqc,
930  t1->mqc.cx_states + ctxno) ^
931  xorbit)
932  ? -mask : mask;
933  ff_jpeg2000_set_significance(t1, x, y, t1->data[y][x] < 0);
934  }
935  dec = 0;
936  t1->flags[y + 1][x + 1] &= ~JPEG2000_T1_VIS;
937  }
938  }
939  }
940  if (seg_symbols) {
941  int val;
942  val = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
943  val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
944  val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
945  val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
946  if (val != 0xa)
948  "Segmentation symbol value incorrect\n");
949  }
950 }
951 
953  Jpeg2000T1Context *t1, Jpeg2000Cblk *cblk,
954  int width, int height, int bandpos)
955 {
956  int passno = cblk->npasses, pass_t = 2, bpno = cblk->nonzerobits - 1, y;
957  int clnpass_cnt = 0;
958  int bpass_csty_symbol = codsty->cblk_style & JPEG2000_CBLK_BYPASS;
959  int vert_causal_ctx_csty_symbol = codsty->cblk_style & JPEG2000_CBLK_VSC;
960 
961  for (y = 0; y < height; y++)
962  memset(t1->data[y], 0, width * sizeof(**t1->data));
963 
964  /* If code-block contains no compressed data: nothing to do. */
965  if (!cblk->length)
966  return 0;
967  for (y = 0; y < height + 2; y++)
968  memset(t1->flags[y], 0, (width + 2) * sizeof(**t1->flags));
969 
970  ff_mqc_initdec(&t1->mqc, cblk->data);
971  cblk->data[cblk->length] = 0xff;
972  cblk->data[cblk->length + 1] = 0xff;
973 
974  while (passno--) {
975  switch (pass_t) {
976  case 0:
977  decode_sigpass(t1, width, height, bpno + 1, bandpos,
978  bpass_csty_symbol && (clnpass_cnt >= 4),
979  vert_causal_ctx_csty_symbol);
980  break;
981  case 1:
982  decode_refpass(t1, width, height, bpno + 1);
983  if (bpass_csty_symbol && clnpass_cnt >= 4)
984  ff_mqc_initdec(&t1->mqc, cblk->data);
985  break;
986  case 2:
987  decode_clnpass(s, t1, width, height, bpno + 1, bandpos,
989  vert_causal_ctx_csty_symbol);
990  clnpass_cnt = clnpass_cnt + 1;
991  if (bpass_csty_symbol && clnpass_cnt >= 4)
992  ff_mqc_initdec(&t1->mqc, cblk->data);
993  break;
994  }
995 
996  pass_t++;
997  if (pass_t == 3) {
998  bpno--;
999  pass_t = 0;
1000  }
1001  }
1002  return 0;
1003 }
1004 
1005 /* TODO: Verify dequantization for lossless case
1006  * comp->data can be float or int
1007  * band->stepsize can be float or int
1008  * depending on the type of DWT transformation.
1009  * see ISO/IEC 15444-1:2002 A.6.1 */
1010 
1011 /* Float dequantization of a codeblock.*/
1012 static void dequantization_float(int x, int y, Jpeg2000Cblk *cblk,
1014  Jpeg2000T1Context *t1, Jpeg2000Band *band)
1015 {
1016  int i, j;
1017  int w = cblk->coord[0][1] - cblk->coord[0][0];
1018  for (j = 0; j < (cblk->coord[1][1] - cblk->coord[1][0]); ++j) {
1019  float *datap = &comp->f_data[(comp->coord[0][1] - comp->coord[0][0]) * (y + j) + x];
1020  int *src = t1->data[j];
1021  for (i = 0; i < w; ++i)
1022  datap[i] = src[i] * band->f_stepsize;
1023  }
1024 }
1025 
1026 /* Integer dequantization of a codeblock.*/
1027 static void dequantization_int(int x, int y, Jpeg2000Cblk *cblk,
1029  Jpeg2000T1Context *t1, Jpeg2000Band *band)
1030 {
1031  int i, j;
1032  int w = cblk->coord[0][1] - cblk->coord[0][0];
1033  for (j = 0; j < (cblk->coord[1][1] - cblk->coord[1][0]); ++j) {
1034  int32_t *datap = &comp->i_data[(comp->coord[0][1] - comp->coord[0][0]) * (y + j) + x];
1035  int *src = t1->data[j];
1036  for (i = 0; i < w; ++i)
1037  datap[i] = (src[i] * band->i_stepsize + (1 << 15)) >> 16;
1038  }
1039 }
1040 
1041 /* Inverse ICT parameters in float and integer.
1042  * int value = (float value) * (1<<16) */
1043 static const float f_ict_params[4] = {
1044  1.402f,
1045  0.34413f,
1046  0.71414f,
1047  1.772f
1048 };
1049 static const int i_ict_params[4] = {
1050  91881,
1051  22553,
1052  46802,
1053  116130
1054 };
1055 
1057 {
1058  int i, csize = 1;
1059  int32_t *src[3], i0, i1, i2;
1060  float *srcf[3], i0f, i1f, i2f;
1061 
1062  for (i = 0; i < 3; i++)
1063  if (tile->codsty[0].transform == FF_DWT97)
1064  srcf[i] = tile->comp[i].f_data;
1065  else
1066  src [i] = tile->comp[i].i_data;
1067 
1068  for (i = 0; i < 2; i++)
1069  csize *= tile->comp[0].coord[i][1] - tile->comp[0].coord[i][0];
1070  switch (tile->codsty[0].transform) {
1071  case FF_DWT97:
1072  for (i = 0; i < csize; i++) {
1073  i0f = *srcf[0] + (f_ict_params[0] * *srcf[2]);
1074  i1f = *srcf[0] - (f_ict_params[1] * *srcf[1])
1075  - (f_ict_params[2] * *srcf[2]);
1076  i2f = *srcf[0] + (f_ict_params[3] * *srcf[1]);
1077  *srcf[0]++ = i0f;
1078  *srcf[1]++ = i1f;
1079  *srcf[2]++ = i2f;
1080  }
1081  break;
1082  case FF_DWT97_INT:
1083  for (i = 0; i < csize; i++) {
1084  i0 = *src[0] + (((i_ict_params[0] * *src[2]) + (1 << 15)) >> 16);
1085  i1 = *src[0] - (((i_ict_params[1] * *src[1]) + (1 << 15)) >> 16)
1086  - (((i_ict_params[2] * *src[2]) + (1 << 15)) >> 16);
1087  i2 = *src[0] + (((i_ict_params[3] * *src[1]) + (1 << 15)) >> 16);
1088  *src[0]++ = i0;
1089  *src[1]++ = i1;
1090  *src[2]++ = i2;
1091  }
1092  break;
1093  case FF_DWT53:
1094  for (i = 0; i < csize; i++) {
1095  i1 = *src[0] - (*src[2] + *src[1] >> 2);
1096  i0 = i1 + *src[2];
1097  i2 = i1 + *src[1];
1098  *src[0]++ = i0;
1099  *src[1]++ = i1;
1100  *src[2]++ = i2;
1101  }
1102  break;
1103  }
1104 }
1105 
1107  AVFrame *picture)
1108 {
1109  int compno, reslevelno, bandno;
1110  int x, y;
1111 
1112  uint8_t *line;
1113  Jpeg2000T1Context t1;
1114  /* Loop on tile components */
1115 
1116  for (compno = 0; compno < s->ncomponents; compno++) {
1117  Jpeg2000Component *comp = tile->comp + compno;
1118  Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1119  /* Loop on resolution levels */
1120  for (reslevelno = 0; reslevelno < codsty->nreslevels2decode; reslevelno++) {
1121  Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1122  /* Loop on bands */
1123  for (bandno = 0; bandno < rlevel->nbands; bandno++) {
1124  uint16_t nb_precincts, precno;
1125  Jpeg2000Band *band = rlevel->band + bandno;
1126  int cblkno = 0, bandpos;
1127  bandpos = bandno + (reslevelno > 0);
1128 
1129  if (band->coord[0][0] == band->coord[0][1] ||
1130  band->coord[1][0] == band->coord[1][1])
1131  continue;
1132 
1133  nb_precincts = rlevel->num_precincts_x * rlevel->num_precincts_y;
1134  /* Loop on precincts */
1135  for (precno = 0; precno < nb_precincts; precno++) {
1136  Jpeg2000Prec *prec = band->prec + precno;
1137 
1138  /* Loop on codeblocks */
1139  for (cblkno = 0; cblkno < prec->nb_codeblocks_width * prec->nb_codeblocks_height; cblkno++) {
1140  int x, y;
1141  Jpeg2000Cblk *cblk = prec->cblk + cblkno;
1142  decode_cblk(s, codsty, &t1, cblk,
1143  cblk->coord[0][1] - cblk->coord[0][0],
1144  cblk->coord[1][1] - cblk->coord[1][0],
1145  bandpos);
1146 
1147  x = cblk->coord[0][0];
1148  y = cblk->coord[1][0];
1149 
1150  if (codsty->transform == FF_DWT97)
1151  dequantization_float(x, y, cblk, comp, &t1, band);
1152  else
1153  dequantization_int(x, y, cblk, comp, &t1, band);
1154  } /* end cblk */
1155  } /*end prec */
1156  } /* end band */
1157  } /* end reslevel */
1158 
1159  /* inverse DWT */
1160  ff_dwt_decode(&comp->dwt, codsty->transform == FF_DWT97 ? (void*)comp->f_data : (void*)comp->i_data);
1161  } /*end comp */
1162 
1163  /* inverse MCT transformation */
1164  if (tile->codsty[0].mct)
1165  mct_decode(s, tile);
1166 
1167  if (s->precision <= 8) {
1168  for (compno = 0; compno < s->ncomponents; compno++) {
1169  Jpeg2000Component *comp = tile->comp + compno;
1170  Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1171  float *datap = comp->f_data;
1172  int32_t *i_datap = comp->i_data;
1173  int cbps = s->cbps[compno];
1174  int w = tile->comp[compno].coord[0][1] - s->image_offset_x;
1175 
1176  y = tile->comp[compno].coord[1][0] - s->image_offset_y;
1177  line = picture->data[0] + y * picture->linesize[0];
1178  for (; y < tile->comp[compno].coord[1][1] - s->image_offset_y; y += s->cdy[compno]) {
1179  uint8_t *dst;
1180 
1181  x = tile->comp[compno].coord[0][0] - s->image_offset_x;
1182  dst = line + x * s->ncomponents + compno;
1183 
1184  if (codsty->transform == FF_DWT97) {
1185  for (; x < w; x += s->cdx[compno]) {
1186  int val = lrintf(*datap) + (1 << (cbps - 1));
1187  /* DC level shift and clip see ISO 15444-1:2002 G.1.2 */
1188  val = av_clip(val, 0, (1 << cbps) - 1);
1189  *dst = val << (8 - cbps);
1190  datap++;
1191  dst += s->ncomponents;
1192  }
1193  } else {
1194  for (; x < w; x += s->cdx[compno]) {
1195  int val = *i_datap + (1 << (cbps - 1));
1196  /* DC level shift and clip see ISO 15444-1:2002 G.1.2 */
1197  val = av_clip(val, 0, (1 << cbps) - 1);
1198  *dst = val << (8 - cbps);
1199  i_datap++;
1200  dst += s->ncomponents;
1201  }
1202  }
1203  line += picture->linesize[0];
1204  }
1205  }
1206  } else {
1207  for (compno = 0; compno < s->ncomponents; compno++) {
1208  Jpeg2000Component *comp = tile->comp + compno;
1209  Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1210  float *datap = comp->f_data;
1211  int32_t *i_datap = comp->i_data;
1212  uint16_t *linel;
1213  int cbps = s->cbps[compno];
1214  int w = tile->comp[compno].coord[0][1] - s->image_offset_x;
1215 
1216  y = tile->comp[compno].coord[1][0] - s->image_offset_y;
1217  linel = (uint16_t *)picture->data[0] + y * (picture->linesize[0] >> 1);
1218  for (; y < tile->comp[compno].coord[1][1] - s->image_offset_y; y += s->cdy[compno]) {
1219  uint16_t *dst;
1220  x = tile->comp[compno].coord[0][0] - s->image_offset_x;
1221  dst = linel + (x * s->ncomponents + compno);
1222  if (codsty->transform == FF_DWT97) {
1223  for (; x < w; x += s-> cdx[compno]) {
1224  int val = lrintf(*datap) + (1 << (cbps - 1));
1225  /* DC level shift and clip see ISO 15444-1:2002 G.1.2 */
1226  val = av_clip(val, 0, (1 << cbps) - 1);
1227  /* align 12 bit values in little-endian mode */
1228  *dst = val << (16 - cbps);
1229  datap++;
1230  dst += s->ncomponents;
1231  }
1232  } else {
1233  for (; x < w; x += s-> cdx[compno]) {
1234  int val = *i_datap + (1 << (cbps - 1));
1235  /* DC level shift and clip see ISO 15444-1:2002 G.1.2 */
1236  val = av_clip(val, 0, (1 << cbps) - 1);
1237  /* align 12 bit values in little-endian mode */
1238  *dst = val << (16 - cbps);
1239  i_datap++;
1240  dst += s->ncomponents;
1241  }
1242  }
1243  linel += picture->linesize[0] >> 1;
1244  }
1245  }
1246  }
1247 
1248  return 0;
1249 }
1250 
1252 {
1253  int tileno, compno;
1254  for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++) {
1255  for (compno = 0; compno < s->ncomponents; compno++) {
1256  Jpeg2000Component *comp = s->tile[tileno].comp + compno;
1257  Jpeg2000CodingStyle *codsty = s->tile[tileno].codsty + compno;
1258 
1259  ff_jpeg2000_cleanup(comp, codsty);
1260  }
1261  av_freep(&s->tile[tileno].comp);
1262  }
1263  av_freep(&s->tile);
1264  s->numXtiles = s->numYtiles = 0;
1265 }
1266 
1268 {
1269  Jpeg2000CodingStyle *codsty = s->codsty;
1270  Jpeg2000QuantStyle *qntsty = s->qntsty;
1271  uint8_t *properties = s->properties;
1272 
1273  for (;;) {
1274  int len, ret = 0;
1275  uint16_t marker;
1276  int oldpos;
1277 
1278  if (bytestream2_get_bytes_left(&s->g) < 2) {
1279  av_log(s->avctx, AV_LOG_ERROR, "Missing EOC\n");
1280  break;
1281  }
1282 
1283  marker = bytestream2_get_be16u(&s->g);
1284  oldpos = bytestream2_tell(&s->g);
1285 
1286  if (marker == JPEG2000_SOD) {
1287  Jpeg2000Tile *tile;
1288  Jpeg2000TilePart *tp;
1289 
1290  if (s->curtileno < 0) {
1291  av_log(s->avctx, AV_LOG_ERROR, "Missing SOT\n");
1292  return AVERROR_INVALIDDATA;
1293  }
1294  if (!s->tile) {
1295  av_log(s->avctx, AV_LOG_ERROR, "Missing SIZ\n");
1296  return AVERROR_INVALIDDATA;
1297  }
1298 
1299  tile = s->tile + s->curtileno;
1300  tp = tile->tile_part + tile->tp_idx;
1301  bytestream2_init(&tp->tpg, s->g.buffer, tp->tp_end - s->g.buffer);
1302  bytestream2_skip(&s->g, tp->tp_end - s->g.buffer);
1303 
1304  continue;
1305  }
1306  if (marker == JPEG2000_EOC)
1307  break;
1308 
1309  len = bytestream2_get_be16u(&s->g);
1310  if (len < 2 || bytestream2_get_bytes_left(&s->g) < len - 2)
1311  return AVERROR_INVALIDDATA;
1312 
1313  switch (marker) {
1314  case JPEG2000_SIZ:
1315  ret = get_siz(s);
1316  break;
1317  case JPEG2000_COC:
1318  ret = get_coc(s, codsty, properties);
1319  break;
1320  case JPEG2000_COD:
1321  ret = get_cod(s, codsty, properties);
1322  break;
1323  case JPEG2000_QCC:
1324  ret = get_qcc(s, len, qntsty, properties);
1325  break;
1326  case JPEG2000_QCD:
1327  ret = get_qcd(s, len, qntsty, properties);
1328  break;
1329  case JPEG2000_SOT:
1330  if (!(ret = get_sot(s, len))) {
1331  codsty = s->tile[s->curtileno].codsty;
1332  qntsty = s->tile[s->curtileno].qntsty;
1333  properties = s->tile[s->curtileno].properties;
1334  }
1335  break;
1336  case JPEG2000_COM:
1337  // the comment is ignored
1338  bytestream2_skip(&s->g, len - 2);
1339  break;
1340  case JPEG2000_TLM:
1341  // Tile-part lengths
1342  ret = get_tlm(s, len);
1343  break;
1344  default:
1346  "unsupported marker 0x%.4X at pos 0x%X\n",
1347  marker, bytestream2_tell(&s->g) - 4);
1348  bytestream2_skip(&s->g, len - 2);
1349  break;
1350  }
1351  if (bytestream2_tell(&s->g) - oldpos != len || ret) {
1353  "error during processing marker segment %.4x\n", marker);
1354  return ret ? ret : -1;
1355  }
1356  }
1357  return 0;
1358 }
1359 
1360 /* Read bit stream packets --> T2 operation. */
1362 {
1363  int ret = 0;
1364  int tileno;
1365 
1366  for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++) {
1367  Jpeg2000Tile *tile = s->tile + tileno;
1368 
1369  if (ret = init_tile(s, tileno))
1370  return ret;
1371 
1372  s->g = tile->tile_part[0].tpg;
1373  if (ret = jpeg2000_decode_packets(s, tile))
1374  return ret;
1375  }
1376 
1377  return 0;
1378 }
1379 
1381 {
1382  uint32_t atom_size, atom;
1383  int found_codestream = 0, search_range = 10;
1384 
1385  while(!found_codestream && search_range
1386  &&
1387  bytestream2_get_bytes_left(&s->g) >= 8) {
1388  atom_size = bytestream2_get_be32u(&s->g);
1389  atom = bytestream2_get_be32u(&s->g);
1390  if (atom == JP2_CODESTREAM) {
1391  found_codestream = 1;
1392  } else {
1393  if (bytestream2_get_bytes_left(&s->g) < atom_size - 8)
1394  return 0;
1395  bytestream2_skipu(&s->g, atom_size - 8);
1396  search_range--;
1397  }
1398  }
1399 
1400  if (found_codestream)
1401  return 1;
1402  return 0;
1403 }
1404 
1405 static int jpeg2000_decode_frame(AVCodecContext *avctx, void *data,
1406  int *got_frame, AVPacket *avpkt)
1407 {
1408  Jpeg2000DecoderContext *s = avctx->priv_data;
1409  ThreadFrame frame = { .f = data };
1410  AVFrame *picture = data;
1411  int tileno, ret;
1412 
1413  s->avctx = avctx;
1414  bytestream2_init(&s->g, avpkt->data, avpkt->size);
1415  s->curtileno = 0; // TODO: only one tile in DCI JP2K. to implement for more tiles
1416 
1417  if (bytestream2_get_bytes_left(&s->g) < 2) {
1418  ret = AVERROR_INVALIDDATA;
1419  goto end;
1420  }
1421 
1422  // check if the image is in jp2 format
1423  if (bytestream2_get_bytes_left(&s->g) >= 12 &&
1424  (bytestream2_get_be32u(&s->g) == 12) &&
1425  (bytestream2_get_be32u(&s->g) == JP2_SIG_TYPE) &&
1426  (bytestream2_get_be32u(&s->g) == JP2_SIG_VALUE)) {
1427  if (!jp2_find_codestream(s)) {
1428  av_log(avctx, AV_LOG_ERROR,
1429  "Could not find Jpeg2000 codestream atom.\n");
1430  ret = AVERROR_INVALIDDATA;
1431  goto end;
1432  }
1433  } else {
1434  bytestream2_seek(&s->g, 0, SEEK_SET);
1435  }
1436 
1437  if (bytestream2_get_be16u(&s->g) != JPEG2000_SOC) {
1438  av_log(avctx, AV_LOG_ERROR, "SOC marker not present\n");
1439  ret = AVERROR_INVALIDDATA;
1440  goto end;
1441  }
1442  if (ret = jpeg2000_read_main_headers(s))
1443  goto end;
1444 
1445  /* get picture buffer */
1446  if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0) {
1447  av_log(avctx, AV_LOG_ERROR, "ff_thread_get_buffer() failed.\n");
1448  goto end;
1449  }
1450  picture->pict_type = AV_PICTURE_TYPE_I;
1451  picture->key_frame = 1;
1452 
1453  if (ret = jpeg2000_read_bitstream_packets(s))
1454  goto end;
1455  for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++)
1456  if (ret = jpeg2000_decode_tile(s, s->tile + tileno, picture))
1457  goto end;
1458 
1460 
1461  *got_frame = 1;
1462 
1463  return bytestream2_tell(&s->g);
1464 
1465 end:
1467  return ret;
1468 }
1469 
1471 {
1474 }
1475 
1476 #define OFFSET(x) offsetof(Jpeg2000DecoderContext, x)
1477 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
1478 
1479 static const AVOption options[] = {
1480  { "lowres", "Lower the decoding resolution by a power of two",
1481  OFFSET(reduction_factor), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, JPEG2000_MAX_RESLEVELS - 1, VD },
1482  { NULL },
1483 };
1484 
1485 static const AVProfile profiles[] = {
1486  { FF_PROFILE_JPEG2000_CSTREAM_RESTRICTION_0, "JPEG 2000 codestream restriction 0" },
1487  { FF_PROFILE_JPEG2000_CSTREAM_RESTRICTION_1, "JPEG 2000 codestream restriction 1" },
1488  { FF_PROFILE_JPEG2000_CSTREAM_NO_RESTRICTION, "JPEG 2000 no codestream restrictions" },
1489  { FF_PROFILE_JPEG2000_DCINEMA_2K, "JPEG 2000 digital cinema 2K" },
1490  { FF_PROFILE_JPEG2000_DCINEMA_4K, "JPEG 2000 digital cinema 4K" },
1491  { FF_PROFILE_UNKNOWN },
1492 };
1493 
1494 static const AVClass class = {
1495  .class_name = "jpeg2000",
1496  .item_name = av_default_item_name,
1497  .option = options,
1499 };
1500 
1502  .name = "jpeg2000",
1503  .long_name = NULL_IF_CONFIG_SMALL("JPEG 2000"),
1504  .type = AVMEDIA_TYPE_VIDEO,
1505  .id = AV_CODEC_ID_JPEG2000,
1506  .capabilities = CODEC_CAP_FRAME_THREADS,
1507  .priv_data_size = sizeof(Jpeg2000DecoderContext),
1508  .init_static_data = jpeg2000_init_static_data,
1510  .priv_class = &class,
1511  .profiles = NULL_IF_CONFIG_SMALL(profiles)
1512 };
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:889
Jpeg2000Component * comp
Definition: jpeg2000dec.c:52
uint8_t nguardbits
Definition: jpeg2000.h:151
#define JPEG2000_CBLK_VSC
Definition: jpeg2000.h:104
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:54
#define OFFSET(x)
Definition: jpeg2000dec.c:1476
int flags[JPEG2000_MAX_CBLKW+2][JPEG2000_MAX_CBLKH+2]
Definition: jpeg2000.h:122
GetByteContext g
Definition: jpeg2000dec.c:63
void ff_jpeg2000_cleanup(Jpeg2000Component *comp, Jpeg2000CodingStyle *codsty)
Definition: jpeg2000.c:484
AVCodecContext * avctx
Definition: jpeg2000dec.c:62
This structure describes decoded (raw) audio or video data.
Definition: frame.h:107
static int jpeg2000_read_main_headers(Jpeg2000DecoderContext *s)
Definition: jpeg2000dec.c:1267
DWTContext dwt
Definition: jpeg2000.h:193
AVOption.
Definition: opt.h:233
Jpeg2000TgtNode * cblkincl
Definition: jpeg2000.h:170
#define HAD_COC
Definition: jpeg2000dec.c:40
static int jpeg2000_decode_tile(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile, AVFrame *picture)
Definition: jpeg2000dec.c:1106
#define JPEG2000_T1_SIG_NB
Definition: jpeg2000.h:84
AVFrame * f
Definition: thread.h:36
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:67
#define JPEG2000_PGOD_PCRL
Definition: jpeg2000.h:117
float * f_data
Definition: jpeg2000.h:194
static AVFrame * picture
Definition: output.c:179
#define JPEG2000_PGOD_RLCP
Definition: jpeg2000.h:115
static void jpeg2000_flush(Jpeg2000DecoderContext *s)
Definition: jpeg2000dec.c:108
#define JP2_CODESTREAM
Definition: jpeg2000dec.c:38
static Float11 * i2f(int i, Float11 *f)
Definition: g726.c:46
int size
Definition: avcodec.h:974
static int get_qcc(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q, uint8_t *properties)
Definition: jpeg2000dec.c:453
Jpeg2000QuantStyle qntsty[4]
Definition: jpeg2000dec.c:55
static void mct_decode(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
Definition: jpeg2000dec.c:1056
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1247
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:130
#define FF_ARRAY_ELEMS(a)
static int get_qcd(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q, uint8_t *properties)
Definition: jpeg2000dec.c:437
static int init_tile(Jpeg2000DecoderContext *s, int tileno)
Definition: jpeg2000dec.c:567
Jpeg2000CodingStyle codsty[4]
Definition: jpeg2000dec.c:78
int profile
profile
Definition: avcodec.h:2596
AVCodec.
Definition: avcodec.h:2755
#define FF_PROFILE_JPEG2000_CSTREAM_RESTRICTION_1
Definition: avcodec.h:2664
float f_stepsize
Definition: jpeg2000.h:179
uint16_t nb_codeblocks_height
Definition: jpeg2000.h:168
static void dequantization_int(int x, int y, Jpeg2000Cblk *cblk, Jpeg2000Component *comp, Jpeg2000T1Context *t1, Jpeg2000Band *band)
Definition: jpeg2000dec.c:1027
static int get_cod(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c, uint8_t *properties)
Definition: jpeg2000dec.c:329
static av_always_inline unsigned int bytestream2_get_bufferu(GetByteContext *g, uint8_t *dst, unsigned int size)
Definition: bytestream.h:258
static int jpeg2000_read_bitstream_packets(Jpeg2000DecoderContext *s)
Definition: jpeg2000dec.c:1361
void av_freep(void *arg)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc() and set the pointer ...
Definition: mem.c:198
uint8_t npasses
Definition: jpeg2000.h:155
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:38
static void dequantization_float(int x, int y, Jpeg2000Cblk *cblk, Jpeg2000Component *comp, Jpeg2000T1Context *t1, Jpeg2000Band *band)
Definition: jpeg2000dec.c:1012
static int jpeg2000_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: jpeg2000dec.c:1405
static int decode(MimicContext *ctx, int quality, int num_coeffs, int is_iframe)
Definition: mimic.c:269
void void avpriv_request_sample(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
uint8_t
#define JP2_SIG_VALUE
Definition: jpeg2000dec.c:37
#define FF_PROFILE_JPEG2000_CSTREAM_NO_RESTRICTION
Definition: avcodec.h:2665
AVOptions.
Multithreading support functions.
Jpeg2000TgtNode * zerobits
Definition: jpeg2000.h:169
Jpeg2000Band * band
Definition: jpeg2000.h:188
static int tag_tree_decode(Jpeg2000DecoderContext *s, Jpeg2000TgtNode *node, int threshold)
Definition: jpeg2000dec.c:116
uint8_t val
Definition: jpeg2000.h:127
const char data[16]
Definition: mxf.c:66
uint8_t * data
Definition: avcodec.h:973
const uint8_t * buffer
Definition: bytestream.h:33
static av_always_inline void bytestream2_skipu(GetByteContext *g, unsigned int size)
Definition: bytestream.h:165
uint16_t num_precincts_x
Definition: jpeg2000.h:186
#define CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:685
#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:533
#define JPEG2000_CBLK_SEGSYM
Definition: jpeg2000.h:106
Jpeg2000Tile * tile
Definition: jpeg2000dec.c:84
#define r
Definition: input.c:51
uint8_t nonzerobits
Definition: jpeg2000.h:157
uint8_t log2_prec_widths[JPEG2000_MAX_RESLEVELS]
Definition: jpeg2000.h:143
#define JPEG2000_CSTY_EPH
Definition: jpeg2000.h:111
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:123
static int getnpasses(Jpeg2000DecoderContext *s)
Definition: jpeg2000dec.c:602
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:837
static const uint16_t mask[17]
Definition: lzw.c:38
void ff_jpeg2000_set_significance(Jpeg2000T1Context *t1, int x, int y, int negative)
Definition: jpeg2000.c:172
uint8_t nreslevels
Definition: jpeg2000.h:133
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
#define AVERROR(e)
Definition: error.h:43
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
Definition: bytestream.h:159
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:142
#define JPEG2000_PGOD_CPRL
Definition: jpeg2000.h:118
static int get_coc(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c, uint8_t *properties)
Definition: jpeg2000dec.c:364
uint8_t log2_prec_heights[JPEG2000_MAX_RESLEVELS]
Definition: jpeg2000.h:144
static void jpeg2000_init_static_data(AVCodec *codec)
Definition: jpeg2000dec.c:1470
static av_always_inline unsigned int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:149
int flags
CODEC_FLAG_*.
Definition: avcodec.h:1142
Definition: graph2dot.c:49
#define AV_PIX_FMT_RGB48
Definition: pixfmt.h:212
void av_log(void *avcl, int level, const char *fmt,...)
Definition: log.c:148
const char * name
Name of the codec implementation.
Definition: avcodec.h:2762
Jpeg2000Cblk * cblk
Definition: jpeg2000.h:171
#define FFMAX(a, b)
Definition: common.h:55
uint8_t tile_index
Definition: jpeg2000dec.c:44
uint8_t cblk_style
Definition: jpeg2000.h:141
packed RGBA 8:8:8:8, 32bpp, RGBARGBA...
Definition: pixfmt.h:96
static int get_cox(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c)
Definition: jpeg2000dec.c:275
#define JPEG2000_T1_REF
Definition: jpeg2000.h:96
uint8_t lblock
Definition: jpeg2000.h:160
#define JP2_SIG_TYPE
Definition: jpeg2000dec.c:36
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:168
#define AV_PIX_FMT_GRAY16
Definition: pixfmt.h:211
#define FFMIN(a, b)
Definition: common.h:57
uint8_t data[8192]
Definition: jpeg2000.h:162
struct Jpeg2000TgtNode * parent
Definition: jpeg2000.h:129
void ff_jpeg2000_init_tier1_luts(void)
Definition: jpeg2000.c:160
int width
picture width / height.
Definition: avcodec.h:1217
JPEG 2000 structures and defines common to encoder and decoder.
int i_stepsize
Definition: jpeg2000.h:178
#define FF_PROFILE_UNKNOWN
Definition: avcodec.h:2597
#define JPEG2000_MAX_RESLEVELS
Definition: jpeg2000.h:72
int32_t
#define HAD_QCC
Definition: jpeg2000dec.c:41
#define FF_PROFILE_JPEG2000_CSTREAM_RESTRICTION_0
Definition: avcodec.h:2663
static av_always_inline av_const long int lrintf(float x)
Definition: libm.h:144
#define MQC_CX_RL
Definition: mqc.h:34
uint16_t num_precincts_y
Definition: jpeg2000.h:186
static int ff_jpeg2000_getsigctxno(int flag, int bandno)
Definition: jpeg2000.h:225
#define VD
Definition: jpeg2000dec.c:1477
#define FF_PROFILE_JPEG2000_DCINEMA_4K
Definition: avcodec.h:2667
uint16_t lengthinc
Definition: jpeg2000.h:159
#define JPEG2000_MAX_DECLEVELS
Definition: jpeg2000.h:71
static int get_siz(Jpeg2000DecoderContext *s)
Definition: jpeg2000dec.c:156
static const AVProfile profiles[]
Definition: jpeg2000dec.c:1485
LIBAVUTIL_VERSION_INT
Definition: eval.c:55
static const float f_ict_params[4]
Definition: jpeg2000dec.c:1043
#define JPEG2000_PGOD_RPCL
Definition: jpeg2000.h:116
static int ff_jpeg2000_ceildivpow2(int a, int b)
Definition: jpeg2000.h:201
#define AVERROR_PATCHWELCOME
Not yet implemented in Libav, patches welcome.
Definition: error.h:57
static av_always_inline int bytestream2_tell(GetByteContext *g)
Definition: bytestream.h:183
GetByteContext tpg
Definition: jpeg2000dec.c:46
NULL
Definition: eval.c:55
uint16_t tp_idx
Definition: jpeg2000dec.c:57
uint16_t coord[2][2]
Definition: jpeg2000.h:176
static int width
Definition: utils.c:156
void ff_mqc_init_context_tables(void)
MQ-coder Initialize context tables (QE, NLPS, NMPS)
Definition: mqc.c:95
Libavcodec external API header.
uint16_t coord[2][2]
Definition: jpeg2000.h:163
uint8_t nreslevels2decode
Definition: jpeg2000.h:134
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:125
int ff_mqc_decode(MqcState *mqc, uint8_t *cxstate)
MQ decoder.
Definition: mqcdec.c:81
av_default_item_name
Definition: dnxhdenc.c:45
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:1054
AVCodec ff_jpeg2000_decoder
Definition: jpeg2000dec.c:1501
uint8_t vis
Definition: jpeg2000.h:128
uint8_t log2_prec_height
Definition: jpeg2000.h:187
uint16_t length
Definition: jpeg2000.h:158
uint8_t properties[4]
Definition: jpeg2000dec.c:53
static int getlblockinc(Jpeg2000DecoderContext *s)
Definition: jpeg2000dec.c:617
#define AV_PIX_FMT_XYZ12
Definition: pixfmt.h:245
Describe the class of an AVClass context structure.
Definition: log.h:33
uint8_t nbands
Definition: jpeg2000.h:184
const uint8_t * tp_end
Definition: jpeg2000dec.c:45
uint16_t nb_codeblocks_width
Definition: jpeg2000.h:167
static const AVOption options[]
Definition: jpeg2000dec.c:1479
uint16_t coord[2][2]
Definition: jpeg2000.h:196
#define JPEG2000_T1_SIG_S
Definition: jpeg2000.h:79
Jpeg2000ResLevel * reslevel
Definition: jpeg2000.h:192
static int ff_jpeg2000_ceildiv(int a, int b)
Definition: jpeg2000.h:206
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:113
uint8_t expn[JPEG2000_MAX_DECLEVELS *3]
Definition: jpeg2000.h:148
static int jpeg2000_decode_packets(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
Definition: jpeg2000dec.c:730
int height
Definition: gxfenc.c:72
static int get_sot(Jpeg2000DecoderContext *s, int n)
Definition: jpeg2000dec.c:475
static int jp2_find_codestream(Jpeg2000DecoderContext *s)
Definition: jpeg2000dec.c:1380
static void jpeg2000_dec_cleanup(Jpeg2000DecoderContext *s)
Definition: jpeg2000dec.c:1251
uint8_t prog_order
Definition: jpeg2000.h:142
Y , 8bpp.
Definition: pixfmt.h:73
uint8_t quantsty
Definition: jpeg2000.h:150
common internal api header.
common internal and external API header
#define CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: avcodec.h:782
uint8_t log2_cblk_width
Definition: jpeg2000.h:135
Jpeg2000QuantStyle qntsty[4]
Definition: jpeg2000dec.c:79
int ff_dwt_decode(DWTContext *s, void *t)
Definition: jpeg2000dwt.c:335
uint16_t coord_o[2][2]
Definition: jpeg2000.h:197
AVProfile.
Definition: avcodec.h:2743
Jpeg2000TilePart tile_part[3]
Definition: jpeg2000dec.c:56
#define JPEG2000_CBLK_BYPASS
Definition: jpeg2000.h:101
#define MQC_CX_UNI
Definition: mqc.h:33
void * priv_data
Definition: avcodec.h:1090
int ff_jpeg2000_init_component(Jpeg2000Component *comp, Jpeg2000CodingStyle *codsty, Jpeg2000QuantStyle *qntsty, int cbps, int dx, int dy, AVCodecContext *avctx)
Definition: jpeg2000.c:197
#define JPEG2000_T1_SIG_SW
Definition: jpeg2000.h:83
#define JPEG2000_PGOD_LRCP
Definition: jpeg2000.h:114
static int get_bits(Jpeg2000DecoderContext *s, int n)
Definition: jpeg2000dec.c:94
static const int i_ict_params[4]
Definition: jpeg2000dec.c:1049
int len
#define av_log2
Definition: intmath.h:85
static int jpeg2000_decode_packet(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *codsty, Jpeg2000ResLevel *rlevel, int precno, int layno, uint8_t *expn, int numgbits)
Definition: jpeg2000dec.c:628
#define FF_PROFILE_JPEG2000_DCINEMA_2K
Definition: avcodec.h:2666
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:163
Jpeg2000Prec * prec
Definition: jpeg2000.h:180
static av_always_inline int bytestream2_seek(GetByteContext *g, int offset, int whence)
Definition: bytestream.h:193
#define JPEG2000_T1_SIG
Definition: jpeg2000.h:95
static void * av_mallocz_array(size_t nmemb, size_t size)
Definition: mem.h:205
static void comp(unsigned char *dst, int dst_stride, unsigned char *src, int src_stride, int add)
Definition: eamad.c:77
MqcState mqc
Definition: jpeg2000.h:123
static int ff_jpeg2000_getrefctxno(int flag)
Definition: jpeg2000.h:234
#define JPEG2000_CSTY_PREC
Definition: jpeg2000.h:109
uint8_t log2_cblk_height
Definition: jpeg2000.h:135
uint8_t log2_prec_width
Definition: jpeg2000.h:187
uint32_t mant[JPEG2000_MAX_DECLEVELS *3]
Definition: jpeg2000.h:149
static void decode_refpass(Jpeg2000T1Context *t1, int width, int height, int bpno)
Definition: jpeg2000dec.c:867
This structure stores compressed data.
Definition: avcodec.h:950
static int get_qcx(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q)
Definition: jpeg2000dec.c:392
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:205
Jpeg2000CodingStyle codsty[4]
Definition: jpeg2000dec.c:54
static int decode_cblk(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *codsty, Jpeg2000T1Context *t1, Jpeg2000Cblk *cblk, int width, int height, int bandpos)
Definition: jpeg2000dec.c:952
uint8_t cx_states[19]
Definition: mqc.h:45
static int ff_jpeg2000_getsgnctxno(int flag, int *xorbit)
Definition: jpeg2000.h:243