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