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