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 15189 : 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 15189 : float enerL, alfa = 1.0f;
68 : int16_t n_freq, mode;
69 15189 : int16_t ener_var_flag = 0;
70 : float voice_factor, pitch;
71 15189 : int16_t env_var_flag = 0;
72 :
73 15189 : mode = NORMAL;
74 :
75 15189 : enerL = EPSILON;
76 987285 : for ( n_freq = 128; n_freq < 192; n_freq++ )
77 : {
78 972096 : enerL += core_dec_freq[n_freq] * core_dec_freq[n_freq];
79 : }
80 15189 : WB_fenv[0] = EPSILON;
81 501237 : for ( n_freq = 192; n_freq < 224; n_freq++ )
82 : {
83 486048 : WB_fenv[0] += core_dec_freq[n_freq] * core_dec_freq[n_freq];
84 : }
85 :
86 15189 : WB_fenv[1] = EPSILON;
87 501237 : for ( n_freq = 224; n_freq < 256; n_freq++ )
88 : {
89 486048 : WB_fenv[1] += core_dec_freq[n_freq] * core_dec_freq[n_freq];
90 : }
91 :
92 15189 : voice_factor = sum_f( voice_factors, 4 );
93 15189 : pitch = sum_f( pitch_buf, 4 ) + EPSILON;
94 :
95 15189 : if ( enerL < 16.0f * max( WB_fenv[0], WB_fenv[1] ) && pitch < 308 )
96 : {
97 14139 : ener_var_flag = 1;
98 : }
99 :
100 15189 : if ( WB_fenv[0] > 2.0f * WB_fenv[1] )
101 : {
102 975 : alfa = max( 2.0f * WB_fenv[1] / WB_fenv[0], 0.1f );
103 975 : WB_fenv[0] *= alfa;
104 : }
105 14214 : else if ( 2.0f * WB_fenv[0] < WB_fenv[1] && coder_type != UNVOICED )
106 : {
107 11241 : alfa = max( 2.0f * WB_fenv[0] / WB_fenv[1], 0.1f );
108 11241 : WB_fenv[1] *= alfa;
109 : }
110 :
111 15189 : WB_fenv[0] = (float) sqrt( ( WB_fenv[0] + WB_fenv[1] ) / 64 );
112 :
113 15189 : if ( coder_type != AUDIO && coder_type != UNVOICED && ener_var_flag == 0 )
114 : {
115 1050 : WB_fenv[0] *= 1.5f;
116 : }
117 :
118 15189 : 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 15189 : alfa = min( 1.5f, max( 0.5f, 77.0f * voice_factor / pitch ) );
130 15189 : 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 84 : env_var_flag = 1;
133 84 : WB_fenv[0] *= min( (float) ( 0.015625f * sqrt( enerL ) / WB_fenv[0] ), 4.0f );
134 :
135 84 : if ( WB_fenv[0] > prev_WB_fenv )
136 : {
137 78 : WB_fenv[0] = 0.3f * WB_fenv[0] + 0.7f * prev_WB_fenv;
138 : }
139 : }
140 :
141 15189 : if ( coder_type == UNVOICED || prev_coder_type == UNVOICED )
142 : {
143 156 : WB_fenv[0] *= 0.5f;
144 : }
145 :
146 15189 : if ( coder_type != AUDIO )
147 : {
148 15189 : WB_fenv[0] /= max( 1.2f * voice_factor, 1.0f );
149 15189 : WB_fenv[0] *= min( 2.0f, max( 0.125f, pitch / 400.0f ) );
150 : }
151 :
152 15189 : if ( last_core_brate > ACELP_8k00 && WB_fenv[0] > last_wb_bwe_ener )
153 : {
154 2133 : WB_fenv[0] = 0.9f * last_wb_bwe_ener + 0.1f * WB_fenv[0];
155 : }
156 :
157 15189 : if ( last_extl != WB_BWE && ( tilt < 8.f ) )
158 : {
159 120 : WB_fenv[0] *= min( 0.5f, 16.0f * tilt );
160 : }
161 :
162 15189 : if ( env_var_flag == 1 )
163 : {
164 84 : WB_fenv[1] = 1.5f * WB_fenv[0];
165 84 : WB_fenv[0] *= 0.75f;
166 : }
167 : else
168 : {
169 15105 : WB_fenv[1] = WB_fenv[0];
170 : }
171 :
172 15189 : if ( coder_type == UNVOICED || prev_coder_type == UNVOICED )
173 : {
174 156 : WB_fenv[1] *= 0.5f;
175 : }
176 :
177 15189 : return ( mode );
178 : }
179 :
180 : /*-------------------------------------------------------------------*
181 : * calc_normal_length()
182 : *
183 : *-------------------------------------------------------------------*/
184 :
185 107147 : 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 107147 : if ( core == HQ_CORE || extl == SWB_BWE || extl == FB_BWE )
201 : {
202 65760 : THRES = 8;
203 : }
204 : else
205 : {
206 41387 : THRES = 4;
207 : }
208 :
209 107147 : if ( core == HQ_CORE && ( mode == HQ_HARMONIC || mode == HQ_HVQ ) )
210 : {
211 6219 : N = 13;
212 : }
213 : else
214 : {
215 100928 : N = 16;
216 : }
217 :
218 107147 : n_band = 0;
219 107147 : pit = sp;
220 1802842 : for ( i = 0; i < N; i++ )
221 : {
222 1695695 : peak = 0.0f;
223 1695695 : mean = 0;
224 :
225 28826815 : for ( n_freq = 0; n_freq < 16; n_freq++ )
226 : {
227 27131120 : mag = (float) fabs( *pit );
228 27131120 : if ( mag > peak )
229 : {
230 5813924 : peak = mag;
231 : }
232 27131120 : mean += mag;
233 27131120 : pit++;
234 : }
235 :
236 1695695 : if ( ( 15 + THRES ) * peak > THRES * mean && peak > 10 )
237 : {
238 202736 : n_band += 1;
239 : }
240 : }
241 :
242 107147 : if ( core == ACELP_CORE )
243 : {
244 88856 : L_swb_norm_trans = (int16_t) ( 4 + 0.25f * n_band );
245 88856 : L_swb_norm_norm = (int16_t) ( 8 + 0.5f * n_band );
246 88856 : L_swb_norm_harm = max( (int16_t) ( 32 + 2.0f * n_band ), 24 );
247 :
248 88856 : if ( mode == HARMONIC )
249 : {
250 6967 : L_swb_norm_cur = L_swb_norm_harm;
251 : }
252 81889 : else if ( mode == NORMAL )
253 : {
254 78402 : L_swb_norm_cur = L_swb_norm_norm;
255 : }
256 : else
257 : {
258 3487 : L_swb_norm_cur = L_swb_norm_trans;
259 : }
260 :
261 88856 : *L_swb_norm = (int16_t) ( 0.5f * L_swb_norm_cur + 0.5f * ( *prev_L_swb_norm ) );
262 88856 : *prev_L_swb_norm = L_swb_norm_cur;
263 : }
264 : else
265 : {
266 18291 : if ( mode == HQ_HARMONIC || mode == HQ_HVQ )
267 : {
268 6219 : L_swb_norm_cur = (int16_t) ( 32 + 2.5f * n_band );
269 : }
270 : else
271 : {
272 12072 : L_swb_norm_cur = (int16_t) ( 8 + 0.5f * n_band );
273 : }
274 :
275 18291 : *L_swb_norm = (int16_t) ( 0.1f * L_swb_norm_cur + 0.9f * ( *prev_L_swb_norm ) + 0.5f );
276 18291 : *prev_L_swb_norm = L_swb_norm_cur;
277 : }
278 :
279 107147 : return;
280 : }
281 : /*-------------------------------------------------------------------*
282 : * calc_tilt_bwe()
283 : *
284 : * calculate tilt parameter
285 : *-------------------------------------------------------------------*/
286 :
287 1404150 : 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 1404150 : r0 = EPSILON;
297 582222966 : for ( i = 0; i < N; i++ )
298 : {
299 580818816 : r0 += sp[i] * sp[i];
300 : }
301 :
302 1404150 : r1 = (float) fabs( sp[1] - sp[0] );
303 579414666 : for ( i = 2; i < N; i++ )
304 : {
305 578010516 : if ( ( sp[i] - sp[i - 1] ) * ( sp[i - 1] - sp[i - 2] ) < 0 )
306 : {
307 158156185 : r1 += (float) fabs( sp[i] - sp[i - 1] );
308 : }
309 : }
310 :
311 1404150 : *tilt = (float) ( r1 / sqrt( r0 ) );
312 :
313 1404150 : return;
314 : }
315 :
316 : /*-------------------------------------------------------------------*
317 : * calc_norm_envelop()
318 : *
319 : * calculate normalized parameter
320 : *-------------------------------------------------------------------*/
321 :
322 88835 : 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 88835 : lookback = L_swb_norm / 2;
333 88835 : env_index = swb_bwe_subband[0] + st_offset;
334 88835 : n_lag_now = L_swb_norm;
335 20402543 : 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 20313708 : envelope[env_index] = EPSILON;
339 207048919 : for ( n_lag = 0; n_lag < n_lag_now; n_lag++ )
340 : {
341 186735211 : envelope[env_index] += (float) fabs( SWB_signal[n_freq + n_lag] );
342 : }
343 20313708 : env_index++;
344 : }
345 :
346 596487 : for ( n_freq = SWB_flength + st_offset - L_swb_norm, i = 0; n_freq < SWB_flength + st_offset - lookback; n_freq++, i++ )
347 : {
348 507652 : n_lag_now = L_swb_norm - i;
349 : /* Apply MA filter */
350 507652 : envelope[env_index] = EPSILON;
351 8525260 : for ( n_lag = 0; n_lag < n_lag_now; n_lag++ )
352 : {
353 8017608 : envelope[env_index] += (float) fabs( SWB_signal[n_freq + n_lag] );
354 : }
355 507652 : env_index++;
356 : }
357 :
358 88835 : return;
359 : }
360 :
361 :
362 : /*-------------------------------------------------------------------*
363 : * calc_norm_envelop_lf()
364 : *
365 : * calc_envelope of low frequency spectrum
366 : *-------------------------------------------------------------------*/
367 9003 : 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 9003 : *sfreq = 2;
379 9003 : if ( hq_generic_offset == HQ_GENERIC_FOFFSET_24K4 )
380 : {
381 9003 : *efreq = 146;
382 9003 : if ( HQ_mode == HQ_GEN_FB )
383 : {
384 6765 : *efreq = 306;
385 : }
386 9003 : if ( ( 328 - *efreq ) * 2 + 1 < *L_swb_norm )
387 : {
388 117 : *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 9003 : lookback = *L_swb_norm / 2;
405 9003 : env_index = 0;
406 9003 : n_lag_now = *L_swb_norm;
407 62037 : for ( n_freq = 0; n_freq < lookback; n_freq++ )
408 : {
409 53034 : envelope[env_index] = EPSILON;
410 879933 : for ( n_lag = 0; n_lag < lookback + n_freq; n_lag++ )
411 : {
412 826899 : envelope[env_index] += (float) fabs( SWB_signal[n_lag] );
413 : }
414 53034 : env_index++;
415 : }
416 2352807 : for ( ; n_freq < *efreq; n_freq++ )
417 : {
418 : /* Apply MA filter */
419 2343804 : envelope[env_index] = EPSILON;
420 29527077 : for ( n_lag = 0; n_lag < n_lag_now; n_lag++ )
421 : {
422 27183273 : envelope[env_index] += (float) fabs( SWB_signal[n_freq - lookback + n_lag] );
423 : }
424 2343804 : env_index++;
425 : }
426 9003 : return;
427 : }
428 :
429 : /*-------------------------------------------------------------------*
430 : * WB_BWE_decoding()
431 : *
432 : * WB BWE decoder
433 : *-------------------------------------------------------------------*/
434 :
435 27591 : 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 27591 : int16_t flag = 0;
461 27591 : int16_t core_type = 1;
462 : int16_t signum[L_FRAME16k];
463 : float inv_L_wb_norm, weight;
464 :
465 27591 : calc_normal_length( ACELP_CORE, core_dec_freq, mode, extl, &L_wb_norm, prev_L_wb_norm );
466 :
467 27591 : set_f( WB_signal, 0, L_FRAME16k );
468 :
469 : /* copy excitation */
470 27591 : if ( coder_type != AUDIO && total_brate <= ACELP_8k00 )
471 : {
472 13161 : core_type = 0;
473 : }
474 :
475 27591 : if ( core_type == 0 )
476 : {
477 13161 : mvr2r( &core_dec_freq[160], &WB_signal[240], 80 );
478 : }
479 : else
480 : {
481 14430 : mvr2r( &core_dec_freq[80], &WB_signal[240], 80 );
482 : }
483 :
484 : /* calculate envelope */
485 27591 : calc_norm_envelop( WB_signal, envelope, L_wb_norm, WB_flength, 0 );
486 :
487 27591 : if ( coder_type != UNVOICED && total_brate <= ACELP_8k00 )
488 : {
489 24108 : inv_L_wb_norm = 1.0f / L_wb_norm;
490 24108 : weight = ( mode != HARMONIC ) ? max( min( 3.0f * inv_L_wb_norm, 0.5f ), 0.25f ) : 0.25f;
491 1952748 : for ( n_freq = swb_bwe_subband[0]; n_freq < swb_bwe_subband[4]; n_freq++ )
492 : {
493 1928640 : signum[n_freq] = 1;
494 1928640 : if ( WB_signal[n_freq] < 0 )
495 : {
496 964815 : signum[n_freq] = -1;
497 964815 : WB_signal[n_freq] *= signum[n_freq];
498 : }
499 :
500 1928640 : WB_signal[n_freq] = WB_signal[n_freq] - 0.45f * envelope[n_freq] * inv_L_wb_norm;
501 1928640 : if ( WB_signal[n_freq] > 0 )
502 : {
503 1435041 : WB_signal[n_freq] *= ( 0.55f - weight );
504 : }
505 1928640 : WB_signal[n_freq] *= signum[n_freq];
506 : }
507 : }
508 :
509 : /* Normalize with envelope */
510 2234871 : for ( n_freq = swb_bwe_subband[0]; n_freq < swb_bwe_subband[4]; n_freq++ )
511 : {
512 2207280 : WB_signal[n_freq] /= envelope[n_freq];
513 : }
514 :
515 27591 : if ( mode == HARMONIC )
516 : {
517 4404 : L = 4;
518 : }
519 : else
520 : {
521 23187 : L = 1;
522 : }
523 :
524 27591 : if ( coder_type == UNVOICED )
525 : {
526 11178 : for ( n_freq = swb_bwe_subband[0]; n_freq < swb_bwe_subband[4]; n_freq++ )
527 : {
528 11040 : *Seed = (int16_t) ( 12345 * ( *Seed ) + 20101 );
529 11040 : WB_signal[n_freq] = ( *Seed ) / PCM16_TO_FLT_FAC;
530 : }
531 : }
532 : else
533 : {
534 124053 : for ( n_band = 0; n_band < 4; n_band += L )
535 : {
536 96600 : energy = EPSILON;
537 2292840 : for ( n_freq = swb_bwe_subband[n_band]; n_freq < swb_bwe_subband[n_band + L]; n_freq++ )
538 : {
539 2196240 : energy += WB_signal[n_freq] * WB_signal[n_freq];
540 : }
541 :
542 96600 : energy = (float) sqrt( ( swb_bwe_subband[n_band + L] - swb_bwe_subband[n_band] ) / energy );
543 :
544 2292840 : for ( n_freq = swb_bwe_subband[n_band]; n_freq < swb_bwe_subband[n_band + L]; n_freq++ )
545 : {
546 2196240 : WB_signal[n_freq] *= energy;
547 : }
548 : }
549 : }
550 :
551 :
552 27591 : EnergyL = 0.0f;
553 27591 : if ( core_type == 1 )
554 : {
555 14430 : if ( prev_coder_type != AUDIO && total_brate <= ACELP_8k00 )
556 : {
557 14580 : for ( i = 160; i < 240; i++ )
558 : {
559 14400 : EnergyL += (float) fabs( core_dec_freq[i] );
560 : }
561 : }
562 : else
563 : {
564 2294250 : for ( i = 80; i < 240; i++ )
565 : {
566 2280000 : EnergyL += (float) fabs( core_dec_freq[i] );
567 : }
568 : }
569 :
570 14430 : if ( total_brate <= ACELP_8k00 )
571 : {
572 11031 : alfa = 0.8f;
573 11031 : beta = 1.25f;
574 : }
575 : else
576 : {
577 3399 : alfa = 0.5f;
578 3399 : beta = 2.0f;
579 : }
580 : }
581 : else
582 : {
583 13161 : 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 1065069 : for ( i = 160; i < 240; i++ )
593 : {
594 1051920 : EnergyL += (float) fabs( core_dec_freq[i] );
595 : }
596 : }
597 :
598 13161 : if ( prev_coder_type == coder_type && WB_fenv[0] > prev_WB_fenv[0] )
599 : {
600 6798 : alfa = 0.4f;
601 6798 : beta = 2.5f;
602 : }
603 : else
604 : {
605 6363 : alfa = 0.6f;
606 6363 : beta = 1.67f;
607 : }
608 :
609 13161 : if ( coder_type == GENERIC || ( EnergyL > 0.5f * ( *prev_Energy ) && EnergyL < 2.0f * ( *prev_Energy ) && *prev_flag == 1 ) )
610 : {
611 168 : WB_fenv[0] *= 0.5f;
612 168 : WB_fenv[1] *= 0.5f;
613 168 : flag = 1;
614 : }
615 : }
616 27591 : if ( ( mode == HARMONIC && WB_fenv[1] < 0.25f * WB_fenv[0] ) || mode == NORMAL )
617 : {
618 23259 : 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 23235 : 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 3516 : wfenv[0] = 0.3f * WB_fenv[0] + 0.7f * prev_WB_fenv[0];
634 3516 : wfenv[1] = 0.3f * WB_fenv[1] + 0.7f * prev_WB_fenv[1];
635 : }
636 19719 : else if ( last_extl == WB_BWE && EnergyL > alfa * ( *prev_Energy ) && EnergyL < beta * ( *prev_Energy ) && prev_coder_type != UNVOICED )
637 : {
638 11406 : wfenv[0] = 0.5f * ( WB_fenv[0] + prev_WB_fenv[0] );
639 11406 : wfenv[1] = 0.5f * ( WB_fenv[1] + prev_WB_fenv[1] );
640 : }
641 : else
642 : {
643 8313 : wfenv[0] = WB_fenv[0];
644 8313 : wfenv[1] = WB_fenv[1];
645 : }
646 953619 : for ( n_freq = swb_bwe_subband[0]; n_freq < swb_bwe_subband[2]; n_freq++ )
647 : {
648 930360 : WB_signal[n_freq] *= wfenv[0];
649 : }
650 :
651 953619 : for ( n_freq = swb_bwe_subband[2]; n_freq < swb_bwe_subband[4]; n_freq++ )
652 : {
653 930360 : WB_signal[n_freq] *= wfenv[1];
654 : }
655 :
656 23259 : prev_WB_fenv[0] = wfenv[0];
657 23259 : prev_WB_fenv[1] = wfenv[1];
658 : }
659 : else
660 : {
661 4332 : wfenv[0] = 0.5f * ( WB_fenv[0] + WB_fenv[1] );
662 :
663 4332 : if ( last_extl == WB_BWE && EnergyL > 0.5f * ( *prev_Energy ) && EnergyL < 2.0f * ( *prev_Energy ) )
664 : {
665 4200 : wfenv[0] = 0.25f * wfenv[0] + 0.375f * ( prev_WB_fenv[0] + prev_WB_fenv[1] );
666 : }
667 350892 : for ( n_freq = swb_bwe_subband[0]; n_freq < swb_bwe_subband[4]; n_freq++ )
668 : {
669 346560 : WB_signal[n_freq] *= wfenv[0];
670 : }
671 :
672 4332 : prev_WB_fenv[0] = wfenv[0];
673 4332 : prev_WB_fenv[1] = wfenv[0];
674 : }
675 :
676 27591 : *prev_flag = flag;
677 27591 : *prev_Energy = EnergyL;
678 27591 : pit1 = &WB_signal[240];
679 :
680 469047 : for ( n_freq = 0; n_freq < 16; n_freq++ )
681 : {
682 441456 : *( pit1++ ) *= ( 0.2f + n_freq * 0.05f );
683 : }
684 :
685 27591 : if ( core_type == 1 )
686 : {
687 14430 : pit1 = &WB_signal[280];
688 591630 : for ( n_freq = 0; n_freq < 40; n_freq++ )
689 : {
690 577200 : *( pit1++ ) *= ( 1.0f - n_freq * 0.02f );
691 : }
692 : }
693 : else
694 : {
695 13161 : pit1 = &WB_signal[300];
696 276381 : for ( n_freq = 0; n_freq < 20; n_freq++ )
697 : {
698 263220 : *( pit1++ ) *= ( 1.0f - n_freq * 0.04f );
699 : }
700 : }
701 :
702 27591 : return;
703 : }
704 :
705 : /*-------------------------------------------------------------------*
706 : * SWB_BWE_decoding()
707 : *
708 : * SWB BWE decoder
709 : *-------------------------------------------------------------------*/
710 :
711 45324 : 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 45324 : fenvL = EPSILON;
738 45324 : EnergyL = EPSILON;
739 770508 : for ( n_freq = 224 + st_offset; n_freq < swb_bwe_trans_subband[0] + st_offset; n_freq++ )
740 : {
741 725184 : fenvL += core_dec_freq[n_freq] * core_dec_freq[n_freq];
742 : }
743 :
744 10923084 : for ( n_freq = 16; n_freq < L_FRAME; n_freq++ )
745 : {
746 10877760 : EnergyL += core_dec_freq[n_freq] * core_dec_freq[n_freq];
747 : }
748 45324 : fenvL = (float) sqrt( fenvL / 16 );
749 45324 : EnergyL = (float) sqrt( EnergyL / 240 );
750 45324 : if ( fenvL > 8.0f * SWB_fenv[0] )
751 : {
752 6063 : fenvL = SWB_fenv[0];
753 : }
754 45324 : calc_normal_length( ACELP_CORE, core_dec_freq, mode, extl, &L_swb_norm, prev_L_swb_norm );
755 :
756 45324 : if ( mode == TRANSIENT )
757 : {
758 240 : Energy = 0.0f;
759 1200 : for ( n_band = 0; n_band < SWB_FENV_TRANS; n_band++ )
760 : {
761 960 : Energy += SWB_fenv[n_band] * SWB_fenv[n_band];
762 : }
763 240 : Energy /= SWB_FENV_TRANS;
764 :
765 : /* Reconstruct excitation from LF signal */
766 240 : mvr2r( &core_dec_freq[112], &SWB_signal[240 + st_offset], 128 );
767 240 : mvr2r( &core_dec_freq[112], &SWB_signal[368 + st_offset], 128 );
768 240 : mvr2r( &core_dec_freq[176], &SWB_signal[496 + st_offset], 64 );
769 :
770 : /* calculate envelope */
771 240 : calc_norm_envelop( SWB_signal, envelope, L_swb_norm, SWB_flength, st_offset );
772 :
773 : /* Normalize with envelope */
774 77040 : 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 76800 : SWB_signal[n_freq] /= envelope[n_freq];
777 : }
778 :
779 1200 : for ( n_band = 0; n_band < SWB_FENV_TRANS; n_band++ )
780 : {
781 960 : energy = EPSILON;
782 77760 : 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 76800 : energy += SWB_signal[n_freq] * SWB_signal[n_freq];
785 : }
786 :
787 960 : tmp_ener = (float) ( sqrt( swb_bwe_trans_subband_width[n_band] / energy ) * SWB_fenv[n_band] );
788 :
789 77760 : 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 76800 : SWB_signal[n_freq] *= tmp_ener;
792 : }
793 : }
794 :
795 2160 : for ( n_band = 0; n_band < 8; n_band++ )
796 : {
797 1920 : prev_SWB_fenv[n_band] = SWB_fenv[n_band / 4] * SWB_fenv[n_band / 4];
798 : }
799 :
800 1680 : for ( n_band = 0; n_band < 6; n_band++ )
801 : {
802 1440 : prev_SWB_fenv[8 + n_band] = SWB_fenv[2 + n_band / 3] * SWB_fenv[2 + n_band / 3];
803 : }
804 :
805 240 : *prev_weight = 0.5f;
806 : }
807 : else
808 : {
809 45084 : Energy = EPSILON;
810 676260 : for ( n_band = 0; n_band < SWB_FENV; n_band++ )
811 : {
812 631176 : Energy += SWB_fenv[n_band];
813 : }
814 45084 : Energy /= SWB_FENV;
815 45084 : if ( last_extl != SWB_BWE && last_extl != FB_BWE )
816 : {
817 15753 : 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 15753 : mvr2r( SWB_fenv, prev_SWB_fenv, SWB_FENV );
826 : }
827 45084 : if ( mode == HARMONIC )
828 : {
829 825 : mvr2r( core_dec_freq, &SWB_signal[240 + st_offset], 240 );
830 825 : mvr2r( &core_dec_freq[128], &SWB_signal[480 + st_offset], 80 );
831 :
832 : /* calculate envelope */
833 825 : calc_norm_envelop( SWB_signal, envelope, L_swb_norm, SWB_flength, st_offset );
834 : }
835 : else
836 : {
837 44259 : if ( mode == NOISE || ( ( Energy > EnergyL || ( tilt_nb > 7 && Energy > 0.5f * EnergyL ) || tilt_nb > 12 ) && Energy > 75 && fenvL > 25 ) )
838 : {
839 991890 : for ( n_freq = swb_bwe_subband[0] + st_offset; n_freq < swb_bwe_subband[SWB_FENV] + st_offset; n_freq++ )
840 : {
841 988800 : *Seed = (int16_t) ( 12345 * ( *Seed ) + 20101 );
842 988800 : SWB_signal[n_freq] = ( *Seed ) / PCM16_TO_FLT_FAC;
843 : }
844 3090 : if ( mode != NOISE )
845 : {
846 654 : *frica_flag = 1;
847 : }
848 : }
849 : else
850 : {
851 : /* modify SHB frequency envelopes when SHB spectrum is unflat */
852 576366 : for ( n_band = 0; n_band < 13; n_band++ )
853 : {
854 535197 : if ( SWB_fenv[n_band] * 0.9f > SWB_fenv[n_band + 1] )
855 : {
856 179997 : SWB_fenv[n_band + 1] *= ( 0.8f + 0.015f * n_band );
857 : }
858 355200 : else if ( SWB_fenv[n_band + 1] * 0.9f > SWB_fenv[n_band] )
859 : {
860 160206 : SWB_fenv[n_band] *= ( 0.8f + 0.015f * n_band );
861 : }
862 : }
863 :
864 41169 : mvr2r( &core_dec_freq[112], &SWB_signal[240 + st_offset], 128 );
865 41169 : mvr2r( &core_dec_freq[112], &SWB_signal[368 + st_offset], 128 );
866 41169 : mvr2r( &core_dec_freq[176], &SWB_signal[496 + st_offset], 64 );
867 :
868 41169 : tmp1 = (float) ( fabs( SWB_signal[368 + st_offset] ) + fabs( SWB_signal[369 + st_offset] ) ) + EPSILON;
869 41169 : tmp2 = (float) ( fabs( SWB_signal[365 + st_offset] ) + fabs( SWB_signal[366 + st_offset] ) ) + EPSILON;
870 41169 : pit1 = &SWB_signal[368 + st_offset];
871 :
872 41169 : tmp3 = tmp2 / tmp1;
873 41169 : if ( tmp3 < 0.3 )
874 : {
875 11619 : tmp3 = 0.3f;
876 : }
877 :
878 192009 : while ( tmp3 < 1 )
879 : {
880 150840 : *pit1++ *= tmp3;
881 150840 : tmp3 += 0.1f;
882 : }
883 :
884 41169 : pit1 = &SWB_signal[367 + st_offset];
885 41169 : tmp3 = tmp1 / tmp2;
886 :
887 41169 : if ( tmp3 > 5 )
888 : {
889 7623 : tmp3 = 5;
890 68607 : while ( tmp3 > 1 )
891 : {
892 60984 : *pit1-- *= tmp3;
893 60984 : tmp3 -= 0.5f;
894 : }
895 : }
896 :
897 41169 : tmp1 = (float) ( fabs( SWB_signal[496 + st_offset] ) + fabs( SWB_signal[497 + st_offset] ) ) + EPSILON;
898 41169 : 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 41169 : pit1 = &SWB_signal[496 + st_offset];
900 :
901 41169 : tmp3 = tmp2 / tmp1;
902 41169 : if ( tmp3 < 0.3 )
903 : {
904 1785 : tmp3 = 0.3f;
905 : }
906 :
907 87618 : while ( tmp3 < 1 )
908 : {
909 46449 : *pit1++ *= tmp3;
910 46449 : tmp3 += 0.1f;
911 : }
912 :
913 41169 : pit1 = &SWB_signal[495 + st_offset];
914 :
915 41169 : tmp3 = tmp1 / tmp2;
916 41169 : tmp3 = 0.5f * tmp3;
917 41169 : tmp4 = 0.05f * tmp3;
918 :
919 73038 : while ( tmp3 > 1 )
920 : {
921 31869 : *pit1-- *= tmp3;
922 31869 : tmp3 -= tmp4;
923 : }
924 :
925 : /* calculate envelope */
926 41169 : calc_norm_envelop( SWB_signal, envelope, L_swb_norm, SWB_flength, st_offset );
927 : }
928 : }
929 :
930 : /* Normalize with envelope */
931 45084 : if ( *frica_flag == 0 && mode != NOISE )
932 : {
933 41994 : L = swb_bwe_subband[0] + st_offset;
934 41994 : inv_L_swb_norm = 1.0f / L_swb_norm;
935 41994 : weight = ( mode != HARMONIC ) ? max( min( 3.0f * inv_L_swb_norm, 0.5f ), 0.2f ) : 0.2f;
936 41994 : weight = 0.4f * weight + 0.6f * ( *prev_weight );
937 13480074 : for ( n_freq = L; n_freq < swb_bwe_subband[SWB_FENV] + st_offset; n_freq++ )
938 : {
939 13438080 : signum[n_freq] = 1;
940 13438080 : if ( SWB_signal[n_freq] < 0 )
941 : {
942 6726102 : signum[n_freq] = -1;
943 6726102 : SWB_signal[n_freq] *= signum[n_freq];
944 : }
945 :
946 13438080 : SWB_signal[n_freq] = SWB_signal[n_freq] - envelope[n_freq] * inv_L_swb_norm;
947 13438080 : if ( SWB_signal[n_freq] > 0 )
948 : {
949 5947797 : SWB_signal[n_freq] *= ( 1.2f - weight );
950 : }
951 13438080 : SWB_signal[n_freq] *= signum[n_freq];
952 : }
953 :
954 13480074 : for ( n_freq = L; n_freq < swb_bwe_subband[SWB_FENV] + st_offset; n_freq++ )
955 : {
956 13438080 : SWB_signal[n_freq] /= envelope[n_freq];
957 : }
958 :
959 41994 : *prev_weight = weight;
960 : }
961 : else
962 : {
963 3090 : *prev_weight = max( min( 3.0f / L_swb_norm, 0.5f ), 0.2f );
964 : }
965 :
966 45084 : if ( mode == HARMONIC )
967 : {
968 825 : pit1 = &SWB_signal[swb_bwe_subband[0] + st_offset];
969 16500 : for ( n_band = 0; n_band < 19; n_band++ )
970 : {
971 15675 : mean = 0;
972 266475 : for ( n_freq = 0; n_freq < 16; n_freq++ )
973 : {
974 250800 : mean += (float) fabs( *pit1 );
975 250800 : pit1++;
976 : }
977 15675 : mean /= 16;
978 15675 : pit1 -= 16;
979 266475 : for ( n_freq = 0; n_freq < 16; n_freq++ )
980 : {
981 250800 : if ( fabs( *pit1 ) < mean )
982 : {
983 148710 : *pit1 *= 0.2f;
984 : }
985 250800 : pit1++;
986 : }
987 : }
988 : }
989 :
990 45084 : if ( mode == HARMONIC )
991 : {
992 825 : L = 2;
993 : }
994 : else
995 : {
996 44259 : L = 1;
997 : }
998 :
999 670485 : for ( n_band = 0; n_band < SWB_FENV; n_band += L )
1000 : {
1001 625401 : energy = EPSILON;
1002 15052281 : for ( n_freq = swb_bwe_subband[n_band] + st_offset; n_freq < swb_bwe_subband[n_band + L] + st_offset; n_freq++ )
1003 : {
1004 14426880 : energy += SWB_signal[n_freq] * SWB_signal[n_freq];
1005 : }
1006 :
1007 625401 : tmp_ener = (float) sqrt( ( swb_bwe_subband[n_band + L] - swb_bwe_subband[n_band] ) / energy );
1008 :
1009 15052281 : for ( n_freq = swb_bwe_subband[n_band] + st_offset; n_freq < swb_bwe_subband[n_band + L] + st_offset; n_freq++ )
1010 : {
1011 14426880 : SWB_signal[n_freq] *= tmp_ener;
1012 : }
1013 : }
1014 :
1015 45084 : if ( *prev_Energy > 1.25f * Energy && Energy > 0 )
1016 : {
1017 7959 : weight = 0.5f * Energy / ( *prev_Energy );
1018 : }
1019 : else
1020 : {
1021 37125 : weight = 0.5f;
1022 : }
1023 :
1024 45084 : wfenv = weight * prev_SWB_fenv[0] + ( 1 - weight ) * SWB_fenv[0];
1025 45084 : factor = fenvL;
1026 45084 : factor1 = ( wfenv - fenvL ) * 0.125f;
1027 405756 : for ( n_freq = swb_bwe_subband[0] + st_offset; n_freq < swb_bwe_subband[0] + 8 + st_offset; n_freq++ )
1028 : {
1029 360672 : SWB_signal[n_freq] *= factor;
1030 360672 : factor += factor1;
1031 : }
1032 :
1033 586092 : for ( n_band = 0; n_band < 12; n_band++ )
1034 : {
1035 541008 : wfenv = weight * prev_SWB_fenv[n_band + 1] + ( 1 - weight ) * SWB_fenv[n_band + 1];
1036 541008 : factor = SWB_fenv[n_band];
1037 541008 : factor1 = ( wfenv - SWB_fenv[n_band] ) * smooth_factor[n_band];
1038 12443184 : for ( ; n_freq < swb_bwe_sm_subband[n_band + 1] + st_offset; n_freq++ )
1039 : {
1040 11902176 : SWB_signal[n_freq] *= factor;
1041 11902176 : factor += factor1;
1042 : }
1043 : }
1044 :
1045 45084 : wfenv = weight * prev_SWB_fenv[13] + ( 1 - weight ) * SWB_fenv[13];
1046 45084 : factor = SWB_fenv[12];
1047 45084 : factor1 = ( wfenv - SWB_fenv[12] ) * smooth_factor[12];
1048 1487772 : for ( ; n_freq < swb_bwe_sm_subband[13] + st_offset; n_freq++ )
1049 : {
1050 1442688 : SWB_signal[n_freq] *= factor;
1051 1442688 : factor += factor1;
1052 : }
1053 :
1054 90168 : for ( n_band = 13; n_band < SWB_FENV; n_band++ )
1055 : {
1056 45084 : wfenv = weight * prev_SWB_fenv[n_band] + ( 1 - weight ) * SWB_fenv[n_band];
1057 766428 : for ( ; n_freq < swb_bwe_subband[n_band + 1] + st_offset; n_freq++ )
1058 : {
1059 721344 : SWB_signal[n_freq] *= wfenv;
1060 : }
1061 : }
1062 :
1063 676260 : for ( n_band = 0; n_band < SWB_FENV; n_band++ )
1064 : {
1065 631176 : prev_SWB_fenv[n_band] = SWB_fenv[n_band];
1066 : }
1067 : }
1068 :
1069 45324 : pit1 = &SWB_signal[240 + st_offset];
1070 226620 : for ( n_freq = 0; n_freq < 4; n_freq++ )
1071 : {
1072 181296 : *( pit1++ ) *= 0.5f;
1073 : }
1074 45324 : *prev_Energy = Energy;
1075 :
1076 45324 : return;
1077 : }
1078 :
1079 : /*-------------------------------------------------------------------*
1080 : * time_envelop_shaping()
1081 : *
1082 : * time shaping of the SHB signal
1083 : *-------------------------------------------------------------------*/
1084 :
1085 240 : 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 240 : pit = werr;
1097 1200 : for ( i = 0; i < SWB_TENV; i++ )
1098 : {
1099 960 : Energy = EPSILON;
1100 212160 : for ( j = 0; j < L / 4; j++ )
1101 : {
1102 211200 : Energy += *pit * *pit;
1103 211200 : pit++;
1104 : }
1105 960 : Energy = (float) sqrt( 4 * Energy / L );
1106 :
1107 960 : if ( SWB_tenv[i] < 2 && Energy < SWB_tenv[i] )
1108 : {
1109 6 : SWB_tenv[i] = Energy;
1110 : }
1111 :
1112 960 : pit -= L / 4;
1113 960 : tmp_ener = 1.0f / Energy;
1114 212160 : for ( j = 0; j < L / 4; j++ )
1115 : {
1116 211200 : *pit *= SWB_tenv[i] * tmp_ener;
1117 211200 : pit++;
1118 : }
1119 : }
1120 :
1121 240 : return;
1122 : }
1123 :
1124 : /*-------------------------------------------------------------------*
1125 : * time_reduce_pre_echo()
1126 : *
1127 : * Pre-echo reduction.
1128 : *-------------------------------------------------------------------*/
1129 :
1130 423 : 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 423 : 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 2115 : for ( i = 0; i < 4; i++ )
1145 : {
1146 1692 : energyL[i] = 0;
1147 386652 : for ( j = 0; j < L; j++ )
1148 : {
1149 384960 : energyL[i] += synth[L * i + j] * synth[L * i + j];
1150 : }
1151 1692 : energyL[i] = (float) sqrt( energyL[i] / L );
1152 : }
1153 :
1154 1614 : for ( i = 0; i < 3; i++ )
1155 : {
1156 1233 : if ( energyL[i + 1] > 1.8f * energyL[i] && energyL[i + 1] > 50 )
1157 : {
1158 42 : pos = i + 1;
1159 42 : break;
1160 : }
1161 : }
1162 :
1163 423 : if ( pos > 0 )
1164 : {
1165 42 : if ( pos < 3 )
1166 : {
1167 21 : pos++;
1168 : }
1169 :
1170 42 : energy = EPSILON;
1171 42 : j = L * pos;
1172 26682 : for ( i = 0; i < j; i++ )
1173 : {
1174 26640 : energy += error[i] * error[i];
1175 : }
1176 42 : energy = (float) sqrt( energy / j );
1177 :
1178 42 : if ( prev_td_energy < 0.2f * energy )
1179 : {
1180 27 : prev_td_energy = 0.2f * energy;
1181 : }
1182 :
1183 42 : tmp_ener = prev_td_energy / energy;
1184 26682 : for ( i = 0; i < j; i++ )
1185 : {
1186 26640 : error[i] *= tmp_ener;
1187 : }
1188 :
1189 42 : energy = EPSILON;
1190 10122 : for ( i = j; i < ( j + L ); i++ )
1191 : {
1192 10080 : energy += error[i] * error[i];
1193 : }
1194 42 : energy = (float) sqrt( energy / L );
1195 :
1196 42 : pit = &error[j];
1197 42 : tmp_ener = prev_td_energy / energy;
1198 10122 : for ( i = 0; i < L; i++ )
1199 : {
1200 10080 : tmpi = i / ( 1.0f * L );
1201 10080 : *pit++ *= ( ( 1.0f - tmpi ) * tmp_ener + tmpi );
1202 : }
1203 : }
1204 :
1205 423 : return;
1206 : }
1207 :
1208 : /*-------------------------------------------------------------------*
1209 : * hq_generic_hf_decoding()
1210 : *
1211 : *-------------------------------------------------------------------*/
1212 9003 : 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 9003 : if ( hq_generic_offset <= HQ_GENERIC_FOFFSET_24K4 )
1237 : {
1238 9003 : nenv = SWB_FENV;
1239 : }
1240 : else
1241 : {
1242 0 : nenv = SWB_FENV - 2;
1243 : }
1244 :
1245 9003 : if ( HQ_mode == HQ_GEN_FB )
1246 : {
1247 6765 : tenv = nenv + DIM_FB;
1248 : }
1249 : else
1250 : {
1251 2238 : tenv = nenv;
1252 : }
1253 :
1254 9003 : fenvL = EPSILON;
1255 153051 : for ( n_freq = HQ_GENERIC_ST_FREQ + hq_generic_offset; n_freq < swb_bwe_subband[0] + hq_generic_offset; n_freq++ )
1256 : {
1257 144048 : fenvL += coeff_out1[n_freq] * coeff_out1[n_freq];
1258 : }
1259 :
1260 9003 : fenvL = (float) sqrt( fenvL / 16 );
1261 :
1262 9003 : calc_normal_length( HQ_CORE, coeff_out1, HQ_GEN_SWB, -1, &L_swb_norm, prev_L_swb_norm );
1263 :
1264 : /* calculate envelope */
1265 9003 : calc_norm_envelop_lf( coeff_out1, envelope, &L_swb_norm, HQ_mode, hq_generic_offset, &sfidx, &efidx );
1266 :
1267 9003 : blen = 16;
1268 9003 : if ( hq_generic_exc_clas == HQ_GENERIC_EXC0 )
1269 : {
1270 8532 : rn_weight0 = 0.8f;
1271 : }
1272 471 : else if ( hq_generic_exc_clas == HQ_GENERIC_EXC1 )
1273 : {
1274 45 : rn_weight0 = 0.05f;
1275 : }
1276 : else
1277 : {
1278 426 : rn_weight0 = 0.2f;
1279 : }
1280 :
1281 9003 : nband_lf = ( efidx - sfidx ) / blen;
1282 2387835 : for ( n_freq = sfidx; n_freq < efidx; n_freq++ )
1283 : {
1284 2378832 : if ( coeff_out1[n_freq] < 0 )
1285 : {
1286 1182954 : signum[n_freq] = -1;
1287 1182954 : coeff_out1[n_freq] *= signum[n_freq];
1288 : }
1289 : else
1290 : {
1291 1195878 : signum[n_freq] = 1;
1292 : }
1293 : }
1294 :
1295 : /* applying whitening */
1296 2387835 : for ( n_freq = sfidx; n_freq < efidx; n_freq++ )
1297 : {
1298 2378832 : coeff_out1[n_freq] = coeff_out1[n_freq] / envelope[n_freq];
1299 : }
1300 :
1301 : /* mean vector generation for controlling dynamic range */
1302 157680 : for ( k = 0; k < nband_lf; ++k )
1303 : {
1304 148677 : energy = EPSILON;
1305 2527509 : for ( i = k * blen + sfidx; i < ( k + 1 ) * blen + sfidx; ++i )
1306 : {
1307 2378832 : energy += coeff_out1[i];
1308 : }
1309 148677 : mean_vector[k] = energy / blen;
1310 : }
1311 :
1312 : /* dynamic range control */
1313 157680 : for ( k = 0; k < nband_lf; ++k )
1314 : {
1315 2527509 : for ( i = k * blen + sfidx; i < ( k + 1 ) * blen + sfidx; ++i )
1316 : {
1317 2378832 : coeff_out1[i] = coeff_out1[i] - ( coeff_out1[i] - mean_vector[k] ) * rn_weight0;
1318 : }
1319 : }
1320 :
1321 9003 : if ( hq_generic_exc_clas == HQ_GENERIC_EXC0 )
1322 : {
1323 : /* applying random sign */
1324 8532 : bwe_seed = R[0] * 8 + R[1] * 4 + R[2] * 2 + R[3];
1325 2278740 : for ( n_freq = sfidx; n_freq < efidx; n_freq++ )
1326 : {
1327 2270208 : 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 109095 : for ( n_freq = sfidx; n_freq < efidx; n_freq++ )
1333 : {
1334 108624 : coeff_out1[n_freq] = coeff_out1[n_freq] * signum[n_freq];
1335 : }
1336 : }
1337 :
1338 : /* normalizing modified low frequency spectrum */
1339 157680 : for ( k = 0; k < nband_lf; ++k )
1340 : {
1341 148677 : energy = EPSILON;
1342 2527509 : for ( i = k * blen + sfidx; i < ( k + 1 ) * blen + sfidx; ++i )
1343 : {
1344 2378832 : energy += coeff_out1[i] * coeff_out1[i];
1345 : }
1346 148677 : energy = (float) sqrt( energy / blen );
1347 :
1348 2527509 : for ( i = k * blen + sfidx; i < ( k + 1 ) * blen + sfidx; ++i )
1349 : {
1350 2378832 : coeff_out1[i] /= energy;
1351 : }
1352 : }
1353 9003 : mvr2r( coeff_out1 + HQ_GENERIC_OFFSET, &coeff_out[HQ_GENERIC_HIGH0 + hq_generic_offset], HQ_GENERIC_LEN0 );
1354 9003 : mvr2r( coeff_out1 + HQ_GENERIC_OFFSET, &coeff_out[HQ_GENERIC_HIGH1 + hq_generic_offset], HQ_GENERIC_LEN0 );
1355 :
1356 9003 : if ( hq_generic_offset <= HQ_GENERIC_FOFFSET_24K4 )
1357 : {
1358 9003 : mvr2r( &coeff_out1[HQ_GENERIC_LOW0], &coeff_out[HQ_GENERIC_HIGH2 + hq_generic_offset], HQ_GENERIC_END_FREQ - HQ_GENERIC_HIGH2 );
1359 : }
1360 :
1361 9003 : if ( HQ_mode == HQ_GEN_FB )
1362 : {
1363 6765 : if ( hq_generic_offset <= HQ_GENERIC_FOFFSET_24K4 )
1364 : {
1365 6765 : 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 9003 : tmp1 = EPSILON;
1373 9003 : tmp2 = EPSILON;
1374 54018 : for ( i = 0; i < 5; ++i )
1375 : {
1376 45015 : tmp1 += (float) fabs( coeff_out[HQ_GENERIC_HIGH1 + hq_generic_offset + i] );
1377 45015 : tmp2 += (float) fabs( coeff_out[HQ_GENERIC_HIGH1 - 2 + hq_generic_offset - i] );
1378 : }
1379 :
1380 9003 : pit1 = &coeff_out[HQ_GENERIC_HIGH1 + hq_generic_offset];
1381 9003 : tmp3 = tmp2 / tmp1;
1382 9003 : if ( tmp3 < 0.3f )
1383 : {
1384 0 : tmp3 = 0.3f;
1385 : }
1386 :
1387 16461 : while ( tmp3 < 1 )
1388 : {
1389 7458 : *pit1++ *= tmp3;
1390 7458 : tmp3 += 0.1f;
1391 : }
1392 :
1393 9003 : pit1 = &coeff_out[HQ_GENERIC_HIGH1 - 1 + hq_generic_offset];
1394 9003 : tmp3 = tmp1 / tmp2;
1395 9003 : 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 9003 : if ( hq_generic_offset <= HQ_GENERIC_FOFFSET_24K4 )
1406 : {
1407 9003 : tmp1 = (float) ( fabs( coeff_out[HQ_GENERIC_HIGH2 + hq_generic_offset] ) + fabs( coeff_out[HQ_GENERIC_HIGH2 + 1 + hq_generic_offset] ) ) + EPSILON;
1408 9003 : 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 9003 : pit1 = &coeff_out[HQ_GENERIC_HIGH2 + hq_generic_offset];
1412 9003 : tmp3 = tmp2 / tmp1;
1413 9003 : if ( tmp3 < 0.3f )
1414 : {
1415 0 : tmp3 = 0.3f;
1416 : }
1417 :
1418 9024 : while ( tmp3 < 1 )
1419 : {
1420 21 : *pit1++ *= tmp3;
1421 21 : tmp3 += 0.1f;
1422 : }
1423 :
1424 9003 : pit1 = &coeff_out[HQ_GENERIC_HIGH2 - 1 + hq_generic_offset];
1425 9003 : tmp3 = tmp1 / tmp2;
1426 9003 : tmp3 = 0.5f * tmp3;
1427 9003 : tmp4 = 0.05f * tmp3;
1428 9003 : while ( tmp3 > 1 )
1429 : {
1430 0 : *pit1-- *= tmp3;
1431 0 : tmp3 -= tmp4;
1432 : }
1433 : }
1434 :
1435 9003 : wfenv = hq_generic_fenv[0];
1436 81027 : 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 72024 : factor = i * 0.125f;
1439 72024 : coeff_out[n_freq] *= ( ( 1 - factor ) * fenvL + factor * wfenv );
1440 : }
1441 :
1442 117039 : for ( n_band = 0; n_band < nenv - 2; n_band++ )
1443 : {
1444 108036 : wfenv = hq_generic_fenv[n_band + 1];
1445 2484828 : for ( i = 0; n_freq < swb_bwe_sm_subband[n_band + 1] + hq_generic_offset; n_freq++, i++ )
1446 : {
1447 2376792 : factor = i * smooth_factor[n_band];
1448 2376792 : coeff_out[n_freq] *= ( ( 1 - factor ) * hq_generic_fenv[n_band] + factor * wfenv );
1449 : }
1450 : }
1451 :
1452 9003 : wfenv = hq_generic_fenv[nenv - 1];
1453 297099 : for ( i = 0; n_freq < swb_bwe_sm_subband[nenv - 1] + hq_generic_offset; n_freq++, i++ )
1454 : {
1455 288096 : factor = i * smooth_factor[nenv - 2];
1456 :
1457 288096 : coeff_out[n_freq] *= ( ( 1 - factor ) * hq_generic_fenv[nenv - 2] + factor * wfenv );
1458 : }
1459 :
1460 9003 : if ( HQ_mode == HQ_GEN_SWB )
1461 : {
1462 4476 : for ( n_band = nenv - 1; n_band < nenv; ++n_band )
1463 : {
1464 2238 : wfenv = hq_generic_fenv[n_band];
1465 38046 : for ( ; n_freq < swb_bwe_subband[n_band + 1] + hq_generic_offset; n_freq++ )
1466 : {
1467 35808 : coeff_out[n_freq] *= wfenv;
1468 : }
1469 : }
1470 : }
1471 : else
1472 : {
1473 6765 : if ( hq_generic_fenv[nenv - 1] - hq_generic_fenv[nenv] > 15.f || hq_generic_fenv[nenv] < 5.f )
1474 : {
1475 5280 : wfenv = hq_generic_fenv[nenv - 1];
1476 89760 : for ( i = 0; n_freq < fb_bwe_subband[0]; n_freq++, i++ )
1477 : {
1478 84480 : coeff_out[n_freq] *= wfenv;
1479 : }
1480 :
1481 21120 : for ( n_band = 0; n_band < DIM_FB; n_band++ )
1482 : {
1483 15840 : wfenv = hq_generic_fenv[n_band + nenv];
1484 860640 : for ( i = 0; n_freq < fb_bwe_subband[n_band + 1]; n_freq++, i++ )
1485 : {
1486 844800 : coeff_out[n_freq] *= wfenv;
1487 : }
1488 : }
1489 : }
1490 : else
1491 : {
1492 5940 : for ( n_band = 0; n_band < DIM_FB; n_band++ )
1493 : {
1494 4455 : wfenv = hq_generic_fenv[n_band + nenv - 1];
1495 :
1496 206415 : for ( i = 0; n_freq < fb_bwe_sm_subband[n_band]; n_freq++, i++ )
1497 : {
1498 201960 : factor = i * fb_smooth_factor[n_band];
1499 201960 : coeff_out[n_freq] *= ( ( 1 - factor ) * hq_generic_fenv[n_band + nenv] + factor * wfenv );
1500 : }
1501 : }
1502 :
1503 1485 : wfenv = hq_generic_fenv[tenv - 1];
1504 :
1505 60885 : for ( ; n_freq < fb_bwe_subband[DIM_FB]; n_freq++ )
1506 : {
1507 59400 : coeff_out[n_freq] *= wfenv;
1508 : }
1509 : }
1510 : }
1511 9003 : 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 681386 : 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 681386 : if ( L_frame == L_FRAME )
1534 : {
1535 361783 : tmps = NS2SA( 12800, DELAY_FD_BWE_ENC_12k8_NS );
1536 : }
1537 : else
1538 : {
1539 319603 : tmps = NS2SA( 16000, DELAY_FD_BWE_ENC_16k_NS );
1540 : }
1541 :
1542 681386 : mvr2r( old_syn_mem, old_syn, tmps );
1543 681386 : mvr2r( syn, old_syn + tmps, L_frame - tmps );
1544 681386 : mvr2r( syn + L_frame - tmps, old_syn_mem, tmps );
1545 :
1546 681386 : deemph( old_syn, preemph_fac, L_frame, mem_deemph );
1547 :
1548 681386 : return;
1549 : }
|
