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