Line data Source code
1 : /*====================================================================================
2 : EVS Codec 3GPP TS26.452 Aug 12, 2021. Version 16.3.0
3 : ====================================================================================*/
4 :
5 :
6 : #include <stdint.h>
7 : #include <assert.h>
8 : #include "options.h"
9 : #include "cnst.h"
10 : #include "rom_enc.h"
11 : #include "rom_com_fx.h"
12 : #include "rom_com.h"
13 : //#include "prot_fx.h"
14 : #include "prot_fx.h" /* Function prototypes */
15 : #include "prot_fx_enc.h" /* Function prototypes */
16 : #include "basop_util.h"
17 : #include "rom_basop_util.h"
18 :
19 : /*-------------------------------------------------------------------*
20 : * local constants
21 : *--------------------------------------------------------------------*/
22 :
23 : #define MIN_LOG_FX 0
24 : #define MIN_LOG_VAL_FX -15360 /* -60.0f in Q8 */
25 :
26 : /*-------------------------------------------------------------------*
27 : * lpc_quantization_fx()
28 : *
29 : *
30 : *--------------------------------------------------------------------*/
31 1246 : void lpc_quantization_fx(
32 : Encoder_State *st,
33 : const Word16 lsp[], /* Q15 */
34 : const Word16 lspmid[], /* Q15 */
35 : Word16 lsp_q[], /* Q15 */
36 : Word16 lsf_q[], /* 14Q1*1.28 */
37 : Word16 lspmid_q[], /* Q15 */
38 : Word16 lspq_ind[], /* Q15 */
39 : Word16 clip_var[], /* [2.56x,Q14,Q8,Q0,Q14,Q14] */
40 : const Word16 coder_type, /* Q0 */
41 : const Word16 acelp_midLpc, /* Q0 */
42 : Word16 param_lpc[], /* Q0 */
43 : Word16 nbits_lpc[], /* Q0 */
44 : Word16 *bits_param_lpc, /* Q0 */
45 : Word16 *no_param_lpc, /* Q0 */
46 : const Word16 Q_ener )
47 : {
48 : Word16 nb_indices;
49 : Word16 lsfmid_q[M]; /* 14Q1*1.28 */
50 : Word16 lsfmid_idx;
51 : Word16 i, force_sf;
52 : Word16 lsf[M], lsfmid[M];
53 : Word16 fec_lsf[M], stab;
54 :
55 1246 : nb_indices = 0;
56 1246 : move16();
57 :
58 : /****** High-rate LPC quantizer *******/
59 :
60 1246 : IF( st->lpcQuantization == 0 )
61 : {
62 0 : if ( st->sr_core != 12800 )
63 : {
64 : // PMT("from the comment in E_LPC_isp_isf_conversion, it seems built for 12.8kHz, current sampling rate is NOT 12800, is it ok?")
65 : /*_DIFF_FLOAT_FIX_ E_LPC_lsp_lsf_conversion, does it work for 16kHz as well ?*/
66 : }
67 0 : E_LPC_lsp_lsf_conversion( lsp, lsf, M );
68 :
69 : /* check resonance for pitch clipping algorithm */
70 0 : gp_clip_test_lsf_fx( st->element_mode, lsf, clip_var, M );
71 :
72 0 : IF( ( EQ_16( st->core, TCX_10_CORE ) ) )
73 : {
74 0 : E_LPC_lsp_lsf_conversion( lspmid, lsfmid, M );
75 : }
76 :
77 : /* LPC quantizer */
78 0 : qlpc_avq_fx( lsf, lsfmid, lsf_q, lsfmid_q, param_lpc, &nb_indices, nbits_lpc, st->core, st->sr_core );
79 :
80 0 : E_LPC_lsf_lsp_conversion( lsf_q, lsp_q, M );
81 :
82 0 : IF( EQ_16( st->core, TCX_10_CORE ) )
83 : {
84 0 : E_LPC_lsf_lsp_conversion( lsfmid_q, lspmid_q, M );
85 : }
86 :
87 : /* assert(nb_indices<=NPRM_LPC_NEW); */
88 : }
89 :
90 : /****** Low-rate LPC quantizer *******/
91 :
92 1246 : ELSE IF( EQ_16( st->lpcQuantization, 1 ) )
93 : {
94 1246 : assert( st->sr_core <= 32000 );
95 :
96 1246 : lsp2lsf_fx( lsp, lsf, M, extract_l( st->sr_core ) );
97 :
98 1246 : gp_clip_test_lsf_fx( st->element_mode, lsf, clip_var, M );
99 :
100 1246 : force_sf = 0;
101 1246 : move16();
102 : /*Force safety net when possible in case of transitions*/
103 1246 : test();
104 1246 : test();
105 1246 : IF( st->tc_cnt >= 1 || LE_32( st->last_core_brate, SID_2k40 ) || ( EQ_16( st->next_force_safety_net, 1 ) ) )
106 : {
107 104 : force_sf = 1;
108 104 : move16();
109 104 : st->next_force_safety_net = 0;
110 104 : move16();
111 : }
112 :
113 1246 : test();
114 1246 : IF( EQ_16( st->next_force_safety_net, 1 ) && EQ_16( st->Opt_RF_ON, 1 ) )
115 : {
116 0 : force_sf = 1;
117 0 : move16();
118 0 : st->next_force_safety_net = 0;
119 0 : move16();
120 : }
121 :
122 1246 : test();
123 1246 : IF( EQ_32( st->sr_core, INT_FS_16k ) && EQ_16( coder_type, UNVOICED ) )
124 : {
125 27 : lsf_end_enc_fx( st, lsf, lsf_q, ENDLSF_NBITS, GENERIC, Q_ener,
126 : force_sf, param_lpc, no_param_lpc, bits_param_lpc, GENERIC );
127 :
128 27 : nb_indices = *no_param_lpc; // Q0
129 27 : move16();
130 : }
131 : ELSE
132 : {
133 1219 : lsf_end_enc_fx( st, lsf, lsf_q, ENDLSF_NBITS, coder_type, Q_ener,
134 : force_sf, param_lpc, no_param_lpc, bits_param_lpc, coder_type );
135 :
136 1219 : nb_indices = *no_param_lpc; // Q0
137 1219 : move16();
138 : }
139 :
140 :
141 1246 : FEC_lsf_estim_enc_fx( st, fec_lsf );
142 :
143 : /* FEC - calculate LSF stability */
144 1246 : stab = lsf_stab_fx( lsf_q, fec_lsf, 0, st->L_frame ); /*Q15*/
145 :
146 :
147 1246 : test();
148 1246 : test();
149 1246 : test();
150 1246 : IF( LT_16( stab, add( STAB_FAC_LIMIT_FX, 6553 /* =0.2 in Q15*/ ) ) &&
151 : ( EQ_16( coder_type, VOICED ) || EQ_16( coder_type, GENERIC ) ) && EQ_16( st->Opt_RF_ON, 1 ) )
152 : {
153 0 : st->next_force_safety_net = 1;
154 0 : move16();
155 : }
156 :
157 1246 : lsf2lsp_fx( lsf_q, lsp_q, M, st->sr_core );
158 :
159 1246 : *nbits_lpc = ENDLSF_NBITS;
160 1246 : move16();
161 : }
162 : ELSE
163 : {
164 0 : assert( 0 );
165 : }
166 :
167 1246 : IF( lspq_ind != NULL )
168 : {
169 1246 : E_LPC_lsf_lsp_conversion( lsf_q, lspq_ind, M );
170 : }
171 :
172 1246 : st->seed_acelp = 0;
173 1246 : move16();
174 6959 : FOR( i = nb_indices - 1; i >= 0; i-- )
175 : {
176 5713 : st->seed_acelp = extract_l( L_mac0( L_mac0( 13849, shr( st->seed_acelp, 1 ), 31821 ), param_lpc[i], 31821 ) ); // Q0
177 5713 : move16();
178 : }
179 :
180 : /* Mid-frame LPC quantization */
181 :
182 1246 : test();
183 1246 : IF( st->lpcQuantization && acelp_midLpc )
184 : {
185 :
186 722 : IF( st->rate_switching_reset == 0 )
187 : {
188 708 : lsp2lsf_fx( lspmid, lsfmid, M, extract_l( st->sr_core ) );
189 :
190 708 : midlsf_enc_fx( st->lsf_old_fx, lsf_q, lsfmid, &lsfmid_idx, M, st->Bin_E_old_fx, Q_ener, (Word8) st->narrowBand, st->sr_core, coder_type );
191 708 : param_lpc[nb_indices++] = lsfmid_idx; // Q0
192 708 : move16();
193 708 : midlsf_dec( st->lsf_old_fx, lsf_q, lsfmid_idx, lsfmid_q, coder_type, NULL, 0, 1 );
194 :
195 708 : reorder_lsf_fx( lsfmid_q, LSF_GAP_MID_FX, M, st->sr_core );
196 708 : lsf2lsp_fx( lsfmid_q, lspmid_q, M, st->sr_core );
197 : }
198 : ELSE
199 : {
200 14 : param_lpc[nb_indices++] = 0;
201 14 : move16();
202 : }
203 : }
204 :
205 :
206 1246 : return;
207 : }
208 :
209 219006 : void lpc_quantization_ivas_fx(
210 : Encoder_State *st,
211 : const Word16 lsp[], /* Q15 */
212 : const Word16 lspmid[], /* Q15 */
213 : Word16 lsp_q[], /* Q15 */
214 : Word16 lsf_q[], /* 14Q1*1.28 */
215 : Word16 lspmid_q[], /* Q15 */
216 : const Word16 coder_type, /* Q0 */
217 : const Word16 acelp_midLpc, /* Q0 */
218 : Word16 param_lpc[], /* Q0 */
219 : Word16 nbits_lpc[], /* Q0 */
220 : Word16 *bits_param_lpc, /* Q0 */
221 : Word16 *no_param_lpc, /* Q0 */
222 : const Word16 Q_ener )
223 : {
224 : Word16 nb_indices;
225 : Word16 lsfmid_q[M]; /* 14Q1*1.28 */
226 : Word16 lsfmid_idx;
227 : Word16 i, force_sf;
228 : Word16 lsf[M], lsfmid[M];
229 : Word16 fec_lsf[M], stab;
230 :
231 219006 : nb_indices = 0;
232 219006 : move16();
233 :
234 : /****** High-rate LPC quantizer *******/
235 :
236 219006 : IF( st->lpcQuantization == 0 )
237 : {
238 106889 : E_LPC_lsp_lsf_conversion( lsp, lsf, M );
239 :
240 106889 : IF( ( EQ_16( st->core, TCX_10_CORE ) ) )
241 : {
242 2059 : E_LPC_lsp_lsf_conversion( lspmid, lsfmid, M );
243 : }
244 :
245 : /* LPC quantizer */
246 106889 : qlpc_avq_fx( lsf, lsfmid, lsf_q, lsfmid_q, param_lpc, &nb_indices, nbits_lpc, st->core, st->sr_core );
247 :
248 106889 : E_LPC_lsf_lsp_conversion( lsf_q, lsp_q, M );
249 :
250 106889 : IF( EQ_16( st->core, TCX_10_CORE ) )
251 : {
252 2059 : E_LPC_lsf_lsp_conversion( lsfmid_q, lspmid_q, M );
253 : }
254 :
255 106889 : assert( nb_indices <= NPRM_LPC_NEW );
256 : }
257 :
258 : /****** Low-rate LPC quantizer *******/
259 :
260 112117 : ELSE IF( EQ_16( st->lpcQuantization, 1 ) )
261 : {
262 :
263 112117 : lsp2lsf_fx( lsp, lsf, M, extract_l( st->sr_core ) );
264 :
265 112117 : force_sf = 0;
266 112117 : move16();
267 : /*Force safety net when possible in case of transitions*/
268 112117 : test();
269 112117 : test();
270 112117 : IF( GE_32( st->tc_cnt, 1 ) || LE_32( st->last_core_brate, SID_2k40 ) || ( EQ_16( st->next_force_safety_net, 1 ) ) )
271 : {
272 12303 : force_sf = 1;
273 12303 : move16();
274 12303 : st->next_force_safety_net = 0;
275 12303 : move16();
276 : }
277 :
278 112117 : test();
279 112117 : IF( EQ_16( st->next_force_safety_net, 1 ) && EQ_16( st->Opt_RF_ON, 1 ) )
280 : {
281 0 : force_sf = 1;
282 0 : st->next_force_safety_net = 0;
283 0 : move16();
284 0 : move16();
285 : }
286 :
287 112117 : test();
288 112117 : IF( EQ_32( st->sr_core, INT_FS_16k ) && EQ_16( coder_type, UNVOICED ) )
289 : {
290 0 : lsf_end_enc_ivas_fx( st, lsf, lsf_q, ENDLSF_NBITS, GENERIC, Q_ener,
291 : force_sf, param_lpc, no_param_lpc, bits_param_lpc, GENERIC, NULL );
292 :
293 0 : nb_indices = *no_param_lpc; // Q0
294 0 : move16();
295 : }
296 : ELSE
297 : {
298 112117 : lsf_end_enc_ivas_fx( st, lsf, lsf_q, ENDLSF_NBITS, coder_type, Q_ener,
299 : force_sf, param_lpc, no_param_lpc, bits_param_lpc, coder_type, NULL );
300 :
301 112117 : nb_indices = *no_param_lpc; // Q0
302 112117 : move16();
303 : }
304 :
305 :
306 112117 : FEC_lsf_estim_enc_fx( st, fec_lsf );
307 :
308 : /* FEC - calculate LSF stability */
309 112117 : stab = lsf_stab_fx( lsf_q, fec_lsf, 0, st->L_frame ); /*Q15*/
310 :
311 :
312 112117 : test();
313 112117 : test();
314 112117 : test();
315 112117 : IF( LT_16( stab, add( STAB_FAC_LIMIT_FX, 6553 /* =0.2 in Q15*/ ) ) &&
316 : ( EQ_16( coder_type, VOICED ) || EQ_16( coder_type, GENERIC ) ) && EQ_16( st->Opt_RF_ON, 1 ) )
317 : {
318 0 : st->next_force_safety_net = 1;
319 0 : move16();
320 : }
321 :
322 112117 : lsf2lsp_fx( lsf_q, lsp_q, M, st->sr_core );
323 :
324 112117 : *nbits_lpc = ENDLSF_NBITS;
325 112117 : move16();
326 : }
327 : ELSE
328 : {
329 0 : assert( 0 );
330 : }
331 :
332 219006 : st->seed_acelp = 0;
333 219006 : move16();
334 2134009 : FOR( i = nb_indices - 1; i >= 0; i-- )
335 : {
336 1915003 : st->seed_acelp = extract_l( L_mac0( L_mac0( 13849, shr( st->seed_acelp, 1 ), 31821 ), param_lpc[i], 31821 ) ); // Q0
337 1915003 : move16();
338 : }
339 :
340 : /* Mid-frame LPC quantization */
341 :
342 219006 : test();
343 219006 : IF( st->lpcQuantization && acelp_midLpc )
344 : {
345 :
346 0 : IF( st->rate_switching_reset == 0 )
347 : {
348 0 : lsp2lsf_fx( lspmid, lsfmid, M, extract_l( st->sr_core ) );
349 :
350 0 : midlsf_enc_fx( st->lsf_old_fx, lsf_q, lsfmid, &lsfmid_idx, M, st->Bin_E_old_fx, Q_ener, (Word8) st->narrowBand, st->sr_core, coder_type );
351 0 : param_lpc[nb_indices] = lsfmid_idx; // Q0
352 0 : move16();
353 0 : nb_indices = add( nb_indices, 1 );
354 0 : midlsf_dec( st->lsf_old_fx, lsf_q, lsfmid_idx, lsfmid_q, coder_type, NULL, 0, 1 );
355 :
356 0 : reorder_lsf_fx( lsfmid_q, LSF_GAP_MID_FX, M, st->sr_core );
357 0 : lsf2lsp_fx( lsfmid_q, lspmid_q, M, st->sr_core );
358 : }
359 : ELSE
360 : {
361 0 : param_lpc[nb_indices] = 0;
362 0 : move16();
363 0 : nb_indices = add( nb_indices, 1 ); // Q0
364 : }
365 : }
366 :
367 :
368 219006 : return;
369 : }
370 :
371 :
372 : /*-------------------------------------------------------------------*
373 : * Unified_weighting()
374 : *
375 : * LSF weighting
376 : *-------------------------------------------------------------------*/
377 :
378 448117 : void Unified_weighting_fx(
379 : const Word32 Bin_Ener_128_fx[], /* i : FFT Bin energy 128 bins in two sets Q_ener */
380 : Word16 Q_ener,
381 : const Word16 lsf_fx[], /* i : LSF vector x2.56 */
382 : Word16 w_fx[], /* o : LP weighting filter (numerator) Q8 */
383 : const Word16 narrowBand, /* i : flag for Narrowband Q0*/
384 : const Word16 unvoiced, /* i : flag for Unvoiced frame Q0*/
385 : const Word32 sr_core, /* i : sampling rate of core-coder Q0*/
386 : const Word16 order /* i : LP order Q0*/
387 : )
388 : {
389 : Word16 i;
390 : const Word16( *ptr_lsf_fit_model )[M];
391 : Word16 last_bin;
392 : /*float compen;*/
393 :
394 : Word16 exp, frac;
395 : Word16 w_fft_fx[M] /*, w_fx[M]*/;
396 : Word16 norm_lsf_fx[M]; /* Q0 */
397 : Word16 tmp_fx, min_fx, tmp1_fx, tmp2_fx, s1, s2;
398 : Word32 L_tmp;
399 : Word16 nf_fx;
400 : Word32 Bin_Ener_160_fx[160];
401 : const Word32 *Freq_w_Table_fx, *Bin_Ener_fx;
402 : #ifndef ISSUE_1867_replace_overflow_libenc
403 : #ifdef BASOP_NOGLOB_DECLARE_LOCAL
404 : Flag Overflow = 0;
405 : move32();
406 : #endif
407 : #endif
408 :
409 : /*Config. weighting*/
410 448117 : IF( narrowBand )
411 : {
412 0 : ptr_lsf_fit_model = lsf_unified_fit_model_nb; // Q0
413 0 : nf_fx = 16384; /* 6400 in x2.56 */
414 0 : move16();
415 :
416 0 : last_bin = 127;
417 0 : move16();
418 0 : Bin_Ener_fx = Bin_Ener_128_fx; /* Q_ener */
419 : }
420 448117 : ELSE IF( EQ_32( sr_core, INT_FS_12k8 ) )
421 : {
422 223252 : ptr_lsf_fit_model = lsf_unified_fit_model_wb;
423 223252 : nf_fx = 16384; /* 6400 in x2.56 */
424 223252 : move16();
425 :
426 223252 : last_bin = 127;
427 223252 : move16();
428 223252 : Bin_Ener_fx = Bin_Ener_128_fx; /* Q_ener */
429 : }
430 : ELSE
431 : {
432 224865 : ptr_lsf_fit_model = lsf_unified_fit_model_wbhb;
433 224865 : nf_fx = 20480; /* 8000 in x2.56 */
434 224865 : move16();
435 :
436 : /* Fill the missing part (128~159) of the bin energy */
437 224865 : last_bin = 159;
438 224865 : move16();
439 :
440 224865 : Copy32( Bin_Ener_128_fx, Bin_Ener_160_fx, L_FFT / 2 ); /* Q_ener */
441 :
442 : /* Find average bin energy (32 Energy) */
443 224865 : L_tmp = L_deposit_l( 0 );
444 7420545 : FOR( i = 95; i < 127; i++ )
445 : {
446 : #ifdef ISSUE_1867_replace_overflow_libenc
447 7195680 : L_tmp = L_add_sat( L_tmp, Bin_Ener_160_fx[i] ); /* Q_ener */
448 : #else
449 : L_tmp = L_add_o( L_tmp, Bin_Ener_160_fx[i], &Overflow ); /* Q_ener */
450 : #endif
451 : }
452 :
453 224865 : L_tmp = L_shr( L_tmp, 5 );
454 7645410 : FOR( i = 127; i < 160; i++ )
455 : {
456 7420545 : Bin_Ener_160_fx[i] = L_tmp; /* Q_ener */
457 7420545 : move32();
458 : }
459 :
460 224865 : Bin_Ener_fx = Bin_Ener_160_fx; /* Q_ener */
461 : }
462 :
463 : /* 1) FFT weights*/
464 448117 : Freq_w_Table_fx = Freq_Weight_Com_fx; /* Q31 */
465 448117 : if ( unvoiced )
466 : {
467 4944 : Freq_w_Table_fx = Freq_Weight_UV_fx; /* Q31 */
468 : }
469 :
470 : /* Use Envelope */
471 448117 : min_fx = MAX_16;
472 448117 : move16();
473 7617989 : FOR( i = 0; i < M; i++ )
474 : {
475 7169872 : norm_lsf_fx[i] = mult_r( lsf_fx[i], 256 );
476 7169872 : move16();
477 :
478 7169872 : IF( norm_lsf_fx[i] == 0 )
479 : {
480 17 : L_tmp = L_add( Bin_Ener_fx[1], 0 );
481 : }
482 7169855 : ELSE IF( norm_lsf_fx[i] == last_bin )
483 : {
484 24 : L_tmp = L_add( Bin_Ener_fx[last_bin - 1], 0 );
485 : }
486 : ELSE
487 : {
488 7169831 : L_tmp = L_max( Bin_Ener_fx[norm_lsf_fx[i]], Bin_Ener_fx[norm_lsf_fx[i] - 1] ); /* Q_ener */
489 7169831 : L_tmp = L_max( Bin_Ener_fx[norm_lsf_fx[i] + 1], L_tmp ); /* Q_ener */
490 : }
491 :
492 7169872 : IF( LE_32( L_tmp, MIN_LOG_FX ) )
493 : {
494 29202 : w_fft_fx[i] = MIN_LOG_VAL_FX;
495 29202 : move16(); /* Q8 */
496 : }
497 : ELSE
498 : {
499 7140670 : exp = norm_l( L_tmp );
500 7140670 : move16();
501 7140670 : IF( L_tmp == 0 )
502 : {
503 0 : frac = 0;
504 0 : move16();
505 : }
506 : ELSE
507 : {
508 7140670 : frac = Log2_norm_lc( L_shl( L_tmp, exp ) );
509 : }
510 7140670 : exp = sub( sub( 30, exp ), Q_ener );
511 7140670 : L_tmp = Mpy_32_16( exp, frac, 24660 ); /* Q14 */ /* 10*log10(2) in Q13*/
512 7140670 : w_fft_fx[i] = round_fx( L_shl( L_tmp, 10 ) ); /* Q8 */
513 : }
514 :
515 7169872 : if ( LT_16( w_fft_fx[i], min_fx ) )
516 : {
517 2499643 : min_fx = w_fft_fx[i]; // Q8
518 2499643 : move16();
519 : }
520 : }
521 :
522 7617989 : FOR( i = 0; i < M; i++ )
523 : {
524 7169872 : IF( EQ_16( w_fft_fx[i], min_fx ) )
525 : {
526 533535 : w_fft_fx[i] = 2048;
527 533535 : move16(); /* 2.0 in Q10 */
528 : }
529 : ELSE
530 : {
531 : #ifdef ISSUE_1867_replace_overflow_libenc
532 6636337 : L_tmp = L_shl_sat( L_deposit_l( sub_sat( w_fft_fx[i], min_fx ) ), 13 ); /* Q21 */
533 : #else
534 : L_tmp = L_shl_o( L_deposit_l( sub_o( w_fft_fx[i], min_fx, &Overflow ) ), 13, &Overflow ); /* Q21 */
535 : #endif
536 6636337 : exp = norm_l( L_tmp );
537 6636337 : frac = round_fx( L_shl( L_tmp, exp ) );
538 6636337 : exp = sub( add( exp, 21 ), 30 );
539 6636337 : tmp_fx = div_s( 16384, frac );
540 6636337 : L_tmp = Isqrt_lc( L_deposit_h( tmp_fx ), &exp ); /* Q(31-exp) */
541 6636337 : w_fft_fx[i] = round_fx( L_shl( L_tmp, sub( exp, 5 ) ) ); /* Q10 */
542 6636337 : w_fft_fx[i] = add( w_fft_fx[i], 2048 );
543 6636337 : move16(); /* Q10; 2.0 in Q10 */
544 : }
545 7169872 : w_fft_fx[i] = round_fx( Mult_32_16( Freq_w_Table_fx[norm_lsf_fx[i]], w_fft_fx[i] ) ); /* Q10 */
546 : }
547 :
548 : /* 2) IHM weights*/
549 7617989 : FOR( i = 0; i < order; i++ )
550 : {
551 : /* 2) IHM weights*/
552 7169872 : tmp1_fx = lsf_fx[i]; /* x2.56 */
553 7169872 : move16();
554 7169872 : if ( i > 0 )
555 : {
556 6721755 : tmp1_fx = sub( tmp1_fx, lsf_fx[i - 1] ); /* x2.56 */
557 : }
558 :
559 7169872 : tmp2_fx = nf_fx;
560 7169872 : move16();
561 7169872 : if ( NE_16( i, sub( order, 1 ) ) )
562 : {
563 6721755 : tmp2_fx = lsf_fx[i + 1]; /* x2.56 */
564 6721755 : move16();
565 : }
566 7169872 : tmp2_fx = sub( tmp2_fx, lsf_fx[i] ); /* x2.56 */
567 :
568 7169872 : s1 = 15;
569 7169872 : move16();
570 7169872 : s2 = 15;
571 7169872 : move16();
572 7169872 : if ( tmp1_fx == 0 )
573 : {
574 0 : tmp1_fx = 8;
575 0 : move16();
576 : }
577 7169872 : tmp1_fx = Inv16( tmp1_fx, &s1 );
578 7169872 : if ( tmp2_fx == 0 )
579 : {
580 0 : tmp2_fx = 8;
581 0 : move16();
582 : }
583 7169872 : tmp2_fx = Inv16( tmp2_fx, &s2 );
584 7169872 : s1 = BASOP_Util_Add_MantExp( tmp1_fx, s1, tmp2_fx, s2, &tmp1_fx ); /* x * 2.56 / pow(2.0, 15 + |s1|) */
585 7169872 : tmp_fx = mult_r( nf_fx, 10430 /* 0.31 in Q15*/ );
586 7169872 : s2 = norm_s( tmp_fx );
587 7169872 : tmp_fx = shl( tmp_fx, s2 );
588 7169872 : s1 = sub( s1, s2 );
589 :
590 7169872 : tmp1_fx = mult_r( tmp1_fx, tmp_fx ); /* |s1| */
591 7169872 : s1 = abs_s( s1 );
592 :
593 : /* 3) Fitting model combining the two weights*/
594 7169872 : L_tmp = L_add( ptr_lsf_fit_model[0][i], 0 ); /* Q10 */
595 7169872 : L_tmp = L_add( L_tmp, L_shl( L_mult0( ptr_lsf_fit_model[1][i], tmp1_fx ), sub( -5, s1 ) ) ); /* Q10 */
596 7169872 : L_tmp = L_add( L_tmp, L_shl( L_mult0( mult_r( tmp1_fx, tmp1_fx ), ptr_lsf_fit_model[2][i] ), sub( 7, shl( s1, 1 ) ) ) );
597 7169872 : L_tmp = L_add( L_tmp, L_shl( L_mult0( w_fft_fx[i], ptr_lsf_fit_model[3][i] ), -12 ) );
598 7169872 : move16(); /* Q10 */
599 :
600 7169872 : IF( LT_32( L_shl( L_tmp, 5 ), InvIntTable[i + 1] ) )
601 : {
602 4 : w_fx[i] = shr( InvIntTable[i + 1], 7 ); // Q8
603 4 : move16();
604 : }
605 : ELSE
606 : {
607 7169868 : IF( norm_l( L_tmp ) < 14 )
608 : {
609 0 : w_fx[i] = MAX_16;
610 0 : move16();
611 : }
612 : ELSE
613 : {
614 7169868 : w_fx[i] = extract_l( L_shr( L_tmp, 2 ) ); // Q8
615 7169868 : move16();
616 : }
617 : }
618 : }
619 :
620 448117 : return;
621 : }
|
