Commit | Line | Data |
---|---|---|
2ba45a60 DM |
1 | /* |
2 | * G.729, G729 Annex D postfilter | |
3 | * Copyright (c) 2008 Vladimir Voroshilov | |
4 | * | |
5 | * This file is part of FFmpeg. | |
6 | * | |
7 | * FFmpeg is free software; you can redistribute it and/or | |
8 | * modify it under the terms of the GNU Lesser General Public | |
9 | * License as published by the Free Software Foundation; either | |
10 | * version 2.1 of the License, or (at your option) any later version. | |
11 | * | |
12 | * FFmpeg is distributed in the hope that it will be useful, | |
13 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
15 | * Lesser General Public License for more details. | |
16 | * | |
17 | * You should have received a copy of the GNU Lesser General Public | |
18 | * License along with FFmpeg; if not, write to the Free Software | |
19 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | |
20 | */ | |
21 | #include <inttypes.h> | |
22 | #include <limits.h> | |
23 | ||
24 | #include "avcodec.h" | |
25 | #include "g729.h" | |
26 | #include "acelp_pitch_delay.h" | |
27 | #include "g729postfilter.h" | |
28 | #include "celp_math.h" | |
29 | #include "acelp_filters.h" | |
30 | #include "acelp_vectors.h" | |
31 | #include "celp_filters.h" | |
32 | ||
33 | #define FRAC_BITS 15 | |
34 | #include "mathops.h" | |
35 | ||
36 | /** | |
37 | * short interpolation filter (of length 33, according to spec) | |
38 | * for computing signal with non-integer delay | |
39 | */ | |
40 | static const int16_t ff_g729_interp_filt_short[(ANALYZED_FRAC_DELAYS+1)*SHORT_INT_FILT_LEN] = { | |
41 | 0, 31650, 28469, 23705, 18050, 12266, 7041, 2873, | |
42 | 0, -1597, -2147, -1992, -1492, -933, -484, -188, | |
43 | }; | |
44 | ||
45 | /** | |
46 | * long interpolation filter (of length 129, according to spec) | |
47 | * for computing signal with non-integer delay | |
48 | */ | |
49 | static const int16_t ff_g729_interp_filt_long[(ANALYZED_FRAC_DELAYS+1)*LONG_INT_FILT_LEN] = { | |
50 | 0, 31915, 29436, 25569, 20676, 15206, 9639, 4439, | |
51 | 0, -3390, -5579, -6549, -6414, -5392, -3773, -1874, | |
52 | 0, 1595, 2727, 3303, 3319, 2850, 2030, 1023, | |
53 | 0, -887, -1527, -1860, -1876, -1614, -1150, -579, | |
54 | 0, 501, 859, 1041, 1044, 892, 631, 315, | |
55 | 0, -266, -453, -543, -538, -455, -317, -156, | |
56 | 0, 130, 218, 258, 253, 212, 147, 72, | |
57 | 0, -59, -101, -122, -123, -106, -77, -40, | |
58 | }; | |
59 | ||
60 | /** | |
61 | * formant_pp_factor_num_pow[i] = FORMANT_PP_FACTOR_NUM^(i+1) | |
62 | */ | |
63 | static const int16_t formant_pp_factor_num_pow[10]= { | |
64 | /* (0.15) */ | |
65 | 18022, 9912, 5451, 2998, 1649, 907, 499, 274, 151, 83 | |
66 | }; | |
67 | ||
68 | /** | |
69 | * formant_pp_factor_den_pow[i] = FORMANT_PP_FACTOR_DEN^(i+1) | |
70 | */ | |
71 | static const int16_t formant_pp_factor_den_pow[10] = { | |
72 | /* (0.15) */ | |
73 | 22938, 16057, 11240, 7868, 5508, 3856, 2699, 1889, 1322, 925 | |
74 | }; | |
75 | ||
76 | /** | |
77 | * \brief Residual signal calculation (4.2.1 if G.729) | |
78 | * \param out [out] output data filtered through A(z/FORMANT_PP_FACTOR_NUM) | |
79 | * \param filter_coeffs (3.12) A(z/FORMANT_PP_FACTOR_NUM) filter coefficients | |
80 | * \param in input speech data to process | |
81 | * \param subframe_size size of one subframe | |
82 | * | |
83 | * \note in buffer must contain 10 items of previous speech data before top of the buffer | |
84 | * \remark It is safe to pass the same buffer for input and output. | |
85 | */ | |
86 | static void residual_filter(int16_t* out, const int16_t* filter_coeffs, const int16_t* in, | |
87 | int subframe_size) | |
88 | { | |
89 | int i, n; | |
90 | ||
91 | for (n = subframe_size - 1; n >= 0; n--) { | |
92 | int sum = 0x800; | |
93 | for (i = 0; i < 10; i++) | |
94 | sum += filter_coeffs[i] * in[n - i - 1]; | |
95 | ||
96 | out[n] = in[n] + (sum >> 12); | |
97 | } | |
98 | } | |
99 | ||
100 | /** | |
101 | * \brief long-term postfilter (4.2.1) | |
102 | * \param dsp initialized DSP context | |
103 | * \param pitch_delay_int integer part of the pitch delay in the first subframe | |
104 | * \param residual filtering input data | |
105 | * \param residual_filt [out] speech signal with applied A(z/FORMANT_PP_FACTOR_NUM) filter | |
106 | * \param subframe_size size of subframe | |
107 | * | |
108 | * \return 0 if long-term prediction gain is less than 3dB, 1 - otherwise | |
109 | */ | |
110 | static int16_t long_term_filter(AudioDSPContext *adsp, int pitch_delay_int, | |
111 | const int16_t* residual, int16_t *residual_filt, | |
112 | int subframe_size) | |
113 | { | |
114 | int i, k, tmp, tmp2; | |
115 | int sum; | |
116 | int L_temp0; | |
117 | int L_temp1; | |
118 | int64_t L64_temp0; | |
119 | int64_t L64_temp1; | |
120 | int16_t shift; | |
121 | int corr_int_num, corr_int_den; | |
122 | ||
123 | int ener; | |
124 | int16_t sh_ener; | |
125 | ||
126 | int16_t gain_num,gain_den; //selected signal's gain numerator and denominator | |
127 | int16_t sh_gain_num, sh_gain_den; | |
128 | int gain_num_square; | |
129 | ||
130 | int16_t gain_long_num,gain_long_den; //filtered through long interpolation filter signal's gain numerator and denominator | |
131 | int16_t sh_gain_long_num, sh_gain_long_den; | |
132 | ||
133 | int16_t best_delay_int, best_delay_frac; | |
134 | ||
135 | int16_t delayed_signal_offset; | |
136 | int lt_filt_factor_a, lt_filt_factor_b; | |
137 | ||
138 | int16_t * selected_signal; | |
139 | const int16_t * selected_signal_const; //Necessary to avoid compiler warning | |
140 | ||
141 | int16_t sig_scaled[SUBFRAME_SIZE + RES_PREV_DATA_SIZE]; | |
142 | int16_t delayed_signal[ANALYZED_FRAC_DELAYS][SUBFRAME_SIZE+1]; | |
143 | int corr_den[ANALYZED_FRAC_DELAYS][2]; | |
144 | ||
145 | tmp = 0; | |
146 | for(i=0; i<subframe_size + RES_PREV_DATA_SIZE; i++) | |
147 | tmp |= FFABS(residual[i]); | |
148 | ||
149 | if(!tmp) | |
150 | shift = 3; | |
151 | else | |
152 | shift = av_log2(tmp) - 11; | |
153 | ||
154 | if (shift > 0) | |
155 | for (i = 0; i < subframe_size + RES_PREV_DATA_SIZE; i++) | |
156 | sig_scaled[i] = residual[i] >> shift; | |
157 | else | |
158 | for (i = 0; i < subframe_size + RES_PREV_DATA_SIZE; i++) | |
159 | sig_scaled[i] = residual[i] << -shift; | |
160 | ||
161 | /* Start of best delay searching code */ | |
162 | gain_num = 0; | |
163 | ||
164 | ener = adsp->scalarproduct_int16(sig_scaled + RES_PREV_DATA_SIZE, | |
165 | sig_scaled + RES_PREV_DATA_SIZE, | |
166 | subframe_size); | |
167 | if (ener) { | |
168 | sh_ener = FFMAX(av_log2(ener) - 14, 0); | |
169 | ener >>= sh_ener; | |
170 | /* Search for best pitch delay. | |
171 | ||
172 | sum{ r(n) * r(k,n) ] }^2 | |
173 | R'(k)^2 := ------------------------- | |
174 | sum{ r(k,n) * r(k,n) } | |
175 | ||
176 | ||
177 | R(T) := sum{ r(n) * r(n-T) ] } | |
178 | ||
179 | ||
180 | where | |
181 | r(n-T) is integer delayed signal with delay T | |
182 | r(k,n) is non-integer delayed signal with integer delay best_delay | |
183 | and fractional delay k */ | |
184 | ||
185 | /* Find integer delay best_delay which maximizes correlation R(T). | |
186 | ||
187 | This is also equals to numerator of R'(0), | |
188 | since the fine search (second step) is done with 1/8 | |
189 | precision around best_delay. */ | |
190 | corr_int_num = 0; | |
191 | best_delay_int = pitch_delay_int - 1; | |
192 | for (i = pitch_delay_int - 1; i <= pitch_delay_int + 1; i++) { | |
193 | sum = adsp->scalarproduct_int16(sig_scaled + RES_PREV_DATA_SIZE, | |
194 | sig_scaled + RES_PREV_DATA_SIZE - i, | |
195 | subframe_size); | |
196 | if (sum > corr_int_num) { | |
197 | corr_int_num = sum; | |
198 | best_delay_int = i; | |
199 | } | |
200 | } | |
201 | if (corr_int_num) { | |
202 | /* Compute denominator of pseudo-normalized correlation R'(0). */ | |
203 | corr_int_den = adsp->scalarproduct_int16(sig_scaled - best_delay_int + RES_PREV_DATA_SIZE, | |
204 | sig_scaled - best_delay_int + RES_PREV_DATA_SIZE, | |
205 | subframe_size); | |
206 | ||
207 | /* Compute signals with non-integer delay k (with 1/8 precision), | |
208 | where k is in [0;6] range. | |
209 | Entire delay is qual to best_delay+(k+1)/8 | |
210 | This is archieved by applying an interpolation filter of | |
211 | legth 33 to source signal. */ | |
212 | for (k = 0; k < ANALYZED_FRAC_DELAYS; k++) { | |
213 | ff_acelp_interpolate(&delayed_signal[k][0], | |
214 | &sig_scaled[RES_PREV_DATA_SIZE - best_delay_int], | |
215 | ff_g729_interp_filt_short, | |
216 | ANALYZED_FRAC_DELAYS+1, | |
217 | 8 - k - 1, | |
218 | SHORT_INT_FILT_LEN, | |
219 | subframe_size + 1); | |
220 | } | |
221 | ||
222 | /* Compute denominator of pseudo-normalized correlation R'(k). | |
223 | ||
224 | corr_den[k][0] is square root of R'(k) denominator, for int(T) == int(T0) | |
225 | corr_den[k][1] is square root of R'(k) denominator, for int(T) == int(T0)+1 | |
226 | ||
227 | Also compute maximum value of above denominators over all k. */ | |
228 | tmp = corr_int_den; | |
229 | for (k = 0; k < ANALYZED_FRAC_DELAYS; k++) { | |
230 | sum = adsp->scalarproduct_int16(&delayed_signal[k][1], | |
231 | &delayed_signal[k][1], | |
232 | subframe_size - 1); | |
233 | corr_den[k][0] = sum + delayed_signal[k][0 ] * delayed_signal[k][0 ]; | |
234 | corr_den[k][1] = sum + delayed_signal[k][subframe_size] * delayed_signal[k][subframe_size]; | |
235 | ||
236 | tmp = FFMAX3(tmp, corr_den[k][0], corr_den[k][1]); | |
237 | } | |
238 | ||
239 | sh_gain_den = av_log2(tmp) - 14; | |
240 | if (sh_gain_den >= 0) { | |
241 | ||
242 | sh_gain_num = FFMAX(sh_gain_den, sh_ener); | |
243 | /* Loop through all k and find delay that maximizes | |
244 | R'(k) correlation. | |
245 | Search is done in [int(T0)-1; intT(0)+1] range | |
246 | with 1/8 precision. */ | |
247 | delayed_signal_offset = 1; | |
248 | best_delay_frac = 0; | |
249 | gain_den = corr_int_den >> sh_gain_den; | |
250 | gain_num = corr_int_num >> sh_gain_num; | |
251 | gain_num_square = gain_num * gain_num; | |
252 | for (k = 0; k < ANALYZED_FRAC_DELAYS; k++) { | |
253 | for (i = 0; i < 2; i++) { | |
254 | int16_t gain_num_short, gain_den_short; | |
255 | int gain_num_short_square; | |
256 | /* Compute numerator of pseudo-normalized | |
257 | correlation R'(k). */ | |
258 | sum = adsp->scalarproduct_int16(&delayed_signal[k][i], | |
259 | sig_scaled + RES_PREV_DATA_SIZE, | |
260 | subframe_size); | |
261 | gain_num_short = FFMAX(sum >> sh_gain_num, 0); | |
262 | ||
263 | /* | |
264 | gain_num_short_square gain_num_square | |
265 | R'(T)^2 = -----------------------, max R'(T)^2= -------------- | |
266 | den gain_den | |
267 | */ | |
268 | gain_num_short_square = gain_num_short * gain_num_short; | |
269 | gain_den_short = corr_den[k][i] >> sh_gain_den; | |
270 | ||
271 | tmp = MULL(gain_num_short_square, gain_den, FRAC_BITS); | |
272 | tmp2 = MULL(gain_num_square, gain_den_short, FRAC_BITS); | |
273 | ||
274 | // R'(T)^2 > max R'(T)^2 | |
275 | if (tmp > tmp2) { | |
276 | gain_num = gain_num_short; | |
277 | gain_den = gain_den_short; | |
278 | gain_num_square = gain_num_short_square; | |
279 | delayed_signal_offset = i; | |
280 | best_delay_frac = k + 1; | |
281 | } | |
282 | } | |
283 | } | |
284 | ||
285 | /* | |
286 | R'(T)^2 | |
287 | 2 * --------- < 1 | |
288 | R(0) | |
289 | */ | |
290 | L64_temp0 = (int64_t)gain_num_square << ((sh_gain_num << 1) + 1); | |
291 | L64_temp1 = ((int64_t)gain_den * ener) << (sh_gain_den + sh_ener); | |
292 | if (L64_temp0 < L64_temp1) | |
293 | gain_num = 0; | |
294 | } // if(sh_gain_den >= 0) | |
295 | } // if(corr_int_num) | |
296 | } // if(ener) | |
297 | /* End of best delay searching code */ | |
298 | ||
299 | if (!gain_num) { | |
300 | memcpy(residual_filt, residual + RES_PREV_DATA_SIZE, subframe_size * sizeof(int16_t)); | |
301 | ||
302 | /* Long-term prediction gain is less than 3dB. Long-term postfilter is disabled. */ | |
303 | return 0; | |
304 | } | |
305 | if (best_delay_frac) { | |
306 | /* Recompute delayed signal with an interpolation filter of length 129. */ | |
307 | ff_acelp_interpolate(residual_filt, | |
308 | &sig_scaled[RES_PREV_DATA_SIZE - best_delay_int + delayed_signal_offset], | |
309 | ff_g729_interp_filt_long, | |
310 | ANALYZED_FRAC_DELAYS + 1, | |
311 | 8 - best_delay_frac, | |
312 | LONG_INT_FILT_LEN, | |
313 | subframe_size + 1); | |
314 | /* Compute R'(k) correlation's numerator. */ | |
315 | sum = adsp->scalarproduct_int16(residual_filt, | |
316 | sig_scaled + RES_PREV_DATA_SIZE, | |
317 | subframe_size); | |
318 | ||
319 | if (sum < 0) { | |
320 | gain_long_num = 0; | |
321 | sh_gain_long_num = 0; | |
322 | } else { | |
323 | tmp = FFMAX(av_log2(sum) - 14, 0); | |
324 | sum >>= tmp; | |
325 | gain_long_num = sum; | |
326 | sh_gain_long_num = tmp; | |
327 | } | |
328 | ||
329 | /* Compute R'(k) correlation's denominator. */ | |
330 | sum = adsp->scalarproduct_int16(residual_filt, residual_filt, subframe_size); | |
331 | ||
332 | tmp = FFMAX(av_log2(sum) - 14, 0); | |
333 | sum >>= tmp; | |
334 | gain_long_den = sum; | |
335 | sh_gain_long_den = tmp; | |
336 | ||
337 | /* Select between original and delayed signal. | |
338 | Delayed signal will be selected if it increases R'(k) | |
339 | correlation. */ | |
340 | L_temp0 = gain_num * gain_num; | |
341 | L_temp0 = MULL(L_temp0, gain_long_den, FRAC_BITS); | |
342 | ||
343 | L_temp1 = gain_long_num * gain_long_num; | |
344 | L_temp1 = MULL(L_temp1, gain_den, FRAC_BITS); | |
345 | ||
346 | tmp = ((sh_gain_long_num - sh_gain_num) << 1) - (sh_gain_long_den - sh_gain_den); | |
347 | if (tmp > 0) | |
348 | L_temp0 >>= tmp; | |
349 | else | |
350 | L_temp1 >>= -tmp; | |
351 | ||
352 | /* Check if longer filter increases the values of R'(k). */ | |
353 | if (L_temp1 > L_temp0) { | |
354 | /* Select long filter. */ | |
355 | selected_signal = residual_filt; | |
356 | gain_num = gain_long_num; | |
357 | gain_den = gain_long_den; | |
358 | sh_gain_num = sh_gain_long_num; | |
359 | sh_gain_den = sh_gain_long_den; | |
360 | } else | |
361 | /* Select short filter. */ | |
362 | selected_signal = &delayed_signal[best_delay_frac-1][delayed_signal_offset]; | |
363 | ||
364 | /* Rescale selected signal to original value. */ | |
365 | if (shift > 0) | |
366 | for (i = 0; i < subframe_size; i++) | |
367 | selected_signal[i] <<= shift; | |
368 | else | |
369 | for (i = 0; i < subframe_size; i++) | |
370 | selected_signal[i] >>= -shift; | |
371 | ||
372 | /* necessary to avoid compiler warning */ | |
373 | selected_signal_const = selected_signal; | |
374 | } // if(best_delay_frac) | |
375 | else | |
376 | selected_signal_const = residual + RES_PREV_DATA_SIZE - (best_delay_int + 1 - delayed_signal_offset); | |
377 | #ifdef G729_BITEXACT | |
378 | tmp = sh_gain_num - sh_gain_den; | |
379 | if (tmp > 0) | |
380 | gain_den >>= tmp; | |
381 | else | |
382 | gain_num >>= -tmp; | |
383 | ||
384 | if (gain_num > gain_den) | |
385 | lt_filt_factor_a = MIN_LT_FILT_FACTOR_A; | |
386 | else { | |
387 | gain_num >>= 2; | |
388 | gain_den >>= 1; | |
389 | lt_filt_factor_a = (gain_den << 15) / (gain_den + gain_num); | |
390 | } | |
391 | #else | |
392 | L64_temp0 = (((int64_t)gain_num) << sh_gain_num) >> 1; | |
393 | L64_temp1 = ((int64_t)gain_den) << sh_gain_den; | |
394 | lt_filt_factor_a = FFMAX((L64_temp1 << 15) / (L64_temp1 + L64_temp0), MIN_LT_FILT_FACTOR_A); | |
395 | #endif | |
396 | ||
397 | /* Filter through selected filter. */ | |
398 | lt_filt_factor_b = 32767 - lt_filt_factor_a + 1; | |
399 | ||
400 | ff_acelp_weighted_vector_sum(residual_filt, residual + RES_PREV_DATA_SIZE, | |
401 | selected_signal_const, | |
402 | lt_filt_factor_a, lt_filt_factor_b, | |
403 | 1<<14, 15, subframe_size); | |
404 | ||
405 | // Long-term prediction gain is larger than 3dB. | |
406 | return 1; | |
407 | } | |
408 | ||
409 | /** | |
410 | * \brief Calculate reflection coefficient for tilt compensation filter (4.2.3). | |
411 | * \param dsp initialized DSP context | |
412 | * \param lp_gn (3.12) coefficients of A(z/FORMANT_PP_FACTOR_NUM) filter | |
413 | * \param lp_gd (3.12) coefficients of A(z/FORMANT_PP_FACTOR_DEN) filter | |
414 | * \param speech speech to update | |
415 | * \param subframe_size size of subframe | |
416 | * | |
417 | * \return (3.12) reflection coefficient | |
418 | * | |
419 | * \remark The routine also calculates the gain term for the short-term | |
420 | * filter (gf) and multiplies the speech data by 1/gf. | |
421 | * | |
422 | * \note All members of lp_gn, except 10-19 must be equal to zero. | |
423 | */ | |
424 | static int16_t get_tilt_comp(AudioDSPContext *adsp, int16_t *lp_gn, | |
425 | const int16_t *lp_gd, int16_t* speech, | |
426 | int subframe_size) | |
427 | { | |
428 | int rh1,rh0; // (3.12) | |
429 | int temp; | |
430 | int i; | |
431 | int gain_term; | |
432 | ||
433 | lp_gn[10] = 4096; //1.0 in (3.12) | |
434 | ||
435 | /* Apply 1/A(z/FORMANT_PP_FACTOR_DEN) filter to hf. */ | |
436 | ff_celp_lp_synthesis_filter(lp_gn + 11, lp_gd + 1, lp_gn + 11, 22, 10, 0, 0, 0x800); | |
437 | /* Now lp_gn (starting with 10) contains impulse response | |
438 | of A(z/FORMANT_PP_FACTOR_NUM)/A(z/FORMANT_PP_FACTOR_DEN) filter. */ | |
439 | ||
440 | rh0 = adsp->scalarproduct_int16(lp_gn + 10, lp_gn + 10, 20); | |
441 | rh1 = adsp->scalarproduct_int16(lp_gn + 10, lp_gn + 11, 20); | |
442 | ||
443 | /* downscale to avoid overflow */ | |
444 | temp = av_log2(rh0) - 14; | |
445 | if (temp > 0) { | |
446 | rh0 >>= temp; | |
447 | rh1 >>= temp; | |
448 | } | |
449 | ||
450 | if (FFABS(rh1) > rh0 || !rh0) | |
451 | return 0; | |
452 | ||
453 | gain_term = 0; | |
454 | for (i = 0; i < 20; i++) | |
455 | gain_term += FFABS(lp_gn[i + 10]); | |
456 | gain_term >>= 2; // (3.12) -> (5.10) | |
457 | ||
458 | if (gain_term > 0x400) { // 1.0 in (5.10) | |
459 | temp = 0x2000000 / gain_term; // 1.0/gain_term in (0.15) | |
460 | for (i = 0; i < subframe_size; i++) | |
461 | speech[i] = (speech[i] * temp + 0x4000) >> 15; | |
462 | } | |
463 | ||
464 | return -(rh1 << 15) / rh0; | |
465 | } | |
466 | ||
467 | /** | |
468 | * \brief Apply tilt compensation filter (4.2.3). | |
469 | * \param res_pst [in/out] residual signal (partially filtered) | |
470 | * \param k1 (3.12) reflection coefficient | |
471 | * \param subframe_size size of subframe | |
472 | * \param ht_prev_data previous data for 4.2.3, equation 86 | |
473 | * | |
474 | * \return new value for ht_prev_data | |
475 | */ | |
476 | static int16_t apply_tilt_comp(int16_t* out, int16_t* res_pst, int refl_coeff, | |
477 | int subframe_size, int16_t ht_prev_data) | |
478 | { | |
479 | int tmp, tmp2; | |
480 | int i; | |
481 | int gt, ga; | |
482 | int fact, sh_fact; | |
483 | ||
484 | if (refl_coeff > 0) { | |
485 | gt = (refl_coeff * G729_TILT_FACTOR_PLUS + 0x4000) >> 15; | |
486 | fact = 0x4000; // 0.5 in (0.15) | |
487 | sh_fact = 15; | |
488 | } else { | |
489 | gt = (refl_coeff * G729_TILT_FACTOR_MINUS + 0x4000) >> 15; | |
490 | fact = 0x800; // 0.5 in (3.12) | |
491 | sh_fact = 12; | |
492 | } | |
493 | ga = (fact << 15) / av_clip_int16(32768 - FFABS(gt)); | |
494 | gt >>= 1; | |
495 | ||
496 | /* Apply tilt compensation filter to signal. */ | |
497 | tmp = res_pst[subframe_size - 1]; | |
498 | ||
499 | for (i = subframe_size - 1; i >= 1; i--) { | |
500 | tmp2 = (res_pst[i] << 15) + ((gt * res_pst[i-1]) << 1); | |
501 | tmp2 = (tmp2 + 0x4000) >> 15; | |
502 | ||
503 | tmp2 = (tmp2 * ga * 2 + fact) >> sh_fact; | |
504 | out[i] = tmp2; | |
505 | } | |
506 | tmp2 = (res_pst[0] << 15) + ((gt * ht_prev_data) << 1); | |
507 | tmp2 = (tmp2 + 0x4000) >> 15; | |
508 | tmp2 = (tmp2 * ga * 2 + fact) >> sh_fact; | |
509 | out[0] = tmp2; | |
510 | ||
511 | return tmp; | |
512 | } | |
513 | ||
514 | void ff_g729_postfilter(AudioDSPContext *adsp, int16_t* ht_prev_data, int* voicing, | |
515 | const int16_t *lp_filter_coeffs, int pitch_delay_int, | |
516 | int16_t* residual, int16_t* res_filter_data, | |
517 | int16_t* pos_filter_data, int16_t *speech, int subframe_size) | |
518 | { | |
519 | int16_t residual_filt_buf[SUBFRAME_SIZE+11]; | |
520 | int16_t lp_gn[33]; // (3.12) | |
521 | int16_t lp_gd[11]; // (3.12) | |
522 | int tilt_comp_coeff; | |
523 | int i; | |
524 | ||
525 | /* Zero-filling is necessary for tilt-compensation filter. */ | |
526 | memset(lp_gn, 0, 33 * sizeof(int16_t)); | |
527 | ||
528 | /* Calculate A(z/FORMANT_PP_FACTOR_NUM) filter coefficients. */ | |
529 | for (i = 0; i < 10; i++) | |
530 | lp_gn[i + 11] = (lp_filter_coeffs[i + 1] * formant_pp_factor_num_pow[i] + 0x4000) >> 15; | |
531 | ||
532 | /* Calculate A(z/FORMANT_PP_FACTOR_DEN) filter coefficients. */ | |
533 | for (i = 0; i < 10; i++) | |
534 | lp_gd[i + 1] = (lp_filter_coeffs[i + 1] * formant_pp_factor_den_pow[i] + 0x4000) >> 15; | |
535 | ||
536 | /* residual signal calculation (one-half of short-term postfilter) */ | |
537 | memcpy(speech - 10, res_filter_data, 10 * sizeof(int16_t)); | |
538 | residual_filter(residual + RES_PREV_DATA_SIZE, lp_gn + 11, speech, subframe_size); | |
539 | /* Save data to use it in the next subframe. */ | |
540 | memcpy(res_filter_data, speech + subframe_size - 10, 10 * sizeof(int16_t)); | |
541 | ||
542 | /* long-term filter. If long-term prediction gain is larger than 3dB (returned value is | |
543 | nonzero) then declare current subframe as periodic. */ | |
544 | *voicing = FFMAX(*voicing, long_term_filter(adsp, pitch_delay_int, | |
545 | residual, residual_filt_buf + 10, | |
546 | subframe_size)); | |
547 | ||
548 | /* shift residual for using in next subframe */ | |
549 | memmove(residual, residual + subframe_size, RES_PREV_DATA_SIZE * sizeof(int16_t)); | |
550 | ||
551 | /* short-term filter tilt compensation */ | |
552 | tilt_comp_coeff = get_tilt_comp(adsp, lp_gn, lp_gd, residual_filt_buf + 10, subframe_size); | |
553 | ||
554 | /* Apply second half of short-term postfilter: 1/A(z/FORMANT_PP_FACTOR_DEN) */ | |
555 | ff_celp_lp_synthesis_filter(pos_filter_data + 10, lp_gd + 1, | |
556 | residual_filt_buf + 10, | |
557 | subframe_size, 10, 0, 0, 0x800); | |
558 | memcpy(pos_filter_data, pos_filter_data + subframe_size, 10 * sizeof(int16_t)); | |
559 | ||
560 | *ht_prev_data = apply_tilt_comp(speech, pos_filter_data + 10, tilt_comp_coeff, | |
561 | subframe_size, *ht_prev_data); | |
562 | } | |
563 | ||
564 | /** | |
565 | * \brief Adaptive gain control (4.2.4) | |
566 | * \param gain_before gain of speech before applying postfilters | |
567 | * \param gain_after gain of speech after applying postfilters | |
568 | * \param speech [in/out] signal buffer | |
569 | * \param subframe_size length of subframe | |
570 | * \param gain_prev (3.12) previous value of gain coefficient | |
571 | * | |
572 | * \return (3.12) last value of gain coefficient | |
573 | */ | |
574 | int16_t ff_g729_adaptive_gain_control(int gain_before, int gain_after, int16_t *speech, | |
575 | int subframe_size, int16_t gain_prev) | |
576 | { | |
577 | int gain; // (3.12) | |
578 | int n; | |
579 | int exp_before, exp_after; | |
580 | ||
581 | if(!gain_after && gain_before) | |
582 | return 0; | |
583 | ||
584 | if (gain_before) { | |
585 | ||
586 | exp_before = 14 - av_log2(gain_before); | |
587 | gain_before = bidir_sal(gain_before, exp_before); | |
588 | ||
589 | exp_after = 14 - av_log2(gain_after); | |
590 | gain_after = bidir_sal(gain_after, exp_after); | |
591 | ||
592 | if (gain_before < gain_after) { | |
593 | gain = (gain_before << 15) / gain_after; | |
594 | gain = bidir_sal(gain, exp_after - exp_before - 1); | |
595 | } else { | |
596 | gain = ((gain_before - gain_after) << 14) / gain_after + 0x4000; | |
597 | gain = bidir_sal(gain, exp_after - exp_before); | |
598 | } | |
599 | gain = (gain * G729_AGC_FAC1 + 0x4000) >> 15; // gain * (1-0.9875) | |
600 | } else | |
601 | gain = 0; | |
602 | ||
603 | for (n = 0; n < subframe_size; n++) { | |
604 | // gain_prev = gain + 0.9875 * gain_prev | |
605 | gain_prev = (G729_AGC_FACTOR * gain_prev + 0x4000) >> 15; | |
606 | gain_prev = av_clip_int16(gain + gain_prev); | |
607 | speech[n] = av_clip_int16((speech[n] * gain_prev + 0x2000) >> 14); | |
608 | } | |
609 | return gain_prev; | |
610 | } |