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