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 <stdio.h>
23 #include <math.h>
24
25 #include "ixheaac_error_standards.h"
26 #include "iusace_type_def.h"
27 #include "ixheaace_adjust_threshold_data.h"
28 #include "iusace_bitbuffer.h"
29 #include "ixheaace_bitbuffer.h"
30 #include "ixheaace_mps_common_define.h"
31
32 /* DRC */
33 #include "impd_drc_common_enc.h"
34 #include "impd_drc_uni_drc.h"
35 #include "impd_drc_tables.h"
36 #include "impd_drc_api.h"
37 #include "impd_drc_uni_drc_eq.h"
38 #include "impd_drc_uni_drc_filter_bank.h"
39 #include "impd_drc_gain_enc.h"
40 #include "impd_drc_struct_def.h"
41
42 #include "iusace_cnst.h"
43 #include "iusace_tns_usac.h"
44 #include "iusace_psy_mod.h"
45 #include "iusace_psy_utils.h"
46 #include "iusace_fd_qc_util.h"
47 #include "ixheaace_memory_standards.h"
48 #include "iusace_tns_usac.h"
49 #include "iusace_config.h"
50 #include "iusace_arith_enc.h"
51 #include "iusace_fd_quant.h"
52 #include "iusace_ms.h"
53 #include "iusace_block_switch_const.h"
54 #include "iusace_block_switch_struct_def.h"
55 #include "iusace_signal_classifier.h"
56 #include "ixheaace_sbr_header.h"
57 #include "ixheaace_config.h"
58 #include "ixheaace_asc_write.h"
59 #include "iusace_main.h"
60 #include "iusace_write_bitstream.h"
61 #include "iusace_windowing.h"
62 #include "iusace_fd_enc.h"
63 #include "iusace_fd_qc_adjthr.h"
64 #include "iusace_config.h"
65 #include "iusace_tcx_mdct.h"
66 #include "iusace_func_prototypes.h"
67 #include "iusace_block_switch.h"
68 #include "iusace_rom.h"
69 #include "ixheaace_error_codes.h"
70
71 #include "ixheaace_sbr_header.h"
72 #include "ixheaace_sbr_def.h"
73 #include "ixheaace_resampler.h"
74 #include "ixheaace_common_rom.h"
75
76 #include "ixheaace_sbr_header.h"
77 #include "ixheaace_sbr_def.h"
78 #include "ixheaace_resampler.h"
79 #include "ixheaace_sbr_rom.h"
80 #include "ixheaace_common_rom.h"
81 #include "ixheaace_sbr_hbe.h"
82 #include "ixheaace_sbr_qmf_enc.h"
83 #include "ixheaace_sbr_tran_det.h"
84 #include "ixheaace_sbr_frame_info_gen.h"
85 #include "ixheaace_sbr_env_est.h"
86 #include "ixheaace_sbr_code_envelope.h"
87 #include "ixheaace_sbr_rom.h"
88 #include "ixheaace_sbr_main.h"
89 #include "ixheaace_common_rom.h"
90 #include "ixheaace_sbr_missing_harmonics_det.h"
91 #include "ixheaace_sbr_inv_filtering_estimation.h"
92 #include "ixheaace_sbr_noise_floor_est.h"
93 #include "ixheaace_sbr_ton_corr.h"
94 #include "iusace_esbr_pvc.h"
95 #include "iusace_esbr_inter_tes.h"
96 #include "ixheaace_sbr.h"
97 #include "ixheaace_sbr_cmondata.h"
98 #include "ixheaace_sbr_crc.h"
99 #include "ixheaace_sbr_enc_struct.h"
100
101 #include "iusace_esbr_pvc.h"
102 #include "iusace_esbr_inter_tes.h"
103
iusace_get_num_elements(WORD32 num_channels)104 static WORD32 iusace_get_num_elements(WORD32 num_channels) {
105 WORD32 num_of_elements = 0;
106
107 switch (num_channels) {
108 case 1:
109 case 2:
110 num_of_elements = 1;
111 break;
112 default:
113 num_of_elements = num_channels;
114 break;
115 }
116
117 return num_of_elements;
118 }
119
iusace_get_element_type(WORD32 elem_idx,WORD32 num_channels)120 static UWORD32 iusace_get_element_type(WORD32 elem_idx, WORD32 num_channels) {
121 UWORD32 elem_type = (UWORD32)USAC_ELEMENT_TYPE_INVALID;
122 (VOID) elem_idx;
123
124 switch (num_channels) {
125 case 1:
126 elem_type = USAC_ELEMENT_TYPE_SCE;
127 break;
128 case 2:
129 elem_type = USAC_ELEMENT_TYPE_CPE;
130 break;
131 default:
132 elem_type = USAC_ELEMENT_TYPE_SCE;
133 break;
134 }
135
136 return elem_type;
137 }
138
iusace_bw_init(ia_usac_encoder_config_struct * ptr_usac_config,ixheaace_audio_specific_config_struct * pstr_asc,WORD32 ele_idx)139 static VOID iusace_bw_init(ia_usac_encoder_config_struct *ptr_usac_config,
140 ixheaace_audio_specific_config_struct *pstr_asc, WORD32 ele_idx) {
141 ptr_usac_config->bw_limit[ele_idx] = 20000;
142 (VOID) pstr_asc;
143 ptr_usac_config->bw_limit[ele_idx] =
144 MIN(ptr_usac_config->bw_limit[ele_idx], ptr_usac_config->core_sample_rate / 2);
145
146 return;
147 }
148
iusace_scratch_mem_init(ia_usac_data_struct * usac_data,WORD32 total_ch,WORD32 sr)149 VOID iusace_scratch_mem_init(ia_usac_data_struct *usac_data, WORD32 total_ch, WORD32 sr) {
150 iusace_scratch_mem *pstr_scratch = &usac_data->str_scratch;
151 UWORD8 *temp_ptr = pstr_scratch->ptr_scratch_buf;
152
153 pstr_scratch->ptr_stack_mem = (FLOAT32 *)(temp_ptr);
154 temp_ptr += USACE_SCR_STACK;
155
156 pstr_scratch->p_fd_mdct_windowed_long_buf = (FLOAT64 *)(temp_ptr);
157 temp_ptr += (2 * FRAME_LEN_LONG) * sizeof(FLOAT64);
158
159 pstr_scratch->p_fd_mdct_windowed_short_buf = (FLOAT64 *)(temp_ptr);
160 // Size needed for above pointer is (2 * FRAME_LEN_LONG) * sizeof(FLOAT64)
161
162 temp_ptr = (UWORD8 *)pstr_scratch->p_fd_mdct_windowed_short_buf;
163
164 pstr_scratch->p_tns_filter = (FLOAT64 *)(temp_ptr);
165 temp_ptr += (FRAME_LEN_LONG) * sizeof(FLOAT64);
166
167 pstr_scratch->ptr_tns_scratch = (FLOAT64 *)(temp_ptr);
168 temp_ptr +=
169 (MAX_SHIFT_LEN_LONG + (TNS_MAX_ORDER + 1) * 2) * sizeof(pstr_scratch->ptr_tns_scratch[0]);
170
171 pstr_scratch->p_left_fac_time_data = (FLOAT64 *)(temp_ptr);
172 temp_ptr += (2 * FAC_LENGTH + ORDER) * sizeof(FLOAT64);
173
174 pstr_scratch->p_fac_win = (FLOAT64 *)(temp_ptr);
175 // Size needed for above pointer is (2 * FAC_LENGTH) * sizeof(FLOAT64)
176
177 temp_ptr = (UWORD8 *)pstr_scratch->p_left_fac_time_data;
178
179 pstr_scratch->p_sort_grouping_scratch = (FLOAT64 *)(temp_ptr);
180 // Size needed for above pointer is (LN2) * sizeof(FLOAT64)
181
182 temp_ptr = (UWORD8 *)pstr_scratch->p_sort_grouping_scratch;
183
184 pstr_scratch->p_noise_filling_highest_tone = (FLOAT64 *)(temp_ptr);
185 temp_ptr += (LN2) * sizeof(FLOAT64);
186
187 pstr_scratch->p_quant_spectrum_spec_scratch = (FLOAT64 *)(temp_ptr);
188 temp_ptr += (2 * FRAME_LEN_LONG) * sizeof(FLOAT64);
189
190 pstr_scratch->p_cmpx_mdct_temp_buf = (FLOAT64 *)(temp_ptr);
191 // Size needed for above pointer is (LN2) * sizeof(FLOAT64)
192
193 temp_ptr = (UWORD8 *)pstr_scratch->p_noise_filling_highest_tone;
194
195 for (WORD32 i = 0; i < total_ch; i++) {
196 pstr_scratch->p_reconstructed_time_signal[i] = (FLOAT64 *)(temp_ptr);
197 temp_ptr += (4 * FRAME_LEN_LONG) * sizeof(FLOAT64);
198 }
199 pstr_scratch->ptr_next_win_scratch = (WORD32 *)(temp_ptr);
200 temp_ptr += (2 * MAX_TIME_CHANNELS) * sizeof(pstr_scratch->ptr_next_win_scratch[0]);
201
202 pstr_scratch->p_fft_p2_y = (FLOAT32 *)(temp_ptr);
203 temp_ptr += (2 * FRAME_LEN_LONG) * sizeof(FLOAT32);
204
205 pstr_scratch->p_fft_p3_data_3 = (FLOAT32 *)(temp_ptr);
206 temp_ptr += (800) * sizeof(FLOAT32);
207
208 pstr_scratch->p_fft_p3_y = (FLOAT32 *)(temp_ptr);
209 temp_ptr += (2 * FRAME_LEN_LONG) * sizeof(FLOAT32);
210
211 pstr_scratch->p_time_signal = (FLOAT32 *)(temp_ptr);
212 temp_ptr += (FRAME_LEN_LONG) * sizeof(FLOAT32);
213
214 pstr_scratch->p_complex_fft = (FLOAT32 *)(temp_ptr);
215 temp_ptr += (2 * FRAME_LEN_LONG) * sizeof(FLOAT32);
216
217 pstr_scratch->p_tonal_flag = (WORD32 *)(temp_ptr);
218 temp_ptr += (FRAME_LEN_LONG / 2) * sizeof(WORD32);
219
220 pstr_scratch->p_pow_spec = (FLOAT32 *)(temp_ptr);
221 // Size needed for above pointer is (FRAME_LEN_LONG / 2) * sizeof(FLOAT32)
222 temp_ptr = (UWORD8 *)pstr_scratch->p_time_signal;
223
224 pstr_scratch->p_temp_mdct = (FLOAT32 *)(temp_ptr);
225 temp_ptr += (1024) * sizeof(FLOAT32);
226
227 pstr_scratch->p_buf_synthesis_tool = (FLOAT32 *)(temp_ptr);
228 temp_ptr += (LEN_FRAME_16K + ORDER_LP_FILT_16K) * sizeof(FLOAT32);
229
230 pstr_scratch->p_mdct_spec_float = (FLOAT32 *)(temp_ptr);
231 temp_ptr += (FRAME_LEN_LONG) * sizeof(FLOAT32);
232
233 pstr_scratch->p_sq_gain_en = (FLOAT32 *)(temp_ptr);
234 temp_ptr += (FRAME_LEN_LONG / 4) * sizeof(FLOAT32);
235
236 pstr_scratch->p_fft_mdct_buf = (FLOAT32 *)(temp_ptr);
237 temp_ptr += (4 * FRAME_LEN_LONG) * sizeof(FLOAT32);
238
239 pstr_scratch->p_arith_map_prev_scratch = (WORD32 *)(temp_ptr);
240 temp_ptr += (516) * sizeof(WORD32);
241
242 pstr_scratch->p_arith_map_pres_scratch = (WORD32 *)(temp_ptr);
243 temp_ptr += (516) * sizeof(WORD32);
244
245 pstr_scratch->p_ol_pitch_buf_tmp = (FLOAT32 *)(temp_ptr);
246 temp_ptr += (FRAME_LEN_LONG) * sizeof(FLOAT32);
247
248 pstr_scratch->p_ol_pitch_speech_buf = (FLOAT32 *)(temp_ptr);
249 temp_ptr += (FRAME_LEN_LONG + LAG_MAX) * sizeof(FLOAT32);
250
251 pstr_scratch->p_ol_pitch_w_table = (FLOAT32 *)(temp_ptr);
252 temp_ptr += (LEN_CORR_R) * sizeof(FLOAT32);
253
254 pstr_scratch->p_ol_pitch_R = (FLOAT32 *)(temp_ptr);
255 temp_ptr += (LEN_CORR_R) * sizeof(FLOAT32);
256
257 WORD32 R0_size = (54 + 6 * ((WORD32)(34.f * ((FLOAT32)sr / 2.f) / 12800.f + 0.5f) * 2)) / 2;
258 pstr_scratch->p_ol_pitch_R0 = (FLOAT32 *)(temp_ptr);
259 temp_ptr += (R0_size) * sizeof(FLOAT32);
260
261 pstr_scratch->p_lpd_frm_enc_scratch = (FLOAT32 *)(temp_ptr);
262 temp_ptr += (LEN_FRAME + 1) * sizeof(FLOAT32);
263
264 pstr_scratch->p_wsig_buf = (FLOAT32 *)(temp_ptr + 128 * sizeof(FLOAT32));
265 temp_ptr += (128 + FRAME_LEN_LONG) * sizeof(FLOAT32);
266
267 pstr_scratch->p_wsyn_tcx_buf = (FLOAT32 *)(temp_ptr + 128 * sizeof(FLOAT32));
268 temp_ptr += (128 + FRAME_LEN_LONG) * sizeof(FLOAT32);
269
270 pstr_scratch->p_synth_tcx_buf = (FLOAT32 *)(temp_ptr + 128 * sizeof(FLOAT32));
271 temp_ptr += (128 + FRAME_LEN_LONG) * sizeof(FLOAT32);
272
273 pstr_scratch->p_wsyn_buf = (FLOAT32 *)(temp_ptr + 128 * sizeof(FLOAT32));
274 temp_ptr += (128 + FRAME_LEN_LONG) * sizeof(FLOAT32);
275
276 pstr_scratch->p_synth_buf = (FLOAT32 *)(temp_ptr + 128 * sizeof(FLOAT32));
277 temp_ptr += (128 + FRAME_LEN_LONG) * sizeof(FLOAT32);
278
279 pstr_scratch->p_temp_wsyn_buf = (FLOAT32 *)temp_ptr;
280 temp_ptr += (FRAME_LEN_LONG) * sizeof(FLOAT32);
281
282 pstr_scratch->p_lp_filter_coeff = (FLOAT32 *)(temp_ptr);
283 temp_ptr += ((NUM_SUBFR_SUPERFRAME + 1) * (ORDER + 1)) * sizeof(FLOAT32);
284
285 pstr_scratch->p_lp_filter_coeff_q = (FLOAT32 *)(temp_ptr);
286 temp_ptr += ((NUM_SUBFR_SUPERFRAME + 1) * (ORDER + 1)) * sizeof(FLOAT32);
287
288 pstr_scratch->p_wsp_prev_buf = (FLOAT32 *)(temp_ptr);
289 temp_ptr += ((MAX_PITCH1 / OPL_DECIM) + LEN_FRAME) * sizeof(FLOAT32);
290
291 pstr_scratch->ptr_lpd_scratch = (UWORD8 *)temp_ptr;
292 temp_ptr += ((2 * (NUM_SUBFR_SUPERFRAME + 1) * (ORDER + 1)) + (4 * (NUM_FRAMES + 1) * ORDER) +
293 (((NUM_FRAMES >> 1) + 1) * ORDER) * 4) *
294 sizeof(FLOAT32) +
295 100 * sizeof(WORD32) + 6 * sizeof(ia_usac_lpd_scratch);
296
297 pstr_scratch->p_prm_tcx = (WORD32 *)(temp_ptr);
298 temp_ptr += (NUM_TCX80_PRM) * sizeof(WORD32);
299
300 pstr_scratch->p_buf_speech = (FLOAT32 *)(temp_ptr);
301 temp_ptr += (2 * LEN_FRAME + ORDER) * sizeof(FLOAT32);
302
303 pstr_scratch->p_buf_res = (FLOAT32 *)(temp_ptr);
304 temp_ptr += (2 * LEN_FRAME) * sizeof(FLOAT32);
305
306 pstr_scratch->p_buf_signal = (FLOAT32 *)(temp_ptr);
307 temp_ptr += (ORDER + LEN_FRAME) * sizeof(FLOAT32);
308
309 pstr_scratch->p_xn1_tcx = (FLOAT32 *)(temp_ptr);
310 temp_ptr += (2 * FAC_LENGTH) * sizeof(FLOAT32);
311
312 pstr_scratch->p_xn_buf_tcx = (FLOAT32 *)(temp_ptr);
313 temp_ptr += (128 + FRAME_LEN_LONG + 128) * sizeof(FLOAT32);
314
315 pstr_scratch->p_x_tcx = (FLOAT32 *)(temp_ptr);
316 temp_ptr += (FRAME_LEN_LONG) * sizeof(FLOAT32);
317
318 pstr_scratch->p_x_tmp_tcx = (FLOAT32 *)(temp_ptr);
319 temp_ptr += (FRAME_LEN_LONG) * sizeof(FLOAT32);
320
321 pstr_scratch->p_en_tcx = (FLOAT32 *)(temp_ptr);
322 temp_ptr += (FRAME_LEN_LONG) * sizeof(FLOAT32);
323
324 pstr_scratch->p_alfd_gains_tcx = (FLOAT32 *)(temp_ptr);
325 temp_ptr += (FRAME_LEN_LONG / (4 * 8)) * sizeof(FLOAT32);
326
327 pstr_scratch->p_sq_enc_tcx = (FLOAT32 *)(temp_ptr);
328 temp_ptr += (FRAME_LEN_LONG) * sizeof(FLOAT32);
329
330 pstr_scratch->p_sq_quant_tcx = (WORD32 *)(temp_ptr);
331 temp_ptr += (FRAME_LEN_LONG) * sizeof(WORD32);
332
333 pstr_scratch->p_gain1_tcx = (FLOAT32 *)(temp_ptr);
334 temp_ptr += (FRAME_LEN_LONG) * sizeof(FLOAT32);
335
336 pstr_scratch->p_gain2_tcx = (FLOAT32 *)(temp_ptr);
337 temp_ptr += (FRAME_LEN_LONG) * sizeof(FLOAT32);
338
339 pstr_scratch->p_facelp_tcx = (FLOAT32 *)(temp_ptr);
340 temp_ptr += (FAC_LENGTH) * sizeof(FLOAT32);
341
342 pstr_scratch->p_xn2_tcx = (FLOAT32 *)(temp_ptr);
343 temp_ptr += (2 * FAC_LENGTH) * sizeof(FLOAT32);
344
345 pstr_scratch->p_fac_window_tcx = (FLOAT32 *)(temp_ptr);
346 temp_ptr += (2 * FAC_LENGTH) * sizeof(FLOAT32);
347
348 pstr_scratch->p_x1_tcx = (FLOAT32 *)(temp_ptr);
349 temp_ptr += (FAC_LENGTH) * sizeof(FLOAT32);
350
351 pstr_scratch->p_x2_tcx = (FLOAT32 *)(temp_ptr);
352 temp_ptr += (FAC_LENGTH) * sizeof(FLOAT32);
353
354 pstr_scratch->p_y_tcx = (WORD32 *)(temp_ptr);
355 temp_ptr += (FAC_LENGTH) * sizeof(WORD32);
356
357 pstr_scratch->p_in_out_tcx = (FLOAT32 *)(temp_ptr);
358 temp_ptr += (FRAME_LEN_LONG * 2 * 2) * sizeof(FLOAT32);
359
360 pstr_scratch->p_tcx_input = (FLOAT32 *)(temp_ptr);
361 temp_ptr += (FRAME_LEN_LONG) * sizeof(FLOAT32);
362
363 pstr_scratch->ptr_tcx_scratch = (FLOAT32 *)(temp_ptr);
364 temp_ptr += 3 * (FRAME_LEN_LONG) * sizeof(pstr_scratch->ptr_tcx_scratch[0]);
365
366 pstr_scratch->p_tcx_output = (FLOAT32 *)(temp_ptr);
367 temp_ptr += (FRAME_LEN_LONG) * sizeof(FLOAT32);
368
369 pstr_scratch->p_buf_aut_corr = (FLOAT32 *)(temp_ptr);
370 // Size needed for above pointer is (LEN_WIN_PLUS) * sizeof(FLOAT32)
371 temp_ptr = (UWORD8 *)pstr_scratch->p_buf_aut_corr;
372
373 pstr_scratch->p_xn2 = (FLOAT32 *)(temp_ptr);
374 temp_ptr += (FAC_LENGTH + ORDER) * sizeof(FLOAT32);
375
376 pstr_scratch->p_fac_dec = (FLOAT32 *)(temp_ptr);
377 temp_ptr += (2 * FAC_LENGTH) * sizeof(FLOAT32);
378
379 pstr_scratch->p_right_fac_spec = (FLOAT32 *)(temp_ptr);
380 temp_ptr += (FAC_LENGTH) * sizeof(FLOAT32);
381
382 pstr_scratch->p_x2 = (FLOAT32 *)(temp_ptr);
383 temp_ptr += (FAC_LENGTH) * sizeof(FLOAT32);
384
385 pstr_scratch->p_param = (WORD32 *)(temp_ptr);
386 temp_ptr += (FAC_LENGTH + 1) * sizeof(WORD32);
387
388 pstr_scratch->p_x = (FLOAT32 *)(temp_ptr);
389 temp_ptr += (FAC_LENGTH) * sizeof(FLOAT32);
390
391 pstr_scratch->p_xn_2 = (FLOAT32 *)(temp_ptr);
392 temp_ptr += (2 * FAC_LENGTH + ORDER) * sizeof(FLOAT32);
393
394 pstr_scratch->p_fac_window = (FLOAT32 *)(temp_ptr);
395 temp_ptr += (2 * FAC_LENGTH) * sizeof(FLOAT32);
396
397 pstr_scratch->p_fir_sig_buf = (FLOAT32 *)(temp_ptr);
398 // Size needed for above pointer is (3 + LEN_FRAME) * sizeof(FLOAT32)
399 temp_ptr = (UWORD8 *)pstr_scratch->p_fir_sig_buf;
400
401 pstr_scratch->p_acelp_ir_buf = (FLOAT32 *)(temp_ptr);
402
403 temp_ptr += (4 * LEN_SUBFR) * sizeof(FLOAT32);
404
405 pstr_scratch->ptr_acelp_scratch = (FLOAT32 *)(temp_ptr);
406 temp_ptr += ((11 * LEN_SUBFR) + (ORDER + LEN_SUBFR + 8) + 1024) *
407 sizeof(pstr_scratch->ptr_acelp_scratch[0]);
408
409 pstr_scratch->p_acelp_exc_buf = (FLOAT32 *)(temp_ptr);
410 // Size needed for above pointer is ((3 * LEN_FRAME) + 1 + 41) * sizeof(FLOAT32)
411
412 temp_ptr = (UWORD8 *)pstr_scratch->p_lpd_frm_enc_scratch;
413
414 pstr_scratch->p_fac_bits_word = (WORD16 *)(temp_ptr);
415 temp_ptr += (5000) * sizeof(WORD16);
416
417 pstr_scratch->p_left_fac_timedata_flt = (FLOAT32 *)(temp_ptr);
418 temp_ptr += (2 * FAC_LENGTH + ORDER) * sizeof(FLOAT32);
419
420 pstr_scratch->p_left_fac_spec = (FLOAT32 *)(temp_ptr);
421 temp_ptr += (FAC_LENGTH) * sizeof(FLOAT32);
422
423 pstr_scratch->p_fac_prm = (WORD32 *)(temp_ptr);
424 temp_ptr += (FAC_LENGTH + 1) * sizeof(WORD32);
425
426 pstr_scratch->p_acelp_folded_scratch = (FLOAT32 *)(temp_ptr);
427 // Size needed for above pointer is (FAC_LENGTH) * sizeof(FLOAT32)
428
429 temp_ptr = (UWORD8 *)pstr_scratch->p_fac_bits_word;
430
431 pstr_scratch->p_exp_spec = (FLOAT32 *)(temp_ptr);
432 temp_ptr += (FRAME_LEN_LONG) * sizeof(FLOAT32);
433
434 pstr_scratch->p_adjthr_ptr_exp_spec = (FLOAT32 *)(temp_ptr);
435 temp_ptr += (FRAME_LEN_LONG) * sizeof(FLOAT32);
436
437 pstr_scratch->p_adjthr_mdct_spec_float = (FLOAT32 *)(temp_ptr);
438 temp_ptr += (FRAME_LEN_LONG) * sizeof(FLOAT32);
439
440 pstr_scratch->p_adjthr_quant_spec_temp = (WORD16 *)(temp_ptr);
441 temp_ptr += (FRAME_LEN_LONG) * sizeof(WORD16);
442
443 pstr_scratch->p_degroup_scratch = (WORD32 *)(temp_ptr);
444 temp_ptr += (FRAME_LEN_LONG) * sizeof(WORD32);
445
446 /*Newly added*/
447 pstr_scratch->ptr_drc_scratch_buf = (UWORD8 *)(temp_ptr);
448
449 pstr_scratch->ptr_num_fac_bits = (WORD32 *)temp_ptr;
450 temp_ptr += MAX_TIME_CHANNELS * sizeof(pstr_scratch->ptr_num_fac_bits[0]);
451 pstr_scratch->ptr_tns_data_present = (WORD32 *)temp_ptr;
452 temp_ptr += MAX_TIME_CHANNELS * sizeof(pstr_scratch->ptr_tns_data_present[0]);
453
454 pstr_scratch->ptr_tmp_lp_res = (FLOAT32 *)temp_ptr;
455 temp_ptr += FAC_LENGTH * sizeof(pstr_scratch->ptr_tmp_lp_res[0]);
456
457 for (WORD32 i = 0; i < total_ch; i++) {
458 pstr_scratch->ptr_sfb_form_fac[i] = (FLOAT32 *)temp_ptr;
459 temp_ptr += (MAX_NUM_GROUPED_SFB) * sizeof(FLOAT32);
460 }
461 for (WORD32 i = 0; i < total_ch; i++) {
462 pstr_scratch->ptr_sfb_num_relevant_lines[i] = (FLOAT32 *)temp_ptr;
463 temp_ptr += (MAX_NUM_GROUPED_SFB) * sizeof(FLOAT32);
464 }
465 for (WORD32 i = 0; i < total_ch; i++) {
466 pstr_scratch->ptr_sfb_ld_energy[i] = (FLOAT32 *)temp_ptr;
467 temp_ptr += (MAX_NUM_GROUPED_SFB) * sizeof(FLOAT32);
468 }
469 pstr_scratch->ptr_num_scfs = (WORD32 *)temp_ptr;
470 temp_ptr += (MAX_TIME_CHANNELS) * sizeof(pstr_scratch->ptr_num_scfs[0]);
471
472 pstr_scratch->ptr_max_ch_dyn_bits = (WORD32 *)temp_ptr;
473 temp_ptr += (MAX_TIME_CHANNELS) * sizeof(pstr_scratch->ptr_max_ch_dyn_bits[0]);
474 pstr_scratch->ptr_ch_bit_dist = (FLOAT32 *)temp_ptr;
475 temp_ptr += (MAX_TIME_CHANNELS) * sizeof(pstr_scratch->ptr_ch_bit_dist[0]);
476 pstr_scratch->ptr_fd_scratch = (UWORD8 *)temp_ptr;
477 // Size needed for above pointer is (IXHEAACE_MAX_CH_IN_BS_ELE * MAX_NUM_GROUPED_SFB * 3) *
478 // sizeof(WORD32)
479
480 return;
481 }
482
iusace_limitbitrate(WORD32 core_sample_rate,WORD32 frame_len,WORD32 num_ch,WORD32 bit_rate)483 WORD32 iusace_limitbitrate(WORD32 core_sample_rate, WORD32 frame_len, WORD32 num_ch,
484 WORD32 bit_rate) {
485 WORD32 transport_bits, prev_bit_rate, shift = 0, iter = 0;
486
487 while ((frame_len & ~((1 << (shift + 1)) - 1)) == frame_len &&
488 (core_sample_rate & ~((1 << (shift + 1)) - 1)) == core_sample_rate) {
489 shift++;
490 }
491
492 do {
493 prev_bit_rate = bit_rate;
494 /* Assume some worst case */
495 transport_bits = 208;
496
497 bit_rate =
498 MAX(bit_rate, ((((40 * num_ch) + transport_bits) * (core_sample_rate)) / frame_len));
499 bit_rate =
500 MIN(bit_rate, ((num_ch * 6144) * (core_sample_rate >> shift)) / (frame_len >> shift));
501
502 } while (prev_bit_rate != bit_rate && iter++ < 3);
503
504 return bit_rate;
505 }
506
iusace_map_sample_rate(WORD32 sample_rate)507 WORD32 iusace_map_sample_rate(WORD32 sample_rate)
508 {
509 WORD32 mapped_sample_rate = sample_rate;
510
511 if ((mapped_sample_rate >= 0) && (mapped_sample_rate < 9391))
512 {
513 mapped_sample_rate = 8000;
514 }
515 else if ((mapped_sample_rate >= 9391) && (mapped_sample_rate < 11502))
516 {
517 mapped_sample_rate = 11025;
518 }
519 else if ((mapped_sample_rate >= 11502) && (mapped_sample_rate < 13856))
520 {
521 mapped_sample_rate = 12000;
522 }
523 else if ((mapped_sample_rate >= 13856) && (mapped_sample_rate < 18783))
524 {
525 mapped_sample_rate = 16000;
526 }
527 else if ((mapped_sample_rate >= 18783) && (mapped_sample_rate < 23004))
528 {
529 mapped_sample_rate = 22050;
530 }
531 else if ((mapped_sample_rate >= 23004) && (mapped_sample_rate < 27713))
532 {
533 mapped_sample_rate = 24000;
534 }
535 else if ((mapped_sample_rate >= 27713) && (mapped_sample_rate < 37566))
536 {
537 mapped_sample_rate = 32000;
538 }
539 else if ((mapped_sample_rate >= 37566) && (mapped_sample_rate < 46009))
540 {
541 mapped_sample_rate = 44100;
542 }
543 else if ((mapped_sample_rate >= 46009) && (mapped_sample_rate < 55426))
544 {
545 mapped_sample_rate = 48000;
546 }
547 else if ((mapped_sample_rate >= 55426) && (mapped_sample_rate < 75132))
548 {
549 mapped_sample_rate = 64000;
550 }
551 else if ((mapped_sample_rate >= 75132) && (mapped_sample_rate < 92017))
552 {
553 mapped_sample_rate = 88200;
554 }
555 else if (mapped_sample_rate >= 92017)
556 {
557 mapped_sample_rate = 96000;
558 }
559 else
560 {
561 mapped_sample_rate = 48000;
562 }
563 return mapped_sample_rate;
564 }
565
566 /**
567 * iusace_enc_init
568 *
569 * \brief Enocder initialization
570 *
571 * \param [in] ptr_usac_config Pointer to encoder config structure
572 * \param [in] ptr_asc Pointer to audio specific config strcuture
573 * \param [in] pstr_state Poniter to encoder handle structure
574 *
575 * \return IA_ERRORCODE Error code
576 */
iusace_enc_init(ia_usac_encoder_config_struct * ptr_usac_config,ixheaace_audio_specific_config_struct * pstr_asc,ia_usac_data_struct * pstr_state)577 IA_ERRORCODE iusace_enc_init(ia_usac_encoder_config_struct *ptr_usac_config,
578 ixheaace_audio_specific_config_struct *pstr_asc,
579 ia_usac_data_struct *pstr_state) {
580 IA_ERRORCODE err_code = IA_NO_ERROR;
581 WORD32 i, j, k, idx, i_ch;
582 UWORD32 elem_idx = 0;
583 ia_usac_data_struct *usac_data = (pstr_state);
584 ixheaace_audio_specific_config_struct *p_audio_specific_config = pstr_asc;
585 ia_usac_config_struct *pstr_asc_usac_config = &(p_audio_specific_config->str_usac_config);
586 WORD32 nbuff = 2048;
587 usac_data->usac_independency_flag_count = 0;
588 usac_data->usac_independency_flag_interval = 25;
589 usac_data->use_acelp_only = ptr_usac_config->use_acelp_only;
590 for (j = 0; j < MAX_TIME_CHANNELS; j++) {
591 memset(usac_data->overlap_buf[j], 0, nbuff * sizeof(FLOAT64 *));
592
593 usac_data->str_ms_info[j].ms_mask = 0;
594 for (i = 0; i < MAX_SHORT_WINDOWS; i++) {
595 for (k = 0; k < MAX_SFB_LONG; k++) {
596 usac_data->str_ms_info[j].ms_used[i][k] = 0;
597 }
598 }
599 }
600
601 iusace_scratch_mem_init(usac_data, ptr_usac_config->channels,
602 ptr_usac_config->core_sample_rate);
603
604 for (i = 0; i < MAX_TIME_CHANNELS; i++) {
605 if (ptr_usac_config->cmplx_pred_flag) {
606 usac_data->str_ms_info[i].ms_mask = 3;
607 }
608 usac_data->ptr_dmx_re_save[i] = &usac_data->arr_dmx_save_float[i][0];
609 usac_data->ptr_dmx_im[i] = &usac_data->arr_dmx_im[i][0];
610 }
611
612 pstr_asc_usac_config->num_elements = 0;
613 pstr_asc_usac_config->usac_cfg_ext_present = 0;
614 pstr_asc_usac_config->num_config_extensions = 0;
615
616 if (ptr_usac_config->channels > 0) {
617 if (ptr_usac_config->channels < 7) {
618 p_audio_specific_config->channel_configuration = ptr_usac_config->channels;
619 }
620 }
621 ia_usac_enc_element_config_struct *pstr_usac_elem_config =
622 &(pstr_asc_usac_config->str_usac_element_config[pstr_asc_usac_config->num_elements]);
623 pstr_asc_usac_config->usac_element_type[pstr_asc_usac_config->num_elements] = ID_USAC_EXT;
624 pstr_usac_elem_config->usac_ext_ele_type = ID_EXT_ELE_AUDIOPREROLL;
625 pstr_usac_elem_config->usac_ext_ele_dflt_len_present = 0;
626 pstr_usac_elem_config->usac_ext_ele_payload_present = 0;
627 pstr_usac_elem_config->usac_ext_ele_cfg_len = 0;
628 pstr_asc_usac_config->num_elements++;
629 // DRC Config
630 if (ptr_usac_config->use_drc_element) {
631 ptr_usac_config->str_drc_cfg.str_uni_drc_config.str_channel_layout.base_ch_count =
632 ptr_usac_config->channels;
633
634 memset(&usac_data->str_drc_state, 0, sizeof(ia_drc_enc_state));
635
636 err_code = impd_drc_enc_init(&usac_data->str_drc_state, pstr_state->str_scratch.drc_scratch,
637 &ptr_usac_config->str_drc_cfg);
638 if (err_code & IA_FATAL_ERROR) {
639 return err_code;
640 }
641 if (err_code) {
642 ptr_usac_config->use_drc_element = 0;
643 err_code = IA_NO_ERROR;
644 }
645
646 if (ptr_usac_config->use_drc_element) {
647 ia_usac_enc_element_config_struct *pstr_usac_elem_config =
648 &(pstr_asc_usac_config->str_usac_element_config[pstr_asc_usac_config->num_elements]);
649 pstr_asc_usac_config->usac_element_type[pstr_asc_usac_config->num_elements] = ID_USAC_EXT;
650 pstr_usac_elem_config->usac_ext_ele_type = ID_EXT_ELE_UNI_DRC;
651 pstr_usac_elem_config->usac_ext_ele_dflt_len_present = 0;
652 pstr_usac_elem_config->usac_ext_ele_payload_present = 0;
653 pstr_usac_elem_config->drc_config_data = usac_data->str_drc_state.bit_buf_base_cfg;
654 pstr_usac_elem_config->usac_ext_ele_cfg_len =
655 (usac_data->str_drc_state.drc_config_data_size_bit + 7) >> 3;
656 pstr_asc_usac_config->num_elements++;
657 }
658 } else {
659 err_code =
660 impd_loudness_info_init(&usac_data->str_drc_state, &ptr_usac_config->str_drc_cfg);
661 if (err_code) {
662 return err_code;
663 }
664 }
665
666 pstr_asc_usac_config->usac_config_ext_type[pstr_asc_usac_config->num_config_extensions] =
667 ID_CONFIG_EXT_STREAM_ID;
668 pstr_asc_usac_config->usac_config_ext_len[pstr_asc_usac_config->num_config_extensions] =
669 CONFIG_EXT_LEN_STREAM_ID;
670 pstr_asc_usac_config->num_config_extensions++;
671 pstr_asc_usac_config->stream_identifier = ptr_usac_config->stream_id;
672
673 pstr_asc_usac_config->usac_config_ext_type[pstr_asc_usac_config->num_config_extensions] =
674 ID_CONFIG_EXT_LOUDNESS_INFO;
675 pstr_asc_usac_config->usac_config_ext_len[pstr_asc_usac_config->num_config_extensions] =
676 (usac_data->str_drc_state.drc_config_ext_data_size_bit + 7) >> 3;
677 pstr_asc_usac_config->usac_config_ext_buf[pstr_asc_usac_config->num_config_extensions] =
678 usac_data->str_drc_state.bit_buf_base_cfg_ext;
679 pstr_asc_usac_config->num_config_extensions++;
680
681 if (pstr_asc_usac_config->num_config_extensions) {
682 pstr_asc_usac_config->usac_cfg_ext_present = 1;
683 }
684
685 p_audio_specific_config->sampling_frequency = ptr_usac_config->native_sample_rate;
686 p_audio_specific_config->num_audio_channels = ptr_usac_config->channels;
687 elem_idx = pstr_asc_usac_config->num_elements;
688 ptr_usac_config->num_ext_elements = elem_idx;
689 pstr_asc_usac_config->num_ext_elements = elem_idx;
690 i = elem_idx;
691
692 if (ptr_usac_config->channels != 0) {
693 ptr_usac_config->num_elements = iusace_get_num_elements(ptr_usac_config->channels);
694 pstr_asc_usac_config->num_elements += ptr_usac_config->num_elements;
695
696 for (; i < (WORD32)pstr_asc_usac_config->num_elements; i++) {
697 pstr_asc_usac_config->usac_element_type[i] = iusace_get_element_type(
698 (i - ptr_usac_config->num_ext_elements), ptr_usac_config->channels);
699 }
700 }
701
702 WORD32 count = ptr_usac_config->num_elements;
703 ptr_usac_config->num_elements = pstr_asc_usac_config->num_elements;
704 iusace_qc_create(&usac_data->str_qc_main);
705
706 if (count > 2) {
707 WORD32 num_mono = 0, num_stereo = 0, num_lfe = 0;
708
709 for (WORD8 ch_idx = 0; ch_idx < count; ch_idx++) {
710 switch (
711 pstr_asc_usac_config->usac_element_type[ch_idx + ptr_usac_config->num_ext_elements]) {
712 case ID_USAC_SCE:
713 num_mono++;
714 break;
715 case ID_USAC_CPE:
716 num_stereo++;
717 break;
718 case ID_USAC_EXT:
719 break;
720 default:
721 return IA_EXHEAACE_INIT_FATAL_USAC_INVALID_ELEMENT_TYPE;
722 }
723 }
724
725 WORD32 bitrate_per_stereo = (WORD32)((ptr_usac_config->basic_bitrate - (num_lfe)*8000) /
726 (num_mono * 0.625 + num_stereo));
727 WORD32 bitrate_per_mono = (WORD32)(0.625 * bitrate_per_stereo);
728
729 for (WORD8 ch_idx = 0; ch_idx < count; ch_idx++) {
730 switch (
731 pstr_asc_usac_config->usac_element_type[ch_idx + ptr_usac_config->num_ext_elements]) {
732 case ID_USAC_SCE:
733 usac_data->str_qc_main.str_qc_data[ch_idx].ch_bitrate = bitrate_per_mono;
734 break;
735 case ID_USAC_CPE:
736 usac_data->str_qc_main.str_qc_data[ch_idx].ch_bitrate = bitrate_per_stereo;
737 break;
738 case ID_USAC_EXT:
739 break;
740 default:
741 return IA_EXHEAACE_INIT_FATAL_USAC_INVALID_ELEMENT_TYPE;
742 }
743
744 usac_data->str_qc_main.str_qc_data[ch_idx].num_ch = 1;
745 if (ID_USAC_CPE ==
746 pstr_asc_usac_config->usac_element_type[ch_idx + ptr_usac_config->num_ext_elements]) {
747 usac_data->str_qc_main.str_qc_data[ch_idx].num_ch = 2;
748 }
749
750 usac_data->str_qc_main.str_qc_data[ch_idx].ch_bitrate =
751 MIN(360000 * usac_data->str_qc_main.str_qc_data[ch_idx].num_ch,
752 usac_data->str_qc_main.str_qc_data[ch_idx].ch_bitrate);
753 usac_data->str_qc_main.str_qc_data[ch_idx].ch_bitrate =
754 MAX(8000 * usac_data->str_qc_main.str_qc_data[ch_idx].num_ch,
755 usac_data->str_qc_main.str_qc_data[ch_idx].ch_bitrate);
756
757 usac_data->str_qc_main.str_qc_data[ch_idx].ch_bitrate =
758 iusace_limitbitrate(ptr_usac_config->core_sample_rate, 512,
759 usac_data->str_qc_main.str_qc_data[ch_idx].num_ch,
760 usac_data->str_qc_main.str_qc_data[ch_idx].ch_bitrate);
761
762 usac_data->str_qc_main.str_qc_data[ch_idx].avg_bits =
763 (usac_data->str_qc_main.str_qc_data[ch_idx].ch_bitrate * ptr_usac_config->ccfl) /
764 ptr_usac_config->core_sample_rate;
765 }
766 } else {
767 for (WORD8 ch_idx = 0; ch_idx < count; ch_idx++) {
768 usac_data->str_qc_main.str_qc_data[ch_idx].num_ch = (WORD8)ptr_usac_config->channels;
769 usac_data->str_qc_main.str_qc_data[ch_idx].ch_bitrate = ptr_usac_config->basic_bitrate;
770 usac_data->str_qc_main.str_qc_data[ch_idx].avg_bits =
771 (usac_data->str_qc_main.str_qc_data[ch_idx].ch_bitrate * ptr_usac_config->ccfl) /
772 ptr_usac_config->core_sample_rate;
773 }
774 }
775
776 for (i_ch = 0;
777 i_ch < (WORD32)(ptr_usac_config->num_elements - ptr_usac_config->num_ext_elements);
778 i_ch++) {
779 iusace_bw_init(ptr_usac_config, p_audio_specific_config, i_ch);
780
781 usac_data->noise_filling[i_ch] = ptr_usac_config->flag_noiseFilling;
782 }
783
784 memset(&usac_data->str_psy_mod.str_psy_out_data, 0,
785 sizeof(ia_psy_mod_out_data_struct) * MAX_TIME_CHANNELS);
786
787 i_ch = 0;
788 for (UWORD32 ch_idx = 0;
789 ch_idx < pstr_asc_usac_config->num_elements - ptr_usac_config->num_ext_elements;
790 ch_idx++) {
791 iusace_psy_mod_init(
792 &usac_data->str_psy_mod,
793 ((LEN_SUPERFRAME_768 == ptr_usac_config->ccfl) && (0 == ptr_usac_config->sbr_enable)) ?
794 (iusace_map_sample_rate((ptr_usac_config->core_sample_rate * 4) / 3)) :
795 (ptr_usac_config->core_sample_rate),
796 usac_data->str_qc_main.str_qc_data[ch_idx].ch_bitrate, ptr_usac_config->bw_limit[ch_idx],
797 usac_data->str_qc_main.str_qc_data[ch_idx].num_ch, i_ch, ch_idx, ptr_usac_config->ccfl);
798 i_ch += usac_data->str_qc_main.str_qc_data[ch_idx].num_ch;
799 }
800
801 for (; elem_idx < pstr_asc_usac_config->num_elements; elem_idx++) {
802 idx = elem_idx - pstr_asc_usac_config->num_ext_elements;
803 pstr_asc_usac_config->str_usac_element_config[elem_idx].noise_filling =
804 usac_data->noise_filling[idx];
805 usac_data->channel_elem_type[idx] = pstr_asc_usac_config->usac_element_type[elem_idx];
806 }
807
808 if (ptr_usac_config->use_fill_element) {
809 ia_usac_enc_element_config_struct *pstr_usac_elem_config =
810 &(pstr_asc_usac_config->str_usac_element_config[pstr_asc_usac_config->num_elements]);
811 pstr_asc_usac_config->usac_element_type[pstr_asc_usac_config->num_elements] = ID_USAC_EXT;
812 pstr_usac_elem_config->usac_ext_ele_type = ID_EXT_ELE_FILL;
813 pstr_usac_elem_config->usac_ext_ele_cfg_len = 0;
814 pstr_usac_elem_config->usac_ext_ele_dflt_len_present = 0;
815 pstr_usac_elem_config->usac_ext_ele_payload_present = 0;
816 pstr_asc_usac_config->num_elements++;
817 ptr_usac_config->num_ext_elements++;
818 ptr_usac_config->num_elements++;
819 }
820
821 if (ptr_usac_config->codec_mode == USAC_SWITCHED) {
822 iusace_init_classification(&usac_data->str_sig_class_data);
823 }
824
825 i_ch = 0;
826 for (UWORD32 ch_idx = 0;
827 ch_idx < pstr_asc_usac_config->num_elements - ptr_usac_config->num_ext_elements;
828 ch_idx++) {
829 for (idx = 0; idx < usac_data->str_qc_main.str_qc_data[ch_idx].num_ch; idx++, i_ch++) {
830 iusace_init_block_switching(&usac_data->block_switch_ctrl[i_ch],
831 usac_data->str_qc_main.str_qc_data[ch_idx].ch_bitrate,
832 usac_data->str_qc_main.str_qc_data[ch_idx].num_ch);
833 }
834 }
835
836 pstr_asc_usac_config->str_usac_element_config[elem_idx].stereo_config_index = 0;
837
838 for (i_ch = 0; i_ch < ptr_usac_config->channels; i_ch++) {
839 ptr_usac_config->window_sequence[i_ch] = ONLY_LONG_SEQUENCE;
840 ptr_usac_config->window_shape_prev[i_ch] = WIN_SEL_0;
841 }
842
843 for (i_ch = 0; i_ch < ptr_usac_config->channels; i_ch++) {
844 memset(usac_data->td_in_buf[i_ch], 0,
845 (FRAME_LEN_LONG + LEN_NEXT_HIGH_RATE) * sizeof(usac_data->td_in_buf[i_ch][0]));
846 }
847
848 usac_data->max_bitreservoir_bits = MAX_CHANNEL_BITS * ptr_usac_config->channels;
849 usac_data->available_bitreservoir_bits = usac_data->max_bitreservoir_bits;
850 usac_data->available_bitreservoir_bits -=
851 (ptr_usac_config->bit_rate * ptr_usac_config->ccfl) / ptr_usac_config->core_sample_rate;
852
853 if (usac_data->available_bitreservoir_bits < 0) {
854 return IA_EXHEAACE_INIT_FATAL_USAC_BITRES_SIZE_TOO_SMALL;
855 }
856 i_ch = 0;
857 for (UWORD32 ch_idx = 0;
858 ch_idx < pstr_asc_usac_config->num_elements - ptr_usac_config->num_ext_elements;
859 ch_idx++) {
860 for (idx = 0; idx < usac_data->str_qc_main.str_qc_data[ch_idx].num_ch; idx++, i_ch++) {
861 usac_data->td_encoder[i_ch]->max_sfb_short =
862 usac_data->str_psy_mod.str_psy_short_config[ch_idx].sfb_count;
863 if (ptr_usac_config->tns_select == 0) {
864 usac_data->pstr_tns_info[i_ch] = NULL;
865 } else {
866 usac_data->pstr_tns_info[i_ch]->sfb_offset_table_short =
867 usac_data->str_psy_mod.str_psy_short_config[ch_idx].sfb_offset;
868 usac_data->pstr_tns_info[i_ch]->sfb_offset_table_long =
869 usac_data->str_psy_mod.str_psy_long_config[ch_idx].sfb_offset;
870 usac_data->pstr_tns_info[i_ch]->max_sfb_short =
871 usac_data->str_psy_mod.str_psy_short_config[ch_idx].sfb_count;
872 usac_data->pstr_tns_info[i_ch]->max_sfb_long =
873 usac_data->str_psy_mod.str_psy_long_config[ch_idx].sfb_count;
874
875 err_code = iusace_tns_init(ptr_usac_config->core_sample_rate,
876 usac_data->str_qc_main.str_qc_data[ch_idx].ch_bitrate /
877 usac_data->str_qc_main.str_qc_data[ch_idx].num_ch,
878 usac_data->pstr_tns_info[i_ch],
879 usac_data->str_qc_main.str_qc_data[ch_idx].num_ch);
880 if (err_code) {
881 return err_code;
882 }
883 }
884 }
885 }
886
887 for (i = 0; i < MAX_TIME_CHANNELS; i++) usac_data->str_quant_info[i].reset = 1;
888
889 if (ptr_usac_config->codec_mode == USAC_SWITCHED ||
890 ptr_usac_config->codec_mode == USAC_ONLY_TD) {
891 for (i_ch = 0; i_ch < ptr_usac_config->channels; i_ch++) {
892 if ((ptr_usac_config->core_sample_rate) < SR_MIN ||
893 (ptr_usac_config->core_sample_rate) > SR_MAX) {
894 return IA_EXHEAACE_CONFIG_FATAL_USAC_SAMP_FREQ;
895 } else {
896 usac_data->td_encoder[i_ch]->fscale = ptr_usac_config->core_sample_rate;
897
898 iusace_init_td_data(usac_data->td_encoder[i_ch], ptr_usac_config->ccfl);
899 }
900
901 usac_data->td_bitrate[i_ch] = ptr_usac_config->bit_rate;
902 usac_data->td_bitrate[i_ch] /= ptr_usac_config->channels;
903 iusace_config_acelp_core_mode(usac_data->td_encoder[i_ch],
904 ptr_usac_config->core_sample_rate,
905 usac_data->td_bitrate[i_ch]);
906
907 usac_data->acelp_core_mode[i_ch] = (usac_data->td_encoder[i_ch])->acelp_core_mode;
908 if (ptr_usac_config->core_sample_rate == 8000) {
909 usac_data->use_acelp_only = 1;
910 }
911 }
912 } else {
913 usac_data->acelp_core_mode[0] = 0;
914 }
915
916 for (UWORD32 ch = 0;
917 ch < pstr_asc_usac_config->num_elements - ptr_usac_config->num_ext_elements; ch++) {
918 iusace_qc_init(&usac_data->str_qc_main.str_qc_data[ch], MAX_CHANNEL_BITS,
919 ptr_usac_config->core_sample_rate, ptr_usac_config->bw_limit[ch],
920 usac_data->str_qc_main.str_qc_data[ch].num_ch, ptr_usac_config->ccfl);
921 }
922
923 return err_code;
924 }
925
iexheaax_append_bitstream(ixheaace_bit_buf_handle hdl_bitbuf_write,ixheaace_bit_buf_handle hdl_bitbuf_read,WORD32 num_bits)926 static WORD32 iexheaax_append_bitstream(ixheaace_bit_buf_handle hdl_bitbuf_write,
927 ixheaace_bit_buf_handle hdl_bitbuf_read,
928 WORD32 num_bits) {
929 WORD32 idx;
930 UWORD32 value;
931
932 if (num_bits > 16) {
933 WORD32 cnt, rem;
934 cnt = num_bits >> 4;
935 rem = num_bits % 16;
936
937 for (idx = 0; idx < cnt; idx++) {
938 value = ixheaace_readbits(hdl_bitbuf_read, 16);
939 ixheaace_write_bits(hdl_bitbuf_write, value, 16);
940 }
941 if (rem) {
942 value = ixheaace_readbits(hdl_bitbuf_read, (UWORD8)rem);
943 ixheaace_write_bits(hdl_bitbuf_write, value, (UWORD8)rem);
944 }
945 } else {
946 value = ixheaace_readbits(hdl_bitbuf_read, (UWORD8)num_bits);
947 ixheaace_write_bits(hdl_bitbuf_write, value, (UWORD8)num_bits);
948 }
949
950 return num_bits;
951 }
952
iusace_enc_ext_elemts(UWORD32 usac_ext_ele_type,ia_usac_encoder_config_struct * pstr_usac_config,ia_usac_data_struct * pstr_usac_data,ixheaace_audio_specific_config_struct * pstr_asc,FLOAT32 ** pptr_input,ia_bit_buf_struct * it_bit_buff,WORD32 * num_bits_written)953 static IA_ERRORCODE iusace_enc_ext_elemts(UWORD32 usac_ext_ele_type,
954 ia_usac_encoder_config_struct *pstr_usac_config,
955 ia_usac_data_struct *pstr_usac_data,
956 ixheaace_audio_specific_config_struct *pstr_asc,
957 FLOAT32 **pptr_input, ia_bit_buf_struct *it_bit_buff,
958 WORD32 *num_bits_written) {
959 WORD8 idx = 0;
960 LOOPIDX idx_2 = 0;
961 WORD32 num_bits_payload = 0;
962 WORD32 num_byts_payload = 0;
963 ia_usac_config_struct *pstr_asc_usac_config = &(pstr_asc->str_usac_config);
964 VOID *pstr_scratch = &pstr_usac_data->str_scratch;
965 IA_ERRORCODE err_code = IA_NO_ERROR;
966
967 for (idx = 0; idx < (WORD32)pstr_asc_usac_config->num_elements; idx++) {
968 if (ID_USAC_EXT != pstr_asc_usac_config->usac_element_type[idx]) {
969 continue;
970 }
971
972 ia_usac_enc_element_config_struct *pstr_usac_elem_config =
973 &(pstr_asc_usac_config->str_usac_element_config[idx]);
974
975 if (usac_ext_ele_type != pstr_usac_elem_config->usac_ext_ele_type) {
976 continue;
977 }
978
979 switch (pstr_usac_elem_config->usac_ext_ele_type) {
980 case ID_EXT_ELE_UNI_DRC: {
981 if (pstr_usac_data->str_drc_state.is_first_drc_process_complete == 0) {
982 iusace_reset_bit_buffer(&pstr_usac_data->str_drc_state.str_bit_buf_out);
983 err_code = impd_drc_enc(&pstr_usac_data->str_drc_state, pptr_input, 0,
984 &num_bits_payload, pstr_scratch);
985 if (err_code) {
986 return err_code;
987 }
988 pstr_usac_data->str_drc_state.is_first_drc_process_complete = 1;
989 num_bits_payload = 0;
990 }
991
992 iusace_reset_bit_buffer(&pstr_usac_data->str_drc_state.str_bit_buf_out);
993 err_code =
994 impd_drc_enc(&pstr_usac_data->str_drc_state, pptr_input,
995 pstr_usac_config->drc_frame_size, &num_bits_payload, pstr_scratch);
996 if (err_code) {
997 return err_code;
998 }
999 num_byts_payload = (num_bits_payload + 7) >> 3;
1000 } break;
1001 default: {
1002 } break;
1003 }
1004
1005 if (num_byts_payload <= 0) {
1006 *num_bits_written += iusace_write_bits_buf(it_bit_buff, 0, 1); // usacExtElementPresent
1007 } else {
1008 *num_bits_written += iusace_write_bits_buf(it_bit_buff, 1, 1); // usacExtElementPresent
1009
1010 *num_bits_written +=
1011 iusace_write_bits_buf(it_bit_buff, 0, 1); // usacExtElementUseDefaultLength
1012
1013 if (num_byts_payload >= 255) {
1014 *num_bits_written +=
1015 iusace_write_bits_buf(it_bit_buff, 255, 8); // usacExtElementPayloadLength
1016
1017 UWORD16 value_add = (UWORD16)(num_byts_payload - 255 + 2);
1018 *num_bits_written += iusace_write_bits_buf(it_bit_buff, value_add, 16);
1019 } else {
1020 *num_bits_written += iusace_write_bits_buf(it_bit_buff, num_byts_payload,
1021 8); // usacExtElementPayloadLength
1022 }
1023
1024 switch (pstr_usac_elem_config->usac_ext_ele_type) {
1025 case ID_EXT_ELE_UNI_DRC: {
1026 for (idx_2 = 0; idx_2 < num_byts_payload; idx_2++) {
1027 *num_bits_written += iusace_write_bits_buf(
1028 it_bit_buff, pstr_usac_data->str_drc_state.bit_buf_base_out[idx_2], 8);
1029 }
1030 } break;
1031 default: {
1032 } break;
1033 }
1034 }
1035 }
1036
1037 return err_code;
1038 }
1039
ixheaace_usac_encode(FLOAT32 ** ptr_input,ia_usac_encoder_config_struct * ptr_usac_config,ia_usac_data_struct * pstr_state,ixheaace_audio_specific_config_struct * pstr_asc,ia_bit_buf_struct * pstr_it_bit_buff,ixheaace_pstr_sbr_enc ptr_env_encoder,FLOAT32 ** pp_drc_inp,WORD32 * is_quant_spec_zero,WORD32 * is_gain_limited)1040 IA_ERRORCODE ixheaace_usac_encode(FLOAT32 **ptr_input,
1041 ia_usac_encoder_config_struct *ptr_usac_config,
1042 ia_usac_data_struct *pstr_state,
1043 ixheaace_audio_specific_config_struct *pstr_asc,
1044 ia_bit_buf_struct *pstr_it_bit_buff,
1045 ixheaace_pstr_sbr_enc ptr_env_encoder, FLOAT32 **pp_drc_inp,
1046 WORD32 *is_quant_spec_zero, WORD32 *is_gain_limited) {
1047 IA_ERRORCODE err = IA_NO_ERROR;
1048 WORD32 i_ch, i, k;
1049 ia_usac_data_struct *ptr_usac_data = pstr_state;
1050 iusace_scratch_mem *pstr_scratch = &ptr_usac_data->str_scratch;
1051 WORD32 bits_written = 0;
1052
1053 WORD32 *next_window_sequence = pstr_scratch->ptr_next_win_scratch;
1054 WORD32 *new_win_seq = pstr_scratch->ptr_next_win_scratch + MAX_TIME_CHANNELS;
1055 memset(next_window_sequence, 0, MAX_TIME_CHANNELS * sizeof(next_window_sequence));
1056 memset(new_win_seq, 0, MAX_TIME_CHANNELS * sizeof(new_win_seq));
1057 ia_sfb_params_struct *pstr_sfb_prms = &ptr_usac_config->str_sfb_prms;
1058 memset(pstr_sfb_prms, 0, sizeof(ia_sfb_params_struct));
1059
1060 WORD32 *num_window_groups = pstr_sfb_prms->num_window_groups;
1061 WORD32 average_bits_total;
1062 WORD32 num_bits;
1063 WORD32 padding_bits;
1064 WORD32 *common_win = pstr_sfb_prms->common_win;
1065 WORD32 usac_independency_flg;
1066 WORD32 mod[NUM_FRAMES] = {0};
1067 WORD32 len_frame;
1068 WORD32 len_lpc0;
1069 WORD32 len_next_high_rate;
1070 WORD8 elem_idx, nr_core_coder_channels = 0, chn = 0;
1071 WORD32 ch_offset = 0;
1072 WORD32 elem_idx_max = ptr_usac_config->num_elements - ptr_usac_config->num_ext_elements;
1073 WORD32 td_buffer_offset = (TD_BUFFER_OFFSET * ptr_usac_config->ccfl) / FRAME_LEN_LONG;
1074 usac_independency_flg = ptr_usac_data->usac_independency_flag;
1075
1076 len_frame = ptr_usac_config->ccfl;
1077 len_lpc0 = (LEN_LPC0 * len_frame) / FRAME_LEN_LONG;
1078 len_next_high_rate = (LEN_NEXT_HIGH_RATE * len_frame) / FRAME_LEN_LONG;
1079
1080 average_bits_total =
1081 (ptr_usac_config->bit_rate * ptr_usac_config->ccfl) / ptr_usac_config->core_sample_rate;
1082
1083 ptr_usac_data->min_bits_needed =
1084 (long)(ptr_usac_data->available_bitreservoir_bits + 2 * average_bits_total -
1085 ptr_usac_data->max_bitreservoir_bits);
1086 if (ptr_usac_data->min_bits_needed < 0) {
1087 ptr_usac_data->min_bits_needed = 0;
1088 }
1089
1090 num_bits = 0;
1091 if (ptr_usac_config->preroll_flag) {
1092 if (ptr_usac_config->iframes_interval != ptr_usac_config->num_preroll_frames) {
1093 iusace_write_bits_buf(pstr_it_bit_buff, usac_independency_flg, 1);
1094 num_bits++;
1095 }
1096 } else {
1097 iusace_write_bits_buf(pstr_it_bit_buff, usac_independency_flg, 1);
1098 num_bits++;
1099 }
1100 for (elem_idx = 0; elem_idx < elem_idx_max; elem_idx++) {
1101 switch (ptr_usac_data->channel_elem_type[elem_idx]) {
1102 case USAC_ELEMENT_TYPE_SCE:
1103 nr_core_coder_channels = 1;
1104 break;
1105 case USAC_ELEMENT_TYPE_CPE:
1106 nr_core_coder_channels = 2;
1107 break;
1108 }
1109
1110 if (ptr_usac_data->core_mode[0] == CORE_MODE_FD) {
1111 for (chn = 0, i_ch = ch_offset; chn < nr_core_coder_channels; chn++, i_ch++) {
1112 iusace_block_switching(&ptr_usac_data->block_switch_ctrl[i_ch], ptr_input[i_ch],
1113 ptr_usac_config->ccfl);
1114 }
1115 }
1116
1117 i_ch = ch_offset;
1118 if (nr_core_coder_channels == 2) {
1119 iusace_sync_block_switching(&ptr_usac_data->block_switch_ctrl[i_ch],
1120 &ptr_usac_data->block_switch_ctrl[i_ch + 1]);
1121 }
1122
1123 for (chn = 0, i_ch = ch_offset; chn < nr_core_coder_channels; chn++, i_ch++) {
1124 switch (ptr_usac_config->codec_mode) {
1125 case USAC_SWITCHED:
1126 if (ptr_usac_data->str_sig_class_data.coding_mode == 2) {
1127 ptr_usac_data->core_mode_next[i_ch] = CORE_MODE_FD;
1128 } else {
1129 ptr_usac_data->core_mode_next[i_ch] = CORE_MODE_TD;
1130 }
1131 break;
1132 case USAC_ONLY_FD:
1133 ptr_usac_data->core_mode_next[i_ch] = CORE_MODE_FD;
1134 break;
1135 case USAC_ONLY_TD:
1136 ptr_usac_data->core_mode_next[i_ch] = CORE_MODE_TD;
1137 break;
1138 default:
1139 return IA_EXHEAACE_INIT_FATAL_USAC_INVALID_CODEC_MODE;
1140 }
1141 if (ptr_usac_data->core_mode[i_ch] == CORE_MODE_TD) {
1142 for (i = 0; i < ptr_usac_config->ccfl; i++) {
1143 ptr_usac_data->ptr_2frame_time_data[i_ch][i] = ptr_usac_data->ptr_time_data[i_ch][i];
1144 ptr_usac_data->ptr_2frame_time_data[i_ch][ptr_usac_config->ccfl + i] =
1145 ptr_usac_data->ptr_look_ahead_time_data[i_ch][i];
1146 ptr_usac_data->ptr_time_data[i_ch][i] =
1147 ptr_usac_data->ptr_look_ahead_time_data[i_ch][i];
1148 ptr_usac_data->ptr_look_ahead_time_data[i_ch][i] = (FLOAT64)ptr_input[i_ch][i];
1149 }
1150 } else {
1151 for (i = 0; i < ptr_usac_config->ccfl; i++) {
1152 ptr_usac_data->ptr_2frame_time_data[i_ch][i] = ptr_usac_data->ptr_time_data[i_ch][i];
1153 ptr_usac_data->ptr_2frame_time_data[i_ch][ptr_usac_config->ccfl + i] =
1154 ptr_usac_data->ptr_look_ahead_time_data[i_ch][i];
1155 ptr_usac_data->ptr_time_data[i_ch][i] = ptr_input[i_ch][i];
1156 ptr_usac_data->ptr_look_ahead_time_data[i_ch][i] = (FLOAT64)ptr_input[i_ch][i];
1157 }
1158 }
1159
1160 for (i = 0; i < len_frame + len_next_high_rate; i++) {
1161 ptr_usac_data->td_in_buf[i_ch][i] =
1162 (FLOAT32)(ptr_usac_data->ptr_2frame_time_data[i_ch][i + td_buffer_offset]);
1163 }
1164 for (i = 0; i < len_frame + len_next_high_rate + len_lpc0; i++) {
1165 ptr_usac_data->td_in_prev_buf[i_ch][i] =
1166 (FLOAT32)(ptr_usac_data->ptr_2frame_time_data[i_ch][i + td_buffer_offset - len_lpc0]);
1167 }
1168
1169 if (ptr_usac_data->core_mode[i_ch] == CORE_MODE_FD) {
1170 ptr_usac_data->window_size_samples[i_ch] = ptr_usac_config->ccfl;
1171 pstr_sfb_prms->window_sequence[i_ch] = ptr_usac_data->block_switch_ctrl[i_ch].window_seq;
1172 ptr_usac_config->window_sequence[i_ch] = pstr_sfb_prms->window_sequence[i_ch];
1173 new_win_seq[i_ch] = ptr_usac_data->block_switch_ctrl[i_ch].next_win_seq;
1174 }
1175
1176 err = iusace_sfb_params_init(((LEN_SUPERFRAME_768 == ptr_usac_config->ccfl) &&
1177 (0 == ptr_usac_config->sbr_enable)) ?
1178 (iusace_map_sample_rate((ptr_usac_config->core_sample_rate
1179 * 4) / 3)) :(ptr_usac_config->core_sample_rate),
1180 ptr_usac_config->ccfl, pstr_sfb_prms->sfb_width_table[i_ch],
1181 &pstr_sfb_prms->num_sfb[i_ch],
1182 pstr_sfb_prms->window_sequence[i_ch]);
1183
1184 if (err) {
1185 return err;
1186 }
1187
1188 pstr_sfb_prms->sfb_offset[i_ch][0] = 0;
1189 k = 0;
1190 for (i = 0; i < pstr_sfb_prms->num_sfb[i_ch]; i++) {
1191 pstr_sfb_prms->sfb_offset[i_ch][i] = k;
1192 k += pstr_sfb_prms->sfb_width_table[i_ch][i];
1193 }
1194 pstr_sfb_prms->sfb_offset[i_ch][i] = k;
1195
1196 if (ptr_usac_data->core_mode[i_ch] != CORE_MODE_TD) {
1197 next_window_sequence[i_ch] = new_win_seq[i_ch];
1198 if (ptr_usac_data->core_mode_next[i_ch] == CORE_MODE_TD) {
1199 next_window_sequence[i_ch] = EIGHT_SHORT_SEQUENCE;
1200 }
1201
1202 if (ptr_usac_data->core_mode[i_ch] == CORE_MODE_TD &&
1203 ptr_usac_data->core_mode_next[i_ch] != CORE_MODE_TD) {
1204 next_window_sequence[i_ch] = LONG_STOP_SEQUENCE;
1205 }
1206
1207 if (next_window_sequence[i_ch] == EIGHT_SHORT_SEQUENCE) {
1208 if (pstr_sfb_prms->window_sequence[i_ch] == ONLY_LONG_SEQUENCE) {
1209 pstr_sfb_prms->window_sequence[i_ch] = LONG_START_SEQUENCE;
1210 }
1211 if (pstr_sfb_prms->window_sequence[i_ch] == LONG_STOP_SEQUENCE) {
1212 pstr_sfb_prms->window_sequence[i_ch] = STOP_START_SEQUENCE;
1213 }
1214 }
1215
1216 if (next_window_sequence[i_ch] == ONLY_LONG_SEQUENCE) {
1217 if (pstr_sfb_prms->window_sequence[i_ch] == EIGHT_SHORT_SEQUENCE) {
1218 next_window_sequence[i_ch] = LONG_STOP_SEQUENCE;
1219 }
1220 }
1221
1222 if (pstr_sfb_prms->window_sequence[i_ch] == EIGHT_SHORT_SEQUENCE) {
1223 num_window_groups[i_ch] = ptr_usac_data->block_switch_ctrl[i_ch].tot_grps_cnt;
1224 for (i = 0; i < 8; i++) {
1225 pstr_sfb_prms->window_group_length[i_ch][i] =
1226 ptr_usac_data->block_switch_ctrl[i_ch].group_len[i];
1227 }
1228 } else {
1229 num_window_groups[i_ch] = 1;
1230 pstr_sfb_prms->window_group_length[i_ch][0] = 1;
1231 }
1232
1233 pstr_sfb_prms->window_shape[i_ch] = ptr_usac_config->window_shape_prev[i_ch];
1234
1235 err = iusace_fd_mdct(ptr_usac_data, ptr_usac_config, i_ch);
1236
1237 if (err) {
1238 return err;
1239 }
1240
1241 if (pstr_sfb_prms->window_sequence[i_ch] != EIGHT_SHORT_SEQUENCE) {
1242 iusace_psy_mod_lb(&ptr_usac_data->str_psy_mod, pstr_sfb_prms,
1243 ptr_usac_data->spectral_line_vector[i_ch],
1244 ptr_usac_data->pstr_tns_info, ptr_usac_config->tns_select, i_ch, chn,
1245 ptr_usac_data->channel_elem_type[elem_idx],
1246 pstr_scratch->p_tns_filter, elem_idx, pstr_scratch->ptr_tns_scratch,
1247 ptr_usac_config->ccfl);
1248 } else {
1249 iusace_psy_mod_sb(&(ptr_usac_data->str_psy_mod), pstr_sfb_prms,
1250 ptr_usac_data->spectral_line_vector[i_ch],
1251 ptr_usac_data->pstr_tns_info, ptr_usac_config->tns_select, i_ch, chn,
1252 ptr_usac_data->channel_elem_type[elem_idx],
1253 pstr_scratch->p_tns_filter, elem_idx, pstr_scratch->ptr_tns_scratch,
1254 ptr_usac_config->ccfl);
1255 }
1256
1257 pstr_sfb_prms->max_sfb[i_ch] =
1258 ptr_usac_data->str_psy_mod.str_psy_out_data[i_ch].max_sfb_per_grp;
1259 }
1260 }
1261 for (chn = 0, i_ch = ch_offset; chn < nr_core_coder_channels; chn++, i_ch++) {
1262 if (nr_core_coder_channels == 2) {
1263 if ((pstr_sfb_prms->window_shape[i_ch] == pstr_sfb_prms->window_shape[i_ch + 1]) &&
1264 (pstr_sfb_prms->window_sequence[i_ch] == pstr_sfb_prms->window_sequence[i_ch + 1]) &&
1265 (ptr_usac_data->core_mode[i_ch] == ptr_usac_data->core_mode[i_ch + 1])) {
1266 common_win[i_ch] = common_win[i_ch + 1] = 1;
1267 } else {
1268 common_win[i_ch] = 0;
1269 }
1270 chn++;
1271 } else {
1272 common_win[i_ch] = 0;
1273 }
1274 }
1275 if (nr_core_coder_channels == 2) {
1276 if (i_ch == (ch_offset + 1)) {
1277 if (pstr_sfb_prms->window_sequence[i_ch] != EIGHT_SHORT_SEQUENCE) {
1278 iusace_calc_ms_band_energy(
1279 ptr_usac_data->spectral_line_vector[ch_offset],
1280 ptr_usac_data->spectral_line_vector[ch_offset + 1],
1281 ptr_usac_data->str_psy_mod.str_psy_long_config[elem_idx].sfb_offset,
1282 ptr_usac_data->str_psy_mod.str_psy_long_config[elem_idx].sfb_active,
1283 ptr_usac_data->str_psy_mod.str_psy_data[ch_offset].ptr_sfb_energy_long_ms,
1284 ptr_usac_data->str_psy_mod.str_psy_data[ch_offset + 1].ptr_sfb_energy_long_ms);
1285 } else {
1286 WORD32 frame_len_short = (ptr_usac_config->ccfl * FRAME_LEN_SHORT_128) / FRAME_LEN_LONG;
1287 for (WORD32 w = 0; w < MAX_SHORT_WINDOWS; w++) {
1288 WORD32 w_offset = w * frame_len_short;
1289
1290 iusace_calc_ms_band_energy(
1291 ptr_usac_data->spectral_line_vector[ch_offset] + w_offset,
1292 ptr_usac_data->spectral_line_vector[ch_offset + 1] + w_offset,
1293 ptr_usac_data->str_psy_mod.str_psy_short_config[elem_idx].sfb_offset,
1294 ptr_usac_data->str_psy_mod.str_psy_short_config[elem_idx].sfb_active,
1295 ptr_usac_data->str_psy_mod.str_psy_data[ch_offset].ptr_sfb_energy_short_ms[w],
1296 ptr_usac_data->str_psy_mod.str_psy_data[ch_offset + 1]
1297 .ptr_sfb_energy_short_ms[w]);
1298 }
1299 }
1300 }
1301 }
1302 if ((nr_core_coder_channels == 2)
1303 ? ((ptr_usac_data->core_mode[ch_offset] == CORE_MODE_FD) &&
1304 (ptr_usac_data->core_mode[ch_offset + 1] == CORE_MODE_FD))
1305 : ((ptr_usac_data->core_mode[ch_offset] == CORE_MODE_FD))) {
1306 iusace_grouping(pstr_sfb_prms, nr_core_coder_channels, ptr_usac_data, ptr_usac_config,
1307 ch_offset, elem_idx);
1308
1309 if (nr_core_coder_channels == 2) {
1310 err = iusace_stereo_proc(pstr_sfb_prms, usac_independency_flg, ptr_usac_data,
1311 ptr_usac_config, ch_offset);
1312 if (err != IA_NO_ERROR) {
1313 return err;
1314 }
1315 }
1316 }
1317 if (ptr_usac_config->preroll_flag) {
1318 if (ptr_usac_config->iframes_interval != ptr_usac_config->num_preroll_frames) {
1319 iusace_write_bits_buf(pstr_it_bit_buff, 0, 1); // extension element present
1320 num_bits++;
1321 }
1322 }
1323 if (ptr_usac_config->use_drc_element) {
1324 WORD32 num_bits_ext_elem = 0;
1325 err = iusace_enc_ext_elemts(ID_EXT_ELE_UNI_DRC, ptr_usac_config, pstr_state, pstr_asc,
1326 pp_drc_inp, pstr_it_bit_buff, &num_bits_ext_elem);
1327 if (err & IA_FATAL_ERROR) {
1328 return err;
1329 }
1330 num_bits += num_bits_ext_elem;
1331 ptr_usac_data->num_drc_bits = num_bits_ext_elem;
1332 #ifdef DRC_BITRATE_CONSIDERATION
1333 ptr_usac_data->drc_data_bit_cnt = num_bits_ext_elem;
1334 #endif
1335 }
1336
1337 for (chn = 0, i_ch = ch_offset; chn < nr_core_coder_channels; chn++, i_ch++) {
1338 iusace_write_bits_buf(pstr_it_bit_buff, ptr_usac_data->core_mode[i_ch], 1);
1339 num_bits++;
1340 }
1341
1342 for (chn = 0, i_ch = ch_offset; chn < nr_core_coder_channels; chn++, i_ch++) {
1343 if (ptr_usac_data->core_mode[i_ch] == CORE_MODE_FD) {
1344 ptr_usac_data->window_size_samples[i_ch] = ptr_usac_config->ccfl;
1345 pstr_sfb_prms->window_sequence[i_ch] = ptr_usac_data->block_switch_ctrl[i_ch].window_seq;
1346 ptr_usac_config->window_sequence[i_ch] = pstr_sfb_prms->window_sequence[i_ch];
1347 new_win_seq[i_ch] = ptr_usac_data->block_switch_ctrl[i_ch].next_win_seq;
1348 }
1349
1350 if (ptr_usac_data->core_mode[i_ch] == CORE_MODE_TD) {
1351 WORD32 error;
1352
1353 error = iusace_lpd_frm_enc(ptr_usac_data, mod, usac_independency_flg, len_frame, i_ch,
1354 pstr_it_bit_buff);
1355 if (error) return error;
1356
1357 num_bits = pstr_it_bit_buff->cnt_bits;
1358
1359 if ((ptr_usac_data->core_mode_prev[i_ch] == CORE_MODE_FD) && (mod[0] == 0)) {
1360 for (i = 0; i < ptr_usac_data->num_td_fac_bits[i_ch]; i++) {
1361 iusace_write_bits_buf(pstr_it_bit_buff, ptr_usac_data->fac_out_stream[i_ch][i], 1);
1362 num_bits++;
1363 }
1364 }
1365 } else {
1366 next_window_sequence[i_ch] = new_win_seq[i_ch];
1367 if (ptr_usac_data->core_mode_next[i_ch] == CORE_MODE_TD) {
1368 next_window_sequence[i_ch] = EIGHT_SHORT_SEQUENCE;
1369 }
1370
1371 if (ptr_usac_data->core_mode[i_ch] == CORE_MODE_TD &&
1372 ptr_usac_data->core_mode_next[i_ch] != CORE_MODE_TD) {
1373 next_window_sequence[i_ch] = LONG_STOP_SEQUENCE;
1374 }
1375
1376 if (next_window_sequence[i_ch] == EIGHT_SHORT_SEQUENCE) {
1377 if (pstr_sfb_prms->window_sequence[i_ch] == ONLY_LONG_SEQUENCE) {
1378 pstr_sfb_prms->window_sequence[i_ch] = LONG_START_SEQUENCE;
1379 }
1380 if (pstr_sfb_prms->window_sequence[i_ch] == LONG_STOP_SEQUENCE) {
1381 pstr_sfb_prms->window_sequence[i_ch] = STOP_START_SEQUENCE;
1382 }
1383 }
1384 if (next_window_sequence[i_ch] == ONLY_LONG_SEQUENCE) {
1385 if (pstr_sfb_prms->window_sequence[i_ch] == EIGHT_SHORT_SEQUENCE) {
1386 next_window_sequence[i_ch] = LONG_STOP_SEQUENCE;
1387 }
1388 }
1389 if (pstr_sfb_prms->window_sequence[i_ch] == EIGHT_SHORT_SEQUENCE) {
1390 num_window_groups[i_ch] = ptr_usac_data->block_switch_ctrl[i_ch].tot_grps_cnt;
1391 for (i = 0; i < 8; i++) {
1392 pstr_sfb_prms->window_group_length[i_ch][i] =
1393 ptr_usac_data->block_switch_ctrl[i_ch].group_len[i];
1394 }
1395 } else {
1396 num_window_groups[i_ch] = 1;
1397 pstr_sfb_prms->window_group_length[i_ch][0] = 1;
1398 }
1399 pstr_sfb_prms->window_shape[i_ch] = ptr_usac_config->window_shape_prev[i_ch];
1400 }
1401 }
1402
1403 if ((nr_core_coder_channels == 2)
1404 ? ((ptr_usac_data->core_mode[ch_offset] == CORE_MODE_FD) &&
1405 (ptr_usac_data->core_mode[ch_offset + 1] == CORE_MODE_FD))
1406 : ((ptr_usac_data->core_mode[ch_offset] == CORE_MODE_FD))) {
1407 err = iusace_fd_encode(pstr_sfb_prms, usac_independency_flg, ptr_usac_data, ptr_usac_config,
1408 pstr_it_bit_buff, nr_core_coder_channels, ch_offset, elem_idx,
1409 &bits_written, is_quant_spec_zero, is_gain_limited);
1410
1411 if (err) {
1412 return err;
1413 }
1414
1415 num_bits += bits_written;
1416 }
1417
1418 for (chn = 0, i_ch = ch_offset; chn < nr_core_coder_channels; chn++, i_ch++) {
1419 ptr_usac_config->window_shape_prev[i_ch] = pstr_sfb_prms->window_shape[i_ch];
1420 ptr_usac_config->window_sequence_prev[i_ch] = ptr_usac_config->window_sequence[i_ch];
1421 ptr_usac_config->window_sequence[i_ch] = next_window_sequence[i_ch];
1422 ptr_usac_data->core_mode_prev[i_ch] = ptr_usac_data->core_mode[i_ch];
1423 ptr_usac_data->core_mode[i_ch] = ptr_usac_data->core_mode_next[i_ch];
1424 }
1425 ch_offset += nr_core_coder_channels;
1426 }
1427
1428 if (1 == ptr_usac_config->sbr_enable) {
1429 // Append SBR bits
1430 ixheaace_bit_buf_handle pstr_it_bit_buff_temp =
1431 &ptr_env_encoder->str_cmon_data.str_sbr_bit_buf;
1432 WORD32 check_num_bits = ia_enhaacplus_enc_get_bits_available(pstr_it_bit_buff_temp);
1433
1434 num_bits += iexheaax_append_bitstream((ixheaace_bit_buf_handle)pstr_it_bit_buff,
1435 pstr_it_bit_buff_temp, check_num_bits);
1436 }
1437
1438 if (ptr_usac_config->use_fill_element) {
1439 WORD32 full_elem_num_bits = 0;
1440 padding_bits = ptr_usac_data->min_bits_needed - num_bits;
1441 full_elem_num_bits = iusace_write_fill_ele(pstr_it_bit_buff, padding_bits);
1442 num_bits += full_elem_num_bits;
1443 }
1444
1445 ptr_usac_data->available_bitreservoir_bits -= num_bits;
1446
1447 if (num_bits % 8) {
1448 ptr_usac_data->available_bitreservoir_bits -= 8 - (num_bits % 8);
1449 }
1450 ptr_usac_data->available_bitreservoir_bits += average_bits_total;
1451
1452 if (ptr_usac_data->available_bitreservoir_bits > ptr_usac_data->max_bitreservoir_bits) {
1453 ptr_usac_data->available_bitreservoir_bits = ptr_usac_data->max_bitreservoir_bits;
1454 }
1455
1456 return err;
1457 }