FFmpeg
on2avc.c
Go to the documentation of this file.
1 /*
2  * On2 Audio for Video Codec decoder
3  *
4  * Copyright (c) 2013 Konstantin Shishkov
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 
24 #include "libavutil/ffmath.h"
25 #include "libavutil/float_dsp.h"
26 #include "libavutil/mem.h"
27 #include "libavutil/mem_internal.h"
28 #include "libavutil/tx.h"
29 
30 #include "avcodec.h"
31 #include "bytestream.h"
32 #include "codec_internal.h"
33 #include "decode.h"
34 #include "get_bits.h"
35 
36 #include "on2avcdata.h"
37 
38 #define ON2AVC_SUBFRAME_SIZE 1024
39 
49 };
50 
51 typedef struct On2AVCContext {
58  void (*wtf)(struct On2AVCContext *ctx, float *out, float *in, int size);
59 
60  int is_av500;
61 
62  const On2AVCMode *modes;
66  const int *band_start;
67 
68  int grouping[8];
71 
72  int is_long;
73 
77 
79 
81  VLC cb_vlc[16];
82 
83  float scale_tab[128];
84 
87 
93 
95 {
96  int w, b, band_off = 0;
97 
98  c->ms_present = get_bits1(gb);
99  if (!c->ms_present)
100  return;
101  for (w = 0; w < c->num_windows; w++) {
102  if (!c->grouping[w]) {
103  memcpy(c->ms_info + band_off,
104  c->ms_info + band_off - c->num_bands,
105  c->num_bands * sizeof(*c->ms_info));
106  band_off += c->num_bands;
107  continue;
108  }
109  for (b = 0; b < c->num_bands; b++)
110  c->ms_info[band_off++] = get_bits1(gb);
111  }
112 }
113 
114 // do not see Table 17 in ISO/IEC 13818-7
116 {
117  int bits_per_sect = c->is_long ? 5 : 3;
118  int esc_val = (1 << bits_per_sect) - 1;
119  int num_bands = c->num_bands * c->num_windows;
120  int band = 0, i, band_type, run_len, run;
121 
122  while (band < num_bands) {
123  band_type = get_bits(gb, 4);
124  run_len = 1;
125  do {
126  run = get_bits(gb, bits_per_sect);
127  if (run > num_bands - band - run_len) {
128  av_log(c->avctx, AV_LOG_ERROR, "Invalid band type run\n");
129  return AVERROR_INVALIDDATA;
130  }
131  run_len += run;
132  } while (run == esc_val);
133  for (i = band; i < band + run_len; i++) {
134  c->band_type[i] = band_type;
135  c->band_run_end[i] = band + run_len;
136  }
137  band += run_len;
138  }
139 
140  return 0;
141 }
142 
143 // completely not like Table 18 in ISO/IEC 13818-7
144 // (no intensity stereo, different coding for the first coefficient)
146 {
147  int w, w2, b, scale, first = 1;
148  int band_off = 0;
149 
150  for (w = 0; w < c->num_windows; w++) {
151  if (!c->grouping[w]) {
152  memcpy(c->band_scales + band_off,
153  c->band_scales + band_off - c->num_bands,
154  c->num_bands * sizeof(*c->band_scales));
155  band_off += c->num_bands;
156  continue;
157  }
158  for (b = 0; b < c->num_bands; b++) {
159  if (!c->band_type[band_off]) {
160  int all_zero = 1;
161  for (w2 = w + 1; w2 < c->num_windows; w2++) {
162  if (c->grouping[w2])
163  break;
164  if (c->band_type[w2 * c->num_bands + b]) {
165  all_zero = 0;
166  break;
167  }
168  }
169  if (all_zero) {
170  c->band_scales[band_off++] = 0;
171  continue;
172  }
173  }
174  if (first) {
175  scale = get_bits(gb, 7);
176  first = 0;
177  } else {
178  scale += get_vlc2(gb, c->scale_diff.table, 9, 3);
179  }
180  if (scale < 0 || scale > 127) {
181  av_log(c->avctx, AV_LOG_ERROR, "Invalid scale value %d\n",
182  scale);
183  return AVERROR_INVALIDDATA;
184  }
185  c->band_scales[band_off++] = c->scale_tab[scale];
186  }
187  }
188 
189  return 0;
190 }
191 
192 static inline float on2avc_scale(int v, float scale)
193 {
194  return v * sqrtf(abs(v)) * scale;
195 }
196 
197 // spectral data is coded completely differently - there are no unsigned codebooks
198 static int on2avc_decode_quads(On2AVCContext *c, GetBitContext *gb, float *dst,
199  int dst_size, int type, float band_scale)
200 {
201  int i, j, val, val1;
202 
203  for (i = 0; i < dst_size; i += 4) {
204  val = get_vlc2(gb, c->cb_vlc[type].table, 9, 2);
205 
206  for (j = 0; j < 4; j++) {
207  val1 = sign_extend((val >> (12 - j * 4)) & 0xF, 4);
208  *dst++ = on2avc_scale(val1, band_scale);
209  }
210  }
211 
212  return 0;
213 }
214 
215 static inline int get_egolomb(GetBitContext *gb)
216 {
217  int v = 4;
218 
219  while (get_bits1(gb)) {
220  v++;
221  if (v > 30) {
222  av_log(NULL, AV_LOG_WARNING, "Too large golomb code in get_egolomb.\n");
223  v = 30;
224  break;
225  }
226  }
227 
228  return (1 << v) + get_bits_long(gb, v);
229 }
230 
231 static int on2avc_decode_pairs(On2AVCContext *c, GetBitContext *gb, float *dst,
232  int dst_size, int type, float band_scale)
233 {
234  int i, val, val1, val2, sign;
235 
236  for (i = 0; i < dst_size; i += 2) {
237  val = get_vlc2(gb, c->cb_vlc[type].table, 9, 2);
238 
239  val1 = sign_extend(val >> 8, 8);
240  val2 = sign_extend(val & 0xFF, 8);
241  if (type == ON2AVC_ESC_CB) {
242  if (val1 <= -16 || val1 >= 16) {
243  sign = 1 - (val1 < 0) * 2;
244  val1 = sign * get_egolomb(gb);
245  }
246  if (val2 <= -16 || val2 >= 16) {
247  sign = 1 - (val2 < 0) * 2;
248  val2 = sign * get_egolomb(gb);
249  }
250  }
251 
252  *dst++ = on2avc_scale(val1, band_scale);
253  *dst++ = on2avc_scale(val2, band_scale);
254  }
255 
256  return 0;
257 }
258 
260 {
261  int ret;
262  int w, b, band_idx;
263  float *coeff_ptr;
264 
265  if ((ret = on2avc_decode_band_types(c, gb)) < 0)
266  return ret;
267  if ((ret = on2avc_decode_band_scales(c, gb)) < 0)
268  return ret;
269 
270  coeff_ptr = c->coeffs[ch];
271  band_idx = 0;
272  memset(coeff_ptr, 0, ON2AVC_SUBFRAME_SIZE * sizeof(*coeff_ptr));
273  for (w = 0; w < c->num_windows; w++) {
274  for (b = 0; b < c->num_bands; b++) {
275  int band_size = c->band_start[b + 1] - c->band_start[b];
276  int band_type = c->band_type[band_idx + b];
277 
278  if (!band_type) {
279  coeff_ptr += band_size;
280  continue;
281  }
282  if (band_type < 9)
283  on2avc_decode_quads(c, gb, coeff_ptr, band_size, band_type,
284  c->band_scales[band_idx + b]);
285  else
286  on2avc_decode_pairs(c, gb, coeff_ptr, band_size, band_type,
287  c->band_scales[band_idx + b]);
288  coeff_ptr += band_size;
289  }
290  band_idx += c->num_bands;
291  }
292 
293  return 0;
294 }
295 
297 {
298  int w, b, i;
299  int band_off = 0;
300  float *ch0 = c->coeffs[0];
301  float *ch1 = c->coeffs[1];
302 
303  for (w = 0; w < c->num_windows; w++) {
304  for (b = 0; b < c->num_bands; b++) {
305  if (c->ms_info[band_off + b]) {
306  for (i = c->band_start[b]; i < c->band_start[b + 1]; i++) {
307  float l = *ch0, r = *ch1;
308  *ch0++ = l + r;
309  *ch1++ = l - r;
310  }
311  } else {
312  ch0 += c->band_start[b + 1] - c->band_start[b];
313  ch1 += c->band_start[b + 1] - c->band_start[b];
314  }
315  }
316  band_off += c->num_bands;
317  }
318  return 0;
319 }
320 
321 static void zero_head_and_tail(float *src, int len, int order0, int order1)
322 {
323  memset(src, 0, sizeof(*src) * order0);
324  memset(src + len - order1, 0, sizeof(*src) * order1);
325 }
326 
327 static void pretwiddle(float *src, float *dst, int dst_len, int tab_step,
328  int step, int order0, int order1, const double * const *tabs)
329 {
330  float *src2, *out;
331  const double *tab;
332  int i, j;
333 
334  out = dst;
335  tab = tabs[0];
336  for (i = 0; i < tab_step; i++) {
337  double sum = 0;
338  for (j = 0; j < order0; j++)
339  sum += src[j] * tab[j * tab_step + i];
340  out[i] += sum;
341  }
342 
343  out = dst + dst_len - tab_step;
344  tab = tabs[order0];
345  src2 = src + (dst_len - tab_step) / step + 1 + order0;
346  for (i = 0; i < tab_step; i++) {
347  double sum = 0;
348  for (j = 0; j < order1; j++)
349  sum += src2[j] * tab[j * tab_step + i];
350  out[i] += sum;
351  }
352 }
353 
354 static void twiddle(float *src1, float *src2, int src2_len,
355  const double *tab, int tab_len, int step,
356  int order0, int order1, const double * const *tabs)
357 {
358  int steps;
359  int mask;
360  int i, j;
361 
362  steps = (src2_len - tab_len) / step + 1;
363  pretwiddle(src1, src2, src2_len, tab_len, step, order0, order1, tabs);
364  mask = tab_len - 1;
365 
366  for (i = 0; i < steps; i++) {
367  float in0 = src1[order0 + i];
368  int pos = (src2_len - 1) & mask;
369 
370  if (pos < tab_len) {
371  const double *t = tab;
372  for (j = pos; j >= 0; j--)
373  src2[j] += in0 * *t++;
374  for (j = 0; j < tab_len - pos - 1; j++)
375  src2[src2_len - j - 1] += in0 * tab[pos + 1 + j];
376  } else {
377  for (j = 0; j < tab_len; j++)
378  src2[pos - j] += in0 * tab[j];
379  }
380  mask = pos + step;
381  }
382 }
383 
384 #define CMUL1_R(s, t, is, it) \
385  s[is + 0] * t[it + 0] - s[is + 1] * t[it + 1]
386 #define CMUL1_I(s, t, is, it) \
387  s[is + 0] * t[it + 1] + s[is + 1] * t[it + 0]
388 #define CMUL2_R(s, t, is, it) \
389  s[is + 0] * t[it + 0] + s[is + 1] * t[it + 1]
390 #define CMUL2_I(s, t, is, it) \
391  s[is + 0] * t[it + 1] - s[is + 1] * t[it + 0]
392 
393 #define CMUL0(dst, id, s0, s1, s2, s3, t0, t1, t2, t3, is, it) \
394  dst[id] = s0[is] * t0[it] + s1[is] * t1[it] \
395  + s2[is] * t2[it] + s3[is] * t3[it]; \
396  dst[id + 1] = s0[is] * t0[it + 1] + s1[is] * t1[it + 1] \
397  + s2[is] * t2[it + 1] + s3[is] * t3[it + 1];
398 
399 #define CMUL1(dst, s0, s1, s2, s3, t0, t1, t2, t3, is, it) \
400  *dst++ = CMUL1_R(s0, t0, is, it) \
401  + CMUL1_R(s1, t1, is, it) \
402  + CMUL1_R(s2, t2, is, it) \
403  + CMUL1_R(s3, t3, is, it); \
404  *dst++ = CMUL1_I(s0, t0, is, it) \
405  + CMUL1_I(s1, t1, is, it) \
406  + CMUL1_I(s2, t2, is, it) \
407  + CMUL1_I(s3, t3, is, it);
408 
409 #define CMUL2(dst, s0, s1, s2, s3, t0, t1, t2, t3, is, it) \
410  *dst++ = CMUL2_R(s0, t0, is, it) \
411  + CMUL2_R(s1, t1, is, it) \
412  + CMUL2_R(s2, t2, is, it) \
413  + CMUL2_R(s3, t3, is, it); \
414  *dst++ = CMUL2_I(s0, t0, is, it) \
415  + CMUL2_I(s1, t1, is, it) \
416  + CMUL2_I(s2, t2, is, it) \
417  + CMUL2_I(s3, t3, is, it);
418 
419 static void combine_fft(float *s0, float *s1, float *s2, float *s3, float *dst,
420  const float *t0, const float *t1,
421  const float *t2, const float *t3, int len, int step)
422 {
423  const float *h0, *h1, *h2, *h3;
424  float *d1, *d2;
425  int tmp, half;
426  int len2 = len >> 1, len4 = len >> 2;
427  int hoff;
428  int i, j, k;
429 
430  tmp = step;
431  for (half = len2; tmp > 1; half <<= 1, tmp >>= 1);
432 
433  h0 = t0 + half;
434  h1 = t1 + half;
435  h2 = t2 + half;
436  h3 = t3 + half;
437 
438  CMUL0(dst, 0, s0, s1, s2, s3, t0, t1, t2, t3, 0, 0);
439 
440  hoff = 2 * step * (len4 >> 1);
441 
442  j = 2;
443  k = 2 * step;
444  d1 = dst + 2;
445  d2 = dst + 2 + (len >> 1);
446  for (i = 0; i < (len4 - 1) >> 1; i++) {
447  CMUL1(d1, s0, s1, s2, s3, t0, t1, t2, t3, j, k);
448  CMUL1(d2, s0, s1, s2, s3, h0, h1, h2, h3, j, k);
449  j += 2;
450  k += 2 * step;
451  }
452  CMUL0(dst, len4, s0, s1, s2, s3, t0, t1, t2, t3, 1, hoff);
453  CMUL0(dst, len4 + len2, s0, s1, s2, s3, h0, h1, h2, h3, 1, hoff);
454 
455  j = len4;
456  k = hoff + 2 * step * len4;
457  d1 = dst + len4 + 2;
458  d2 = dst + len4 + 2 + len2;
459  for (i = 0; i < (len4 - 2) >> 1; i++) {
460  CMUL2(d1, s0, s1, s2, s3, t0, t1, t2, t3, j, k);
461  CMUL2(d2, s0, s1, s2, s3, h0, h1, h2, h3, j, k);
462  j -= 2;
463  k += 2 * step;
464  }
465  CMUL0(dst, len2 + 4, s0, s1, s2, s3, t0, t1, t2, t3, 0, k);
466 }
467 
468 static void wtf_end_512(On2AVCContext *c, float *out, float *src,
469  float *tmp0, float *tmp1)
470 {
471  memcpy(tmp1, tmp0, 384 * sizeof(*tmp0));
472  memcpy(tmp0 + 384, tmp1 + 384, 128 * sizeof(*tmp0));
473 
474  zero_head_and_tail(tmp1, 128, 16, 4);
475  zero_head_and_tail(tmp1 + 128, 128, 16, 4);
476  zero_head_and_tail(tmp1 + 256, 128, 13, 7);
477  zero_head_and_tail(tmp1 + 384, 128, 15, 5);
478 
479  c->fft64_fn(c->fft64, src + 0, tmp1 + 0, sizeof(float));
480  c->fft64_fn(c->fft64, src + 128, tmp1 + 128, sizeof(float));
481  c->fft64_fn(c->fft64, src + 256, tmp1 + 256, sizeof(float));
482  c->fft64_fn(c->fft64, src + 384, tmp1 + 384, sizeof(float));
483 
484  combine_fft(src, src + 128, src + 256, src + 384, tmp1,
487 
488  c->fft256_fn(c->fft256, src, tmp1, sizeof(float));
489 
490  pretwiddle(&tmp0[ 0], src, 512, 84, 4, 16, 4, ff_on2avc_tabs_20_84_1);
491  pretwiddle(&tmp0[128], src, 512, 84, 4, 16, 4, ff_on2avc_tabs_20_84_2);
492  pretwiddle(&tmp0[256], src, 512, 84, 4, 13, 7, ff_on2avc_tabs_20_84_3);
493  pretwiddle(&tmp0[384], src, 512, 84, 4, 15, 5, ff_on2avc_tabs_20_84_4);
494 }
495 
496 static void wtf_end_1024(On2AVCContext *c, float *out, float *src,
497  float *tmp0, float *tmp1)
498 {
499  memcpy(tmp1, tmp0, 768 * sizeof(*tmp0));
500  memcpy(tmp0 + 768, tmp1 + 768, 256 * sizeof(*tmp0));
501 
502  zero_head_and_tail(tmp1, 256, 16, 4);
503  zero_head_and_tail(tmp1 + 256, 256, 16, 4);
504  zero_head_and_tail(tmp1 + 512, 256, 13, 7);
505  zero_head_and_tail(tmp1 + 768, 256, 15, 5);
506 
507  c->fft128_fn(c->fft128, src + 0, tmp1 + 0, sizeof(float));
508  c->fft128_fn(c->fft128, src + 256, tmp1 + 256, sizeof(float));
509  c->fft128_fn(c->fft128, src + 512, tmp1 + 512, sizeof(float));
510  c->fft128_fn(c->fft128, src + 768, tmp1 + 768, sizeof(float));
511 
512  combine_fft(src, src + 256, src + 512, src + 768, tmp1,
515 
516  c->fft512_fn(c->fft512, src, tmp1, sizeof(float));
517 
518  pretwiddle(&tmp0[ 0], src, 1024, 84, 4, 16, 4, ff_on2avc_tabs_20_84_1);
519  pretwiddle(&tmp0[256], src, 1024, 84, 4, 16, 4, ff_on2avc_tabs_20_84_2);
520  pretwiddle(&tmp0[512], src, 1024, 84, 4, 13, 7, ff_on2avc_tabs_20_84_3);
521  pretwiddle(&tmp0[768], src, 1024, 84, 4, 15, 5, ff_on2avc_tabs_20_84_4);
522 }
523 
524 static void wtf_40(On2AVCContext *c, float *out, float *src, int size)
525 {
526  float *tmp0 = c->temp, *tmp1 = c->temp + 1024;
527 
528  memset(tmp0, 0, sizeof(*tmp0) * 1024);
529  memset(tmp1, 0, sizeof(*tmp1) * 1024);
530 
531  if (size == 512) {
532  twiddle(src, &tmp0[ 0], 16, ff_on2avc_tab_10_1, 10, 2, 1, 3, ff_on2avc_tabs_4_10_1);
533  twiddle(src + 8, &tmp0[ 0], 16, ff_on2avc_tab_10_2, 10, 2, 3, 1, ff_on2avc_tabs_4_10_2);
534  twiddle(src + 16, &tmp0[ 16], 16, ff_on2avc_tab_10_2, 10, 2, 3, 1, ff_on2avc_tabs_4_10_2);
535  twiddle(src + 24, &tmp0[ 16], 16, ff_on2avc_tab_10_1, 10, 2, 1, 3, ff_on2avc_tabs_4_10_1);
536  twiddle(src + 32, &tmp0[ 32], 16, ff_on2avc_tab_10_1, 10, 2, 1, 3, ff_on2avc_tabs_4_10_1);
537  twiddle(src + 40, &tmp0[ 32], 16, ff_on2avc_tab_10_2, 10, 2, 3, 1, ff_on2avc_tabs_4_10_2);
538  twiddle(src + 48, &tmp0[ 48], 16, ff_on2avc_tab_10_2, 10, 2, 3, 1, ff_on2avc_tabs_4_10_2);
539  twiddle(src + 56, &tmp0[ 48], 16, ff_on2avc_tab_10_1, 10, 2, 1, 3, ff_on2avc_tabs_4_10_1);
540  twiddle(&tmp0[ 0], &tmp1[ 0], 32, ff_on2avc_tab_20_1, 20, 2, 5, 4, ff_on2avc_tabs_9_20_1);
541  twiddle(&tmp0[16], &tmp1[ 0], 32, ff_on2avc_tab_20_2, 20, 2, 4, 5, ff_on2avc_tabs_9_20_2);
542  twiddle(&tmp0[32], &tmp1[ 32], 32, ff_on2avc_tab_20_2, 20, 2, 4, 5, ff_on2avc_tabs_9_20_2);
543  twiddle(&tmp0[48], &tmp1[ 32], 32, ff_on2avc_tab_20_1, 20, 2, 5, 4, ff_on2avc_tabs_9_20_1);
544  twiddle(src + 64, &tmp1[ 64], 32, ff_on2avc_tab_20_1, 20, 2, 5, 4, ff_on2avc_tabs_9_20_1);
545  twiddle(src + 80, &tmp1[ 64], 32, ff_on2avc_tab_20_2, 20, 2, 4, 5, ff_on2avc_tabs_9_20_2);
546  twiddle(src + 96, &tmp1[ 96], 32, ff_on2avc_tab_20_2, 20, 2, 4, 5, ff_on2avc_tabs_9_20_2);
547  twiddle(src + 112, &tmp1[ 96], 32, ff_on2avc_tab_20_1, 20, 2, 5, 4, ff_on2avc_tabs_9_20_1);
548  twiddle(src + 128, &tmp1[128], 32, ff_on2avc_tab_20_1, 20, 2, 5, 4, ff_on2avc_tabs_9_20_1);
549  twiddle(src + 144, &tmp1[128], 32, ff_on2avc_tab_20_2, 20, 2, 4, 5, ff_on2avc_tabs_9_20_2);
550  twiddle(src + 160, &tmp1[160], 32, ff_on2avc_tab_20_2, 20, 2, 4, 5, ff_on2avc_tabs_9_20_2);
551  twiddle(src + 176, &tmp1[160], 32, ff_on2avc_tab_20_1, 20, 2, 5, 4, ff_on2avc_tabs_9_20_1);
552 
553  memset(tmp0, 0, 64 * sizeof(*tmp0));
554 
555  twiddle(&tmp1[ 0], &tmp0[ 0], 128, ff_on2avc_tab_84_1, 84, 4, 16, 4, ff_on2avc_tabs_20_84_1);
556  twiddle(&tmp1[ 32], &tmp0[ 0], 128, ff_on2avc_tab_84_2, 84, 4, 16, 4, ff_on2avc_tabs_20_84_2);
557  twiddle(&tmp1[ 64], &tmp0[ 0], 128, ff_on2avc_tab_84_3, 84, 4, 13, 7, ff_on2avc_tabs_20_84_3);
558  twiddle(&tmp1[ 96], &tmp0[ 0], 128, ff_on2avc_tab_84_4, 84, 4, 15, 5, ff_on2avc_tabs_20_84_4);
559  twiddle(&tmp1[128], &tmp0[128], 128, ff_on2avc_tab_84_4, 84, 4, 15, 5, ff_on2avc_tabs_20_84_4);
560  twiddle(&tmp1[160], &tmp0[128], 128, ff_on2avc_tab_84_3, 84, 4, 13, 7, ff_on2avc_tabs_20_84_3);
561  twiddle(src + 192, &tmp0[128], 128, ff_on2avc_tab_84_2, 84, 4, 16, 4, ff_on2avc_tabs_20_84_2);
562  twiddle(src + 224, &tmp0[128], 128, ff_on2avc_tab_84_1, 84, 4, 16, 4, ff_on2avc_tabs_20_84_1);
563  twiddle(src + 256, &tmp0[256], 128, ff_on2avc_tab_84_1, 84, 4, 16, 4, ff_on2avc_tabs_20_84_1);
564  twiddle(src + 288, &tmp0[256], 128, ff_on2avc_tab_84_2, 84, 4, 16, 4, ff_on2avc_tabs_20_84_2);
565  twiddle(src + 320, &tmp0[256], 128, ff_on2avc_tab_84_3, 84, 4, 13, 7, ff_on2avc_tabs_20_84_3);
566  twiddle(src + 352, &tmp0[256], 128, ff_on2avc_tab_84_4, 84, 4, 15, 5, ff_on2avc_tabs_20_84_4);
567 
568  wtf_end_512(c, out, src, tmp0, tmp1);
569  } else {
570  twiddle(src, &tmp0[ 0], 32, ff_on2avc_tab_20_1, 20, 2, 5, 4, ff_on2avc_tabs_9_20_1);
571  twiddle(src + 16, &tmp0[ 0], 32, ff_on2avc_tab_20_2, 20, 2, 4, 5, ff_on2avc_tabs_9_20_2);
572  twiddle(src + 32, &tmp0[ 32], 32, ff_on2avc_tab_20_2, 20, 2, 4, 5, ff_on2avc_tabs_9_20_2);
573  twiddle(src + 48, &tmp0[ 32], 32, ff_on2avc_tab_20_1, 20, 2, 5, 4, ff_on2avc_tabs_9_20_1);
574  twiddle(src + 64, &tmp0[ 64], 32, ff_on2avc_tab_20_1, 20, 2, 5, 4, ff_on2avc_tabs_9_20_1);
575  twiddle(src + 80, &tmp0[ 64], 32, ff_on2avc_tab_20_2, 20, 2, 4, 5, ff_on2avc_tabs_9_20_2);
576  twiddle(src + 96, &tmp0[ 96], 32, ff_on2avc_tab_20_2, 20, 2, 4, 5, ff_on2avc_tabs_9_20_2);
577  twiddle(src + 112, &tmp0[ 96], 32, ff_on2avc_tab_20_1, 20, 2, 5, 4, ff_on2avc_tabs_9_20_1);
578  twiddle(&tmp0[ 0], &tmp1[ 0], 64, ff_on2avc_tab_40_1, 40, 2, 11, 8, ff_on2avc_tabs_19_40_1);
579  twiddle(&tmp0[32], &tmp1[ 0], 64, ff_on2avc_tab_40_2, 40, 2, 8, 11, ff_on2avc_tabs_19_40_2);
580  twiddle(&tmp0[64], &tmp1[ 64], 64, ff_on2avc_tab_40_2, 40, 2, 8, 11, ff_on2avc_tabs_19_40_2);
581  twiddle(&tmp0[96], &tmp1[ 64], 64, ff_on2avc_tab_40_1, 40, 2, 11, 8, ff_on2avc_tabs_19_40_1);
582  twiddle(src + 128, &tmp1[128], 64, ff_on2avc_tab_40_1, 40, 2, 11, 8, ff_on2avc_tabs_19_40_1);
583  twiddle(src + 160, &tmp1[128], 64, ff_on2avc_tab_40_2, 40, 2, 8, 11, ff_on2avc_tabs_19_40_2);
584  twiddle(src + 192, &tmp1[192], 64, ff_on2avc_tab_40_2, 40, 2, 8, 11, ff_on2avc_tabs_19_40_2);
585  twiddle(src + 224, &tmp1[192], 64, ff_on2avc_tab_40_1, 40, 2, 11, 8, ff_on2avc_tabs_19_40_1);
586  twiddle(src + 256, &tmp1[256], 64, ff_on2avc_tab_40_1, 40, 2, 11, 8, ff_on2avc_tabs_19_40_1);
587  twiddle(src + 288, &tmp1[256], 64, ff_on2avc_tab_40_2, 40, 2, 8, 11, ff_on2avc_tabs_19_40_2);
588  twiddle(src + 320, &tmp1[320], 64, ff_on2avc_tab_40_2, 40, 2, 8, 11, ff_on2avc_tabs_19_40_2);
589  twiddle(src + 352, &tmp1[320], 64, ff_on2avc_tab_40_1, 40, 2, 11, 8, ff_on2avc_tabs_19_40_1);
590 
591  memset(tmp0, 0, 128 * sizeof(*tmp0));
592 
593  twiddle(&tmp1[ 0], &tmp0[ 0], 256, ff_on2avc_tab_84_1, 84, 4, 16, 4, ff_on2avc_tabs_20_84_1);
594  twiddle(&tmp1[ 64], &tmp0[ 0], 256, ff_on2avc_tab_84_2, 84, 4, 16, 4, ff_on2avc_tabs_20_84_2);
595  twiddle(&tmp1[128], &tmp0[ 0], 256, ff_on2avc_tab_84_3, 84, 4, 13, 7, ff_on2avc_tabs_20_84_3);
596  twiddle(&tmp1[192], &tmp0[ 0], 256, ff_on2avc_tab_84_4, 84, 4, 15, 5, ff_on2avc_tabs_20_84_4);
597  twiddle(&tmp1[256], &tmp0[256], 256, ff_on2avc_tab_84_4, 84, 4, 15, 5, ff_on2avc_tabs_20_84_4);
598  twiddle(&tmp1[320], &tmp0[256], 256, ff_on2avc_tab_84_3, 84, 4, 13, 7, ff_on2avc_tabs_20_84_3);
599  twiddle(src + 384, &tmp0[256], 256, ff_on2avc_tab_84_2, 84, 4, 16, 4, ff_on2avc_tabs_20_84_2);
600  twiddle(src + 448, &tmp0[256], 256, ff_on2avc_tab_84_1, 84, 4, 16, 4, ff_on2avc_tabs_20_84_1);
601  twiddle(src + 512, &tmp0[512], 256, ff_on2avc_tab_84_1, 84, 4, 16, 4, ff_on2avc_tabs_20_84_1);
602  twiddle(src + 576, &tmp0[512], 256, ff_on2avc_tab_84_2, 84, 4, 16, 4, ff_on2avc_tabs_20_84_2);
603  twiddle(src + 640, &tmp0[512], 256, ff_on2avc_tab_84_3, 84, 4, 13, 7, ff_on2avc_tabs_20_84_3);
604  twiddle(src + 704, &tmp0[512], 256, ff_on2avc_tab_84_4, 84, 4, 15, 5, ff_on2avc_tabs_20_84_4);
605 
606  wtf_end_1024(c, out, src, tmp0, tmp1);
607  }
608 }
609 
610 static void wtf_44(On2AVCContext *c, float *out, float *src, int size)
611 {
612  float *tmp0 = c->temp, *tmp1 = c->temp + 1024;
613 
614  memset(tmp0, 0, sizeof(*tmp0) * 1024);
615  memset(tmp1, 0, sizeof(*tmp1) * 1024);
616 
617  if (size == 512) {
618  twiddle(src, &tmp0[ 0], 16, ff_on2avc_tab_10_1, 10, 2, 1, 3, ff_on2avc_tabs_4_10_1);
619  twiddle(src + 8, &tmp0[ 0], 16, ff_on2avc_tab_10_2, 10, 2, 3, 1, ff_on2avc_tabs_4_10_2);
620  twiddle(src + 16, &tmp0[16], 16, ff_on2avc_tab_10_2, 10, 2, 3, 1, ff_on2avc_tabs_4_10_2);
621  twiddle(src + 24, &tmp0[16], 16, ff_on2avc_tab_10_1, 10, 2, 1, 3, ff_on2avc_tabs_4_10_1);
622  twiddle(src + 32, &tmp0[32], 16, ff_on2avc_tab_10_1, 10, 2, 1, 3, ff_on2avc_tabs_4_10_1);
623  twiddle(src + 40, &tmp0[32], 16, ff_on2avc_tab_10_2, 10, 2, 3, 1, ff_on2avc_tabs_4_10_2);
624  twiddle(src + 48, &tmp0[48], 16, ff_on2avc_tab_10_2, 10, 2, 3, 1, ff_on2avc_tabs_4_10_2);
625  twiddle(src + 56, &tmp0[48], 16, ff_on2avc_tab_10_1, 10, 2, 1, 3, ff_on2avc_tabs_4_10_1);
626  twiddle(&tmp0[ 0], &tmp1[ 0], 32, ff_on2avc_tab_20_1, 20, 2, 5, 4, ff_on2avc_tabs_9_20_1);
627  twiddle(&tmp0[16], &tmp1[ 0], 32, ff_on2avc_tab_20_2, 20, 2, 4, 5, ff_on2avc_tabs_9_20_2);
628  twiddle(&tmp0[32], &tmp1[32], 32, ff_on2avc_tab_20_2, 20, 2, 4, 5, ff_on2avc_tabs_9_20_2);
629  twiddle(&tmp0[48], &tmp1[32], 32, ff_on2avc_tab_20_1, 20, 2, 5, 4, ff_on2avc_tabs_9_20_1);
630  twiddle(src + 64, &tmp1[64], 32, ff_on2avc_tab_20_1, 20, 2, 5, 4, ff_on2avc_tabs_9_20_1);
631  twiddle(src + 80, &tmp1[64], 32, ff_on2avc_tab_20_2, 20, 2, 4, 5, ff_on2avc_tabs_9_20_2);
632  twiddle(src + 96, &tmp1[96], 32, ff_on2avc_tab_20_2, 20, 2, 4, 5, ff_on2avc_tabs_9_20_2);
633  twiddle(src + 112, &tmp1[96], 32, ff_on2avc_tab_20_1, 20, 2, 5, 4, ff_on2avc_tabs_9_20_1);
634 
635  memset(tmp0, 0, 64 * sizeof(*tmp0));
636 
637  twiddle(&tmp1[ 0], &tmp0[ 0], 128, ff_on2avc_tab_84_1, 84, 4, 16, 4, ff_on2avc_tabs_20_84_1);
638  twiddle(&tmp1[32], &tmp0[ 0], 128, ff_on2avc_tab_84_2, 84, 4, 16, 4, ff_on2avc_tabs_20_84_2);
639  twiddle(&tmp1[64], &tmp0[ 0], 128, ff_on2avc_tab_84_3, 84, 4, 13, 7, ff_on2avc_tabs_20_84_3);
640  twiddle(&tmp1[96], &tmp0[ 0], 128, ff_on2avc_tab_84_4, 84, 4, 15, 5, ff_on2avc_tabs_20_84_4);
641  twiddle(src + 128, &tmp0[128], 128, ff_on2avc_tab_84_4, 84, 4, 15, 5, ff_on2avc_tabs_20_84_4);
642  twiddle(src + 160, &tmp0[128], 128, ff_on2avc_tab_84_3, 84, 4, 13, 7, ff_on2avc_tabs_20_84_3);
643  twiddle(src + 192, &tmp0[128], 128, ff_on2avc_tab_84_2, 84, 4, 16, 4, ff_on2avc_tabs_20_84_2);
644  twiddle(src + 224, &tmp0[128], 128, ff_on2avc_tab_84_1, 84, 4, 16, 4, ff_on2avc_tabs_20_84_1);
645  twiddle(src + 256, &tmp0[256], 128, ff_on2avc_tab_40_1, 40, 2, 11, 8, ff_on2avc_tabs_19_40_1);
646  twiddle(src + 320, &tmp0[256], 128, ff_on2avc_tab_40_2, 40, 2, 8, 11, ff_on2avc_tabs_19_40_2);
647 
648  wtf_end_512(c, out, src, tmp0, tmp1);
649  } else {
650  twiddle(src, &tmp0[ 0], 32, ff_on2avc_tab_20_1, 20, 2, 5, 4, ff_on2avc_tabs_9_20_1);
651  twiddle(src + 16, &tmp0[ 0], 32, ff_on2avc_tab_20_2, 20, 2, 4, 5, ff_on2avc_tabs_9_20_2);
652  twiddle(src + 32, &tmp0[ 32], 32, ff_on2avc_tab_20_2, 20, 2, 4, 5, ff_on2avc_tabs_9_20_2);
653  twiddle(src + 48, &tmp0[ 32], 32, ff_on2avc_tab_20_1, 20, 2, 5, 4, ff_on2avc_tabs_9_20_1);
654  twiddle(src + 64, &tmp0[ 64], 32, ff_on2avc_tab_20_1, 20, 2, 5, 4, ff_on2avc_tabs_9_20_1);
655  twiddle(src + 80, &tmp0[ 64], 32, ff_on2avc_tab_20_2, 20, 2, 4, 5, ff_on2avc_tabs_9_20_2);
656  twiddle(src + 96, &tmp0[ 96], 32, ff_on2avc_tab_20_2, 20, 2, 4, 5, ff_on2avc_tabs_9_20_2);
657  twiddle(src + 112, &tmp0[ 96], 32, ff_on2avc_tab_20_1, 20, 2, 5, 4, ff_on2avc_tabs_9_20_1);
658  twiddle(&tmp0[ 0], &tmp1[ 0], 64, ff_on2avc_tab_40_1, 40, 2, 11, 8, ff_on2avc_tabs_19_40_1);
659  twiddle(&tmp0[32], &tmp1[ 0], 64, ff_on2avc_tab_40_2, 40, 2, 8, 11, ff_on2avc_tabs_19_40_2);
660  twiddle(&tmp0[64], &tmp1[ 64], 64, ff_on2avc_tab_40_2, 40, 2, 8, 11, ff_on2avc_tabs_19_40_2);
661  twiddle(&tmp0[96], &tmp1[ 64], 64, ff_on2avc_tab_40_1, 40, 2, 11, 8, ff_on2avc_tabs_19_40_1);
662  twiddle(src + 128, &tmp1[128], 64, ff_on2avc_tab_40_1, 40, 2, 11, 8, ff_on2avc_tabs_19_40_1);
663  twiddle(src + 160, &tmp1[128], 64, ff_on2avc_tab_40_2, 40, 2, 8, 11, ff_on2avc_tabs_19_40_2);
664  twiddle(src + 192, &tmp1[192], 64, ff_on2avc_tab_40_2, 40, 2, 8, 11, ff_on2avc_tabs_19_40_2);
665  twiddle(src + 224, &tmp1[192], 64, ff_on2avc_tab_40_1, 40, 2, 11, 8, ff_on2avc_tabs_19_40_1);
666 
667  memset(tmp0, 0, 128 * sizeof(*tmp0));
668 
669  twiddle(&tmp1[ 0], &tmp0[ 0], 256, ff_on2avc_tab_84_1, 84, 4, 16, 4, ff_on2avc_tabs_20_84_1);
670  twiddle(&tmp1[ 64], &tmp0[ 0], 256, ff_on2avc_tab_84_2, 84, 4, 16, 4, ff_on2avc_tabs_20_84_2);
671  twiddle(&tmp1[128], &tmp0[ 0], 256, ff_on2avc_tab_84_3, 84, 4, 13, 7, ff_on2avc_tabs_20_84_3);
672  twiddle(&tmp1[192], &tmp0[ 0], 256, ff_on2avc_tab_84_4, 84, 4, 15, 5, ff_on2avc_tabs_20_84_4);
673  twiddle(src + 256, &tmp0[256], 256, ff_on2avc_tab_84_4, 84, 4, 15, 5, ff_on2avc_tabs_20_84_4);
674  twiddle(src + 320, &tmp0[256], 256, ff_on2avc_tab_84_3, 84, 4, 13, 7, ff_on2avc_tabs_20_84_3);
675  twiddle(src + 384, &tmp0[256], 256, ff_on2avc_tab_84_2, 84, 4, 16, 4, ff_on2avc_tabs_20_84_2);
676  twiddle(src + 448, &tmp0[256], 256, ff_on2avc_tab_84_1, 84, 4, 16, 4, ff_on2avc_tabs_20_84_1);
677  twiddle(src + 512, &tmp0[512], 256, ff_on2avc_tab_40_1, 40, 2, 11, 8, ff_on2avc_tabs_19_40_1);
678  twiddle(src + 640, &tmp0[512], 256, ff_on2avc_tab_40_2, 40, 2, 8, 11, ff_on2avc_tabs_19_40_2);
679 
680  wtf_end_1024(c, out, src, tmp0, tmp1);
681  }
682 }
683 
685 {
686  int ch, i;
687 
688  for (ch = 0; ch < c->avctx->ch_layout.nb_channels; ch++) {
689  float *out = (float*)dst->extended_data[ch] + offset;
690  float *in = c->coeffs[ch];
691  float *saved = c->delay[ch];
692  float *buf = c->mdct_buf;
693  float *wout = out + 448;
694 
695  switch (c->window_type) {
696  case WINDOW_TYPE_EXT7:
697  c->mdct_fn(c->mdct, buf, in, sizeof(float));
698  break;
699  case WINDOW_TYPE_EXT4:
700  c->wtf(c, buf, in, 1024);
701  break;
702  case WINDOW_TYPE_EXT5:
703  c->wtf(c, buf, in, 512);
704  c->mdct_half_fn(c->mdct_half, buf + 512, in + 512, sizeof(float));
705  for (i = 0; i < 256; i++) {
706  FFSWAP(float, buf[i + 512], buf[1023 - i]);
707  }
708  break;
709  case WINDOW_TYPE_EXT6:
710  c->mdct_half_fn(c->mdct_half, buf, in, sizeof(float));
711  for (i = 0; i < 256; i++) {
712  FFSWAP(float, buf[i], buf[511 - i]);
713  }
714  c->wtf(c, buf + 512, in + 512, 512);
715  break;
716  }
717 
718  memcpy(out, saved, 448 * sizeof(float));
719  c->fdsp->vector_fmul_window(wout, saved + 448, buf, c->short_win, 64);
720  memcpy(wout + 128, buf + 64, 448 * sizeof(float));
721  memcpy(saved, buf + 512, 448 * sizeof(float));
722  memcpy(saved + 448, buf + 7*128 + 64, 64 * sizeof(float));
723  }
724 
725  return 0;
726 }
727 
728 // not borrowed from aacdec.c - the codec has original design after all
730  AVFrame *dst, int offset)
731 {
732  int i;
733  float *out = (float*)dst->extended_data[channel] + offset;
734  float *in = c->coeffs[channel];
735  float *saved = c->delay[channel];
736  float *buf = c->mdct_buf;
737  float *temp = c->temp;
738 
739  switch (c->window_type) {
742  case WINDOW_TYPE_LONG:
743  c->mdct_fn(c->mdct, buf, in, sizeof(float));
744  break;
745  case WINDOW_TYPE_8SHORT:
746  for (i = 0; i < ON2AVC_SUBFRAME_SIZE; i += ON2AVC_SUBFRAME_SIZE / 8)
747  c->mdct_small_fn(c->mdct_small, buf + i, in + i, sizeof(float));
748  break;
749  }
750 
751  if ((c->prev_window_type == WINDOW_TYPE_LONG ||
752  c->prev_window_type == WINDOW_TYPE_LONG_STOP) &&
753  (c->window_type == WINDOW_TYPE_LONG ||
754  c->window_type == WINDOW_TYPE_LONG_START)) {
755  c->fdsp->vector_fmul_window(out, saved, buf, c->long_win, 512);
756  } else {
757  float *wout = out + 448;
758  memcpy(out, saved, 448 * sizeof(float));
759 
760  if (c->window_type == WINDOW_TYPE_8SHORT) {
761  c->fdsp->vector_fmul_window(wout + 0*128, saved + 448, buf + 0*128, c->short_win, 64);
762  c->fdsp->vector_fmul_window(wout + 1*128, buf + 0*128 + 64, buf + 1*128, c->short_win, 64);
763  c->fdsp->vector_fmul_window(wout + 2*128, buf + 1*128 + 64, buf + 2*128, c->short_win, 64);
764  c->fdsp->vector_fmul_window(wout + 3*128, buf + 2*128 + 64, buf + 3*128, c->short_win, 64);
765  c->fdsp->vector_fmul_window(temp, buf + 3*128 + 64, buf + 4*128, c->short_win, 64);
766  memcpy(wout + 4*128, temp, 64 * sizeof(float));
767  } else {
768  c->fdsp->vector_fmul_window(wout, saved + 448, buf, c->short_win, 64);
769  memcpy(wout + 128, buf + 64, 448 * sizeof(float));
770  }
771  }
772 
773  // buffer update
774  switch (c->window_type) {
775  case WINDOW_TYPE_8SHORT:
776  memcpy(saved, temp + 64, 64 * sizeof(float));
777  c->fdsp->vector_fmul_window(saved + 64, buf + 4*128 + 64, buf + 5*128, c->short_win, 64);
778  c->fdsp->vector_fmul_window(saved + 192, buf + 5*128 + 64, buf + 6*128, c->short_win, 64);
779  c->fdsp->vector_fmul_window(saved + 320, buf + 6*128 + 64, buf + 7*128, c->short_win, 64);
780  memcpy(saved + 448, buf + 7*128 + 64, 64 * sizeof(float));
781  break;
783  memcpy(saved, buf + 512, 448 * sizeof(float));
784  memcpy(saved + 448, buf + 7*128 + 64, 64 * sizeof(float));
785  break;
787  case WINDOW_TYPE_LONG:
788  memcpy(saved, buf + 512, 512 * sizeof(float));
789  break;
790  }
791  return 0;
792 }
793 
794 static int on2avc_decode_subframe(On2AVCContext *c, const uint8_t *buf,
795  int buf_size, AVFrame *dst, int offset)
796 {
797  GetBitContext gb;
798  int i, ret;
799 
800  if ((ret = init_get_bits8(&gb, buf, buf_size)) < 0)
801  return ret;
802 
803  if (get_bits1(&gb)) {
804  av_log(c->avctx, AV_LOG_ERROR, "enh bit set\n");
805  return AVERROR_INVALIDDATA;
806  }
807  c->prev_window_type = c->window_type;
808  c->window_type = get_bits(&gb, 3);
809 
810  c->band_start = c->modes[c->window_type].band_start;
811  c->num_windows = c->modes[c->window_type].num_windows;
812  c->num_bands = c->modes[c->window_type].num_bands;
813  c->is_long = (c->window_type != WINDOW_TYPE_8SHORT);
814 
815  c->grouping[0] = 1;
816  for (i = 1; i < c->num_windows; i++)
817  c->grouping[i] = !get_bits1(&gb);
818 
819  on2avc_read_ms_info(c, &gb);
820  for (i = 0; i < c->avctx->ch_layout.nb_channels; i++)
821  if ((ret = on2avc_read_channel_data(c, &gb, i)) < 0)
822  return AVERROR_INVALIDDATA;
823  if (c->avctx->ch_layout.nb_channels == 2 && c->ms_present)
825  if (c->window_type < WINDOW_TYPE_EXT4) {
826  for (i = 0; i < c->avctx->ch_layout.nb_channels; i++)
828  } else {
830  }
831 
832  return 0;
833 }
834 
836  int *got_frame_ptr, AVPacket *avpkt)
837 {
838  const uint8_t *buf = avpkt->data;
839  int buf_size = avpkt->size;
841  GetByteContext gb;
842  int num_frames = 0, frame_size, audio_off;
843  int ret;
844 
845  if (c->is_av500) {
846  /* get output buffer */
847  frame->nb_samples = ON2AVC_SUBFRAME_SIZE;
848  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
849  return ret;
850 
851  if ((ret = on2avc_decode_subframe(c, buf, buf_size, frame, 0)) < 0)
852  return ret;
853  } else {
854  bytestream2_init(&gb, buf, buf_size);
855  while (bytestream2_get_bytes_left(&gb) > 2) {
856  frame_size = bytestream2_get_le16(&gb);
858  av_log(avctx, AV_LOG_ERROR, "Invalid subframe size %d\n",
859  frame_size);
860  return AVERROR_INVALIDDATA;
861  }
862  num_frames++;
864  }
865  if (!num_frames) {
866  av_log(avctx, AV_LOG_ERROR, "No subframes present\n");
867  return AVERROR_INVALIDDATA;
868  }
869 
870  /* get output buffer */
871  frame->nb_samples = ON2AVC_SUBFRAME_SIZE * num_frames;
872  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
873  return ret;
874 
875  audio_off = 0;
876  bytestream2_init(&gb, buf, buf_size);
877  while (bytestream2_get_bytes_left(&gb) > 2) {
878  frame_size = bytestream2_get_le16(&gb);
880  frame, audio_off)) < 0)
881  return ret;
882  audio_off += ON2AVC_SUBFRAME_SIZE;
884  }
885  }
886 
887  *got_frame_ptr = 1;
888 
889  return buf_size;
890 }
891 
893 {
894  int i;
895 
896  ff_vlc_free(&c->scale_diff);
897  for (i = 1; i < 16; i++)
898  ff_vlc_free(&c->cb_vlc[i]);
899 }
900 
902 {
904  const uint8_t *lens = ff_on2avc_cb_lens;
905  const uint16_t *syms = ff_on2avc_cb_syms;
907  float scale;
908  int i, ret;
909 
910  if (channels > 2U) {
911  avpriv_request_sample(avctx, "Decoding more than 2 channels");
912  return AVERROR_PATCHWELCOME;
913  }
914 
915  c->avctx = avctx;
920 
921  c->is_av500 = (avctx->codec_tag == 0x500);
922 
923  if (channels == 2)
925  "Stereo mode support is not good, patch is welcome\n");
926 
927  // We add -0.01 before ceil() to avoid any values to fall at exactly the
928  // midpoint between different ceil values. The results are identical to
929  // using pow(10, i / 10.0) without such bias
930  for (i = 0; i < 20; i++)
931  c->scale_tab[i] = ceil(ff_exp10(i * 0.1) * 16 - 0.01) / 32;
932  for (; i < 128; i++)
933  c->scale_tab[i] = ceil(ff_exp10(i * 0.1) * 0.5 - 0.01);
934 
935  if (avctx->sample_rate < 32000 || channels == 1)
936  memcpy(c->long_win, ff_on2avc_window_long_24000,
937  1024 * sizeof(*c->long_win));
938  else
939  memcpy(c->long_win, ff_on2avc_window_long_32000,
940  1024 * sizeof(*c->long_win));
941  memcpy(c->short_win, ff_on2avc_window_short, 128 * sizeof(*c->short_win));
942 
943  c->modes = (avctx->sample_rate <= 40000) ? ff_on2avc_modes_40
945  c->wtf = (avctx->sample_rate <= 40000) ? wtf_40
946  : wtf_44;
947 
948  scale = 1.0 / (1024*32768);
949  if ((ret = av_tx_init(&c->mdct, &c->mdct_fn, AV_TX_FLOAT_MDCT, 1, 1024, &scale, 0)) < 0)
950  return ret;
951 
952  scale = 1.0 / (512*32768);
953  if ((ret = av_tx_init(&c->mdct_half, &c->mdct_half_fn, AV_TX_FLOAT_MDCT, 1, 512, &scale, 0)) < 0)
954  return ret;
955 
956  scale = 1.0 / (128*32768);
957  if ((ret = av_tx_init(&c->mdct_small, &c->mdct_small_fn, AV_TX_FLOAT_MDCT, 1, 128, &scale, 0)) < 0)
958  return ret;
959 
960  if ((ret = av_tx_init(&c->fft512, &c->fft512_fn, AV_TX_FLOAT_FFT, 1, 512, NULL, 0)) < 0)
961  return ret;
962  if ((ret = av_tx_init(&c->fft256, &c->fft256_fn, AV_TX_FLOAT_FFT, 1, 256, NULL, 0)) < 0)
963  return ret;
964  if ((ret = av_tx_init(&c->fft128, &c->fft128_fn, AV_TX_FLOAT_FFT, 0, 128, NULL, 0)) < 0)
965  return ret;
966  if ((ret = av_tx_init(&c->fft64, &c->fft64_fn, AV_TX_FLOAT_FFT, 0, 64, NULL, 0)) < 0)
967  return ret;
968 
970  if (!c->fdsp)
971  return AVERROR(ENOMEM);
972 
975  ff_on2avc_scale_diff_syms, 1, 1, -60, 0, avctx);
976  if (ret < 0)
977  goto vlc_fail;
978  for (i = 1; i < 16; i++) {
979  int idx = i - 1;
980  ret = ff_vlc_init_from_lengths(&c->cb_vlc[i], 9, ff_on2avc_cb_elems[idx],
981  lens, 1,
982  syms, 2, 2, 0, 0, avctx);
983  if (ret < 0)
984  goto vlc_fail;
985  lens += ff_on2avc_cb_elems[idx];
986  syms += ff_on2avc_cb_elems[idx];
987  }
988 
989  return 0;
990 vlc_fail:
991  av_log(avctx, AV_LOG_ERROR, "Cannot init VLC\n");
992  return ret;
993 }
994 
996 {
998 
999  av_tx_uninit(&c->mdct);
1000  av_tx_uninit(&c->mdct_half);
1001  av_tx_uninit(&c->mdct_small);
1002  av_tx_uninit(&c->fft64);
1003  av_tx_uninit(&c->fft128);
1004  av_tx_uninit(&c->fft256);
1005  av_tx_uninit(&c->fft512);
1006 
1007  av_freep(&c->fdsp);
1008 
1010 
1011  return 0;
1012 }
1013 
1014 
1016  .p.name = "on2avc",
1017  CODEC_LONG_NAME("On2 Audio for Video Codec"),
1018  .p.type = AVMEDIA_TYPE_AUDIO,
1019  .p.id = AV_CODEC_ID_ON2AVC,
1020  .priv_data_size = sizeof(On2AVCContext),
1023  .close = on2avc_decode_close,
1024  .p.capabilities = AV_CODEC_CAP_DR1,
1025  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1026  .p.sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
1028 };
on2avc_decode_quads
static int on2avc_decode_quads(On2AVCContext *c, GetBitContext *gb, float *dst, int dst_size, int type, float band_scale)
Definition: on2avc.c:198
get_egolomb
static int get_egolomb(GetBitContext *gb)
Definition: on2avc.c:215
AV_SAMPLE_FMT_FLTP
@ AV_SAMPLE_FMT_FLTP
float, planar
Definition: samplefmt.h:66
on2avc_decode_init
static av_cold int on2avc_decode_init(AVCodecContext *avctx)
Definition: on2avc.c:901
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
h0
static const float h0[64]
Definition: speexdata.h:741
ff_vlc_init_from_lengths
int ff_vlc_init_from_lengths(VLC *vlc, int nb_bits, int nb_codes, const int8_t *lens, int lens_wrap, const void *symbols, int symbols_wrap, int symbols_size, int offset, int flags, void *logctx)
Build VLC decoding tables suitable for use with get_vlc2()
Definition: vlc.c:306
on2avc_apply_ms
static int on2avc_apply_ms(On2AVCContext *c)
Definition: on2avc.c:296
ff_on2avc_decoder
const FFCodec ff_on2avc_decoder
Definition: on2avc.c:1015
ff_exp10
static av_always_inline double ff_exp10(double x)
Compute 10^x for floating point values.
Definition: ffmath.h:42
on2avc_scale
static float on2avc_scale(int v, float scale)
Definition: on2avc.c:192
FF_CODEC_CAP_INIT_CLEANUP
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: codec_internal.h:42
r
const char * r
Definition: vf_curves.c:127
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
WINDOW_TYPE_EXT4
@ WINDOW_TYPE_EXT4
Definition: on2avc.c:45
mem_internal.h
ff_on2avc_cb_lens
const uint8_t ff_on2avc_cb_lens[]
Definition: on2avcdata.c:146
out
FILE * out
Definition: movenc.c:55
AV_CHANNEL_LAYOUT_STEREO
#define AV_CHANNEL_LAYOUT_STEREO
Definition: channel_layout.h:379
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:1050
GetByteContext
Definition: bytestream.h:33
On2AVCContext::cb_vlc
VLC cb_vlc[16]
Definition: on2avc.c:81
twiddle
static void twiddle(float *src1, float *src2, int src2_len, const double *tab, int tab_len, int step, int order0, int order1, const double *const *tabs)
Definition: on2avc.c:354
On2AVCContext::fdsp
AVFloatDSPContext * fdsp
Definition: on2avc.c:53
ON2AVC_ESC_CB
#define ON2AVC_ESC_CB
Definition: on2avcdata.h:29
ff_on2avc_tabs_19_40_2
const double *const ff_on2avc_tabs_19_40_2[19]
Definition: on2avcdata.c:3386
On2AVCContext::ms_present
int ms_present
Definition: on2avc.c:69
src1
const pixel * src1
Definition: h264pred_template.c:421
AVTXContext
Definition: tx_priv.h:235
On2AVCContext::delay
float delay[2][ON2AVC_SUBFRAME_SIZE]
Definition: on2avc.c:86
get_bits_long
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:421
wtf_44
static void wtf_44(On2AVCContext *c, float *out, float *src, int size)
Definition: on2avc.c:610
ON2AVC_SCALE_DIFFS
#define ON2AVC_SCALE_DIFFS
Definition: on2avcdata.h:40
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:374
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
step
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But a word about which is also called distortion Distortion can be quantified by almost any quality measurement one chooses the sum of squared differences is used but more complex methods that consider psychovisual effects can be used as well It makes no difference in this discussion First step
Definition: rate_distortion.txt:58
w
uint8_t w
Definition: llviddspenc.c:38
On2AVCContext::ms_info
int ms_info[ON2AVC_MAX_BANDS]
Definition: on2avc.c:70
On2AVCContext::short_win
float short_win[ON2AVC_SUBFRAME_SIZE/8]
Definition: on2avc.c:91
AVPacket::data
uint8_t * data
Definition: packet.h:524
t0
#define t0
Definition: regdef.h:28
b
#define b
Definition: input.c:41
on2avc_reconstruct_channel
static int on2avc_reconstruct_channel(On2AVCContext *c, int channel, AVFrame *dst, int offset)
Definition: on2avc.c:729
half
static uint8_t half(int a, int b)
Definition: mobiclip.c:539
on2avc_decode_pairs
static int on2avc_decode_pairs(On2AVCContext *c, GetBitContext *gb, float *dst, int dst_size, int type, float band_scale)
Definition: on2avc.c:231
On2AVCContext::fft512_fn
av_tx_fn fft512_fn
Definition: on2avc.c:57
FFCodec
Definition: codec_internal.h:126
On2AVCContext::band_run_end
uint8_t band_run_end[ON2AVC_MAX_BANDS]
Definition: on2avc.c:75
AV_CODEC_ID_ON2AVC
@ AV_CODEC_ID_ON2AVC
Definition: codec_id.h:505
tabs
static const struct @139 tabs[]
t1
#define t1
Definition: regdef.h:29
WINDOW_TYPE_EXT7
@ WINDOW_TYPE_EXT7
Definition: on2avc.c:48
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:313
av_tx_init
av_cold int av_tx_init(AVTXContext **ctx, av_tx_fn *tx, enum AVTXType type, int inv, int len, const void *scale, uint64_t flags)
Initialize a transform context with the given configuration (i)MDCTs with an odd length are currently...
Definition: tx.c:903
ff_on2avc_tab_84_1
const double ff_on2avc_tab_84_1[]
Definition: on2avcdata.c:2949
combine_fft
static void combine_fft(float *s0, float *s1, float *s2, float *s3, float *dst, const float *t0, const float *t1, const float *t2, const float *t3, int len, int step)
Definition: on2avc.c:419
On2AVCContext::grouping
int grouping[8]
Definition: on2avc.c:68
ff_on2avc_window_long_32000
const float ff_on2avc_window_long_32000[1024]
Definition: on2avcdata.c:2336
ff_on2avc_tabs_9_20_2
const double *const ff_on2avc_tabs_9_20_2[9]
Definition: on2avcdata.c:3180
On2AVCContext::mdct_fn
av_tx_fn mdct_fn
Definition: on2avc.c:56
bytestream2_skip
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
Definition: bytestream.h:168
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:335
On2AVCContext::wtf
void(* wtf)(struct On2AVCContext *ctx, float *out, float *in, int size)
Definition: on2avc.c:58
s3
#define s3
Definition: regdef.h:40
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:130
wtf_end_512
static void wtf_end_512(On2AVCContext *c, float *out, float *src, float *tmp0, float *tmp1)
Definition: on2avc.c:468
AVCodecContext::ch_layout
AVChannelLayout ch_layout
Audio channel layout.
Definition: avcodec.h:1065
On2AVCContext::fft64_fn
av_tx_fn fft64_fn
Definition: on2avc.c:57
GetBitContext
Definition: get_bits.h:108
On2AVCContext::prev_window_type
int prev_window_type
Definition: on2avc.c:63
tab
static const struct twinvq_data tab
Definition: twinvq_data.h:10345
ff_on2avc_tabs_20_84_2
const double *const ff_on2avc_tabs_20_84_2[20]
Definition: on2avcdata.c:4285
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:502
val
static double val(void *priv, double ch)
Definition: aeval.c:78
type
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type
Definition: writing_filters.txt:86
on2avc_reconstruct_channel_ext
static int on2avc_reconstruct_channel_ext(On2AVCContext *c, AVFrame *dst, int offset)
Definition: on2avc.c:684
pretwiddle
static void pretwiddle(float *src, float *dst, int dst_len, int tab_step, int step, int order0, int order1, const double *const *tabs)
Definition: on2avc.c:327
ff_on2avc_modes_44
const On2AVCMode ff_on2avc_modes_44[8]
Definition: on2avcdata.c:102
ff_on2avc_cb_elems
const int ff_on2avc_cb_elems[]
Definition: on2avcdata.c:2328
first
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But first
Definition: rate_distortion.txt:12
ceil
static __device__ float ceil(float a)
Definition: cuda_runtime.h:176
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
av_cold
#define av_cold
Definition: attributes.h:90
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:545
av_tx_fn
void(* av_tx_fn)(AVTXContext *s, void *out, void *in, ptrdiff_t stride)
Function pointer to a function to perform the transform.
Definition: tx.h:151
mask
static const uint16_t mask[17]
Definition: lzw.c:38
AV_TX_FLOAT_MDCT
@ AV_TX_FLOAT_MDCT
Standard MDCT with a sample data type of float, double or int32_t, respecively.
Definition: tx.h:68
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:286
ON2AVC_SUBFRAME_SIZE
#define ON2AVC_SUBFRAME_SIZE
Definition: on2avc.c:38
frame_size
int frame_size
Definition: mxfenc.c:2423
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
s1
#define s1
Definition: regdef.h:38
On2AVCContext::band_scales
float band_scales[ON2AVC_MAX_BANDS]
Definition: on2avc.c:78
GetByteContext::buffer
const uint8_t * buffer
Definition: bytestream.h:34
AV_TX_FLOAT_FFT
@ AV_TX_FLOAT_FFT
Standard complex to complex FFT with sample data type of AVComplexFloat, AVComplexDouble or AVComplex...
Definition: tx.h:47
ctx
AVFormatContext * ctx
Definition: movenc.c:49
channels
channels
Definition: aptx.h:31
decode.h
get_bits.h
ff_on2avc_tab_10_1
const double ff_on2avc_tab_10_1[]
Definition: on2avcdata.c:2889
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:271
ff_on2avc_tab_84_3
const double ff_on2avc_tab_84_3[]
Definition: on2avcdata.c:3011
ff_on2avc_tabs_20_84_3
const double *const ff_on2avc_tabs_20_84_3[20]
Definition: on2avcdata.c:4293
On2AVCContext::fft256
AVTXContext * fft256
Definition: on2avc.c:55
ff_on2avc_scale_diff_bits
const uint8_t ff_on2avc_scale_diff_bits[ON2AVC_SCALE_DIFFS]
Definition: on2avcdata.c:125
NULL
#define NULL
Definition: coverity.c:32
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
run
uint8_t run
Definition: svq3.c:204
WINDOW_TYPE_EXT6
@ WINDOW_TYPE_EXT6
Definition: on2avc.c:47
On2AVCContext::coeffs
float coeffs[2][ON2AVC_SUBFRAME_SIZE]
Definition: on2avc.c:85
ff_on2avc_tabs_20_84_4
const double *const ff_on2avc_tabs_20_84_4[20]
Definition: on2avcdata.c:4301
ff_on2avc_tabs_19_40_1
const double *const ff_on2avc_tabs_19_40_1[19]
Definition: on2avcdata.c:3378
On2AVCContext::mdct_buf
float mdct_buf[ON2AVC_SUBFRAME_SIZE]
Definition: on2avc.c:89
WINDOW_TYPE_LONG
@ WINDOW_TYPE_LONG
Definition: on2avc.c:41
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:388
ff_on2avc_tabs_20_84_1
const double *const ff_on2avc_tabs_20_84_1[20]
Definition: on2avcdata.c:4277
ff_on2avc_cb_syms
const uint16_t ff_on2avc_cb_syms[]
Definition: on2avcdata.c:858
sqrtf
static __device__ float sqrtf(float a)
Definition: cuda_runtime.h:184
ff_on2avc_ctab_4
const float ff_on2avc_ctab_4[2048]
Definition: on2avcdata.c:4702
abs
#define abs(x)
Definition: cuda_runtime.h:35
get_vlc2
static av_always_inline int get_vlc2(GetBitContext *s, const VLCElem *table, int bits, int max_depth)
Parse a vlc code.
Definition: get_bits.h:652
ff_on2avc_tab_84_4
const double ff_on2avc_tab_84_4[]
Definition: on2avcdata.c:3042
On2AVCContext::num_sections
int num_sections
Definition: on2avc.c:76
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
On2AVCContext::modes
const On2AVCMode * modes
Definition: on2avc.c:62
ff_on2avc_scale_diff_syms
const uint8_t ff_on2avc_scale_diff_syms[ON2AVC_SCALE_DIFFS]
Definition: on2avcdata.c:113
bytestream2_get_bytes_left
static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:158
float_dsp.h
s2
#define s2
Definition: regdef.h:39
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1575
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:366
On2AVCContext::avctx
AVCodecContext * avctx
Definition: on2avc.c:52
on2avc_decode_close
static av_cold int on2avc_decode_close(AVCodecContext *avctx)
Definition: on2avc.c:995
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
AVPacket::size
int size
Definition: packet.h:525
On2AVCContext::fft256_fn
av_tx_fn fft256_fn
Definition: on2avc.c:57
CMUL2
#define CMUL2(dst, s0, s1, s2, s3, t0, t1, t2, t3, is, it)
Definition: on2avc.c:409
CMUL1
#define CMUL1(dst, s0, s1, s2, s3, t0, t1, t2, t3, is, it)
Definition: on2avc.c:399
wtf_40
static void wtf_40(On2AVCContext *c, float *out, float *src, int size)
Definition: on2avc.c:524
AVChannelLayout
An AVChannelLayout holds information about the channel layout of audio data.
Definition: channel_layout.h:303
codec_internal.h
DECLARE_ALIGNED
#define DECLARE_ALIGNED(n, t, v)
Definition: mem_internal.h:109
On2AVCContext::is_av500
int is_av500
Definition: on2avc.c:60
CMUL0
#define CMUL0(dst, id, s0, s1, s2, s3, t0, t1, t2, t3, is, it)
Definition: on2avc.c:393
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1057
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:56
size
int size
Definition: twinvq_data.h:10344
On2AVCContext::num_bands
int num_bands
Definition: on2avc.c:64
AVFloatDSPContext
Definition: float_dsp.h:22
ff_on2avc_ctab_3
const float ff_on2avc_ctab_3[2048]
Definition: on2avcdata.c:4571
on2avc_decode_frame
static int on2avc_decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame_ptr, AVPacket *avpkt)
Definition: on2avc.c:835
offset
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Definition: writing_filters.txt:86
ON2AVC_MAX_BANDS
#define ON2AVC_MAX_BANDS
Definition: on2avcdata.h:28
av_tx_uninit
av_cold void av_tx_uninit(AVTXContext **ctx)
Frees a context and sets *ctx to NULL, does nothing when *ctx == NULL.
Definition: tx.c:295
ff_on2avc_tab_40_2
const double ff_on2avc_tab_40_2[]
Definition: on2avcdata.c:2932
ff_on2avc_tab_20_2
const double ff_on2avc_tab_20_2[]
Definition: on2avcdata.c:2909
on2avc_read_channel_data
static int on2avc_read_channel_data(On2AVCContext *c, GetBitContext *gb, int ch)
Definition: on2avc.c:259
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
zero_head_and_tail
static void zero_head_and_tail(float *src, int len, int order0, int order1)
Definition: on2avc.c:321
t3
#define t3
Definition: regdef.h:31
On2AVCContext::band_start
const int * band_start
Definition: on2avc.c:66
AVFrame::extended_data
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:435
src2
const pixel * src2
Definition: h264pred_template.c:422
On2AVCContext::long_win
float long_win[ON2AVC_SUBFRAME_SIZE]
Definition: on2avc.c:90
On2AVCContext::window_type
int window_type
Definition: on2avc.c:63
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:55
On2AVCContext::mdct_small_fn
av_tx_fn mdct_small_fn
Definition: on2avc.c:56
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:194
WindowTypes
WindowTypes
Definition: on2avc.c:40
len
int len
Definition: vorbis_enc_data.h:426
WINDOW_TYPE_LONG_START
@ WINDOW_TYPE_LONG_START
Definition: on2avc.c:43
On2AVCContext::mdct_half_fn
av_tx_fn mdct_half_fn
Definition: on2avc.c:56
on2avc_read_ms_info
static void on2avc_read_ms_info(On2AVCContext *c, GetBitContext *gb)
Definition: on2avc.c:94
on2avc_free_vlcs
static av_cold void on2avc_free_vlcs(On2AVCContext *c)
Definition: on2avc.c:892
avcodec.h
on2avc_decode_band_scales
static int on2avc_decode_band_scales(On2AVCContext *c, GetBitContext *gb)
Definition: on2avc.c:145
On2AVCMode
Definition: on2avcdata.h:31
ff_vlc_free
void ff_vlc_free(VLC *vlc)
Definition: vlc.c:580
ret
ret
Definition: filter_design.txt:187
On2AVCContext::mdct_half
AVTXContext * mdct_half
Definition: on2avc.c:54
FFSWAP
#define FFSWAP(type, a, b)
Definition: macros.h:52
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
on2avc_decode_band_types
static int on2avc_decode_band_types(On2AVCContext *c, GetBitContext *gb)
Definition: on2avc.c:115
ff_on2avc_modes_40
const On2AVCMode ff_on2avc_modes_40[8]
Definition: on2avcdata.c:91
pos
unsigned int pos
Definition: spdifenc.c:414
On2AVCContext::is_long
int is_long
Definition: on2avc.c:72
On2AVCContext::bits_per_section
int bits_per_section
Definition: on2avc.c:65
ff_on2avc_tabs_9_20_1
const double *const ff_on2avc_tabs_9_20_1[9]
Definition: on2avcdata.c:3175
run_len
static const uint8_t run_len[7][16]
Definition: h264_cavlc.c:217
U
#define U(x)
Definition: vpx_arith.h:37
steps
static const int16_t steps[16]
Definition: misc4.c:30
AVCodecContext
main external API structure.
Definition: avcodec.h:445
on2avc_decode_subframe
static int on2avc_decode_subframe(On2AVCContext *c, const uint8_t *buf, int buf_size, AVFrame *dst, int offset)
Definition: on2avc.c:794
On2AVCContext::scale_tab
float scale_tab[128]
Definition: on2avc.c:83
channel_layout.h
t2
#define t2
Definition: regdef.h:30
VLC
Definition: vlc.h:36
On2AVCContext::scale_diff
VLC scale_diff
Definition: on2avc.c:80
ff_on2avc_tab_20_1
const double ff_on2avc_tab_20_1[]
Definition: on2avcdata.c:2902
av_channel_layout_uninit
void av_channel_layout_uninit(AVChannelLayout *channel_layout)
Free any allocated data in the channel layout and reset the channel count to 0.
Definition: channel_layout.c:433
ff_on2avc_tabs_4_10_2
const double *const ff_on2avc_tabs_4_10_2[4]
Definition: on2avcdata.c:3096
sign_extend
static av_const int sign_extend(int val, unsigned bits)
Definition: mathops.h:133
ff_on2avc_window_long_24000
const float ff_on2avc_window_long_24000[1024]
Definition: on2avcdata.c:2595
On2AVCContext::mdct
AVTXContext * mdct
Definition: on2avc.c:54
temp
else temp
Definition: vf_mcdeint.c:263
WINDOW_TYPE_LONG_STOP
@ WINDOW_TYPE_LONG_STOP
Definition: on2avc.c:42
ff_on2avc_tabs_4_10_1
const double *const ff_on2avc_tabs_4_10_1[4]
Definition: on2avcdata.c:3092
On2AVCContext::fft128
AVTXContext * fft128
Definition: on2avc.c:55
ffmath.h
ff_on2avc_ctab_1
const float ff_on2avc_ctab_1[2048]
Definition: on2avcdata.c:4309
on2avcdata.h
mem.h
AV_CODEC_FLAG_BITEXACT
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:342
s0
#define s0
Definition: regdef.h:37
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:36
ff_on2avc_tab_10_2
const double ff_on2avc_tab_10_2[]
Definition: on2avcdata.c:2894
AV_CHANNEL_LAYOUT_MONO
#define AV_CHANNEL_LAYOUT_MONO
Definition: channel_layout.h:378
ff_on2avc_ctab_2
const float ff_on2avc_ctab_2[2048]
Definition: on2avcdata.c:4440
ff_on2avc_tab_40_1
const double ff_on2avc_tab_40_1[]
Definition: on2avcdata.c:2919
AVCodecContext::codec_tag
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
Definition: avcodec.h:470
scale
static void scale(int *out, const int *in, const int w, const int h, const int shift)
Definition: intra.c:291
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:472
AVPacket
This structure stores compressed data.
Definition: packet.h:501
WINDOW_TYPE_EXT5
@ WINDOW_TYPE_EXT5
Definition: on2avc.c:46
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
wtf_end_1024
static void wtf_end_1024(On2AVCContext *c, float *out, float *src, float *tmp0, float *tmp1)
Definition: on2avc.c:496
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
avpriv_float_dsp_alloc
av_cold AVFloatDSPContext * avpriv_float_dsp_alloc(int bit_exact)
Allocate a float DSP context.
Definition: float_dsp.c:135
ff_on2avc_tab_84_2
const double ff_on2avc_tab_84_2[]
Definition: on2avcdata.c:2980
ff_on2avc_window_short
const float ff_on2avc_window_short[128]
Definition: on2avcdata.c:2854
bytestream.h
bytestream2_init
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:137
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
On2AVCContext::num_windows
int num_windows
Definition: on2avc.c:64
On2AVCContext::fft128_fn
av_tx_fn fft128_fn
Definition: on2avc.c:57
WINDOW_TYPE_8SHORT
@ WINDOW_TYPE_8SHORT
Definition: on2avc.c:44
On2AVCContext::band_type
uint8_t band_type[ON2AVC_MAX_BANDS]
Definition: on2avc.c:74
On2AVCContext::fft512
AVTXContext * fft512
Definition: on2avc.c:55
On2AVCContext::mdct_small
AVTXContext * mdct_small
Definition: on2avc.c:54
On2AVCContext::temp
float temp[ON2AVC_SUBFRAME_SIZE *2]
Definition: on2avc.c:88
channel
channel
Definition: ebur128.h:39
tx.h
On2AVCContext
Definition: on2avc.c:51
On2AVCContext::fft64
AVTXContext * fft64
Definition: on2avc.c:55