FFmpeg
jpeg2000.c
Go to the documentation of this file.
1 /*
2  * JPEG 2000 encoder and decoder common functions
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 encoder and decoder common functions
26  */
27 
28 #include "libavutil/attributes.h"
29 #include "libavutil/avassert.h"
30 #include "libavutil/common.h"
31 #include "libavutil/imgutils.h"
32 #include "libavutil/mem.h"
33 #include "avcodec.h"
34 #include "internal.h"
35 #include "jpeg2000.h"
36 
37 #define SHL(a, n) ((n) >= 0 ? (a) << (n) : (a) >> -(n))
38 
39 /* tag tree routines */
40 
41 /* allocate the memory for tag tree */
43 {
44  int64_t res = 0;
45  while (w > 1 || h > 1) {
46  res += w * (int64_t)h;
47  av_assert0(res + 1 < INT32_MAX);
48  w = (w + 1) >> 1;
49  h = (h + 1) >> 1;
50  }
51  return (int32_t)(res + 1);
52 }
53 
55 {
56  int pw = w, ph = h;
57  Jpeg2000TgtNode *res, *t, *t2;
58  int32_t tt_size;
59 
60  tt_size = ff_tag_tree_size(w, h);
61 
62  t = res = av_mallocz_array(tt_size, sizeof(*t));
63  if (!res)
64  return NULL;
65 
66  while (w > 1 || h > 1) {
67  int i, j;
68  pw = w;
69  ph = h;
70 
71  w = (w + 1) >> 1;
72  h = (h + 1) >> 1;
73  t2 = t + pw * ph;
74 
75  for (i = 0; i < ph; i++)
76  for (j = 0; j < pw; j++)
77  t[i * pw + j].parent = &t2[(i >> 1) * w + (j >> 1)];
78 
79  t = t2;
80  }
81  t[0].parent = NULL;
82  return res;
83 }
84 
85 void ff_tag_tree_zero(Jpeg2000TgtNode *t, int w, int h, int val)
86 {
87  int i, siz = ff_tag_tree_size(w, h);
88 
89  for (i = 0; i < siz; i++) {
90  t[i].val = val;
91  t[i].temp_val = 0;
92  t[i].vis = 0;
93  }
94 }
95 
97 
98 static int getsigctxno(int flag, int bandno)
99 {
100  int h, v, d;
101 
102  h = ((flag & JPEG2000_T1_SIG_E) ? 1 : 0) +
103  ((flag & JPEG2000_T1_SIG_W) ? 1 : 0);
104  v = ((flag & JPEG2000_T1_SIG_N) ? 1 : 0) +
105  ((flag & JPEG2000_T1_SIG_S) ? 1 : 0);
106  d = ((flag & JPEG2000_T1_SIG_NE) ? 1 : 0) +
107  ((flag & JPEG2000_T1_SIG_NW) ? 1 : 0) +
108  ((flag & JPEG2000_T1_SIG_SE) ? 1 : 0) +
109  ((flag & JPEG2000_T1_SIG_SW) ? 1 : 0);
110 
111  if (bandno < 3) {
112  if (bandno == 1)
113  FFSWAP(int, h, v);
114  if (h == 2) return 8;
115  if (h == 1) {
116  if (v >= 1) return 7;
117  if (d >= 1) return 6;
118  return 5;
119  }
120  if (v == 2) return 4;
121  if (v == 1) return 3;
122  if (d >= 2) return 2;
123  if (d == 1) return 1;
124  } else {
125  if (d >= 3) return 8;
126  if (d == 2) {
127  if (h+v >= 1) return 7;
128  return 6;
129  }
130  if (d == 1) {
131  if (h+v >= 2) return 5;
132  if (h+v == 1) return 4;
133  return 3;
134  }
135  if (h+v >= 2) return 2;
136  if (h+v == 1) return 1;
137  }
138  return 0;
139 }
140 
142 
143 static const int contribtab[3][3] = { { 0, -1, 1 }, { -1, -1, 0 }, { 1, 0, 1 } };
144 static const int ctxlbltab[3][3] = { { 13, 12, 11 }, { 10, 9, 10 }, { 11, 12, 13 } };
145 static const int xorbittab[3][3] = { { 1, 1, 1 }, { 1, 0, 0 }, { 0, 0, 0 } };
146 
147 static int getsgnctxno(int flag, uint8_t *xorbit)
148 {
149  int vcontrib, hcontrib;
150 
151  hcontrib = contribtab[flag & JPEG2000_T1_SIG_E ? flag & JPEG2000_T1_SGN_E ? 1 : 2 : 0]
152  [flag & JPEG2000_T1_SIG_W ? flag & JPEG2000_T1_SGN_W ? 1 : 2 : 0] + 1;
153  vcontrib = contribtab[flag & JPEG2000_T1_SIG_S ? flag & JPEG2000_T1_SGN_S ? 1 : 2 : 0]
154  [flag & JPEG2000_T1_SIG_N ? flag & JPEG2000_T1_SGN_N ? 1 : 2 : 0] + 1;
155  *xorbit = xorbittab[hcontrib][vcontrib];
156 
157  return ctxlbltab[hcontrib][vcontrib];
158 }
159 
161 {
162  int i, j;
163  for (i = 0; i < 256; i++)
164  for (j = 0; j < 4; j++)
166  for (i = 0; i < 16; i++)
167  for (j = 0; j < 16; j++)
169  getsgnctxno(i + (j << 8), &ff_jpeg2000_xorbit_lut[i][j]);
170 }
171 
173  int negative)
174 {
175  x++;
176  y++;
177  t1->flags[(y) * t1->stride + x] |= JPEG2000_T1_SIG;
178  if (negative) {
179  t1->flags[(y) * t1->stride + x + 1] |= JPEG2000_T1_SIG_W | JPEG2000_T1_SGN_W;
180  t1->flags[(y) * t1->stride + x - 1] |= JPEG2000_T1_SIG_E | JPEG2000_T1_SGN_E;
181  t1->flags[(y + 1) * t1->stride + x] |= JPEG2000_T1_SIG_N | JPEG2000_T1_SGN_N;
182  t1->flags[(y - 1) * t1->stride + x] |= JPEG2000_T1_SIG_S | JPEG2000_T1_SGN_S;
183  } else {
184  t1->flags[(y) * t1->stride + x + 1] |= JPEG2000_T1_SIG_W;
185  t1->flags[(y) * t1->stride + x - 1] |= JPEG2000_T1_SIG_E;
186  t1->flags[(y + 1) * t1->stride + x] |= JPEG2000_T1_SIG_N;
187  t1->flags[(y - 1) * t1->stride + x] |= JPEG2000_T1_SIG_S;
188  }
189  t1->flags[(y + 1) * t1->stride + x + 1] |= JPEG2000_T1_SIG_NW;
190  t1->flags[(y + 1) * t1->stride + x - 1] |= JPEG2000_T1_SIG_NE;
191  t1->flags[(y - 1) * t1->stride + x + 1] |= JPEG2000_T1_SIG_SW;
192  t1->flags[(y - 1) * t1->stride + x - 1] |= JPEG2000_T1_SIG_SE;
193 }
194 
195 // static const uint8_t lut_gain[2][4] = { { 0, 0, 0, 0 }, { 0, 1, 1, 2 } }; (unused)
196 
198  Jpeg2000Band *band,
199  Jpeg2000CodingStyle *codsty,
200  Jpeg2000QuantStyle *qntsty,
201  int bandno, int gbandno, int reslevelno,
202  int cbps)
203 {
204  /* TODO: Implementation of quantization step not finished,
205  * see ISO/IEC 15444-1:2002 E.1 and A.6.4. */
206  switch (qntsty->quantsty) {
207  uint8_t gain;
208  case JPEG2000_QSTY_NONE:
209  /* TODO: to verify. No quantization in this case */
210  band->f_stepsize = 1;
211  break;
212  case JPEG2000_QSTY_SI:
213  /*TODO: Compute formula to implement. */
214 // numbps = cbps +
215 // lut_gain[codsty->transform == FF_DWT53][bandno + (reslevelno > 0)];
216 // band->f_stepsize = SHL(2048 + qntsty->mant[gbandno],
217 // 2 + numbps - qntsty->expn[gbandno]);
218 // break;
219  case JPEG2000_QSTY_SE:
220  /* Exponent quantization step.
221  * Formula:
222  * delta_b = 2 ^ (R_b - expn_b) * (1 + (mant_b / 2 ^ 11))
223  * R_b = R_I + log2 (gain_b )
224  * see ISO/IEC 15444-1:2002 E.1.1 eqn. E-3 and E-4 */
225  gain = cbps;
226  band->f_stepsize = ff_exp2fi(gain - qntsty->expn[gbandno]);
227  band->f_stepsize *= qntsty->mant[gbandno] / 2048.0 + 1.0;
228  break;
229  default:
230  band->f_stepsize = 0;
231  av_log(avctx, AV_LOG_ERROR, "Unknown quantization format\n");
232  break;
233  }
234  if (codsty->transform != FF_DWT53) {
235  int lband = 0;
236  switch (bandno + (reslevelno > 0)) {
237  case 1:
238  case 2:
239  band->f_stepsize *= F_LFTG_X * 2;
240  lband = 1;
241  break;
242  case 3:
243  band->f_stepsize *= F_LFTG_X * F_LFTG_X * 4;
244  break;
245  }
246  if (codsty->transform == FF_DWT97) {
247  band->f_stepsize *= pow(F_LFTG_K, 2*(codsty->nreslevels2decode - reslevelno) + lband - 2);
248  }
249  }
250 
251  if (band->f_stepsize > (INT_MAX >> 15)) {
252  band->f_stepsize = 0;
253  av_log(avctx, AV_LOG_ERROR, "stepsize out of range\n");
254  }
255 
256  band->i_stepsize = band->f_stepsize * (1 << 15);
257 
258  /* FIXME: In OpenJPEG code stepsize = stepsize * 0.5. Why?
259  * If not set output of entropic decoder is not correct. */
260  if (!av_codec_is_encoder(avctx->codec))
261  band->f_stepsize *= 0.5;
262 }
263 
264 static int init_prec(AVCodecContext *avctx,
265  Jpeg2000Band *band,
266  Jpeg2000ResLevel *reslevel,
268  Jpeg2000CodingStyle *codsty,
269  int precno, int bandno, int reslevelno,
270  int log2_band_prec_width,
271  int log2_band_prec_height)
272 {
273  Jpeg2000Prec *prec = band->prec + precno;
274  int nb_codeblocks, cblkno;
275 
276  prec->decoded_layers = 0;
277 
278  /* TODO: Explain formula for JPEG200 DCINEMA. */
279  /* TODO: Verify with previous count of codeblocks per band */
280 
281  /* Compute P_x0 */
282  prec->coord[0][0] = ((reslevel->coord[0][0] >> reslevel->log2_prec_width) + precno % reslevel->num_precincts_x) *
283  (1 << log2_band_prec_width);
284 
285  /* Compute P_y0 */
286  prec->coord[1][0] = ((reslevel->coord[1][0] >> reslevel->log2_prec_height) + precno / reslevel->num_precincts_x) *
287  (1 << log2_band_prec_height);
288 
289  /* Compute P_x1 */
290  prec->coord[0][1] = prec->coord[0][0] +
291  (1 << log2_band_prec_width);
292  prec->coord[0][0] = FFMAX(prec->coord[0][0], band->coord[0][0]);
293  prec->coord[0][1] = FFMIN(prec->coord[0][1], band->coord[0][1]);
294 
295  /* Compute P_y1 */
296  prec->coord[1][1] = prec->coord[1][0] +
297  (1 << log2_band_prec_height);
298  prec->coord[1][0] = FFMAX(prec->coord[1][0], band->coord[1][0]);
299  prec->coord[1][1] = FFMIN(prec->coord[1][1], band->coord[1][1]);
300 
301  prec->nb_codeblocks_width =
302  ff_jpeg2000_ceildivpow2(prec->coord[0][1],
303  band->log2_cblk_width)
304  - (prec->coord[0][0] >> band->log2_cblk_width);
305  prec->nb_codeblocks_height =
306  ff_jpeg2000_ceildivpow2(prec->coord[1][1],
307  band->log2_cblk_height)
308  - (prec->coord[1][0] >> band->log2_cblk_height);
309 
310 
311  /* Tag trees initialization */
312  prec->cblkincl =
314  prec->nb_codeblocks_height);
315  if (!prec->cblkincl)
316  return AVERROR(ENOMEM);
317 
318  prec->zerobits =
320  prec->nb_codeblocks_height);
321  if (!prec->zerobits)
322  return AVERROR(ENOMEM);
323 
324  if (prec->nb_codeblocks_width * (uint64_t)prec->nb_codeblocks_height > INT_MAX) {
325  prec->cblk = NULL;
326  return AVERROR(ENOMEM);
327  }
328  nb_codeblocks = prec->nb_codeblocks_width * prec->nb_codeblocks_height;
329  prec->cblk = av_mallocz_array(nb_codeblocks, sizeof(*prec->cblk));
330  if (!prec->cblk)
331  return AVERROR(ENOMEM);
332  for (cblkno = 0; cblkno < nb_codeblocks; cblkno++) {
333  Jpeg2000Cblk *cblk = prec->cblk + cblkno;
334  int Cx0, Cy0;
335 
336  /* Compute coordinates of codeblocks */
337  /* Compute Cx0*/
338  Cx0 = ((prec->coord[0][0]) >> band->log2_cblk_width) << band->log2_cblk_width;
339  Cx0 = Cx0 + ((cblkno % prec->nb_codeblocks_width) << band->log2_cblk_width);
340  cblk->coord[0][0] = FFMAX(Cx0, prec->coord[0][0]);
341 
342  /* Compute Cy0*/
343  Cy0 = ((prec->coord[1][0]) >> band->log2_cblk_height) << band->log2_cblk_height;
344  Cy0 = Cy0 + ((cblkno / prec->nb_codeblocks_width) << band->log2_cblk_height);
345  cblk->coord[1][0] = FFMAX(Cy0, prec->coord[1][0]);
346 
347  /* Compute Cx1 */
348  cblk->coord[0][1] = FFMIN(Cx0 + (1 << band->log2_cblk_width),
349  prec->coord[0][1]);
350 
351  /* Compute Cy1 */
352  cblk->coord[1][1] = FFMIN(Cy0 + (1 << band->log2_cblk_height),
353  prec->coord[1][1]);
354  /* Update code-blocks coordinates according sub-band position */
355  if ((bandno + !!reslevelno) & 1) {
356  cblk->coord[0][0] += comp->reslevel[reslevelno-1].coord[0][1] -
357  comp->reslevel[reslevelno-1].coord[0][0];
358  cblk->coord[0][1] += comp->reslevel[reslevelno-1].coord[0][1] -
359  comp->reslevel[reslevelno-1].coord[0][0];
360  }
361  if ((bandno + !!reslevelno) & 2) {
362  cblk->coord[1][0] += comp->reslevel[reslevelno-1].coord[1][1] -
363  comp->reslevel[reslevelno-1].coord[1][0];
364  cblk->coord[1][1] += comp->reslevel[reslevelno-1].coord[1][1] -
365  comp->reslevel[reslevelno-1].coord[1][0];
366  }
367 
368  cblk->lblock = 3;
369  cblk->length = 0;
370  cblk->npasses = 0;
371  if (av_codec_is_encoder(avctx->codec)) {
372  cblk->layers = av_mallocz_array(codsty->nlayers, sizeof(*cblk->layers));
373  if (!cblk->layers)
374  return AVERROR(ENOMEM);
375  }
376  }
377 
378  return 0;
379 }
380 
381 static int init_band(AVCodecContext *avctx,
382  Jpeg2000ResLevel *reslevel,
384  Jpeg2000CodingStyle *codsty,
385  Jpeg2000QuantStyle *qntsty,
386  int bandno, int gbandno, int reslevelno,
387  int cbps, int dx, int dy)
388 {
389  Jpeg2000Band *band = reslevel->band + bandno;
390  uint8_t log2_band_prec_width, log2_band_prec_height;
391  int declvl = codsty->nreslevels - reslevelno; // N_L -r see ISO/IEC 15444-1:2002 B.5
392  int precno;
393  int nb_precincts;
394  int i, j, ret;
395 
396  init_band_stepsize(avctx, band, codsty, qntsty, bandno, gbandno, reslevelno, cbps);
397 
398  /* computation of tbx_0, tbx_1, tby_0, tby_1
399  * see ISO/IEC 15444-1:2002 B.5 eq. B-15 and tbl B.1
400  * codeblock width and height is computed for
401  * DCI JPEG 2000 codeblock_width = codeblock_width = 32 = 2 ^ 5 */
402  if (reslevelno == 0) {
403  /* for reslevelno = 0, only one band, x0_b = y0_b = 0 */
404  for (i = 0; i < 2; i++)
405  for (j = 0; j < 2; j++)
406  band->coord[i][j] =
407  ff_jpeg2000_ceildivpow2(comp->coord_o[i][j],
408  declvl - 1);
409  log2_band_prec_width = reslevel->log2_prec_width;
410  log2_band_prec_height = reslevel->log2_prec_height;
411  /* see ISO/IEC 15444-1:2002 eq. B-17 and eq. B-15 */
412  band->log2_cblk_width = FFMIN(codsty->log2_cblk_width,
413  reslevel->log2_prec_width);
414  band->log2_cblk_height = FFMIN(codsty->log2_cblk_height,
415  reslevel->log2_prec_height);
416  } else {
417  /* 3 bands x0_b = 1 y0_b = 0; x0_b = 0 y0_b = 1; x0_b = y0_b = 1 */
418  /* x0_b and y0_b are computed with ((bandno + 1 >> i) & 1) */
419  for (i = 0; i < 2; i++)
420  for (j = 0; j < 2; j++)
421  /* Formula example for tbx_0 = ceildiv((tcx_0 - 2 ^ (declvl - 1) * x0_b) / declvl) */
422  band->coord[i][j] =
423  ff_jpeg2000_ceildivpow2(comp->coord_o[i][j] -
424  (((bandno + 1 >> i) & 1LL) << declvl - 1),
425  declvl);
426  /* TODO: Manage case of 3 band offsets here or
427  * in coding/decoding function? */
428 
429  /* see ISO/IEC 15444-1:2002 eq. B-17 and eq. B-15 */
430  band->log2_cblk_width = FFMIN(codsty->log2_cblk_width,
431  reslevel->log2_prec_width - 1);
432  band->log2_cblk_height = FFMIN(codsty->log2_cblk_height,
433  reslevel->log2_prec_height - 1);
434 
435  log2_band_prec_width = reslevel->log2_prec_width - 1;
436  log2_band_prec_height = reslevel->log2_prec_height - 1;
437  }
438 
439  if (reslevel->num_precincts_x * (uint64_t)reslevel->num_precincts_y > INT_MAX) {
440  band->prec = NULL;
441  return AVERROR(ENOMEM);
442  }
443  nb_precincts = reslevel->num_precincts_x * reslevel->num_precincts_y;
444  band->prec = av_mallocz_array(nb_precincts, sizeof(*band->prec));
445  if (!band->prec)
446  return AVERROR(ENOMEM);
447 
448  for (precno = 0; precno < nb_precincts; precno++) {
449  ret = init_prec(avctx, band, reslevel, comp, codsty,
450  precno, bandno, reslevelno,
451  log2_band_prec_width, log2_band_prec_height);
452  if (ret < 0)
453  return ret;
454  }
455 
456  return 0;
457 }
458 
460  Jpeg2000CodingStyle *codsty,
461  Jpeg2000QuantStyle *qntsty,
462  int cbps, int dx, int dy,
463  AVCodecContext *avctx)
464 {
465  int reslevelno, bandno, gbandno = 0, ret, i, j;
466  uint32_t csize;
467 
468  if (codsty->nreslevels2decode <= 0) {
469  av_log(avctx, AV_LOG_ERROR, "nreslevels2decode %d invalid or uninitialized\n", codsty->nreslevels2decode);
470  return AVERROR_INVALIDDATA;
471  }
472 
473  if (ret = ff_jpeg2000_dwt_init(&comp->dwt, comp->coord,
474  codsty->nreslevels2decode - 1,
475  codsty->transform))
476  return ret;
477 
478  if (av_image_check_size(comp->coord[0][1] - comp->coord[0][0],
479  comp->coord[1][1] - comp->coord[1][0], 0, avctx))
480  return AVERROR_INVALIDDATA;
481  csize = (comp->coord[0][1] - comp->coord[0][0]) *
482  (comp->coord[1][1] - comp->coord[1][0]);
483  if (comp->coord[0][1] - comp->coord[0][0] > 32768 ||
484  comp->coord[1][1] - comp->coord[1][0] > 32768) {
485  av_log(avctx, AV_LOG_ERROR, "component size too large\n");
486  return AVERROR_PATCHWELCOME;
487  }
488 
489  if (codsty->transform == FF_DWT97) {
490  csize += AV_INPUT_BUFFER_PADDING_SIZE / sizeof(*comp->f_data);
491  comp->i_data = NULL;
492  comp->f_data = av_mallocz_array(csize, sizeof(*comp->f_data));
493  if (!comp->f_data)
494  return AVERROR(ENOMEM);
495  } else {
496  csize += AV_INPUT_BUFFER_PADDING_SIZE / sizeof(*comp->i_data);
497  comp->f_data = NULL;
498  comp->i_data = av_mallocz_array(csize, sizeof(*comp->i_data));
499  if (!comp->i_data)
500  return AVERROR(ENOMEM);
501  }
502  comp->reslevel = av_mallocz_array(codsty->nreslevels, sizeof(*comp->reslevel));
503  if (!comp->reslevel)
504  return AVERROR(ENOMEM);
505  /* LOOP on resolution levels */
506  for (reslevelno = 0; reslevelno < codsty->nreslevels; reslevelno++) {
507  int declvl = codsty->nreslevels - reslevelno; // N_L -r see ISO/IEC 15444-1:2002 B.5
508  Jpeg2000ResLevel *reslevel = comp->reslevel + reslevelno;
509 
510  /* Compute borders for each resolution level.
511  * Computation of trx_0, trx_1, try_0 and try_1.
512  * see ISO/IEC 15444-1:2002 eq. B.5 and B-14 */
513  for (i = 0; i < 2; i++)
514  for (j = 0; j < 2; j++)
515  reslevel->coord[i][j] =
516  ff_jpeg2000_ceildivpow2(comp->coord_o[i][j], declvl - 1);
517  // update precincts size: 2^n value
518  reslevel->log2_prec_width = codsty->log2_prec_widths[reslevelno];
519  reslevel->log2_prec_height = codsty->log2_prec_heights[reslevelno];
520 
521  /* Number of bands for each resolution level */
522  if (reslevelno == 0)
523  reslevel->nbands = 1;
524  else
525  reslevel->nbands = 3;
526 
527  /* Number of precincts which span the tile for resolution level reslevelno
528  * see B.6 in ISO/IEC 15444-1:2002 eq. B-16
529  * num_precincts_x = |- trx_1 / 2 ^ log2_prec_width) -| - (trx_0 / 2 ^ log2_prec_width)
530  * num_precincts_y = |- try_1 / 2 ^ log2_prec_width) -| - (try_0 / 2 ^ log2_prec_width)
531  * for Dcinema profiles in JPEG 2000
532  * num_precincts_x = |- trx_1 / 2 ^ log2_prec_width) -|
533  * num_precincts_y = |- try_1 / 2 ^ log2_prec_width) -| */
534  if (reslevel->coord[0][1] == reslevel->coord[0][0])
535  reslevel->num_precincts_x = 0;
536  else
537  reslevel->num_precincts_x =
538  ff_jpeg2000_ceildivpow2(reslevel->coord[0][1],
539  reslevel->log2_prec_width) -
540  (reslevel->coord[0][0] >> reslevel->log2_prec_width);
541 
542  if (reslevel->coord[1][1] == reslevel->coord[1][0])
543  reslevel->num_precincts_y = 0;
544  else
545  reslevel->num_precincts_y =
546  ff_jpeg2000_ceildivpow2(reslevel->coord[1][1],
547  reslevel->log2_prec_height) -
548  (reslevel->coord[1][0] >> reslevel->log2_prec_height);
549 
550  reslevel->band = av_mallocz_array(reslevel->nbands, sizeof(*reslevel->band));
551  if (!reslevel->band)
552  return AVERROR(ENOMEM);
553 
554  if (reslevel->num_precincts_x * (uint64_t)reslevel->num_precincts_y * reslevel->nbands > avctx->max_pixels / sizeof(*reslevel->band->prec))
555  return AVERROR(ENOMEM);
556 
557  for (bandno = 0; bandno < reslevel->nbands; bandno++, gbandno++) {
558  ret = init_band(avctx, reslevel,
559  comp, codsty, qntsty,
560  bandno, gbandno, reslevelno,
561  cbps, dx, dy);
562  if (ret < 0)
563  return ret;
564  }
565  }
566  return 0;
567 }
568 
570 {
571  int reslevelno, bandno, cblkno, precno;
572  for (reslevelno = 0; reslevelno < codsty->nreslevels; reslevelno++) {
573  Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
574  for (bandno = 0; bandno < rlevel->nbands; bandno++) {
575  Jpeg2000Band *band = rlevel->band + bandno;
576  for(precno = 0; precno < rlevel->num_precincts_x * rlevel->num_precincts_y; precno++) {
577  Jpeg2000Prec *prec = band->prec + precno;
580  for (cblkno = 0; cblkno < prec->nb_codeblocks_width * prec->nb_codeblocks_height; cblkno++) {
581  Jpeg2000Cblk *cblk = prec->cblk + cblkno;
582  cblk->length = 0;
583  cblk->lblock = 3;
584  }
585  }
586  }
587  }
588 }
589 
591 {
592  int reslevelno, bandno, precno;
593  for (reslevelno = 0;
594  comp->reslevel && reslevelno < codsty->nreslevels;
595  reslevelno++) {
596  Jpeg2000ResLevel *reslevel;
597 
598  if (!comp->reslevel)
599  continue;
600 
601  reslevel = comp->reslevel + reslevelno;
602  for (bandno = 0; bandno < reslevel->nbands; bandno++) {
603  Jpeg2000Band *band;
604 
605  if (!reslevel->band)
606  continue;
607 
608  band = reslevel->band + bandno;
609  for (precno = 0; precno < reslevel->num_precincts_x * reslevel->num_precincts_y; precno++) {
610  if (band->prec) {
611  Jpeg2000Prec *prec = band->prec + precno;
612  int nb_code_blocks = prec->nb_codeblocks_height * prec->nb_codeblocks_width;
613 
614  av_freep(&prec->zerobits);
615  av_freep(&prec->cblkincl);
616  if (prec->cblk) {
617  int cblkno;
618  for (cblkno = 0; cblkno < nb_code_blocks; cblkno ++) {
619  Jpeg2000Cblk *cblk = &prec->cblk[cblkno];
620  av_freep(&cblk->data);
621  av_freep(&cblk->passes);
622  av_freep(&cblk->lengthinc);
623  av_freep(&cblk->data_start);
624  av_freep(&cblk->layers);
625  }
626  av_freep(&prec->cblk);
627  }
628  }
629  }
630 
631  av_freep(&band->prec);
632  }
633  av_freep(&reslevel->band);
634  }
635 
636  ff_dwt_destroy(&comp->dwt);
637  av_freep(&comp->reslevel);
638  av_freep(&comp->i_data);
639  av_freep(&comp->f_data);
640 }
uint8_t ff_jpeg2000_sgnctxno_lut[16][16]
Definition: jpeg2000.c:141
#define NULL
Definition: coverity.c:32
const struct AVCodec * codec
Definition: avcodec.h:535
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
void av_cold ff_jpeg2000_init_tier1_luts(void)
Definition: jpeg2000.c:160
void ff_jpeg2000_cleanup(Jpeg2000Component *comp, Jpeg2000CodingStyle *codsty)
Definition: jpeg2000.c:590
DWTContext dwt
Definition: jpeg2000.h:220
int av_codec_is_encoder(const AVCodec *codec)
Definition: utils.c:96
Jpeg2000TgtNode * cblkincl
Definition: jpeg2000.h:196
misc image utilities
Memory handling functions.
float * f_data
Definition: jpeg2000.h:221
int nb_codeblocks_width
Definition: jpeg2000.h:193
uint16_t mant[JPEG2000_MAX_DECLEVELS *3]
Definition: jpeg2000.h:153
static const int contribtab[3][3]
Definition: jpeg2000.c:143
static const int xorbittab[3][3]
Definition: jpeg2000.c:145
float f_stepsize
Definition: jpeg2000.h:206
static Jpeg2000TgtNode * ff_jpeg2000_tag_tree_init(int w, int h)
Definition: jpeg2000.c:54
Macro definitions for various function/variable attributes.
uint8_t npasses
Definition: jpeg2000.h:174
#define JPEG2000_T1_SIG_W
Definition: jpeg2000.h:79
uint16_t log2_cblk_width
Definition: jpeg2000.h:204
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
int * data_start
Definition: jpeg2000.h:186
uint8_t
#define av_cold
Definition: attributes.h:88
Jpeg2000TgtNode * zerobits
Definition: jpeg2000.h:195
Jpeg2000Band * band
Definition: jpeg2000.h:215
uint8_t val
Definition: jpeg2000.h:129
int coord[2][2]
Definition: jpeg2000.h:223
#define JPEG2000_T1_SIG_NE
Definition: jpeg2000.h:81
#define JPEG2000_T1_SIG_SE
Definition: jpeg2000.h:83
static const int ctxlbltab[3][3]
Definition: jpeg2000.c:144
uint16_t flags[6156]
Definition: jpeg2000.h:123
#define av_log(a,...)
uint16_t * lengthinc
Definition: jpeg2000.h:179
uint8_t log2_prec_widths[JPEG2000_MAX_RESLEVELS]
Definition: jpeg2000.h:146
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
int ff_jpeg2000_dwt_init(DWTContext *s, int border[2][2], int decomp_levels, int type)
Initialize DWT.
Definition: jpeg2000dwt.c:537
static int init_band(AVCodecContext *avctx, Jpeg2000ResLevel *reslevel, Jpeg2000Component *comp, Jpeg2000CodingStyle *codsty, Jpeg2000QuantStyle *qntsty, int bandno, int gbandno, int reslevelno, int cbps, int dx, int dy)
Definition: jpeg2000.c:381
void ff_jpeg2000_set_significance(Jpeg2000T1Context *t1, int x, int y, int negative)
Definition: jpeg2000.c:172
#define F_LFTG_X
Definition: jpeg2000dwt.h:34
int nb_codeblocks_height
Definition: jpeg2000.h:194
uint8_t log2_prec_heights[JPEG2000_MAX_RESLEVELS]
Definition: jpeg2000.h:147
#define t1
Definition: regdef.h:29
simple assert() macros that are a bit more flexible than ISO C assert().
int64_t max_pixels
The number of pixels per image to maximally accept.
Definition: avcodec.h:2256
static void init_band_stepsize(AVCodecContext *avctx, Jpeg2000Band *band, Jpeg2000CodingStyle *codsty, Jpeg2000QuantStyle *qntsty, int bandno, int gbandno, int reslevelno, int cbps)
Definition: jpeg2000.c:197
static av_always_inline float ff_exp2fi(int x)
2^(x) for integer x
Definition: internal.h:276
Jpeg2000Cblk * cblk
Definition: jpeg2000.h:197
#define FFMAX(a, b)
Definition: common.h:94
int av_image_check_size(unsigned int w, unsigned int h, int log_offset, void *log_ctx)
Check if the given dimension of an image is valid, meaning that all bytes of the image can be address...
Definition: imgutils.c:317
uint8_t lblock
Definition: jpeg2000.h:181
#define FFMIN(a, b)
Definition: common.h:96
struct Jpeg2000TgtNode * parent
Definition: jpeg2000.h:132
#define JPEG2000_T1_SGN_S
Definition: jpeg2000.h:91
JPEG 2000 structures and defines common to encoder and decoder.
uint8_t w
Definition: llviddspenc.c:38
int i_stepsize
Definition: jpeg2000.h:205
void ff_dwt_destroy(DWTContext *s)
Definition: jpeg2000dwt.c:620
int32_t
#define JPEG2000_T1_SIG_N
Definition: jpeg2000.h:77
Jpeg2000Layer * layers
Definition: jpeg2000.h:188
int coord[2][2]
Definition: jpeg2000.h:212
int coord[2][2]
Definition: jpeg2000.h:189
uint8_t * data
Definition: jpeg2000.h:182
if(ret)
static int ff_jpeg2000_ceildivpow2(int a, int b)
Definition: jpeg2000.h:229
static void comp(unsigned char *dst, ptrdiff_t dst_stride, unsigned char *src, ptrdiff_t src_stride, int add)
Definition: eamad.c:83
int coord[2][2]
Definition: jpeg2000.h:203
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
int coord_o[2][2]
Definition: jpeg2000.h:224
Libavcodec external API header.
int coord[2][2]
Definition: jpeg2000.h:199
main external API structure.
Definition: avcodec.h:526
uint8_t vis
Definition: jpeg2000.h:131
uint8_t log2_prec_height
Definition: jpeg2000.h:214
uint16_t length
Definition: jpeg2000.h:178
uint8_t nbands
Definition: jpeg2000.h:211
int decoded_layers
Definition: jpeg2000.h:198
#define JPEG2000_T1_SIG_S
Definition: jpeg2000.h:80
Jpeg2000ResLevel * reslevel
Definition: jpeg2000.h:219
void ff_jpeg2000_reinit(Jpeg2000Component *comp, Jpeg2000CodingStyle *codsty)
Definition: jpeg2000.c:569
#define JPEG2000_T1_SGN_E
Definition: jpeg2000.h:93
uint8_t expn[JPEG2000_MAX_DECLEVELS *3]
Definition: jpeg2000.h:152
uint8_t temp_val
Definition: jpeg2000.h:130
uint8_t quantsty
Definition: jpeg2000.h:154
common internal api header.
common internal and external API header
uint8_t log2_cblk_width
Definition: jpeg2000.h:138
#define flag(name)
Definition: cbs_av1.c:552
#define F_LFTG_K
Definition: jpeg2000dwt.h:33
uint16_t log2_cblk_height
Definition: jpeg2000.h:204
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:215
void ff_tag_tree_zero(Jpeg2000TgtNode *t, int w, int h, int val)
Definition: jpeg2000.c:85
int ff_jpeg2000_init_component(Jpeg2000Component *comp, Jpeg2000CodingStyle *codsty, Jpeg2000QuantStyle *qntsty, int cbps, int dx, int dy, AVCodecContext *avctx)
Definition: jpeg2000.c:459
#define JPEG2000_T1_SIG_SW
Definition: jpeg2000.h:84
#define JPEG2000_T1_SGN_N
Definition: jpeg2000.h:90
static int getsgnctxno(int flag, uint8_t *xorbit)
Definition: jpeg2000.c:147
#define JPEG2000_T1_SIG_E
Definition: jpeg2000.h:78
Jpeg2000Prec * prec
Definition: jpeg2000.h:207
int32_t ff_tag_tree_size(int w, int h)
Definition: jpeg2000.c:42
#define JPEG2000_T1_SIG
Definition: jpeg2000.h:96
#define av_freep(p)
static int getsigctxno(int flag, int bandno)
Definition: jpeg2000.c:98
static int init_prec(AVCodecContext *avctx, Jpeg2000Band *band, Jpeg2000ResLevel *reslevel, Jpeg2000Component *comp, Jpeg2000CodingStyle *codsty, int precno, int bandno, int reslevelno, int log2_band_prec_width, int log2_band_prec_height)
Definition: jpeg2000.c:264
uint8_t log2_cblk_height
Definition: jpeg2000.h:138
#define FFSWAP(type, a, b)
Definition: common.h:99
uint8_t ff_jpeg2000_sigctxno_lut[256][4]
Definition: jpeg2000.c:96
uint8_t log2_prec_width
Definition: jpeg2000.h:214
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
Jpeg2000Pass * passes
Definition: jpeg2000.h:187
#define JPEG2000_T1_SIG_NW
Definition: jpeg2000.h:82
#define JPEG2000_T1_SGN_W
Definition: jpeg2000.h:92
static double val(void *priv, double ch)
Definition: aeval.c:76
#define t2
Definition: regdef.h:30
int i
Definition: input.c:407
void * av_mallocz_array(size_t nmemb, size_t size)
Definition: mem.c:190
uint8_t ff_jpeg2000_xorbit_lut[16][16]
Definition: jpeg2000.c:141