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 
96 uint8_t ff_jpeg2000_sigctxno_lut[256][4];
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 }
contribtab
static const int contribtab[3][3]
Definition: jpeg2000.c:143
AVERROR
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
JPEG2000_T1_SGN_N
#define JPEG2000_T1_SGN_N
Definition: jpeg2000.h:90
Jpeg2000QuantStyle::quantsty
uint8_t quantsty
Definition: jpeg2000.h:154
Jpeg2000Prec::decoded_layers
int decoded_layers
Definition: jpeg2000.h:198
FFSWAP
#define FFSWAP(type, a, b)
Definition: common.h:108
comp
static void comp(unsigned char *dst, ptrdiff_t dst_stride, unsigned char *src, ptrdiff_t src_stride, int add)
Definition: eamad.c:85
ff_jpeg2000_init_component
int ff_jpeg2000_init_component(Jpeg2000Component *comp, Jpeg2000CodingStyle *codsty, Jpeg2000QuantStyle *qntsty, int cbps, int dx, int dy, AVCodecContext *avctx)
Definition: jpeg2000.c:459
JPEG2000_T1_SIG_NE
#define JPEG2000_T1_SIG_NE
Definition: jpeg2000.h:81
JPEG2000_QSTY_NONE
@ JPEG2000_QSTY_NONE
Definition: jpeg2000.h:65
Jpeg2000Prec::nb_codeblocks_height
int nb_codeblocks_height
Definition: jpeg2000.h:194
Jpeg2000Cblk::coord
int coord[2][2]
Definition: jpeg2000.h:189
xorbittab
static const int xorbittab[3][3]
Definition: jpeg2000.c:145
ff_jpeg2000_sgnctxno_lut
uint8_t ff_jpeg2000_sgnctxno_lut[16][16]
Definition: jpeg2000.c:141
Jpeg2000Band::i_stepsize
int i_stepsize
Definition: jpeg2000.h:205
w
uint8_t w
Definition: llviddspenc.c:39
internal.h
Jpeg2000Prec::zerobits
Jpeg2000TgtNode * zerobits
Definition: jpeg2000.h:195
init_band_stepsize
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
Jpeg2000Prec::coord
int coord[2][2]
Definition: jpeg2000.h:199
ff_jpeg2000_sigctxno_lut
uint8_t ff_jpeg2000_sigctxno_lut[256][4]
Definition: jpeg2000.c:96
Jpeg2000Prec
Definition: jpeg2000.h:192
av_mallocz_array
void * av_mallocz_array(size_t nmemb, size_t size)
Definition: mem.c:196
Jpeg2000TgtNode::parent
struct Jpeg2000TgtNode * parent
Definition: jpeg2000.h:132
Jpeg2000Band
Definition: jpeg2000.h:202
t1
#define t1
Definition: regdef.h:29
FF_DWT97
@ FF_DWT97
Definition: jpeg2000dwt.h:37
JPEG2000_T1_SIG_N
#define JPEG2000_T1_SIG_N
Definition: jpeg2000.h:77
Jpeg2000CodingStyle::log2_cblk_width
uint8_t log2_cblk_width
Definition: jpeg2000.h:138
AVCodecContext::codec
const struct AVCodec * codec
Definition: avcodec.h:510
JPEG2000_T1_SGN_E
#define JPEG2000_T1_SGN_E
Definition: jpeg2000.h:93
Jpeg2000Cblk::passes
Jpeg2000Pass * passes
Definition: jpeg2000.h:187
Jpeg2000CodingStyle::log2_prec_heights
uint8_t log2_prec_heights[JPEG2000_MAX_RESLEVELS]
Definition: jpeg2000.h:147
JPEG2000_T1_SIG_E
#define JPEG2000_T1_SIG_E
Definition: jpeg2000.h:78
val
static double val(void *priv, double ch)
Definition: aeval.c:76
Jpeg2000T1Context
Definition: jpeg2000.h:121
avassert.h
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:181
ff_exp2fi
static av_always_inline float ff_exp2fi(int x)
2^(x) for integer x
Definition: internal.h:275
Jpeg2000ResLevel
Definition: jpeg2000.h:210
av_cold
#define av_cold
Definition: attributes.h:90
ff_jpeg2000_tag_tree_init
static Jpeg2000TgtNode * ff_jpeg2000_tag_tree_init(int w, int h)
Definition: jpeg2000.c:54
Jpeg2000CodingStyle::transform
uint8_t transform
Definition: jpeg2000.h:140
Jpeg2000Cblk::layers
Jpeg2000Layer * layers
Definition: jpeg2000.h:188
Jpeg2000ResLevel::band
Jpeg2000Band * band
Definition: jpeg2000.h:215
jpeg2000.h
Jpeg2000Cblk::data
uint8_t * data
Definition: jpeg2000.h:182
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
Jpeg2000Band::coord
int coord[2][2]
Definition: jpeg2000.h:203
init_band
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
AVCodecContext::max_pixels
int64_t max_pixels
The number of pixels per image to maximally accept.
Definition: avcodec.h:1990
JPEG2000_T1_SGN_W
#define JPEG2000_T1_SGN_W
Definition: jpeg2000.h:92
Jpeg2000Band::f_stepsize
float f_stepsize
Definition: jpeg2000.h:206
JPEG2000_QSTY_SI
@ JPEG2000_QSTY_SI
Definition: jpeg2000.h:66
ff_tag_tree_size
int32_t ff_tag_tree_size(int w, int h)
Definition: jpeg2000.c:42
if
if(ret)
Definition: filter_design.txt:179
Jpeg2000Cblk::lblock
uint8_t lblock
Definition: jpeg2000.h:181
JPEG2000_T1_SIG_S
#define JPEG2000_T1_SIG_S
Definition: jpeg2000.h:80
Jpeg2000CodingStyle::log2_prec_widths
uint8_t log2_prec_widths[JPEG2000_MAX_RESLEVELS]
Definition: jpeg2000.h:146
Jpeg2000Cblk::length
uint16_t length
Definition: jpeg2000.h:178
NULL
#define NULL
Definition: coverity.c:32
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
JPEG2000_T1_SIG_W
#define JPEG2000_T1_SIG_W
Definition: jpeg2000.h:79
Jpeg2000Band::prec
Jpeg2000Prec * prec
Definition: jpeg2000.h:207
Jpeg2000ResLevel::num_precincts_y
int num_precincts_y
Definition: jpeg2000.h:213
Jpeg2000ResLevel::coord
int coord[2][2]
Definition: jpeg2000.h:212
F_LFTG_K
#define F_LFTG_K
Definition: jpeg2000dwt.h:33
Jpeg2000Band::log2_cblk_height
uint16_t log2_cblk_height
Definition: jpeg2000.h:204
getsgnctxno
static int getsgnctxno(int flag, uint8_t *xorbit)
Definition: jpeg2000.c:147
Jpeg2000Prec::nb_codeblocks_width
int nb_codeblocks_width
Definition: jpeg2000.h:193
JPEG2000_T1_SIG_SE
#define JPEG2000_T1_SIG_SE
Definition: jpeg2000.h:83
ctxlbltab
static const int ctxlbltab[3][3]
Definition: jpeg2000.c:144
ff_jpeg2000_dwt_init
int ff_jpeg2000_dwt_init(DWTContext *s, int border[2][2], int decomp_levels, int type)
Initialize DWT.
Definition: jpeg2000dwt.c:537
Jpeg2000ResLevel::log2_prec_height
uint8_t log2_prec_height
Definition: jpeg2000.h:214
ff_jpeg2000_cleanup
void ff_jpeg2000_cleanup(Jpeg2000Component *comp, Jpeg2000CodingStyle *codsty)
Definition: jpeg2000.c:590
Jpeg2000Component
Definition: jpeg2000.h:218
JPEG2000_T1_SIG_SW
#define JPEG2000_T1_SIG_SW
Definition: jpeg2000.h:84
Jpeg2000Prec::cblkincl
Jpeg2000TgtNode * cblkincl
Definition: jpeg2000.h:196
Jpeg2000ResLevel::nbands
uint8_t nbands
Definition: jpeg2000.h:211
FFMAX
#define FFMAX(a, b)
Definition: common.h:103
ff_jpeg2000_xorbit_lut
uint8_t ff_jpeg2000_xorbit_lut[16][16]
Definition: jpeg2000.c:141
Jpeg2000Cblk
Definition: jpeg2000.h:173
ff_dwt_destroy
void ff_dwt_destroy(DWTContext *s)
Definition: jpeg2000dwt.c:620
FFMIN
#define FFMIN(a, b)
Definition: common.h:105
attributes.h
Jpeg2000TgtNode
Definition: jpeg2000.h:128
Jpeg2000Cblk::data_start
int * data_start
Definition: jpeg2000.h:186
Jpeg2000CodingStyle::nlayers
uint8_t nlayers
Definition: jpeg2000.h:142
Jpeg2000CodingStyle::nreslevels
int nreslevels
Definition: jpeg2000.h:136
ff_jpeg2000_reinit
void ff_jpeg2000_reinit(Jpeg2000Component *comp, Jpeg2000CodingStyle *codsty)
Definition: jpeg2000.c:569
av_codec_is_encoder
int av_codec_is_encoder(const AVCodec *codec)
Definition: utils.c:74
Jpeg2000TgtNode::temp_val
uint8_t temp_val
Definition: jpeg2000.h:130
flag
#define flag(name)
Definition: cbs_av1.c:553
Jpeg2000CodingStyle::log2_cblk_height
uint8_t log2_cblk_height
Definition: jpeg2000.h:139
i
int i
Definition: input.c:407
Jpeg2000ResLevel::num_precincts_x
int num_precincts_x
Definition: jpeg2000.h:213
Jpeg2000QuantStyle::expn
uint8_t expn[JPEG2000_MAX_DECLEVELS *3]
Definition: jpeg2000.h:152
common.h
Jpeg2000Band::log2_cblk_width
uint16_t log2_cblk_width
Definition: jpeg2000.h:204
F_LFTG_X
#define F_LFTG_X
Definition: jpeg2000dwt.h:34
Jpeg2000QuantStyle::mant
uint16_t mant[JPEG2000_MAX_DECLEVELS *3]
Definition: jpeg2000.h:153
avcodec.h
JPEG2000_T1_SIG
#define JPEG2000_T1_SIG
Definition: jpeg2000.h:96
ret
ret
Definition: filter_design.txt:187
JPEG2000_QSTY_SE
@ JPEG2000_QSTY_SE
Definition: jpeg2000.h:67
getsigctxno
static int getsigctxno(int flag, int bandno)
Definition: jpeg2000.c:98
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: avcodec.h:192
AVCodecContext
main external API structure.
Definition: avcodec.h:501
FF_DWT53
@ FF_DWT53
Definition: jpeg2000dwt.h:38
t2
#define t2
Definition: regdef.h:30
ff_jpeg2000_ceildivpow2
static int ff_jpeg2000_ceildivpow2(int a, int b)
Definition: jpeg2000.h:229
Jpeg2000ResLevel::log2_prec_width
uint8_t log2_prec_width
Definition: jpeg2000.h:214
ff_jpeg2000_init_tier1_luts
void av_cold ff_jpeg2000_init_tier1_luts(void)
Definition: jpeg2000.c:160
JPEG2000_T1_SGN_S
#define JPEG2000_T1_SGN_S
Definition: jpeg2000.h:91
JPEG2000_T1_SIG_NW
#define JPEG2000_T1_SIG_NW
Definition: jpeg2000.h:82
mem.h
Jpeg2000Cblk::npasses
uint8_t npasses
Definition: jpeg2000.h:174
Jpeg2000CodingStyle::nreslevels2decode
int nreslevels2decode
Definition: jpeg2000.h:137
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
ff_jpeg2000_set_significance
void ff_jpeg2000_set_significance(Jpeg2000T1Context *t1, int x, int y, int negative)
Definition: jpeg2000.c:172
d
d
Definition: ffmpeg_filter.c:156
int32_t
int32_t
Definition: audioconvert.c:56
imgutils.h
Jpeg2000TgtNode::val
uint8_t val
Definition: jpeg2000.h:129
Jpeg2000TgtNode::vis
uint8_t vis
Definition: jpeg2000.h:131
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
Jpeg2000CodingStyle
Definition: jpeg2000.h:135
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
Jpeg2000Cblk::lengthinc
uint16_t * lengthinc
Definition: jpeg2000.h:179
h
h
Definition: vp9dsp_template.c:2038
Jpeg2000QuantStyle
Definition: jpeg2000.h:151
av_image_check_size
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:315
Jpeg2000Prec::cblk
Jpeg2000Cblk * cblk
Definition: jpeg2000.h:197
ff_tag_tree_zero
void ff_tag_tree_zero(Jpeg2000TgtNode *t, int w, int h, int val)
Definition: jpeg2000.c:85
init_prec
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