Line data Source code
1 : /*====================================================================================
2 : EVS Codec 3GPP TS26.452 Aug 12, 2021. Version 16.3.0
3 : ====================================================================================*/
4 :
5 : #include "options.h" /* Compilation switches */
6 : #include "cnst.h" /* Common constants */
7 : #include "rom_com.h" /* Static table prototypes */
8 : #include "stl.h"
9 : #include "ivas_cnst.h"
10 : #include "ivas_error.h"
11 : #include "prot_fx.h" /* Function prototypes */
12 : #include "prot_fx_enc.h" /* Function prototypes */
13 : #include "ivas_prot_fx.h"
14 :
15 :
16 : /*-----------------------------------------------------------------------*
17 : * init_encoder_fx()
18 : *
19 : * Initialization of state variables
20 : *-----------------------------------------------------------------------*/
21 :
22 3 : ivas_error init_encoder_fx(
23 : Encoder_State *st_fx, /* i/o: Encoder static variables structure */
24 : const Word16 var_SID_rate_flag, /* i : flag for variable SID update rate */
25 : const Word16 interval_SID /* i : interval for SID update */
26 : )
27 : {
28 : Word16 i;
29 : Word32 L_tmp;
30 3 : Word16 idchan = 0; /* i : channel ID */
31 3 : Word16 vad_only_flag = 0; /* i : channel ID */
32 3 : move16();
33 3 : move16();
34 3 : ISM_MODE ism_mode = ISM_MODE_NONE;
35 : ivas_error error;
36 :
37 3 : error = IVAS_ERR_OK;
38 :
39 : /*-----------------------------------------------------------------*
40 : * General signal buffers
41 : *-----------------------------------------------------------------*/
42 3 : IF( !vad_only_flag )
43 : {
44 3 : IF( ( st_fx->hSignalBuf = (SIGNAL_BUFFERS_ENC_HANDLE) malloc( sizeof( SIGNAL_BUFFERS_ENC_DATA ) ) ) == NULL )
45 : {
46 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Signal buffers\n" ) );
47 : }
48 :
49 3 : st_fx->Bin_E_old_fx = st_fx->hSignalBuf->Bin_E_old_fx;
50 3 : st_fx->mem_decim_fx = st_fx->hSignalBuf->mem_decim_fx;
51 3 : st_fx->mem_decim16k_fx = st_fx->hSignalBuf->mem_decim16k_fx;
52 3 : st_fx->old_inp_12k8_fx = st_fx->hSignalBuf->old_inp_12k8_fx;
53 3 : st_fx->old_inp_16k_fx = st_fx->hSignalBuf->old_inp_16k_fx;
54 3 : st_fx->buf_speech_enc_pe = st_fx->hSignalBuf->buf_speech_enc_pe;
55 3 : st_fx->buf_synth = st_fx->hSignalBuf->buf_synth;
56 3 : st_fx->buf_speech_enc = st_fx->hSignalBuf->buf_speech_enc;
57 3 : st_fx->buf_wspeech_enc = st_fx->hSignalBuf->buf_wspeech_enc;
58 :
59 : /* initializations */
60 3 : set16_fx( st_fx->old_inp_12k8_fx, 0, L_INP_MEM ); /* memory of input signal at 12.8kHz */
61 3 : set16_fx( st_fx->old_inp_16k_fx, 0, L_INP_MEM );
62 3 : set16_fx( st_fx->mem_decim16k_fx, 0, 2 * L_FILT_MAX );
63 3 : set16_fx( st_fx->mem_decim_fx, 0, 2 * L_FILT_MAX );
64 3 : set32_fx( st_fx->Bin_E_old_fx, 0, L_FFT / 2 );
65 3 : st_fx->q_Bin_E_old = Q31;
66 3 : move16();
67 :
68 3 : st_fx->input_buff_fx = st_fx->hSignalBuf->input_buff;
69 3 : set16_fx( st_fx->input_buff_fx, 0, L_FRAME48k + L_FRAME48k + NS2SA( 48000, DELAY_FIR_RESAMPL_NS ) );
70 3 : st_fx->old_input_signal_fx = st_fx->input_buff_fx;
71 3 : IF( EQ_16( st_fx->element_mode, EVS_MONO ) )
72 : {
73 3 : st_fx->input_fx = st_fx->input_buff_fx + st_fx->input_Fs / FRAMES_PER_SEC + NS2SA_FX2( st_fx->input_Fs, DELAY_FIR_RESAMPL_NS );
74 : }
75 : ELSE
76 : {
77 0 : st_fx->input_fx = st_fx->input_buff_fx + st_fx->input_Fs / FRAMES_PER_SEC;
78 : }
79 : }
80 : ELSE
81 : {
82 0 : st_fx->hSignalBuf = NULL;
83 0 : st_fx->Bin_E_old_fx = NULL;
84 0 : st_fx->mem_decim_fx = NULL;
85 0 : st_fx->mem_decim16k_fx = NULL;
86 0 : st_fx->old_inp_12k8_fx = NULL;
87 0 : st_fx->old_inp_16k_fx = NULL;
88 0 : st_fx->buf_speech_enc_pe = NULL;
89 0 : st_fx->buf_synth = NULL;
90 0 : st_fx->buf_speech_enc = NULL;
91 0 : st_fx->buf_wspeech_enc = NULL;
92 0 : st_fx->input_buff_fx = NULL;
93 : }
94 :
95 : /*-----------------------------------------------------------------*
96 : * ACELP core parameters
97 : *-----------------------------------------------------------------*/
98 3 : st_fx->last_core = -1;
99 3 : move16();
100 :
101 3 : if ( st_fx->Opt_AMR_WB )
102 : {
103 0 : st_fx->last_core = AMR_WB_CORE;
104 0 : move16();
105 : }
106 :
107 3 : st_fx->L_frame = L_FRAME;
108 3 : move16();
109 3 : st_fx->last_coder_type = GENERIC;
110 3 : move16();
111 3 : st_fx->last_total_brate = st_fx->total_brate;
112 3 : move32();
113 3 : st_fx->last_total_brate_cng = -1;
114 3 : move32();
115 3 : st_fx->last_core_brate = st_fx->total_brate;
116 3 : move32();
117 3 : st_fx->extl = -1;
118 3 : move16();
119 3 : st_fx->last_extl = -1;
120 3 : move16();
121 3 : st_fx->last_L_frame = L_FRAME;
122 3 : move16();
123 3 : st_fx->rate_switching_reset = 0;
124 3 : move16();
125 3 : st_fx->rate_switching_reset_16kHz = 0;
126 3 : move16();
127 :
128 : /*-----------------------------------------------------------------*
129 : * Bitstream
130 : *-----------------------------------------------------------------*/
131 :
132 3 : IF( !vad_only_flag )
133 : {
134 3 : IF( ( st_fx->hBstr = (BSTR_ENC_HANDLE) malloc( sizeof( BSTR_ENC_DATA ) ) ) == NULL )
135 : {
136 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Bitstream structure\n" ) );
137 : }
138 : }
139 : ELSE
140 : {
141 0 : st_fx->hBstr = NULL;
142 : }
143 :
144 :
145 3 : Copy( GEWB_Ave_fx, st_fx->mem_AR_fx, M );
146 3 : Copy( GEWB_Ave_fx, st_fx->lsfoldbfi0_fx, M );
147 3 : Copy( GEWB_Ave_fx, st_fx->lsfoldbfi1_fx, M );
148 3 : Copy( GEWB_Ave_fx, st_fx->lsf_adaptive_mean_fx, M );
149 3 : init_lvq_fx( st_fx->offset_scale1_fx, st_fx->offset_scale2_fx, st_fx->offset_scale1_p_fx, st_fx->offset_scale2_p_fx, st_fx->no_scales_fx, st_fx->no_scales_p_fx );
150 3 : st_fx->next_force_safety_net = 0;
151 3 : move16();
152 3 : st_fx->pstreaklen = 0;
153 3 : move16();
154 3 : st_fx->streaklimit_fx = 32767;
155 3 : move16(); /*1;//Q15 */
156 3 : set16_fx( st_fx->mem_MA_fx, 0, M );
157 :
158 3 : init_gp_clip_fx( st_fx->clip_var_fx );
159 3 : pitch_ol_init_fx( &st_fx->old_thres_fx, &st_fx->old_pitch, &st_fx->delta_pit, &st_fx->old_corr_fx );
160 :
161 : /*-----------------------------------------------------------------*
162 : * AMR-WB IO initialization
163 : *-----------------------------------------------------------------*/
164 3 : test();
165 3 : IF( st_fx->Opt_AMR_WB || EQ_16( st_fx->element_mode, EVS_MONO ) )
166 : {
167 3 : IF( ( st_fx->hAmrwb_IO = (AMRWB_IO_ENC_HANDLE) malloc( sizeof( AMRWB_IO_ENC_DATA ) ) ) == NULL )
168 : {
169 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for AMR-WB IO\n" ) );
170 : }
171 :
172 3 : amr_wb_enc_init_fx( st_fx->hAmrwb_IO );
173 : }
174 : ELSE
175 : {
176 0 : st_fx->hAmrwb_IO = NULL;
177 : }
178 3 : st_fx->clas = UNVOICED_CLAS;
179 3 : move16();
180 3 : set16_fx( st_fx->old_wsp2_fx, 0, ( L_WSP_MEM - L_INTERPOL ) / OPL_DECIM );
181 3 : set16_fx( st_fx->old_wsp_fx, 0, L_WSP_MEM );
182 3 : st_fx->mem_deemph_fx = 0;
183 3 : move16();
184 3 : st_fx->mem_preemph_fx = 0;
185 3 : move16();
186 3 : st_fx->mem_preemph16k_fx = 0;
187 3 : move16();
188 3 : st_fx->mem_preemph_enc = 0;
189 3 : move16();
190 :
191 : /* AVQ pre-quantizer memory */
192 3 : st_fx->mem_preemp_preQ_fx = 0;
193 3 : move16();
194 3 : st_fx->mem_deemp_preQ_fx = 0;
195 3 : move16();
196 3 : st_fx->last_nq_preQ = 0;
197 3 : move16();
198 3 : st_fx->use_acelp_preq = 0;
199 3 : move16();
200 :
201 : /* (Decimated) Weighted Speech Memory */
202 3 : st_fx->mem_wsp_enc = 0;
203 3 : move16();
204 :
205 3 : st_fx->mem_wsp_fx = 0;
206 3 : move16();
207 3 : st_fx->mem_wsp_q = 0;
208 3 : move16();
209 3 : set32_fx( st_fx->Bin_E_fx, 0, L_FFT );
210 3 : st_fx->q_Bin_E = Q31;
211 3 : move16();
212 3 : set16_fx( st_fx->mem_decim2_fx, 0, 3 );
213 3 : set16_fx( st_fx->lgBin_E_fx, 0, L_FFT / 2 );
214 :
215 3 : st_fx->ini_frame = 0;
216 3 : move16();
217 3 : st_fx->ee_old_fx = 640;
218 3 : move32(); /*chk //10 in Q6 */
219 3 : st_fx->Nb_ACELP_frames = 0;
220 3 : move16();
221 3 : st_fx->audio_frame_cnt = AUDIO_COUNTER_INI;
222 3 : move16(); /* Initializatin of the audio frame counter mildly into the audio mode */
223 :
224 : /* adaptive lag window memory */
225 3 : st_fx->old_pitch_la = 0;
226 3 : move16();
227 3 : st_fx->old_voicing_la = 0;
228 3 : move16();
229 3 : set32_fx( st_fx->mem_hp20_in_fx, 0, 5 );
230 :
231 3 : st_fx->old_hpfilt_in_fx = 0;
232 3 : move16();
233 3 : st_fx->old_hpfilt_out_fx = 0;
234 3 : move16();
235 3 : st_fx->EnergyLT_fx = 0;
236 3 : move32();
237 3 : st_fx->prev_Q_new = 0;
238 3 : move16();
239 :
240 :
241 3 : IF( EQ_32( st_fx->input_Fs, 8000 ) )
242 : {
243 0 : st_fx->min_band = 1;
244 0 : move16();
245 0 : st_fx->max_band = 16;
246 0 : move16();
247 : }
248 : ELSE
249 : {
250 3 : st_fx->min_band = 0;
251 3 : move16();
252 3 : st_fx->max_band = 19;
253 3 : move16();
254 : }
255 3 : IF( st_fx->Opt_AMR_WB )
256 : {
257 0 : Copy( mean_isf_amr_wb_fx, st_fx->lsf_old_fx, M );
258 0 : E_LPC_isf_isp_conversion( st_fx->lsf_old_fx, st_fx->lsp_old1_fx, M );
259 : }
260 : ELSE
261 : {
262 3 : Copy( GEWB_Ave_fx, st_fx->lsf_old_fx, M );
263 3 : lsf2lsp_fx( st_fx->lsf_old_fx, st_fx->lsp_old1_fx, M, INT_FS_FX );
264 : }
265 :
266 3 : Copy( st_fx->lsf_old_fx, st_fx->lsf_old1_fx, M );
267 3 : Copy( st_fx->lsp_old1_fx, st_fx->lsp_old_fx, M );
268 3 : Copy( st_fx->lsp_old_fx, st_fx->lsp_old16k_fx, M );
269 3 : Copy( st_fx->lsp_old_fx, st_fx->lspold_enc_fx, M );
270 :
271 3 : st_fx->stab_fac_fx = 0;
272 3 : move16();
273 : /* Bass post-filter memories - encoder side of MODE2 */
274 3 : st_fx->bpf_off = 0;
275 3 : move16();
276 :
277 : /* TC mode */
278 3 : st_fx->tc_cnt = 0;
279 3 : move16();
280 3 : st_fx->mCb1_fx = 0;
281 3 : move16();
282 :
283 : /* AC mode */
284 :
285 : /*-----------------------------------------------------------------*
286 : * parameters for AC coder type (GSC)
287 : *-----------------------------------------------------------------*/
288 :
289 : // st_fx->GSC_noisy_speech = 0;
290 3 : st_fx->GSC_IVAS_mode = 0;
291 3 : move16();
292 3 : test();
293 3 : test();
294 3 : IF( ( idchan == 0 && NE_16( st_fx->element_mode, IVAS_CPE_MDCT ) ) || EQ_16( st_fx->element_mode, IVAS_CPE_TD ) )
295 : {
296 3 : IF( ( st_fx->hGSCEnc = (GSC_ENC_HANDLE) malloc( sizeof( GSC_ENC_DATA ) ) ) == NULL )
297 : {
298 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for GSC\n" ) );
299 : }
300 :
301 3 : GSC_enc_init_fx( st_fx->hGSCEnc );
302 : }
303 : ELSE
304 : {
305 0 : st_fx->hGSCEnc = NULL;
306 : }
307 :
308 3 : st_fx->last_ener_fx = 0;
309 3 : move16();
310 :
311 3 : st_fx->old_dE1_fx = 0;
312 3 : move16();
313 3 : st_fx->old_ind_deltaMax = 0;
314 3 : move32();
315 3 : set32_fx( st_fx->old_enr_ssf_fx, 0, 2 * NB_SSF );
316 3 : st_fx->spike_hyst = -1;
317 3 : move16();
318 3 : st_fx->music_hysteresis_fx = 0;
319 3 : move16(); /* Counter of frames after AUDIO frame to prevent UC */
320 3 : st_fx->last_harm_flag_acelp = 0;
321 3 : move16();
322 3 : st_fx->GSC_noisy_speech = 0;
323 3 : move16();
324 :
325 : /* speech/music classifier */
326 3 : st_fx->Last_pulse_pos = 0;
327 3 : move16();
328 :
329 3 : st_fx->last_vad_spa_fx = 0;
330 3 : move16();
331 :
332 : /*-----------------------------------------------------------------*
333 : * VAD
334 : *-----------------------------------------------------------------*/
335 :
336 3 : st_fx->vad_flag = 1;
337 3 : st_fx->localVAD = 0;
338 3 : move16();
339 3 : move16();
340 3 : test();
341 3 : test();
342 3 : test();
343 3 : test();
344 3 : IF( ( idchan == 0 || EQ_16( st_fx->element_mode, IVAS_CPE_TD ) || EQ_16( st_fx->element_mode, IVAS_CPE_MDCT ) || st_fx->element_mode == EVS_MONO ) && ( !vad_only_flag ) )
345 : {
346 3 : if ( ( st_fx->hVAD = (VAD_HANDLE) malloc( sizeof( VAD_DATA ) ) ) == NULL )
347 : {
348 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for VAD\n" ) );
349 : }
350 :
351 3 : wb_vad_init_fx( st_fx->hVAD );
352 : }
353 : ELSE
354 : {
355 0 : st_fx->hVAD = NULL;
356 : }
357 :
358 3 : st_fx->Pos_relE_cnt = 5120;
359 3 : move16(); /*20.0f*/
360 :
361 : /* CLDFB-based VAD */
362 3 : IF( st_fx->element_mode == EVS_MONO )
363 : {
364 3 : if ( ( st_fx->hVAD_CLDFB = (VAD_CLDFB_HANDLE) malloc( sizeof( T_CldfbVadState ) ) ) == NULL )
365 : {
366 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for CLDFB VAD\n" ) );
367 : }
368 :
369 3 : vad_init_fx( st_fx->hVAD_CLDFB );
370 : }
371 : ELSE
372 : {
373 0 : st_fx->hVAD_CLDFB = NULL;
374 : }
375 :
376 :
377 : /*-----------------------------------------------------------------*
378 : * Noise estimator
379 : *-----------------------------------------------------------------*/
380 :
381 3 : test();
382 3 : test();
383 3 : IF( /*idchan == 0 ||*/ EQ_16( st_fx->element_mode, IVAS_CPE_TD ) || EQ_16( st_fx->element_mode, IVAS_CPE_MDCT ) || st_fx->element_mode == EVS_MONO )
384 : {
385 3 : if ( ( st_fx->hNoiseEst = (NOISE_EST_HANDLE) malloc( sizeof( NOISE_EST_DATA ) ) ) == NULL )
386 : {
387 0 : return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Noise estimation\n" );
388 : }
389 3 : noise_est_init_fx( st_fx->hNoiseEst );
390 : }
391 : ELSE
392 : {
393 0 : st_fx->hNoiseEst = NULL;
394 : }
395 :
396 : /*-----------------------------------------------------------------*
397 : * Speech/music classifier
398 : *-----------------------------------------------------------------*/
399 3 : test();
400 3 : test();
401 3 : test();
402 3 : IF( idchan == 0 || EQ_16( st_fx->element_mode, IVAS_CPE_TD ) || EQ_16( st_fx->element_mode, IVAS_CPE_MDCT ) || st_fx->element_mode == EVS_MONO )
403 : {
404 3 : IF( ( st_fx->hSpMusClas = (SP_MUS_CLAS_HANDLE) malloc( sizeof( SP_MUS_CLAS_DATA ) ) ) == NULL )
405 : {
406 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Speech/music classifier\n" ) );
407 : }
408 :
409 3 : speech_music_clas_init_fx( st_fx->hSpMusClas );
410 :
411 3 : st_fx->sp_aud_decision0 = 0;
412 3 : st_fx->sp_aud_decision1 = 0;
413 3 : st_fx->sp_aud_decision2 = 0;
414 3 : move16();
415 3 : move16();
416 3 : move16();
417 : }
418 : ELSE
419 : {
420 0 : st_fx->hSpMusClas = NULL;
421 : }
422 :
423 3 : st_fx->bckr_tilt_lt = 0;
424 3 : move32();
425 :
426 : /* WB, SWB and FB bandwidth detector */
427 3 : st_fx->lt_mean_NB_fx = 0;
428 3 : move16();
429 3 : st_fx->lt_mean_WB_fx = 0;
430 3 : move16();
431 3 : st_fx->lt_mean_SWB_fx = 0;
432 3 : move16();
433 3 : st_fx->count_WB = BWD_COUNT_MAX;
434 3 : move16();
435 3 : st_fx->count_SWB = BWD_COUNT_MAX;
436 3 : move16();
437 3 : st_fx->count_FB = BWD_COUNT_MAX;
438 3 : move16();
439 3 : st_fx->bwidth = st_fx->max_bwidth;
440 3 : move16();
441 3 : st_fx->last_input_bwidth = st_fx->bwidth;
442 3 : move16();
443 3 : st_fx->last_bwidth = st_fx->bwidth;
444 3 : move16();
445 3 : st_fx->last_bwidth_cng = st_fx->bwidth;
446 3 : move16();
447 :
448 :
449 3 : move16();
450 3 : st_fx->coder_type_raw = VOICED;
451 3 : st_fx->last_coder_type_raw = st_fx->coder_type_raw;
452 3 : move16();
453 3 : st_fx->is_ism_format = 0;
454 3 : move16();
455 3 : if ( NE_16( ism_mode, ISM_MODE_NONE ) )
456 : {
457 0 : st_fx->is_ism_format = 1;
458 0 : move16();
459 : }
460 : /* Stationary noise UV modification */
461 3 : st_fx->ge_sm_fx = 640;
462 3 : move32(); /*Q(GE_SHIFT) */
463 3 : st_fx->uv_count = 0;
464 3 : move16();
465 3 : st_fx->act_count = 3;
466 3 : move16();
467 3 : Copy( st_fx->lsp_old_fx, st_fx->lspold_s_fx, M );
468 3 : st_fx->noimix_seed = RANDOM_INITSEED;
469 3 : move16();
470 3 : st_fx->min_alpha_fx = 1;
471 3 : move16();
472 3 : st_fx->exc_pe_fx = 0;
473 3 : move16();
474 :
475 : /*-----------------------------------------------------------------*
476 : * DTX
477 : *-----------------------------------------------------------------*/
478 :
479 3 : st_fx->lp_speech_fx = 11520;
480 3 : move16(); /*Q8 (45.0) */ /* Initialize the long-term active speech level in dB */
481 3 : st_fx->lp_noise_fx = 0;
482 3 : move16();
483 :
484 3 : test();
485 3 : test();
486 3 : IF( ( ( idchan == 0 && st_fx->Opt_DTX_ON ) || EQ_16( st_fx->element_mode, EVS_MONO ) ) || ( EQ_16( st_fx->element_mode, IVAS_CPE_MDCT ) && st_fx->Opt_DTX_ON ) )
487 : {
488 3 : if ( ( st_fx->hDtxEnc = (DTX_ENC_HANDLE) malloc( sizeof( DTX_ENC_DATA ) ) ) == NULL )
489 : {
490 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for DTX variables\n" ) );
491 : }
492 3 : dtx_enc_init_fx( st_fx, var_SID_rate_flag, interval_SID );
493 : }
494 : ELSE
495 : {
496 0 : st_fx->hDtxEnc = NULL;
497 : }
498 :
499 3 : st_fx->fd_cng_reset_flag = 0;
500 3 : move16();
501 :
502 3 : IF( st_fx->Opt_DTX_ON )
503 : {
504 0 : move16();
505 : }
506 :
507 3 : st_fx->cng_type = -1;
508 3 : move16();
509 :
510 :
511 : /*-----------------------------------------------------------------*
512 : * LP-CNG
513 : *-----------------------------------------------------------------*/
514 :
515 3 : test();
516 3 : test();
517 3 : test();
518 3 : test();
519 3 : test();
520 3 : IF( ( ( idchan == 0 && st_fx->Opt_DTX_ON && NE_16( st_fx->element_mode, IVAS_CPE_MDCT ) ) || EQ_16( st_fx->element_mode, EVS_MONO ) ) && !( EQ_16( ism_mode, ISM_MODE_PARAM ) || EQ_16( ism_mode, ISM_MODE_DISC ) ) )
521 : {
522 3 : IF( ( st_fx->hTdCngEnc = (TD_CNG_ENC_HANDLE) malloc( sizeof( TD_CNG_ENC_DATA ) ) ) == NULL )
523 : {
524 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for DTX/TD CNG\n" ) );
525 : }
526 :
527 3 : td_cng_enc_init_fx( st_fx->hTdCngEnc, st_fx->Opt_DTX_ON, st_fx->max_bwidth );
528 : }
529 : ELSE
530 : {
531 0 : st_fx->hTdCngEnc = NULL;
532 : }
533 :
534 :
535 : /*-----------------------------------------------------------------*
536 : * ACELP LPDmem
537 : *-----------------------------------------------------------------*/
538 :
539 3 : test();
540 3 : test();
541 3 : IF( ( idchan == 0 && NE_16( st_fx->element_mode, IVAS_CPE_MDCT ) ) || EQ_16( st_fx->element_mode, IVAS_CPE_TD ) )
542 : {
543 3 : IF( ( st_fx->hLPDmem = (LPD_state_HANDLE) malloc( sizeof( LPD_state ) ) ) == NULL )
544 : {
545 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for LPDmem\n" ) );
546 : }
547 :
548 3 : LPDmem_enc_init_fx( st_fx->hLPDmem );
549 : }
550 : ELSE
551 : {
552 0 : st_fx->hLPDmem = NULL;
553 : }
554 :
555 : /* FEC */
556 3 : st_fx->last_clas = UNVOICED_CLAS;
557 3 : move16();
558 :
559 33 : FOR( i = 0; i < 2 * NB_SUBFR16k; i++ )
560 : {
561 30 : st_fx->old_pitch_buf_fx[i] = L_SUBFR_Q6;
562 30 : move16();
563 : }
564 3 : st_fx->old_Es_pred_fx = 0;
565 3 : move16();
566 3 : set16_fx( st_fx->old_Aq_12_8_fx + 1, 0, M );
567 3 : st_fx->old_Aq_12_8_fx[0] = 4096;
568 3 : move16();
569 :
570 : /*-----------------------------------------------------------------*
571 : * CLDFB Analysis
572 : *-----------------------------------------------------------------*/
573 :
574 : /* open analysis for input SR */
575 3 : if ( ( error = openCldfb( &st_fx->cldfbAnaEnc, CLDFB_ANALYSIS, CLDFB_getNumChannels( st_fx->input_Fs ), st_fx->input_frame_fx ) ) != IVAS_ERR_OK )
576 : {
577 0 : return error;
578 : }
579 :
580 3 : if ( ( error = openCldfb( &st_fx->cldfbSynTd, CLDFB_SYNTHESIS, CLDFB_getNumChannels( 16000 ), L_FRAME16k ) ) != IVAS_ERR_OK )
581 : {
582 0 : return error;
583 : }
584 :
585 3 : st_fx->energyCoreLookahead_Fx = 0;
586 3 : move32();
587 3 : st_fx->sf_energyCoreLookahead_Fx = 0;
588 3 : move16();
589 :
590 : /* stable short pitch detection */
591 3 : st_fx->voicing0_sm_fx = 0;
592 3 : move16();
593 3 : st_fx->voicing_sm_fx = 0;
594 3 : move16();
595 3 : st_fx->LF_EnergyRatio_sm_fx = 128;
596 3 : move16();
597 3 : st_fx->predecision_flag = 0;
598 3 : move16();
599 3 : st_fx->diff_sm_fx = 0;
600 3 : move32();
601 3 : st_fx->energy_sm_fx = 0;
602 3 : move32();
603 :
604 : /*-----------------------------------------------------------------*
605 : * SC-VBR parameters
606 : *-----------------------------------------------------------------*/
607 3 : test();
608 3 : IF( st_fx->Opt_SC_VBR || st_fx->element_mode == EVS_MONO )
609 : {
610 3 : IF( ( st_fx->hSC_VBR = (SC_VBR_ENC_HANDLE) malloc( sizeof( SC_VBR_ENC_DATA ) ) ) == NULL )
611 : {
612 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for SC-VBR\n" ) );
613 : }
614 :
615 3 : sc_vbr_enc_init_fx( st_fx->hSC_VBR );
616 : }
617 : ELSE
618 : {
619 0 : st_fx->hSC_VBR = NULL;
620 : }
621 : /* PLC encoder */
622 3 : IF( st_fx->element_mode == EVS_MONO )
623 : {
624 3 : IF( ( st_fx->hPlcExt = (PLC_ENC_EVS_HANDLE) malloc( sizeof( PLC_ENC_EVS ) ) ) == NULL )
625 : {
626 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for hPlcExt\n" ) );
627 : }
628 : }
629 : ELSE
630 : {
631 0 : st_fx->hPlcExt = NULL;
632 : }
633 : /*-----------------------------------------------------------------*
634 : * Temporal Envelope Coding
635 : *-----------------------------------------------------------------*/
636 :
637 3 : IF( st_fx->element_mode == EVS_MONO )
638 : {
639 3 : IF( ( st_fx->hTECEnc = (TEC_ENC_HANDLE) malloc( sizeof( TEC_ENC_DATA ) ) ) == NULL )
640 : {
641 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for TEC\n" ) );
642 : }
643 : }
644 : ELSE
645 : {
646 0 : st_fx->hTECEnc = NULL;
647 : }
648 :
649 : /*-----------------------------------------------------------------*
650 : * SWB BWE parameters
651 : *-----------------------------------------------------------------*/
652 3 : IF( idchan == 0 && NE_16( st_fx->element_mode, IVAS_CPE_MDCT ) )
653 : {
654 3 : IF( ( st_fx->hBWE_FD = (FD_BWE_ENC_HANDLE) malloc( sizeof( FD_BWE_ENC_DATA ) ) ) == NULL )
655 : {
656 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for FD BWE\n" ) );
657 : }
658 :
659 3 : fd_bwe_enc_init_fx( st_fx->hBWE_FD );
660 : }
661 : ELSE
662 : {
663 0 : st_fx->hBWE_FD = NULL;
664 : }
665 :
666 3 : st_fx->prev_Q_shb = 0;
667 3 : move16();
668 3 : st_fx->last_Opt_SC_VBR = 0;
669 3 : move16();
670 :
671 : /*-----------------------------------------------------------------*
672 : * TBE parameters
673 : *-----------------------------------------------------------------*/
674 :
675 3 : IF( idchan == 0 && NE_16( st_fx->element_mode, IVAS_CPE_MDCT ) )
676 : {
677 3 : IF( ( st_fx->hBWE_TD = (TD_BWE_ENC_HANDLE) malloc( sizeof( TD_BWE_ENC_DATA ) ) ) == NULL )
678 : {
679 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for TD BWE\n" ) );
680 : }
681 :
682 : // IF ((error = openCldfb(&st_fx->cldfbSynTd, CLDFB_SYNTHESIS, 16000, CLDFB_PROTOTYPE_1_25MS)) != IVAS_ERR_OK)
683 : //{
684 : // return error;
685 : // }
686 :
687 3 : InitSWBencBuffer_fx( st_fx /*st_fx->hBWE_TD*/ );
688 3 : ResetSHBbuffer_Enc_fx( st_fx /*st_fx->hBWE_TD*/ );
689 : }
690 : ELSE
691 : {
692 0 : st_fx->hBWE_TD = NULL;
693 : // st_fx->cldfbSynTd = NULL;
694 : }
695 :
696 3 : test();
697 3 : IF( st_fx->Opt_RF_ON || st_fx->element_mode == EVS_MONO )
698 : {
699 3 : IF( ( st_fx->hRF = (RF_ENC_HANDLE) malloc( sizeof( RF_ENC_DATA ) ) ) == NULL )
700 : {
701 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for RF\n" ) );
702 : }
703 :
704 : /* initialize RF indice buffers */
705 3 : reset_rf_indices_fx( st_fx /*->hRF, st_fx->L_frame, &st->rf_target_bits_write*/ );
706 : }
707 : ELSE
708 : {
709 0 : st_fx->hRF = NULL;
710 : }
711 :
712 :
713 : /*-----------------------------------------------------------------*
714 : * HQ core parameters
715 : *-----------------------------------------------------------------*/
716 :
717 3 : st_fx->input_fx = st_fx->input_buff_fx + L_FRAME48k + NS2SA( 48000, DELAY_FIR_RESAMPL_NS );
718 3 : set16_fx( st_fx->input_buff_fx + L_FRAME48k, 0, L_FRAME48k + NS2SA( 48000, DELAY_FIR_RESAMPL_NS ) );
719 3 : st_fx->old_input_signal_fx = st_fx->input_fx - add( NS2SA_FX2( st_fx->input_Fs, DELAY_FIR_RESAMPL_NS ), st_fx->input_frame_fx );
720 :
721 :
722 3 : st_fx->Energy_Old_fx = 0;
723 3 : move16();
724 3 : st_fx->Q_old_wtda = 15;
725 3 : move16();
726 3 : st_fx->EnergyLT_fx = 1;
727 3 : move32();
728 3 : st_fx->EnergyLT_fx_exp = 30;
729 3 : move16(); /* Set to a High Exponent so it is 1^-30 */
730 3 : st_fx->TransientHangOver = 0;
731 3 : move16();
732 :
733 : /*-----------------------------------------------------------------*
734 : * TCX core
735 : *-----------------------------------------------------------------*/
736 :
737 3 : test();
738 3 : IF( idchan == 0 || EQ_16( st_fx->element_mode, IVAS_CPE_MDCT ) )
739 : {
740 3 : IF( ( st_fx->hTcxEnc = (TCX_ENC_HANDLE) malloc( sizeof( TCX_ENC_DATA ) ) ) == NULL )
741 : {
742 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for hTcxEnc\n" ) );
743 : }
744 :
745 : /* Share the memories for 2xTCX10/4xTCX5 and for TCX20 */
746 : /*st_fx->hTcxEnc->spectrum[0] = st_fx->hTcxEnc->spectrum_long;
747 : st_fx->hTcxEnc->spectrum[1] = st_fx->hTcxEnc->spectrum_long + N_TCX10_MAX;*/
748 :
749 3 : st_fx->hTcxEnc->spectrum_fx[0] = st_fx->hTcxEnc->spectrum_long_fx;
750 3 : st_fx->hTcxEnc->spectrum_fx[1] = st_fx->hTcxEnc->spectrum_long_fx + N_TCX10_MAX;
751 :
752 3 : set16_fx( st_fx->hTcxEnc->old_out_fx, 0, L_FRAME32k );
753 3 : st_fx->hTcxEnc->Q_old_out = 0;
754 3 : move16();
755 : /* MDCT selector */
756 3 : MDCT_selector_reset_fx( st_fx->hTcxEnc );
757 3 : st_fx->hTcxEnc->Q_old_out = 0;
758 3 : move16();
759 :
760 : /* MDCT classifier */
761 3 : MDCT_classifier_reset_fx( st_fx->hTcxEnc );
762 :
763 3 : IF( ( st_fx->hTcxCfg = (TCX_CONFIG_HANDLE) malloc( sizeof( TCX_config ) ) ) == NULL )
764 : {
765 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for hTcxCfg\n" ) );
766 : }
767 : }
768 : ELSE
769 : {
770 0 : st_fx->hTcxEnc = NULL;
771 : // st_fx->hTcxCfg = NULL;
772 : }
773 : /*-----------------------------------------------------------------*
774 : * HQ core parameters
775 : *-----------------------------------------------------------------*/
776 :
777 3 : test();
778 3 : test();
779 3 : IF( NE_16( st_fx->element_mode, IVAS_CPE_TD ) && NE_16( st_fx->element_mode, IVAS_CPE_MDCT ) && idchan == 0 )
780 : {
781 3 : IF( ( st_fx->hHQ_core = (HQ_ENC_HANDLE) malloc( sizeof( HQ_ENC_DATA ) ) ) == NULL )
782 : {
783 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for HQ core\n" ) );
784 : }
785 :
786 3 : HQ_core_enc_init_fx( st_fx->hHQ_core );
787 : }
788 : ELSE
789 : {
790 0 : st_fx->hHQ_core = NULL;
791 : }
792 :
793 3 : st_fx->last_enerBuffer_exp = 0;
794 3 : move16();
795 :
796 : /*-----------------------------------------------------------------*
797 : * Channel-aware mode
798 : *-----------------------------------------------------------------*/
799 :
800 :
801 3 : test();
802 3 : test();
803 3 : test();
804 3 : IF( st_fx->Opt_RF_ON == 0 || ( NE_16( st_fx->bwidth, WB ) && NE_16( st_fx->bwidth, SWB ) ) || NE_32( st_fx->total_brate, ACELP_13k20 ) )
805 : {
806 3 : IF( EQ_16( st_fx->Opt_RF_ON, 1 ) )
807 : {
808 0 : printf( "\nWarning: Channel-aware mode only available for 13.2 kbps WB/SWB\n" );
809 0 : printf( " Switched to normal mode!\n" );
810 0 : st_fx->Opt_RF_ON = 0;
811 0 : move16();
812 0 : st_fx->rf_fec_offset = 0;
813 0 : move16();
814 : }
815 3 : st_fx->rf_mode = 0;
816 3 : move16();
817 : }
818 : ELSE
819 : {
820 0 : st_fx->rf_mode = st_fx->Opt_RF_ON;
821 0 : move16();
822 : }
823 3 : st_fx->rf_mode_last = st_fx->rf_mode;
824 3 : move16();
825 : /* initialize RF indice buffers */
826 3 : reset_rf_indices_fx( st_fx );
827 :
828 : /*-----------------------------------------------------------------*
829 : * MODE2 initialization
830 : *-----------------------------------------------------------------*/
831 :
832 3 : st_fx->last_sr_core = i_mult2( st_fx->last_L_frame, 50 );
833 3 : move16();
834 : /*-----------------------------------------------------------------*
835 : * IGF
836 : *-----------------------------------------------------------------*/
837 :
838 3 : test();
839 3 : IF( idchan == 0 || EQ_16( st_fx->element_mode, IVAS_CPE_MDCT ) )
840 : {
841 3 : IF( ( st_fx->hIGFEnc = (IGF_ENC_INSTANCE_HANDLE) malloc( sizeof( IGF_ENC_INSTANCE ) ) ) == NULL )
842 : {
843 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for hIGFEnc\n" ) );
844 : }
845 : }
846 : ELSE
847 : {
848 0 : st_fx->hIGFEnc = NULL;
849 0 : move16();
850 : }
851 :
852 3 : IF( EQ_16( st_fx->codec_mode, MODE2 ) )
853 : {
854 1 : st_fx->igf = getIgfPresent_fx( st_fx->element_mode, st_fx->total_brate, st_fx->bwidth, st_fx->rf_mode );
855 : }
856 : ELSE
857 : {
858 2 : st_fx->igf = 0;
859 2 : move16();
860 : }
861 :
862 : /* FD-CNG encoder */
863 3 : createFdCngEnc_fx( &st_fx->hFdCngEnc );
864 3 : initFdCngEnc_fx( st_fx->hFdCngEnc, st_fx->input_Fs, st_fx->cldfbAnaEnc->scale );
865 3 : L_tmp = st_fx->total_brate;
866 3 : move32();
867 3 : test();
868 3 : if ( st_fx->rf_mode && EQ_32( st_fx->total_brate, ACELP_13k20 ) )
869 : {
870 0 : L_tmp = ACELP_9k60;
871 0 : move32();
872 : }
873 3 : configureFdCngEnc_fx( st_fx->hFdCngEnc, st_fx->bwidth, L_tmp );
874 :
875 3 : st_fx->last_totalNoise_fx = 0;
876 3 : move16();
877 3 : set16_fx( st_fx->totalNoise_increase_hist_fx, 0, TOTALNOISE_HIST_SIZE );
878 3 : st_fx->totalNoise_increase_len = 0;
879 3 : move16();
880 3 : init_coder_ace_plus_fx( st_fx, st_fx->last_total_brate, 0, -10 /*hack*/ );
881 :
882 3 : IF( ( st_fx->hTranDet = (TRAN_DET_HANDLE) malloc( sizeof( TRAN_DET_DATA ) ) ) == NULL )
883 : {
884 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Transient Detection\n" ) );
885 : }
886 :
887 3 : InitTransientDetection_fx( extract_l( Mult_32_16( st_fx->input_Fs, INV_FRAME_PER_SEC_Q15 ) ),
888 3 : NS2SA_FX2( st_fx->input_Fs, DELAY_FIR_RESAMPL_NS ),
889 : st_fx->hTranDet );
890 :
891 3 : st_fx->Q_syn2 = 0;
892 3 : move16();
893 3 : st_fx->Q_syn = 0;
894 3 : move16();
895 3 : set16_fx( st_fx->Q_max, Q_MAX, L_Q_MEM );
896 3 : set16_fx( st_fx->Q_max_16k, Q_MAX, L_Q_MEM );
897 3 : st_fx->Q_old = 15;
898 3 : move16();
899 3 : st_fx->old_wsp_max = 0;
900 3 : move16();
901 3 : st_fx->old_wsp_shift = 0;
902 3 : move16();
903 3 : st_fx->sharpFlag = 0;
904 3 : move16();
905 :
906 3 : st_fx->tdm_LRTD_flag = 0; /* LRTD stereo mode flag */
907 3 : move16();
908 3 : st_fx->cna_dirac_flag = 0; /* CNA in DirAC flag */
909 3 : move16();
910 3 : st_fx->cng_sba_flag = 0; /* CNG in SBA flag */
911 3 : move16();
912 3 : st_fx->GSC_IVAS_mode = 0; /* CNG in SBA flag */
913 3 : move16();
914 3 : st_fx->element_mode = EVS_MONO; /* element mode */
915 3 : move16();
916 3 : st_fx->last_element_mode = st_fx->element_mode; /* element mode */
917 3 : move16();
918 3 : st_fx->element_brate = -1; /* element bitrate */
919 3 : move32();
920 : // PMT("element_mode and element_brate should be initialized at a proper place in ivas_dec_init eventually")
921 3 : st_fx->low_rate_mode = 0; /* low-rate mode flag */
922 3 : move16();
923 : // st_fx->coder_type = GENERIC; /* low-rate mode flag */
924 :
925 3 : set16_fx( st_fx->pitch, L_SUBFR, 3 );
926 3 : set16_fx( st_fx->voicing_fx, 0, 3 );
927 :
928 :
929 : #ifdef DEBUGGING
930 : st_fx->id_element = -1; /* element ID */
931 : move16();
932 : #endif
933 3 : st_fx->extl_orig = -1; /* extension layer */
934 3 : move16();
935 3 : st_fx->extl_brate_orig = 0; /* extension layer bitrate */
936 3 : move32();
937 3 : return error;
938 : }
939 :
940 : /*-----------------------------------------------------------------------*
941 : * LPDmem_enc_init_fx()
942 : *
943 : * Initialization of ACELP LPDmem state variables
944 : *-----------------------------------------------------------------------*/
945 :
946 3 : void LPDmem_enc_init_fx(
947 : LPD_state_HANDLE hLPDmem /* i/o: LP memories */
948 : )
949 : {
950 : Word16 i;
951 :
952 3 : set16_fx( hLPDmem->syn, 0, 1 + M );
953 3 : set16_fx( hLPDmem->old_exc, 0, L_EXC_MEM );
954 3 : set16_fx( hLPDmem->mem_syn, 0, M );
955 3 : set16_fx( hLPDmem->mem_syn1_fx, 0, M );
956 3 : set16_fx( hLPDmem->mem_syn2, 0, M );
957 3 : set16_fx( hLPDmem->mem_syn_r, 0, L_SYN_MEM );
958 3 : set16_fx( hLPDmem->mem_syn3, 0, M );
959 :
960 3 : hLPDmem->mem_w0 = 0;
961 3 : move16();
962 3 : hLPDmem->tilt_code = 0;
963 3 : move16();
964 3 : hLPDmem->gc_threshold = 0;
965 3 : move32();
966 3 : hLPDmem->dm_fx.prev_state = 0;
967 3 : move16(); /* This corresponds to st_fx->dispMem in FLP */
968 3 : hLPDmem->dm_fx.prev_gain_code = 0;
969 3 : move32();
970 :
971 21 : FOR( i = 2; i < 8; i++ )
972 : {
973 18 : hLPDmem->dm_fx.prev_gain_pit[i - 2] = 0;
974 18 : move16();
975 : }
976 3 : return;
977 : }
978 :
979 3895 : void LPDmem_enc_init_ivas_fx(
980 : LPD_state_HANDLE hLPDmem /* i/o: LP memories */
981 : )
982 : {
983 : Word16 i;
984 :
985 3895 : set16_fx( hLPDmem->syn, 0, 1 + M );
986 3895 : set16_fx( hLPDmem->old_exc, 0, L_EXC_MEM );
987 3895 : set16_fx( hLPDmem->mem_syn, 0, M );
988 3895 : set16_fx( hLPDmem->mem_syn1_fx, 0, M );
989 3895 : set16_fx( hLPDmem->mem_syn2, 0, M );
990 3895 : set16_fx( hLPDmem->mem_syn_r, 0, L_SYN_MEM );
991 3895 : set16_fx( hLPDmem->mem_syn3, 0, M );
992 3895 : hLPDmem->q_lpd_old_exc = Q15;
993 3895 : move16();
994 3895 : hLPDmem->q_lpd_syn = Q15;
995 3895 : move16();
996 3895 : hLPDmem->q_mem_syn = Q15;
997 3895 : move16();
998 3895 : hLPDmem->mem_w0 = 0;
999 3895 : move16();
1000 3895 : hLPDmem->tilt_code = 0;
1001 3895 : move16();
1002 3895 : hLPDmem->gc_threshold = 0;
1003 3895 : move32();
1004 3895 : hLPDmem->dm_fx.prev_state = 0;
1005 3895 : move16(); /* This corresponds to st_fx->dispMem in FLP */
1006 3895 : hLPDmem->dm_fx.prev_gain_code = 0;
1007 3895 : move32();
1008 :
1009 27265 : FOR( i = 2; i < 8; i++ )
1010 : {
1011 23370 : hLPDmem->dm_fx.prev_gain_pit[i - 2] = 0;
1012 23370 : move16();
1013 : }
1014 :
1015 3895 : return;
1016 : }
1017 :
1018 : /*-----------------------------------------------------------------------*
1019 : * destroy_encoder_fx()
1020 : *
1021 : * Free memory which was allocated in init_encoder_fx()
1022 : *-----------------------------------------------------------------------*/
1023 :
1024 3 : void destroy_encoder_fx(
1025 : Encoder_State *st_fx /* i/o: Encoder static variables structure */
1026 : )
1027 : {
1028 3 : deleteCldfb( &st_fx->cldfbAnaEnc );
1029 3 : deleteCldfb( &st_fx->cldfbSynTd );
1030 :
1031 3 : deleteFdCngEnc_fx( &st_fx->hFdCngEnc );
1032 :
1033 3 : return;
1034 : }
1035 :
1036 8837 : ivas_error init_encoder_ivas_fx(
1037 : Encoder_State *st, /* i/o: state structure */
1038 : Encoder_Struct *st_ivas, /* i/o: encoder state structure */
1039 : const Word16 idchan, /* i : channel ID */
1040 : const Word16 var_SID_rate_flag, /* i : flag for variable SID update rate */
1041 : const Word16 interval_SID, /* i : interval for SID update */
1042 : const Word16 vad_only_flag, /* i : flag to indicate front-VAD structure */
1043 : const ISM_MODE ism_mode, /* i : ISM mode */
1044 : const Word32 element_brate /* i : element bitrate */
1045 : )
1046 : {
1047 : Word16 i;
1048 : ivas_error error;
1049 : Word32 igf_brate;
1050 :
1051 8837 : error = IVAS_ERR_OK;
1052 8837 : move32();
1053 :
1054 : /*-----------------------------------------------------------------*
1055 : * General parameters
1056 : *-----------------------------------------------------------------*/
1057 :
1058 8837 : IF( st->Opt_AMR_WB )
1059 : {
1060 0 : st->last_core = AMR_WB_CORE;
1061 : }
1062 : ELSE
1063 : {
1064 8837 : st->last_core = -1;
1065 : }
1066 8837 : move16();
1067 :
1068 8837 : st->L_frame = L_FRAME;
1069 8837 : move16();
1070 8837 : st->last_coder_type = GENERIC;
1071 8837 : move16();
1072 8837 : st->coder_type = GENERIC;
1073 8837 : move16();
1074 8837 : st->last_total_brate = st->total_brate;
1075 8837 : move32();
1076 8837 : st->last_bits_frame_nominal = -1;
1077 8837 : move16();
1078 8837 : st->last_total_brate_cng = -1;
1079 8837 : move16();
1080 8837 : st->last_core_brate = st->total_brate;
1081 8837 : move32();
1082 8837 : st->dtx_sce_sba = 0;
1083 8837 : move16();
1084 8837 : st->extl = -1;
1085 8837 : move16();
1086 8837 : st->last_extl = -1;
1087 8837 : move16();
1088 8837 : st->last_L_frame = L_FRAME;
1089 8837 : move16();
1090 8837 : st->rate_switching_reset = 0;
1091 8837 : move16();
1092 8837 : st->rate_switching_reset_16kHz = 0;
1093 8837 : move16();
1094 8837 : st->clas = UNVOICED_CLAS;
1095 8837 : move16();
1096 8837 : st->low_rate_mode = 0;
1097 8837 : move16();
1098 8837 : st->ini_frame = 0;
1099 8837 : move16();
1100 8837 : st->inactive_coder_type_flag = 0;
1101 8837 : move16();
1102 8837 : st->sba_br_sw_while_no_data = 0;
1103 8837 : move16();
1104 :
1105 8837 : st->coder_type_raw = VOICED;
1106 8837 : move16();
1107 8837 : st->last_coder_type_raw = st->coder_type_raw;
1108 8837 : move16();
1109 :
1110 8837 : st->flag_ACELP16k = set_ACELP_flag_IVAS( st->element_mode, st->total_brate, st->total_brate, idchan, 0, -1, -1 );
1111 8837 : move16();
1112 :
1113 8837 : st->is_ism_format = 0;
1114 8837 : move16();
1115 :
1116 8837 : IF( NE_16( ism_mode, ISM_MODE_NONE ) )
1117 : {
1118 2160 : st->is_ism_format = 1;
1119 2160 : move16();
1120 : }
1121 :
1122 : /*-----------------------------------------------------------------*
1123 : * Bitstream
1124 : *-----------------------------------------------------------------*/
1125 :
1126 8837 : IF( !vad_only_flag )
1127 : {
1128 8768 : IF( ( st->hBstr = (BSTR_ENC_HANDLE) malloc( sizeof( BSTR_ENC_DATA ) ) ) == NULL )
1129 : {
1130 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Bitstream structure\n" ) );
1131 : }
1132 :
1133 : /* set pointer to the buffer of indices */
1134 8768 : st->hBstr->ind_list = st_ivas->ind_list;
1135 8768 : st->hBstr->ivas_ind_list_zero = &st_ivas->ind_list;
1136 8768 : st->hBstr->ivas_max_num_indices = &st_ivas->ivas_max_num_indices;
1137 8768 : st->hBstr->nb_ind_tot = 0;
1138 8768 : move16();
1139 8768 : st->hBstr->nb_bits_tot = 0;
1140 8768 : move16();
1141 8768 : st->hBstr->st_ivas = st_ivas;
1142 : }
1143 : ELSE
1144 : {
1145 69 : st->hBstr = NULL;
1146 : }
1147 :
1148 : /*-----------------------------------------------------------------*
1149 : * Pre-processing and ACELP core parameters
1150 : *-----------------------------------------------------------------*/
1151 :
1152 8837 : Copy( GEWB_Ave_fx, st->mem_AR_fx, M );
1153 8837 : Copy( GEWB_Ave_fx, st->lsfoldbfi0_fx, M );
1154 8837 : Copy( GEWB_Ave_fx, st->lsfoldbfi1_fx, M );
1155 8837 : Copy( GEWB_Ave_fx, st->lsf_adaptive_mean_fx, M );
1156 :
1157 8837 : st->next_force_safety_net = 0;
1158 8837 : move16();
1159 :
1160 8837 : st->pstreaklen = 0;
1161 8837 : move16();
1162 8837 : st->streaklimit_fx = MAX_WORD16;
1163 8837 : move16();
1164 8837 : set16_fx( st->mem_MA_fx, 0, M );
1165 :
1166 8837 : init_gp_clip_fx( st->clip_var_fx );
1167 8837 : pitch_ol_init_fx( &st->old_thres_fx, &st->old_pitch, &st->delta_pit, &st->old_corr_fx );
1168 8837 : set16_fx( st->old_wsp_fx, 0, L_WSP_MEM );
1169 8837 : st->exp_old_wsp = 0;
1170 8837 : move16();
1171 8837 : set16_fx( st->old_wsp2_fx, 0, ( L_WSP_MEM - L_INTERPOL ) / OPL_DECIM ); // Needs to change depending on usage.
1172 8837 : st->Q_old_wsp2 = 0;
1173 8837 : move16();
1174 :
1175 8837 : st->mem_preemph_fx = 0;
1176 8837 : move16();
1177 8837 : st->mem_preemph_fx_q_inp = 0;
1178 8837 : move16();
1179 8837 : st->mem_preemph16k_fx = 0;
1180 8837 : move16();
1181 8837 : st->mem_preemph_enc = 0;
1182 8837 : move16();
1183 8837 : st->exp_mem_preemph_enc = 0;
1184 8837 : move16();
1185 :
1186 8837 : st->active_cnt = 0;
1187 8837 : move16();
1188 :
1189 8837 : st->pst_mem_deemp_err_fx = 0;
1190 8837 : move16();
1191 8837 : st->pst_lp_ener_fx = 0;
1192 8837 : move16();
1193 :
1194 : /* AVQ pre-quantizer memory */
1195 8837 : st->mem_preemp_preQ_fx = 0;
1196 8837 : move16();
1197 8837 : st->mem_deemp_preQ_fx = 0;
1198 8837 : move16();
1199 8837 : st->last_nq_preQ = 0;
1200 8837 : move16();
1201 8837 : st->last_code_preq = 0;
1202 8837 : move16();
1203 8837 : st->use_acelp_preq = 0;
1204 8837 : move16();
1205 8837 : st->last_harm_flag_acelp = 0;
1206 8837 : move16();
1207 :
1208 : /* (Decimated) Weighted Speech Memory */
1209 8837 : st->mem_wsp_enc = 0;
1210 8837 : move16();
1211 8837 : st->mem_wsp_fx = 0;
1212 8837 : move16();
1213 8837 : st->mem_wsp_q = 0;
1214 8837 : move16();
1215 8837 : set16_fx( st->mem_decim2_fx, 0, 3 );
1216 8837 : set32_fx( st->Bin_E_fx, 0, L_FFT );
1217 8837 : st->q_Bin_E = Q31;
1218 8837 : move16();
1219 8837 : st->ee_old_fx = 640; /* 10.0f in Q6 */
1220 8837 : move16();
1221 8837 : st->Nb_ACELP_frames = 0;
1222 8837 : move16();
1223 8837 : st->audio_frame_cnt = AUDIO_COUNTER_INI; /* Initialization of the audio frame counter mildly into the audio mode */
1224 8837 : move16();
1225 :
1226 : /* adaptive lag window memory */
1227 8837 : st->old_pitch_la = 0;
1228 8837 : move16();
1229 :
1230 8837 : st->prev_Q_new = 0;
1231 8837 : move16();
1232 :
1233 8837 : IF( EQ_32( st->input_Fs, 8000 ) )
1234 : {
1235 0 : st->min_band = 1;
1236 0 : move16();
1237 0 : st->max_band = 16;
1238 0 : move16();
1239 : }
1240 : ELSE
1241 : {
1242 8837 : st->min_band = 0;
1243 8837 : move16();
1244 8837 : st->max_band = 19;
1245 8837 : move16();
1246 : }
1247 :
1248 8837 : IF( st->Opt_AMR_WB )
1249 : {
1250 0 : Copy( mean_isf_amr_wb_fx, st->lsf_old_fx, M );
1251 0 : E_LPC_isf_isp_conversion( st->lsf_old_fx, st->lsp_old1_fx, M );
1252 : }
1253 : ELSE
1254 : {
1255 8837 : Copy( GEWB_Ave_fx, st->lsf_old_fx, M );
1256 8837 : lsf2lsp_fx( st->lsf_old_fx, st->lsp_old1_fx, M, INT_FS_12k8 );
1257 : }
1258 :
1259 8837 : Copy( st->lsf_old_fx, st->lsf_old1_fx, M );
1260 8837 : Copy( st->lsp_old1_fx, st->lsp_old_fx, M );
1261 8837 : Copy( st->lsp_old_fx, st->lsp_old16k_fx, M );
1262 8837 : Copy( st->lsp_old_fx, st->lspold_enc_fx, M );
1263 :
1264 8837 : st->stab_fac_fx = 0;
1265 8837 : move16();
1266 :
1267 : /* Bass post-filter memories - encoder side of MODE2 */
1268 8837 : st->bpf_off = 0;
1269 8837 : move16();
1270 8837 : st->pst_mem_deemp_err_fx = 0;
1271 8837 : move16();
1272 8837 : st->pst_lp_ener_fx = 0;
1273 8837 : move16();
1274 :
1275 : /* TC coder type */
1276 8837 : st->tc_cnt = 0;
1277 8837 : move16();
1278 :
1279 : /* find_uv() parameters */
1280 8837 : st->old_dE1_fx = 0;
1281 8837 : move16();
1282 8837 : st->old_ind_deltaMax = 0;
1283 8837 : move16();
1284 8837 : set32_fx( st->old_enr_ssf_fx, 0, shl( NB_SSF, 1 ) );
1285 8837 : st->spike_hyst = -1;
1286 8837 : move16();
1287 :
1288 : /* stereo switching memories */
1289 8837 : st->mem_preemph_DFT_fx = 0;
1290 8837 : move16();
1291 8837 : st->mem_preemph_DFT_fx_q_inp = 0;
1292 8837 : move16();
1293 8837 : set16_fx( st->inp_12k8_mem_stereo_sw_fx, 0, sub( sub( STEREO_DFT_OVL_12k8, L_MEM_RECALC_12K8 ), L_FILT ) );
1294 8837 : st->mem_preemph16k_DFT_fx = 0;
1295 8837 : move16();
1296 8837 : set16_fx( st->inp_16k_mem_stereo_sw_fx, 0, sub( sub( STEREO_DFT_OVL_16k, L_MEM_RECALC_16K ), L_FILT16k ) );
1297 :
1298 8837 : st->sharpFlag = 0;
1299 8837 : move16();
1300 :
1301 : /* Stationary noise UV modification */
1302 8837 : st->ge_sm_fx = L_deposit_l( 640 ); /*Q(GE_SHIFT)*/
1303 8837 : move16();
1304 8837 : st->uv_count = 0;
1305 8837 : move16();
1306 8837 : st->act_count = 3;
1307 8837 : move16();
1308 8837 : Copy( st->lsp_old_fx, st->lspold_s_fx, M );
1309 8837 : st->noimix_seed = RANDOM_INITSEED;
1310 8837 : move16();
1311 8837 : st->min_alpha_fx = 32767;
1312 8837 : move16();
1313 8837 : st->exc_pe_fx = 0;
1314 8837 : move16();
1315 8837 : st->Q_stat_noise = 15;
1316 8837 : move16();
1317 : /* FEC */
1318 8837 : st->last_clas = UNVOICED_CLAS;
1319 8837 : move16();
1320 8837 : st->prev_fmerit = 0;
1321 8837 : move16();
1322 8837 : st->fmerit_dt = 0;
1323 8837 : move16();
1324 8837 : st->Last_pulse_pos = 0;
1325 8837 : move16();
1326 :
1327 97207 : FOR( i = 0; i < shl( NB_SUBFR16k, 1 ); i++ )
1328 : {
1329 88370 : st->old_pitch_buf_fx[i] = L_SUBFR_Q6;
1330 88370 : move16();
1331 : }
1332 :
1333 : /* mode1 core switching */
1334 8837 : st->old_Es_pred_fx = 0;
1335 8837 : move16();
1336 8837 : set16_fx( st->old_Aq_12_8_fx + 1, 0, M );
1337 8837 : st->old_Aq_12_8_fx[0] = ONE_IN_Q12;
1338 8837 : move16();
1339 :
1340 : /* stable short pitch detection */
1341 8837 : st->voicing0_sm_fx = 0;
1342 8837 : move16();
1343 8837 : st->voicing_sm_fx = 0;
1344 8837 : move16();
1345 8837 : st->LF_EnergyRatio_sm_fx = 1;
1346 8837 : move16();
1347 8837 : st->predecision_flag = 0;
1348 8837 : move16();
1349 8837 : st->diff_sm_fx = 0;
1350 8837 : move32();
1351 8837 : st->energy_sm_fx = 0;
1352 8837 : move32();
1353 :
1354 8837 : set16_fx( st->pitch, L_SUBFR, 3 );
1355 8837 : set16_fx( st->voicing_fx, 0, 3 );
1356 :
1357 : /*-----------------------------------------------------------------*
1358 : * General signal buffers
1359 : *-----------------------------------------------------------------*/
1360 :
1361 8837 : IF( !vad_only_flag )
1362 : {
1363 8768 : IF( ( st->hSignalBuf = (SIGNAL_BUFFERS_ENC_HANDLE) malloc( sizeof( SIGNAL_BUFFERS_ENC_DATA ) ) ) == NULL )
1364 : {
1365 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Signal buffers\n" ) );
1366 : }
1367 :
1368 8768 : st->Bin_E_old_fx = st->hSignalBuf->Bin_E_old_fx;
1369 8768 : st->mem_decim_fx = st->hSignalBuf->mem_decim_fx;
1370 8768 : st->mem_decim16k_fx = st->hSignalBuf->mem_decim16k_fx;
1371 8768 : st->old_inp_12k8_fx = st->hSignalBuf->old_inp_12k8_fx;
1372 8768 : st->old_inp_16k_fx = st->hSignalBuf->old_inp_16k_fx;
1373 8768 : st->buf_speech_enc_pe = st->hSignalBuf->buf_speech_enc_pe;
1374 8768 : st->buf_synth = st->hSignalBuf->buf_synth;
1375 8768 : st->buf_speech_enc = st->hSignalBuf->buf_speech_enc;
1376 8768 : st->buf_wspeech_enc = st->hSignalBuf->buf_wspeech_enc;
1377 :
1378 8768 : set32_fx( st->Bin_E_old_fx, 0, L_FFT / 2 );
1379 8768 : st->q_Bin_E_old = Q31;
1380 8768 : move16();
1381 8768 : set16_fx( st->hSignalBuf->buf_speech_enc, 0, L_PAST_MAX_32k + L_FRAME32k + L_NEXT_MAX_32k );
1382 8768 : st->exp_buf_speech_enc = 0;
1383 8768 : move16();
1384 8768 : set16_fx( st->hSignalBuf->buf_wspeech_enc, 0, L_FRAME16k + L_SUBFR + L_FRAME16k + L_NEXT_MAX_16k + 320 );
1385 8768 : st->exp_buf_wspeech_enc = 0;
1386 8768 : move16();
1387 : /* initializations */
1388 8768 : set32_fx( st->Bin_E_old_fx, 0, L_FFT / 2 );
1389 8768 : st->q_Bin_E_old = Q31;
1390 8768 : move16();
1391 8768 : set16_fx( st->mem_decim_fx, 0, shl( L_FILT_MAX, 1 ) );
1392 8768 : set16_fx( st->mem_decim_fx_q_inp, 0, shl( L_FILT_MAX, 1 ) );
1393 8768 : set16_fx( st->mem_decim16k_fx, 0, shl( L_FILT_MAX, 1 ) );
1394 8768 : set16_fx( st->old_inp_12k8_fx, 0, L_INP_MEM );
1395 8768 : set16_fx( st->old_inp_16k_fx, 0, L_INP_MEM );
1396 8768 : st->exp_old_inp_16k = 0;
1397 8768 : st->exp_old_inp_12k8 = 0;
1398 8768 : move16();
1399 8768 : move16();
1400 :
1401 8768 : st->input_buff_fx = st->hSignalBuf->input_buff;
1402 8768 : st->input_buff32_fx = st->hSignalBuf->input_buff32;
1403 8768 : set16_fx( st->input_buff_fx, 0, add( L_FRAME48k, add( L_FRAME48k, NS2SA( 48000, DELAY_FIR_RESAMPL_NS ) ) ) );
1404 8768 : st->q_inp = Q15;
1405 8768 : move16();
1406 8768 : st->mem_preemph_q = Q15;
1407 8768 : move16();
1408 8768 : st->mem_q = Q15;
1409 8768 : move16();
1410 8768 : st->q_old_inp = Q15;
1411 8768 : move16();
1412 8768 : set32_fx( st->input_buff32_fx, 0, add( L_FRAME48k, add( L_FRAME48k, NS2SA( 48000, DELAY_FIR_RESAMPL_NS ) ) ) );
1413 8768 : st->q_inp32 = Q31;
1414 8768 : move16();
1415 8768 : st->q_old_inp32 = Q31;
1416 8768 : move16();
1417 8768 : st->old_input_signal_fx = st->input_buff_fx;
1418 8768 : st->old_input_signal32_fx = st->input_buff32_fx;
1419 : /* st->input_Fs / FRAMES_PER_SEC */
1420 8768 : Word16 frame_length = extract_l( Mpy_32_32( st->input_Fs, ONE_BY_FRAMES_PER_SEC_Q31 ) );
1421 :
1422 8768 : IF( st->element_mode == EVS_MONO )
1423 : {
1424 0 : st->input32_fx = st->input_buff32_fx + st->input_Fs / FRAMES_PER_SEC + NS2SA_FX2( st->input_Fs, DELAY_FIR_RESAMPL_NS );
1425 0 : st->input_fx = st->input_buff_fx + add( frame_length, (Word16) NS2SA( st->input_Fs, DELAY_FIR_RESAMPL_NS ) );
1426 : }
1427 : ELSE
1428 : {
1429 : // st->input32_fx = st->input_buff32_fx + Mpy_32_32( st->input_Fs, 42949673 ) /* 1/50 in Q31*/; // st->input_Fs / FRAMES_PER_SEC
1430 8768 : st->input32_fx = st->input_buff32_fx + frame_length;
1431 8768 : st->input_fx = st->input_buff_fx + frame_length;
1432 : }
1433 : }
1434 : ELSE
1435 : {
1436 69 : st->hSignalBuf = NULL;
1437 69 : st->Bin_E_old_fx = NULL;
1438 69 : st->mem_decim_fx = NULL;
1439 69 : st->mem_decim16k_fx = NULL;
1440 69 : st->old_inp_12k8_fx = NULL;
1441 69 : st->old_inp_16k_fx = NULL;
1442 69 : st->buf_speech_enc_pe = NULL;
1443 69 : st->buf_synth = NULL;
1444 69 : st->buf_speech_enc = NULL;
1445 69 : st->buf_wspeech_enc = NULL;
1446 69 : st->input_buff_fx = NULL;
1447 : }
1448 :
1449 : /*-----------------------------------------------------------------*
1450 : * Noise estimator
1451 : *-----------------------------------------------------------------*/
1452 :
1453 8837 : test();
1454 8837 : test();
1455 8837 : test();
1456 8837 : IF( idchan == 0 || EQ_16( st->element_mode, IVAS_CPE_TD ) || EQ_16( st->element_mode, IVAS_CPE_MDCT ) || st->element_mode == EVS_MONO )
1457 : {
1458 8738 : IF( ( st->hNoiseEst = (NOISE_EST_HANDLE) malloc( sizeof( NOISE_EST_DATA ) ) ) == NULL )
1459 : {
1460 0 : return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Noise estimation\n" );
1461 : }
1462 :
1463 8738 : noise_est_init_ivas_fx( st->hNoiseEst );
1464 : }
1465 : ELSE
1466 : {
1467 99 : st->hNoiseEst = NULL;
1468 : }
1469 :
1470 : /*-----------------------------------------------------------------*
1471 : * VAD
1472 : *-----------------------------------------------------------------*/
1473 :
1474 8837 : st->vad_flag = 1;
1475 8837 : move16();
1476 8837 : st->localVAD = 0;
1477 8837 : move16();
1478 :
1479 8837 : IF( ( idchan == 0 || EQ_16( st->element_mode, IVAS_CPE_TD ) || EQ_16( st->element_mode, IVAS_CPE_MDCT ) || st->element_mode == EVS_MONO ) && ( !vad_only_flag ) )
1480 : {
1481 8669 : IF( ( st->hVAD = (VAD_HANDLE) malloc( sizeof( VAD_DATA ) ) ) == NULL )
1482 : {
1483 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for VAD\n" ) );
1484 : }
1485 :
1486 8669 : wb_vad_init_fx( st->hVAD );
1487 : }
1488 : ELSE
1489 : {
1490 168 : st->hVAD = NULL;
1491 : }
1492 8837 : st->Pos_relE_cnt = 20;
1493 8837 : move16();
1494 :
1495 : /* CLDFB-based VAD */
1496 8837 : IF( st->element_mode == EVS_MONO )
1497 : {
1498 0 : if ( ( st->hVAD_CLDFB = (VAD_CLDFB_HANDLE) malloc( sizeof( T_CldfbVadState ) ) ) == NULL )
1499 : {
1500 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for CLDFB VAD\n" ) );
1501 : }
1502 :
1503 0 : vad_init_fx( st->hVAD_CLDFB );
1504 : }
1505 : ELSE
1506 : {
1507 8837 : st->hVAD_CLDFB = NULL;
1508 : }
1509 :
1510 : /*-----------------------------------------------------------------*
1511 : * Speech/music classifier
1512 : *-----------------------------------------------------------------*/
1513 :
1514 8837 : IF( idchan == 0 || EQ_16( st->element_mode, IVAS_CPE_TD ) || EQ_16( st->element_mode, IVAS_CPE_MDCT ) || st->element_mode == EVS_MONO )
1515 : {
1516 8738 : IF( ( st->hSpMusClas = (SP_MUS_CLAS_HANDLE) malloc( sizeof( SP_MUS_CLAS_DATA ) ) ) == NULL )
1517 : {
1518 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Speech/music classifier\n" ) );
1519 : }
1520 :
1521 8738 : speech_music_clas_init_ivas_fx( st->hSpMusClas );
1522 8738 : st->sp_aud_decision0 = 0;
1523 8738 : move16();
1524 8738 : st->sp_aud_decision1 = 0;
1525 8738 : move16();
1526 8738 : st->sp_aud_decision2 = 0;
1527 8738 : move16();
1528 : }
1529 : ELSE
1530 : {
1531 99 : st->hSpMusClas = NULL;
1532 : }
1533 :
1534 :
1535 : /*-----------------------------------------------------------------*
1536 : * WB, SWB and FB bandwidth detector
1537 : *-----------------------------------------------------------------*/
1538 :
1539 8837 : st->lt_mean_NB_fx = 0;
1540 8837 : move16();
1541 8837 : st->lt_mean_WB_fx = 0;
1542 8837 : move16();
1543 8837 : st->lt_mean_SWB_fx = 0;
1544 8837 : move16();
1545 8837 : st->count_WB = BWD_COUNT_MAX;
1546 8837 : move16();
1547 8837 : st->count_SWB = BWD_COUNT_MAX;
1548 8837 : move16();
1549 8837 : st->count_FB = BWD_COUNT_MAX;
1550 8837 : move16();
1551 8837 : st->bwidth = st->max_bwidth;
1552 8837 : move16();
1553 8837 : st->last_input_bwidth = st->bwidth;
1554 8837 : move16();
1555 8837 : st->last_bwidth = st->bwidth;
1556 8837 : move16();
1557 8837 : st->last_bwidth_cng = st->bwidth;
1558 8837 : move16();
1559 8837 : st->bwidth_sw_cnt = 0;
1560 8837 : move16();
1561 :
1562 :
1563 : /*-----------------------------------------------------------------*
1564 : * DTX
1565 : *-----------------------------------------------------------------*/
1566 :
1567 8837 : st->lp_speech_32fx = 754974720; /*Q24 (45.0) */ /* Initialize the long-term active speech level in dB */
1568 8837 : move32();
1569 8837 : st->lp_noise_32fx = 0;
1570 8837 : move16();
1571 8837 : st->flag_noisy_speech_snr = 0;
1572 8837 : move16();
1573 8837 : st->fd_cng_reset_flag = 0;
1574 8837 : move16();
1575 8837 : st->cng_type = -1;
1576 8837 : move16();
1577 8837 : st->bckr_tilt_lt = 0;
1578 8837 : move16();
1579 8837 : st->active_cnt = 0;
1580 8837 : move16();
1581 :
1582 8837 : test();
1583 8837 : test();
1584 8837 : test();
1585 8837 : test();
1586 8837 : IF( ( ( idchan == 0 && st->Opt_DTX_ON ) || st->element_mode == EVS_MONO ) || ( EQ_16( st->element_mode, IVAS_CPE_MDCT ) && st->Opt_DTX_ON ) )
1587 : {
1588 485 : IF( ( st->hDtxEnc = (DTX_ENC_HANDLE) malloc( sizeof( DTX_ENC_DATA ) ) ) == NULL )
1589 : {
1590 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for DTX variables\n" ) );
1591 : }
1592 485 : dtx_enc_init_fx( st, var_SID_rate_flag, interval_SID );
1593 : }
1594 : ELSE
1595 : {
1596 8352 : st->hDtxEnc = NULL;
1597 : }
1598 :
1599 : /*-----------------------------------------------------------------*
1600 : * No other handles needed to be allocated for front-VAD structure
1601 : *-----------------------------------------------------------------*/
1602 :
1603 8837 : IF( vad_only_flag )
1604 : {
1605 69 : st->hTdCngEnc = NULL;
1606 69 : st->cldfbAnaEnc = NULL;
1607 69 : st->hFdCngEnc = NULL;
1608 69 : st->hSC_VBR = NULL;
1609 69 : st->hAmrwb_IO = NULL;
1610 69 : st->hLPDmem = NULL;
1611 69 : st->hGSCEnc = NULL;
1612 69 : st->hBWE_TD = NULL;
1613 69 : st->cldfbSynTd = NULL;
1614 69 : st->hBWE_FD = NULL;
1615 69 : st->hHQ_core = NULL;
1616 69 : st->hRF = NULL;
1617 69 : st->hTECEnc = NULL;
1618 69 : st->hTcxEnc = NULL;
1619 69 : st->hTcxCfg = NULL;
1620 69 : st->hIGFEnc = NULL;
1621 69 : st->hPlcExt = NULL;
1622 69 : st->hTranDet = NULL;
1623 :
1624 69 : st->element_mode = IVAS_SCE;
1625 69 : move16();
1626 69 : st->idchan = 100; /* indicates hCoreCoderVAD */
1627 69 : move16();
1628 69 : st->core = -1;
1629 69 : move16();
1630 69 : st->rf_mode = 0;
1631 69 : move16();
1632 :
1633 69 : return error;
1634 : }
1635 :
1636 : /*-----------------------------------------------------------------*
1637 : * LP-CNG
1638 : *-----------------------------------------------------------------*/
1639 :
1640 8768 : test();
1641 8768 : test();
1642 8768 : test();
1643 8768 : test();
1644 8768 : test();
1645 8768 : IF( ( ( idchan == 0 && st->Opt_DTX_ON && NE_16( st->element_mode, IVAS_CPE_MDCT ) ) || st->element_mode == EVS_MONO ) && !( EQ_16( ism_mode, ISM_MODE_PARAM ) || EQ_16( ism_mode, ISM_MODE_DISC ) ) )
1646 : {
1647 88 : IF( ( st->hTdCngEnc = (TD_CNG_ENC_HANDLE) malloc( sizeof( TD_CNG_ENC_DATA ) ) ) == NULL )
1648 : {
1649 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for DTX/TD CNG\n" ) );
1650 : }
1651 :
1652 88 : td_cng_enc_init_ivas_fx( st->hTdCngEnc, st->Opt_DTX_ON, st->max_bwidth );
1653 : }
1654 : ELSE
1655 : {
1656 8680 : st->hTdCngEnc = NULL;
1657 : }
1658 :
1659 : /*-----------------------------------------------------------------*
1660 : * CLDFB & resampling tools parameters
1661 : *-----------------------------------------------------------------*/
1662 8768 : test();
1663 8768 : test();
1664 8768 : test();
1665 8768 : IF( ( NE_16( st->element_mode, IVAS_CPE_MDCT ) && idchan == 0 ) || ( EQ_16( st->element_mode, IVAS_CPE_MDCT ) && st->Opt_DTX_ON ) )
1666 : {
1667 3217 : IF( EQ_16( st->element_mode, EVS_MONO ) )
1668 : {
1669 : /* open analysis for input SR */
1670 0 : st->input_frame_fx = extract_l( Mult_32_16( st->input_Fs, INV_FRAME_PER_SEC_Q15 ) );
1671 :
1672 0 : if ( ( error = openCldfb( &st->cldfbAnaEnc, CLDFB_ANALYSIS, CLDFB_getNumChannels( st->input_Fs ), st->input_frame_fx ) ) != IVAS_ERR_OK )
1673 : {
1674 0 : return error;
1675 : }
1676 : }
1677 : ELSE
1678 : {
1679 :
1680 3217 : IF( ( error = openCldfb_ivas_fx( &st->cldfbAnaEnc, CLDFB_ANALYSIS, st->input_Fs, CLDFB_PROTOTYPE_1_25MS, ENC ) ) != IVAS_ERR_OK )
1681 : {
1682 0 : return error;
1683 : }
1684 : }
1685 : }
1686 : ELSE
1687 : {
1688 5551 : st->cldfbAnaEnc = NULL;
1689 : }
1690 :
1691 8768 : st->energyCoreLookahead_Fx = 2; /* 6.1e-5f in Q15 */
1692 8768 : move32();
1693 8768 : st->sf_energyCoreLookahead_Fx = 2; /* 6.1e-5f in Q15 */
1694 8768 : move16();
1695 :
1696 : /*-----------------------------------------------------------------*
1697 : * SC-VBR parameters
1698 : *-----------------------------------------------------------------*/
1699 :
1700 8768 : test();
1701 8768 : IF( st->Opt_SC_VBR || st->element_mode == EVS_MONO )
1702 : {
1703 0 : IF( ( st->hSC_VBR = (SC_VBR_ENC_HANDLE) malloc( sizeof( SC_VBR_ENC_DATA ) ) ) == NULL )
1704 : {
1705 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for SC-VBR\n" ) );
1706 : }
1707 :
1708 0 : sc_vbr_enc_init_fx( st->hSC_VBR );
1709 : }
1710 : ELSE
1711 : {
1712 8768 : st->hSC_VBR = NULL;
1713 : }
1714 :
1715 8768 : st->last_Opt_SC_VBR = 0;
1716 8768 : move16();
1717 :
1718 :
1719 : /*-----------------------------------------------------------------*
1720 : * AMR-WB IO initialization
1721 : *-----------------------------------------------------------------*/
1722 :
1723 8768 : test();
1724 8768 : IF( st->Opt_AMR_WB || st->element_mode == EVS_MONO )
1725 : {
1726 0 : IF( ( st->hAmrwb_IO = (AMRWB_IO_ENC_HANDLE) malloc( sizeof( AMRWB_IO_ENC_DATA ) ) ) == NULL )
1727 : {
1728 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for AMR-WB IO\n" ) );
1729 : }
1730 :
1731 0 : amr_wb_enc_init_fx( st->hAmrwb_IO );
1732 : }
1733 : ELSE
1734 : {
1735 8768 : st->hAmrwb_IO = NULL;
1736 : }
1737 :
1738 : /*-----------------------------------------------------------------*
1739 : * ACELP LPDmem
1740 : *-----------------------------------------------------------------*/
1741 :
1742 8768 : test();
1743 8768 : test();
1744 8768 : IF( ( idchan == 0 && NE_16( st->element_mode, IVAS_CPE_MDCT ) ) || EQ_16( st->element_mode, IVAS_CPE_TD ) )
1745 : {
1746 3103 : IF( ( st->hLPDmem = (LPD_state_HANDLE) malloc( sizeof( LPD_state ) ) ) == NULL )
1747 : {
1748 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for LPDmem\n" ) );
1749 : }
1750 :
1751 3103 : LPDmem_enc_init_ivas_fx( st->hLPDmem );
1752 : }
1753 : ELSE
1754 : {
1755 5665 : st->hLPDmem = NULL;
1756 : }
1757 :
1758 : /*-----------------------------------------------------------------*
1759 : * parameters for AC coder type (GSC)
1760 : *-----------------------------------------------------------------*/
1761 :
1762 8768 : st->GSC_noisy_speech = 0;
1763 8768 : move16();
1764 8768 : st->GSC_IVAS_mode = 0;
1765 8768 : move16();
1766 :
1767 8768 : test();
1768 8768 : test();
1769 8768 : IF( ( idchan == 0 && NE_16( st->element_mode, IVAS_CPE_MDCT ) ) || EQ_16( st->element_mode, IVAS_CPE_TD ) )
1770 : {
1771 3103 : IF( ( st->hGSCEnc = (GSC_ENC_HANDLE) malloc( sizeof( GSC_ENC_DATA ) ) ) == NULL )
1772 : {
1773 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for GSC\n" ) );
1774 : }
1775 :
1776 3103 : GSC_enc_init_fx( st->hGSCEnc );
1777 : }
1778 : ELSE
1779 : {
1780 5665 : st->hGSCEnc = NULL;
1781 : }
1782 :
1783 : /*-----------------------------------------------------------------*
1784 : * TBE parameters
1785 : *-----------------------------------------------------------------*/
1786 :
1787 8768 : test();
1788 8768 : IF( idchan == 0 && NE_16( st->element_mode, IVAS_CPE_MDCT ) )
1789 : {
1790 3103 : IF( ( st->hBWE_TD = (TD_BWE_ENC_HANDLE) malloc( sizeof( TD_BWE_ENC_DATA ) ) ) == NULL )
1791 : {
1792 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for TD BWE\n" ) );
1793 : }
1794 :
1795 3103 : IF( st->element_mode == EVS_MONO )
1796 : {
1797 0 : if ( ( error = openCldfb( &st->cldfbSynTd, CLDFB_SYNTHESIS, CLDFB_getNumChannels( 16000 ), L_FRAME16k ) ) != IVAS_ERR_OK )
1798 : {
1799 0 : return error;
1800 : }
1801 : }
1802 : ELSE
1803 : {
1804 3103 : IF( ( error = openCldfb_ivas_fx( &st->cldfbSynTd, CLDFB_SYNTHESIS, 16000, CLDFB_PROTOTYPE_1_25MS, ENC ) ) != IVAS_ERR_OK )
1805 : {
1806 0 : return error;
1807 : }
1808 : }
1809 3103 : InitSWBencBuffer_ivas_fx( st );
1810 3103 : ResetSHBbuffer_Enc_fx( st );
1811 : }
1812 : ELSE
1813 : {
1814 5665 : st->hBWE_TD = NULL;
1815 5665 : st->cldfbSynTd = NULL;
1816 : }
1817 :
1818 : /*-----------------------------------------------------------------*
1819 : * SWB BWE parameters
1820 : *-----------------------------------------------------------------*/
1821 :
1822 8768 : test();
1823 8768 : IF( idchan == 0 && NE_16( st->element_mode, IVAS_CPE_MDCT ) )
1824 : {
1825 3103 : IF( ( st->hBWE_FD = (FD_BWE_ENC_HANDLE) malloc( sizeof( FD_BWE_ENC_DATA ) ) ) == NULL )
1826 : {
1827 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for FD BWE\n" ) );
1828 : }
1829 :
1830 3103 : fd_bwe_enc_init_fx( st->hBWE_FD );
1831 3103 : st->Q_old_wtda = 0;
1832 3103 : move16();
1833 : }
1834 : ELSE
1835 : {
1836 5665 : st->hBWE_FD = NULL;
1837 : }
1838 :
1839 : /*-----------------------------------------------------------------*
1840 : * HQ core parameters
1841 : *-----------------------------------------------------------------*/
1842 :
1843 8768 : IF( NE_16( st->element_mode, IVAS_CPE_TD ) && NE_16( st->element_mode, IVAS_CPE_MDCT ) && idchan == 0 )
1844 : {
1845 3103 : IF( ( st->hHQ_core = (HQ_ENC_HANDLE) malloc( sizeof( HQ_ENC_DATA ) ) ) == NULL )
1846 : {
1847 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for HQ core\n" ) );
1848 : }
1849 :
1850 3103 : HQ_core_enc_init_fx( st->hHQ_core );
1851 : }
1852 : ELSE
1853 : {
1854 5665 : st->hHQ_core = NULL;
1855 : }
1856 :
1857 : /* init memory for detect_transient(), used by HQ core and swb_bwe_enc */
1858 8768 : st->old_hpfilt_in_fx = 0;
1859 8768 : move16();
1860 8768 : st->old_hpfilt_out_fx = 0;
1861 8768 : move16();
1862 8768 : st->EnergyLT_fx = 0;
1863 8768 : move32();
1864 8768 : st->Energy_Old_fx = 0;
1865 8768 : move32();
1866 8768 : st->TransientHangOver = 0;
1867 8768 : move16();
1868 8768 : st->EnergyLT_fx_exp = 30;
1869 8768 : move16();
1870 8768 : st->last_enerBuffer_exp = 0;
1871 8768 : move16();
1872 :
1873 : /*-----------------------------------------------------------------*
1874 : * Channel-aware mode
1875 : *-----------------------------------------------------------------*/
1876 :
1877 8768 : test();
1878 8768 : test();
1879 8768 : test();
1880 8768 : IF( !st->Opt_RF_ON || ( NE_16( st->bwidth, WB ) && NE_16( st->bwidth, SWB ) ) || NE_32( st->total_brate, ACELP_13k20 ) )
1881 : {
1882 8768 : st->rf_mode = 0;
1883 8768 : move16();
1884 : }
1885 : ELSE
1886 : {
1887 0 : st->rf_mode = st->Opt_RF_ON;
1888 0 : move16();
1889 : }
1890 :
1891 8768 : st->rf_mode_last = st->rf_mode;
1892 8768 : move16();
1893 :
1894 8768 : test();
1895 8768 : IF( st->Opt_RF_ON || st->element_mode == EVS_MONO )
1896 : {
1897 0 : IF( ( st->hRF = (RF_ENC_HANDLE) malloc( sizeof( RF_ENC_DATA ) ) ) == NULL )
1898 : {
1899 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for RF\n" ) );
1900 : }
1901 :
1902 : /* initialize RF indice buffers */
1903 0 : reset_rf_indices_fx( st );
1904 : }
1905 : ELSE
1906 : {
1907 8768 : st->hRF = NULL;
1908 : }
1909 :
1910 : /*-----------------------------------------------------------------*
1911 : * Temporal Envelope Coding
1912 : *-----------------------------------------------------------------*/
1913 :
1914 8768 : IF( st->element_mode == EVS_MONO )
1915 : {
1916 0 : IF( ( st->hTECEnc = (TEC_ENC_HANDLE) malloc( sizeof( TEC_ENC_DATA ) ) ) == NULL )
1917 : {
1918 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for TEC\n" ) );
1919 : }
1920 : }
1921 : ELSE
1922 : {
1923 8768 : st->hTECEnc = NULL;
1924 : }
1925 : /* note: initialization done later in init_coder_ace_plus() */
1926 :
1927 : /*-----------------------------------------------------------------*
1928 : * TCX core
1929 : *-----------------------------------------------------------------*/
1930 :
1931 : // ToDo: reduction possible for MCT_CHAN_MODE_LFE channel
1932 8768 : test();
1933 8768 : IF( idchan == 0 || EQ_16( st->element_mode, IVAS_CPE_MDCT ) )
1934 : {
1935 8669 : IF( ( st->hTcxEnc = (TCX_ENC_HANDLE) malloc( sizeof( TCX_ENC_DATA ) ) ) == NULL )
1936 : {
1937 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for hTcxEnc\n" ) );
1938 : }
1939 8669 : set32_fx( st->hTcxEnc->spectrum_long_fx, 0, N_MAX );
1940 8669 : st->hTcxEnc->spectrum_long_e = 0;
1941 8669 : move16();
1942 : /* Share the memories for 2xTCX10/4xTCX5 and for TCX20 */
1943 8669 : st->hTcxEnc->spectrum_fx[0] = st->hTcxEnc->spectrum_long_fx;
1944 8669 : st->hTcxEnc->spectrum_fx[1] = st->hTcxEnc->spectrum_long_fx + N_TCX10_MAX;
1945 8669 : move32();
1946 8669 : move32();
1947 8669 : st->hTcxEnc->spectrum_e[0] = st->hTcxEnc->spectrum_e[1] = 0;
1948 8669 : move16();
1949 8669 : move16();
1950 :
1951 8669 : set16_fx( st->hTcxEnc->old_out_fx, 0, L_FRAME32k );
1952 8669 : st->hTcxEnc->Q_old_out = 0;
1953 8669 : move16();
1954 :
1955 : /* MDCT selector */
1956 8669 : MDCT_selector_reset_fx( st->hTcxEnc );
1957 :
1958 : /* MDCT classifier */
1959 8669 : MDCT_classifier_reset_fx( st->hTcxEnc );
1960 :
1961 8669 : IF( ( st->hTcxCfg = (TCX_CONFIG_HANDLE) malloc( sizeof( TCX_config ) ) ) == NULL )
1962 : {
1963 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for hTcxCfg\n" ) );
1964 : }
1965 : }
1966 : ELSE
1967 : {
1968 99 : st->hTcxEnc = NULL;
1969 99 : st->hTcxCfg = NULL;
1970 : }
1971 :
1972 : /*-----------------------------------------------------------------*
1973 : * IGF
1974 : *-----------------------------------------------------------------*/
1975 :
1976 8768 : igf_brate = st->total_brate;
1977 8768 : move32();
1978 :
1979 8768 : test();
1980 8768 : test();
1981 8768 : test();
1982 8768 : test();
1983 8768 : test();
1984 8768 : test();
1985 8768 : test();
1986 8768 : IF( EQ_16( st->element_mode, IVAS_SCE ) && ( EQ_16( st_ivas->hEncoderConfig->ivas_format, ISM_FORMAT ) || EQ_16( st_ivas->hEncoderConfig->ivas_format, MASA_ISM_FORMAT ) ) )
1987 : {
1988 2160 : igf_brate = L_sub( st->total_brate, i_mult( ISM_NB_BITS_METADATA_NOMINAL, FRAMES_PER_SEC ) );
1989 : }
1990 6608 : ELSE IF( EQ_16( st->element_mode, IVAS_CPE_DFT ) || ( EQ_16( st->element_mode, IVAS_SCE ) && ( EQ_16( st_ivas->hEncoderConfig->ivas_format, SBA_FORMAT ) ||
1991 : EQ_16( st_ivas->hEncoderConfig->ivas_format, SBA_ISM_FORMAT ) ||
1992 : EQ_16( st_ivas->hEncoderConfig->ivas_format, MC_FORMAT ) ||
1993 : EQ_16( st_ivas->hEncoderConfig->ivas_format, MASA_FORMAT ) ) ) )
1994 : {
1995 : /* use nominal bitrates for DFT Stereo and (O)SBA, same as in stereo_dft_config()/ivas_spar_config() */
1996 1042 : IF( EQ_32( element_brate, IVAS_13k2 ) )
1997 : {
1998 266 : igf_brate = ACELP_9k60;
1999 : }
2000 776 : ELSE IF( EQ_32( element_brate, IVAS_16k4 ) )
2001 : {
2002 272 : igf_brate = ACELP_13k20;
2003 : }
2004 504 : ELSE IF( EQ_32( element_brate, IVAS_24k4 ) )
2005 : {
2006 197 : igf_brate = ACELP_16k40;
2007 : }
2008 307 : ELSE IF( EQ_32( element_brate, IVAS_32k ) )
2009 : {
2010 251 : igf_brate = ACELP_24k40;
2011 : }
2012 : }
2013 5566 : ELSE IF( EQ_16( st->element_mode, IVAS_CPE_MDCT ) )
2014 : {
2015 5566 : igf_brate = element_brate;
2016 : }
2017 8768 : move32();
2018 8768 : test();
2019 8768 : IF( EQ_16( st->codec_mode, MODE2 ) || GT_16( st->element_mode, EVS_MONO ) )
2020 : {
2021 8768 : st->igf = getIgfPresent_fx( st->element_mode, igf_brate, st->max_bwidth, st->rf_mode );
2022 : }
2023 : ELSE
2024 : {
2025 0 : st->igf = 0;
2026 : }
2027 8768 : move16();
2028 :
2029 8768 : test();
2030 8768 : test();
2031 8768 : test();
2032 8768 : IF( ( idchan == 0 || EQ_16( st->element_mode, IVAS_CPE_MDCT ) ) && ( st->igf || st->element_mode == EVS_MONO ) )
2033 : {
2034 6881 : IF( ( st->hIGFEnc = (IGF_ENC_INSTANCE_HANDLE) malloc( sizeof( IGF_ENC_INSTANCE ) ) ) == NULL )
2035 : {
2036 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for hIGFEnc\n" ) );
2037 : }
2038 : }
2039 : ELSE
2040 : {
2041 1887 : st->hIGFEnc = NULL;
2042 : }
2043 :
2044 : /*-----------------------------------------------------------------*
2045 : * Mode 2 initialization
2046 : *-----------------------------------------------------------------*/
2047 :
2048 8768 : st->last_sr_core = L_mult0( st->last_L_frame, FRAMES_PER_SEC );
2049 8768 : move32();
2050 :
2051 :
2052 : /* PLC encoder */
2053 8768 : IF( st->element_mode == EVS_MONO )
2054 : {
2055 0 : IF( ( st->hPlcExt = (PLC_ENC_EVS_HANDLE) malloc( sizeof( PLC_ENC_EVS ) ) ) == NULL )
2056 : {
2057 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for hPlcExt\n" ) );
2058 : }
2059 : }
2060 : ELSE
2061 : {
2062 8768 : st->hPlcExt = NULL;
2063 : }
2064 :
2065 : /* Init Mode 2 core coder */
2066 8768 : st->last_totalNoise_fx = 0;
2067 8768 : move16();
2068 8768 : set16_fx( st->totalNoise_increase_hist_fx, 0, TOTALNOISE_HIST_SIZE );
2069 8768 : st->totalNoise_increase_len = 0;
2070 8768 : move16();
2071 8768 : TCX_ENC_HANDLE hTcxEnc = st->hTcxEnc;
2072 8768 : IF( hTcxEnc != NULL )
2073 : {
2074 8669 : hTcxEnc->L_frameTCX = extract_l( Mult_32_16( st->input_Fs, INV_FRAME_PER_SEC_Q15 ) );
2075 8669 : move16();
2076 : }
2077 8768 : st->currEnergyHF_fx = 0;
2078 8768 : move32();
2079 8768 : st->currEnergyHF_e_fx = 0;
2080 8768 : move16();
2081 8768 : st->prevEnergyHF_fx = 0;
2082 8768 : move32();
2083 :
2084 : /* Initialize TCX */
2085 :
2086 : /* Initialize Signal Buffers */
2087 8768 : Word16 shift = getScaleFactor16( st->old_inp_16k_fx, L_INP_MEM );
2088 8768 : Scale_sig( st->old_inp_16k_fx, L_INP_MEM, shift );
2089 8768 : st->exp_old_inp_16k = sub( st->exp_old_inp_16k, shift );
2090 8768 : move16();
2091 8768 : shift = getScaleFactor16( st->old_inp_12k8_fx, L_INP_MEM );
2092 8768 : Scale_sig( st->old_inp_12k8_fx, L_INP_MEM, shift );
2093 8768 : st->exp_old_inp_12k8 = sub( st->exp_old_inp_12k8, shift );
2094 8768 : move16();
2095 : /* Initialize ACELP */
2096 8768 : init_coder_ace_plus_ivas_fx( st, st->last_total_brate, igf_brate, 0 );
2097 :
2098 8768 : IF( st->hLPDmem != NULL )
2099 : {
2100 3103 : st->hLPDmem->q_lpd_old_exc = st->prev_Q_new;
2101 3103 : move16();
2102 : }
2103 : /*-----------------------------------------------------------------*
2104 : * FD-CNG encoder
2105 : *-----------------------------------------------------------------*/
2106 :
2107 8768 : test();
2108 8768 : test();
2109 8768 : test();
2110 8768 : test();
2111 8768 : IF( ( idchan == 0 && st->Opt_DTX_ON ) || st->element_mode == EVS_MONO || ( EQ_16( st->element_mode, IVAS_CPE_MDCT ) && st->Opt_DTX_ON ) )
2112 : {
2113 416 : createFdCngEnc_fx( &st->hFdCngEnc );
2114 416 : initFdCngEnc_fx( st->hFdCngEnc, st->input_Fs, st->cldfbAnaEnc->scale );
2115 : /* initialization for IVAS modes happens in first frame pre-processing */
2116 416 : IF( st->element_mode == EVS_MONO )
2117 : {
2118 : Word32 total_brate;
2119 :
2120 0 : test();
2121 0 : IF( st->rf_mode && EQ_32( st->total_brate, ACELP_13k20 ) )
2122 : {
2123 0 : total_brate = ACELP_9k60;
2124 0 : move32();
2125 : }
2126 : ELSE
2127 : {
2128 0 : total_brate = st->total_brate;
2129 0 : move32();
2130 : }
2131 :
2132 0 : configureFdCngEnc_ivas_fx( st->hFdCngEnc, st->bwidth, total_brate );
2133 : }
2134 : }
2135 : ELSE
2136 : {
2137 8352 : st->hFdCngEnc = NULL;
2138 : }
2139 :
2140 : /*-----------------------------------------------------------------*
2141 : * Transient detector
2142 : *-----------------------------------------------------------------*/
2143 :
2144 8768 : IF( ( st->hTranDet = (TRAN_DET_HANDLE) malloc( sizeof( TRAN_DET_DATA ) ) ) == NULL )
2145 : {
2146 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Transient Detection\n" ) );
2147 : }
2148 :
2149 8768 : Word16 frame_length = extract_l( Mpy_32_32_r( st->input_Fs, ONE_BY_FRAMES_PER_SEC_Q31 ) );
2150 :
2151 8768 : IF( GT_16( st->element_mode, EVS_MONO ) )
2152 : {
2153 8768 : InitTransientDetection_ivas_fx( frame_length, 0, st->hTranDet, 1 );
2154 : }
2155 : ELSE
2156 : {
2157 0 : InitTransientDetection_fx( frame_length, NS2SA_FX2( st->input_Fs, DELAY_FIR_RESAMPL_NS ), st->hTranDet );
2158 : }
2159 :
2160 : /*-----------------------------------------------------------------*
2161 : * IVAS parameters
2162 : *-----------------------------------------------------------------*/
2163 :
2164 8768 : st->tdm_LRTD_flag = 0;
2165 8768 : move16();
2166 8768 : st->cng_sba_flag = 0;
2167 8768 : move16();
2168 8768 : st->bits_frame_channel = 0;
2169 8768 : move16();
2170 8768 : st->side_bits_frame_channel = 0;
2171 8768 : move16();
2172 8768 : st->Q_syn2 = 0;
2173 8768 : move16();
2174 8768 : st->Q_syn = 0;
2175 8768 : move16();
2176 8768 : set16_fx( st->Q_max, Q_MAX, L_Q_MEM );
2177 8768 : set16_fx( st->Q_max_16k, Q_MAX, L_Q_MEM );
2178 8768 : st->Q_old = 15;
2179 8768 : move16();
2180 8768 : st->old_wsp_max = 0;
2181 8768 : move16();
2182 8768 : st->old_wsp_shift = 0;
2183 8768 : move16();
2184 8768 : st->sharpFlag = 0;
2185 8768 : move16();
2186 :
2187 8768 : return error;
2188 : }
2189 :
2190 :
2191 : /*-----------------------------------------------------------------------*
2192 : * destroy_cldfb_encoder()
2193 : *
2194 : * Free memory which was allocated in init_encoder()
2195 : *-----------------------------------------------------------------------*/
2196 :
2197 8837 : void destroy_cldfb_encoder_fx(
2198 : Encoder_State *st /* i/o: Encoder static variables structure */
2199 : )
2200 : {
2201 8837 : deleteCldfb_ivas_fx( &st->cldfbSynTd );
2202 8837 : deleteCldfb_ivas_fx( &st->cldfbAnaEnc );
2203 :
2204 8837 : deleteFdCngEnc_fx( &st->hFdCngEnc );
2205 :
2206 8837 : return;
2207 : }
|
