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 206637 : 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 206637 : float enerL, alfa = 1.0f;
68 : int16_t n_freq, mode;
69 206637 : int16_t ener_var_flag = 0;
70 : float voice_factor, pitch;
71 206637 : int16_t env_var_flag = 0;
72 :
73 206637 : mode = NORMAL;
74 :
75 206637 : enerL = EPSILON;
76 13431405 : for ( n_freq = 128; n_freq < 192; n_freq++ )
77 : {
78 13224768 : enerL += core_dec_freq[n_freq] * core_dec_freq[n_freq];
79 : }
80 206637 : WB_fenv[0] = EPSILON;
81 6819021 : for ( n_freq = 192; n_freq < 224; n_freq++ )
82 : {
83 6612384 : WB_fenv[0] += core_dec_freq[n_freq] * core_dec_freq[n_freq];
84 : }
85 :
86 206637 : WB_fenv[1] = EPSILON;
87 6819021 : for ( n_freq = 224; n_freq < 256; n_freq++ )
88 : {
89 6612384 : WB_fenv[1] += core_dec_freq[n_freq] * core_dec_freq[n_freq];
90 : }
91 :
92 206637 : voice_factor = sum_f( voice_factors, 4 );
93 206637 : pitch = sum_f( pitch_buf, 4 ) + EPSILON;
94 :
95 206637 : if ( enerL < 16.0f * max( WB_fenv[0], WB_fenv[1] ) && pitch < 308 )
96 : {
97 202293 : ener_var_flag = 1;
98 : }
99 :
100 206637 : if ( WB_fenv[0] > 2.0f * WB_fenv[1] )
101 : {
102 5274 : alfa = max( 2.0f * WB_fenv[1] / WB_fenv[0], 0.1f );
103 5274 : WB_fenv[0] *= alfa;
104 : }
105 201363 : else if ( 2.0f * WB_fenv[0] < WB_fenv[1] && coder_type != UNVOICED )
106 : {
107 165992 : alfa = max( 2.0f * WB_fenv[0] / WB_fenv[1], 0.1f );
108 165992 : WB_fenv[1] *= alfa;
109 : }
110 :
111 206637 : WB_fenv[0] = (float) sqrt( ( WB_fenv[0] + WB_fenv[1] ) / 64 );
112 :
113 206637 : if ( coder_type != AUDIO && coder_type != UNVOICED && ener_var_flag == 0 )
114 : {
115 3846 : WB_fenv[0] *= 1.5f;
116 : }
117 :
118 206637 : if ( coder_type != TRANSITION && coder_type != AUDIO && coder_type != UNVOICED && sqrt( enerL ) > 40.0f * WB_fenv[0] && alfa > 0.9f &&
119 50 : !( coder_type == prev_coder_type && WB_fenv[0] > prev_WB_fenv ) )
120 : {
121 9 : WB_fenv[0] *= min( (float) ( 0.025f * sqrt( enerL ) / WB_fenv[0] ), 4.0f );
122 :
123 9 : if ( WB_fenv[0] > prev_WB_fenv )
124 : {
125 8 : WB_fenv[0] = 0.3f * WB_fenv[0] + 0.7f * prev_WB_fenv;
126 : }
127 : }
128 :
129 206637 : alfa = min( 1.5f, max( 0.5f, 77.0f * voice_factor / pitch ) );
130 206637 : 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 528 : env_var_flag = 1;
133 528 : WB_fenv[0] *= min( (float) ( 0.015625f * sqrt( enerL ) / WB_fenv[0] ), 4.0f );
134 :
135 528 : if ( WB_fenv[0] > prev_WB_fenv )
136 : {
137 473 : WB_fenv[0] = 0.3f * WB_fenv[0] + 0.7f * prev_WB_fenv;
138 : }
139 : }
140 :
141 206637 : if ( coder_type == UNVOICED || prev_coder_type == UNVOICED )
142 : {
143 2589 : WB_fenv[0] *= 0.5f;
144 : }
145 :
146 206637 : if ( coder_type != AUDIO )
147 : {
148 205564 : WB_fenv[0] /= max( 1.2f * voice_factor, 1.0f );
149 205564 : WB_fenv[0] *= min( 2.0f, max( 0.125f, pitch / 400.0f ) );
150 : }
151 :
152 206637 : if ( last_core_brate > ACELP_8k00 && WB_fenv[0] > last_wb_bwe_ener )
153 : {
154 4270 : WB_fenv[0] = 0.9f * last_wb_bwe_ener + 0.1f * WB_fenv[0];
155 : }
156 :
157 206637 : if ( last_extl != WB_BWE && ( tilt < 8.f ) )
158 : {
159 1013 : WB_fenv[0] *= min( 0.5f, 16.0f * tilt );
160 : }
161 :
162 206637 : if ( env_var_flag == 1 )
163 : {
164 528 : WB_fenv[1] = 1.5f * WB_fenv[0];
165 528 : WB_fenv[0] *= 0.75f;
166 : }
167 : else
168 : {
169 206109 : WB_fenv[1] = WB_fenv[0];
170 : }
171 :
172 206637 : if ( coder_type == UNVOICED || prev_coder_type == UNVOICED )
173 : {
174 2589 : WB_fenv[1] *= 0.5f;
175 : }
176 :
177 206637 : return ( mode );
178 : }
179 :
180 : /*-------------------------------------------------------------------*
181 : * calc_normal_length()
182 : *
183 : *-------------------------------------------------------------------*/
184 :
185 741345 : 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 741345 : if ( core == HQ_CORE || extl == SWB_BWE || extl == FB_BWE )
201 : {
202 345706 : THRES = 8;
203 : }
204 : else
205 : {
206 395639 : THRES = 4;
207 : }
208 :
209 741345 : if ( core == HQ_CORE && ( mode == HQ_HARMONIC || mode == HQ_HVQ ) )
210 : {
211 32485 : N = 13;
212 : }
213 : else
214 : {
215 708860 : N = 16;
216 : }
217 :
218 741345 : n_band = 0;
219 741345 : pit = sp;
220 12505410 : for ( i = 0; i < N; i++ )
221 : {
222 11764065 : peak = 0.0f;
223 11764065 : mean = 0;
224 :
225 199989105 : for ( n_freq = 0; n_freq < 16; n_freq++ )
226 : {
227 188225040 : mag = (float) fabs( *pit );
228 188225040 : if ( mag > peak )
229 : {
230 42039028 : peak = mag;
231 : }
232 188225040 : mean += mag;
233 188225040 : pit++;
234 : }
235 :
236 11764065 : if ( ( 15 + THRES ) * peak > THRES * mean && peak > 10 )
237 : {
238 926766 : n_band += 1;
239 : }
240 : }
241 :
242 741345 : if ( core == ACELP_CORE )
243 : {
244 644240 : L_swb_norm_trans = (int16_t) ( 4 + 0.25f * n_band );
245 644240 : L_swb_norm_norm = (int16_t) ( 8 + 0.5f * n_band );
246 644240 : L_swb_norm_harm = max( (int16_t) ( 32 + 2.0f * n_band ), 24 );
247 :
248 644240 : if ( mode == HARMONIC )
249 : {
250 9793 : L_swb_norm_cur = L_swb_norm_harm;
251 : }
252 634447 : else if ( mode == NORMAL )
253 : {
254 601510 : L_swb_norm_cur = L_swb_norm_norm;
255 : }
256 : else
257 : {
258 32937 : L_swb_norm_cur = L_swb_norm_trans;
259 : }
260 :
261 644240 : *L_swb_norm = (int16_t) ( 0.5f * L_swb_norm_cur + 0.5f * ( *prev_L_swb_norm ) );
262 644240 : *prev_L_swb_norm = L_swb_norm_cur;
263 : }
264 : else
265 : {
266 97105 : if ( mode == HQ_HARMONIC || mode == HQ_HVQ )
267 : {
268 32485 : L_swb_norm_cur = (int16_t) ( 32 + 2.5f * n_band );
269 : }
270 : else
271 : {
272 64620 : L_swb_norm_cur = (int16_t) ( 8 + 0.5f * n_band );
273 : }
274 :
275 97105 : *L_swb_norm = (int16_t) ( 0.1f * L_swb_norm_cur + 0.9f * ( *prev_L_swb_norm ) + 0.5f );
276 97105 : *prev_L_swb_norm = L_swb_norm_cur;
277 : }
278 :
279 741345 : return;
280 : }
281 : /*-------------------------------------------------------------------*
282 : * calc_tilt_bwe()
283 : *
284 : * calculate tilt parameter
285 : *-------------------------------------------------------------------*/
286 :
287 13729755 : 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 13729755 : r0 = EPSILON;
297 6809550491 : for ( i = 0; i < N; i++ )
298 : {
299 6795820736 : r0 += sp[i] * sp[i];
300 : }
301 :
302 13729755 : r1 = (float) fabs( sp[1] - sp[0] );
303 6782090981 : for ( i = 2; i < N; i++ )
304 : {
305 6768361226 : if ( ( sp[i] - sp[i - 1] ) * ( sp[i - 1] - sp[i - 2] ) < 0 )
306 : {
307 1710595333 : r1 += (float) fabs( sp[i] - sp[i - 1] );
308 : }
309 : }
310 :
311 13729755 : *tilt = (float) ( r1 / sqrt( r0 ) );
312 :
313 13729755 : return;
314 : }
315 :
316 : /*-------------------------------------------------------------------*
317 : * calc_norm_envelop()
318 : *
319 : * calculate normalized parameter
320 : *-------------------------------------------------------------------*/
321 :
322 647515 : 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 647515 : lookback = L_swb_norm / 2;
333 647515 : env_index = swb_bwe_subband[0] + st_offset;
334 647515 : n_lag_now = L_swb_norm;
335 129704647 : 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 129057132 : envelope[env_index] = EPSILON;
339 1198653456 : for ( n_lag = 0; n_lag < n_lag_now; n_lag++ )
340 : {
341 1069596324 : envelope[env_index] += (float) fabs( SWB_signal[n_freq + n_lag] );
342 : }
343 129057132 : env_index++;
344 : }
345 :
346 3518463 : for ( n_freq = SWB_flength + st_offset - L_swb_norm, i = 0; n_freq < SWB_flength + st_offset - lookback; n_freq++, i++ )
347 : {
348 2870948 : n_lag_now = L_swb_norm - i;
349 : /* Apply MA filter */
350 2870948 : envelope[env_index] = EPSILON;
351 28161021 : for ( n_lag = 0; n_lag < n_lag_now; n_lag++ )
352 : {
353 25290073 : envelope[env_index] += (float) fabs( SWB_signal[n_freq + n_lag] );
354 : }
355 2870948 : env_index++;
356 : }
357 :
358 647515 : return;
359 : }
360 :
361 :
362 : /*-------------------------------------------------------------------*
363 : * calc_norm_envelop_lf()
364 : *
365 : * calc_envelope of low frequency spectrum
366 : *-------------------------------------------------------------------*/
367 39084 : 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 39084 : *sfreq = 2;
379 39084 : if ( hq_generic_offset == HQ_GENERIC_FOFFSET_24K4 )
380 : {
381 38215 : *efreq = 146;
382 38215 : if ( HQ_mode == HQ_GEN_FB )
383 : {
384 20830 : *efreq = 306;
385 : }
386 38215 : if ( ( 328 - *efreq ) * 2 + 1 < *L_swb_norm )
387 : {
388 459 : *L_swb_norm = ( 328 - *efreq ) * 2 + 1;
389 : }
390 : }
391 : else
392 : {
393 869 : *efreq = 130;
394 869 : if ( HQ_mode == HQ_GEN_FB )
395 : {
396 265 : *efreq = 290;
397 : }
398 869 : if ( ( 400 - *efreq ) * 2 + 1 < *L_swb_norm )
399 : {
400 0 : *L_swb_norm = ( 400 - *efreq ) * 2 + 1;
401 : }
402 : }
403 :
404 39084 : lookback = *L_swb_norm / 2;
405 39084 : env_index = 0;
406 39084 : n_lag_now = *L_swb_norm;
407 289995 : for ( n_freq = 0; n_freq < lookback; n_freq++ )
408 : {
409 250911 : envelope[env_index] = EPSILON;
410 4612542 : for ( n_lag = 0; n_lag < lookback + n_freq; n_lag++ )
411 : {
412 4361631 : envelope[env_index] += (float) fabs( SWB_signal[n_lag] );
413 : }
414 250911 : env_index++;
415 : }
416 8855733 : for ( ; n_freq < *efreq; n_freq++ )
417 : {
418 : /* Apply MA filter */
419 8816649 : envelope[env_index] = EPSILON;
420 117792168 : for ( n_lag = 0; n_lag < n_lag_now; n_lag++ )
421 : {
422 108975519 : envelope[env_index] += (float) fabs( SWB_signal[n_freq - lookback + n_lag] );
423 : }
424 8816649 : env_index++;
425 : }
426 39084 : return;
427 : }
428 :
429 : /*-------------------------------------------------------------------*
430 : * WB_BWE_decoding()
431 : *
432 : * WB BWE decoder
433 : *-------------------------------------------------------------------*/
434 :
435 285632 : 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 285632 : int16_t flag = 0;
461 285632 : int16_t core_type = 1;
462 : int16_t signum[L_FRAME16k];
463 : float inv_L_wb_norm, weight;
464 :
465 285632 : calc_normal_length( ACELP_CORE, core_dec_freq, mode, extl, &L_wb_norm, prev_L_wb_norm );
466 :
467 285632 : set_f( WB_signal, 0, L_FRAME16k );
468 :
469 : /* copy excitation */
470 285632 : if ( coder_type != AUDIO && total_brate <= ACELP_8k00 )
471 : {
472 207030 : core_type = 0;
473 : }
474 :
475 285632 : if ( core_type == 0 )
476 : {
477 207030 : mvr2r( &core_dec_freq[160], &WB_signal[240], 80 );
478 : }
479 : else
480 : {
481 78602 : mvr2r( &core_dec_freq[80], &WB_signal[240], 80 );
482 : }
483 :
484 : /* calculate envelope */
485 285632 : calc_norm_envelop( WB_signal, envelope, L_wb_norm, WB_flength, 0 );
486 :
487 285632 : if ( coder_type != UNVOICED && total_brate <= ACELP_8k00 )
488 : {
489 235717 : inv_L_wb_norm = 1.0f / L_wb_norm;
490 235717 : weight = ( mode != HARMONIC ) ? max( min( 3.0f * inv_L_wb_norm, 0.5f ), 0.25f ) : 0.25f;
491 19093077 : for ( n_freq = swb_bwe_subband[0]; n_freq < swb_bwe_subband[4]; n_freq++ )
492 : {
493 18857360 : signum[n_freq] = 1;
494 18857360 : if ( WB_signal[n_freq] < 0 )
495 : {
496 9420213 : signum[n_freq] = -1;
497 9420213 : WB_signal[n_freq] *= signum[n_freq];
498 : }
499 :
500 18857360 : WB_signal[n_freq] = WB_signal[n_freq] - 0.45f * envelope[n_freq] * inv_L_wb_norm;
501 18857360 : if ( WB_signal[n_freq] > 0 )
502 : {
503 14279800 : WB_signal[n_freq] *= ( 0.55f - weight );
504 : }
505 18857360 : WB_signal[n_freq] *= signum[n_freq];
506 : }
507 : }
508 :
509 : /* Normalize with envelope */
510 23136192 : for ( n_freq = swb_bwe_subband[0]; n_freq < swb_bwe_subband[4]; n_freq++ )
511 : {
512 22850560 : WB_signal[n_freq] /= envelope[n_freq];
513 : }
514 :
515 285632 : if ( mode == HARMONIC )
516 : {
517 5388 : L = 4;
518 : }
519 : else
520 : {
521 280244 : L = 1;
522 : }
523 :
524 285632 : if ( coder_type == UNVOICED )
525 : {
526 224613 : for ( n_freq = swb_bwe_subband[0]; n_freq < swb_bwe_subband[4]; n_freq++ )
527 : {
528 221840 : *Seed = (int16_t) ( 12345 * ( *Seed ) + 20101 );
529 221840 : WB_signal[n_freq] = ( *Seed ) / PCM16_TO_FLT_FAC;
530 : }
531 : }
532 : else
533 : {
534 1398131 : for ( n_band = 0; n_band < 4; n_band += L )
535 : {
536 1115272 : energy = EPSILON;
537 23743992 : for ( n_freq = swb_bwe_subband[n_band]; n_freq < swb_bwe_subband[n_band + L]; n_freq++ )
538 : {
539 22628720 : energy += WB_signal[n_freq] * WB_signal[n_freq];
540 : }
541 :
542 1115272 : energy = (float) sqrt( ( swb_bwe_subband[n_band + L] - swb_bwe_subband[n_band] ) / energy );
543 :
544 23743992 : for ( n_freq = swb_bwe_subband[n_band]; n_freq < swb_bwe_subband[n_band + L]; n_freq++ )
545 : {
546 22628720 : WB_signal[n_freq] *= energy;
547 : }
548 : }
549 : }
550 :
551 :
552 285632 : EnergyL = 0.0f;
553 285632 : if ( core_type == 1 )
554 : {
555 78602 : if ( prev_coder_type != AUDIO && total_brate <= ACELP_8k00 )
556 : {
557 76464 : for ( i = 160; i < 240; i++ )
558 : {
559 75520 : EnergyL += (float) fabs( core_dec_freq[i] );
560 : }
561 : }
562 : else
563 : {
564 12502938 : for ( i = 80; i < 240; i++ )
565 : {
566 12425280 : EnergyL += (float) fabs( core_dec_freq[i] );
567 : }
568 : }
569 :
570 78602 : if ( total_brate <= ACELP_8k00 )
571 : {
572 31204 : alfa = 0.8f;
573 31204 : beta = 1.25f;
574 : }
575 : else
576 : {
577 47398 : alfa = 0.5f;
578 47398 : beta = 2.0f;
579 : }
580 : }
581 : else
582 : {
583 207030 : if ( prev_coder_type == AUDIO )
584 : {
585 12236 : for ( i = 80; i < 240; i++ )
586 : {
587 12160 : EnergyL += (float) fabs( core_dec_freq[i] );
588 : }
589 : }
590 : else
591 : {
592 16763274 : for ( i = 160; i < 240; i++ )
593 : {
594 16556320 : EnergyL += (float) fabs( core_dec_freq[i] );
595 : }
596 : }
597 :
598 207030 : if ( prev_coder_type == coder_type && WB_fenv[0] > prev_WB_fenv[0] )
599 : {
600 107917 : alfa = 0.4f;
601 107917 : beta = 2.5f;
602 : }
603 : else
604 : {
605 99113 : alfa = 0.6f;
606 99113 : beta = 1.67f;
607 : }
608 :
609 207030 : if ( coder_type == GENERIC || ( EnergyL > 0.5f * ( *prev_Energy ) && EnergyL < 2.0f * ( *prev_Energy ) && *prev_flag == 1 ) )
610 : {
611 3402 : WB_fenv[0] *= 0.5f;
612 3402 : WB_fenv[1] *= 0.5f;
613 3402 : flag = 1;
614 : }
615 : }
616 285632 : if ( ( mode == HARMONIC && WB_fenv[1] < 0.25f * WB_fenv[0] ) || mode == NORMAL )
617 : {
618 280345 : 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 150 : if ( WB_fenv[0] > prev_WB_fenv[0] )
621 : {
622 77 : wfenv[0] = 0.3f * WB_fenv[0] + 0.7f * prev_WB_fenv[0];
623 77 : wfenv[1] = 0.3f * WB_fenv[1] + 0.7f * prev_WB_fenv[1];
624 : }
625 : else
626 : {
627 73 : wfenv[0] = 0.5f * WB_fenv[0] + 0.5f * prev_WB_fenv[0];
628 73 : wfenv[1] = 0.4f * WB_fenv[1] + 0.4f * prev_WB_fenv[1];
629 : }
630 : }
631 280195 : 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 58129 : wfenv[0] = 0.3f * WB_fenv[0] + 0.7f * prev_WB_fenv[0];
634 58129 : wfenv[1] = 0.3f * WB_fenv[1] + 0.7f * prev_WB_fenv[1];
635 : }
636 222066 : else if ( last_extl == WB_BWE && EnergyL > alfa * ( *prev_Energy ) && EnergyL < beta * ( *prev_Energy ) && prev_coder_type != UNVOICED )
637 : {
638 134617 : wfenv[0] = 0.5f * ( WB_fenv[0] + prev_WB_fenv[0] );
639 134617 : wfenv[1] = 0.5f * ( WB_fenv[1] + prev_WB_fenv[1] );
640 : }
641 : else
642 : {
643 87449 : wfenv[0] = WB_fenv[0];
644 87449 : wfenv[1] = WB_fenv[1];
645 : }
646 11494145 : for ( n_freq = swb_bwe_subband[0]; n_freq < swb_bwe_subband[2]; n_freq++ )
647 : {
648 11213800 : WB_signal[n_freq] *= wfenv[0];
649 : }
650 :
651 11494145 : for ( n_freq = swb_bwe_subband[2]; n_freq < swb_bwe_subband[4]; n_freq++ )
652 : {
653 11213800 : WB_signal[n_freq] *= wfenv[1];
654 : }
655 :
656 280345 : prev_WB_fenv[0] = wfenv[0];
657 280345 : prev_WB_fenv[1] = wfenv[1];
658 : }
659 : else
660 : {
661 5287 : wfenv[0] = 0.5f * ( WB_fenv[0] + WB_fenv[1] );
662 :
663 5287 : if ( last_extl == WB_BWE && EnergyL > 0.5f * ( *prev_Energy ) && EnergyL < 2.0f * ( *prev_Energy ) )
664 : {
665 5121 : wfenv[0] = 0.25f * wfenv[0] + 0.375f * ( prev_WB_fenv[0] + prev_WB_fenv[1] );
666 : }
667 428247 : for ( n_freq = swb_bwe_subband[0]; n_freq < swb_bwe_subband[4]; n_freq++ )
668 : {
669 422960 : WB_signal[n_freq] *= wfenv[0];
670 : }
671 :
672 5287 : prev_WB_fenv[0] = wfenv[0];
673 5287 : prev_WB_fenv[1] = wfenv[0];
674 : }
675 :
676 285632 : *prev_flag = flag;
677 285632 : *prev_Energy = EnergyL;
678 285632 : pit1 = &WB_signal[240];
679 :
680 4855744 : for ( n_freq = 0; n_freq < 16; n_freq++ )
681 : {
682 4570112 : *( pit1++ ) *= ( 0.2f + n_freq * 0.05f );
683 : }
684 :
685 285632 : if ( core_type == 1 )
686 : {
687 78602 : pit1 = &WB_signal[280];
688 3222682 : for ( n_freq = 0; n_freq < 40; n_freq++ )
689 : {
690 3144080 : *( pit1++ ) *= ( 1.0f - n_freq * 0.02f );
691 : }
692 : }
693 : else
694 : {
695 207030 : pit1 = &WB_signal[300];
696 4347630 : for ( n_freq = 0; n_freq < 20; n_freq++ )
697 : {
698 4140600 : *( pit1++ ) *= ( 1.0f - n_freq * 0.04f );
699 : }
700 : }
701 :
702 285632 : return;
703 : }
704 :
705 : /*-------------------------------------------------------------------*
706 : * SWB_BWE_decoding()
707 : *
708 : * SWB BWE decoder
709 : *-------------------------------------------------------------------*/
710 :
711 235518 : 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 235518 : fenvL = EPSILON;
738 235518 : EnergyL = EPSILON;
739 4003806 : for ( n_freq = 224 + st_offset; n_freq < swb_bwe_trans_subband[0] + st_offset; n_freq++ )
740 : {
741 3768288 : fenvL += core_dec_freq[n_freq] * core_dec_freq[n_freq];
742 : }
743 :
744 56759838 : for ( n_freq = 16; n_freq < L_FRAME; n_freq++ )
745 : {
746 56524320 : EnergyL += core_dec_freq[n_freq] * core_dec_freq[n_freq];
747 : }
748 235518 : fenvL = (float) sqrt( fenvL / 16 );
749 235518 : EnergyL = (float) sqrt( EnergyL / 240 );
750 235518 : if ( fenvL > 8.0f * SWB_fenv[0] )
751 : {
752 77837 : fenvL = SWB_fenv[0];
753 : }
754 235518 : calc_normal_length( ACELP_CORE, core_dec_freq, mode, extl, &L_swb_norm, prev_L_swb_norm );
755 :
756 235518 : if ( mode == TRANSIENT )
757 : {
758 1618 : Energy = 0.0f;
759 8090 : for ( n_band = 0; n_band < SWB_FENV_TRANS; n_band++ )
760 : {
761 6472 : Energy += SWB_fenv[n_band] * SWB_fenv[n_band];
762 : }
763 1618 : Energy /= SWB_FENV_TRANS;
764 :
765 : /* Reconstruct excitation from LF signal */
766 1618 : mvr2r( &core_dec_freq[112], &SWB_signal[240 + st_offset], 128 );
767 1618 : mvr2r( &core_dec_freq[112], &SWB_signal[368 + st_offset], 128 );
768 1618 : mvr2r( &core_dec_freq[176], &SWB_signal[496 + st_offset], 64 );
769 :
770 : /* calculate envelope */
771 1618 : calc_norm_envelop( SWB_signal, envelope, L_swb_norm, SWB_flength, st_offset );
772 :
773 : /* Normalize with envelope */
774 519378 : 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 517760 : SWB_signal[n_freq] /= envelope[n_freq];
777 : }
778 :
779 8090 : for ( n_band = 0; n_band < SWB_FENV_TRANS; n_band++ )
780 : {
781 6472 : energy = EPSILON;
782 524232 : 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 517760 : energy += SWB_signal[n_freq] * SWB_signal[n_freq];
785 : }
786 :
787 6472 : tmp_ener = (float) ( sqrt( swb_bwe_trans_subband_width[n_band] / energy ) * SWB_fenv[n_band] );
788 :
789 524232 : 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 517760 : SWB_signal[n_freq] *= tmp_ener;
792 : }
793 : }
794 :
795 14562 : for ( n_band = 0; n_band < 8; n_band++ )
796 : {
797 12944 : prev_SWB_fenv[n_band] = SWB_fenv[n_band / 4] * SWB_fenv[n_band / 4];
798 : }
799 :
800 11326 : for ( n_band = 0; n_band < 6; n_band++ )
801 : {
802 9708 : prev_SWB_fenv[8 + n_band] = SWB_fenv[2 + n_band / 3] * SWB_fenv[2 + n_band / 3];
803 : }
804 :
805 1618 : *prev_weight = 0.5f;
806 : }
807 : else
808 : {
809 233900 : Energy = EPSILON;
810 3508500 : for ( n_band = 0; n_band < SWB_FENV; n_band++ )
811 : {
812 3274600 : Energy += SWB_fenv[n_band];
813 : }
814 233900 : Energy /= SWB_FENV;
815 233900 : if ( last_extl != SWB_BWE && last_extl != FB_BWE )
816 : {
817 112602 : if ( 16.0f * Energy < EnergyL && extl == FB_BWE )
818 : {
819 5175 : for ( n_band = 0; n_band < SWB_FENV; n_band++ )
820 : {
821 4830 : SWB_fenv[n_band] *= 0.2f;
822 : }
823 345 : fenvL *= 0.2f;
824 : }
825 112602 : mvr2r( SWB_fenv, prev_SWB_fenv, SWB_FENV );
826 : }
827 233900 : if ( mode == HARMONIC )
828 : {
829 1479 : mvr2r( core_dec_freq, &SWB_signal[240 + st_offset], 240 );
830 1479 : mvr2r( &core_dec_freq[128], &SWB_signal[480 + st_offset], 80 );
831 :
832 : /* calculate envelope */
833 1479 : calc_norm_envelop( SWB_signal, envelope, L_swb_norm, SWB_flength, st_offset );
834 : }
835 : else
836 : {
837 232421 : if ( mode == NOISE || ( ( Energy > EnergyL || ( tilt_nb > 7 && Energy > 0.5f * EnergyL ) || tilt_nb > 12 ) && Energy > 75 && fenvL > 25 ) )
838 : {
839 7145781 : for ( n_freq = swb_bwe_subband[0] + st_offset; n_freq < swb_bwe_subband[SWB_FENV] + st_offset; n_freq++ )
840 : {
841 7123520 : *Seed = (int16_t) ( 12345 * ( *Seed ) + 20101 );
842 7123520 : SWB_signal[n_freq] = ( *Seed ) / PCM16_TO_FLT_FAC;
843 : }
844 22261 : if ( mode != NOISE )
845 : {
846 2886 : *frica_flag = 1;
847 : }
848 : }
849 : else
850 : {
851 : /* modify SHB frequency envelopes when SHB spectrum is unflat */
852 2942240 : for ( n_band = 0; n_band < 13; n_band++ )
853 : {
854 2732080 : if ( SWB_fenv[n_band] * 0.9f > SWB_fenv[n_band + 1] )
855 : {
856 763845 : SWB_fenv[n_band + 1] *= ( 0.8f + 0.015f * n_band );
857 : }
858 1968235 : else if ( SWB_fenv[n_band + 1] * 0.9f > SWB_fenv[n_band] )
859 : {
860 683818 : SWB_fenv[n_band] *= ( 0.8f + 0.015f * n_band );
861 : }
862 : }
863 :
864 210160 : mvr2r( &core_dec_freq[112], &SWB_signal[240 + st_offset], 128 );
865 210160 : mvr2r( &core_dec_freq[112], &SWB_signal[368 + st_offset], 128 );
866 210160 : mvr2r( &core_dec_freq[176], &SWB_signal[496 + st_offset], 64 );
867 :
868 210160 : tmp1 = (float) ( fabs( SWB_signal[368 + st_offset] ) + fabs( SWB_signal[369 + st_offset] ) ) + EPSILON;
869 210160 : tmp2 = (float) ( fabs( SWB_signal[365 + st_offset] ) + fabs( SWB_signal[366 + st_offset] ) ) + EPSILON;
870 210160 : pit1 = &SWB_signal[368 + st_offset];
871 :
872 210160 : tmp3 = tmp2 / tmp1;
873 210160 : if ( tmp3 < 0.3 )
874 : {
875 47482 : tmp3 = 0.3f;
876 : }
877 :
878 810178 : while ( tmp3 < 1 )
879 : {
880 600018 : *pit1++ *= tmp3;
881 600018 : tmp3 += 0.1f;
882 : }
883 :
884 210160 : pit1 = &SWB_signal[367 + st_offset];
885 210160 : tmp3 = tmp1 / tmp2;
886 :
887 210160 : if ( tmp3 > 5 )
888 : {
889 33160 : tmp3 = 5;
890 298440 : while ( tmp3 > 1 )
891 : {
892 265280 : *pit1-- *= tmp3;
893 265280 : tmp3 -= 0.5f;
894 : }
895 : }
896 :
897 210160 : tmp1 = (float) ( fabs( SWB_signal[496 + st_offset] ) + fabs( SWB_signal[497 + st_offset] ) ) + EPSILON;
898 210160 : 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 210160 : pit1 = &SWB_signal[496 + st_offset];
900 :
901 210160 : tmp3 = tmp2 / tmp1;
902 210160 : if ( tmp3 < 0.3 )
903 : {
904 6253 : tmp3 = 0.3f;
905 : }
906 :
907 392904 : while ( tmp3 < 1 )
908 : {
909 182744 : *pit1++ *= tmp3;
910 182744 : tmp3 += 0.1f;
911 : }
912 :
913 210160 : pit1 = &SWB_signal[495 + st_offset];
914 :
915 210160 : tmp3 = tmp1 / tmp2;
916 210160 : tmp3 = 0.5f * tmp3;
917 210160 : tmp4 = 0.05f * tmp3;
918 :
919 327884 : while ( tmp3 > 1 )
920 : {
921 117724 : *pit1-- *= tmp3;
922 117724 : tmp3 -= tmp4;
923 : }
924 :
925 : /* calculate envelope */
926 210160 : calc_norm_envelop( SWB_signal, envelope, L_swb_norm, SWB_flength, st_offset );
927 : }
928 : }
929 :
930 : /* Normalize with envelope */
931 233900 : if ( *frica_flag == 0 && mode != NOISE )
932 : {
933 211639 : L = swb_bwe_subband[0] + st_offset;
934 211639 : inv_L_swb_norm = 1.0f / L_swb_norm;
935 211639 : weight = ( mode != HARMONIC ) ? max( min( 3.0f * inv_L_swb_norm, 0.5f ), 0.2f ) : 0.2f;
936 211639 : weight = 0.4f * weight + 0.6f * ( *prev_weight );
937 67936119 : for ( n_freq = L; n_freq < swb_bwe_subband[SWB_FENV] + st_offset; n_freq++ )
938 : {
939 67724480 : signum[n_freq] = 1;
940 67724480 : if ( SWB_signal[n_freq] < 0 )
941 : {
942 33649847 : signum[n_freq] = -1;
943 33649847 : SWB_signal[n_freq] *= signum[n_freq];
944 : }
945 :
946 67724480 : SWB_signal[n_freq] = SWB_signal[n_freq] - envelope[n_freq] * inv_L_swb_norm;
947 67724480 : if ( SWB_signal[n_freq] > 0 )
948 : {
949 29948820 : SWB_signal[n_freq] *= ( 1.2f - weight );
950 : }
951 67724480 : SWB_signal[n_freq] *= signum[n_freq];
952 : }
953 :
954 67936119 : for ( n_freq = L; n_freq < swb_bwe_subband[SWB_FENV] + st_offset; n_freq++ )
955 : {
956 67724480 : SWB_signal[n_freq] /= envelope[n_freq];
957 : }
958 :
959 211639 : *prev_weight = weight;
960 : }
961 : else
962 : {
963 22261 : *prev_weight = max( min( 3.0f / L_swb_norm, 0.5f ), 0.2f );
964 : }
965 :
966 233900 : if ( mode == HARMONIC )
967 : {
968 1479 : pit1 = &SWB_signal[swb_bwe_subband[0] + st_offset];
969 29580 : for ( n_band = 0; n_band < 19; n_band++ )
970 : {
971 28101 : mean = 0;
972 477717 : for ( n_freq = 0; n_freq < 16; n_freq++ )
973 : {
974 449616 : mean += (float) fabs( *pit1 );
975 449616 : pit1++;
976 : }
977 28101 : mean /= 16;
978 28101 : pit1 -= 16;
979 477717 : for ( n_freq = 0; n_freq < 16; n_freq++ )
980 : {
981 449616 : if ( fabs( *pit1 ) < mean )
982 : {
983 267137 : *pit1 *= 0.2f;
984 : }
985 449616 : pit1++;
986 : }
987 : }
988 : }
989 :
990 233900 : if ( mode == HARMONIC )
991 : {
992 1479 : L = 2;
993 : }
994 : else
995 : {
996 232421 : L = 1;
997 : }
998 :
999 3498147 : for ( n_band = 0; n_band < SWB_FENV; n_band += L )
1000 : {
1001 3264247 : energy = EPSILON;
1002 78112247 : for ( n_freq = swb_bwe_subband[n_band] + st_offset; n_freq < swb_bwe_subband[n_band + L] + st_offset; n_freq++ )
1003 : {
1004 74848000 : energy += SWB_signal[n_freq] * SWB_signal[n_freq];
1005 : }
1006 :
1007 3264247 : tmp_ener = (float) sqrt( ( swb_bwe_subband[n_band + L] - swb_bwe_subband[n_band] ) / energy );
1008 :
1009 78112247 : for ( n_freq = swb_bwe_subband[n_band] + st_offset; n_freq < swb_bwe_subband[n_band + L] + st_offset; n_freq++ )
1010 : {
1011 74848000 : SWB_signal[n_freq] *= tmp_ener;
1012 : }
1013 : }
1014 :
1015 233900 : if ( *prev_Energy > 1.25f * Energy && Energy > 0 )
1016 : {
1017 62038 : weight = 0.5f * Energy / ( *prev_Energy );
1018 : }
1019 : else
1020 : {
1021 171862 : weight = 0.5f;
1022 : }
1023 :
1024 233900 : wfenv = weight * prev_SWB_fenv[0] + ( 1 - weight ) * SWB_fenv[0];
1025 233900 : factor = fenvL;
1026 233900 : factor1 = ( wfenv - fenvL ) * 0.125f;
1027 2105100 : for ( n_freq = swb_bwe_subband[0] + st_offset; n_freq < swb_bwe_subband[0] + 8 + st_offset; n_freq++ )
1028 : {
1029 1871200 : SWB_signal[n_freq] *= factor;
1030 1871200 : factor += factor1;
1031 : }
1032 :
1033 3040700 : for ( n_band = 0; n_band < 12; n_band++ )
1034 : {
1035 2806800 : wfenv = weight * prev_SWB_fenv[n_band + 1] + ( 1 - weight ) * SWB_fenv[n_band + 1];
1036 2806800 : factor = SWB_fenv[n_band];
1037 2806800 : factor1 = ( wfenv - SWB_fenv[n_band] ) * smooth_factor[n_band];
1038 64556400 : for ( ; n_freq < swb_bwe_sm_subband[n_band + 1] + st_offset; n_freq++ )
1039 : {
1040 61749600 : SWB_signal[n_freq] *= factor;
1041 61749600 : factor += factor1;
1042 : }
1043 : }
1044 :
1045 233900 : wfenv = weight * prev_SWB_fenv[13] + ( 1 - weight ) * SWB_fenv[13];
1046 233900 : factor = SWB_fenv[12];
1047 233900 : factor1 = ( wfenv - SWB_fenv[12] ) * smooth_factor[12];
1048 7718700 : for ( ; n_freq < swb_bwe_sm_subband[13] + st_offset; n_freq++ )
1049 : {
1050 7484800 : SWB_signal[n_freq] *= factor;
1051 7484800 : factor += factor1;
1052 : }
1053 :
1054 467800 : for ( n_band = 13; n_band < SWB_FENV; n_band++ )
1055 : {
1056 233900 : wfenv = weight * prev_SWB_fenv[n_band] + ( 1 - weight ) * SWB_fenv[n_band];
1057 3976300 : for ( ; n_freq < swb_bwe_subband[n_band + 1] + st_offset; n_freq++ )
1058 : {
1059 3742400 : SWB_signal[n_freq] *= wfenv;
1060 : }
1061 : }
1062 :
1063 3508500 : for ( n_band = 0; n_band < SWB_FENV; n_band++ )
1064 : {
1065 3274600 : prev_SWB_fenv[n_band] = SWB_fenv[n_band];
1066 : }
1067 : }
1068 :
1069 235518 : pit1 = &SWB_signal[240 + st_offset];
1070 1177590 : for ( n_freq = 0; n_freq < 4; n_freq++ )
1071 : {
1072 942072 : *( pit1++ ) *= 0.5f;
1073 : }
1074 235518 : *prev_Energy = Energy;
1075 :
1076 235518 : return;
1077 : }
1078 :
1079 : /*-------------------------------------------------------------------*
1080 : * time_envelop_shaping()
1081 : *
1082 : * time shaping of the SHB signal
1083 : *-------------------------------------------------------------------*/
1084 :
1085 1618 : 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 1618 : pit = werr;
1097 8090 : for ( i = 0; i < SWB_TENV; i++ )
1098 : {
1099 6472 : Energy = EPSILON;
1100 1353032 : for ( j = 0; j < L / 4; j++ )
1101 : {
1102 1346560 : Energy += *pit * *pit;
1103 1346560 : pit++;
1104 : }
1105 6472 : Energy = (float) sqrt( 4 * Energy / L );
1106 :
1107 6472 : if ( SWB_tenv[i] < 2 && Energy < SWB_tenv[i] )
1108 : {
1109 1117 : SWB_tenv[i] = Energy;
1110 : }
1111 :
1112 6472 : pit -= L / 4;
1113 6472 : tmp_ener = 1.0f / Energy;
1114 1353032 : for ( j = 0; j < L / 4; j++ )
1115 : {
1116 1346560 : *pit *= SWB_tenv[i] * tmp_ener;
1117 1346560 : pit++;
1118 : }
1119 : }
1120 :
1121 1618 : return;
1122 : }
1123 :
1124 : /*-------------------------------------------------------------------*
1125 : * time_reduce_pre_echo()
1126 : *
1127 : * Pre-echo reduction.
1128 : *-------------------------------------------------------------------*/
1129 :
1130 1590 : 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 1590 : 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 7950 : for ( i = 0; i < 4; i++ )
1145 : {
1146 6360 : energyL[i] = 0;
1147 1335320 : for ( j = 0; j < L; j++ )
1148 : {
1149 1328960 : energyL[i] += synth[L * i + j] * synth[L * i + j];
1150 : }
1151 6360 : energyL[i] = (float) sqrt( energyL[i] / L );
1152 : }
1153 :
1154 6121 : for ( i = 0; i < 3; i++ )
1155 : {
1156 4663 : if ( energyL[i + 1] > 1.8f * energyL[i] && energyL[i + 1] > 50 )
1157 : {
1158 132 : pos = i + 1;
1159 132 : break;
1160 : }
1161 : }
1162 :
1163 1590 : if ( pos > 0 )
1164 : {
1165 132 : if ( pos < 3 )
1166 : {
1167 85 : pos++;
1168 : }
1169 :
1170 132 : energy = EPSILON;
1171 132 : j = L * pos;
1172 81892 : for ( i = 0; i < j; i++ )
1173 : {
1174 81760 : energy += error[i] * error[i];
1175 : }
1176 132 : energy = (float) sqrt( energy / j );
1177 :
1178 132 : if ( prev_td_energy < 0.2f * energy )
1179 : {
1180 108 : prev_td_energy = 0.2f * energy;
1181 : }
1182 :
1183 132 : tmp_ener = prev_td_energy / energy;
1184 81892 : for ( i = 0; i < j; i++ )
1185 : {
1186 81760 : error[i] *= tmp_ener;
1187 : }
1188 :
1189 132 : energy = EPSILON;
1190 29092 : for ( i = j; i < ( j + L ); i++ )
1191 : {
1192 28960 : energy += error[i] * error[i];
1193 : }
1194 132 : energy = (float) sqrt( energy / L );
1195 :
1196 132 : pit = &error[j];
1197 132 : tmp_ener = prev_td_energy / energy;
1198 29092 : for ( i = 0; i < L; i++ )
1199 : {
1200 28960 : tmpi = i / ( 1.0f * L );
1201 28960 : *pit++ *= ( ( 1.0f - tmpi ) * tmp_ener + tmpi );
1202 : }
1203 : }
1204 :
1205 1590 : return;
1206 : }
1207 :
1208 : /*-------------------------------------------------------------------*
1209 : * hq_generic_hf_decoding()
1210 : *
1211 : *-------------------------------------------------------------------*/
1212 39084 : 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 39084 : if ( hq_generic_offset <= HQ_GENERIC_FOFFSET_24K4 )
1237 : {
1238 38215 : nenv = SWB_FENV;
1239 : }
1240 : else
1241 : {
1242 869 : nenv = SWB_FENV - 2;
1243 : }
1244 :
1245 39084 : if ( HQ_mode == HQ_GEN_FB )
1246 : {
1247 21095 : tenv = nenv + DIM_FB;
1248 : }
1249 : else
1250 : {
1251 17989 : tenv = nenv;
1252 : }
1253 :
1254 39084 : fenvL = EPSILON;
1255 664428 : for ( n_freq = HQ_GENERIC_ST_FREQ + hq_generic_offset; n_freq < swb_bwe_subband[0] + hq_generic_offset; n_freq++ )
1256 : {
1257 625344 : fenvL += coeff_out1[n_freq] * coeff_out1[n_freq];
1258 : }
1259 :
1260 39084 : fenvL = (float) sqrt( fenvL / 16 );
1261 :
1262 39084 : calc_normal_length( HQ_CORE, coeff_out1, HQ_GEN_SWB, -1, &L_swb_norm, prev_L_swb_norm );
1263 :
1264 : /* calculate envelope */
1265 39084 : calc_norm_envelop_lf( coeff_out1, envelope, &L_swb_norm, HQ_mode, hq_generic_offset, &sfidx, &efidx );
1266 :
1267 39084 : blen = 16;
1268 39084 : if ( hq_generic_exc_clas == HQ_GENERIC_EXC0 )
1269 : {
1270 36015 : rn_weight0 = 0.8f;
1271 : }
1272 3069 : else if ( hq_generic_exc_clas == HQ_GENERIC_EXC1 )
1273 : {
1274 324 : rn_weight0 = 0.05f;
1275 : }
1276 : else
1277 : {
1278 2745 : rn_weight0 = 0.2f;
1279 : }
1280 :
1281 39084 : nband_lf = ( efidx - sfidx ) / blen;
1282 9028476 : for ( n_freq = sfidx; n_freq < efidx; n_freq++ )
1283 : {
1284 8989392 : if ( coeff_out1[n_freq] < 0 )
1285 : {
1286 4479572 : signum[n_freq] = -1;
1287 4479572 : coeff_out1[n_freq] *= signum[n_freq];
1288 : }
1289 : else
1290 : {
1291 4509820 : signum[n_freq] = 1;
1292 : }
1293 : }
1294 :
1295 : /* applying whitening */
1296 9028476 : for ( n_freq = sfidx; n_freq < efidx; n_freq++ )
1297 : {
1298 8989392 : coeff_out1[n_freq] = coeff_out1[n_freq] / envelope[n_freq];
1299 : }
1300 :
1301 : /* mean vector generation for controlling dynamic range */
1302 600921 : for ( k = 0; k < nband_lf; ++k )
1303 : {
1304 561837 : energy = EPSILON;
1305 9551229 : for ( i = k * blen + sfidx; i < ( k + 1 ) * blen + sfidx; ++i )
1306 : {
1307 8989392 : energy += coeff_out1[i];
1308 : }
1309 561837 : mean_vector[k] = energy / blen;
1310 : }
1311 :
1312 : /* dynamic range control */
1313 600921 : for ( k = 0; k < nband_lf; ++k )
1314 : {
1315 9551229 : for ( i = k * blen + sfidx; i < ( k + 1 ) * blen + sfidx; ++i )
1316 : {
1317 8989392 : coeff_out1[i] = coeff_out1[i] - ( coeff_out1[i] - mean_vector[k] ) * rn_weight0;
1318 : }
1319 : }
1320 :
1321 39084 : if ( hq_generic_exc_clas == HQ_GENERIC_EXC0 )
1322 : {
1323 : /* applying random sign */
1324 36015 : bwe_seed = R[0] * 8 + R[1] * 4 + R[2] * 2 + R[3];
1325 8353775 : for ( n_freq = sfidx; n_freq < efidx; n_freq++ )
1326 : {
1327 8317760 : 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 674701 : for ( n_freq = sfidx; n_freq < efidx; n_freq++ )
1333 : {
1334 671632 : coeff_out1[n_freq] = coeff_out1[n_freq] * signum[n_freq];
1335 : }
1336 : }
1337 :
1338 : /* normalizing modified low frequency spectrum */
1339 600921 : for ( k = 0; k < nband_lf; ++k )
1340 : {
1341 561837 : energy = EPSILON;
1342 9551229 : for ( i = k * blen + sfidx; i < ( k + 1 ) * blen + sfidx; ++i )
1343 : {
1344 8989392 : energy += coeff_out1[i] * coeff_out1[i];
1345 : }
1346 561837 : energy = (float) sqrt( energy / blen );
1347 :
1348 9551229 : for ( i = k * blen + sfidx; i < ( k + 1 ) * blen + sfidx; ++i )
1349 : {
1350 8989392 : coeff_out1[i] /= energy;
1351 : }
1352 : }
1353 39084 : mvr2r( coeff_out1 + HQ_GENERIC_OFFSET, &coeff_out[HQ_GENERIC_HIGH0 + hq_generic_offset], HQ_GENERIC_LEN0 );
1354 39084 : mvr2r( coeff_out1 + HQ_GENERIC_OFFSET, &coeff_out[HQ_GENERIC_HIGH1 + hq_generic_offset], HQ_GENERIC_LEN0 );
1355 :
1356 39084 : if ( hq_generic_offset <= HQ_GENERIC_FOFFSET_24K4 )
1357 : {
1358 38215 : mvr2r( &coeff_out1[HQ_GENERIC_LOW0], &coeff_out[HQ_GENERIC_HIGH2 + hq_generic_offset], HQ_GENERIC_END_FREQ - HQ_GENERIC_HIGH2 );
1359 : }
1360 :
1361 39084 : if ( HQ_mode == HQ_GEN_FB )
1362 : {
1363 21095 : if ( hq_generic_offset <= HQ_GENERIC_FOFFSET_24K4 )
1364 : {
1365 20830 : 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 265 : mvr2r( coeff_out1 + HQ_GENERIC_OFFSET + HQ_GENERIC_LEN0, &coeff_out[fb_bwe_subband[0]], 160 );
1370 : }
1371 : }
1372 39084 : tmp1 = EPSILON;
1373 39084 : tmp2 = EPSILON;
1374 234504 : for ( i = 0; i < 5; ++i )
1375 : {
1376 195420 : tmp1 += (float) fabs( coeff_out[HQ_GENERIC_HIGH1 + hq_generic_offset + i] );
1377 195420 : tmp2 += (float) fabs( coeff_out[HQ_GENERIC_HIGH1 - 2 + hq_generic_offset - i] );
1378 : }
1379 :
1380 39084 : pit1 = &coeff_out[HQ_GENERIC_HIGH1 + hq_generic_offset];
1381 39084 : tmp3 = tmp2 / tmp1;
1382 39084 : if ( tmp3 < 0.3f )
1383 : {
1384 24 : tmp3 = 0.3f;
1385 : }
1386 :
1387 74713 : while ( tmp3 < 1 )
1388 : {
1389 35629 : *pit1++ *= tmp3;
1390 35629 : tmp3 += 0.1f;
1391 : }
1392 :
1393 39084 : pit1 = &coeff_out[HQ_GENERIC_HIGH1 - 1 + hq_generic_offset];
1394 39084 : tmp3 = tmp1 / tmp2;
1395 39084 : if ( tmp3 > 5 )
1396 : {
1397 9 : tmp3 = 5;
1398 81 : while ( tmp3 > 1 )
1399 : {
1400 72 : *pit1-- *= tmp3;
1401 72 : tmp3 -= 0.5f;
1402 : }
1403 : }
1404 :
1405 39084 : if ( hq_generic_offset <= HQ_GENERIC_FOFFSET_24K4 )
1406 : {
1407 38215 : tmp1 = (float) ( fabs( coeff_out[HQ_GENERIC_HIGH2 + hq_generic_offset] ) + fabs( coeff_out[HQ_GENERIC_HIGH2 + 1 + hq_generic_offset] ) ) + EPSILON;
1408 38215 : 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 38215 : pit1 = &coeff_out[HQ_GENERIC_HIGH2 + hq_generic_offset];
1412 38215 : tmp3 = tmp2 / tmp1;
1413 38215 : if ( tmp3 < 0.3f )
1414 : {
1415 0 : tmp3 = 0.3f;
1416 : }
1417 :
1418 38441 : while ( tmp3 < 1 )
1419 : {
1420 226 : *pit1++ *= tmp3;
1421 226 : tmp3 += 0.1f;
1422 : }
1423 :
1424 38215 : pit1 = &coeff_out[HQ_GENERIC_HIGH2 - 1 + hq_generic_offset];
1425 38215 : tmp3 = tmp1 / tmp2;
1426 38215 : tmp3 = 0.5f * tmp3;
1427 38215 : tmp4 = 0.05f * tmp3;
1428 38232 : while ( tmp3 > 1 )
1429 : {
1430 17 : *pit1-- *= tmp3;
1431 17 : tmp3 -= tmp4;
1432 : }
1433 : }
1434 :
1435 39084 : wfenv = hq_generic_fenv[0];
1436 351756 : 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 312672 : factor = i * 0.125f;
1439 312672 : coeff_out[n_freq] *= ( ( 1 - factor ) * fenvL + factor * wfenv );
1440 : }
1441 :
1442 506354 : for ( n_band = 0; n_band < nenv - 2; n_band++ )
1443 : {
1444 467270 : wfenv = hq_generic_fenv[n_band + 1];
1445 10740258 : for ( i = 0; n_freq < swb_bwe_sm_subband[n_band + 1] + hq_generic_offset; n_freq++, i++ )
1446 : {
1447 10272988 : factor = i * smooth_factor[n_band];
1448 10272988 : coeff_out[n_freq] *= ( ( 1 - factor ) * hq_generic_fenv[n_band] + factor * wfenv );
1449 : }
1450 : }
1451 :
1452 39084 : wfenv = hq_generic_fenv[nenv - 1];
1453 1282820 : for ( i = 0; n_freq < swb_bwe_sm_subband[nenv - 1] + hq_generic_offset; n_freq++, i++ )
1454 : {
1455 1243736 : factor = i * smooth_factor[nenv - 2];
1456 :
1457 1243736 : coeff_out[n_freq] *= ( ( 1 - factor ) * hq_generic_fenv[nenv - 2] + factor * wfenv );
1458 : }
1459 :
1460 39084 : if ( HQ_mode == HQ_GEN_SWB )
1461 : {
1462 35978 : for ( n_band = nenv - 1; n_band < nenv; ++n_band )
1463 : {
1464 17989 : wfenv = hq_generic_fenv[n_band];
1465 303397 : for ( ; n_freq < swb_bwe_subband[n_band + 1] + hq_generic_offset; n_freq++ )
1466 : {
1467 285408 : coeff_out[n_freq] *= wfenv;
1468 : }
1469 : }
1470 : }
1471 : else
1472 : {
1473 21095 : if ( hq_generic_fenv[nenv - 1] - hq_generic_fenv[nenv] > 15.f || hq_generic_fenv[nenv] < 5.f )
1474 : {
1475 15357 : wfenv = hq_generic_fenv[nenv - 1];
1476 260137 : for ( i = 0; n_freq < fb_bwe_subband[0]; n_freq++, i++ )
1477 : {
1478 244780 : coeff_out[n_freq] *= wfenv;
1479 : }
1480 :
1481 61428 : for ( n_band = 0; n_band < DIM_FB; n_band++ )
1482 : {
1483 46071 : wfenv = hq_generic_fenv[n_band + nenv];
1484 2503191 : for ( i = 0; n_freq < fb_bwe_subband[n_band + 1]; n_freq++, i++ )
1485 : {
1486 2457120 : coeff_out[n_freq] *= wfenv;
1487 : }
1488 : }
1489 : }
1490 : else
1491 : {
1492 22952 : for ( n_band = 0; n_band < DIM_FB; n_band++ )
1493 : {
1494 17214 : wfenv = hq_generic_fenv[n_band + nenv - 1];
1495 :
1496 797454 : for ( i = 0; n_freq < fb_bwe_sm_subband[n_band]; n_freq++, i++ )
1497 : {
1498 780240 : factor = i * fb_smooth_factor[n_band];
1499 780240 : coeff_out[n_freq] *= ( ( 1 - factor ) * hq_generic_fenv[n_band + nenv] + factor * wfenv );
1500 : }
1501 : }
1502 :
1503 5738 : wfenv = hq_generic_fenv[tenv - 1];
1504 :
1505 235258 : for ( ; n_freq < fb_bwe_subband[DIM_FB]; n_freq++ )
1506 : {
1507 229520 : coeff_out[n_freq] *= wfenv;
1508 : }
1509 : }
1510 : }
1511 39084 : 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 5088556 : 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 5088556 : if ( L_frame == L_FRAME )
1534 : {
1535 2770519 : tmps = NS2SA( 12800, DELAY_FD_BWE_ENC_12k8_NS );
1536 : }
1537 : else
1538 : {
1539 2318037 : tmps = NS2SA( 16000, DELAY_FD_BWE_ENC_16k_NS );
1540 : }
1541 :
1542 5088556 : mvr2r( old_syn_mem, old_syn, tmps );
1543 5088556 : mvr2r( syn, old_syn + tmps, L_frame - tmps );
1544 5088556 : mvr2r( syn + L_frame - tmps, old_syn_mem, tmps );
1545 :
1546 5088556 : deemph( old_syn, preemph_fac, L_frame, mem_deemph );
1547 :
1548 5088556 : return;
1549 : }
|
