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