Directory: | ../../../ffmpeg/ |
---|---|
File: | src/libavcodec/dcadsp.c |
Date: | 2022-07-04 00:18:54 |
Exec | Total | Coverage | |
---|---|---|---|
Lines: | 171 | 231 | 74.0% |
Branches: | 68 | 94 | 72.3% |
Line | Branch | Exec | Source |
---|---|---|---|
1 | /* | ||
2 | * Copyright (C) 2016 foo86 | ||
3 | * | ||
4 | * This file is part of FFmpeg. | ||
5 | * | ||
6 | * FFmpeg is free software; you can redistribute it and/or | ||
7 | * modify it under the terms of the GNU Lesser General Public | ||
8 | * License as published by the Free Software Foundation; either | ||
9 | * version 2.1 of the License, or (at your option) any later version. | ||
10 | * | ||
11 | * FFmpeg is distributed in the hope that it will be useful, | ||
12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
14 | * Lesser General Public License for more details. | ||
15 | * | ||
16 | * You should have received a copy of the GNU Lesser General Public | ||
17 | * License along with FFmpeg; if not, write to the Free Software | ||
18 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | ||
19 | */ | ||
20 | |||
21 | #include "libavutil/mem_internal.h" | ||
22 | |||
23 | #include "dcadsp.h" | ||
24 | #include "dcamath.h" | ||
25 | |||
26 | 9736 | static void decode_hf_c(int32_t **dst, | |
27 | const int32_t *vq_index, | ||
28 | const int8_t hf_vq[1024][32], | ||
29 | int32_t scale_factors[32][2], | ||
30 | ptrdiff_t sb_start, ptrdiff_t sb_end, | ||
31 | ptrdiff_t ofs, ptrdiff_t len) | ||
32 | { | ||
33 | int i, j; | ||
34 | |||
35 |
2/2✓ Branch 0 taken 43304 times.
✓ Branch 1 taken 9736 times.
|
53040 | for (i = sb_start; i < sb_end; i++) { |
36 | 43304 | const int8_t *coeff = hf_vq[vq_index[i]]; | |
37 | 43304 | int32_t scale = scale_factors[i][0]; | |
38 |
2/2✓ Branch 0 taken 692864 times.
✓ Branch 1 taken 43304 times.
|
736168 | for (j = 0; j < len; j++) |
39 | 692864 | dst[i][j + ofs] = clip23(coeff[j] * scale + (1 << 3) >> 4); | |
40 | } | ||
41 | 9736 | } | |
42 | |||
43 | 91 | static void decode_joint_c(int32_t **dst, int32_t **src, | |
44 | const int32_t *scale_factors, | ||
45 | ptrdiff_t sb_start, ptrdiff_t sb_end, | ||
46 | ptrdiff_t ofs, ptrdiff_t len) | ||
47 | { | ||
48 | int i, j; | ||
49 | |||
50 |
2/2✓ Branch 0 taken 2541 times.
✓ Branch 1 taken 91 times.
|
2632 | for (i = sb_start; i < sb_end; i++) { |
51 | 2541 | int32_t scale = scale_factors[i]; | |
52 |
2/2✓ Branch 0 taken 40656 times.
✓ Branch 1 taken 2541 times.
|
43197 | for (j = 0; j < len; j++) |
53 | 40656 | dst[i][j + ofs] = clip23(mul17(src[i][j + ofs], scale)); | |
54 | } | ||
55 | 91 | } | |
56 | |||
57 | 603 | static void lfe_fir_float_c(float *pcm_samples, int32_t *lfe_samples, | |
58 | const float *filter_coeff, ptrdiff_t npcmblocks, | ||
59 | int dec_select) | ||
60 | { | ||
61 | // Select decimation factor | ||
62 | 603 | int factor = 64 << dec_select; | |
63 | 603 | int ncoeffs = 8 >> dec_select; | |
64 | 603 | int nlfesamples = npcmblocks >> (dec_select + 1); | |
65 | int i, j, k; | ||
66 | |||
67 |
2/2✓ Branch 0 taken 4824 times.
✓ Branch 1 taken 603 times.
|
5427 | for (i = 0; i < nlfesamples; i++) { |
68 | // One decimated sample generates 64 or 128 interpolated ones | ||
69 |
2/2✓ Branch 0 taken 154368 times.
✓ Branch 1 taken 4824 times.
|
159192 | for (j = 0; j < factor / 2; j++) { |
70 | 154368 | float a = 0; | |
71 | 154368 | float b = 0; | |
72 | |||
73 |
2/2✓ Branch 0 taken 1234944 times.
✓ Branch 1 taken 154368 times.
|
1389312 | for (k = 0; k < ncoeffs; k++) { |
74 | 1234944 | a += filter_coeff[ j * ncoeffs + k] * lfe_samples[-k]; | |
75 | 1234944 | b += filter_coeff[255 - j * ncoeffs - k] * lfe_samples[-k]; | |
76 | } | ||
77 | |||
78 | 154368 | pcm_samples[ j] = a; | |
79 | 154368 | pcm_samples[factor / 2 + j] = b; | |
80 | } | ||
81 | |||
82 | 4824 | lfe_samples++; | |
83 | 4824 | pcm_samples += factor; | |
84 | } | ||
85 | 603 | } | |
86 | |||
87 | 603 | static void lfe_fir0_float_c(float *pcm_samples, int32_t *lfe_samples, | |
88 | const float *filter_coeff, ptrdiff_t npcmblocks) | ||
89 | { | ||
90 | 603 | lfe_fir_float_c(pcm_samples, lfe_samples, filter_coeff, npcmblocks, 0); | |
91 | 603 | } | |
92 | |||
93 | ✗ | static void lfe_fir1_float_c(float *pcm_samples, int32_t *lfe_samples, | |
94 | const float *filter_coeff, ptrdiff_t npcmblocks) | ||
95 | { | ||
96 | ✗ | lfe_fir_float_c(pcm_samples, lfe_samples, filter_coeff, npcmblocks, 1); | |
97 | } | ||
98 | |||
99 | 35 | static void lfe_x96_float_c(float *dst, const float *src, | |
100 | float *hist, ptrdiff_t len) | ||
101 | { | ||
102 | 35 | float prev = *hist; | |
103 | int i; | ||
104 | |||
105 |
2/2✓ Branch 0 taken 17920 times.
✓ Branch 1 taken 35 times.
|
17955 | for (i = 0; i < len; i++) { |
106 | 17920 | float a = 0.25f * src[i] + 0.75f * prev; | |
107 | 17920 | float b = 0.75f * src[i] + 0.25f * prev; | |
108 | 17920 | prev = src[i]; | |
109 | 17920 | *dst++ = a; | |
110 | 17920 | *dst++ = b; | |
111 | } | ||
112 | |||
113 | 35 | *hist = prev; | |
114 | 35 | } | |
115 | |||
116 | 3135 | static void sub_qmf32_float_c(SynthFilterContext *synth, | |
117 | FFTContext *imdct, | ||
118 | float *pcm_samples, | ||
119 | int32_t **subband_samples_lo, | ||
120 | int32_t **subband_samples_hi, | ||
121 | float *hist1, int *offset, float *hist2, | ||
122 | const float *filter_coeff, ptrdiff_t npcmblocks, | ||
123 | float scale) | ||
124 | { | ||
125 | 3135 | LOCAL_ALIGNED_32(float, input, [32]); | |
126 | int i, j; | ||
127 | |||
128 |
2/2✓ Branch 0 taken 50160 times.
✓ Branch 1 taken 3135 times.
|
53295 | for (j = 0; j < npcmblocks; j++) { |
129 | // Load in one sample from each subband | ||
130 |
2/2✓ Branch 0 taken 1605120 times.
✓ Branch 1 taken 50160 times.
|
1655280 | for (i = 0; i < 32; i++) { |
131 |
2/2✓ Branch 0 taken 802560 times.
✓ Branch 1 taken 802560 times.
|
1605120 | if ((i - 1) & 2) |
132 | 802560 | input[i] = -subband_samples_lo[i][j]; | |
133 | else | ||
134 | 802560 | input[i] = subband_samples_lo[i][j]; | |
135 | } | ||
136 | |||
137 | // One subband sample generates 32 interpolated ones | ||
138 | 50160 | synth->synth_filter_float(imdct, hist1, offset, | |
139 | hist2, filter_coeff, | ||
140 | pcm_samples, input, scale); | ||
141 | 50160 | pcm_samples += 32; | |
142 | } | ||
143 | 3135 | } | |
144 | |||
145 | 196 | static void sub_qmf64_float_c(SynthFilterContext *synth, | |
146 | FFTContext *imdct, | ||
147 | float *pcm_samples, | ||
148 | int32_t **subband_samples_lo, | ||
149 | int32_t **subband_samples_hi, | ||
150 | float *hist1, int *offset, float *hist2, | ||
151 | const float *filter_coeff, ptrdiff_t npcmblocks, | ||
152 | float scale) | ||
153 | { | ||
154 | 196 | LOCAL_ALIGNED_32(float, input, [64]); | |
155 | int i, j; | ||
156 | |||
157 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 196 times.
|
196 | if (!subband_samples_hi) |
158 | ✗ | memset(&input[32], 0, sizeof(input[0]) * 32); | |
159 | |||
160 |
2/2✓ Branch 0 taken 3136 times.
✓ Branch 1 taken 196 times.
|
3332 | for (j = 0; j < npcmblocks; j++) { |
161 | // Load in one sample from each subband | ||
162 |
1/2✓ Branch 0 taken 3136 times.
✗ Branch 1 not taken.
|
3136 | if (subband_samples_hi) { |
163 | // Full 64 subbands, first 32 are residual coded | ||
164 |
2/2✓ Branch 0 taken 100352 times.
✓ Branch 1 taken 3136 times.
|
103488 | for (i = 0; i < 32; i++) { |
165 |
2/2✓ Branch 0 taken 50176 times.
✓ Branch 1 taken 50176 times.
|
100352 | if ((i - 1) & 2) |
166 | 50176 | input[i] = -subband_samples_lo[i][j] - subband_samples_hi[i][j]; | |
167 | else | ||
168 | 50176 | input[i] = subband_samples_lo[i][j] + subband_samples_hi[i][j]; | |
169 | } | ||
170 |
2/2✓ Branch 0 taken 100352 times.
✓ Branch 1 taken 3136 times.
|
103488 | for (i = 32; i < 64; i++) { |
171 |
2/2✓ Branch 0 taken 50176 times.
✓ Branch 1 taken 50176 times.
|
100352 | if ((i - 1) & 2) |
172 | 50176 | input[i] = -subband_samples_hi[i][j]; | |
173 | else | ||
174 | 50176 | input[i] = subband_samples_hi[i][j]; | |
175 | } | ||
176 | } else { | ||
177 | // Only first 32 subbands | ||
178 | ✗ | for (i = 0; i < 32; i++) { | |
179 | ✗ | if ((i - 1) & 2) | |
180 | ✗ | input[i] = -subband_samples_lo[i][j]; | |
181 | else | ||
182 | ✗ | input[i] = subband_samples_lo[i][j]; | |
183 | } | ||
184 | } | ||
185 | |||
186 | // One subband sample generates 64 interpolated ones | ||
187 | 3136 | synth->synth_filter_float_64(imdct, hist1, offset, | |
188 | hist2, filter_coeff, | ||
189 | pcm_samples, input, scale); | ||
190 | 3136 | pcm_samples += 64; | |
191 | } | ||
192 | 196 | } | |
193 | |||
194 | 1343 | static void lfe_fir_fixed_c(int32_t *pcm_samples, int32_t *lfe_samples, | |
195 | const int32_t *filter_coeff, ptrdiff_t npcmblocks) | ||
196 | { | ||
197 | // Select decimation factor | ||
198 | 1343 | int nlfesamples = npcmblocks >> 1; | |
199 | int i, j, k; | ||
200 | |||
201 |
2/2✓ Branch 0 taken 10744 times.
✓ Branch 1 taken 1343 times.
|
12087 | for (i = 0; i < nlfesamples; i++) { |
202 | // One decimated sample generates 64 interpolated ones | ||
203 |
2/2✓ Branch 0 taken 343808 times.
✓ Branch 1 taken 10744 times.
|
354552 | for (j = 0; j < 32; j++) { |
204 | 343808 | int64_t a = 0; | |
205 | 343808 | int64_t b = 0; | |
206 | |||
207 |
2/2✓ Branch 0 taken 2750464 times.
✓ Branch 1 taken 343808 times.
|
3094272 | for (k = 0; k < 8; k++) { |
208 | 2750464 | a += (int64_t)filter_coeff[ j * 8 + k] * lfe_samples[-k]; | |
209 | 2750464 | b += (int64_t)filter_coeff[255 - j * 8 - k] * lfe_samples[-k]; | |
210 | } | ||
211 | |||
212 | 343808 | pcm_samples[ j] = clip23(norm23(a)); | |
213 | 343808 | pcm_samples[32 + j] = clip23(norm23(b)); | |
214 | } | ||
215 | |||
216 | 10744 | lfe_samples++; | |
217 | 10744 | pcm_samples += 64; | |
218 | } | ||
219 | 1343 | } | |
220 | |||
221 | 84 | static void lfe_x96_fixed_c(int32_t *dst, const int32_t *src, | |
222 | int32_t *hist, ptrdiff_t len) | ||
223 | { | ||
224 | 84 | int32_t prev = *hist; | |
225 | int i; | ||
226 | |||
227 |
2/2✓ Branch 0 taken 43008 times.
✓ Branch 1 taken 84 times.
|
43092 | for (i = 0; i < len; i++) { |
228 | 43008 | int64_t a = INT64_C(2097471) * src[i] + INT64_C(6291137) * prev; | |
229 | 43008 | int64_t b = INT64_C(6291137) * src[i] + INT64_C(2097471) * prev; | |
230 | 43008 | prev = src[i]; | |
231 | 43008 | *dst++ = clip23(norm23(a)); | |
232 | 43008 | *dst++ = clip23(norm23(b)); | |
233 | } | ||
234 | |||
235 | 84 | *hist = prev; | |
236 | 84 | } | |
237 | |||
238 | 7336 | static void sub_qmf32_fixed_c(SynthFilterContext *synth, | |
239 | DCADCTContext *imdct, | ||
240 | int32_t *pcm_samples, | ||
241 | int32_t **subband_samples_lo, | ||
242 | int32_t **subband_samples_hi, | ||
243 | int32_t *hist1, int *offset, int32_t *hist2, | ||
244 | const int32_t *filter_coeff, ptrdiff_t npcmblocks) | ||
245 | { | ||
246 | 7336 | LOCAL_ALIGNED_32(int32_t, input, [32]); | |
247 | int i, j; | ||
248 | |||
249 |
2/2✓ Branch 0 taken 117376 times.
✓ Branch 1 taken 7336 times.
|
124712 | for (j = 0; j < npcmblocks; j++) { |
250 | // Load in one sample from each subband | ||
251 |
2/2✓ Branch 0 taken 3756032 times.
✓ Branch 1 taken 117376 times.
|
3873408 | for (i = 0; i < 32; i++) |
252 | 3756032 | input[i] = subband_samples_lo[i][j]; | |
253 | |||
254 | // One subband sample generates 32 interpolated ones | ||
255 | 117376 | synth->synth_filter_fixed(imdct, hist1, offset, | |
256 | hist2, filter_coeff, | ||
257 | pcm_samples, input); | ||
258 | 117376 | pcm_samples += 32; | |
259 | } | ||
260 | 7336 | } | |
261 | |||
262 | 420 | static void sub_qmf64_fixed_c(SynthFilterContext *synth, | |
263 | DCADCTContext *imdct, | ||
264 | int32_t *pcm_samples, | ||
265 | int32_t **subband_samples_lo, | ||
266 | int32_t **subband_samples_hi, | ||
267 | int32_t *hist1, int *offset, int32_t *hist2, | ||
268 | const int32_t *filter_coeff, ptrdiff_t npcmblocks) | ||
269 | { | ||
270 | 420 | LOCAL_ALIGNED_32(int32_t, input, [64]); | |
271 | int i, j; | ||
272 | |||
273 |
1/2✓ Branch 0 taken 420 times.
✗ Branch 1 not taken.
|
420 | if (!subband_samples_hi) |
274 | 420 | memset(&input[32], 0, sizeof(input[0]) * 32); | |
275 | |||
276 |
2/2✓ Branch 0 taken 6720 times.
✓ Branch 1 taken 420 times.
|
7140 | for (j = 0; j < npcmblocks; j++) { |
277 | // Load in one sample from each subband | ||
278 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6720 times.
|
6720 | if (subband_samples_hi) { |
279 | // Full 64 subbands, first 32 are residual coded | ||
280 | ✗ | for (i = 0; i < 32; i++) | |
281 | ✗ | input[i] = subband_samples_lo[i][j] + subband_samples_hi[i][j]; | |
282 | ✗ | for (i = 32; i < 64; i++) | |
283 | ✗ | input[i] = subband_samples_hi[i][j]; | |
284 | } else { | ||
285 | // Only first 32 subbands | ||
286 |
2/2✓ Branch 0 taken 215040 times.
✓ Branch 1 taken 6720 times.
|
221760 | for (i = 0; i < 32; i++) |
287 | 215040 | input[i] = subband_samples_lo[i][j]; | |
288 | } | ||
289 | |||
290 | // One subband sample generates 64 interpolated ones | ||
291 | 6720 | synth->synth_filter_fixed_64(imdct, hist1, offset, | |
292 | hist2, filter_coeff, | ||
293 | pcm_samples, input); | ||
294 | 6720 | pcm_samples += 64; | |
295 | } | ||
296 | 420 | } | |
297 | |||
298 | 1803 | static void decor_c(int32_t *dst, const int32_t *src, int coeff, ptrdiff_t len) | |
299 | { | ||
300 | int i; | ||
301 | |||
302 |
2/2✓ Branch 0 taken 1024000 times.
✓ Branch 1 taken 1803 times.
|
1025803 | for (i = 0; i < len; i++) |
303 | 1024000 | dst[i] += (SUINT)((int)(src[i] * (SUINT)coeff + (1 << 2)) >> 3); | |
304 | 1803 | } | |
305 | |||
306 | ✗ | static void dmix_sub_xch_c(int32_t *dst1, int32_t *dst2, | |
307 | const int32_t *src, ptrdiff_t len) | ||
308 | { | ||
309 | int i; | ||
310 | |||
311 | ✗ | for (i = 0; i < len; i++) { | |
312 | ✗ | int32_t cs = mul23(src[i], 5931520 /* M_SQRT1_2 * (1 << 23) */); | |
313 | ✗ | dst1[i] -= cs; | |
314 | ✗ | dst2[i] -= cs; | |
315 | } | ||
316 | } | ||
317 | |||
318 | 120 | static void dmix_sub_c(int32_t *dst, const int32_t *src, int coeff, ptrdiff_t len) | |
319 | { | ||
320 | int i; | ||
321 | |||
322 |
2/2✓ Branch 0 taken 76960 times.
✓ Branch 1 taken 120 times.
|
77080 | for (i = 0; i < len; i++) |
323 | 76960 | dst[i] -= (unsigned)mul15(src[i], coeff); | |
324 | 120 | } | |
325 | |||
326 | 14 | static void dmix_add_c(int32_t *dst, const int32_t *src, int coeff, ptrdiff_t len) | |
327 | { | ||
328 | int i; | ||
329 | |||
330 |
2/2✓ Branch 0 taken 7168 times.
✓ Branch 1 taken 14 times.
|
7182 | for (i = 0; i < len; i++) |
331 | 7168 | dst[i] += (unsigned)mul15(src[i], coeff); | |
332 | 14 | } | |
333 | |||
334 | 204 | static void dmix_scale_c(int32_t *dst, int scale, ptrdiff_t len) | |
335 | { | ||
336 | int i; | ||
337 | |||
338 |
2/2✓ Branch 0 taken 140368 times.
✓ Branch 1 taken 204 times.
|
140572 | for (i = 0; i < len; i++) |
339 | 140368 | dst[i] = mul15(dst[i], scale); | |
340 | 204 | } | |
341 | |||
342 | ✗ | static void dmix_scale_inv_c(int32_t *dst, int scale_inv, ptrdiff_t len) | |
343 | { | ||
344 | int i; | ||
345 | |||
346 | ✗ | for (i = 0; i < len; i++) | |
347 | ✗ | dst[i] = mul16(dst[i], scale_inv); | |
348 | } | ||
349 | |||
350 | 896 | static void filter0(SUINT32 *dst, const int32_t *src, int32_t coeff, ptrdiff_t len) | |
351 | { | ||
352 | int i; | ||
353 | |||
354 |
2/2✓ Branch 0 taken 917504 times.
✓ Branch 1 taken 896 times.
|
918400 | for (i = 0; i < len; i++) |
355 | 917504 | dst[i] -= mul22(src[i], coeff); | |
356 | 896 | } | |
357 | |||
358 | 5376 | static void filter1(SUINT32 *dst, const int32_t *src, int32_t coeff, ptrdiff_t len) | |
359 | { | ||
360 | int i; | ||
361 | |||
362 |
2/2✓ Branch 0 taken 5505024 times.
✓ Branch 1 taken 5376 times.
|
5510400 | for (i = 0; i < len; i++) |
363 | 5505024 | dst[i] -= mul23(src[i], coeff); | |
364 | 5376 | } | |
365 | |||
366 | 224 | static void assemble_freq_bands_c(int32_t *dst, int32_t *src0, int32_t *src1, | |
367 | const int32_t *coeff, ptrdiff_t len) | ||
368 | { | ||
369 | int i; | ||
370 | |||
371 | 224 | filter0(src0, src1, coeff[0], len); | |
372 | 224 | filter0(src1, src0, coeff[1], len); | |
373 | 224 | filter0(src0, src1, coeff[2], len); | |
374 | 224 | filter0(src1, src0, coeff[3], len); | |
375 | |||
376 |
2/2✓ Branch 0 taken 1792 times.
✓ Branch 1 taken 224 times.
|
2016 | for (i = 0; i < 8; i++, src0--) { |
377 | 1792 | filter1(src0, src1, coeff[i + 4], len); | |
378 | 1792 | filter1(src1, src0, coeff[i + 12], len); | |
379 | 1792 | filter1(src0, src1, coeff[i + 4], len); | |
380 | } | ||
381 | |||
382 |
2/2✓ Branch 0 taken 229376 times.
✓ Branch 1 taken 224 times.
|
229600 | for (i = 0; i < len; i++) { |
383 | 229376 | *dst++ = *src1++; | |
384 | 229376 | *dst++ = *++src0; | |
385 | } | ||
386 | 224 | } | |
387 | |||
388 | ✗ | static void lbr_bank_c(float output[32][4], float **input, | |
389 | const float *coeff, ptrdiff_t ofs, ptrdiff_t len) | ||
390 | { | ||
391 | ✗ | float SW0 = coeff[0]; | |
392 | ✗ | float SW1 = coeff[1]; | |
393 | ✗ | float SW2 = coeff[2]; | |
394 | ✗ | float SW3 = coeff[3]; | |
395 | |||
396 | ✗ | float C1 = coeff[4]; | |
397 | ✗ | float C2 = coeff[5]; | |
398 | ✗ | float C3 = coeff[6]; | |
399 | ✗ | float C4 = coeff[7]; | |
400 | |||
401 | ✗ | float AL1 = coeff[8]; | |
402 | ✗ | float AL2 = coeff[9]; | |
403 | |||
404 | int i; | ||
405 | |||
406 | // Short window and 8 point forward MDCT | ||
407 | ✗ | for (i = 0; i < len; i++) { | |
408 | ✗ | float *src = input[i] + ofs; | |
409 | |||
410 | ✗ | float a = src[-4] * SW0 - src[-1] * SW3; | |
411 | ✗ | float b = src[-3] * SW1 - src[-2] * SW2; | |
412 | ✗ | float c = src[ 2] * SW1 + src[ 1] * SW2; | |
413 | ✗ | float d = src[ 3] * SW0 + src[ 0] * SW3; | |
414 | |||
415 | ✗ | output[i][0] = C1 * b - C2 * c + C4 * a - C3 * d; | |
416 | ✗ | output[i][1] = C1 * d - C2 * a - C4 * b - C3 * c; | |
417 | ✗ | output[i][2] = C3 * b + C2 * d - C4 * c + C1 * a; | |
418 | ✗ | output[i][3] = C3 * a - C2 * b + C4 * d - C1 * c; | |
419 | } | ||
420 | |||
421 | // Aliasing cancellation for high frequencies | ||
422 | ✗ | for (i = 12; i < len - 1; i++) { | |
423 | ✗ | float a = output[i ][3] * AL1; | |
424 | ✗ | float b = output[i+1][0] * AL1; | |
425 | ✗ | output[i ][3] += b - a; | |
426 | ✗ | output[i+1][0] -= b + a; | |
427 | ✗ | a = output[i ][2] * AL2; | |
428 | ✗ | b = output[i+1][1] * AL2; | |
429 | ✗ | output[i ][2] += b - a; | |
430 | ✗ | output[i+1][1] -= b + a; | |
431 | } | ||
432 | } | ||
433 | |||
434 | ✗ | static void lfe_iir_c(float *output, const float *input, | |
435 | const float iir[5][4], float hist[5][2], | ||
436 | ptrdiff_t factor) | ||
437 | { | ||
438 | float res, tmp; | ||
439 | int i, j, k; | ||
440 | |||
441 | ✗ | for (i = 0; i < 64; i++) { | |
442 | ✗ | res = *input++; | |
443 | |||
444 | ✗ | for (j = 0; j < factor; j++) { | |
445 | ✗ | for (k = 0; k < 5; k++) { | |
446 | ✗ | tmp = hist[k][0] * iir[k][0] + hist[k][1] * iir[k][1] + res; | |
447 | ✗ | res = hist[k][0] * iir[k][2] + hist[k][1] * iir[k][3] + tmp; | |
448 | |||
449 | ✗ | hist[k][0] = hist[k][1]; | |
450 | ✗ | hist[k][1] = tmp; | |
451 | } | ||
452 | |||
453 | ✗ | *output++ = res; | |
454 | ✗ | res = 0; | |
455 | } | ||
456 | } | ||
457 | } | ||
458 | |||
459 | 92 | av_cold void ff_dcadsp_init(DCADSPContext *s) | |
460 | { | ||
461 | 92 | s->decode_hf = decode_hf_c; | |
462 | 92 | s->decode_joint = decode_joint_c; | |
463 | |||
464 | 92 | s->lfe_fir_float[0] = lfe_fir0_float_c; | |
465 | 92 | s->lfe_fir_float[1] = lfe_fir1_float_c; | |
466 | 92 | s->lfe_x96_float = lfe_x96_float_c; | |
467 | 92 | s->sub_qmf_float[0] = sub_qmf32_float_c; | |
468 | 92 | s->sub_qmf_float[1] = sub_qmf64_float_c; | |
469 | |||
470 | 92 | s->lfe_fir_fixed = lfe_fir_fixed_c; | |
471 | 92 | s->lfe_x96_fixed = lfe_x96_fixed_c; | |
472 | 92 | s->sub_qmf_fixed[0] = sub_qmf32_fixed_c; | |
473 | 92 | s->sub_qmf_fixed[1] = sub_qmf64_fixed_c; | |
474 | |||
475 | 92 | s->decor = decor_c; | |
476 | |||
477 | 92 | s->dmix_sub_xch = dmix_sub_xch_c; | |
478 | 92 | s->dmix_sub = dmix_sub_c; | |
479 | 92 | s->dmix_add = dmix_add_c; | |
480 | 92 | s->dmix_scale = dmix_scale_c; | |
481 | 92 | s->dmix_scale_inv = dmix_scale_inv_c; | |
482 | |||
483 | 92 | s->assemble_freq_bands = assemble_freq_bands_c; | |
484 | |||
485 | 92 | s->lbr_bank = lbr_bank_c; | |
486 | 92 | s->lfe_iir = lfe_iir_c; | |
487 | |||
488 | #if ARCH_X86 | ||
489 | 92 | ff_dcadsp_init_x86(s); | |
490 | #endif | ||
491 | 92 | } | |
492 |