1 /******************************************************************************
2 * *
3 * Copyright (C) 2023 The Android Open Source Project
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at:
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 *
17 *****************************************************************************
18 * Originally developed and contributed by Ittiam Systems Pvt. Ltd, Bangalore
19 */
20
21 #include <string.h>
22 #include <math.h>
23 #include "ixheaac_type_def.h"
24 #include "ixheaace_adjust_threshold_data.h"
25 #include "iusace_bitbuffer.h"
26
27 /* DRC */
28 #include "impd_drc_common_enc.h"
29 #include "impd_drc_uni_drc.h"
30 #include "impd_drc_tables.h"
31 #include "impd_drc_api.h"
32 #include "impd_drc_uni_drc_eq.h"
33 #include "impd_drc_uni_drc_filter_bank.h"
34 #include "impd_drc_gain_enc.h"
35 #include "impd_drc_struct_def.h"
36
37 #include "iusace_cnst.h"
38 #include "iusace_tns_usac.h"
39 #include "iusace_psy_mod.h"
40 #include "iusace_psy_utils.h"
41 #include "iusace_tns_usac.h"
42 #include "iusace_config.h"
43 #include "iusace_arith_enc.h"
44 #include "iusace_fd_qc_util.h"
45 #include "iusace_fd_quant.h"
46 #include "iusace_block_switch_const.h"
47 #include "iusace_block_switch_struct_def.h"
48 #include "iusace_ms.h"
49 #include "iusace_signal_classifier.h"
50 #include "ixheaace_sbr_header.h"
51 #include "ixheaace_config.h"
52 #include "ixheaace_asc_write.h"
53 #include "iusace_main.h"
54 #include "iusace_lpd_rom.h"
55 #include "iusace_lpd.h"
56 #include "iusace_func_prototypes.h"
57 #include "ixheaac_error_standards.h"
58
iusace_init_td_data(ia_usac_td_encoder_struct * st,WORD32 len_frame)59 VOID iusace_init_td_data(ia_usac_td_encoder_struct *st, WORD32 len_frame) {
60 WORD32 len_window;
61 WORD32 num_frames = NUM_FRAMES;
62 st->len_subfrm = len_frame / num_frames;
63
64 st->len_frame = len_frame;
65 st->num_subfrm = (MAX_NUM_SUBFR * len_frame) / LEN_SUPERFRAME;
66
67 iusace_reset_td_enc(st);
68 st->prev_mode = -1;
69 st->arith_reset_flag = 1;
70
71 if (st->fscale <= FSCALE_DENOM) {
72 len_window = (LEN_LP_WINDOW * len_frame) / LEN_SUPERFRAME;
73 } else {
74 len_window = (LEN_LP_WINDOW_HIGH_RATE * len_frame) / LEN_SUPERFRAME;
75 }
76
77 switch (len_window) {
78 case 512:
79 st->lp_analysis_window = iusace_cos_window_512;
80 break;
81 case 448:
82 st->lp_analysis_window = iusace_cos_window_448;
83 break;
84 case 384:
85 st->lp_analysis_window = iexheaac_cos_window_384;
86 break;
87 default:
88 st->lp_analysis_window = iusace_cos_window_512;
89 break;
90 }
91 return;
92 }
93
iusace_config_acelp_core_mode(ia_usac_td_encoder_struct * st,WORD32 sampling_rate,WORD32 bitrate)94 VOID iusace_config_acelp_core_mode(ia_usac_td_encoder_struct *st, WORD32 sampling_rate,
95 WORD32 bitrate) {
96 WORD32 max_bits, coder_bits;
97 const WORD32 *p_acelp_core_numbits_table;
98
99 p_acelp_core_numbits_table = (WORD32 *)iusace_acelp_core_numbits_1024;
100
101 max_bits = (WORD32)((FLOAT32)(bitrate * LEN_SUPERFRAME) / (FLOAT32)sampling_rate);
102
103 for (st->acelp_core_mode = 5; st->acelp_core_mode >= 0; st->acelp_core_mode--) {
104 coder_bits = p_acelp_core_numbits_table[st->acelp_core_mode];
105 if (coder_bits <= max_bits) {
106 return;
107 }
108 }
109 if (st->acelp_core_mode == -1) {
110 st->acelp_core_mode = 0;
111 }
112 return;
113 }
114
iusace_reset_td_enc(ia_usac_td_encoder_struct * st)115 VOID iusace_reset_td_enc(ia_usac_td_encoder_struct *st) {
116 WORD32 i;
117
118 memset(st->old_speech_pe, 0, (ORDER + LEN_NEXT_HIGH_RATE) * sizeof(FLOAT32));
119 memset(st->prev_exc, 0, (MAX_PITCH + LEN_INTERPOL) * sizeof(FLOAT32));
120 memset(st->prev_wsp, 0, (MAX_PITCH / OPL_DECIM) * sizeof(FLOAT32));
121 memset(st->mem_lp_decim2, 0, 3 * sizeof(FLOAT32));
122 memset(st->weighted_sig, 0, 128 * sizeof(FLOAT32));
123
124 st->lpd_state.mode = -1;
125 st->lpd_state.num_bits = 0;
126 memset(st->lpd_state.lpc_coeffs_quant, 0, (2 * (ORDER + 1)) * sizeof(FLOAT32));
127 memset(st->lpd_state.lpc_coeffs, 0, (2 * (ORDER + 1)) * sizeof(FLOAT32));
128 memset(st->lpd_state.synth, 0, (ORDER + 128) * sizeof(FLOAT32));
129 memset(st->lpd_state.wsynth, 0, (1 + 128) * sizeof(FLOAT32));
130
131 memset(st->lpd_state.acelp_exc, 0, (2 * LEN_FRAME) * sizeof(FLOAT32));
132
133 memset(st->lpd_state.tcx_mem, 0, 128 * sizeof(FLOAT32));
134 memset(st->lpd_state.tcx_quant, 0, (1 + 256) * sizeof(FLOAT32));
135 st->lpd_state.tcx_fac = 0.0f;
136
137 memset(st->prev_hp_wsp, 0,
138 (LEN_SUPERFRAME / OPL_DECIM + (MAX_PITCH / OPL_DECIM)) * sizeof(FLOAT32));
139
140 memset(st->hp_ol_ltp_mem, 0, (3 * 2 + 1) * sizeof(FLOAT32));
141 for (i = 0; i < 5; i++) st->prev_ol_lags[i] = 40;
142 st->prev_wsyn_mem = 0.0;
143 st->prev_wsp_mem = 0.0;
144 st->prev_xnq_mem = 0.0;
145 st->mem_wsp = 0.0;
146 st->prev_ovlp_size = 0;
147 st->prev_pitch_med = 40;
148 st->ol_wght_flg = 0;
149 st->ada_w = 0.0;
150
151 memcpy(st->isf_old, iusace_lsf_init, ORDER * sizeof(FLOAT32));
152 memcpy(st->isp_old, iusace_ispold_init, ORDER * sizeof(FLOAT32));
153 memcpy(st->isp_old_q, st->isp_old, ORDER * sizeof(FLOAT32));
154
155 st->mem_preemph = 0.0;
156 memset(st->mem_sig_in, 0, 4 * sizeof(FLOAT32));
157 memset(st->xn_buffer, 0, 128 * sizeof(FLOAT32));
158
159 return;
160 }
161
iusace_highpass_prev_wsp(ia_usac_td_encoder_struct * st,FLOAT32 * decim_sig,WORD32 pitch_max)162 VOID iusace_highpass_prev_wsp(ia_usac_td_encoder_struct *st, FLOAT32 *decim_sig,
163 WORD32 pitch_max) {
164 WORD32 i, k;
165 WORD32 wsp_offset = pitch_max / OPL_DECIM;
166 WORD32 num_frames = (2 * LEN_SUBFR) / OPL_DECIM;
167 FLOAT32 *hp_wsp_mem = st->hp_ol_ltp_mem;
168 FLOAT32 *prev_hp_wsp = st->prev_hp_wsp;
169 for (i = 0; i < 2 * st->len_subfrm / OPL_DECIM; i += num_frames) {
170 FLOAT32 *data_a, *data_b, *hp_wsp, o;
171 FLOAT32 *wsp = decim_sig + ORDER + i;
172 data_a = hp_wsp_mem;
173 data_b = hp_wsp_mem + HP_ORDER;
174 hp_wsp = prev_hp_wsp + wsp_offset;
175 for (k = 0; k < num_frames; k++) {
176 data_b[0] = data_b[1];
177 data_b[1] = data_b[2];
178 data_b[2] = data_b[3];
179 data_b[HP_ORDER] = wsp[k];
180 o = data_b[0] * 0.83787057505665F;
181 o += data_b[1] * -2.50975570071058F;
182 o += data_b[2] * 2.50975570071058F;
183 o += data_b[3] * -0.83787057505665F;
184 o -= data_a[0] * -2.64436711600664F;
185 o -= data_a[1] * 2.35087386625360F;
186 o -= data_a[2] * -0.70001156927424F;
187 data_a[2] = data_a[1];
188 data_a[1] = data_a[0];
189 data_a[0] = o;
190 hp_wsp[k] = o;
191 }
192 memmove(prev_hp_wsp, &prev_hp_wsp[num_frames], wsp_offset * sizeof(FLOAT32));
193 }
194 }
195
iusace_find_weighted_speech(FLOAT32 * filter_coef,FLOAT32 * speech,FLOAT32 * wsp,FLOAT32 * mem_wsp,WORD32 length)196 VOID iusace_find_weighted_speech(FLOAT32 *filter_coef, FLOAT32 *speech, FLOAT32 *wsp,
197 FLOAT32 *mem_wsp, WORD32 length) {
198 WORD32 i_subfr;
199 FLOAT32 weighted_lpc[ORDER + 1];
200 for (i_subfr = 0; i_subfr < length; i_subfr += LEN_SUBFR) {
201 iusace_get_weighted_lpc(filter_coef, weighted_lpc);
202 iusace_compute_lp_residual(weighted_lpc, &speech[i_subfr], &wsp[i_subfr], LEN_SUBFR);
203 filter_coef += (ORDER + 1);
204 }
205 iusace_apply_deemph(wsp, TILT_FAC, length, mem_wsp);
206 return;
207 }
208
iusace_get_interpolated_lpc(FLOAT32 * lsp_old,FLOAT32 * lsp_new,FLOAT32 * lpc,WORD32 num_subfrm)209 VOID iusace_get_interpolated_lpc(FLOAT32 *lsp_old, FLOAT32 *lsp_new, FLOAT32 *lpc,
210 WORD32 num_subfrm) {
211 FLOAT32 lsp[ORDER], *p_lpc, inc, fnew, fold;
212 WORD32 i, k;
213
214 inc = 1.0f / (FLOAT32)num_subfrm;
215 p_lpc = lpc;
216 fnew = 0.0f;
217
218 for (k = 0; k < num_subfrm; k++) {
219 fold = 1.0f - fnew;
220 for (i = 0; i < ORDER; i++) {
221 lsp[i] = (FLOAT32)(lsp_old[i] * fold + lsp_new[i] * fnew);
222 }
223 fnew += inc;
224 iusace_lsp_to_lp_conversion(lsp, p_lpc);
225 p_lpc += (ORDER + 1);
226 }
227
228 iusace_lsp_to_lp_conversion(lsp_new, p_lpc);
229 }
230
iusace_core_lpd_encode(ia_usac_data_struct * usac_data,FLOAT32 * speech,WORD32 * mode,WORD32 * num_tcx_param,WORD32 ch_idx)231 VOID iusace_core_lpd_encode(ia_usac_data_struct *usac_data, FLOAT32 *speech, WORD32 *mode,
232 WORD32 *num_tcx_param, WORD32 ch_idx) {
233 WORD32 first_lpd_flag = (usac_data->core_mode_prev[ch_idx] == CORE_MODE_FD);
234 iusace_scratch_mem *pstr_scratch = &usac_data->str_scratch;
235 WORD32 pit_adj = usac_data->td_encoder[ch_idx]->fscale;
236 WORD32 *num_fac_bits = &usac_data->num_td_fac_bits[ch_idx];
237 WORD16 *serial_fac_out = usac_data->fac_out_stream[ch_idx];
238 WORD32 *lpc_params = usac_data->param_buf + (NUM_FRAMES * MAX_NUM_TCX_PRM_PER_DIV);
239 ia_usac_td_encoder_struct *st = usac_data->td_encoder[ch_idx];
240 WORD32 *acelp_tcx_params = usac_data->param_buf;
241 WORD16 *codec_mode = &st->acelp_core_mode;
242 const FLOAT32 *lp_analysis_window = st->lp_analysis_window;
243 FLOAT32 *lp_filter_coeff = pstr_scratch->p_lp_filter_coeff;
244 FLOAT32 *lp_filter_coeff_q = pstr_scratch->p_lp_filter_coeff_q;
245
246 FLOAT32 *ptr_stack_mem = (FLOAT32 *)pstr_scratch->ptr_stack_mem;
247
248 FLOAT32 *auto_corr_vector = ptr_stack_mem;
249 ptr_stack_mem += (ORDER + 1);
250 memset(auto_corr_vector, 0, sizeof(*auto_corr_vector) * (ORDER + 1));
251
252 FLOAT32 *isp_new = ptr_stack_mem;
253 ptr_stack_mem += ORDER;
254 memset(isp_new, 0, sizeof(*isp_new) * (ORDER));
255
256 FLOAT32 *isp_curr = ptr_stack_mem;
257 ptr_stack_mem += ((NUM_FRAMES + 1) * ORDER);
258 memset(isp_curr, 0, sizeof(*isp_curr) * ((NUM_FRAMES + 1) * ORDER));
259
260 FLOAT32 *isp_curr_q = ptr_stack_mem;
261 ptr_stack_mem += ((NUM_FRAMES + 1) * ORDER);
262 memset(isp_curr_q, 0, sizeof(*isp_curr_q) * ((NUM_FRAMES + 1) * ORDER));
263
264 FLOAT32 *isf_curr = ptr_stack_mem;
265 ptr_stack_mem += ((NUM_FRAMES + 1) * ORDER);
266 memset(isf_curr, 0, sizeof(*isf_curr) * ((NUM_FRAMES + 1) * ORDER));
267
268 FLOAT32 *isf_curr_q = ptr_stack_mem;
269 ptr_stack_mem += ((NUM_FRAMES + 1) * ORDER);
270 memset(isf_curr_q, 0, sizeof(*isf_curr_q) * ((NUM_FRAMES + 1) * ORDER));
271
272 FLOAT32 *auto_corr_lp_filter_coeff = ptr_stack_mem;
273 ptr_stack_mem += (ORDER + 1);
274 memset(auto_corr_lp_filter_coeff, 0, sizeof(*auto_corr_lp_filter_coeff) * (ORDER + 1));
275
276 WORD32 num_indices = 0, num_bits = 0;
277 WORD32 *prm_tcx = pstr_scratch->p_prm_tcx;
278 FLOAT32 *p_wsp_prev_buf;
279 FLOAT32 *wsp_prev_buf = pstr_scratch->p_wsp_prev_buf;
280 memset(lp_filter_coeff, 0, ((NUM_SUBFR_SUPERFRAME + 1) * (ORDER + 1)) * sizeof(FLOAT32));
281 memset(lp_filter_coeff_q, 0, ((NUM_SUBFR_SUPERFRAME + 1) * (ORDER + 1)) * sizeof(FLOAT32));
282 memset(wsp_prev_buf, 0, ((MAX_PITCH1 / OPL_DECIM) + LEN_FRAME) * sizeof(FLOAT32));
283 WORD32 i, j, k, i1, i2;
284 WORD32 *p_params;
285 FLOAT32 energy = 0, max_corr = 0, t0 = 0, *p, *p1;
286 WORD32 ol_pitch_lag[2 * NUM_FRAMES] = {0};
287 FLOAT32 norm_corr[2 * NUM_FRAMES] = {0};
288 WORD32 num_params, pitch_min, pitch_max;
289
290 ia_usac_lpd_state_struct *lpd_state[6], *lpd_state_temp;
291 lpd_state_temp = (ia_usac_lpd_state_struct *)ptr_stack_mem;
292 ptr_stack_mem +=
293 (sizeof(ia_usac_lpd_state_struct) + sizeof(*ptr_stack_mem)) / (sizeof(*ptr_stack_mem));
294 memset(lpd_state_temp, 0, sizeof(*lpd_state_temp));
295 for (j = 0; j < 6; j++) {
296 lpd_state[j] = (ia_usac_lpd_state_struct *)ptr_stack_mem;
297 ptr_stack_mem +=
298 (sizeof(ia_usac_lpd_state_struct) + sizeof(*ptr_stack_mem)) / (sizeof(*ptr_stack_mem));
299 memset(lpd_state[j], 0, sizeof(*lpd_state[0]));
300 }
301
302 WORD32 num_bits_acelp = 0, num_bits_tcx = 0;
303 WORD32 range_pitch_search = 0;
304 WORD32 len_subfrm = 0;
305 WORD32 num_subfrm = 0;
306 WORD32 num_sbfrm_per_supfrm = 0;
307 WORD32 window_len = 0;
308 WORD32 len = (MAX_PITCH / OPL_DECIM);
309 FLOAT32 mem_wsyn;
310 FLOAT32 ssnr_256 = 0.0f, ssnr_512 = 0.0f, ssnr_1024 = 0.0f;
311 FLOAT32 tmp_ssnr = 0.0f;
312
313 len_subfrm = st->len_subfrm;
314 num_subfrm = st->num_subfrm;
315 num_sbfrm_per_supfrm = NUM_FRAMES * num_subfrm;
316
317 if (pit_adj <= FSCALE_DENOM) {
318 window_len = (LEN_LP_WINDOW * len_subfrm) / LEN_FRAME;
319 } else {
320 window_len = (LEN_LP_WINDOW_HIGH_RATE * len_subfrm) / LEN_FRAME;
321 }
322
323 memcpy(pstr_scratch->p_wsig_buf, st->weighted_sig, 128 * sizeof(FLOAT32));
324
325 num_bits_acelp = (iusace_acelp_core_numbits_1024[*codec_mode] - NBITS_MODE) >> 2;
326
327 num_bits_tcx = (WORD32)(0.85f * num_bits_acelp - NBITS_LPC);
328
329 if (pit_adj == 0) {
330 pitch_min = TMIN;
331 pitch_max = TMAX;
332 } else {
333 i = (((pit_adj * TMIN) + (FSCALE_DENOM / 2)) / FSCALE_DENOM) - TMIN;
334 pitch_min = TMIN + i;
335 pitch_max = TMAX + (6 * i);
336 }
337
338 p_wsp_prev_buf = wsp_prev_buf + MAX_PITCH1 / OPL_DECIM;
339 memcpy(wsp_prev_buf, st->prev_wsp, (WORD32)((MAX_PITCH / OPL_DECIM) * sizeof(FLOAT32)));
340
341 if (first_lpd_flag) {
342 memcpy(st->isp_old, iusace_ispold_init, ORDER * sizeof(FLOAT32));
343
344 iusace_autocorr_plus(&speech[-(window_len / 2)], auto_corr_vector, window_len,
345 (FLOAT32 *)lp_analysis_window, pstr_scratch->p_buf_aut_corr);
346
347 for (j = 0; j <= ORDER; j++) {
348 auto_corr_vector[j] *= (FLOAT32)iusace_lag_window[j];
349 }
350
351 iusace_levinson_durbin_algo(auto_corr_vector, auto_corr_lp_filter_coeff);
352 iusace_lpc_2_lsp_conversion(auto_corr_lp_filter_coeff, isp_new, st->isp_old);
353 memcpy(st->isp_old, isp_new, ORDER * sizeof(FLOAT32));
354 iusace_lsp_2_lsf_conversion(isp_new, isf_curr);
355 memcpy(st->isf_old, isf_curr, ORDER * sizeof(FLOAT32));
356 }
357
358 memcpy(isp_curr, st->isp_old, ORDER * sizeof(FLOAT32));
359
360 for (i = 0; i < NUM_FRAMES; i++) {
361 iusace_autocorr_plus(&speech[((i + 1) * len_subfrm) - (window_len / 2)], auto_corr_vector,
362 window_len, (FLOAT32 *)lp_analysis_window, pstr_scratch->p_buf_aut_corr);
363
364 for (j = 0; j <= ORDER; j++) {
365 auto_corr_vector[j] *= (FLOAT32)iusace_lag_window[j];
366 }
367
368 iusace_levinson_durbin_algo(auto_corr_vector, auto_corr_lp_filter_coeff);
369 iusace_lpc_2_lsp_conversion(auto_corr_lp_filter_coeff, isp_new, st->isp_old);
370 memcpy(&isp_curr[(i + 1) * ORDER], isp_new, ORDER * sizeof(FLOAT32));
371 iusace_interpolation_lsp_params(st->isp_old, isp_new,
372 &lp_filter_coeff[i * num_subfrm * (ORDER + 1)], num_subfrm);
373 iusace_lsp_2_lsf_conversion(&isp_curr[(i + 1) * ORDER], &isf_curr[(i + 1) * ORDER]);
374 memcpy(st->isp_old, isp_new, ORDER * sizeof(FLOAT32));
375 }
376
377 memcpy(isf_curr, st->isf_old, ORDER * sizeof(FLOAT32));
378 memcpy(st->isf_old, &isf_curr[NUM_FRAMES * ORDER], ORDER * sizeof(FLOAT32));
379
380 if (!first_lpd_flag) {
381 iusace_lsp_2_lsf_conversion(st->isp_old_q, isf_curr_q);
382 }
383
384 iusace_quantize_lpc_avq(&isf_curr[ORDER], &isf_curr_q[ORDER], first_lpd_flag, &lpc_params[0],
385 &num_indices, &num_bits);
386
387 for (i = 0; i < NUM_FRAMES; i++) {
388 iusace_lsf_2_lsp_conversion(&isf_curr_q[(i + 1) * ORDER], &isp_curr_q[(i + 1) * ORDER]);
389 }
390
391 if (first_lpd_flag) {
392 iusace_lsf_2_lsp_conversion(isf_curr_q, isp_curr_q);
393 memcpy(st->isp_old_q, isp_curr_q, ORDER * sizeof(FLOAT32));
394 }
395
396 *num_fac_bits = 0;
397 if (first_lpd_flag) {
398 FLOAT32 *temp_speech = pstr_scratch->p_buf_speech;
399 FLOAT32 *temp_res = pstr_scratch->p_buf_res;
400 FLOAT32 lpc[9 * (ORDER + 1)];
401 FLOAT32 hp_mem[4];
402 FLOAT32 premph_mem = 0.0f;
403 WORD32 fac_length;
404 WORD32 num_bits_fac = (WORD32)((FLOAT32)num_bits_tcx / 2.f);
405 FLOAT32 *temp_signal = pstr_scratch->p_buf_signal;
406
407 if (st->last_was_short) {
408 fac_length = (st->len_frame) / 16;
409 } else {
410 fac_length = len_subfrm / 2;
411 }
412
413 iusace_get_interpolated_lpc(st->isp_old_q, st->isp_old_q, lpc, (2 * len_subfrm) / LEN_SUBFR);
414
415 memset(temp_speech, 0, (ORDER + 2 * len_subfrm) * sizeof(FLOAT32));
416 memset(temp_res, 0, (2 * len_subfrm) * sizeof(FLOAT32));
417
418 iusace_fac_apply(&st->fd_orig[1 + ORDER], len_subfrm, fac_length, st->low_pass_line,
419 num_bits_fac, &st->fd_synth[1 + ORDER], lpc, serial_fac_out, num_fac_bits,
420 pstr_scratch);
421 memset(hp_mem, 0, 4 * sizeof(FLOAT32));
422 iusace_highpass_50hz_12k8(st->fd_orig, 2 * len_subfrm + 1 + ORDER, hp_mem, pit_adj);
423 premph_mem = 0.0f;
424 iusace_apply_preemph(st->fd_orig, PREEMPH_FILT_FAC, 2 * len_subfrm + 1 + ORDER, &premph_mem);
425
426 memcpy(temp_signal, st->fd_orig + len_subfrm + 1, (len_subfrm + ORDER) * sizeof(FLOAT32));
427 premph_mem = temp_signal[0];
428 iusace_apply_deemph(temp_signal, PREEMPH_FILT_FAC, len_subfrm + ORDER, &premph_mem);
429 memcpy(st->lpd_state.tcx_mem, &temp_signal[len_subfrm + ORDER - 128], 128 * sizeof(FLOAT32));
430
431 premph_mem = 0.0f;
432 iusace_apply_preemph(st->fd_synth, PREEMPH_FILT_FAC, 2 * len_subfrm + 1 + ORDER, &premph_mem);
433 memcpy(st->lpd_state.synth, st->fd_synth + 2 * len_subfrm - ORDER - 128 + 1 + ORDER,
434 (ORDER + 128) * sizeof(FLOAT32));
435 memcpy(temp_speech + ORDER, st->fd_synth + 1 + ORDER, 2 * len_subfrm * sizeof(FLOAT32));
436
437 premph_mem = 0.0f;
438 iusace_find_weighted_speech(lpc, temp_speech + ORDER, temp_res, &premph_mem, 2 * len_subfrm);
439 st->prev_wsyn_mem = premph_mem;
440 memcpy(st->lpd_state.wsynth, temp_res + 2 * len_subfrm - ORDER - 128,
441 (ORDER + 128) * sizeof(FLOAT32));
442 memcpy(temp_speech + ORDER, st->fd_synth + 1 + ORDER, 2 * len_subfrm * sizeof(FLOAT32));
443 memset(temp_res, 0, 2 * len_subfrm * sizeof(FLOAT32));
444 for (i = 0; i < 2 * len_subfrm; i += LEN_SUBFR) {
445 iusace_compute_lp_residual(lpc, &temp_speech[ORDER + i], &temp_res[i], LEN_SUBFR);
446 }
447 memcpy(st->lpd_state.acelp_exc, temp_res, 2 * len_subfrm * sizeof(FLOAT32));
448 premph_mem = 0.0f;
449 iusace_find_weighted_speech(lp_filter_coeff, st->fd_orig + 1 + ORDER, temp_speech + ORDER,
450 &(st->mem_wsp), 2 * len_subfrm);
451 memcpy(st->weighted_sig, temp_speech + ORDER + 2 * len_subfrm - 128, 128 * sizeof(FLOAT32));
452 memcpy(pstr_scratch->p_wsig_buf, st->weighted_sig, 128 * sizeof(FLOAT32));
453 for (i = 0; i < 2 * len_subfrm; i += len_subfrm) {
454 iusace_decim2_fir_filter(&temp_speech[i + ORDER], len_subfrm, st->mem_lp_decim2,
455 pstr_scratch->p_fir_sig_buf);
456 memcpy(temp_speech + ORDER + i / OPL_DECIM, temp_speech + ORDER + i,
457 (len_subfrm / OPL_DECIM) * sizeof(FLOAT32));
458 }
459 memcpy(wsp_prev_buf, temp_speech + ORDER + 2 * len_subfrm / OPL_DECIM - MAX_PITCH / OPL_DECIM,
460 (WORD32)((MAX_PITCH / OPL_DECIM) * sizeof(FLOAT32)));
461 iusace_highpass_prev_wsp(st, temp_speech, pitch_max);
462 }
463 memcpy(isp_curr_q, st->isp_old_q, ORDER * sizeof(FLOAT32));
464 memcpy(st->isp_old_q, &isp_curr_q[NUM_FRAMES * ORDER], ORDER * sizeof(FLOAT32));
465
466 for (i = 0; i < NUM_FRAMES; i++) {
467 iusace_find_weighted_speech(
468 &lp_filter_coeff[i * (num_sbfrm_per_supfrm / NUM_FRAMES) * (ORDER + 1)],
469 &speech[i * len_subfrm], &pstr_scratch->p_wsig_buf[i * len_subfrm], &(st->mem_wsp),
470 len_subfrm);
471 memcpy(p_wsp_prev_buf, &pstr_scratch->p_wsig_buf[i * len_subfrm],
472 len_subfrm * sizeof(FLOAT32));
473
474 iusace_decim2_fir_filter(p_wsp_prev_buf, len_subfrm, st->mem_lp_decim2,
475 pstr_scratch->p_fir_sig_buf);
476 range_pitch_search = 2 * LEN_SUBFR;
477 if (num_subfrm < 4) {
478 range_pitch_search = 3 * LEN_SUBFR;
479 }
480
481 iusace_open_loop_search(p_wsp_prev_buf, (pitch_min / OPL_DECIM) + 1, pitch_max / OPL_DECIM,
482 range_pitch_search / OPL_DECIM, &ol_pitch_lag[i * 2], st);
483
484 if (st->ol_gain > 0.6) {
485 st->prev_pitch_med = iusace_get_ol_lag_median(ol_pitch_lag[i * 2], st->prev_ol_lags);
486 st->ada_w = 1.0;
487 } else {
488 st->ada_w = st->ada_w * 0.9f;
489 }
490 if (st->ada_w < 0.8) {
491 st->ol_wght_flg = 0;
492 } else {
493 st->ol_wght_flg = 1;
494 }
495
496 max_corr = 0.0f;
497 p = &p_wsp_prev_buf[0];
498 p1 = p_wsp_prev_buf - ol_pitch_lag[i * 2];
499 for (j = 0; j < range_pitch_search / OPL_DECIM; j++) {
500 max_corr += *p++ * *p1++;
501 }
502
503 t0 = 0.01f;
504 p = p_wsp_prev_buf - ol_pitch_lag[i * 2];
505 for (j = 0; j < range_pitch_search / OPL_DECIM; j++, p++) {
506 t0 += *p * *p;
507 }
508 t0 = (FLOAT32)(1.0 / sqrt(t0));
509 norm_corr[i * 2] = max_corr * t0;
510
511 energy = 0.01f;
512 for (j = 0; j < range_pitch_search / OPL_DECIM; j++) {
513 energy += p_wsp_prev_buf[j] * p_wsp_prev_buf[j];
514 }
515 energy = (FLOAT32)(1.0 / sqrt(energy));
516 norm_corr[i * 2] *= energy;
517
518 if (num_subfrm < 4) {
519 ol_pitch_lag[(i * 2) + 1] = ol_pitch_lag[i * 2];
520 norm_corr[(i * 2) + 1] = norm_corr[i * 2];
521 } else {
522 iusace_open_loop_search(p_wsp_prev_buf + ((2 * LEN_SUBFR) / OPL_DECIM),
523 (pitch_min / OPL_DECIM) + 1, pitch_max / OPL_DECIM,
524 (2 * LEN_SUBFR) / OPL_DECIM, &ol_pitch_lag[(i * 2) + 1], st);
525
526 if (st->ol_gain > 0.6) {
527 st->prev_pitch_med =
528 iusace_get_ol_lag_median(ol_pitch_lag[(i * 2) + 1], st->prev_ol_lags);
529 st->ada_w = 1.0;
530 } else {
531 st->ada_w = st->ada_w * 0.9f;
532 }
533 if (st->ada_w < 0.8) {
534 st->ol_wght_flg = 0;
535 } else {
536 st->ol_wght_flg = 1;
537 }
538 max_corr = 0.0f;
539 p = p_wsp_prev_buf + (2 * LEN_SUBFR) / OPL_DECIM;
540 p1 = p_wsp_prev_buf + ((2 * LEN_SUBFR) / OPL_DECIM) - ol_pitch_lag[(i * 2) + 1];
541 for (j = 0; j < (2 * LEN_SUBFR) / OPL_DECIM; j++) {
542 max_corr += *p++ * *p1++;
543 }
544
545 t0 = 0.01f;
546 p = p_wsp_prev_buf + ((2 * LEN_SUBFR) / OPL_DECIM) - ol_pitch_lag[(i * 2) + 1];
547 for (j = 0; j < (2 * LEN_SUBFR) / OPL_DECIM; j++, p++) {
548 t0 += *p * *p;
549 }
550 t0 = (FLOAT32)(1.0 / sqrt(t0));
551 norm_corr[(i * 2) + 1] = max_corr * t0;
552
553 energy = 0.01f;
554 for (j = 0; j < (2 * LEN_SUBFR) / OPL_DECIM; j++) {
555 energy += p_wsp_prev_buf[((2 * LEN_SUBFR) / OPL_DECIM) + j] *
556 p_wsp_prev_buf[((2 * LEN_SUBFR) / OPL_DECIM) + j];
557 }
558 energy = (FLOAT32)(1.0 / sqrt(energy));
559 norm_corr[(i * 2) + 1] *= energy;
560 }
561
562 memmove(wsp_prev_buf, &wsp_prev_buf[len_subfrm / OPL_DECIM],
563 (WORD32)((MAX_PITCH / OPL_DECIM) * sizeof(FLOAT32)));
564 }
565
566 memcpy(lpd_state[0], &st->lpd_state, sizeof(*lpd_state[0]));
567
568 ssnr_1024 = 0;
569 if (usac_data->use_acelp_only) {
570 for (i1 = 0; i1 < 2; i1++) {
571 for (i2 = 0; i2 < 2; i2++) {
572 k = (i1 * 2) + i2;
573 p_params = acelp_tcx_params + (k * MAX_NUM_TCX_PRM_PER_DIV);
574
575 iusace_interpolation_lsp_params(&isp_curr_q[k * ORDER], &isp_curr_q[(k + 1) * ORDER],
576 lp_filter_coeff_q, st->num_subfrm);
577
578 memcpy(lpd_state[k + 1], lpd_state[k], sizeof(*lpd_state[0]));
579
580 iusace_acelp_encode(
581 &lp_filter_coeff[k * (num_sbfrm_per_supfrm / 4) * (ORDER + 1)], lp_filter_coeff_q,
582 &speech[k * st->len_subfrm], &pstr_scratch->p_wsig_buf[k * st->len_subfrm],
583 &pstr_scratch->p_synth_buf[k * st->len_subfrm],
584 &pstr_scratch->p_wsyn_buf[k * st->len_subfrm], *codec_mode, lpd_state[k + 1],
585 st->len_subfrm, norm_corr[k * 2], norm_corr[(k * 2) + 1], ol_pitch_lag[k * 2],
586 ol_pitch_lag[(k * 2) + 1], pit_adj, p_params, pstr_scratch);
587
588 mem_wsyn = lpd_state[k]->mem_wsyn;
589
590 iusace_find_weighted_speech(&lp_filter_coeff[k * (num_sbfrm_per_supfrm / 4) *
591 (ORDER + 1)], &pstr_scratch->p_synth_buf[k * LEN_FRAME],
592 pstr_scratch->p_temp_wsyn_buf, &mem_wsyn, LEN_FRAME);
593
594 lpd_state[k + 1]->mem_wsyn = mem_wsyn;
595 mode[k] = 0;
596 num_tcx_param[k] = 0;
597 }
598 }
599 memcpy(&st->lpd_state, lpd_state[4], sizeof(*lpd_state[4]));
600 memcpy(st->weighted_sig, pstr_scratch->p_wsig_buf + (st->len_frame), 128 * sizeof(FLOAT32));
601 memcpy(st->prev_wsp, wsp_prev_buf, (len * sizeof(FLOAT32)));
602 return;
603 }
604 for (i1 = 0; i1 < 2; i1++) {
605 ssnr_512 = 0;
606 for (i2 = 0; i2 < 2; i2++) {
607 k = (i1 * 2) + i2;
608 p_params = acelp_tcx_params + (k * MAX_NUM_TCX_PRM_PER_DIV);
609
610 iusace_interpolation_lsp_params(&isp_curr_q[k * ORDER], &isp_curr_q[(k + 1) * ORDER],
611 lp_filter_coeff_q, st->num_subfrm);
612
613 memcpy(lpd_state[k + 1], lpd_state[k], sizeof(*lpd_state[0]));
614
615 iusace_acelp_encode(
616 &lp_filter_coeff[k * (num_sbfrm_per_supfrm / 4) * (ORDER + 1)], lp_filter_coeff_q,
617 &speech[k * st->len_subfrm], &pstr_scratch->p_wsig_buf[k * st->len_subfrm],
618 &pstr_scratch->p_synth_buf[k * st->len_subfrm],
619 &pstr_scratch->p_wsyn_buf[k * st->len_subfrm], *codec_mode, lpd_state[k + 1],
620 st->len_subfrm, norm_corr[k * 2], norm_corr[(k * 2) + 1], ol_pitch_lag[k * 2],
621 ol_pitch_lag[(k * 2) + 1], pit_adj, p_params, pstr_scratch);
622
623 mem_wsyn = lpd_state[k]->mem_wsyn;
624
625 iusace_find_weighted_speech(&lp_filter_coeff[k * (num_sbfrm_per_supfrm / 4) * (ORDER + 1)],
626 &pstr_scratch->p_synth_buf[k * LEN_FRAME],
627 pstr_scratch->p_temp_wsyn_buf, &mem_wsyn, LEN_FRAME);
628
629 lpd_state[k + 1]->mem_wsyn = mem_wsyn;
630
631 ssnr_256 = iusace_cal_segsnr(&pstr_scratch->p_wsig_buf[k * LEN_FRAME],
632 pstr_scratch->p_temp_wsyn_buf, LEN_FRAME, LEN_SUBFR);
633
634 mode[k] = 0;
635 num_tcx_param[k] = 0;
636
637 iusace_lpc_coef_gen(&isp_curr_q[k * ORDER], &isp_curr_q[(k + 1) * ORDER], lp_filter_coeff_q,
638 st->num_subfrm, ORDER);
639
640 memcpy(lpd_state_temp, lpd_state[k], sizeof(*lpd_state[0]));
641
642 iusace_tcx_fac_encode(usac_data,
643 &lp_filter_coeff[k * (num_sbfrm_per_supfrm / 4) * (ORDER + 1)],
644 lp_filter_coeff_q, &speech[k * st->len_subfrm], st->len_subfrm,
645 num_bits_tcx, lpd_state_temp, prm_tcx, &num_params, ch_idx, k);
646
647 mem_wsyn = lpd_state[k]->mem_wsyn;
648
649 iusace_find_weighted_speech(&lp_filter_coeff[k * (num_sbfrm_per_supfrm / 4) * (ORDER + 1)],
650 pstr_scratch->p_synth_tcx_buf, pstr_scratch->p_temp_wsyn_buf,
651 &mem_wsyn, LEN_FRAME);
652
653 lpd_state_temp->mem_wsyn = mem_wsyn;
654
655 tmp_ssnr = iusace_cal_segsnr(&pstr_scratch->p_wsig_buf[k * LEN_FRAME],
656 pstr_scratch->p_temp_wsyn_buf, LEN_FRAME, LEN_SUBFR);
657
658 if (tmp_ssnr > ssnr_256) {
659 ssnr_256 = tmp_ssnr;
660 mode[k] = 1;
661 num_tcx_param[k] = num_params;
662 memcpy(lpd_state[k + 1], lpd_state_temp, sizeof(*lpd_state[0]));
663
664 memcpy(&pstr_scratch->p_synth_buf[(k * st->len_subfrm) - 128],
665 pstr_scratch->p_synth_tcx_buf - 128, (st->len_subfrm + 128) * sizeof(FLOAT32));
666
667 memcpy(&pstr_scratch->p_wsyn_buf[(k * st->len_subfrm) - 128],
668 pstr_scratch->p_wsyn_tcx_buf - 128, (st->len_subfrm + 128) * sizeof(FLOAT32));
669
670 memcpy(p_params, prm_tcx, NUM_TCX20_PRM * sizeof(WORD32));
671 }
672 ssnr_512 += 0.50f * ssnr_256;
673 }
674
675 k = i1 * 2;
676
677 p_params = acelp_tcx_params + (k * MAX_NUM_TCX_PRM_PER_DIV);
678
679 iusace_lpc_coef_gen(&isp_curr_q[2 * i1 * ORDER], &isp_curr_q[(2 * i1 + 2) * ORDER],
680 lp_filter_coeff_q, (num_sbfrm_per_supfrm / 2), ORDER);
681
682 memcpy(lpd_state_temp, lpd_state[2 * i1], sizeof(*lpd_state[0]));
683 iusace_tcx_fac_encode(usac_data,
684 &lp_filter_coeff[2 * i1 * (num_sbfrm_per_supfrm / 4) * (ORDER + 1)],
685 lp_filter_coeff_q, &speech[2 * i1 * st->len_subfrm], 2 * st->len_subfrm,
686 2 * num_bits_tcx, lpd_state_temp, prm_tcx, &num_params, ch_idx, 2 * i1);
687
688 mem_wsyn = lpd_state[2 * i1]->mem_wsyn;
689
690 iusace_find_weighted_speech(
691 &lp_filter_coeff[2 * i1 * (num_sbfrm_per_supfrm / 4) * (ORDER + 1)],
692 pstr_scratch->p_synth_tcx_buf, pstr_scratch->p_temp_wsyn_buf, &mem_wsyn, LEN_FRAME * 2);
693
694 lpd_state_temp->mem_wsyn = mem_wsyn;
695
696 tmp_ssnr = iusace_cal_segsnr(&pstr_scratch->p_wsig_buf[2 * i1 * LEN_FRAME],
697 pstr_scratch->p_temp_wsyn_buf, LEN_FRAME * 2, LEN_SUBFR);
698
699 if (tmp_ssnr > ssnr_512) {
700 ssnr_512 = tmp_ssnr;
701 for (i = 0; i < 2; i++) {
702 mode[k + i] = 2;
703 num_tcx_param[k + i] = num_params;
704 }
705 memcpy(lpd_state[k + 2], lpd_state_temp, sizeof(*lpd_state[0]));
706
707 memcpy(&pstr_scratch->p_synth_buf[(2 * i1 * st->len_subfrm) - 128],
708 pstr_scratch->p_synth_tcx_buf - 128, ((2 * st->len_subfrm) + 128) * sizeof(FLOAT32));
709 memcpy(&pstr_scratch->p_wsyn_buf[(2 * i1 * st->len_subfrm) - 128],
710 pstr_scratch->p_wsyn_tcx_buf - 128, ((2 * st->len_subfrm) + 128) * sizeof(FLOAT32));
711 memcpy(p_params, prm_tcx, NUM_TCX40_PRM * sizeof(WORD32));
712 }
713 ssnr_1024 += 0.50f * ssnr_512;
714 }
715
716 k = 0;
717
718 p_params = acelp_tcx_params + (k * MAX_NUM_TCX_PRM_PER_DIV);
719
720 iusace_lpc_coef_gen(&isp_curr_q[k * ORDER], &isp_curr_q[(k + 4) * ORDER], lp_filter_coeff_q,
721 num_sbfrm_per_supfrm, ORDER);
722
723 memcpy(lpd_state_temp, lpd_state[k], sizeof(*lpd_state[0]));
724
725 iusace_tcx_fac_encode(usac_data, &lp_filter_coeff[k * (num_sbfrm_per_supfrm / 4) * (ORDER + 1)],
726 lp_filter_coeff_q, &speech[k * st->len_subfrm], 4 * st->len_subfrm,
727 4 * num_bits_tcx, lpd_state_temp, prm_tcx, &num_params, ch_idx, k);
728
729 mem_wsyn = lpd_state[k]->mem_wsyn;
730
731 iusace_find_weighted_speech(&lp_filter_coeff[k * (num_sbfrm_per_supfrm / 4) * (ORDER + 1)],
732 pstr_scratch->p_synth_tcx_buf, pstr_scratch->p_temp_wsyn_buf,
733 &mem_wsyn, LEN_FRAME * 4);
734
735 lpd_state_temp->mem_wsyn = mem_wsyn;
736
737 tmp_ssnr = iusace_cal_segsnr(&pstr_scratch->p_wsig_buf[k * LEN_FRAME],
738 pstr_scratch->p_temp_wsyn_buf, LEN_FRAME * 4, LEN_SUBFR);
739
740 if (tmp_ssnr > ssnr_1024) {
741 for (i = 0; i < 4; i++) {
742 mode[k + i] = 3;
743 num_tcx_param[k + i] = num_params;
744 }
745 memcpy(lpd_state[k + 4], lpd_state_temp, sizeof(*lpd_state[0]));
746
747 memcpy(&pstr_scratch->p_synth_buf[(k * st->len_subfrm) - 128],
748 pstr_scratch->p_synth_tcx_buf - 128, ((4 * st->len_subfrm) + 128) * sizeof(FLOAT32));
749 memcpy(&pstr_scratch->p_wsyn_buf[(k * st->len_subfrm) - 128],
750 pstr_scratch->p_wsyn_tcx_buf - 128, ((4 * st->len_subfrm) + 128) * sizeof(FLOAT32));
751 memcpy(p_params, prm_tcx, NUM_TCX80_PRM * sizeof(WORD32));
752 }
753 memcpy(&st->lpd_state, lpd_state[4], sizeof(*lpd_state[4]));
754
755 memcpy(st->weighted_sig, pstr_scratch->p_wsig_buf + (st->len_frame), 128 * sizeof(FLOAT32));
756 memcpy(st->prev_wsp, wsp_prev_buf, (len * sizeof(FLOAT32)));
757
758 return;
759 }
760
iusace_lpd_frm_enc(ia_usac_data_struct * usac_data,WORD32 * mod_out,WORD32 const usac_independency_flg,WORD32 len_frame,WORD32 i_ch,ia_bit_buf_struct * pstr_it_bit_buff)761 IA_ERRORCODE iusace_lpd_frm_enc(ia_usac_data_struct *usac_data, WORD32 *mod_out,
762 WORD32 const usac_independency_flg, WORD32 len_frame, WORD32 i_ch,
763 ia_bit_buf_struct *pstr_it_bit_buff) {
764 WORD32 i;
765 WORD32 len_next_high_rate = (LEN_NEXT_HIGH_RATE * len_frame) / LEN_SUPERFRAME;
766 WORD32 len_lpc0 = (LEN_LPC0 * len_frame) / LEN_SUPERFRAME;
767 FLOAT32 *input_data = &usac_data->td_in_buf[i_ch][len_next_high_rate];
768 ia_usac_td_encoder_struct *td_encoder = usac_data->td_encoder[i_ch];
769 WORD32 fscale = usac_data->td_encoder[i_ch]->fscale;
770 WORD32 first_lpd_flag = (usac_data->core_mode_prev[i_ch] == CORE_MODE_FD);
771 FLOAT32 *speech_buf = usac_data->speech_buf;
772 FLOAT32 *ptr_scratch_buf = usac_data->str_scratch.p_lpd_frm_enc_scratch;
773 FLOAT32 *speech, *new_speech;
774 WORD32 mode_buf[1 + NUM_FRAMES] = {0}, *mode;
775 WORD32 num_tcx_params[NUM_FRAMES] = {0};
776 WORD32 len_subfrm;
777
778 len_subfrm = td_encoder->len_subfrm;
779
780 if (usac_data->core_mode_prev[i_ch] == CORE_MODE_FD) {
781 iusace_reset_td_enc(usac_data->td_encoder[i_ch]);
782
783 FLOAT32 *in_data = usac_data->td_in_prev_buf[i_ch];
784 FLOAT32 *ptr_speech = usac_data->speech_buf;
785 WORD32 length = len_next_high_rate + len_lpc0;
786 ia_usac_td_encoder_struct *st = usac_data->td_encoder[i_ch];
787 memcpy(ptr_speech, in_data, length * sizeof(FLOAT32));
788
789 iusace_highpass_50hz_12k8(ptr_speech, length, st->mem_sig_in, st->fscale);
790
791 iusace_apply_preemph(ptr_speech, PREEMPH_FILT_FAC, length, &(st->mem_preemph));
792 memcpy(st->old_speech_pe + ORDER, ptr_speech, length * sizeof(FLOAT32));
793 }
794
795 if (first_lpd_flag) {
796 td_encoder->prev_mode = -1;
797 }
798
799 mode = mode_buf + 1;
800 mode[-1] = td_encoder->prev_mode;
801 fscale = (fscale * len_subfrm) / LEN_FRAME;
802
803 new_speech = speech_buf + ORDER + (LEN_NEXT_HIGH_RATE * len_subfrm) / LEN_FRAME;
804 speech = speech_buf + ORDER;
805 if (first_lpd_flag) {
806 new_speech += (LEN_LPC0 * len_subfrm) / LEN_FRAME;
807 speech += (LEN_LPC0 * len_subfrm) / LEN_FRAME;
808 }
809 memcpy(new_speech, input_data, td_encoder->len_frame * sizeof(FLOAT32));
810
811 iusace_highpass_50hz_12k8(new_speech, td_encoder->len_frame, td_encoder->mem_sig_in, fscale);
812 iusace_apply_preemph(new_speech, PREEMPH_FILT_FAC, td_encoder->len_frame,
813 &(td_encoder->mem_preemph));
814
815 if (first_lpd_flag) {
816 memcpy(speech_buf, td_encoder->old_speech_pe,
817 ((ORDER + (((LEN_NEXT_HIGH_RATE + LEN_LPC0) * len_subfrm) / LEN_FRAME))) *
818 sizeof(FLOAT32));
819 for (i = 0; i < (len_subfrm + 1); i++) {
820 ptr_scratch_buf[i] = speech[-len_subfrm - 1 + i];
821 }
822 iusace_apply_deemph(ptr_scratch_buf, PREEMPH_FILT_FAC, len_subfrm + 1, &ptr_scratch_buf[0]);
823 memcpy(td_encoder->lpd_state.tcx_mem, &ptr_scratch_buf[len_subfrm - 128 + 1],
824 128 * sizeof(FLOAT32));
825 } else {
826 memcpy(speech_buf, td_encoder->old_speech_pe,
827 ((ORDER + ((LEN_NEXT_HIGH_RATE * len_subfrm) / LEN_FRAME))) * sizeof(FLOAT32));
828 }
829
830 iusace_core_lpd_encode(usac_data, speech, mode, num_tcx_params, i_ch);
831
832 if (first_lpd_flag) {
833 memcpy(td_encoder->old_speech_pe,
834 &speech_buf[(td_encoder->len_frame) + (LEN_LPC0 * len_subfrm) / LEN_FRAME],
835 (ORDER + ((LEN_NEXT_HIGH_RATE * len_subfrm) / LEN_FRAME)) * sizeof(FLOAT32));
836 } else {
837 memcpy(td_encoder->old_speech_pe, &speech_buf[(td_encoder->len_frame)],
838 (ORDER + ((LEN_NEXT_HIGH_RATE * len_subfrm) / LEN_FRAME)) * sizeof(FLOAT32));
839 }
840
841 iusace_encode_fac_params(mode, num_tcx_params, usac_data, usac_independency_flg,
842 pstr_it_bit_buff, i_ch);
843
844 td_encoder->prev_mode = (WORD16)mode[3];
845
846 memcpy(mod_out, mode, 4 * sizeof(WORD32));
847 return IA_NO_ERROR;
848 }
849