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