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_internal.h"
27 #include "libavutil/tx.h"
28 
29 #include "avcodec.h"
30 #include "bytestream.h"
31 #include "codec_internal.h"
32 #include "decode.h"
33 #include "get_bits.h"
34 
35 #include "on2avcdata.h"
36 
37 #define ON2AVC_SUBFRAME_SIZE 1024
38 
48 };
49 
50 typedef struct On2AVCContext {
57  void (*wtf)(struct On2AVCContext *ctx, float *out, float *in, int size);
58 
59  int is_av500;
60 
61  const On2AVCMode *modes;
65  const int *band_start;
66 
67  int grouping[8];
70 
71  int is_long;
72 
76 
78 
80  VLC cb_vlc[16];
81 
82  float scale_tab[128];
83 
86 
92 
94 {
95  int w, b, band_off = 0;
96 
97  c->ms_present = get_bits1(gb);
98  if (!c->ms_present)
99  return;
100  for (w = 0; w < c->num_windows; w++) {
101  if (!c->grouping[w]) {
102  memcpy(c->ms_info + band_off,
103  c->ms_info + band_off - c->num_bands,
104  c->num_bands * sizeof(*c->ms_info));
105  band_off += c->num_bands;
106  continue;
107  }
108  for (b = 0; b < c->num_bands; b++)
109  c->ms_info[band_off++] = get_bits1(gb);
110  }
111 }
112 
113 // do not see Table 17 in ISO/IEC 13818-7
115 {
116  int bits_per_sect = c->is_long ? 5 : 3;
117  int esc_val = (1 << bits_per_sect) - 1;
118  int num_bands = c->num_bands * c->num_windows;
119  int band = 0, i, band_type, run_len, run;
120 
121  while (band < num_bands) {
122  band_type = get_bits(gb, 4);
123  run_len = 1;
124  do {
125  run = get_bits(gb, bits_per_sect);
126  if (run > num_bands - band - run_len) {
127  av_log(c->avctx, AV_LOG_ERROR, "Invalid band type run\n");
128  return AVERROR_INVALIDDATA;
129  }
130  run_len += run;
131  } while (run == esc_val);
132  for (i = band; i < band + run_len; i++) {
133  c->band_type[i] = band_type;
134  c->band_run_end[i] = band + run_len;
135  }
136  band += run_len;
137  }
138 
139  return 0;
140 }
141 
142 // completely not like Table 18 in ISO/IEC 13818-7
143 // (no intensity stereo, different coding for the first coefficient)
145 {
146  int w, w2, b, scale, first = 1;
147  int band_off = 0;
148 
149  for (w = 0; w < c->num_windows; w++) {
150  if (!c->grouping[w]) {
151  memcpy(c->band_scales + band_off,
152  c->band_scales + band_off - c->num_bands,
153  c->num_bands * sizeof(*c->band_scales));
154  band_off += c->num_bands;
155  continue;
156  }
157  for (b = 0; b < c->num_bands; b++) {
158  if (!c->band_type[band_off]) {
159  int all_zero = 1;
160  for (w2 = w + 1; w2 < c->num_windows; w2++) {
161  if (c->grouping[w2])
162  break;
163  if (c->band_type[w2 * c->num_bands + b]) {
164  all_zero = 0;
165  break;
166  }
167  }
168  if (all_zero) {
169  c->band_scales[band_off++] = 0;
170  continue;
171  }
172  }
173  if (first) {
174  scale = get_bits(gb, 7);
175  first = 0;
176  } else {
177  scale += get_vlc2(gb, c->scale_diff.table, 9, 3);
178  }
179  if (scale < 0 || scale > 127) {
180  av_log(c->avctx, AV_LOG_ERROR, "Invalid scale value %d\n",
181  scale);
182  return AVERROR_INVALIDDATA;
183  }
184  c->band_scales[band_off++] = c->scale_tab[scale];
185  }
186  }
187 
188  return 0;
189 }
190 
191 static inline float on2avc_scale(int v, float scale)
192 {
193  return v * sqrtf(abs(v)) * scale;
194 }
195 
196 // spectral data is coded completely differently - there are no unsigned codebooks
197 static int on2avc_decode_quads(On2AVCContext *c, GetBitContext *gb, float *dst,
198  int dst_size, int type, float band_scale)
199 {
200  int i, j, val, val1;
201 
202  for (i = 0; i < dst_size; i += 4) {
203  val = get_vlc2(gb, c->cb_vlc[type].table, 9, 2);
204 
205  for (j = 0; j < 4; j++) {
206  val1 = sign_extend((val >> (12 - j * 4)) & 0xF, 4);
207  *dst++ = on2avc_scale(val1, band_scale);
208  }
209  }
210 
211  return 0;
212 }
213 
214 static inline int get_egolomb(GetBitContext *gb)
215 {
216  int v = 4;
217 
218  while (get_bits1(gb)) {
219  v++;
220  if (v > 30) {
221  av_log(NULL, AV_LOG_WARNING, "Too large golomb code in get_egolomb.\n");
222  v = 30;
223  break;
224  }
225  }
226 
227  return (1 << v) + get_bits_long(gb, v);
228 }
229 
230 static int on2avc_decode_pairs(On2AVCContext *c, GetBitContext *gb, float *dst,
231  int dst_size, int type, float band_scale)
232 {
233  int i, val, val1, val2, sign;
234 
235  for (i = 0; i < dst_size; i += 2) {
236  val = get_vlc2(gb, c->cb_vlc[type].table, 9, 2);
237 
238  val1 = sign_extend(val >> 8, 8);
239  val2 = sign_extend(val & 0xFF, 8);
240  if (type == ON2AVC_ESC_CB) {
241  if (val1 <= -16 || val1 >= 16) {
242  sign = 1 - (val1 < 0) * 2;
243  val1 = sign * get_egolomb(gb);
244  }
245  if (val2 <= -16 || val2 >= 16) {
246  sign = 1 - (val2 < 0) * 2;
247  val2 = sign * get_egolomb(gb);
248  }
249  }
250 
251  *dst++ = on2avc_scale(val1, band_scale);
252  *dst++ = on2avc_scale(val2, band_scale);
253  }
254 
255  return 0;
256 }
257 
259 {
260  int ret;
261  int w, b, band_idx;
262  float *coeff_ptr;
263 
264  if ((ret = on2avc_decode_band_types(c, gb)) < 0)
265  return ret;
266  if ((ret = on2avc_decode_band_scales(c, gb)) < 0)
267  return ret;
268 
269  coeff_ptr = c->coeffs[ch];
270  band_idx = 0;
271  memset(coeff_ptr, 0, ON2AVC_SUBFRAME_SIZE * sizeof(*coeff_ptr));
272  for (w = 0; w < c->num_windows; w++) {
273  for (b = 0; b < c->num_bands; b++) {
274  int band_size = c->band_start[b + 1] - c->band_start[b];
275  int band_type = c->band_type[band_idx + b];
276 
277  if (!band_type) {
278  coeff_ptr += band_size;
279  continue;
280  }
281  if (band_type < 9)
282  on2avc_decode_quads(c, gb, coeff_ptr, band_size, band_type,
283  c->band_scales[band_idx + b]);
284  else
285  on2avc_decode_pairs(c, gb, coeff_ptr, band_size, band_type,
286  c->band_scales[band_idx + b]);
287  coeff_ptr += band_size;
288  }
289  band_idx += c->num_bands;
290  }
291 
292  return 0;
293 }
294 
296 {
297  int w, b, i;
298  int band_off = 0;
299  float *ch0 = c->coeffs[0];
300  float *ch1 = c->coeffs[1];
301 
302  for (w = 0; w < c->num_windows; w++) {
303  for (b = 0; b < c->num_bands; b++) {
304  if (c->ms_info[band_off + b]) {
305  for (i = c->band_start[b]; i < c->band_start[b + 1]; i++) {
306  float l = *ch0, r = *ch1;
307  *ch0++ = l + r;
308  *ch1++ = l - r;
309  }
310  } else {
311  ch0 += c->band_start[b + 1] - c->band_start[b];
312  ch1 += c->band_start[b + 1] - c->band_start[b];
313  }
314  }
315  band_off += c->num_bands;
316  }
317  return 0;
318 }
319 
320 static void zero_head_and_tail(float *src, int len, int order0, int order1)
321 {
322  memset(src, 0, sizeof(*src) * order0);
323  memset(src + len - order1, 0, sizeof(*src) * order1);
324 }
325 
326 static void pretwiddle(float *src, float *dst, int dst_len, int tab_step,
327  int step, int order0, int order1, const double * const *tabs)
328 {
329  float *src2, *out;
330  const double *tab;
331  int i, j;
332 
333  out = dst;
334  tab = tabs[0];
335  for (i = 0; i < tab_step; i++) {
336  double sum = 0;
337  for (j = 0; j < order0; j++)
338  sum += src[j] * tab[j * tab_step + i];
339  out[i] += sum;
340  }
341 
342  out = dst + dst_len - tab_step;
343  tab = tabs[order0];
344  src2 = src + (dst_len - tab_step) / step + 1 + order0;
345  for (i = 0; i < tab_step; i++) {
346  double sum = 0;
347  for (j = 0; j < order1; j++)
348  sum += src2[j] * tab[j * tab_step + i];
349  out[i] += sum;
350  }
351 }
352 
353 static void twiddle(float *src1, float *src2, int src2_len,
354  const double *tab, int tab_len, int step,
355  int order0, int order1, const double * const *tabs)
356 {
357  int steps;
358  int mask;
359  int i, j;
360 
361  steps = (src2_len - tab_len) / step + 1;
362  pretwiddle(src1, src2, src2_len, tab_len, step, order0, order1, tabs);
363  mask = tab_len - 1;
364 
365  for (i = 0; i < steps; i++) {
366  float in0 = src1[order0 + i];
367  int pos = (src2_len - 1) & mask;
368 
369  if (pos < tab_len) {
370  const double *t = tab;
371  for (j = pos; j >= 0; j--)
372  src2[j] += in0 * *t++;
373  for (j = 0; j < tab_len - pos - 1; j++)
374  src2[src2_len - j - 1] += in0 * tab[pos + 1 + j];
375  } else {
376  for (j = 0; j < tab_len; j++)
377  src2[pos - j] += in0 * tab[j];
378  }
379  mask = pos + step;
380  }
381 }
382 
383 #define CMUL1_R(s, t, is, it) \
384  s[is + 0] * t[it + 0] - s[is + 1] * t[it + 1]
385 #define CMUL1_I(s, t, is, it) \
386  s[is + 0] * t[it + 1] + s[is + 1] * t[it + 0]
387 #define CMUL2_R(s, t, is, it) \
388  s[is + 0] * t[it + 0] + s[is + 1] * t[it + 1]
389 #define CMUL2_I(s, t, is, it) \
390  s[is + 0] * t[it + 1] - s[is + 1] * t[it + 0]
391 
392 #define CMUL0(dst, id, s0, s1, s2, s3, t0, t1, t2, t3, is, it) \
393  dst[id] = s0[is] * t0[it] + s1[is] * t1[it] \
394  + s2[is] * t2[it] + s3[is] * t3[it]; \
395  dst[id + 1] = s0[is] * t0[it + 1] + s1[is] * t1[it + 1] \
396  + s2[is] * t2[it + 1] + s3[is] * t3[it + 1];
397 
398 #define CMUL1(dst, s0, s1, s2, s3, t0, t1, t2, t3, is, it) \
399  *dst++ = CMUL1_R(s0, t0, is, it) \
400  + CMUL1_R(s1, t1, is, it) \
401  + CMUL1_R(s2, t2, is, it) \
402  + CMUL1_R(s3, t3, is, it); \
403  *dst++ = CMUL1_I(s0, t0, is, it) \
404  + CMUL1_I(s1, t1, is, it) \
405  + CMUL1_I(s2, t2, is, it) \
406  + CMUL1_I(s3, t3, is, it);
407 
408 #define CMUL2(dst, s0, s1, s2, s3, t0, t1, t2, t3, is, it) \
409  *dst++ = CMUL2_R(s0, t0, is, it) \
410  + CMUL2_R(s1, t1, is, it) \
411  + CMUL2_R(s2, t2, is, it) \
412  + CMUL2_R(s3, t3, is, it); \
413  *dst++ = CMUL2_I(s0, t0, is, it) \
414  + CMUL2_I(s1, t1, is, it) \
415  + CMUL2_I(s2, t2, is, it) \
416  + CMUL2_I(s3, t3, is, it);
417 
418 static void combine_fft(float *s0, float *s1, float *s2, float *s3, float *dst,
419  const float *t0, const float *t1,
420  const float *t2, const float *t3, int len, int step)
421 {
422  const float *h0, *h1, *h2, *h3;
423  float *d1, *d2;
424  int tmp, half;
425  int len2 = len >> 1, len4 = len >> 2;
426  int hoff;
427  int i, j, k;
428 
429  tmp = step;
430  for (half = len2; tmp > 1; half <<= 1, tmp >>= 1);
431 
432  h0 = t0 + half;
433  h1 = t1 + half;
434  h2 = t2 + half;
435  h3 = t3 + half;
436 
437  CMUL0(dst, 0, s0, s1, s2, s3, t0, t1, t2, t3, 0, 0);
438 
439  hoff = 2 * step * (len4 >> 1);
440 
441  j = 2;
442  k = 2 * step;
443  d1 = dst + 2;
444  d2 = dst + 2 + (len >> 1);
445  for (i = 0; i < (len4 - 1) >> 1; i++) {
446  CMUL1(d1, s0, s1, s2, s3, t0, t1, t2, t3, j, k);
447  CMUL1(d2, s0, s1, s2, s3, h0, h1, h2, h3, j, k);
448  j += 2;
449  k += 2 * step;
450  }
451  CMUL0(dst, len4, s0, s1, s2, s3, t0, t1, t2, t3, 1, hoff);
452  CMUL0(dst, len4 + len2, s0, s1, s2, s3, h0, h1, h2, h3, 1, hoff);
453 
454  j = len4;
455  k = hoff + 2 * step * len4;
456  d1 = dst + len4 + 2;
457  d2 = dst + len4 + 2 + len2;
458  for (i = 0; i < (len4 - 2) >> 1; i++) {
459  CMUL2(d1, s0, s1, s2, s3, t0, t1, t2, t3, j, k);
460  CMUL2(d2, s0, s1, s2, s3, h0, h1, h2, h3, j, k);
461  j -= 2;
462  k += 2 * step;
463  }
464  CMUL0(dst, len2 + 4, s0, s1, s2, s3, t0, t1, t2, t3, 0, k);
465 }
466 
467 static void wtf_end_512(On2AVCContext *c, float *out, float *src,
468  float *tmp0, float *tmp1)
469 {
470  memcpy(tmp1, tmp0, 384 * sizeof(*tmp0));
471  memcpy(tmp0 + 384, tmp1 + 384, 128 * sizeof(*tmp0));
472 
473  zero_head_and_tail(tmp1, 128, 16, 4);
474  zero_head_and_tail(tmp1 + 128, 128, 16, 4);
475  zero_head_and_tail(tmp1 + 256, 128, 13, 7);
476  zero_head_and_tail(tmp1 + 384, 128, 15, 5);
477 
478  c->fft128_fn(c->fft128, src + 0, tmp1 + 0, sizeof(float));
479  c->fft128_fn(c->fft128, src + 128, tmp1 + 128, sizeof(float));
480  c->fft128_fn(c->fft128, src + 256, tmp1 + 256, sizeof(float));
481  c->fft128_fn(c->fft128, src + 384, tmp1 + 384, sizeof(float));
482 
483  combine_fft(src, src + 128, src + 256, src + 384, tmp1,
486 
487  c->fft512_fn(c->fft512, src, tmp1, sizeof(float));
488 
489  pretwiddle(&tmp0[ 0], src, 512, 84, 4, 16, 4, ff_on2avc_tabs_20_84_1);
490  pretwiddle(&tmp0[128], src, 512, 84, 4, 16, 4, ff_on2avc_tabs_20_84_2);
491  pretwiddle(&tmp0[256], src, 512, 84, 4, 13, 7, ff_on2avc_tabs_20_84_3);
492  pretwiddle(&tmp0[384], src, 512, 84, 4, 15, 5, ff_on2avc_tabs_20_84_4);
493 }
494 
495 static void wtf_end_1024(On2AVCContext *c, float *out, float *src,
496  float *tmp0, float *tmp1)
497 {
498  memcpy(tmp1, tmp0, 768 * sizeof(*tmp0));
499  memcpy(tmp0 + 768, tmp1 + 768, 256 * sizeof(*tmp0));
500 
501  zero_head_and_tail(tmp1, 256, 16, 4);
502  zero_head_and_tail(tmp1 + 256, 256, 16, 4);
503  zero_head_and_tail(tmp1 + 512, 256, 13, 7);
504  zero_head_and_tail(tmp1 + 768, 256, 15, 5);
505 
506  c->fft256_fn(c->fft256, src + 0, tmp1 + 0, sizeof(float));
507  c->fft256_fn(c->fft256, src + 256, tmp1 + 256, sizeof(float));
508  c->fft256_fn(c->fft256, src + 512, tmp1 + 512, sizeof(float));
509  c->fft256_fn(c->fft256, src + 768, tmp1 + 768, sizeof(float));
510 
511  combine_fft(src, src + 256, src + 512, src + 768, tmp1,
514 
515  c->fft1024_fn(c->fft1024, src, tmp1, sizeof(float));
516 
517  pretwiddle(&tmp0[ 0], src, 1024, 84, 4, 16, 4, ff_on2avc_tabs_20_84_1);
518  pretwiddle(&tmp0[256], src, 1024, 84, 4, 16, 4, ff_on2avc_tabs_20_84_2);
519  pretwiddle(&tmp0[512], src, 1024, 84, 4, 13, 7, ff_on2avc_tabs_20_84_3);
520  pretwiddle(&tmp0[768], src, 1024, 84, 4, 15, 5, ff_on2avc_tabs_20_84_4);
521 }
522 
523 static void wtf_40(On2AVCContext *c, float *out, float *src, int size)
524 {
525  float *tmp0 = c->temp, *tmp1 = c->temp + 1024;
526 
527  memset(tmp0, 0, sizeof(*tmp0) * 1024);
528  memset(tmp1, 0, sizeof(*tmp1) * 1024);
529 
530  if (size == 512) {
531  twiddle(src, &tmp0[ 0], 16, ff_on2avc_tab_10_1, 10, 2, 1, 3, ff_on2avc_tabs_4_10_1);
532  twiddle(src + 8, &tmp0[ 0], 16, ff_on2avc_tab_10_2, 10, 2, 3, 1, ff_on2avc_tabs_4_10_2);
533  twiddle(src + 16, &tmp0[ 16], 16, ff_on2avc_tab_10_2, 10, 2, 3, 1, ff_on2avc_tabs_4_10_2);
534  twiddle(src + 24, &tmp0[ 16], 16, ff_on2avc_tab_10_1, 10, 2, 1, 3, ff_on2avc_tabs_4_10_1);
535  twiddle(src + 32, &tmp0[ 32], 16, ff_on2avc_tab_10_1, 10, 2, 1, 3, ff_on2avc_tabs_4_10_1);
536  twiddle(src + 40, &tmp0[ 32], 16, ff_on2avc_tab_10_2, 10, 2, 3, 1, ff_on2avc_tabs_4_10_2);
537  twiddle(src + 48, &tmp0[ 48], 16, ff_on2avc_tab_10_2, 10, 2, 3, 1, ff_on2avc_tabs_4_10_2);
538  twiddle(src + 56, &tmp0[ 48], 16, ff_on2avc_tab_10_1, 10, 2, 1, 3, ff_on2avc_tabs_4_10_1);
539  twiddle(&tmp0[ 0], &tmp1[ 0], 32, ff_on2avc_tab_20_1, 20, 2, 5, 4, ff_on2avc_tabs_9_20_1);
540  twiddle(&tmp0[16], &tmp1[ 0], 32, ff_on2avc_tab_20_2, 20, 2, 4, 5, ff_on2avc_tabs_9_20_2);
541  twiddle(&tmp0[32], &tmp1[ 32], 32, ff_on2avc_tab_20_2, 20, 2, 4, 5, ff_on2avc_tabs_9_20_2);
542  twiddle(&tmp0[48], &tmp1[ 32], 32, ff_on2avc_tab_20_1, 20, 2, 5, 4, ff_on2avc_tabs_9_20_1);
543  twiddle(src + 64, &tmp1[ 64], 32, ff_on2avc_tab_20_1, 20, 2, 5, 4, ff_on2avc_tabs_9_20_1);
544  twiddle(src + 80, &tmp1[ 64], 32, ff_on2avc_tab_20_2, 20, 2, 4, 5, ff_on2avc_tabs_9_20_2);
545  twiddle(src + 96, &tmp1[ 96], 32, ff_on2avc_tab_20_2, 20, 2, 4, 5, ff_on2avc_tabs_9_20_2);
546  twiddle(src + 112, &tmp1[ 96], 32, ff_on2avc_tab_20_1, 20, 2, 5, 4, ff_on2avc_tabs_9_20_1);
547  twiddle(src + 128, &tmp1[128], 32, ff_on2avc_tab_20_1, 20, 2, 5, 4, ff_on2avc_tabs_9_20_1);
548  twiddle(src + 144, &tmp1[128], 32, ff_on2avc_tab_20_2, 20, 2, 4, 5, ff_on2avc_tabs_9_20_2);
549  twiddle(src + 160, &tmp1[160], 32, ff_on2avc_tab_20_2, 20, 2, 4, 5, ff_on2avc_tabs_9_20_2);
550  twiddle(src + 176, &tmp1[160], 32, ff_on2avc_tab_20_1, 20, 2, 5, 4, ff_on2avc_tabs_9_20_1);
551 
552  memset(tmp0, 0, 64 * sizeof(*tmp0));
553 
554  twiddle(&tmp1[ 0], &tmp0[ 0], 128, ff_on2avc_tab_84_1, 84, 4, 16, 4, ff_on2avc_tabs_20_84_1);
555  twiddle(&tmp1[ 32], &tmp0[ 0], 128, ff_on2avc_tab_84_2, 84, 4, 16, 4, ff_on2avc_tabs_20_84_2);
556  twiddle(&tmp1[ 64], &tmp0[ 0], 128, ff_on2avc_tab_84_3, 84, 4, 13, 7, ff_on2avc_tabs_20_84_3);
557  twiddle(&tmp1[ 96], &tmp0[ 0], 128, ff_on2avc_tab_84_4, 84, 4, 15, 5, ff_on2avc_tabs_20_84_4);
558  twiddle(&tmp1[128], &tmp0[128], 128, ff_on2avc_tab_84_4, 84, 4, 15, 5, ff_on2avc_tabs_20_84_4);
559  twiddle(&tmp1[160], &tmp0[128], 128, ff_on2avc_tab_84_3, 84, 4, 13, 7, ff_on2avc_tabs_20_84_3);
560  twiddle(src + 192, &tmp0[128], 128, ff_on2avc_tab_84_2, 84, 4, 16, 4, ff_on2avc_tabs_20_84_2);
561  twiddle(src + 224, &tmp0[128], 128, ff_on2avc_tab_84_1, 84, 4, 16, 4, ff_on2avc_tabs_20_84_1);
562  twiddle(src + 256, &tmp0[256], 128, ff_on2avc_tab_84_1, 84, 4, 16, 4, ff_on2avc_tabs_20_84_1);
563  twiddle(src + 288, &tmp0[256], 128, ff_on2avc_tab_84_2, 84, 4, 16, 4, ff_on2avc_tabs_20_84_2);
564  twiddle(src + 320, &tmp0[256], 128, ff_on2avc_tab_84_3, 84, 4, 13, 7, ff_on2avc_tabs_20_84_3);
565  twiddle(src + 352, &tmp0[256], 128, ff_on2avc_tab_84_4, 84, 4, 15, 5, ff_on2avc_tabs_20_84_4);
566 
567  wtf_end_512(c, out, src, tmp0, tmp1);
568  } else {
569  twiddle(src, &tmp0[ 0], 32, ff_on2avc_tab_20_1, 20, 2, 5, 4, ff_on2avc_tabs_9_20_1);
570  twiddle(src + 16, &tmp0[ 0], 32, ff_on2avc_tab_20_2, 20, 2, 4, 5, ff_on2avc_tabs_9_20_2);
571  twiddle(src + 32, &tmp0[ 32], 32, ff_on2avc_tab_20_2, 20, 2, 4, 5, ff_on2avc_tabs_9_20_2);
572  twiddle(src + 48, &tmp0[ 32], 32, ff_on2avc_tab_20_1, 20, 2, 5, 4, ff_on2avc_tabs_9_20_1);
573  twiddle(src + 64, &tmp0[ 64], 32, ff_on2avc_tab_20_1, 20, 2, 5, 4, ff_on2avc_tabs_9_20_1);
574  twiddle(src + 80, &tmp0[ 64], 32, ff_on2avc_tab_20_2, 20, 2, 4, 5, ff_on2avc_tabs_9_20_2);
575  twiddle(src + 96, &tmp0[ 96], 32, ff_on2avc_tab_20_2, 20, 2, 4, 5, ff_on2avc_tabs_9_20_2);
576  twiddle(src + 112, &tmp0[ 96], 32, ff_on2avc_tab_20_1, 20, 2, 5, 4, ff_on2avc_tabs_9_20_1);
577  twiddle(&tmp0[ 0], &tmp1[ 0], 64, ff_on2avc_tab_40_1, 40, 2, 11, 8, ff_on2avc_tabs_19_40_1);
578  twiddle(&tmp0[32], &tmp1[ 0], 64, ff_on2avc_tab_40_2, 40, 2, 8, 11, ff_on2avc_tabs_19_40_2);
579  twiddle(&tmp0[64], &tmp1[ 64], 64, ff_on2avc_tab_40_2, 40, 2, 8, 11, ff_on2avc_tabs_19_40_2);
580  twiddle(&tmp0[96], &tmp1[ 64], 64, ff_on2avc_tab_40_1, 40, 2, 11, 8, ff_on2avc_tabs_19_40_1);
581  twiddle(src + 128, &tmp1[128], 64, ff_on2avc_tab_40_1, 40, 2, 11, 8, ff_on2avc_tabs_19_40_1);
582  twiddle(src + 160, &tmp1[128], 64, ff_on2avc_tab_40_2, 40, 2, 8, 11, ff_on2avc_tabs_19_40_2);
583  twiddle(src + 192, &tmp1[192], 64, ff_on2avc_tab_40_2, 40, 2, 8, 11, ff_on2avc_tabs_19_40_2);
584  twiddle(src + 224, &tmp1[192], 64, ff_on2avc_tab_40_1, 40, 2, 11, 8, ff_on2avc_tabs_19_40_1);
585  twiddle(src + 256, &tmp1[256], 64, ff_on2avc_tab_40_1, 40, 2, 11, 8, ff_on2avc_tabs_19_40_1);
586  twiddle(src + 288, &tmp1[256], 64, ff_on2avc_tab_40_2, 40, 2, 8, 11, ff_on2avc_tabs_19_40_2);
587  twiddle(src + 320, &tmp1[320], 64, ff_on2avc_tab_40_2, 40, 2, 8, 11, ff_on2avc_tabs_19_40_2);
588  twiddle(src + 352, &tmp1[320], 64, ff_on2avc_tab_40_1, 40, 2, 11, 8, ff_on2avc_tabs_19_40_1);
589 
590  memset(tmp0, 0, 128 * sizeof(*tmp0));
591 
592  twiddle(&tmp1[ 0], &tmp0[ 0], 256, ff_on2avc_tab_84_1, 84, 4, 16, 4, ff_on2avc_tabs_20_84_1);
593  twiddle(&tmp1[ 64], &tmp0[ 0], 256, ff_on2avc_tab_84_2, 84, 4, 16, 4, ff_on2avc_tabs_20_84_2);
594  twiddle(&tmp1[128], &tmp0[ 0], 256, ff_on2avc_tab_84_3, 84, 4, 13, 7, ff_on2avc_tabs_20_84_3);
595  twiddle(&tmp1[192], &tmp0[ 0], 256, ff_on2avc_tab_84_4, 84, 4, 15, 5, ff_on2avc_tabs_20_84_4);
596  twiddle(&tmp1[256], &tmp0[256], 256, ff_on2avc_tab_84_4, 84, 4, 15, 5, ff_on2avc_tabs_20_84_4);
597  twiddle(&tmp1[320], &tmp0[256], 256, ff_on2avc_tab_84_3, 84, 4, 13, 7, ff_on2avc_tabs_20_84_3);
598  twiddle(src + 384, &tmp0[256], 256, ff_on2avc_tab_84_2, 84, 4, 16, 4, ff_on2avc_tabs_20_84_2);
599  twiddle(src + 448, &tmp0[256], 256, ff_on2avc_tab_84_1, 84, 4, 16, 4, ff_on2avc_tabs_20_84_1);
600  twiddle(src + 512, &tmp0[512], 256, ff_on2avc_tab_84_1, 84, 4, 16, 4, ff_on2avc_tabs_20_84_1);
601  twiddle(src + 576, &tmp0[512], 256, ff_on2avc_tab_84_2, 84, 4, 16, 4, ff_on2avc_tabs_20_84_2);
602  twiddle(src + 640, &tmp0[512], 256, ff_on2avc_tab_84_3, 84, 4, 13, 7, ff_on2avc_tabs_20_84_3);
603  twiddle(src + 704, &tmp0[512], 256, ff_on2avc_tab_84_4, 84, 4, 15, 5, ff_on2avc_tabs_20_84_4);
604 
605  wtf_end_1024(c, out, src, tmp0, tmp1);
606  }
607 }
608 
609 static void wtf_44(On2AVCContext *c, float *out, float *src, int size)
610 {
611  float *tmp0 = c->temp, *tmp1 = c->temp + 1024;
612 
613  memset(tmp0, 0, sizeof(*tmp0) * 1024);
614  memset(tmp1, 0, sizeof(*tmp1) * 1024);
615 
616  if (size == 512) {
617  twiddle(src, &tmp0[ 0], 16, ff_on2avc_tab_10_1, 10, 2, 1, 3, ff_on2avc_tabs_4_10_1);
618  twiddle(src + 8, &tmp0[ 0], 16, ff_on2avc_tab_10_2, 10, 2, 3, 1, ff_on2avc_tabs_4_10_2);
619  twiddle(src + 16, &tmp0[16], 16, ff_on2avc_tab_10_2, 10, 2, 3, 1, ff_on2avc_tabs_4_10_2);
620  twiddle(src + 24, &tmp0[16], 16, ff_on2avc_tab_10_1, 10, 2, 1, 3, ff_on2avc_tabs_4_10_1);
621  twiddle(src + 32, &tmp0[32], 16, ff_on2avc_tab_10_1, 10, 2, 1, 3, ff_on2avc_tabs_4_10_1);
622  twiddle(src + 40, &tmp0[32], 16, ff_on2avc_tab_10_2, 10, 2, 3, 1, ff_on2avc_tabs_4_10_2);
623  twiddle(src + 48, &tmp0[48], 16, ff_on2avc_tab_10_2, 10, 2, 3, 1, ff_on2avc_tabs_4_10_2);
624  twiddle(src + 56, &tmp0[48], 16, ff_on2avc_tab_10_1, 10, 2, 1, 3, ff_on2avc_tabs_4_10_1);
625  twiddle(&tmp0[ 0], &tmp1[ 0], 32, ff_on2avc_tab_20_1, 20, 2, 5, 4, ff_on2avc_tabs_9_20_1);
626  twiddle(&tmp0[16], &tmp1[ 0], 32, ff_on2avc_tab_20_2, 20, 2, 4, 5, ff_on2avc_tabs_9_20_2);
627  twiddle(&tmp0[32], &tmp1[32], 32, ff_on2avc_tab_20_2, 20, 2, 4, 5, ff_on2avc_tabs_9_20_2);
628  twiddle(&tmp0[48], &tmp1[32], 32, ff_on2avc_tab_20_1, 20, 2, 5, 4, ff_on2avc_tabs_9_20_1);
629  twiddle(src + 64, &tmp1[64], 32, ff_on2avc_tab_20_1, 20, 2, 5, 4, ff_on2avc_tabs_9_20_1);
630  twiddle(src + 80, &tmp1[64], 32, ff_on2avc_tab_20_2, 20, 2, 4, 5, ff_on2avc_tabs_9_20_2);
631  twiddle(src + 96, &tmp1[96], 32, ff_on2avc_tab_20_2, 20, 2, 4, 5, ff_on2avc_tabs_9_20_2);
632  twiddle(src + 112, &tmp1[96], 32, ff_on2avc_tab_20_1, 20, 2, 5, 4, ff_on2avc_tabs_9_20_1);
633 
634  memset(tmp0, 0, 64 * sizeof(*tmp0));
635 
636  twiddle(&tmp1[ 0], &tmp0[ 0], 128, ff_on2avc_tab_84_1, 84, 4, 16, 4, ff_on2avc_tabs_20_84_1);
637  twiddle(&tmp1[32], &tmp0[ 0], 128, ff_on2avc_tab_84_2, 84, 4, 16, 4, ff_on2avc_tabs_20_84_2);
638  twiddle(&tmp1[64], &tmp0[ 0], 128, ff_on2avc_tab_84_3, 84, 4, 13, 7, ff_on2avc_tabs_20_84_3);
639  twiddle(&tmp1[96], &tmp0[ 0], 128, ff_on2avc_tab_84_4, 84, 4, 15, 5, ff_on2avc_tabs_20_84_4);
640  twiddle(src + 128, &tmp0[128], 128, ff_on2avc_tab_84_4, 84, 4, 15, 5, ff_on2avc_tabs_20_84_4);
641  twiddle(src + 160, &tmp0[128], 128, ff_on2avc_tab_84_3, 84, 4, 13, 7, ff_on2avc_tabs_20_84_3);
642  twiddle(src + 192, &tmp0[128], 128, ff_on2avc_tab_84_2, 84, 4, 16, 4, ff_on2avc_tabs_20_84_2);
643  twiddle(src + 224, &tmp0[128], 128, ff_on2avc_tab_84_1, 84, 4, 16, 4, ff_on2avc_tabs_20_84_1);
644  twiddle(src + 256, &tmp0[256], 128, ff_on2avc_tab_40_1, 40, 2, 11, 8, ff_on2avc_tabs_19_40_1);
645  twiddle(src + 320, &tmp0[256], 128, ff_on2avc_tab_40_2, 40, 2, 8, 11, ff_on2avc_tabs_19_40_2);
646 
647  wtf_end_512(c, out, src, tmp0, tmp1);
648  } else {
649  twiddle(src, &tmp0[ 0], 32, ff_on2avc_tab_20_1, 20, 2, 5, 4, ff_on2avc_tabs_9_20_1);
650  twiddle(src + 16, &tmp0[ 0], 32, ff_on2avc_tab_20_2, 20, 2, 4, 5, ff_on2avc_tabs_9_20_2);
651  twiddle(src + 32, &tmp0[ 32], 32, ff_on2avc_tab_20_2, 20, 2, 4, 5, ff_on2avc_tabs_9_20_2);
652  twiddle(src + 48, &tmp0[ 32], 32, ff_on2avc_tab_20_1, 20, 2, 5, 4, ff_on2avc_tabs_9_20_1);
653  twiddle(src + 64, &tmp0[ 64], 32, ff_on2avc_tab_20_1, 20, 2, 5, 4, ff_on2avc_tabs_9_20_1);
654  twiddle(src + 80, &tmp0[ 64], 32, ff_on2avc_tab_20_2, 20, 2, 4, 5, ff_on2avc_tabs_9_20_2);
655  twiddle(src + 96, &tmp0[ 96], 32, ff_on2avc_tab_20_2, 20, 2, 4, 5, ff_on2avc_tabs_9_20_2);
656  twiddle(src + 112, &tmp0[ 96], 32, ff_on2avc_tab_20_1, 20, 2, 5, 4, ff_on2avc_tabs_9_20_1);
657  twiddle(&tmp0[ 0], &tmp1[ 0], 64, ff_on2avc_tab_40_1, 40, 2, 11, 8, ff_on2avc_tabs_19_40_1);
658  twiddle(&tmp0[32], &tmp1[ 0], 64, ff_on2avc_tab_40_2, 40, 2, 8, 11, ff_on2avc_tabs_19_40_2);
659  twiddle(&tmp0[64], &tmp1[ 64], 64, ff_on2avc_tab_40_2, 40, 2, 8, 11, ff_on2avc_tabs_19_40_2);
660  twiddle(&tmp0[96], &tmp1[ 64], 64, ff_on2avc_tab_40_1, 40, 2, 11, 8, ff_on2avc_tabs_19_40_1);
661  twiddle(src + 128, &tmp1[128], 64, ff_on2avc_tab_40_1, 40, 2, 11, 8, ff_on2avc_tabs_19_40_1);
662  twiddle(src + 160, &tmp1[128], 64, ff_on2avc_tab_40_2, 40, 2, 8, 11, ff_on2avc_tabs_19_40_2);
663  twiddle(src + 192, &tmp1[192], 64, ff_on2avc_tab_40_2, 40, 2, 8, 11, ff_on2avc_tabs_19_40_2);
664  twiddle(src + 224, &tmp1[192], 64, ff_on2avc_tab_40_1, 40, 2, 11, 8, ff_on2avc_tabs_19_40_1);
665 
666  memset(tmp0, 0, 128 * sizeof(*tmp0));
667 
668  twiddle(&tmp1[ 0], &tmp0[ 0], 256, ff_on2avc_tab_84_1, 84, 4, 16, 4, ff_on2avc_tabs_20_84_1);
669  twiddle(&tmp1[ 64], &tmp0[ 0], 256, ff_on2avc_tab_84_2, 84, 4, 16, 4, ff_on2avc_tabs_20_84_2);
670  twiddle(&tmp1[128], &tmp0[ 0], 256, ff_on2avc_tab_84_3, 84, 4, 13, 7, ff_on2avc_tabs_20_84_3);
671  twiddle(&tmp1[192], &tmp0[ 0], 256, ff_on2avc_tab_84_4, 84, 4, 15, 5, ff_on2avc_tabs_20_84_4);
672  twiddle(src + 256, &tmp0[256], 256, ff_on2avc_tab_84_4, 84, 4, 15, 5, ff_on2avc_tabs_20_84_4);
673  twiddle(src + 320, &tmp0[256], 256, ff_on2avc_tab_84_3, 84, 4, 13, 7, ff_on2avc_tabs_20_84_3);
674  twiddle(src + 384, &tmp0[256], 256, ff_on2avc_tab_84_2, 84, 4, 16, 4, ff_on2avc_tabs_20_84_2);
675  twiddle(src + 448, &tmp0[256], 256, ff_on2avc_tab_84_1, 84, 4, 16, 4, ff_on2avc_tabs_20_84_1);
676  twiddle(src + 512, &tmp0[512], 256, ff_on2avc_tab_40_1, 40, 2, 11, 8, ff_on2avc_tabs_19_40_1);
677  twiddle(src + 640, &tmp0[512], 256, ff_on2avc_tab_40_2, 40, 2, 8, 11, ff_on2avc_tabs_19_40_2);
678 
679  wtf_end_1024(c, out, src, tmp0, tmp1);
680  }
681 }
682 
684 {
685  int ch, i;
686 
687  for (ch = 0; ch < c->avctx->ch_layout.nb_channels; ch++) {
688  float *out = (float*)dst->extended_data[ch] + offset;
689  float *in = c->coeffs[ch];
690  float *saved = c->delay[ch];
691  float *buf = c->mdct_buf;
692  float *wout = out + 448;
693 
694  switch (c->window_type) {
695  case WINDOW_TYPE_EXT7:
696  c->mdct_fn(c->mdct, buf, in, sizeof(float));
697  break;
698  case WINDOW_TYPE_EXT4:
699  c->wtf(c, buf, in, 1024);
700  break;
701  case WINDOW_TYPE_EXT5:
702  c->wtf(c, buf, in, 512);
703  c->mdct_half_fn(c->mdct, buf + 512, in + 512, sizeof(float));
704  for (i = 0; i < 256; i++) {
705  FFSWAP(float, buf[i + 512], buf[1023 - i]);
706  }
707  break;
708  case WINDOW_TYPE_EXT6:
709  c->mdct_half_fn(c->mdct_half, buf, in, sizeof(float));
710  for (i = 0; i < 256; i++) {
711  FFSWAP(float, buf[i], buf[511 - i]);
712  }
713  c->wtf(c, buf + 512, in + 512, 512);
714  break;
715  }
716 
717  memcpy(out, saved, 448 * sizeof(float));
718  c->fdsp->vector_fmul_window(wout, saved + 448, buf, c->short_win, 64);
719  memcpy(wout + 128, buf + 64, 448 * sizeof(float));
720  memcpy(saved, buf + 512, 448 * sizeof(float));
721  memcpy(saved + 448, buf + 7*128 + 64, 64 * sizeof(float));
722  }
723 
724  return 0;
725 }
726 
727 // not borrowed from aacdec.c - the codec has original design after all
729  AVFrame *dst, int offset)
730 {
731  int i;
732  float *out = (float*)dst->extended_data[channel] + offset;
733  float *in = c->coeffs[channel];
734  float *saved = c->delay[channel];
735  float *buf = c->mdct_buf;
736  float *temp = c->temp;
737 
738  switch (c->window_type) {
741  case WINDOW_TYPE_LONG:
742  c->mdct_fn(c->mdct, buf, in, sizeof(float));
743  break;
744  case WINDOW_TYPE_8SHORT:
745  for (i = 0; i < ON2AVC_SUBFRAME_SIZE; i += ON2AVC_SUBFRAME_SIZE / 8)
746  c->mdct_small_fn(c->mdct_small, buf + i, in + i, sizeof(float));
747  break;
748  }
749 
750  if ((c->prev_window_type == WINDOW_TYPE_LONG ||
751  c->prev_window_type == WINDOW_TYPE_LONG_STOP) &&
752  (c->window_type == WINDOW_TYPE_LONG ||
753  c->window_type == WINDOW_TYPE_LONG_START)) {
754  c->fdsp->vector_fmul_window(out, saved, buf, c->long_win, 512);
755  } else {
756  float *wout = out + 448;
757  memcpy(out, saved, 448 * sizeof(float));
758 
759  if (c->window_type == WINDOW_TYPE_8SHORT) {
760  c->fdsp->vector_fmul_window(wout + 0*128, saved + 448, buf + 0*128, c->short_win, 64);
761  c->fdsp->vector_fmul_window(wout + 1*128, buf + 0*128 + 64, buf + 1*128, c->short_win, 64);
762  c->fdsp->vector_fmul_window(wout + 2*128, buf + 1*128 + 64, buf + 2*128, c->short_win, 64);
763  c->fdsp->vector_fmul_window(wout + 3*128, buf + 2*128 + 64, buf + 3*128, c->short_win, 64);
764  c->fdsp->vector_fmul_window(temp, buf + 3*128 + 64, buf + 4*128, c->short_win, 64);
765  memcpy(wout + 4*128, temp, 64 * sizeof(float));
766  } else {
767  c->fdsp->vector_fmul_window(wout, saved + 448, buf, c->short_win, 64);
768  memcpy(wout + 128, buf + 64, 448 * sizeof(float));
769  }
770  }
771 
772  // buffer update
773  switch (c->window_type) {
774  case WINDOW_TYPE_8SHORT:
775  memcpy(saved, temp + 64, 64 * sizeof(float));
776  c->fdsp->vector_fmul_window(saved + 64, buf + 4*128 + 64, buf + 5*128, c->short_win, 64);
777  c->fdsp->vector_fmul_window(saved + 192, buf + 5*128 + 64, buf + 6*128, c->short_win, 64);
778  c->fdsp->vector_fmul_window(saved + 320, buf + 6*128 + 64, buf + 7*128, c->short_win, 64);
779  memcpy(saved + 448, buf + 7*128 + 64, 64 * sizeof(float));
780  break;
782  memcpy(saved, buf + 512, 448 * sizeof(float));
783  memcpy(saved + 448, buf + 7*128 + 64, 64 * sizeof(float));
784  break;
786  case WINDOW_TYPE_LONG:
787  memcpy(saved, buf + 512, 512 * sizeof(float));
788  break;
789  }
790  return 0;
791 }
792 
793 static int on2avc_decode_subframe(On2AVCContext *c, const uint8_t *buf,
794  int buf_size, AVFrame *dst, int offset)
795 {
796  GetBitContext gb;
797  int i, ret;
798 
799  if ((ret = init_get_bits8(&gb, buf, buf_size)) < 0)
800  return ret;
801 
802  if (get_bits1(&gb)) {
803  av_log(c->avctx, AV_LOG_ERROR, "enh bit set\n");
804  return AVERROR_INVALIDDATA;
805  }
806  c->prev_window_type = c->window_type;
807  c->window_type = get_bits(&gb, 3);
808 
809  c->band_start = c->modes[c->window_type].band_start;
810  c->num_windows = c->modes[c->window_type].num_windows;
811  c->num_bands = c->modes[c->window_type].num_bands;
812  c->is_long = (c->window_type != WINDOW_TYPE_8SHORT);
813 
814  c->grouping[0] = 1;
815  for (i = 1; i < c->num_windows; i++)
816  c->grouping[i] = !get_bits1(&gb);
817 
818  on2avc_read_ms_info(c, &gb);
819  for (i = 0; i < c->avctx->ch_layout.nb_channels; i++)
820  if ((ret = on2avc_read_channel_data(c, &gb, i)) < 0)
821  return AVERROR_INVALIDDATA;
822  if (c->avctx->ch_layout.nb_channels == 2 && c->ms_present)
824  if (c->window_type < WINDOW_TYPE_EXT4) {
825  for (i = 0; i < c->avctx->ch_layout.nb_channels; i++)
827  } else {
829  }
830 
831  return 0;
832 }
833 
835  int *got_frame_ptr, AVPacket *avpkt)
836 {
837  const uint8_t *buf = avpkt->data;
838  int buf_size = avpkt->size;
840  GetByteContext gb;
841  int num_frames = 0, frame_size, audio_off;
842  int ret;
843 
844  if (c->is_av500) {
845  /* get output buffer */
846  frame->nb_samples = ON2AVC_SUBFRAME_SIZE;
847  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
848  return ret;
849 
850  if ((ret = on2avc_decode_subframe(c, buf, buf_size, frame, 0)) < 0)
851  return ret;
852  } else {
853  bytestream2_init(&gb, buf, buf_size);
854  while (bytestream2_get_bytes_left(&gb) > 2) {
855  frame_size = bytestream2_get_le16(&gb);
857  av_log(avctx, AV_LOG_ERROR, "Invalid subframe size %d\n",
858  frame_size);
859  return AVERROR_INVALIDDATA;
860  }
861  num_frames++;
863  }
864  if (!num_frames) {
865  av_log(avctx, AV_LOG_ERROR, "No subframes present\n");
866  return AVERROR_INVALIDDATA;
867  }
868 
869  /* get output buffer */
870  frame->nb_samples = ON2AVC_SUBFRAME_SIZE * num_frames;
871  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
872  return ret;
873 
874  audio_off = 0;
875  bytestream2_init(&gb, buf, buf_size);
876  while (bytestream2_get_bytes_left(&gb) > 2) {
877  frame_size = bytestream2_get_le16(&gb);
879  frame, audio_off)) < 0)
880  return ret;
881  audio_off += ON2AVC_SUBFRAME_SIZE;
883  }
884  }
885 
886  *got_frame_ptr = 1;
887 
888  return buf_size;
889 }
890 
892 {
893  int i;
894 
895  ff_free_vlc(&c->scale_diff);
896  for (i = 1; i < 16; i++)
897  ff_free_vlc(&c->cb_vlc[i]);
898 }
899 
901 {
903  const uint8_t *lens = ff_on2avc_cb_lens;
904  const uint16_t *syms = ff_on2avc_cb_syms;
906  float scale;
907  int i, ret;
908 
909  if (channels > 2U) {
910  avpriv_request_sample(avctx, "Decoding more than 2 channels");
911  return AVERROR_PATCHWELCOME;
912  }
913 
914  c->avctx = avctx;
919 
920  c->is_av500 = (avctx->codec_tag == 0x500);
921 
922  if (channels == 2)
924  "Stereo mode support is not good, patch is welcome\n");
925 
926  // We add -0.01 before ceil() to avoid any values to fall at exactly the
927  // midpoint between different ceil values. The results are identical to
928  // using pow(10, i / 10.0) without such bias
929  for (i = 0; i < 20; i++)
930  c->scale_tab[i] = ceil(ff_exp10(i * 0.1) * 16 - 0.01) / 32;
931  for (; i < 128; i++)
932  c->scale_tab[i] = ceil(ff_exp10(i * 0.1) * 0.5 - 0.01);
933 
934  if (avctx->sample_rate < 32000 || channels == 1)
935  memcpy(c->long_win, ff_on2avc_window_long_24000,
936  1024 * sizeof(*c->long_win));
937  else
938  memcpy(c->long_win, ff_on2avc_window_long_32000,
939  1024 * sizeof(*c->long_win));
940  memcpy(c->short_win, ff_on2avc_window_short, 128 * sizeof(*c->short_win));
941 
942  c->modes = (avctx->sample_rate <= 40000) ? ff_on2avc_modes_40
944  c->wtf = (avctx->sample_rate <= 40000) ? wtf_40
945  : wtf_44;
946 
947  scale = 1.0 / (1024*32768);
948  if ((ret = av_tx_init(&c->mdct, &c->mdct_fn, AV_TX_FLOAT_MDCT, 1, 1024, &scale, 0)) < 0)
949  return ret;
950 
951  scale = 1.0 / (512*32768);
952  if ((ret = av_tx_init(&c->mdct_half, &c->mdct_half_fn, AV_TX_FLOAT_MDCT, 1, 512, &scale, 0)) < 0)
953  return ret;
954 
955  scale = 1.0 / (128*32768);
956  if ((ret = av_tx_init(&c->mdct_small, &c->mdct_small_fn, AV_TX_FLOAT_MDCT, 1, 128, &scale, 0)) < 0)
957  return ret;
958 
959  if ((ret = av_tx_init(&c->fft1024, &c->fft1024_fn, AV_TX_FLOAT_FFT, 1, 1024, NULL, 0)) < 0)
960  return ret;
961  if ((ret = av_tx_init(&c->fft512, &c->fft512_fn, AV_TX_FLOAT_FFT, 1, 512, NULL, 0)) < 0)
962  return ret;
963  if ((ret = av_tx_init(&c->fft256, &c->fft256_fn, AV_TX_FLOAT_FFT, 0, 256, NULL, 0)) < 0)
964  return ret;
965  if ((ret = av_tx_init(&c->fft128, &c->fft128_fn, AV_TX_FLOAT_FFT, 0, 128, NULL, 0)) < 0)
966  return ret;
967 
969  if (!c->fdsp)
970  return AVERROR(ENOMEM);
971 
974  ff_on2avc_scale_diff_syms, 1, 1, -60, 0, avctx);
975  if (ret < 0)
976  goto vlc_fail;
977  for (i = 1; i < 16; i++) {
978  int idx = i - 1;
979  ret = ff_init_vlc_from_lengths(&c->cb_vlc[i], 9, ff_on2avc_cb_elems[idx],
980  lens, 1,
981  syms, 2, 2, 0, 0, avctx);
982  if (ret < 0)
983  goto vlc_fail;
984  lens += ff_on2avc_cb_elems[idx];
985  syms += ff_on2avc_cb_elems[idx];
986  }
987 
988  return 0;
989 vlc_fail:
990  av_log(avctx, AV_LOG_ERROR, "Cannot init VLC\n");
991  return ret;
992 }
993 
995 {
997 
998  av_tx_uninit(&c->mdct);
999  av_tx_uninit(&c->mdct_half);
1000  av_tx_uninit(&c->mdct_small);
1001  av_tx_uninit(&c->fft128);
1002  av_tx_uninit(&c->fft256);
1003  av_tx_uninit(&c->fft512);
1004  av_tx_uninit(&c->fft1024);
1005 
1006  av_freep(&c->fdsp);
1007 
1009 
1010  return 0;
1011 }
1012 
1013 
1015  .p.name = "on2avc",
1016  CODEC_LONG_NAME("On2 Audio for Video Codec"),
1017  .p.type = AVMEDIA_TYPE_AUDIO,
1018  .p.id = AV_CODEC_ID_ON2AVC,
1019  .priv_data_size = sizeof(On2AVCContext),
1022  .close = on2avc_decode_close,
1023  .p.capabilities = AV_CODEC_CAP_DR1,
1024  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1025  .p.sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
1027 };
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:197
get_egolomb
static int get_egolomb(GetBitContext *gb)
Definition: on2avc.c:214
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:900
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
on2avc_apply_ms
static int on2avc_apply_ms(On2AVCContext *c)
Definition: on2avc.c:295
ff_on2avc_decoder
const FFCodec ff_on2avc_decoder
Definition: on2avc.c:1014
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:191
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:126
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:44
mem_internal.h
ff_on2avc_cb_lens
const uint8_t ff_on2avc_cb_lens[]
Definition: on2avcdata.c:146
out
FILE * out
Definition: movenc.c:54
AV_CHANNEL_LAYOUT_STEREO
#define AV_CHANNEL_LAYOUT_STEREO
Definition: channel_layout.h:369
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:1007
GetByteContext
Definition: bytestream.h:33
On2AVCContext::cb_vlc
VLC cb_vlc[16]
Definition: on2avc.c:80
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:353
On2AVCContext::fdsp
AVFloatDSPContext * fdsp
Definition: on2avc.c:52
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:68
src1
const pixel * src1
Definition: h264pred_template.c:421
AVTXContext
Definition: tx_priv.h:228
On2AVCContext::delay
float delay[2][ON2AVC_SUBFRAME_SIZE]
Definition: on2avc.c:85
get_bits_long
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:546
wtf_44
static void wtf_44(On2AVCContext *c, float *out, float *src, int size)
Definition: on2avc.c:609
ON2AVC_SCALE_DIFFS
#define ON2AVC_SCALE_DIFFS
Definition: on2avcdata.h:40
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:325
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:69
On2AVCContext::short_win
float short_win[ON2AVC_SUBFRAME_SIZE/8]
Definition: on2avc.c:90
AVPacket::data
uint8_t * data
Definition: packet.h:374
t0
#define t0
Definition: regdef.h:28
b
#define b
Definition: input.c:41
tabs
static const struct @103 tabs[]
on2avc_reconstruct_channel
static int on2avc_reconstruct_channel(On2AVCContext *c, int channel, AVFrame *dst, int offset)
Definition: on2avc.c:728
half
static uint8_t half(int a, int b)
Definition: mobiclip.c:541
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:230
On2AVCContext::fft512_fn
av_tx_fn fft512_fn
Definition: on2avc.c:56
FFCodec
Definition: codec_internal.h:119
On2AVCContext::band_run_end
uint8_t band_run_end[ON2AVC_MAX_BANDS]
Definition: on2avc.c:74
AV_CODEC_ID_ON2AVC
@ AV_CODEC_ID_ON2AVC
Definition: codec_id.h:500
t1
#define t1
Definition: regdef.h:29
WINDOW_TYPE_EXT7
@ WINDOW_TYPE_EXT7
Definition: on2avc.c:47
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:311
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:883
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:418
On2AVCContext::grouping
int grouping[8]
Definition: on2avc.c:67
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:55
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:379
On2AVCContext::wtf
void(* wtf)(struct On2AVCContext *ctx, float *out, float *in, int size)
Definition: on2avc.c:57
s3
#define s3
Definition: regdef.h:40
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:123
wtf_end_512
static void wtf_end_512(On2AVCContext *c, float *out, float *src, float *tmp0, float *tmp1)
Definition: on2avc.c:467
AVCodecContext::ch_layout
AVChannelLayout ch_layout
Audio channel layout.
Definition: avcodec.h:2059
GetBitContext
Definition: get_bits.h:61
On2AVCContext::prev_window_type
int prev_window_type
Definition: on2avc.c:62
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:478
val
static double val(void *priv, double ch)
Definition: aeval.c:77
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:683
scale
static av_always_inline float scale(float x, float s)
Definition: vf_v360.c:1389
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:326
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:667
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:127
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:298
ON2AVC_SUBFRAME_SIZE
#define ON2AVC_SUBFRAME_SIZE
Definition: on2avc.c:37
frame_size
int frame_size
Definition: mxfenc.c:2202
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:77
GetByteContext::buffer
const uint8_t * buffer
Definition: bytestream.h:34
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts_bsf.c:363
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:48
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:264
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:54
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:203
WINDOW_TYPE_EXT6
@ WINDOW_TYPE_EXT6
Definition: on2avc.c:46
On2AVCContext::coeffs
float coeffs[2][ON2AVC_SUBFRAME_SIZE]
Definition: on2avc.c:84
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:88
WINDOW_TYPE_LONG
@ WINDOW_TYPE_LONG
Definition: on2avc.c:40
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
ff_init_vlc_from_lengths
int ff_init_vlc_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:328
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
On2AVCContext::fft1024
AVTXContext * fft1024
Definition: on2avc.c:54
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:787
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:75
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:61
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:1450
On2AVCContext::avctx
AVCodecContext * avctx
Definition: on2avc.c:51
on2avc_decode_close
static av_cold int on2avc_decode_close(AVCodecContext *avctx)
Definition: on2avc.c:994
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:375
On2AVCContext::fft256_fn
av_tx_fn fft256_fn
Definition: on2avc.c:56
CMUL2
#define CMUL2(dst, s0, s1, s2, s3, t0, t1, t2, t3, is, it)
Definition: on2avc.c:408
CMUL1
#define CMUL1(dst, s0, s1, s2, s3, t0, t1, t2, t3, is, it)
Definition: on2avc.c:398
wtf_40
static void wtf_40(On2AVCContext *c, float *out, float *src, int size)
Definition: on2avc.c:523
AVChannelLayout
An AVChannelLayout holds information about the channel layout of audio data.
Definition: channel_layout.h:301
codec_internal.h
On2AVCContext::is_av500
int is_av500
Definition: on2avc.c:59
CMUL0
#define CMUL0(dst, id, s0, s1, s2, s3, t0, t1, t2, t3, is, it)
Definition: on2avc.c:392
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1023
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:63
AVFloatDSPContext
Definition: float_dsp.h:24
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:834
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:294
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
DECLARE_ALIGNED
#define DECLARE_ALIGNED(n, t, v)
Definition: mem.h:116
on2avc_read_channel_data
static int on2avc_read_channel_data(On2AVCContext *c, GetBitContext *gb, int ch)
Definition: on2avc.c:258
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
On2AVCContext::fft1024_fn
av_tx_fn fft1024_fn
Definition: on2avc.c:56
zero_head_and_tail
static void zero_head_and_tail(float *src, int len, int order0, int order1)
Definition: on2avc.c:320
t3
#define t3
Definition: regdef.h:31
On2AVCContext::band_start
const int * band_start
Definition: on2avc.c:65
AVFrame::extended_data
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:386
src2
const pixel * src2
Definition: h264pred_template.c:422
On2AVCContext::long_win
float long_win[ON2AVC_SUBFRAME_SIZE]
Definition: on2avc.c:89
On2AVCContext::window_type
int window_type
Definition: on2avc.c:62
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:55
On2AVCContext::mdct_small_fn
av_tx_fn mdct_small_fn
Definition: on2avc.c:55
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:211
WindowTypes
WindowTypes
Definition: on2avc.c:39
len
int len
Definition: vorbis_enc_data.h:426
ff_free_vlc
void ff_free_vlc(VLC *vlc)
Definition: vlc.c:375
WINDOW_TYPE_LONG_START
@ WINDOW_TYPE_LONG_START
Definition: on2avc.c:42
On2AVCContext::mdct_half_fn
av_tx_fn mdct_half_fn
Definition: on2avc.c:55
on2avc_read_ms_info
static void on2avc_read_ms_info(On2AVCContext *c, GetBitContext *gb)
Definition: on2avc.c:93
on2avc_free_vlcs
static av_cold void on2avc_free_vlcs(On2AVCContext *c)
Definition: on2avc.c:891
avcodec.h
on2avc_decode_band_scales
static int on2avc_decode_band_scales(On2AVCContext *c, GetBitContext *gb)
Definition: on2avc.c:144
On2AVCMode
Definition: on2avcdata.h:31
ret
ret
Definition: filter_design.txt:187
On2AVCContext::mdct_half
AVTXContext * mdct_half
Definition: on2avc.c:53
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:114
ff_on2avc_modes_40
const On2AVCMode ff_on2avc_modes_40[8]
Definition: on2avcdata.c:91
pos
unsigned int pos
Definition: spdifenc.c:412
On2AVCContext::is_long
int is_long
Definition: on2avc.c:71
On2AVCContext::bits_per_section
int bits_per_section
Definition: on2avc.c:64
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:398
on2avc_decode_subframe
static int on2avc_decode_subframe(On2AVCContext *c, const uint8_t *buf, int buf_size, AVFrame *dst, int offset)
Definition: on2avc.c:793
On2AVCContext::scale_tab
float scale_tab[128]
Definition: on2avc.c:82
channel_layout.h
t2
#define t2
Definition: regdef.h:30
VLC
Definition: vlc.h:31
On2AVCContext::scale_diff
VLC scale_diff
Definition: on2avc.c:79
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:632
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:53
temp
else temp
Definition: vf_mcdeint.c:248
WINDOW_TYPE_LONG_STOP
@ WINDOW_TYPE_LONG_STOP
Definition: on2avc.c:41
ff_on2avc_tabs_4_10_1
const double *const ff_on2avc_tabs_4_10_1[4]
Definition: on2avcdata.c:3092
ffmath.h
ff_on2avc_ctab_1
const float ff_on2avc_ctab_1[2048]
Definition: on2avcdata.c:4309
On2AVCContext::fft128
AVTXContext * fft128
Definition: on2avc.c:54
on2avcdata.h
AV_CODEC_FLAG_BITEXACT
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:288
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:368
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:423
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:425
AVPacket
This structure stores compressed data.
Definition: packet.h:351
WINDOW_TYPE_EXT5
@ WINDOW_TYPE_EXT5
Definition: on2avc.c:45
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:495
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:63
On2AVCContext::fft128_fn
av_tx_fn fft128_fn
Definition: on2avc.c:56
WINDOW_TYPE_8SHORT
@ WINDOW_TYPE_8SHORT
Definition: on2avc.c:43
On2AVCContext::band_type
uint8_t band_type[ON2AVC_MAX_BANDS]
Definition: on2avc.c:73
On2AVCContext::fft512
AVTXContext * fft512
Definition: on2avc.c:54
On2AVCContext::mdct_small
AVTXContext * mdct_small
Definition: on2avc.c:53
On2AVCContext::temp
float temp[ON2AVC_SUBFRAME_SIZE *2]
Definition: on2avc.c:87
channel
channel
Definition: ebur128.h:39
tx.h
On2AVCContext
Definition: on2avc.c:50