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