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 5100 : 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 5100 : float enerL, alfa = 1.0f;
68 : int16_t n_freq, mode;
69 5100 : int16_t ener_var_flag = 0;
70 : float voice_factor, pitch;
71 5100 : int16_t env_var_flag = 0;
72 :
73 5100 : mode = NORMAL;
74 :
75 5100 : enerL = EPSILON;
76 331500 : for ( n_freq = 128; n_freq < 192; n_freq++ )
77 : {
78 326400 : enerL += core_dec_freq[n_freq] * core_dec_freq[n_freq];
79 : }
80 5100 : WB_fenv[0] = EPSILON;
81 168300 : for ( n_freq = 192; n_freq < 224; n_freq++ )
82 : {
83 163200 : WB_fenv[0] += core_dec_freq[n_freq] * core_dec_freq[n_freq];
84 : }
85 :
86 5100 : WB_fenv[1] = EPSILON;
87 168300 : for ( n_freq = 224; n_freq < 256; n_freq++ )
88 : {
89 163200 : WB_fenv[1] += core_dec_freq[n_freq] * core_dec_freq[n_freq];
90 : }
91 :
92 5100 : voice_factor = sum_f( voice_factors, 4 );
93 5100 : pitch = sum_f( pitch_buf, 4 ) + EPSILON;
94 :
95 5100 : if ( enerL < 16.0f * max( WB_fenv[0], WB_fenv[1] ) && pitch < 308 )
96 : {
97 4750 : ener_var_flag = 1;
98 : }
99 :
100 5100 : if ( WB_fenv[0] > 2.0f * WB_fenv[1] )
101 : {
102 325 : alfa = max( 2.0f * WB_fenv[1] / WB_fenv[0], 0.1f );
103 325 : WB_fenv[0] *= alfa;
104 : }
105 4775 : else if ( 2.0f * WB_fenv[0] < WB_fenv[1] && coder_type != UNVOICED )
106 : {
107 3779 : alfa = max( 2.0f * WB_fenv[0] / WB_fenv[1], 0.1f );
108 3779 : WB_fenv[1] *= alfa;
109 : }
110 :
111 5100 : WB_fenv[0] = (float) sqrt( ( WB_fenv[0] + WB_fenv[1] ) / 64 );
112 :
113 5100 : if ( coder_type != AUDIO && coder_type != UNVOICED && ener_var_flag == 0 )
114 : {
115 350 : WB_fenv[0] *= 1.5f;
116 : }
117 :
118 5100 : 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 5100 : alfa = min( 1.5f, max( 0.5f, 77.0f * voice_factor / pitch ) );
130 5100 : 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 28 : env_var_flag = 1;
133 28 : WB_fenv[0] *= min( (float) ( 0.015625f * sqrt( enerL ) / WB_fenv[0] ), 4.0f );
134 :
135 28 : if ( WB_fenv[0] > prev_WB_fenv )
136 : {
137 26 : WB_fenv[0] = 0.3f * WB_fenv[0] + 0.7f * prev_WB_fenv;
138 : }
139 : }
140 :
141 5100 : if ( coder_type == UNVOICED || prev_coder_type == UNVOICED )
142 : {
143 52 : WB_fenv[0] *= 0.5f;
144 : }
145 :
146 5100 : if ( coder_type != AUDIO )
147 : {
148 5100 : WB_fenv[0] /= max( 1.2f * voice_factor, 1.0f );
149 5100 : WB_fenv[0] *= min( 2.0f, max( 0.125f, pitch / 400.0f ) );
150 : }
151 :
152 5100 : if ( last_core_brate > ACELP_8k00 && WB_fenv[0] > last_wb_bwe_ener )
153 : {
154 711 : WB_fenv[0] = 0.9f * last_wb_bwe_ener + 0.1f * WB_fenv[0];
155 : }
156 :
157 5100 : if ( last_extl != WB_BWE && ( tilt < 8.f ) )
158 : {
159 40 : WB_fenv[0] *= min( 0.5f, 16.0f * tilt );
160 : }
161 :
162 5100 : if ( env_var_flag == 1 )
163 : {
164 28 : WB_fenv[1] = 1.5f * WB_fenv[0];
165 28 : WB_fenv[0] *= 0.75f;
166 : }
167 : else
168 : {
169 5072 : WB_fenv[1] = WB_fenv[0];
170 : }
171 :
172 5100 : if ( coder_type == UNVOICED || prev_coder_type == UNVOICED )
173 : {
174 52 : WB_fenv[1] *= 0.5f;
175 : }
176 :
177 5100 : return ( mode );
178 : }
179 :
180 : /*-------------------------------------------------------------------*
181 : * calc_normal_length()
182 : *
183 : *-------------------------------------------------------------------*/
184 :
185 54655 : 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 54655 : if ( core == HQ_CORE || extl == SWB_BWE || extl == FB_BWE )
201 : {
202 39762 : THRES = 8;
203 : }
204 : else
205 : {
206 14893 : THRES = 4;
207 : }
208 :
209 54655 : if ( core == HQ_CORE && ( mode == HQ_HARMONIC || mode == HQ_HVQ ) )
210 : {
211 2122 : N = 13;
212 : }
213 : else
214 : {
215 52533 : N = 16;
216 : }
217 :
218 54655 : n_band = 0;
219 54655 : pit = sp;
220 922769 : for ( i = 0; i < N; i++ )
221 : {
222 868114 : peak = 0.0f;
223 868114 : mean = 0;
224 :
225 14757938 : for ( n_freq = 0; n_freq < 16; n_freq++ )
226 : {
227 13889824 : mag = (float) fabs( *pit );
228 13889824 : if ( mag > peak )
229 : {
230 2943317 : peak = mag;
231 : }
232 13889824 : mean += mag;
233 13889824 : pit++;
234 : }
235 :
236 868114 : if ( ( 15 + THRES ) * peak > THRES * mean && peak > 10 )
237 : {
238 84039 : n_band += 1;
239 : }
240 : }
241 :
242 54655 : if ( core == ACELP_CORE )
243 : {
244 46287 : L_swb_norm_trans = (int16_t) ( 4 + 0.25f * n_band );
245 46287 : L_swb_norm_norm = (int16_t) ( 8 + 0.5f * n_band );
246 46287 : L_swb_norm_harm = max( (int16_t) ( 32 + 2.0f * n_band ), 24 );
247 :
248 46287 : if ( mode == HARMONIC )
249 : {
250 2604 : L_swb_norm_cur = L_swb_norm_harm;
251 : }
252 43683 : else if ( mode == NORMAL )
253 : {
254 41031 : L_swb_norm_cur = L_swb_norm_norm;
255 : }
256 : else
257 : {
258 2652 : L_swb_norm_cur = L_swb_norm_trans;
259 : }
260 :
261 46287 : *L_swb_norm = (int16_t) ( 0.5f * L_swb_norm_cur + 0.5f * ( *prev_L_swb_norm ) );
262 46287 : *prev_L_swb_norm = L_swb_norm_cur;
263 : }
264 : else
265 : {
266 8368 : if ( mode == HQ_HARMONIC || mode == HQ_HVQ )
267 : {
268 2122 : L_swb_norm_cur = (int16_t) ( 32 + 2.5f * n_band );
269 : }
270 : else
271 : {
272 6246 : L_swb_norm_cur = (int16_t) ( 8 + 0.5f * n_band );
273 : }
274 :
275 8368 : *L_swb_norm = (int16_t) ( 0.1f * L_swb_norm_cur + 0.9f * ( *prev_L_swb_norm ) + 0.5f );
276 8368 : *prev_L_swb_norm = L_swb_norm_cur;
277 : }
278 :
279 54655 : return;
280 : }
281 : /*-------------------------------------------------------------------*
282 : * calc_tilt_bwe()
283 : *
284 : * calculate tilt parameter
285 : *-------------------------------------------------------------------*/
286 :
287 583855 : 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 583855 : r0 = EPSILON;
297 227084399 : for ( i = 0; i < N; i++ )
298 : {
299 226500544 : r0 += sp[i] * sp[i];
300 : }
301 :
302 583855 : r1 = (float) fabs( sp[1] - sp[0] );
303 225916689 : for ( i = 2; i < N; i++ )
304 : {
305 225332834 : if ( ( sp[i] - sp[i - 1] ) * ( sp[i - 1] - sp[i - 2] ) < 0 )
306 : {
307 62658473 : r1 += (float) fabs( sp[i] - sp[i - 1] );
308 : }
309 : }
310 :
311 583855 : *tilt = (float) ( r1 / sqrt( r0 ) );
312 :
313 583855 : return;
314 : }
315 :
316 : /*-------------------------------------------------------------------*
317 : * calc_norm_envelop()
318 : *
319 : * calculate normalized parameter
320 : *-------------------------------------------------------------------*/
321 :
322 46073 : 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 46073 : lookback = L_swb_norm / 2;
333 46073 : env_index = swb_bwe_subband[0] + st_offset;
334 46073 : n_lag_now = L_swb_norm;
335 11806207 : 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 11760134 : envelope[env_index] = EPSILON;
339 114701228 : for ( n_lag = 0; n_lag < n_lag_now; n_lag++ )
340 : {
341 102941094 : envelope[env_index] += (float) fabs( SWB_signal[n_freq + n_lag] );
342 : }
343 11760134 : env_index++;
344 : }
345 :
346 288499 : for ( n_freq = SWB_flength + st_offset - L_swb_norm, i = 0; n_freq < SWB_flength + st_offset - lookback; n_freq++, i++ )
347 : {
348 242426 : n_lag_now = L_swb_norm - i;
349 : /* Apply MA filter */
350 242426 : envelope[env_index] = EPSILON;
351 3669983 : for ( n_lag = 0; n_lag < n_lag_now; n_lag++ )
352 : {
353 3427557 : envelope[env_index] += (float) fabs( SWB_signal[n_freq + n_lag] );
354 : }
355 242426 : env_index++;
356 : }
357 :
358 46073 : return;
359 : }
360 :
361 :
362 : /*-------------------------------------------------------------------*
363 : * calc_norm_envelop_lf()
364 : *
365 : * calc_envelope of low frequency spectrum
366 : *-------------------------------------------------------------------*/
367 4198 : 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 4198 : *sfreq = 2;
379 4198 : if ( hq_generic_offset == HQ_GENERIC_FOFFSET_24K4 )
380 : {
381 4198 : *efreq = 146;
382 4198 : if ( HQ_mode == HQ_GEN_FB )
383 : {
384 3402 : *efreq = 306;
385 : }
386 4198 : if ( ( 328 - *efreq ) * 2 + 1 < *L_swb_norm )
387 : {
388 39 : *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 4198 : lookback = *L_swb_norm / 2;
405 4198 : env_index = 0;
406 4198 : n_lag_now = *L_swb_norm;
407 26834 : for ( n_freq = 0; n_freq < lookback; n_freq++ )
408 : {
409 22636 : envelope[env_index] = EPSILON;
410 330053 : for ( n_lag = 0; n_lag < lookback + n_freq; n_lag++ )
411 : {
412 307417 : envelope[env_index] += (float) fabs( SWB_signal[n_lag] );
413 : }
414 22636 : env_index++;
415 : }
416 1138790 : for ( ; n_freq < *efreq; n_freq++ )
417 : {
418 : /* Apply MA filter */
419 1134592 : envelope[env_index] = EPSILON;
420 13143746 : for ( n_lag = 0; n_lag < n_lag_now; n_lag++ )
421 : {
422 12009154 : envelope[env_index] += (float) fabs( SWB_signal[n_freq - lookback + n_lag] );
423 : }
424 1134592 : env_index++;
425 : }
426 4198 : return;
427 : }
428 :
429 : /*-------------------------------------------------------------------*
430 : * WB_BWE_decoding()
431 : *
432 : * WB BWE decoder
433 : *-------------------------------------------------------------------*/
434 :
435 9234 : 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 9234 : int16_t flag = 0;
461 9234 : int16_t core_type = 1;
462 : int16_t signum[L_FRAME16k];
463 : float inv_L_wb_norm, weight;
464 :
465 9234 : calc_normal_length( ACELP_CORE, core_dec_freq, mode, extl, &L_wb_norm, prev_L_wb_norm );
466 :
467 9234 : set_f( WB_signal, 0, L_FRAME16k );
468 :
469 : /* copy excitation */
470 9234 : if ( coder_type != AUDIO && total_brate <= ACELP_8k00 )
471 : {
472 4424 : core_type = 0;
473 : }
474 :
475 9234 : if ( core_type == 0 )
476 : {
477 4424 : mvr2r( &core_dec_freq[160], &WB_signal[240], 80 );
478 : }
479 : else
480 : {
481 4810 : mvr2r( &core_dec_freq[80], &WB_signal[240], 80 );
482 : }
483 :
484 : /* calculate envelope */
485 9234 : calc_norm_envelop( WB_signal, envelope, L_wb_norm, WB_flength, 0 );
486 :
487 9234 : if ( coder_type != UNVOICED && total_brate <= ACELP_8k00 )
488 : {
489 8073 : inv_L_wb_norm = 1.0f / L_wb_norm;
490 8073 : weight = ( mode != HARMONIC ) ? max( min( 3.0f * inv_L_wb_norm, 0.5f ), 0.25f ) : 0.25f;
491 653913 : for ( n_freq = swb_bwe_subband[0]; n_freq < swb_bwe_subband[4]; n_freq++ )
492 : {
493 645840 : signum[n_freq] = 1;
494 645840 : if ( WB_signal[n_freq] < 0 )
495 : {
496 323094 : signum[n_freq] = -1;
497 323094 : WB_signal[n_freq] *= signum[n_freq];
498 : }
499 :
500 645840 : WB_signal[n_freq] = WB_signal[n_freq] - 0.45f * envelope[n_freq] * inv_L_wb_norm;
501 645840 : if ( WB_signal[n_freq] > 0 )
502 : {
503 480592 : WB_signal[n_freq] *= ( 0.55f - weight );
504 : }
505 645840 : WB_signal[n_freq] *= signum[n_freq];
506 : }
507 : }
508 :
509 : /* Normalize with envelope */
510 747954 : for ( n_freq = swb_bwe_subband[0]; n_freq < swb_bwe_subband[4]; n_freq++ )
511 : {
512 738720 : WB_signal[n_freq] /= envelope[n_freq];
513 : }
514 :
515 9234 : if ( mode == HARMONIC )
516 : {
517 1468 : L = 4;
518 : }
519 : else
520 : {
521 7766 : L = 1;
522 : }
523 :
524 9234 : if ( coder_type == UNVOICED )
525 : {
526 3726 : for ( n_freq = swb_bwe_subband[0]; n_freq < swb_bwe_subband[4]; n_freq++ )
527 : {
528 3680 : *Seed = (int16_t) ( 12345 * ( *Seed ) + 20101 );
529 3680 : WB_signal[n_freq] = ( *Seed ) / PCM16_TO_FLT_FAC;
530 : }
531 : }
532 : else
533 : {
534 41536 : for ( n_band = 0; n_band < 4; n_band += L )
535 : {
536 32348 : energy = EPSILON;
537 767388 : for ( n_freq = swb_bwe_subband[n_band]; n_freq < swb_bwe_subband[n_band + L]; n_freq++ )
538 : {
539 735040 : energy += WB_signal[n_freq] * WB_signal[n_freq];
540 : }
541 :
542 32348 : energy = (float) sqrt( ( swb_bwe_subband[n_band + L] - swb_bwe_subband[n_band] ) / energy );
543 :
544 767388 : for ( n_freq = swb_bwe_subband[n_band]; n_freq < swb_bwe_subband[n_band + L]; n_freq++ )
545 : {
546 735040 : WB_signal[n_freq] *= energy;
547 : }
548 : }
549 : }
550 :
551 :
552 9234 : EnergyL = 0.0f;
553 9234 : if ( core_type == 1 )
554 : {
555 4810 : if ( prev_coder_type != AUDIO && total_brate <= ACELP_8k00 )
556 : {
557 4860 : for ( i = 160; i < 240; i++ )
558 : {
559 4800 : EnergyL += (float) fabs( core_dec_freq[i] );
560 : }
561 : }
562 : else
563 : {
564 764750 : for ( i = 80; i < 240; i++ )
565 : {
566 760000 : EnergyL += (float) fabs( core_dec_freq[i] );
567 : }
568 : }
569 :
570 4810 : if ( total_brate <= ACELP_8k00 )
571 : {
572 3677 : alfa = 0.8f;
573 3677 : beta = 1.25f;
574 : }
575 : else
576 : {
577 1133 : alfa = 0.5f;
578 1133 : beta = 2.0f;
579 : }
580 : }
581 : else
582 : {
583 4424 : if ( prev_coder_type == AUDIO )
584 : {
585 644 : for ( i = 80; i < 240; i++ )
586 : {
587 640 : EnergyL += (float) fabs( core_dec_freq[i] );
588 : }
589 : }
590 : else
591 : {
592 358020 : for ( i = 160; i < 240; i++ )
593 : {
594 353600 : EnergyL += (float) fabs( core_dec_freq[i] );
595 : }
596 : }
597 :
598 4424 : if ( prev_coder_type == coder_type && WB_fenv[0] > prev_WB_fenv[0] )
599 : {
600 2283 : alfa = 0.4f;
601 2283 : beta = 2.5f;
602 : }
603 : else
604 : {
605 2141 : alfa = 0.6f;
606 2141 : beta = 1.67f;
607 : }
608 :
609 4424 : if ( coder_type == GENERIC || ( EnergyL > 0.5f * ( *prev_Energy ) && EnergyL < 2.0f * ( *prev_Energy ) && *prev_flag == 1 ) )
610 : {
611 56 : WB_fenv[0] *= 0.5f;
612 56 : WB_fenv[1] *= 0.5f;
613 56 : flag = 1;
614 : }
615 : }
616 9234 : if ( ( mode == HARMONIC && WB_fenv[1] < 0.25f * WB_fenv[0] ) || mode == NORMAL )
617 : {
618 7790 : 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 8 : if ( WB_fenv[0] > prev_WB_fenv[0] )
621 : {
622 4 : wfenv[0] = 0.3f * WB_fenv[0] + 0.7f * prev_WB_fenv[0];
623 4 : wfenv[1] = 0.3f * WB_fenv[1] + 0.7f * prev_WB_fenv[1];
624 : }
625 : else
626 : {
627 4 : wfenv[0] = 0.5f * WB_fenv[0] + 0.5f * prev_WB_fenv[0];
628 4 : wfenv[1] = 0.4f * WB_fenv[1] + 0.4f * prev_WB_fenv[1];
629 : }
630 : }
631 7782 : 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 1182 : wfenv[0] = 0.3f * WB_fenv[0] + 0.7f * prev_WB_fenv[0];
634 1182 : wfenv[1] = 0.3f * WB_fenv[1] + 0.7f * prev_WB_fenv[1];
635 : }
636 6600 : else if ( last_extl == WB_BWE && EnergyL > alfa * ( *prev_Energy ) && EnergyL < beta * ( *prev_Energy ) && prev_coder_type != UNVOICED )
637 : {
638 3816 : wfenv[0] = 0.5f * ( WB_fenv[0] + prev_WB_fenv[0] );
639 3816 : wfenv[1] = 0.5f * ( WB_fenv[1] + prev_WB_fenv[1] );
640 : }
641 : else
642 : {
643 2784 : wfenv[0] = WB_fenv[0];
644 2784 : wfenv[1] = WB_fenv[1];
645 : }
646 319390 : for ( n_freq = swb_bwe_subband[0]; n_freq < swb_bwe_subband[2]; n_freq++ )
647 : {
648 311600 : WB_signal[n_freq] *= wfenv[0];
649 : }
650 :
651 319390 : for ( n_freq = swb_bwe_subband[2]; n_freq < swb_bwe_subband[4]; n_freq++ )
652 : {
653 311600 : WB_signal[n_freq] *= wfenv[1];
654 : }
655 :
656 7790 : prev_WB_fenv[0] = wfenv[0];
657 7790 : prev_WB_fenv[1] = wfenv[1];
658 : }
659 : else
660 : {
661 1444 : wfenv[0] = 0.5f * ( WB_fenv[0] + WB_fenv[1] );
662 :
663 1444 : if ( last_extl == WB_BWE && EnergyL > 0.5f * ( *prev_Energy ) && EnergyL < 2.0f * ( *prev_Energy ) )
664 : {
665 1400 : wfenv[0] = 0.25f * wfenv[0] + 0.375f * ( prev_WB_fenv[0] + prev_WB_fenv[1] );
666 : }
667 116964 : for ( n_freq = swb_bwe_subband[0]; n_freq < swb_bwe_subband[4]; n_freq++ )
668 : {
669 115520 : WB_signal[n_freq] *= wfenv[0];
670 : }
671 :
672 1444 : prev_WB_fenv[0] = wfenv[0];
673 1444 : prev_WB_fenv[1] = wfenv[0];
674 : }
675 :
676 9234 : *prev_flag = flag;
677 9234 : *prev_Energy = EnergyL;
678 9234 : pit1 = &WB_signal[240];
679 :
680 156978 : for ( n_freq = 0; n_freq < 16; n_freq++ )
681 : {
682 147744 : *( pit1++ ) *= ( 0.2f + n_freq * 0.05f );
683 : }
684 :
685 9234 : if ( core_type == 1 )
686 : {
687 4810 : pit1 = &WB_signal[280];
688 197210 : for ( n_freq = 0; n_freq < 40; n_freq++ )
689 : {
690 192400 : *( pit1++ ) *= ( 1.0f - n_freq * 0.02f );
691 : }
692 : }
693 : else
694 : {
695 4424 : pit1 = &WB_signal[300];
696 92904 : for ( n_freq = 0; n_freq < 20; n_freq++ )
697 : {
698 88480 : *( pit1++ ) *= ( 1.0f - n_freq * 0.04f );
699 : }
700 : }
701 :
702 9234 : return;
703 : }
704 :
705 : /*-------------------------------------------------------------------*
706 : * SWB_BWE_decoding()
707 : *
708 : * SWB BWE decoder
709 : *-------------------------------------------------------------------*/
710 :
711 26908 : 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 26908 : fenvL = EPSILON;
738 26908 : EnergyL = EPSILON;
739 457436 : for ( n_freq = 224 + st_offset; n_freq < swb_bwe_trans_subband[0] + st_offset; n_freq++ )
740 : {
741 430528 : fenvL += core_dec_freq[n_freq] * core_dec_freq[n_freq];
742 : }
743 :
744 6484828 : for ( n_freq = 16; n_freq < L_FRAME; n_freq++ )
745 : {
746 6457920 : EnergyL += core_dec_freq[n_freq] * core_dec_freq[n_freq];
747 : }
748 26908 : fenvL = (float) sqrt( fenvL / 16 );
749 26908 : EnergyL = (float) sqrt( EnergyL / 240 );
750 26908 : if ( fenvL > 8.0f * SWB_fenv[0] )
751 : {
752 2208 : fenvL = SWB_fenv[0];
753 : }
754 26908 : calc_normal_length( ACELP_CORE, core_dec_freq, mode, extl, &L_swb_norm, prev_L_swb_norm );
755 :
756 26908 : if ( mode == TRANSIENT )
757 : {
758 80 : Energy = 0.0f;
759 400 : for ( n_band = 0; n_band < SWB_FENV_TRANS; n_band++ )
760 : {
761 320 : Energy += SWB_fenv[n_band] * SWB_fenv[n_band];
762 : }
763 80 : Energy /= SWB_FENV_TRANS;
764 :
765 : /* Reconstruct excitation from LF signal */
766 80 : mvr2r( &core_dec_freq[112], &SWB_signal[240 + st_offset], 128 );
767 80 : mvr2r( &core_dec_freq[112], &SWB_signal[368 + st_offset], 128 );
768 80 : mvr2r( &core_dec_freq[176], &SWB_signal[496 + st_offset], 64 );
769 :
770 : /* calculate envelope */
771 80 : calc_norm_envelop( SWB_signal, envelope, L_swb_norm, SWB_flength, st_offset );
772 :
773 : /* Normalize with envelope */
774 25680 : 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 25600 : SWB_signal[n_freq] /= envelope[n_freq];
777 : }
778 :
779 400 : for ( n_band = 0; n_band < SWB_FENV_TRANS; n_band++ )
780 : {
781 320 : energy = EPSILON;
782 25920 : 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 25600 : energy += SWB_signal[n_freq] * SWB_signal[n_freq];
785 : }
786 :
787 320 : tmp_ener = (float) ( sqrt( swb_bwe_trans_subband_width[n_band] / energy ) * SWB_fenv[n_band] );
788 :
789 25920 : 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 25600 : SWB_signal[n_freq] *= tmp_ener;
792 : }
793 : }
794 :
795 720 : for ( n_band = 0; n_band < 8; n_band++ )
796 : {
797 640 : prev_SWB_fenv[n_band] = SWB_fenv[n_band / 4] * SWB_fenv[n_band / 4];
798 : }
799 :
800 560 : for ( n_band = 0; n_band < 6; n_band++ )
801 : {
802 480 : prev_SWB_fenv[8 + n_band] = SWB_fenv[2 + n_band / 3] * SWB_fenv[2 + n_band / 3];
803 : }
804 :
805 80 : *prev_weight = 0.5f;
806 : }
807 : else
808 : {
809 26828 : Energy = EPSILON;
810 402420 : for ( n_band = 0; n_band < SWB_FENV; n_band++ )
811 : {
812 375592 : Energy += SWB_fenv[n_band];
813 : }
814 26828 : Energy /= SWB_FENV;
815 26828 : if ( last_extl != SWB_BWE && last_extl != FB_BWE )
816 : {
817 6320 : if ( 16.0f * Energy < EnergyL && extl == FB_BWE )
818 : {
819 105 : for ( n_band = 0; n_band < SWB_FENV; n_band++ )
820 : {
821 98 : SWB_fenv[n_band] *= 0.2f;
822 : }
823 7 : fenvL *= 0.2f;
824 : }
825 6320 : mvr2r( SWB_fenv, prev_SWB_fenv, SWB_FENV );
826 : }
827 26828 : if ( mode == HARMONIC )
828 : {
829 295 : mvr2r( core_dec_freq, &SWB_signal[240 + st_offset], 240 );
830 295 : mvr2r( &core_dec_freq[128], &SWB_signal[480 + st_offset], 80 );
831 :
832 : /* calculate envelope */
833 295 : calc_norm_envelop( SWB_signal, envelope, L_swb_norm, SWB_flength, st_offset );
834 : }
835 : else
836 : {
837 26533 : if ( mode == NOISE || ( ( Energy > EnergyL || ( tilt_nb > 7 && Energy > 0.5f * EnergyL ) || tilt_nb > 12 ) && Energy > 75 && fenvL > 25 ) )
838 : {
839 726102 : for ( n_freq = swb_bwe_subband[0] + st_offset; n_freq < swb_bwe_subband[SWB_FENV] + st_offset; n_freq++ )
840 : {
841 723840 : *Seed = (int16_t) ( 12345 * ( *Seed ) + 20101 );
842 723840 : SWB_signal[n_freq] = ( *Seed ) / PCM16_TO_FLT_FAC;
843 : }
844 2262 : if ( mode != NOISE )
845 : {
846 223 : *frica_flag = 1;
847 : }
848 : }
849 : else
850 : {
851 : /* modify SHB frequency envelopes when SHB spectrum is unflat */
852 339794 : for ( n_band = 0; n_band < 13; n_band++ )
853 : {
854 315523 : if ( SWB_fenv[n_band] * 0.9f > SWB_fenv[n_band + 1] )
855 : {
856 112778 : SWB_fenv[n_band + 1] *= ( 0.8f + 0.015f * n_band );
857 : }
858 202745 : else if ( SWB_fenv[n_band + 1] * 0.9f > SWB_fenv[n_band] )
859 : {
860 104180 : SWB_fenv[n_band] *= ( 0.8f + 0.015f * n_band );
861 : }
862 : }
863 :
864 24271 : mvr2r( &core_dec_freq[112], &SWB_signal[240 + st_offset], 128 );
865 24271 : mvr2r( &core_dec_freq[112], &SWB_signal[368 + st_offset], 128 );
866 24271 : mvr2r( &core_dec_freq[176], &SWB_signal[496 + st_offset], 64 );
867 :
868 24271 : tmp1 = (float) ( fabs( SWB_signal[368 + st_offset] ) + fabs( SWB_signal[369 + st_offset] ) ) + EPSILON;
869 24271 : tmp2 = (float) ( fabs( SWB_signal[365 + st_offset] ) + fabs( SWB_signal[366 + st_offset] ) ) + EPSILON;
870 24271 : pit1 = &SWB_signal[368 + st_offset];
871 :
872 24271 : tmp3 = tmp2 / tmp1;
873 24271 : if ( tmp3 < 0.3 )
874 : {
875 8146 : tmp3 = 0.3f;
876 : }
877 :
878 121770 : while ( tmp3 < 1 )
879 : {
880 97499 : *pit1++ *= tmp3;
881 97499 : tmp3 += 0.1f;
882 : }
883 :
884 24271 : pit1 = &SWB_signal[367 + st_offset];
885 24271 : tmp3 = tmp1 / tmp2;
886 :
887 24271 : if ( tmp3 > 5 )
888 : {
889 5832 : tmp3 = 5;
890 52488 : while ( tmp3 > 1 )
891 : {
892 46656 : *pit1-- *= tmp3;
893 46656 : tmp3 -= 0.5f;
894 : }
895 : }
896 :
897 24271 : tmp1 = (float) ( fabs( SWB_signal[496 + st_offset] ) + fabs( SWB_signal[497 + st_offset] ) ) + EPSILON;
898 24271 : 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 24271 : pit1 = &SWB_signal[496 + st_offset];
900 :
901 24271 : tmp3 = tmp2 / tmp1;
902 24271 : if ( tmp3 < 0.3 )
903 : {
904 819 : tmp3 = 0.3f;
905 : }
906 :
907 50947 : while ( tmp3 < 1 )
908 : {
909 26676 : *pit1++ *= tmp3;
910 26676 : tmp3 += 0.1f;
911 : }
912 :
913 24271 : pit1 = &SWB_signal[495 + st_offset];
914 :
915 24271 : tmp3 = tmp1 / tmp2;
916 24271 : tmp3 = 0.5f * tmp3;
917 24271 : tmp4 = 0.05f * tmp3;
918 :
919 40182 : while ( tmp3 > 1 )
920 : {
921 15911 : *pit1-- *= tmp3;
922 15911 : tmp3 -= tmp4;
923 : }
924 :
925 : /* calculate envelope */
926 24271 : calc_norm_envelop( SWB_signal, envelope, L_swb_norm, SWB_flength, st_offset );
927 : }
928 : }
929 :
930 : /* Normalize with envelope */
931 26828 : if ( *frica_flag == 0 && mode != NOISE )
932 : {
933 24566 : L = swb_bwe_subband[0] + st_offset;
934 24566 : inv_L_swb_norm = 1.0f / L_swb_norm;
935 24566 : weight = ( mode != HARMONIC ) ? max( min( 3.0f * inv_L_swb_norm, 0.5f ), 0.2f ) : 0.2f;
936 24566 : weight = 0.4f * weight + 0.6f * ( *prev_weight );
937 7885686 : for ( n_freq = L; n_freq < swb_bwe_subband[SWB_FENV] + st_offset; n_freq++ )
938 : {
939 7861120 : signum[n_freq] = 1;
940 7861120 : if ( SWB_signal[n_freq] < 0 )
941 : {
942 3932525 : signum[n_freq] = -1;
943 3932525 : SWB_signal[n_freq] *= signum[n_freq];
944 : }
945 :
946 7861120 : SWB_signal[n_freq] = SWB_signal[n_freq] - envelope[n_freq] * inv_L_swb_norm;
947 7861120 : if ( SWB_signal[n_freq] > 0 )
948 : {
949 3469740 : SWB_signal[n_freq] *= ( 1.2f - weight );
950 : }
951 7861120 : SWB_signal[n_freq] *= signum[n_freq];
952 : }
953 :
954 7885686 : for ( n_freq = L; n_freq < swb_bwe_subband[SWB_FENV] + st_offset; n_freq++ )
955 : {
956 7861120 : SWB_signal[n_freq] /= envelope[n_freq];
957 : }
958 :
959 24566 : *prev_weight = weight;
960 : }
961 : else
962 : {
963 2262 : *prev_weight = max( min( 3.0f / L_swb_norm, 0.5f ), 0.2f );
964 : }
965 :
966 26828 : if ( mode == HARMONIC )
967 : {
968 295 : pit1 = &SWB_signal[swb_bwe_subband[0] + st_offset];
969 5900 : for ( n_band = 0; n_band < 19; n_band++ )
970 : {
971 5605 : mean = 0;
972 95285 : for ( n_freq = 0; n_freq < 16; n_freq++ )
973 : {
974 89680 : mean += (float) fabs( *pit1 );
975 89680 : pit1++;
976 : }
977 5605 : mean /= 16;
978 5605 : pit1 -= 16;
979 95285 : for ( n_freq = 0; n_freq < 16; n_freq++ )
980 : {
981 89680 : if ( fabs( *pit1 ) < mean )
982 : {
983 53228 : *pit1 *= 0.2f;
984 : }
985 89680 : pit1++;
986 : }
987 : }
988 : }
989 :
990 26828 : if ( mode == HARMONIC )
991 : {
992 295 : L = 2;
993 : }
994 : else
995 : {
996 26533 : L = 1;
997 : }
998 :
999 400355 : for ( n_band = 0; n_band < SWB_FENV; n_band += L )
1000 : {
1001 373527 : energy = EPSILON;
1002 8958487 : for ( n_freq = swb_bwe_subband[n_band] + st_offset; n_freq < swb_bwe_subband[n_band + L] + st_offset; n_freq++ )
1003 : {
1004 8584960 : energy += SWB_signal[n_freq] * SWB_signal[n_freq];
1005 : }
1006 :
1007 373527 : tmp_ener = (float) sqrt( ( swb_bwe_subband[n_band + L] - swb_bwe_subband[n_band] ) / energy );
1008 :
1009 8958487 : for ( n_freq = swb_bwe_subband[n_band] + st_offset; n_freq < swb_bwe_subband[n_band + L] + st_offset; n_freq++ )
1010 : {
1011 8584960 : SWB_signal[n_freq] *= tmp_ener;
1012 : }
1013 : }
1014 :
1015 26828 : if ( *prev_Energy > 1.25f * Energy && Energy > 0 )
1016 : {
1017 3819 : weight = 0.5f * Energy / ( *prev_Energy );
1018 : }
1019 : else
1020 : {
1021 23009 : weight = 0.5f;
1022 : }
1023 :
1024 26828 : wfenv = weight * prev_SWB_fenv[0] + ( 1 - weight ) * SWB_fenv[0];
1025 26828 : factor = fenvL;
1026 26828 : factor1 = ( wfenv - fenvL ) * 0.125f;
1027 241452 : for ( n_freq = swb_bwe_subband[0] + st_offset; n_freq < swb_bwe_subband[0] + 8 + st_offset; n_freq++ )
1028 : {
1029 214624 : SWB_signal[n_freq] *= factor;
1030 214624 : factor += factor1;
1031 : }
1032 :
1033 348764 : for ( n_band = 0; n_band < 12; n_band++ )
1034 : {
1035 321936 : wfenv = weight * prev_SWB_fenv[n_band + 1] + ( 1 - weight ) * SWB_fenv[n_band + 1];
1036 321936 : factor = SWB_fenv[n_band];
1037 321936 : factor1 = ( wfenv - SWB_fenv[n_band] ) * smooth_factor[n_band];
1038 7404528 : for ( ; n_freq < swb_bwe_sm_subband[n_band + 1] + st_offset; n_freq++ )
1039 : {
1040 7082592 : SWB_signal[n_freq] *= factor;
1041 7082592 : factor += factor1;
1042 : }
1043 : }
1044 :
1045 26828 : wfenv = weight * prev_SWB_fenv[13] + ( 1 - weight ) * SWB_fenv[13];
1046 26828 : factor = SWB_fenv[12];
1047 26828 : factor1 = ( wfenv - SWB_fenv[12] ) * smooth_factor[12];
1048 885324 : for ( ; n_freq < swb_bwe_sm_subband[13] + st_offset; n_freq++ )
1049 : {
1050 858496 : SWB_signal[n_freq] *= factor;
1051 858496 : factor += factor1;
1052 : }
1053 :
1054 53656 : for ( n_band = 13; n_band < SWB_FENV; n_band++ )
1055 : {
1056 26828 : wfenv = weight * prev_SWB_fenv[n_band] + ( 1 - weight ) * SWB_fenv[n_band];
1057 456076 : for ( ; n_freq < swb_bwe_subband[n_band + 1] + st_offset; n_freq++ )
1058 : {
1059 429248 : SWB_signal[n_freq] *= wfenv;
1060 : }
1061 : }
1062 :
1063 402420 : for ( n_band = 0; n_band < SWB_FENV; n_band++ )
1064 : {
1065 375592 : prev_SWB_fenv[n_band] = SWB_fenv[n_band];
1066 : }
1067 : }
1068 :
1069 26908 : pit1 = &SWB_signal[240 + st_offset];
1070 134540 : for ( n_freq = 0; n_freq < 4; n_freq++ )
1071 : {
1072 107632 : *( pit1++ ) *= 0.5f;
1073 : }
1074 26908 : *prev_Energy = Energy;
1075 :
1076 26908 : return;
1077 : }
1078 :
1079 : /*-------------------------------------------------------------------*
1080 : * time_envelop_shaping()
1081 : *
1082 : * time shaping of the SHB signal
1083 : *-------------------------------------------------------------------*/
1084 :
1085 80 : 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 80 : pit = werr;
1097 400 : for ( i = 0; i < SWB_TENV; i++ )
1098 : {
1099 320 : Energy = EPSILON;
1100 70720 : for ( j = 0; j < L / 4; j++ )
1101 : {
1102 70400 : Energy += *pit * *pit;
1103 70400 : pit++;
1104 : }
1105 320 : Energy = (float) sqrt( 4 * Energy / L );
1106 :
1107 320 : if ( SWB_tenv[i] < 2 && Energy < SWB_tenv[i] )
1108 : {
1109 2 : SWB_tenv[i] = Energy;
1110 : }
1111 :
1112 320 : pit -= L / 4;
1113 320 : tmp_ener = 1.0f / Energy;
1114 70720 : for ( j = 0; j < L / 4; j++ )
1115 : {
1116 70400 : *pit *= SWB_tenv[i] * tmp_ener;
1117 70400 : pit++;
1118 : }
1119 : }
1120 :
1121 80 : return;
1122 : }
1123 :
1124 : /*-------------------------------------------------------------------*
1125 : * time_reduce_pre_echo()
1126 : *
1127 : * Pre-echo reduction.
1128 : *-------------------------------------------------------------------*/
1129 :
1130 145 : 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 145 : 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 725 : for ( i = 0; i < 4; i++ )
1145 : {
1146 580 : energyL[i] = 0;
1147 132740 : for ( j = 0; j < L; j++ )
1148 : {
1149 132160 : energyL[i] += synth[L * i + j] * synth[L * i + j];
1150 : }
1151 580 : energyL[i] = (float) sqrt( energyL[i] / L );
1152 : }
1153 :
1154 554 : for ( i = 0; i < 3; i++ )
1155 : {
1156 423 : if ( energyL[i + 1] > 1.8f * energyL[i] && energyL[i + 1] > 50 )
1157 : {
1158 14 : pos = i + 1;
1159 14 : break;
1160 : }
1161 : }
1162 :
1163 145 : if ( pos > 0 )
1164 : {
1165 14 : if ( pos < 3 )
1166 : {
1167 7 : pos++;
1168 : }
1169 :
1170 14 : energy = EPSILON;
1171 14 : j = L * pos;
1172 8894 : for ( i = 0; i < j; i++ )
1173 : {
1174 8880 : energy += error[i] * error[i];
1175 : }
1176 14 : energy = (float) sqrt( energy / j );
1177 :
1178 14 : if ( prev_td_energy < 0.2f * energy )
1179 : {
1180 9 : prev_td_energy = 0.2f * energy;
1181 : }
1182 :
1183 14 : tmp_ener = prev_td_energy / energy;
1184 8894 : for ( i = 0; i < j; i++ )
1185 : {
1186 8880 : error[i] *= tmp_ener;
1187 : }
1188 :
1189 14 : energy = EPSILON;
1190 3374 : for ( i = j; i < ( j + L ); i++ )
1191 : {
1192 3360 : energy += error[i] * error[i];
1193 : }
1194 14 : energy = (float) sqrt( energy / L );
1195 :
1196 14 : pit = &error[j];
1197 14 : tmp_ener = prev_td_energy / energy;
1198 3374 : for ( i = 0; i < L; i++ )
1199 : {
1200 3360 : tmpi = i / ( 1.0f * L );
1201 3360 : *pit++ *= ( ( 1.0f - tmpi ) * tmp_ener + tmpi );
1202 : }
1203 : }
1204 :
1205 145 : return;
1206 : }
1207 :
1208 : /*-------------------------------------------------------------------*
1209 : * hq_generic_hf_decoding()
1210 : *
1211 : *-------------------------------------------------------------------*/
1212 4198 : 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 4198 : if ( hq_generic_offset <= HQ_GENERIC_FOFFSET_24K4 )
1237 : {
1238 4198 : nenv = SWB_FENV;
1239 : }
1240 : else
1241 : {
1242 0 : nenv = SWB_FENV - 2;
1243 : }
1244 :
1245 4198 : if ( HQ_mode == HQ_GEN_FB )
1246 : {
1247 3402 : tenv = nenv + DIM_FB;
1248 : }
1249 : else
1250 : {
1251 796 : tenv = nenv;
1252 : }
1253 :
1254 4198 : fenvL = EPSILON;
1255 71366 : for ( n_freq = HQ_GENERIC_ST_FREQ + hq_generic_offset; n_freq < swb_bwe_subband[0] + hq_generic_offset; n_freq++ )
1256 : {
1257 67168 : fenvL += coeff_out1[n_freq] * coeff_out1[n_freq];
1258 : }
1259 :
1260 4198 : fenvL = (float) sqrt( fenvL / 16 );
1261 :
1262 4198 : calc_normal_length( HQ_CORE, coeff_out1, HQ_GEN_SWB, -1, &L_swb_norm, prev_L_swb_norm );
1263 :
1264 : /* calculate envelope */
1265 4198 : calc_norm_envelop_lf( coeff_out1, envelope, &L_swb_norm, HQ_mode, hq_generic_offset, &sfidx, &efidx );
1266 :
1267 4198 : blen = 16;
1268 4198 : if ( hq_generic_exc_clas == HQ_GENERIC_EXC0 )
1269 : {
1270 3943 : rn_weight0 = 0.8f;
1271 : }
1272 255 : else if ( hq_generic_exc_clas == HQ_GENERIC_EXC1 )
1273 : {
1274 17 : rn_weight0 = 0.05f;
1275 : }
1276 : else
1277 : {
1278 238 : rn_weight0 = 0.2f;
1279 : }
1280 :
1281 4198 : nband_lf = ( efidx - sfidx ) / blen;
1282 1153030 : for ( n_freq = sfidx; n_freq < efidx; n_freq++ )
1283 : {
1284 1148832 : if ( coeff_out1[n_freq] < 0 )
1285 : {
1286 566801 : signum[n_freq] = -1;
1287 566801 : coeff_out1[n_freq] *= signum[n_freq];
1288 : }
1289 : else
1290 : {
1291 582031 : signum[n_freq] = 1;
1292 : }
1293 : }
1294 :
1295 : /* applying whitening */
1296 1153030 : for ( n_freq = sfidx; n_freq < efidx; n_freq++ )
1297 : {
1298 1148832 : coeff_out1[n_freq] = coeff_out1[n_freq] / envelope[n_freq];
1299 : }
1300 :
1301 : /* mean vector generation for controlling dynamic range */
1302 76000 : for ( k = 0; k < nband_lf; ++k )
1303 : {
1304 71802 : energy = EPSILON;
1305 1220634 : for ( i = k * blen + sfidx; i < ( k + 1 ) * blen + sfidx; ++i )
1306 : {
1307 1148832 : energy += coeff_out1[i];
1308 : }
1309 71802 : mean_vector[k] = energy / blen;
1310 : }
1311 :
1312 : /* dynamic range control */
1313 76000 : for ( k = 0; k < nband_lf; ++k )
1314 : {
1315 1220634 : for ( i = k * blen + sfidx; i < ( k + 1 ) * blen + sfidx; ++i )
1316 : {
1317 1148832 : coeff_out1[i] = coeff_out1[i] - ( coeff_out1[i] - mean_vector[k] ) * rn_weight0;
1318 : }
1319 : }
1320 :
1321 4198 : if ( hq_generic_exc_clas == HQ_GENERIC_EXC0 )
1322 : {
1323 : /* applying random sign */
1324 3943 : bwe_seed = R[0] * 8 + R[1] * 4 + R[2] * 2 + R[3];
1325 1090775 : for ( n_freq = sfidx; n_freq < efidx; n_freq++ )
1326 : {
1327 1086832 : 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 62255 : for ( n_freq = sfidx; n_freq < efidx; n_freq++ )
1333 : {
1334 62000 : coeff_out1[n_freq] = coeff_out1[n_freq] * signum[n_freq];
1335 : }
1336 : }
1337 :
1338 : /* normalizing modified low frequency spectrum */
1339 76000 : for ( k = 0; k < nband_lf; ++k )
1340 : {
1341 71802 : energy = EPSILON;
1342 1220634 : for ( i = k * blen + sfidx; i < ( k + 1 ) * blen + sfidx; ++i )
1343 : {
1344 1148832 : energy += coeff_out1[i] * coeff_out1[i];
1345 : }
1346 71802 : energy = (float) sqrt( energy / blen );
1347 :
1348 1220634 : for ( i = k * blen + sfidx; i < ( k + 1 ) * blen + sfidx; ++i )
1349 : {
1350 1148832 : coeff_out1[i] /= energy;
1351 : }
1352 : }
1353 4198 : mvr2r( coeff_out1 + HQ_GENERIC_OFFSET, &coeff_out[HQ_GENERIC_HIGH0 + hq_generic_offset], HQ_GENERIC_LEN0 );
1354 4198 : mvr2r( coeff_out1 + HQ_GENERIC_OFFSET, &coeff_out[HQ_GENERIC_HIGH1 + hq_generic_offset], HQ_GENERIC_LEN0 );
1355 :
1356 4198 : if ( hq_generic_offset <= HQ_GENERIC_FOFFSET_24K4 )
1357 : {
1358 4198 : mvr2r( &coeff_out1[HQ_GENERIC_LOW0], &coeff_out[HQ_GENERIC_HIGH2 + hq_generic_offset], HQ_GENERIC_END_FREQ - HQ_GENERIC_HIGH2 );
1359 : }
1360 :
1361 4198 : if ( HQ_mode == HQ_GEN_FB )
1362 : {
1363 3402 : if ( hq_generic_offset <= HQ_GENERIC_FOFFSET_24K4 )
1364 : {
1365 3402 : 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 4198 : tmp1 = EPSILON;
1373 4198 : tmp2 = EPSILON;
1374 25188 : for ( i = 0; i < 5; ++i )
1375 : {
1376 20990 : tmp1 += (float) fabs( coeff_out[HQ_GENERIC_HIGH1 + hq_generic_offset + i] );
1377 20990 : tmp2 += (float) fabs( coeff_out[HQ_GENERIC_HIGH1 - 2 + hq_generic_offset - i] );
1378 : }
1379 :
1380 4198 : pit1 = &coeff_out[HQ_GENERIC_HIGH1 + hq_generic_offset];
1381 4198 : tmp3 = tmp2 / tmp1;
1382 4198 : if ( tmp3 < 0.3f )
1383 : {
1384 0 : tmp3 = 0.3f;
1385 : }
1386 :
1387 7175 : while ( tmp3 < 1 )
1388 : {
1389 2977 : *pit1++ *= tmp3;
1390 2977 : tmp3 += 0.1f;
1391 : }
1392 :
1393 4198 : pit1 = &coeff_out[HQ_GENERIC_HIGH1 - 1 + hq_generic_offset];
1394 4198 : tmp3 = tmp1 / tmp2;
1395 4198 : 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 4198 : if ( hq_generic_offset <= HQ_GENERIC_FOFFSET_24K4 )
1406 : {
1407 4198 : tmp1 = (float) ( fabs( coeff_out[HQ_GENERIC_HIGH2 + hq_generic_offset] ) + fabs( coeff_out[HQ_GENERIC_HIGH2 + 1 + hq_generic_offset] ) ) + EPSILON;
1408 4198 : 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 4198 : pit1 = &coeff_out[HQ_GENERIC_HIGH2 + hq_generic_offset];
1412 4198 : tmp3 = tmp2 / tmp1;
1413 4198 : if ( tmp3 < 0.3f )
1414 : {
1415 0 : tmp3 = 0.3f;
1416 : }
1417 :
1418 4211 : while ( tmp3 < 1 )
1419 : {
1420 13 : *pit1++ *= tmp3;
1421 13 : tmp3 += 0.1f;
1422 : }
1423 :
1424 4198 : pit1 = &coeff_out[HQ_GENERIC_HIGH2 - 1 + hq_generic_offset];
1425 4198 : tmp3 = tmp1 / tmp2;
1426 4198 : tmp3 = 0.5f * tmp3;
1427 4198 : tmp4 = 0.05f * tmp3;
1428 4198 : while ( tmp3 > 1 )
1429 : {
1430 0 : *pit1-- *= tmp3;
1431 0 : tmp3 -= tmp4;
1432 : }
1433 : }
1434 :
1435 4198 : wfenv = hq_generic_fenv[0];
1436 37782 : 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 33584 : factor = i * 0.125f;
1439 33584 : coeff_out[n_freq] *= ( ( 1 - factor ) * fenvL + factor * wfenv );
1440 : }
1441 :
1442 54574 : for ( n_band = 0; n_band < nenv - 2; n_band++ )
1443 : {
1444 50376 : wfenv = hq_generic_fenv[n_band + 1];
1445 1158648 : for ( i = 0; n_freq < swb_bwe_sm_subband[n_band + 1] + hq_generic_offset; n_freq++, i++ )
1446 : {
1447 1108272 : factor = i * smooth_factor[n_band];
1448 1108272 : coeff_out[n_freq] *= ( ( 1 - factor ) * hq_generic_fenv[n_band] + factor * wfenv );
1449 : }
1450 : }
1451 :
1452 4198 : wfenv = hq_generic_fenv[nenv - 1];
1453 138534 : for ( i = 0; n_freq < swb_bwe_sm_subband[nenv - 1] + hq_generic_offset; n_freq++, i++ )
1454 : {
1455 134336 : factor = i * smooth_factor[nenv - 2];
1456 :
1457 134336 : coeff_out[n_freq] *= ( ( 1 - factor ) * hq_generic_fenv[nenv - 2] + factor * wfenv );
1458 : }
1459 :
1460 4198 : if ( HQ_mode == HQ_GEN_SWB )
1461 : {
1462 1592 : for ( n_band = nenv - 1; n_band < nenv; ++n_band )
1463 : {
1464 796 : wfenv = hq_generic_fenv[n_band];
1465 13532 : for ( ; n_freq < swb_bwe_subband[n_band + 1] + hq_generic_offset; n_freq++ )
1466 : {
1467 12736 : coeff_out[n_freq] *= wfenv;
1468 : }
1469 : }
1470 : }
1471 : else
1472 : {
1473 3402 : if ( hq_generic_fenv[nenv - 1] - hq_generic_fenv[nenv] > 15.f || hq_generic_fenv[nenv] < 5.f )
1474 : {
1475 2900 : wfenv = hq_generic_fenv[nenv - 1];
1476 49300 : for ( i = 0; n_freq < fb_bwe_subband[0]; n_freq++, i++ )
1477 : {
1478 46400 : coeff_out[n_freq] *= wfenv;
1479 : }
1480 :
1481 11600 : for ( n_band = 0; n_band < DIM_FB; n_band++ )
1482 : {
1483 8700 : wfenv = hq_generic_fenv[n_band + nenv];
1484 472700 : for ( i = 0; n_freq < fb_bwe_subband[n_band + 1]; n_freq++, i++ )
1485 : {
1486 464000 : coeff_out[n_freq] *= wfenv;
1487 : }
1488 : }
1489 : }
1490 : else
1491 : {
1492 2008 : for ( n_band = 0; n_band < DIM_FB; n_band++ )
1493 : {
1494 1506 : wfenv = hq_generic_fenv[n_band + nenv - 1];
1495 :
1496 69778 : for ( i = 0; n_freq < fb_bwe_sm_subband[n_band]; n_freq++, i++ )
1497 : {
1498 68272 : factor = i * fb_smooth_factor[n_band];
1499 68272 : coeff_out[n_freq] *= ( ( 1 - factor ) * hq_generic_fenv[n_band + nenv] + factor * wfenv );
1500 : }
1501 : }
1502 :
1503 502 : wfenv = hq_generic_fenv[tenv - 1];
1504 :
1505 20582 : for ( ; n_freq < fb_bwe_subband[DIM_FB]; n_freq++ )
1506 : {
1507 20080 : coeff_out[n_freq] *= wfenv;
1508 : }
1509 : }
1510 : }
1511 4198 : 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 339660 : 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 339660 : if ( L_frame == L_FRAME )
1534 : {
1535 182969 : tmps = NS2SA( 12800, DELAY_FD_BWE_ENC_12k8_NS );
1536 : }
1537 : else
1538 : {
1539 156691 : tmps = NS2SA( 16000, DELAY_FD_BWE_ENC_16k_NS );
1540 : }
1541 :
1542 339660 : mvr2r( old_syn_mem, old_syn, tmps );
1543 339660 : mvr2r( syn, old_syn + tmps, L_frame - tmps );
1544 339660 : mvr2r( syn + L_frame - tmps, old_syn_mem, tmps );
1545 :
1546 339660 : deemph( old_syn, preemph_fac, L_frame, mem_deemph );
1547 :
1548 339660 : return;
1549 : }
|
