Line data Source code
1 : /******************************************************************************************************
2 :
3 : (C) 2022-2025 IVAS codec Public Collaboration with portions copyright Dolby International AB, Ericsson AB,
4 : Fraunhofer-Gesellschaft zur Foerderung der angewandten Forschung e.V., Huawei Technologies Co. LTD.,
5 : Koninklijke Philips N.V., Nippon Telegraph and Telephone Corporation, Nokia Technologies Oy, Orange,
6 : Panasonic Holdings Corporation, Qualcomm Technologies, Inc., VoiceAge Corporation, and other
7 : contributors to this repository. All Rights Reserved.
8 :
9 : This software is protected by copyright law and by international treaties.
10 : The IVAS codec Public Collaboration consisting of Dolby International AB, Ericsson AB,
11 : Fraunhofer-Gesellschaft zur Foerderung der angewandten Forschung e.V., Huawei Technologies Co. LTD.,
12 : Koninklijke Philips N.V., Nippon Telegraph and Telephone Corporation, Nokia Technologies Oy, Orange,
13 : Panasonic Holdings Corporation, Qualcomm Technologies, Inc., VoiceAge Corporation, and other
14 : contributors to this repository retain full ownership rights in their respective contributions in
15 : the software. This notice grants no license of any kind, including but not limited to patent
16 : license, nor is any license granted by implication, estoppel or otherwise.
17 :
18 : Contributors are required to enter into the IVAS codec Public Collaboration agreement before making
19 : contributions.
20 :
21 : This software is provided "AS IS", without any express or implied warranties. The software is in the
22 : development stage. It is intended exclusively for experts who have experience with such software and
23 : solely for the purpose of inspection. All implied warranties of non-infringement, merchantability
24 : and fitness for a particular purpose are hereby disclaimed and excluded.
25 :
26 : Any dispute, controversy or claim arising under or in relation to providing this software shall be
27 : submitted to and settled by the final, binding jurisdiction of the courts of Munich, Germany in
28 : accordance with the laws of the Federal Republic of Germany excluding its conflict of law rules and
29 : the United Nations Convention on Contracts on the International Sales of Goods.
30 :
31 : *******************************************************************************************************/
32 :
33 : /*====================================================================================
34 : EVS Codec 3GPP TS26.443 Nov 04, 2021. Version 12.14.0 / 13.10.0 / 14.6.0 / 15.4.0 / 16.3.0
35 : ====================================================================================*/
36 :
37 : #include <stdint.h>
38 : #include "options.h"
39 : #ifdef DEBUGGING
40 : #include "debug.h"
41 : #endif
42 : #include <math.h>
43 : #include "cnst.h"
44 : #include "prot.h"
45 : #include "rom_com.h"
46 : #include "wmc_auto.h"
47 :
48 : /*-------------------------------------------------------------------*
49 : * WB_BWE_gain_pred()
50 : *
51 : * predict WB frequency envelopes for 0b WB BWE
52 : *-------------------------------------------------------------------*/
53 :
54 18660 : int16_t WB_BWE_gain_pred(
55 : float *WB_fenv, /* o : WB frequency envelopes */
56 : const float *core_dec_freq, /* i : Frequency domain core decoded signal */
57 : const int16_t coder_type, /* i : coding type */
58 : const int16_t prev_coder_type, /* i : coding type of last frame */
59 : const float prev_WB_fenv, /* i : envelope for last frame */
60 : const float voice_factors[], /* i : voicing factors */
61 : const float pitch_buf[], /* i : pitch buffer */
62 : const int32_t last_core_brate, /* i : previous frame core bitrate */
63 : const float last_wb_bwe_ener, /* i : previous frame wb bwe signal energy */
64 : const int16_t last_extl, /* i : extl. layer for last frame */
65 : const float tilt )
66 : {
67 18660 : float enerL, alfa = 1.0f;
68 : int16_t n_freq, mode;
69 18660 : int16_t ener_var_flag = 0;
70 : float voice_factor, pitch;
71 18660 : int16_t env_var_flag = 0;
72 :
73 18660 : mode = NORMAL;
74 :
75 18660 : enerL = EPSILON;
76 1212900 : for ( n_freq = 128; n_freq < 192; n_freq++ )
77 : {
78 1194240 : enerL += core_dec_freq[n_freq] * core_dec_freq[n_freq];
79 : }
80 18660 : WB_fenv[0] = EPSILON;
81 615780 : for ( n_freq = 192; n_freq < 224; n_freq++ )
82 : {
83 597120 : WB_fenv[0] += core_dec_freq[n_freq] * core_dec_freq[n_freq];
84 : }
85 :
86 18660 : WB_fenv[1] = EPSILON;
87 615780 : for ( n_freq = 224; n_freq < 256; n_freq++ )
88 : {
89 597120 : WB_fenv[1] += core_dec_freq[n_freq] * core_dec_freq[n_freq];
90 : }
91 :
92 18660 : voice_factor = sum_f( voice_factors, 4 );
93 18660 : pitch = sum_f( pitch_buf, 4 ) + EPSILON;
94 :
95 18660 : if ( enerL < 16.0f * max( WB_fenv[0], WB_fenv[1] ) && pitch < 308 )
96 : {
97 16877 : ener_var_flag = 1;
98 : }
99 :
100 18660 : if ( WB_fenv[0] > 2.0f * WB_fenv[1] )
101 : {
102 2054 : alfa = max( 2.0f * WB_fenv[1] / WB_fenv[0], 0.1f );
103 2054 : WB_fenv[0] *= alfa;
104 : }
105 16606 : else if ( 2.0f * WB_fenv[0] < WB_fenv[1] && coder_type != UNVOICED )
106 : {
107 12668 : alfa = max( 2.0f * WB_fenv[0] / WB_fenv[1], 0.1f );
108 12668 : WB_fenv[1] *= alfa;
109 : }
110 :
111 18660 : WB_fenv[0] = (float) sqrt( ( WB_fenv[0] + WB_fenv[1] ) / 64 );
112 :
113 18660 : if ( coder_type != AUDIO && coder_type != UNVOICED && ener_var_flag == 0 )
114 : {
115 1783 : WB_fenv[0] *= 1.5f;
116 : }
117 :
118 18660 : if ( coder_type != TRANSITION && coder_type != AUDIO && coder_type != UNVOICED && sqrt( enerL ) > 40.0f * WB_fenv[0] && alfa > 0.9f &&
119 0 : !( coder_type == prev_coder_type && WB_fenv[0] > prev_WB_fenv ) )
120 : {
121 0 : WB_fenv[0] *= min( (float) ( 0.025f * sqrt( enerL ) / WB_fenv[0] ), 4.0f );
122 :
123 0 : if ( WB_fenv[0] > prev_WB_fenv )
124 : {
125 0 : WB_fenv[0] = 0.3f * WB_fenv[0] + 0.7f * prev_WB_fenv;
126 : }
127 : }
128 :
129 18660 : alfa = min( 1.5f, max( 0.5f, 77.0f * voice_factor / pitch ) );
130 18660 : if ( sqrt( enerL ) > 64.0f * alfa * WB_fenv[0] && 3.0f * WB_fenv[0] * WB_fenv[0] < sqrt( enerL ) && prev_coder_type != UNVOICED )
131 : {
132 212 : env_var_flag = 1;
133 212 : WB_fenv[0] *= min( (float) ( 0.015625f * sqrt( enerL ) / WB_fenv[0] ), 4.0f );
134 :
135 212 : if ( WB_fenv[0] > prev_WB_fenv )
136 : {
137 206 : WB_fenv[0] = 0.3f * WB_fenv[0] + 0.7f * prev_WB_fenv;
138 : }
139 : }
140 :
141 18660 : if ( coder_type == UNVOICED || prev_coder_type == UNVOICED )
142 : {
143 624 : WB_fenv[0] *= 0.5f;
144 : }
145 :
146 18660 : if ( coder_type != AUDIO )
147 : {
148 18660 : WB_fenv[0] /= max( 1.2f * voice_factor, 1.0f );
149 18660 : WB_fenv[0] *= min( 2.0f, max( 0.125f, pitch / 400.0f ) );
150 : }
151 :
152 18660 : if ( last_core_brate > ACELP_8k00 && WB_fenv[0] > last_wb_bwe_ener )
153 : {
154 3033 : WB_fenv[0] = 0.9f * last_wb_bwe_ener + 0.1f * WB_fenv[0];
155 : }
156 :
157 18660 : if ( last_extl != WB_BWE && ( tilt < 8.f ) )
158 : {
159 388 : WB_fenv[0] *= min( 0.5f, 16.0f * tilt );
160 : }
161 :
162 18660 : if ( env_var_flag == 1 )
163 : {
164 212 : WB_fenv[1] = 1.5f * WB_fenv[0];
165 212 : WB_fenv[0] *= 0.75f;
166 : }
167 : else
168 : {
169 18448 : WB_fenv[1] = WB_fenv[0];
170 : }
171 :
172 18660 : if ( coder_type == UNVOICED || prev_coder_type == UNVOICED )
173 : {
174 624 : WB_fenv[1] *= 0.5f;
175 : }
176 :
177 18660 : return ( mode );
178 : }
179 :
180 : /*-------------------------------------------------------------------*
181 : * calc_normal_length()
182 : *
183 : *-------------------------------------------------------------------*/
184 :
185 238106 : void calc_normal_length(
186 : const int16_t core, /* i : core */
187 : const float *sp, /* i : input signal */
188 : const int16_t mode, /* i : input mode */
189 : const int16_t extl, /* i : extension layer */
190 : int16_t *L_swb_norm, /* o : normalize length */
191 : int16_t *prev_L_swb_norm /* i/o: last normalize length */
192 : )
193 : {
194 : int16_t i, n_freq, n_band, THRES;
195 : const float *pit;
196 : float peak, mean, mag;
197 : int16_t L_swb_norm_trans, L_swb_norm_norm, L_swb_norm_harm, L_swb_norm_cur;
198 : int16_t N;
199 :
200 238106 : if ( core == HQ_CORE || extl == SWB_BWE || extl == FB_BWE )
201 : {
202 146411 : THRES = 8;
203 : }
204 : else
205 : {
206 91695 : THRES = 4;
207 : }
208 :
209 238106 : if ( core == HQ_CORE && ( mode == HQ_HARMONIC || mode == HQ_HVQ ) )
210 : {
211 9356 : N = 13;
212 : }
213 : else
214 : {
215 228750 : N = 16;
216 : }
217 :
218 238106 : n_band = 0;
219 238106 : pit = sp;
220 4019734 : for ( i = 0; i < N; i++ )
221 : {
222 3781628 : peak = 0.0f;
223 3781628 : mean = 0;
224 :
225 64287676 : for ( n_freq = 0; n_freq < 16; n_freq++ )
226 : {
227 60506048 : mag = (float) fabs( *pit );
228 60506048 : if ( mag > peak )
229 : {
230 12761196 : peak = mag;
231 : }
232 60506048 : mean += mag;
233 60506048 : pit++;
234 : }
235 :
236 3781628 : if ( ( 15 + THRES ) * peak > THRES * mean && peak > 10 )
237 : {
238 516788 : n_band += 1;
239 : }
240 : }
241 :
242 238106 : if ( core == ACELP_CORE )
243 : {
244 209177 : L_swb_norm_trans = (int16_t) ( 4 + 0.25f * n_band );
245 209177 : L_swb_norm_norm = (int16_t) ( 8 + 0.5f * n_band );
246 209177 : L_swb_norm_harm = max( (int16_t) ( 32 + 2.0f * n_band ), 24 );
247 :
248 209177 : if ( mode == HARMONIC )
249 : {
250 7771 : L_swb_norm_cur = L_swb_norm_harm;
251 : }
252 201406 : else if ( mode == NORMAL )
253 : {
254 187758 : L_swb_norm_cur = L_swb_norm_norm;
255 : }
256 : else
257 : {
258 13648 : L_swb_norm_cur = L_swb_norm_trans;
259 : }
260 :
261 209177 : *L_swb_norm = (int16_t) ( 0.5f * L_swb_norm_cur + 0.5f * ( *prev_L_swb_norm ) );
262 209177 : *prev_L_swb_norm = L_swb_norm_cur;
263 : }
264 : else
265 : {
266 28929 : if ( mode == HQ_HARMONIC || mode == HQ_HVQ )
267 : {
268 9356 : L_swb_norm_cur = (int16_t) ( 32 + 2.5f * n_band );
269 : }
270 : else
271 : {
272 19573 : L_swb_norm_cur = (int16_t) ( 8 + 0.5f * n_band );
273 : }
274 :
275 28929 : *L_swb_norm = (int16_t) ( 0.1f * L_swb_norm_cur + 0.9f * ( *prev_L_swb_norm ) + 0.5f );
276 28929 : *prev_L_swb_norm = L_swb_norm_cur;
277 : }
278 :
279 238106 : return;
280 : }
281 : /*-------------------------------------------------------------------*
282 : * calc_tilt_bwe()
283 : *
284 : * calculate tilt parameter
285 : *-------------------------------------------------------------------*/
286 :
287 7496111 : void calc_tilt_bwe(
288 : const float *sp, /* i : input signal */
289 : float *tilt, /* o : signal tilt */
290 : const int16_t N /* i : signal length */
291 : )
292 : {
293 : int16_t i;
294 : float r0, r1;
295 :
296 7496111 : r0 = EPSILON;
297 3816230319 : for ( i = 0; i < N; i++ )
298 : {
299 3808734208 : r0 += sp[i] * sp[i];
300 : }
301 :
302 7496111 : r1 = (float) fabs( sp[1] - sp[0] );
303 3801238097 : for ( i = 2; i < N; i++ )
304 : {
305 3793741986 : if ( ( sp[i] - sp[i - 1] ) * ( sp[i - 1] - sp[i - 2] ) < 0 )
306 : {
307 850211827 : r1 += (float) fabs( sp[i] - sp[i - 1] );
308 : }
309 : }
310 :
311 7496111 : *tilt = (float) ( r1 / sqrt( r0 ) );
312 :
313 7496111 : return;
314 : }
315 :
316 : /*-------------------------------------------------------------------*
317 : * calc_norm_envelop()
318 : *
319 : * calculate normalized parameter
320 : *-------------------------------------------------------------------*/
321 :
322 201624 : void calc_norm_envelop(
323 : const float SWB_signal[], /* i : SWB spectrum */
324 : float *envelope, /* o : normalized envelope */
325 : const int16_t L_swb_norm, /* i : length of envelope */
326 : const int16_t SWB_flength, /* i : Length of input/output */
327 : const int16_t st_offset /* i : offset */
328 : )
329 : {
330 : int16_t i, lookback, env_index, n_freq, n_lag_now, n_lag;
331 :
332 201624 : lookback = L_swb_norm / 2;
333 201624 : env_index = swb_bwe_subband[0] + st_offset;
334 201624 : n_lag_now = L_swb_norm;
335 44633156 : for ( n_freq = swb_bwe_trans_subband[0] + st_offset - lookback; n_freq < SWB_flength + st_offset - L_swb_norm; n_freq++ )
336 : {
337 : /* Apply MA filter */
338 44431532 : envelope[env_index] = EPSILON;
339 431353994 : for ( n_lag = 0; n_lag < n_lag_now; n_lag++ )
340 : {
341 386922462 : envelope[env_index] += (float) fabs( SWB_signal[n_freq + n_lag] );
342 : }
343 44431532 : env_index++;
344 : }
345 :
346 1226572 : for ( n_freq = SWB_flength + st_offset - L_swb_norm, i = 0; n_freq < SWB_flength + st_offset - lookback; n_freq++, i++ )
347 : {
348 1024948 : n_lag_now = L_swb_norm - i;
349 : /* Apply MA filter */
350 1024948 : envelope[env_index] = EPSILON;
351 13045156 : for ( n_lag = 0; n_lag < n_lag_now; n_lag++ )
352 : {
353 12020208 : envelope[env_index] += (float) fabs( SWB_signal[n_freq + n_lag] );
354 : }
355 1024948 : env_index++;
356 : }
357 :
358 201624 : return;
359 : }
360 :
361 :
362 : /*-------------------------------------------------------------------*
363 : * calc_norm_envelop_lf()
364 : *
365 : * calc_envelope of low frequency spectrum
366 : *-------------------------------------------------------------------*/
367 14612 : static void calc_norm_envelop_lf(
368 : const float SWB_signal[], /* i : SWB spectrum */
369 : float *envelope, /* o : normalized envelope */
370 : int16_t *L_swb_norm, /* i/o: length of envelope */
371 : const int16_t HQ_mode, /* i : HQ mode */
372 : const int16_t hq_generic_offset, /* i : frequency offset for representing hq swb bwe */
373 : int16_t *sfreq, /* i : starting frequency index */
374 : int16_t *efreq ) /* i : ending frequency index */
375 : {
376 : int16_t lookback, env_index, n_freq, n_lag_now, n_lag;
377 :
378 14612 : *sfreq = 2;
379 14612 : if ( hq_generic_offset == HQ_GENERIC_FOFFSET_24K4 )
380 : {
381 14612 : *efreq = 146;
382 14612 : if ( HQ_mode == HQ_GEN_FB )
383 : {
384 10223 : *efreq = 306;
385 : }
386 14612 : if ( ( 328 - *efreq ) * 2 + 1 < *L_swb_norm )
387 : {
388 133 : *L_swb_norm = ( 328 - *efreq ) * 2 + 1;
389 : }
390 : }
391 : else
392 : {
393 0 : *efreq = 130;
394 0 : if ( HQ_mode == HQ_GEN_FB )
395 : {
396 0 : *efreq = 290;
397 : }
398 0 : if ( ( 400 - *efreq ) * 2 + 1 < *L_swb_norm )
399 : {
400 0 : *L_swb_norm = ( 400 - *efreq ) * 2 + 1;
401 : }
402 : }
403 :
404 14612 : lookback = *L_swb_norm / 2;
405 14612 : env_index = 0;
406 14612 : n_lag_now = *L_swb_norm;
407 114810 : for ( n_freq = 0; n_freq < lookback; n_freq++ )
408 : {
409 100198 : envelope[env_index] = EPSILON;
410 1948088 : for ( n_lag = 0; n_lag < lookback + n_freq; n_lag++ )
411 : {
412 1847890 : envelope[env_index] += (float) fabs( SWB_signal[n_lag] );
413 : }
414 100198 : env_index++;
415 : }
416 3683446 : for ( ; n_freq < *efreq; n_freq++ )
417 : {
418 : /* Apply MA filter */
419 3668834 : envelope[env_index] = EPSILON;
420 51302466 : for ( n_lag = 0; n_lag < n_lag_now; n_lag++ )
421 : {
422 47633632 : envelope[env_index] += (float) fabs( SWB_signal[n_freq - lookback + n_lag] );
423 : }
424 3668834 : env_index++;
425 : }
426 14612 : return;
427 : }
428 :
429 : /*-------------------------------------------------------------------*
430 : * WB_BWE_decoding()
431 : *
432 : * WB BWE decoder
433 : *-------------------------------------------------------------------*/
434 :
435 73908 : void WB_BWE_decoding(
436 : const float *core_dec_freq, /* i : Frequency domain core decoded signal */
437 : float *WB_fenv, /* i : WB frequency envelopes */
438 : float *WB_signal, /* o : WB signal in MDCT domain */
439 : const int16_t WB_flength, /* i : Length of input/output */
440 : const int16_t mode, /* i : classification for WB signal */
441 : const int16_t last_extl, /* i : extl. layer for last frame */
442 : float *prev_Energy, /* i/o: energy for last frame */
443 : float *prev_WB_fenv, /* i/o: envelope for last frame */
444 : int16_t *prev_L_wb_norm, /* i/o: length for last frame wb norm */
445 : const int16_t extl, /* i : extension layer */
446 : const int16_t coder_type, /* i : coding type */
447 : const int32_t total_brate, /* i : core layer bitrate */
448 : int16_t *Seed, /* i/o: random generator seed */
449 : int16_t *prev_flag, /* i/o: attenu flag of last frame */
450 : int16_t prev_coder_type /* i : coding type of last frame */
451 : )
452 : {
453 : int16_t n_freq, n_band;
454 : int16_t i, L;
455 : float envelope[L_FRAME16k];
456 : float energy, wfenv[2], EnergyL;
457 : float *pit1;
458 : int16_t L_wb_norm;
459 : float alfa, beta;
460 73908 : int16_t flag = 0;
461 73908 : int16_t core_type = 1;
462 : int16_t signum[L_FRAME16k];
463 : float inv_L_wb_norm, weight;
464 :
465 73908 : calc_normal_length( ACELP_CORE, core_dec_freq, mode, extl, &L_wb_norm, prev_L_wb_norm );
466 :
467 73908 : set_f( WB_signal, 0, L_FRAME16k );
468 :
469 : /* copy excitation */
470 73908 : if ( coder_type != AUDIO && total_brate <= ACELP_8k00 )
471 : {
472 16100 : core_type = 0;
473 : }
474 :
475 73908 : if ( core_type == 0 )
476 : {
477 16100 : mvr2r( &core_dec_freq[160], &WB_signal[240], 80 );
478 : }
479 : else
480 : {
481 57808 : mvr2r( &core_dec_freq[80], &WB_signal[240], 80 );
482 : }
483 :
484 : /* calculate envelope */
485 73908 : calc_norm_envelop( WB_signal, envelope, L_wb_norm, WB_flength, 0 );
486 :
487 73908 : if ( coder_type != UNVOICED && total_brate <= ACELP_8k00 )
488 : {
489 39727 : inv_L_wb_norm = 1.0f / L_wb_norm;
490 39727 : weight = ( mode != HARMONIC ) ? max( min( 3.0f * inv_L_wb_norm, 0.5f ), 0.25f ) : 0.25f;
491 3217887 : for ( n_freq = swb_bwe_subband[0]; n_freq < swb_bwe_subband[4]; n_freq++ )
492 : {
493 3178160 : signum[n_freq] = 1;
494 3178160 : if ( WB_signal[n_freq] < 0 )
495 : {
496 1593880 : signum[n_freq] = -1;
497 1593880 : WB_signal[n_freq] *= signum[n_freq];
498 : }
499 :
500 3178160 : WB_signal[n_freq] = WB_signal[n_freq] - 0.45f * envelope[n_freq] * inv_L_wb_norm;
501 3178160 : if ( WB_signal[n_freq] > 0 )
502 : {
503 2351230 : WB_signal[n_freq] *= ( 0.55f - weight );
504 : }
505 3178160 : WB_signal[n_freq] *= signum[n_freq];
506 : }
507 : }
508 :
509 : /* Normalize with envelope */
510 5986548 : for ( n_freq = swb_bwe_subband[0]; n_freq < swb_bwe_subband[4]; n_freq++ )
511 : {
512 5912640 : WB_signal[n_freq] /= envelope[n_freq];
513 : }
514 :
515 73908 : if ( mode == HARMONIC )
516 : {
517 4788 : L = 4;
518 : }
519 : else
520 : {
521 69120 : L = 1;
522 : }
523 :
524 73908 : if ( coder_type == UNVOICED )
525 : {
526 45198 : for ( n_freq = swb_bwe_subband[0]; n_freq < swb_bwe_subband[4]; n_freq++ )
527 : {
528 44640 : *Seed = (int16_t) ( 12345 * ( *Seed ) + 20101 );
529 44640 : WB_signal[n_freq] = ( *Seed ) / PCM16_TO_FLT_FAC;
530 : }
531 : }
532 : else
533 : {
534 352386 : for ( n_band = 0; n_band < 4; n_band += L )
535 : {
536 279036 : energy = EPSILON;
537 6147036 : for ( n_freq = swb_bwe_subband[n_band]; n_freq < swb_bwe_subband[n_band + L]; n_freq++ )
538 : {
539 5868000 : energy += WB_signal[n_freq] * WB_signal[n_freq];
540 : }
541 :
542 279036 : energy = (float) sqrt( ( swb_bwe_subband[n_band + L] - swb_bwe_subband[n_band] ) / energy );
543 :
544 6147036 : for ( n_freq = swb_bwe_subband[n_band]; n_freq < swb_bwe_subband[n_band + L]; n_freq++ )
545 : {
546 5868000 : WB_signal[n_freq] *= energy;
547 : }
548 : }
549 : }
550 :
551 :
552 73908 : EnergyL = 0.0f;
553 73908 : if ( core_type == 1 )
554 : {
555 57808 : if ( prev_coder_type != AUDIO && total_brate <= ACELP_8k00 )
556 : {
557 59778 : for ( i = 160; i < 240; i++ )
558 : {
559 59040 : EnergyL += (float) fabs( core_dec_freq[i] );
560 : }
561 : }
562 : else
563 : {
564 9188270 : for ( i = 80; i < 240; i++ )
565 : {
566 9131200 : EnergyL += (float) fabs( core_dec_freq[i] );
567 : }
568 : }
569 :
570 57808 : if ( total_brate <= ACELP_8k00 )
571 : {
572 24131 : alfa = 0.8f;
573 24131 : beta = 1.25f;
574 : }
575 : else
576 : {
577 33677 : alfa = 0.5f;
578 33677 : beta = 2.0f;
579 : }
580 : }
581 : else
582 : {
583 16100 : if ( prev_coder_type == AUDIO )
584 : {
585 1932 : for ( i = 80; i < 240; i++ )
586 : {
587 1920 : EnergyL += (float) fabs( core_dec_freq[i] );
588 : }
589 : }
590 : else
591 : {
592 1303128 : for ( i = 160; i < 240; i++ )
593 : {
594 1287040 : EnergyL += (float) fabs( core_dec_freq[i] );
595 : }
596 : }
597 :
598 16100 : if ( prev_coder_type == coder_type && WB_fenv[0] > prev_WB_fenv[0] )
599 : {
600 8017 : alfa = 0.4f;
601 8017 : beta = 2.5f;
602 : }
603 : else
604 : {
605 8083 : alfa = 0.6f;
606 8083 : beta = 1.67f;
607 : }
608 :
609 16100 : if ( coder_type == GENERIC || ( EnergyL > 0.5f * ( *prev_Energy ) && EnergyL < 2.0f * ( *prev_Energy ) && *prev_flag == 1 ) )
610 : {
611 904 : WB_fenv[0] *= 0.5f;
612 904 : WB_fenv[1] *= 0.5f;
613 904 : flag = 1;
614 : }
615 : }
616 73908 : if ( ( mode == HARMONIC && WB_fenv[1] < 0.25f * WB_fenv[0] ) || mode == NORMAL )
617 : {
618 69192 : if ( last_extl == WB_BWE && ( ( prev_coder_type == AUDIO && coder_type != AUDIO ) || ( prev_coder_type != AUDIO && coder_type == AUDIO ) ) && total_brate <= ACELP_8k00 )
619 : {
620 24 : if ( WB_fenv[0] > prev_WB_fenv[0] )
621 : {
622 12 : wfenv[0] = 0.3f * WB_fenv[0] + 0.7f * prev_WB_fenv[0];
623 12 : wfenv[1] = 0.3f * WB_fenv[1] + 0.7f * prev_WB_fenv[1];
624 : }
625 : else
626 : {
627 12 : wfenv[0] = 0.5f * WB_fenv[0] + 0.5f * prev_WB_fenv[0];
628 12 : wfenv[1] = 0.4f * WB_fenv[1] + 0.4f * prev_WB_fenv[1];
629 : }
630 : }
631 69168 : else if ( last_extl == WB_BWE && prev_WB_fenv[0] * EnergyL < WB_fenv[0] * ( *prev_Energy ) && WB_fenv[0] > prev_WB_fenv[0] && coder_type != AUDIO && coder_type != UNVOICED && total_brate <= ACELP_8k00 )
632 : {
633 4284 : wfenv[0] = 0.3f * WB_fenv[0] + 0.7f * prev_WB_fenv[0];
634 4284 : wfenv[1] = 0.3f * WB_fenv[1] + 0.7f * prev_WB_fenv[1];
635 : }
636 64884 : else if ( last_extl == WB_BWE && EnergyL > alfa * ( *prev_Energy ) && EnergyL < beta * ( *prev_Energy ) && prev_coder_type != UNVOICED )
637 : {
638 45208 : wfenv[0] = 0.5f * ( WB_fenv[0] + prev_WB_fenv[0] );
639 45208 : wfenv[1] = 0.5f * ( WB_fenv[1] + prev_WB_fenv[1] );
640 : }
641 : else
642 : {
643 19676 : wfenv[0] = WB_fenv[0];
644 19676 : wfenv[1] = WB_fenv[1];
645 : }
646 2836872 : for ( n_freq = swb_bwe_subband[0]; n_freq < swb_bwe_subband[2]; n_freq++ )
647 : {
648 2767680 : WB_signal[n_freq] *= wfenv[0];
649 : }
650 :
651 2836872 : for ( n_freq = swb_bwe_subband[2]; n_freq < swb_bwe_subband[4]; n_freq++ )
652 : {
653 2767680 : WB_signal[n_freq] *= wfenv[1];
654 : }
655 :
656 69192 : prev_WB_fenv[0] = wfenv[0];
657 69192 : prev_WB_fenv[1] = wfenv[1];
658 : }
659 : else
660 : {
661 4716 : wfenv[0] = 0.5f * ( WB_fenv[0] + WB_fenv[1] );
662 :
663 4716 : if ( last_extl == WB_BWE && EnergyL > 0.5f * ( *prev_Energy ) && EnergyL < 2.0f * ( *prev_Energy ) )
664 : {
665 4584 : wfenv[0] = 0.25f * wfenv[0] + 0.375f * ( prev_WB_fenv[0] + prev_WB_fenv[1] );
666 : }
667 381996 : for ( n_freq = swb_bwe_subband[0]; n_freq < swb_bwe_subband[4]; n_freq++ )
668 : {
669 377280 : WB_signal[n_freq] *= wfenv[0];
670 : }
671 :
672 4716 : prev_WB_fenv[0] = wfenv[0];
673 4716 : prev_WB_fenv[1] = wfenv[0];
674 : }
675 :
676 73908 : *prev_flag = flag;
677 73908 : *prev_Energy = EnergyL;
678 73908 : pit1 = &WB_signal[240];
679 :
680 1256436 : for ( n_freq = 0; n_freq < 16; n_freq++ )
681 : {
682 1182528 : *( pit1++ ) *= ( 0.2f + n_freq * 0.05f );
683 : }
684 :
685 73908 : if ( core_type == 1 )
686 : {
687 57808 : pit1 = &WB_signal[280];
688 2370128 : for ( n_freq = 0; n_freq < 40; n_freq++ )
689 : {
690 2312320 : *( pit1++ ) *= ( 1.0f - n_freq * 0.02f );
691 : }
692 : }
693 : else
694 : {
695 16100 : pit1 = &WB_signal[300];
696 338100 : for ( n_freq = 0; n_freq < 20; n_freq++ )
697 : {
698 322000 : *( pit1++ ) *= ( 1.0f - n_freq * 0.04f );
699 : }
700 : }
701 :
702 73908 : return;
703 : }
704 :
705 : /*-------------------------------------------------------------------*
706 : * SWB_BWE_decoding()
707 : *
708 : * SWB BWE decoder
709 : *-------------------------------------------------------------------*/
710 :
711 101755 : void SWB_BWE_decoding(
712 : const float *core_dec_freq, /* i : Frequency domain core decoded signal */
713 : float *SWB_fenv, /* i/o: SWB frequency envelopes */
714 : float *SWB_signal, /* o : SWB signal in MDCT domain */
715 : const int16_t SWB_flength, /* i : Length of input/output */
716 : const int16_t mode, /* i : classification for SWB signal */
717 : int16_t *frica_flag, /* o : fricative signal flag */
718 : float *prev_Energy, /* i/o: energy for last frame */
719 : float *prev_SWB_fenv, /* i/o: envelope for last frame */
720 : int16_t *prev_L_swb_norm, /* i/o: length for last frame wb norm */
721 : const float tilt_nb, /* i : tilt of synthesis wb signal */
722 : int16_t *Seed, /* i/o: random generator seed */
723 : const int16_t st_offset, /* i : offset value due to different core */
724 : float *prev_weight, /* i/o: excitation weight value of last frame */
725 : const int16_t extl, /* i : extension layer */
726 : const int16_t last_extl /* i : extension layer of last frame */
727 : )
728 : {
729 : int16_t n_freq, n_band, L, L_swb_norm;
730 : float *pit1;
731 : float envelope[L_FRAME32k];
732 : float fenvL, EnergyL, Energy, energy, weight, wfenv, factor;
733 : float mean, factor1, tmp1, tmp2, tmp3, tmp4, tmp_ener;
734 : int16_t signum[L_FRAME32k];
735 : float inv_L_swb_norm;
736 :
737 101755 : fenvL = EPSILON;
738 101755 : EnergyL = EPSILON;
739 1729835 : for ( n_freq = 224 + st_offset; n_freq < swb_bwe_trans_subband[0] + st_offset; n_freq++ )
740 : {
741 1628080 : fenvL += core_dec_freq[n_freq] * core_dec_freq[n_freq];
742 : }
743 :
744 24522955 : for ( n_freq = 16; n_freq < L_FRAME; n_freq++ )
745 : {
746 24421200 : EnergyL += core_dec_freq[n_freq] * core_dec_freq[n_freq];
747 : }
748 101755 : fenvL = (float) sqrt( fenvL / 16 );
749 101755 : EnergyL = (float) sqrt( EnergyL / 240 );
750 101755 : if ( fenvL > 8.0f * SWB_fenv[0] )
751 : {
752 9306 : fenvL = SWB_fenv[0];
753 : }
754 101755 : calc_normal_length( ACELP_CORE, core_dec_freq, mode, extl, &L_swb_norm, prev_L_swb_norm );
755 :
756 101755 : if ( mode == TRANSIENT )
757 : {
758 689 : Energy = 0.0f;
759 3445 : for ( n_band = 0; n_band < SWB_FENV_TRANS; n_band++ )
760 : {
761 2756 : Energy += SWB_fenv[n_band] * SWB_fenv[n_band];
762 : }
763 689 : Energy /= SWB_FENV_TRANS;
764 :
765 : /* Reconstruct excitation from LF signal */
766 689 : mvr2r( &core_dec_freq[112], &SWB_signal[240 + st_offset], 128 );
767 689 : mvr2r( &core_dec_freq[112], &SWB_signal[368 + st_offset], 128 );
768 689 : mvr2r( &core_dec_freq[176], &SWB_signal[496 + st_offset], 64 );
769 :
770 : /* calculate envelope */
771 689 : calc_norm_envelop( SWB_signal, envelope, L_swb_norm, SWB_flength, st_offset );
772 :
773 : /* Normalize with envelope */
774 221169 : for ( n_freq = swb_bwe_trans_subband[0] + st_offset; n_freq < swb_bwe_trans_subband[SWB_FENV_TRANS] + st_offset; n_freq++ )
775 : {
776 220480 : SWB_signal[n_freq] /= envelope[n_freq];
777 : }
778 :
779 3445 : for ( n_band = 0; n_band < SWB_FENV_TRANS; n_band++ )
780 : {
781 2756 : energy = EPSILON;
782 223236 : for ( n_freq = swb_bwe_trans_subband[n_band] + st_offset; n_freq < swb_bwe_trans_subband[n_band + 1] + st_offset; n_freq++ )
783 : {
784 220480 : energy += SWB_signal[n_freq] * SWB_signal[n_freq];
785 : }
786 :
787 2756 : tmp_ener = (float) ( sqrt( swb_bwe_trans_subband_width[n_band] / energy ) * SWB_fenv[n_band] );
788 :
789 223236 : for ( n_freq = swb_bwe_trans_subband[n_band] + st_offset; n_freq < swb_bwe_trans_subband[n_band + 1] + st_offset; n_freq++ )
790 : {
791 220480 : SWB_signal[n_freq] *= tmp_ener;
792 : }
793 : }
794 :
795 6201 : for ( n_band = 0; n_band < 8; n_band++ )
796 : {
797 5512 : prev_SWB_fenv[n_band] = SWB_fenv[n_band / 4] * SWB_fenv[n_band / 4];
798 : }
799 :
800 4823 : for ( n_band = 0; n_band < 6; n_band++ )
801 : {
802 4134 : prev_SWB_fenv[8 + n_band] = SWB_fenv[2 + n_band / 3] * SWB_fenv[2 + n_band / 3];
803 : }
804 :
805 689 : *prev_weight = 0.5f;
806 : }
807 : else
808 : {
809 101066 : Energy = EPSILON;
810 1515990 : for ( n_band = 0; n_band < SWB_FENV; n_band++ )
811 : {
812 1414924 : Energy += SWB_fenv[n_band];
813 : }
814 101066 : Energy /= SWB_FENV;
815 101066 : if ( last_extl != SWB_BWE && last_extl != FB_BWE )
816 : {
817 30548 : if ( 16.0f * Energy < EnergyL && extl == FB_BWE )
818 : {
819 315 : for ( n_band = 0; n_band < SWB_FENV; n_band++ )
820 : {
821 294 : SWB_fenv[n_band] *= 0.2f;
822 : }
823 21 : fenvL *= 0.2f;
824 : }
825 30548 : mvr2r( SWB_fenv, prev_SWB_fenv, SWB_FENV );
826 : }
827 101066 : if ( mode == HARMONIC )
828 : {
829 1101 : mvr2r( core_dec_freq, &SWB_signal[240 + st_offset], 240 );
830 1101 : mvr2r( &core_dec_freq[128], &SWB_signal[480 + st_offset], 80 );
831 :
832 : /* calculate envelope */
833 1101 : calc_norm_envelop( SWB_signal, envelope, L_swb_norm, SWB_flength, st_offset );
834 : }
835 : else
836 : {
837 99965 : if ( mode == NOISE || ( ( Energy > EnergyL || ( tilt_nb > 7 && Energy > 0.5f * EnergyL ) || tilt_nb > 12 ) && Energy > 75 && fenvL > 25 ) )
838 : {
839 4016994 : for ( n_freq = swb_bwe_subband[0] + st_offset; n_freq < swb_bwe_subband[SWB_FENV] + st_offset; n_freq++ )
840 : {
841 4004480 : *Seed = (int16_t) ( 12345 * ( *Seed ) + 20101 );
842 4004480 : SWB_signal[n_freq] = ( *Seed ) / PCM16_TO_FLT_FAC;
843 : }
844 12514 : if ( mode != NOISE )
845 : {
846 2024 : *frica_flag = 1;
847 : }
848 : }
849 : else
850 : {
851 : /* modify SHB frequency envelopes when SHB spectrum is unflat */
852 1224314 : for ( n_band = 0; n_band < 13; n_band++ )
853 : {
854 1136863 : if ( SWB_fenv[n_band] * 0.9f > SWB_fenv[n_band + 1] )
855 : {
856 407083 : SWB_fenv[n_band + 1] *= ( 0.8f + 0.015f * n_band );
857 : }
858 729780 : else if ( SWB_fenv[n_band + 1] * 0.9f > SWB_fenv[n_band] )
859 : {
860 360805 : SWB_fenv[n_band] *= ( 0.8f + 0.015f * n_band );
861 : }
862 : }
863 :
864 87451 : mvr2r( &core_dec_freq[112], &SWB_signal[240 + st_offset], 128 );
865 87451 : mvr2r( &core_dec_freq[112], &SWB_signal[368 + st_offset], 128 );
866 87451 : mvr2r( &core_dec_freq[176], &SWB_signal[496 + st_offset], 64 );
867 :
868 87451 : tmp1 = (float) ( fabs( SWB_signal[368 + st_offset] ) + fabs( SWB_signal[369 + st_offset] ) ) + EPSILON;
869 87451 : tmp2 = (float) ( fabs( SWB_signal[365 + st_offset] ) + fabs( SWB_signal[366 + st_offset] ) ) + EPSILON;
870 87451 : pit1 = &SWB_signal[368 + st_offset];
871 :
872 87451 : tmp3 = tmp2 / tmp1;
873 87451 : if ( tmp3 < 0.3 )
874 : {
875 30773 : tmp3 = 0.3f;
876 : }
877 :
878 452913 : while ( tmp3 < 1 )
879 : {
880 365462 : *pit1++ *= tmp3;
881 365462 : tmp3 += 0.1f;
882 : }
883 :
884 87451 : pit1 = &SWB_signal[367 + st_offset];
885 87451 : tmp3 = tmp1 / tmp2;
886 :
887 87451 : if ( tmp3 > 5 )
888 : {
889 22054 : tmp3 = 5;
890 198486 : while ( tmp3 > 1 )
891 : {
892 176432 : *pit1-- *= tmp3;
893 176432 : tmp3 -= 0.5f;
894 : }
895 : }
896 :
897 87451 : tmp1 = (float) ( fabs( SWB_signal[496 + st_offset] ) + fabs( SWB_signal[497 + st_offset] ) ) + EPSILON;
898 87451 : tmp2 = (float) ( fabs( SWB_signal[492 + st_offset] ) + fabs( SWB_signal[493 + st_offset] ) + fabs( SWB_signal[494 + st_offset] ) + fabs( SWB_signal[495 + st_offset] ) ) + EPSILON;
899 87451 : pit1 = &SWB_signal[496 + st_offset];
900 :
901 87451 : tmp3 = tmp2 / tmp1;
902 87451 : if ( tmp3 < 0.3 )
903 : {
904 2838 : tmp3 = 0.3f;
905 : }
906 :
907 186292 : while ( tmp3 < 1 )
908 : {
909 98841 : *pit1++ *= tmp3;
910 98841 : tmp3 += 0.1f;
911 : }
912 :
913 87451 : pit1 = &SWB_signal[495 + st_offset];
914 :
915 87451 : tmp3 = tmp1 / tmp2;
916 87451 : tmp3 = 0.5f * tmp3;
917 87451 : tmp4 = 0.05f * tmp3;
918 :
919 142686 : while ( tmp3 > 1 )
920 : {
921 55235 : *pit1-- *= tmp3;
922 55235 : tmp3 -= tmp4;
923 : }
924 :
925 : /* calculate envelope */
926 87451 : calc_norm_envelop( SWB_signal, envelope, L_swb_norm, SWB_flength, st_offset );
927 : }
928 : }
929 :
930 : /* Normalize with envelope */
931 101066 : if ( *frica_flag == 0 && mode != NOISE )
932 : {
933 88552 : L = swb_bwe_subband[0] + st_offset;
934 88552 : inv_L_swb_norm = 1.0f / L_swb_norm;
935 88552 : weight = ( mode != HARMONIC ) ? max( min( 3.0f * inv_L_swb_norm, 0.5f ), 0.2f ) : 0.2f;
936 88552 : weight = 0.4f * weight + 0.6f * ( *prev_weight );
937 28425192 : for ( n_freq = L; n_freq < swb_bwe_subband[SWB_FENV] + st_offset; n_freq++ )
938 : {
939 28336640 : signum[n_freq] = 1;
940 28336640 : if ( SWB_signal[n_freq] < 0 )
941 : {
942 14186233 : signum[n_freq] = -1;
943 14186233 : SWB_signal[n_freq] *= signum[n_freq];
944 : }
945 :
946 28336640 : SWB_signal[n_freq] = SWB_signal[n_freq] - envelope[n_freq] * inv_L_swb_norm;
947 28336640 : if ( SWB_signal[n_freq] > 0 )
948 : {
949 12505362 : SWB_signal[n_freq] *= ( 1.2f - weight );
950 : }
951 28336640 : SWB_signal[n_freq] *= signum[n_freq];
952 : }
953 :
954 28425192 : for ( n_freq = L; n_freq < swb_bwe_subband[SWB_FENV] + st_offset; n_freq++ )
955 : {
956 28336640 : SWB_signal[n_freq] /= envelope[n_freq];
957 : }
958 :
959 88552 : *prev_weight = weight;
960 : }
961 : else
962 : {
963 12514 : *prev_weight = max( min( 3.0f / L_swb_norm, 0.5f ), 0.2f );
964 : }
965 :
966 101066 : if ( mode == HARMONIC )
967 : {
968 1101 : pit1 = &SWB_signal[swb_bwe_subband[0] + st_offset];
969 22020 : for ( n_band = 0; n_band < 19; n_band++ )
970 : {
971 20919 : mean = 0;
972 355623 : for ( n_freq = 0; n_freq < 16; n_freq++ )
973 : {
974 334704 : mean += (float) fabs( *pit1 );
975 334704 : pit1++;
976 : }
977 20919 : mean /= 16;
978 20919 : pit1 -= 16;
979 355623 : for ( n_freq = 0; n_freq < 16; n_freq++ )
980 : {
981 334704 : if ( fabs( *pit1 ) < mean )
982 : {
983 198380 : *pit1 *= 0.2f;
984 : }
985 334704 : pit1++;
986 : }
987 : }
988 : }
989 :
990 101066 : if ( mode == HARMONIC )
991 : {
992 1101 : L = 2;
993 : }
994 : else
995 : {
996 99965 : L = 1;
997 : }
998 :
999 1508283 : for ( n_band = 0; n_band < SWB_FENV; n_band += L )
1000 : {
1001 1407217 : energy = EPSILON;
1002 33748337 : for ( n_freq = swb_bwe_subband[n_band] + st_offset; n_freq < swb_bwe_subband[n_band + L] + st_offset; n_freq++ )
1003 : {
1004 32341120 : energy += SWB_signal[n_freq] * SWB_signal[n_freq];
1005 : }
1006 :
1007 1407217 : tmp_ener = (float) sqrt( ( swb_bwe_subband[n_band + L] - swb_bwe_subband[n_band] ) / energy );
1008 :
1009 33748337 : for ( n_freq = swb_bwe_subband[n_band] + st_offset; n_freq < swb_bwe_subband[n_band + L] + st_offset; n_freq++ )
1010 : {
1011 32341120 : SWB_signal[n_freq] *= tmp_ener;
1012 : }
1013 : }
1014 :
1015 101066 : if ( *prev_Energy > 1.25f * Energy && Energy > 0 )
1016 : {
1017 15968 : weight = 0.5f * Energy / ( *prev_Energy );
1018 : }
1019 : else
1020 : {
1021 85098 : weight = 0.5f;
1022 : }
1023 :
1024 101066 : wfenv = weight * prev_SWB_fenv[0] + ( 1 - weight ) * SWB_fenv[0];
1025 101066 : factor = fenvL;
1026 101066 : factor1 = ( wfenv - fenvL ) * 0.125f;
1027 909594 : for ( n_freq = swb_bwe_subband[0] + st_offset; n_freq < swb_bwe_subband[0] + 8 + st_offset; n_freq++ )
1028 : {
1029 808528 : SWB_signal[n_freq] *= factor;
1030 808528 : factor += factor1;
1031 : }
1032 :
1033 1313858 : for ( n_band = 0; n_band < 12; n_band++ )
1034 : {
1035 1212792 : wfenv = weight * prev_SWB_fenv[n_band + 1] + ( 1 - weight ) * SWB_fenv[n_band + 1];
1036 1212792 : factor = SWB_fenv[n_band];
1037 1212792 : factor1 = ( wfenv - SWB_fenv[n_band] ) * smooth_factor[n_band];
1038 27894216 : for ( ; n_freq < swb_bwe_sm_subband[n_band + 1] + st_offset; n_freq++ )
1039 : {
1040 26681424 : SWB_signal[n_freq] *= factor;
1041 26681424 : factor += factor1;
1042 : }
1043 : }
1044 :
1045 101066 : wfenv = weight * prev_SWB_fenv[13] + ( 1 - weight ) * SWB_fenv[13];
1046 101066 : factor = SWB_fenv[12];
1047 101066 : factor1 = ( wfenv - SWB_fenv[12] ) * smooth_factor[12];
1048 3335178 : for ( ; n_freq < swb_bwe_sm_subband[13] + st_offset; n_freq++ )
1049 : {
1050 3234112 : SWB_signal[n_freq] *= factor;
1051 3234112 : factor += factor1;
1052 : }
1053 :
1054 202132 : for ( n_band = 13; n_band < SWB_FENV; n_band++ )
1055 : {
1056 101066 : wfenv = weight * prev_SWB_fenv[n_band] + ( 1 - weight ) * SWB_fenv[n_band];
1057 1718122 : for ( ; n_freq < swb_bwe_subband[n_band + 1] + st_offset; n_freq++ )
1058 : {
1059 1617056 : SWB_signal[n_freq] *= wfenv;
1060 : }
1061 : }
1062 :
1063 1515990 : for ( n_band = 0; n_band < SWB_FENV; n_band++ )
1064 : {
1065 1414924 : prev_SWB_fenv[n_band] = SWB_fenv[n_band];
1066 : }
1067 : }
1068 :
1069 101755 : pit1 = &SWB_signal[240 + st_offset];
1070 508775 : for ( n_freq = 0; n_freq < 4; n_freq++ )
1071 : {
1072 407020 : *( pit1++ ) *= 0.5f;
1073 : }
1074 101755 : *prev_Energy = Energy;
1075 :
1076 101755 : return;
1077 : }
1078 :
1079 : /*-------------------------------------------------------------------*
1080 : * time_envelop_shaping()
1081 : *
1082 : * time shaping of the SHB signal
1083 : *-------------------------------------------------------------------*/
1084 :
1085 689 : void time_envelop_shaping(
1086 : float werr[], /* i/o: SHB synthesis */
1087 : float SWB_tenv[], /* i/o: frequency envelope */
1088 : const int16_t L /* i : frame length */
1089 : )
1090 : {
1091 : float *pit;
1092 : float Energy;
1093 : int16_t i, j;
1094 : float tmp_ener;
1095 :
1096 689 : pit = werr;
1097 3445 : for ( i = 0; i < SWB_TENV; i++ )
1098 : {
1099 2756 : Energy = EPSILON;
1100 568196 : for ( j = 0; j < L / 4; j++ )
1101 : {
1102 565440 : Energy += *pit * *pit;
1103 565440 : pit++;
1104 : }
1105 2756 : Energy = (float) sqrt( 4 * Energy / L );
1106 :
1107 2756 : if ( SWB_tenv[i] < 2 && Energy < SWB_tenv[i] )
1108 : {
1109 6 : SWB_tenv[i] = Energy;
1110 : }
1111 :
1112 2756 : pit -= L / 4;
1113 2756 : tmp_ener = 1.0f / Energy;
1114 568196 : for ( j = 0; j < L / 4; j++ )
1115 : {
1116 565440 : *pit *= SWB_tenv[i] * tmp_ener;
1117 565440 : pit++;
1118 : }
1119 : }
1120 :
1121 689 : return;
1122 : }
1123 :
1124 : /*-------------------------------------------------------------------*
1125 : * time_reduce_pre_echo()
1126 : *
1127 : * Pre-echo reduction.
1128 : *-------------------------------------------------------------------*/
1129 :
1130 1031 : void time_reduce_pre_echo(
1131 : const float *synth, /* i : ACELP core synthesis */
1132 : float *error, /* o : SHB BWE synthesis */
1133 : float prev_td_energy, /* o : last td energy */
1134 : const int16_t L /* i : subframe length */
1135 : )
1136 : {
1137 1031 : int16_t i, j, pos = 0;
1138 : float energy;
1139 : float energyL[4];
1140 : float tmp_ener;
1141 : float *pit;
1142 : float tmpi;
1143 :
1144 5155 : for ( i = 0; i < 4; i++ )
1145 : {
1146 4124 : energyL[i] = 0;
1147 898524 : for ( j = 0; j < L; j++ )
1148 : {
1149 894400 : energyL[i] += synth[L * i + j] * synth[L * i + j];
1150 : }
1151 4124 : energyL[i] = (float) sqrt( energyL[i] / L );
1152 : }
1153 :
1154 3950 : for ( i = 0; i < 3; i++ )
1155 : {
1156 3011 : if ( energyL[i + 1] > 1.8f * energyL[i] && energyL[i + 1] > 50 )
1157 : {
1158 92 : pos = i + 1;
1159 92 : break;
1160 : }
1161 : }
1162 :
1163 1031 : if ( pos > 0 )
1164 : {
1165 92 : if ( pos < 3 )
1166 : {
1167 63 : pos++;
1168 : }
1169 :
1170 92 : energy = EPSILON;
1171 92 : j = L * pos;
1172 61772 : for ( i = 0; i < j; i++ )
1173 : {
1174 61680 : energy += error[i] * error[i];
1175 : }
1176 92 : energy = (float) sqrt( energy / j );
1177 :
1178 92 : if ( prev_td_energy < 0.2f * energy )
1179 : {
1180 73 : prev_td_energy = 0.2f * energy;
1181 : }
1182 :
1183 92 : tmp_ener = prev_td_energy / energy;
1184 61772 : for ( i = 0; i < j; i++ )
1185 : {
1186 61680 : error[i] *= tmp_ener;
1187 : }
1188 :
1189 92 : energy = EPSILON;
1190 22172 : for ( i = j; i < ( j + L ); i++ )
1191 : {
1192 22080 : energy += error[i] * error[i];
1193 : }
1194 92 : energy = (float) sqrt( energy / L );
1195 :
1196 92 : pit = &error[j];
1197 92 : tmp_ener = prev_td_energy / energy;
1198 22172 : for ( i = 0; i < L; i++ )
1199 : {
1200 22080 : tmpi = i / ( 1.0f * L );
1201 22080 : *pit++ *= ( ( 1.0f - tmpi ) * tmp_ener + tmpi );
1202 : }
1203 : }
1204 :
1205 1031 : return;
1206 : }
1207 :
1208 : /*-------------------------------------------------------------------*
1209 : * hq_generic_hf_decoding()
1210 : *
1211 : *-------------------------------------------------------------------*/
1212 14612 : void hq_generic_hf_decoding(
1213 : const int16_t HQ_mode, /* i : HQ mode */
1214 : float *coeff_out1, /* i/o: BWE input & temporary buffer */
1215 : const float *hq_generic_fenv, /* i : SWB frequency envelopes */
1216 : float *coeff_out, /* o : SWB signal in MDCT domain */
1217 : const int16_t hq_generic_offset, /* i : frequency offset for representing hq swb bwe*/
1218 : int16_t *prev_L_swb_norm, /* i/o: last normalize length */
1219 : const int16_t hq_generic_exc_clas, /* i : bwe excitation class */
1220 : const int16_t *R )
1221 : {
1222 : int16_t i, n_freq, n_band, L_swb_norm;
1223 : float fenvL, energy, wfenv, factor;
1224 : float envelope[L_FRAME16k];
1225 : float *pit1;
1226 : float tmp1, tmp2, tmp3, tmp4;
1227 : float mean_vector[20];
1228 : int16_t k;
1229 : int16_t nenv;
1230 : int16_t tenv;
1231 : float rn_weight0;
1232 : int16_t blen, nband_lf, sfidx, efidx;
1233 : int16_t bwe_seed;
1234 : int16_t signum[L_FRAME16k];
1235 :
1236 14612 : if ( hq_generic_offset <= HQ_GENERIC_FOFFSET_24K4 )
1237 : {
1238 14612 : nenv = SWB_FENV;
1239 : }
1240 : else
1241 : {
1242 0 : nenv = SWB_FENV - 2;
1243 : }
1244 :
1245 14612 : if ( HQ_mode == HQ_GEN_FB )
1246 : {
1247 10223 : tenv = nenv + DIM_FB;
1248 : }
1249 : else
1250 : {
1251 4389 : tenv = nenv;
1252 : }
1253 :
1254 14612 : fenvL = EPSILON;
1255 248404 : for ( n_freq = HQ_GENERIC_ST_FREQ + hq_generic_offset; n_freq < swb_bwe_subband[0] + hq_generic_offset; n_freq++ )
1256 : {
1257 233792 : fenvL += coeff_out1[n_freq] * coeff_out1[n_freq];
1258 : }
1259 :
1260 14612 : fenvL = (float) sqrt( fenvL / 16 );
1261 :
1262 14612 : calc_normal_length( HQ_CORE, coeff_out1, HQ_GEN_SWB, -1, &L_swb_norm, prev_L_swb_norm );
1263 :
1264 : /* calculate envelope */
1265 14612 : calc_norm_envelop_lf( coeff_out1, envelope, &L_swb_norm, HQ_mode, hq_generic_offset, &sfidx, &efidx );
1266 :
1267 14612 : blen = 16;
1268 14612 : if ( hq_generic_exc_clas == HQ_GENERIC_EXC0 )
1269 : {
1270 13456 : rn_weight0 = 0.8f;
1271 : }
1272 1156 : else if ( hq_generic_exc_clas == HQ_GENERIC_EXC1 )
1273 : {
1274 51 : rn_weight0 = 0.05f;
1275 : }
1276 : else
1277 : {
1278 1105 : rn_weight0 = 0.2f;
1279 : }
1280 :
1281 14612 : nband_lf = ( efidx - sfidx ) / blen;
1282 3754420 : for ( n_freq = sfidx; n_freq < efidx; n_freq++ )
1283 : {
1284 3739808 : if ( coeff_out1[n_freq] < 0 )
1285 : {
1286 1854741 : signum[n_freq] = -1;
1287 1854741 : coeff_out1[n_freq] *= signum[n_freq];
1288 : }
1289 : else
1290 : {
1291 1885067 : signum[n_freq] = 1;
1292 : }
1293 : }
1294 :
1295 : /* applying whitening */
1296 3754420 : for ( n_freq = sfidx; n_freq < efidx; n_freq++ )
1297 : {
1298 3739808 : coeff_out1[n_freq] = coeff_out1[n_freq] / envelope[n_freq];
1299 : }
1300 :
1301 : /* mean vector generation for controlling dynamic range */
1302 248350 : for ( k = 0; k < nband_lf; ++k )
1303 : {
1304 233738 : energy = EPSILON;
1305 3973546 : for ( i = k * blen + sfidx; i < ( k + 1 ) * blen + sfidx; ++i )
1306 : {
1307 3739808 : energy += coeff_out1[i];
1308 : }
1309 233738 : mean_vector[k] = energy / blen;
1310 : }
1311 :
1312 : /* dynamic range control */
1313 248350 : for ( k = 0; k < nband_lf; ++k )
1314 : {
1315 3973546 : for ( i = k * blen + sfidx; i < ( k + 1 ) * blen + sfidx; ++i )
1316 : {
1317 3739808 : coeff_out1[i] = coeff_out1[i] - ( coeff_out1[i] - mean_vector[k] ) * rn_weight0;
1318 : }
1319 : }
1320 :
1321 14612 : if ( hq_generic_exc_clas == HQ_GENERIC_EXC0 )
1322 : {
1323 : /* applying random sign */
1324 13456 : bwe_seed = R[0] * 8 + R[1] * 4 + R[2] * 2 + R[3];
1325 3486640 : for ( n_freq = sfidx; n_freq < efidx; n_freq++ )
1326 : {
1327 3473184 : coeff_out1[n_freq] = coeff_out1[n_freq] * signum[n_freq] * ( own_random( &bwe_seed ) > 0 ? 1.0f : -1.0f );
1328 : }
1329 : }
1330 : else
1331 : {
1332 267780 : for ( n_freq = sfidx; n_freq < efidx; n_freq++ )
1333 : {
1334 266624 : coeff_out1[n_freq] = coeff_out1[n_freq] * signum[n_freq];
1335 : }
1336 : }
1337 :
1338 : /* normalizing modified low frequency spectrum */
1339 248350 : for ( k = 0; k < nband_lf; ++k )
1340 : {
1341 233738 : energy = EPSILON;
1342 3973546 : for ( i = k * blen + sfidx; i < ( k + 1 ) * blen + sfidx; ++i )
1343 : {
1344 3739808 : energy += coeff_out1[i] * coeff_out1[i];
1345 : }
1346 233738 : energy = (float) sqrt( energy / blen );
1347 :
1348 3973546 : for ( i = k * blen + sfidx; i < ( k + 1 ) * blen + sfidx; ++i )
1349 : {
1350 3739808 : coeff_out1[i] /= energy;
1351 : }
1352 : }
1353 14612 : mvr2r( coeff_out1 + HQ_GENERIC_OFFSET, &coeff_out[HQ_GENERIC_HIGH0 + hq_generic_offset], HQ_GENERIC_LEN0 );
1354 14612 : mvr2r( coeff_out1 + HQ_GENERIC_OFFSET, &coeff_out[HQ_GENERIC_HIGH1 + hq_generic_offset], HQ_GENERIC_LEN0 );
1355 :
1356 14612 : if ( hq_generic_offset <= HQ_GENERIC_FOFFSET_24K4 )
1357 : {
1358 14612 : mvr2r( &coeff_out1[HQ_GENERIC_LOW0], &coeff_out[HQ_GENERIC_HIGH2 + hq_generic_offset], HQ_GENERIC_END_FREQ - HQ_GENERIC_HIGH2 );
1359 : }
1360 :
1361 14612 : if ( HQ_mode == HQ_GEN_FB )
1362 : {
1363 10223 : if ( hq_generic_offset <= HQ_GENERIC_FOFFSET_24K4 )
1364 : {
1365 10223 : mvr2r( coeff_out1 + HQ_GENERIC_LOW0 + HQ_GENERIC_END_FREQ - HQ_GENERIC_HIGH2, &coeff_out[fb_bwe_subband[0]], 160 );
1366 : }
1367 : else
1368 : {
1369 0 : mvr2r( coeff_out1 + HQ_GENERIC_OFFSET + HQ_GENERIC_LEN0, &coeff_out[fb_bwe_subband[0]], 160 );
1370 : }
1371 : }
1372 14612 : tmp1 = EPSILON;
1373 14612 : tmp2 = EPSILON;
1374 87672 : for ( i = 0; i < 5; ++i )
1375 : {
1376 73060 : tmp1 += (float) fabs( coeff_out[HQ_GENERIC_HIGH1 + hq_generic_offset + i] );
1377 73060 : tmp2 += (float) fabs( coeff_out[HQ_GENERIC_HIGH1 - 2 + hq_generic_offset - i] );
1378 : }
1379 :
1380 14612 : pit1 = &coeff_out[HQ_GENERIC_HIGH1 + hq_generic_offset];
1381 14612 : tmp3 = tmp2 / tmp1;
1382 14612 : if ( tmp3 < 0.3f )
1383 : {
1384 0 : tmp3 = 0.3f;
1385 : }
1386 :
1387 24580 : while ( tmp3 < 1 )
1388 : {
1389 9968 : *pit1++ *= tmp3;
1390 9968 : tmp3 += 0.1f;
1391 : }
1392 :
1393 14612 : pit1 = &coeff_out[HQ_GENERIC_HIGH1 - 1 + hq_generic_offset];
1394 14612 : tmp3 = tmp1 / tmp2;
1395 14612 : if ( tmp3 > 5 )
1396 : {
1397 0 : tmp3 = 5;
1398 0 : while ( tmp3 > 1 )
1399 : {
1400 0 : *pit1-- *= tmp3;
1401 0 : tmp3 -= 0.5f;
1402 : }
1403 : }
1404 :
1405 14612 : if ( hq_generic_offset <= HQ_GENERIC_FOFFSET_24K4 )
1406 : {
1407 14612 : tmp1 = (float) ( fabs( coeff_out[HQ_GENERIC_HIGH2 + hq_generic_offset] ) + fabs( coeff_out[HQ_GENERIC_HIGH2 + 1 + hq_generic_offset] ) ) + EPSILON;
1408 14612 : tmp2 = (float) ( fabs( coeff_out[HQ_GENERIC_HIGH2 - 4 + hq_generic_offset] ) + fabs( coeff_out[HQ_GENERIC_HIGH2 - 3 + hq_generic_offset] ) + fabs( coeff_out[HQ_GENERIC_HIGH2 - 2 + hq_generic_offset] ) + fabs( coeff_out[HQ_GENERIC_HIGH2 - 1 + hq_generic_offset] ) ) +
1409 : EPSILON;
1410 :
1411 14612 : pit1 = &coeff_out[HQ_GENERIC_HIGH2 + hq_generic_offset];
1412 14612 : tmp3 = tmp2 / tmp1;
1413 14612 : if ( tmp3 < 0.3f )
1414 : {
1415 0 : tmp3 = 0.3f;
1416 : }
1417 :
1418 14651 : while ( tmp3 < 1 )
1419 : {
1420 39 : *pit1++ *= tmp3;
1421 39 : tmp3 += 0.1f;
1422 : }
1423 :
1424 14612 : pit1 = &coeff_out[HQ_GENERIC_HIGH2 - 1 + hq_generic_offset];
1425 14612 : tmp3 = tmp1 / tmp2;
1426 14612 : tmp3 = 0.5f * tmp3;
1427 14612 : tmp4 = 0.05f * tmp3;
1428 14612 : while ( tmp3 > 1 )
1429 : {
1430 0 : *pit1-- *= tmp3;
1431 0 : tmp3 -= tmp4;
1432 : }
1433 : }
1434 :
1435 14612 : wfenv = hq_generic_fenv[0];
1436 131508 : for ( n_freq = swb_bwe_subband[0] + hq_generic_offset, i = 0; n_freq < swb_bwe_subband[0] + hq_generic_offset + 8; n_freq++, i++ )
1437 : {
1438 116896 : factor = i * 0.125f;
1439 116896 : coeff_out[n_freq] *= ( ( 1 - factor ) * fenvL + factor * wfenv );
1440 : }
1441 :
1442 189956 : for ( n_band = 0; n_band < nenv - 2; n_band++ )
1443 : {
1444 175344 : wfenv = hq_generic_fenv[n_band + 1];
1445 4032912 : for ( i = 0; n_freq < swb_bwe_sm_subband[n_band + 1] + hq_generic_offset; n_freq++, i++ )
1446 : {
1447 3857568 : factor = i * smooth_factor[n_band];
1448 3857568 : coeff_out[n_freq] *= ( ( 1 - factor ) * hq_generic_fenv[n_band] + factor * wfenv );
1449 : }
1450 : }
1451 :
1452 14612 : wfenv = hq_generic_fenv[nenv - 1];
1453 482196 : for ( i = 0; n_freq < swb_bwe_sm_subband[nenv - 1] + hq_generic_offset; n_freq++, i++ )
1454 : {
1455 467584 : factor = i * smooth_factor[nenv - 2];
1456 :
1457 467584 : coeff_out[n_freq] *= ( ( 1 - factor ) * hq_generic_fenv[nenv - 2] + factor * wfenv );
1458 : }
1459 :
1460 14612 : if ( HQ_mode == HQ_GEN_SWB )
1461 : {
1462 8778 : for ( n_band = nenv - 1; n_band < nenv; ++n_band )
1463 : {
1464 4389 : wfenv = hq_generic_fenv[n_band];
1465 74613 : for ( ; n_freq < swb_bwe_subband[n_band + 1] + hq_generic_offset; n_freq++ )
1466 : {
1467 70224 : coeff_out[n_freq] *= wfenv;
1468 : }
1469 : }
1470 : }
1471 : else
1472 : {
1473 10223 : if ( hq_generic_fenv[nenv - 1] - hq_generic_fenv[nenv] > 15.f || hq_generic_fenv[nenv] < 5.f )
1474 : {
1475 7992 : wfenv = hq_generic_fenv[nenv - 1];
1476 135864 : for ( i = 0; n_freq < fb_bwe_subband[0]; n_freq++, i++ )
1477 : {
1478 127872 : coeff_out[n_freq] *= wfenv;
1479 : }
1480 :
1481 31968 : for ( n_band = 0; n_band < DIM_FB; n_band++ )
1482 : {
1483 23976 : wfenv = hq_generic_fenv[n_band + nenv];
1484 1302696 : for ( i = 0; n_freq < fb_bwe_subband[n_band + 1]; n_freq++, i++ )
1485 : {
1486 1278720 : coeff_out[n_freq] *= wfenv;
1487 : }
1488 : }
1489 : }
1490 : else
1491 : {
1492 8924 : for ( n_band = 0; n_band < DIM_FB; n_band++ )
1493 : {
1494 6693 : wfenv = hq_generic_fenv[n_band + nenv - 1];
1495 :
1496 310109 : for ( i = 0; n_freq < fb_bwe_sm_subband[n_band]; n_freq++, i++ )
1497 : {
1498 303416 : factor = i * fb_smooth_factor[n_band];
1499 303416 : coeff_out[n_freq] *= ( ( 1 - factor ) * hq_generic_fenv[n_band + nenv] + factor * wfenv );
1500 : }
1501 : }
1502 :
1503 2231 : wfenv = hq_generic_fenv[tenv - 1];
1504 :
1505 91471 : for ( ; n_freq < fb_bwe_subband[DIM_FB]; n_freq++ )
1506 : {
1507 89240 : coeff_out[n_freq] *= wfenv;
1508 : }
1509 : }
1510 : }
1511 14612 : return;
1512 : }
1513 :
1514 :
1515 : /*-------------------------------------------------------------------*
1516 : * save_old_syn()
1517 : *
1518 : * Save and delay the ACELP core synthesis signal by
1519 : * DELAY_FD_BWE_ENC_xxkx to be used by SWB BWE
1520 : *-------------------------------------------------------------------*/
1521 :
1522 1985273 : void save_old_syn(
1523 : const int16_t L_frame, /* i : frame length */
1524 : const float syn[], /* i : ACELP synthesis */
1525 : float old_syn[], /* o : old synthesis buffer */
1526 : float old_syn_mem[], /* i/o: old synthesis buffer memory */
1527 : const float preemph_fac, /* i : preemphasis factor */
1528 : float *mem_deemph /* i/o: deemphasis filter memory */
1529 : )
1530 : {
1531 : int16_t tmps;
1532 :
1533 1985273 : if ( L_frame == L_FRAME )
1534 : {
1535 1170252 : tmps = NS2SA( 12800, DELAY_FD_BWE_ENC_12k8_NS );
1536 : }
1537 : else
1538 : {
1539 815021 : tmps = NS2SA( 16000, DELAY_FD_BWE_ENC_16k_NS );
1540 : }
1541 :
1542 1985273 : mvr2r( old_syn_mem, old_syn, tmps );
1543 1985273 : mvr2r( syn, old_syn + tmps, L_frame - tmps );
1544 1985273 : mvr2r( syn + L_frame - tmps, old_syn_mem, tmps );
1545 :
1546 1985273 : deemph( old_syn, preemph_fac, L_frame, mem_deemph );
1547 :
1548 1985273 : return;
1549 : }
|
