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 <stdlib.h>
22 #include <string.h>
23 #include <math.h>
24 #include "ixheaac_type_def.h"
25 #include "impd_drc_common_enc.h"
26 #include "impd_drc_uni_drc.h"
27 #include "impd_drc_tables.h"
28 #include "impd_drc_api.h"
29 #include "ixheaace_api.h"
30 #include "ixheaac_error_standards.h"
31 #include "ixheaace_error_codes.h"
32 #include "ixheaace_mps_common_fix.h"
33 #include "ixheaace_mps_defines.h"
34 #include "ixheaace_mps_common_define.h"
35 #include "ixheaac_constants.h"
36 #include "ixheaace_bitbuffer.h"
37 #include "ixheaace_sbr_def.h"
38 #include "ixheaace_mps_buf.h"
39 #include "ixheaace_mps_lib.h"
40 #include "ixheaace_mps_main_structure.h"
41 #include "ixheaace_mps_bitstream.h"
42 #include "ixheaace_mps_onset_detect.h"
43 #include "ixheaace_mps_filter.h"
44 #include "ixheaace_mps_param_extract.h"
45 #include "ixheaace_mps_static_gain.h"
46
47 #include "ixheaace_mps_dmx_tdom_enh.h"
48 #include "ixheaace_mps_tools_rom.h"
49 #include "ixheaace_mps_qmf.h"
50 #include "ixheaace_mps_struct_def.h"
51 #include "ixheaace_mps_sac_polyphase.h"
52 #include "ixheaace_mps_sac_hybfilter.h"
53 #include "ixheaace_mps_spatial_bitstream.h"
54 #include "ixheaace_mps_tree.h"
55 #include "ixheaace_mps_rom.h"
56 #include "ixheaace_mps_delay.h"
57 #include "ixheaace_mps_frame_windowing.h"
58 #include "ixheaace_mps_structure.h"
59 #include "ixheaace_mps_memory.h"
60 #include "ixheaace_mps_enc.h"
61 #include "ixheaac_basic_ops32.h"
62 #include "ixheaac_basic_ops40.h"
63 #include "ixheaac_basic_ops.h"
64
ixheaace_mps_212_space_get_num_qmf_bands(const UWORD32 num_sample_rate)65 static UWORD8 ixheaace_mps_212_space_get_num_qmf_bands(const UWORD32 num_sample_rate) {
66 UWORD8 num_qmf_bands = 0;
67 if (num_sample_rate < 27713)
68 num_qmf_bands = 32;
69 else if (num_sample_rate < 55426)
70 num_qmf_bands = 64;
71
72 return num_qmf_bands;
73 }
74
ixheaace_mps_212_space_tree_open(ixheaace_mps_pstr_space_tree * pstr_ph_space_tree,ixheaace_mps_212_memory_struct * pstr_mps_memory)75 static VOID ixheaace_mps_212_space_tree_open(ixheaace_mps_pstr_space_tree *pstr_ph_space_tree,
76 ixheaace_mps_212_memory_struct *pstr_mps_memory) {
77 ixheaace_mps_pstr_space_tree pstr_space_tree = NULL;
78 WORD32 box;
79
80 pstr_space_tree = &pstr_mps_memory->spacce_tree;
81
82 for (box = 0; box < IXHEAACE_MPS_MAX_NUM_BOXES; box++) {
83 ixheaace_mps_pstr_tto_box pstr_tto_box = NULL;
84 pstr_tto_box = &pstr_mps_memory->tto_box;
85
86 if (NULL != pstr_space_tree) {
87 pstr_space_tree->pstr_tto_box[box] = pstr_tto_box;
88 }
89 }
90 *pstr_ph_space_tree = pstr_space_tree;
91 }
92
ixheaace_mps_212_init_num_param_bands(ixheaace_mps_pstr_space_structure pstr_space_enc,const WORD32 num_param_bands)93 static VOID ixheaace_mps_212_init_num_param_bands(
94 ixheaace_mps_pstr_space_structure pstr_space_enc, const WORD32 num_param_bands) {
95 WORD32 k = 0;
96 const WORD32 n = sizeof(valid_bands_ld) / sizeof(UWORD8);
97 const UWORD8 *p_bands = valid_bands_ld;
98
99 while (k < n && p_bands[k] != (UWORD8)num_param_bands) ++k;
100 if (k == n) {
101 pstr_space_enc->num_param_bands = IXHEAACE_MPS_SAC_BANDS_INVALID;
102 } else {
103 pstr_space_enc->num_param_bands = num_param_bands;
104 }
105 }
106
ixheaace_mps_212_configure(ixheaace_mps_pstr_space_structure pstr_space_enc,const ixheaace_mps_pstr_spece_enc_setup pstr_h_set_up)107 static IA_ERRORCODE ixheaace_mps_212_configure(
108 ixheaace_mps_pstr_space_structure pstr_space_enc,
109 const ixheaace_mps_pstr_spece_enc_setup pstr_h_set_up) {
110 IA_ERRORCODE error = IA_NO_ERROR;
111
112 pstr_space_enc->num_sample_rate = pstr_h_set_up->sample_rate;
113 pstr_space_enc->num_qmf_bands =
114 ixheaace_mps_212_space_get_num_qmf_bands(pstr_space_enc->num_sample_rate);
115 pstr_space_enc->time_alignment = pstr_h_set_up->time_alignment;
116 pstr_space_enc->quant_mode = pstr_h_set_up->quant_mode;
117
118 pstr_space_enc->use_coarse_quant_cld = pstr_h_set_up->b_use_coarse_quant;
119 pstr_space_enc->use_coarse_quant_cpc = pstr_h_set_up->b_use_coarse_quant;
120 pstr_space_enc->use_frame_keep = (pstr_h_set_up->b_ld_mode == 2);
121 pstr_space_enc->use_coarse_quant_icc = 0;
122 pstr_space_enc->use_coarse_quant_arb_dmx = 0;
123 pstr_space_enc->independency_factor = pstr_h_set_up->independency_factor;
124 pstr_space_enc->independency_count = 0;
125 pstr_space_enc->independency_flag = 1;
126
127 pstr_space_enc->num_hybrid_bands = pstr_space_enc->num_qmf_bands;
128 pstr_space_enc->num_frame_time_slots = pstr_h_set_up->frame_time_slots;
129 ixheaace_mps_212_init_num_param_bands(pstr_space_enc, pstr_h_set_up->num_param_bands);
130
131 return error;
132 }
133
ixheaace_mps_212_get_analysis_length_time_slots(FLOAT32 * ptr_frame_window_ana,WORD32 num_time_slots)134 static WORD32 ixheaace_mps_212_get_analysis_length_time_slots(FLOAT32 *ptr_frame_window_ana,
135 WORD32 num_time_slots) {
136 WORD32 i;
137 for (i = num_time_slots - 1; i >= 0; i--) {
138 if (ptr_frame_window_ana[i] != 0) {
139 break;
140 }
141 }
142 num_time_slots = i + 1;
143 return num_time_slots;
144 }
145
ixheaace_mps_212_get_analysis_start_time_slot(FLOAT32 * ptr_frame_window_ana,WORD32 num_time_slots)146 static WORD32 ixheaace_mps_212_get_analysis_start_time_slot(FLOAT32 *ptr_frame_window_ana,
147 WORD32 num_time_slots) {
148 WORD32 start_time_slot = 0;
149 WORD32 i;
150 for (i = 0; i < num_time_slots; i++) {
151 if (ptr_frame_window_ana[i] != 0) {
152 break;
153 }
154 }
155 start_time_slot = i;
156 return start_time_slot;
157 }
158
ixheaace_mps_212_memcpy_flex_pcm(FLOAT32 * const ptr_dst,const WORD32 dst_stride,const FLOAT32 * const ptr_src,const WORD32 src_stride,const WORD32 num_samples)159 static VOID ixheaace_mps_212_memcpy_flex_pcm(FLOAT32 *const ptr_dst, const WORD32 dst_stride,
160 const FLOAT32 *const ptr_src,
161 const WORD32 src_stride, const WORD32 num_samples) {
162 WORD32 i;
163
164 for (i = 0; i < num_samples; i++) {
165 ptr_dst[i * dst_stride] = ptr_src[i * src_stride];
166 }
167 }
168
ixheaace_mps_212_feed_de_inter_pre_scale(ixheaace_mps_pstr_space_structure pstr_space_enc,FLOAT32 const * const ptr_samples,FLOAT32 * const ptr_output_samples,WORD32 const num_samples,UWORD32 const is_input_inter_leaved,UWORD32 const input_buffer_size_per_channel,UWORD32 * const ptr_n_samples_fed)169 static IA_ERRORCODE ixheaace_mps_212_feed_de_inter_pre_scale(
170 ixheaace_mps_pstr_space_structure pstr_space_enc, FLOAT32 const *const ptr_samples,
171 FLOAT32 *const ptr_output_samples, WORD32 const num_samples,
172 UWORD32 const is_input_inter_leaved, UWORD32 const input_buffer_size_per_channel,
173 UWORD32 *const ptr_n_samples_fed) {
174 IA_ERRORCODE error = IA_NO_ERROR;
175 WORD32 ch;
176 const WORD32 num_ch_in = pstr_space_enc->n_input_channels;
177 const WORD32 num_ch_in_with_dmx = num_ch_in;
178 const WORD32 samples_to_feed =
179 MIN(num_samples, pstr_space_enc->n_samples_next - pstr_space_enc->n_samples_valid);
180 const WORD32 num_samples_per_channel = samples_to_feed / num_ch_in_with_dmx;
181
182 if ((samples_to_feed < 0) || (samples_to_feed % num_ch_in_with_dmx != 0) ||
183 (samples_to_feed > num_ch_in_with_dmx * (WORD32)pstr_space_enc->n_frame_length)) {
184 return IA_EXHEAACE_CONFIG_NONFATAL_MPS_INVALID_CONFIG;
185 }
186 const FLOAT32 *p_input_mps;
187 const FLOAT32 *p_input_2_mps;
188 {
189 p_input_mps = ptr_samples;
190 p_input_2_mps = ptr_samples + (pstr_space_enc->n_input_delay * num_ch_in_with_dmx);
191 }
192 for (ch = 0; ch < num_ch_in; ch++) {
193 memcpy(&(pstr_space_enc->time_signal_in[ch][0]),
194 &(pstr_space_enc->time_signal_delay_in[ch][0]),
195 pstr_space_enc->n_surround_analysis_buffer_delay * sizeof(FLOAT32));
196
197 if (is_input_inter_leaved) {
198 ixheaace_mps_212_memcpy_flex_pcm(
199 &(pstr_space_enc->time_signal_in[ch][pstr_space_enc->n_surround_analysis_buffer_delay]),
200 1, p_input_mps + ch, num_ch_in_with_dmx, pstr_space_enc->n_input_delay);
201 ixheaace_mps_212_memcpy_flex_pcm(
202 &(pstr_space_enc->time_signal_in[ch][pstr_space_enc->n_surround_analysis_buffer_delay +
203 pstr_space_enc->n_input_delay]),
204 1, p_input_2_mps + ch, num_ch_in_with_dmx,
205 num_samples_per_channel - pstr_space_enc->n_input_delay);
206 } else {
207 memcpy(
208 &(pstr_space_enc->time_signal_in[ch][pstr_space_enc->n_surround_analysis_buffer_delay]),
209 p_input_mps + ch * input_buffer_size_per_channel,
210 pstr_space_enc->n_input_delay * sizeof(FLOAT32));
211 memcpy(
212 &(pstr_space_enc->time_signal_in[ch][pstr_space_enc->n_surround_analysis_buffer_delay +
213 pstr_space_enc->n_input_delay]),
214 p_input_2_mps + ch * input_buffer_size_per_channel,
215 (num_samples_per_channel - pstr_space_enc->n_input_delay) * sizeof(FLOAT32));
216 }
217
218 memcpy(&(pstr_space_enc->time_signal_delay_in[ch][0]),
219 &(pstr_space_enc->time_signal_in[ch][pstr_space_enc->n_frame_length]),
220 pstr_space_enc->n_surround_analysis_buffer_delay * sizeof(FLOAT32));
221 }
222
223 error = ixheaace_mps_212_apply_enhanced_time_domain_dmx(
224 pstr_space_enc->pstr_enhanced_time_dmx, pstr_space_enc->time_signal_in, ptr_output_samples,
225 pstr_space_enc->n_surround_analysis_buffer_delay);
226 if (error) {
227 return error;
228 }
229
230 pstr_space_enc->n_samples_valid += samples_to_feed;
231
232 *ptr_n_samples_fed = samples_to_feed;
233 return error;
234 }
235
ixheaace_mps_212_init_delay_compensation(ixheaace_mps_pstr_space_structure pstr_space_enc,const WORD32 core_coder_delay,WORD32 aot)236 static IA_ERRORCODE ixheaace_mps_212_init_delay_compensation(
237 ixheaace_mps_pstr_space_structure pstr_space_enc, const WORD32 core_coder_delay, WORD32 aot) {
238 IA_ERRORCODE error = IA_NO_ERROR;
239 WORD32 i;
240 memset(&pstr_space_enc->pstr_delay->delay_config, 0,
241 sizeof(pstr_space_enc->pstr_delay->delay_config));
242 pstr_space_enc->core_coder_delay = core_coder_delay;
243 pstr_space_enc->pstr_delay->delay_config.num_qmf_len = pstr_space_enc->num_qmf_bands;
244 pstr_space_enc->pstr_delay->delay_config.num_frame_len = pstr_space_enc->n_frame_length;
245 pstr_space_enc->pstr_delay->delay_config.num_core_coder_delay = core_coder_delay;
246 pstr_space_enc->pstr_delay->delay_config.num_sac_stream_mux_delay =
247 pstr_space_enc->time_alignment;
248 pstr_space_enc->pstr_delay->delay_config.b_dmx_align = 0;
249 pstr_space_enc->pstr_delay->delay_config.b_minimize_delay = 1;
250
251 ixheaace_mps_212_delay_sub_calculate_buffer_delays(pstr_space_enc->pstr_delay);
252
253 pstr_space_enc->n_bitstream_delay_buffer =
254 pstr_space_enc->pstr_delay->num_bitstream_frame_buffer_size;
255 pstr_space_enc->n_output_buffer_delay = pstr_space_enc->pstr_delay->num_output_audio_buffer;
256 pstr_space_enc->n_surround_analysis_buffer_delay =
257 pstr_space_enc->pstr_delay->num_surround_analysis_buffer;
258 pstr_space_enc->n_bitstream_buffer_read = 0;
259 pstr_space_enc->n_bitstream_buffer_write = pstr_space_enc->n_bitstream_delay_buffer - 1;
260 pstr_space_enc->num_discard_out_frames = pstr_space_enc->pstr_delay->num_discard_out_frames;
261 pstr_space_enc->n_input_delay = pstr_space_enc->pstr_delay->num_dmx_align_buffer;
262 pstr_space_enc->independency_count = 0;
263 pstr_space_enc->independency_flag = 1;
264
265 for (i = 0; i < pstr_space_enc->n_bitstream_delay_buffer - 1; i++) {
266 ixheaace_mps_spatial_frame *pstr_frame_data = NULL;
267 pstr_frame_data = &pstr_space_enc->pstr_bitstream_formatter->frame;
268 pstr_frame_data->bs_independency_flag = 1;
269 pstr_frame_data->framing_info.num_param_sets = 1;
270 pstr_frame_data->framing_info.bs_framing_type = 0;
271
272 error = ixheaace_mps_212_write_spatial_frame(
273 pstr_space_enc->bit_stream_delay_buffer[i], MAX_MPEGS_BYTES,
274 &pstr_space_enc->pn_output_bits[i], pstr_space_enc->pstr_bitstream_formatter, aot);
275 if (error) {
276 return error;
277 }
278 }
279
280 if ((pstr_space_enc->n_input_delay > MAX_DELAY_INPUT) ||
281 (pstr_space_enc->n_output_buffer_delay > MAX_DELAY_OUTPUT) ||
282 (pstr_space_enc->n_surround_analysis_buffer_delay > MAX_DELAY_SURROUND_ANALYSIS) ||
283 (pstr_space_enc->n_bitstream_delay_buffer > MAX_BITSTREAM_DELAY)) {
284 return IA_EXHEAACE_INIT_FATAL_MPS_INIT_FAILED;
285 }
286 return error;
287 }
288
ixheaace_mps_212_fill_spatial_specific_config(const ixheaace_mps_pstr_space_structure pstr_space_enc,ixheaace_mps_spatial_specific_config * const pstr_h_ssc)289 static IA_ERRORCODE ixheaace_mps_212_fill_spatial_specific_config(
290 const ixheaace_mps_pstr_space_structure pstr_space_enc,
291 ixheaace_mps_spatial_specific_config *const pstr_h_ssc) {
292 IA_ERRORCODE error = IA_NO_ERROR;
293
294 ixheaace_mps_space_tree_description space_tree_description;
295 WORD32 i;
296 space_tree_description = pstr_space_enc->pstr_space_tree->descr;
297 memset(pstr_h_ssc, 0, sizeof(ixheaace_mps_spatial_specific_config));
298
299 pstr_h_ssc->num_bands = pstr_space_enc->space_tree_setup.num_param_bands;
300 pstr_h_ssc->tree_description.num_ott_boxes = space_tree_description.num_ott_boxes;
301 pstr_h_ssc->tree_description.num_in_chan = space_tree_description.num_in_channels;
302 pstr_h_ssc->tree_description.num_out_chan = space_tree_description.num_out_channels;
303
304 for (i = 0; i < IXHEAACE_MPS_MAX_NUM_BOXES; i++) {
305 pstr_h_ssc->ott_config[i].bs_ott_bands = pstr_h_ssc->num_bands;
306 }
307 pstr_h_ssc->bs_tree_config = IXHEAACE_MPS_TREE_212;
308 pstr_h_ssc->bs_sampling_frequency = pstr_space_enc->num_sample_rate;
309 pstr_h_ssc->bs_frame_length = pstr_space_enc->num_frame_time_slots - 1;
310 pstr_h_ssc->bs_decorr_config = IXHEAACE_MPS_DECORR_QMFSPLIT0;
311 pstr_h_ssc->bs_quant_mode = pstr_space_enc->quant_mode;
312 if (pstr_space_enc->pstr_static_gain->fixed_gain_dmx > IXHEAACE_MPS_MAX_FIXED_GAIN_DMX) {
313 pstr_h_ssc->bs_fixed_gain_dmx = IXHEAACE_MPS_FIXED_GAIN_DMX_INVALID;
314 } else {
315 pstr_h_ssc->bs_fixed_gain_dmx = pstr_space_enc->pstr_static_gain->fixed_gain_dmx;
316 }
317 pstr_h_ssc->bs_env_quant_mode = 0;
318 return error;
319 }
320
ixheaace_mps_212_fill_space_tree_setup(const ixheaace_mps_pstr_space_structure pstr_space_enc,ixheaace_mps_space_tree_setup * const ptr_space_tree_setup)321 static IA_ERRORCODE ixheaace_mps_212_fill_space_tree_setup(
322 const ixheaace_mps_pstr_space_structure pstr_space_enc,
323 ixheaace_mps_space_tree_setup *const ptr_space_tree_setup) {
324 IA_ERRORCODE error = IA_NO_ERROR;
325
326 ptr_space_tree_setup->num_param_bands = pstr_space_enc->num_param_bands;
327 ptr_space_tree_setup->use_coarse_quant_tto_cld_flag = pstr_space_enc->use_coarse_quant_cld;
328 ptr_space_tree_setup->use_coarse_quant_tto_icc_flag = pstr_space_enc->use_coarse_quant_icc;
329 ptr_space_tree_setup->quant_mode = pstr_space_enc->quant_mode;
330 ptr_space_tree_setup->num_hybrid_bands_max = pstr_space_enc->num_hybrid_bands;
331 ptr_space_tree_setup->num_channels_in_max = 2;
332 return error;
333 }
334
ixheaace_mps_212_get_info(const ixheaace_mps_pstr_space_structure pstr_space_enc,ixheaace_mps_space_info * const pstr_space_info)335 static VOID ixheaace_mps_212_get_info(const ixheaace_mps_pstr_space_structure pstr_space_enc,
336 ixheaace_mps_space_info *const pstr_space_info) {
337 pstr_space_info->num_sample_rate = pstr_space_enc->num_sample_rate;
338 pstr_space_info->num_samples_frame = pstr_space_enc->n_frame_length;
339 pstr_space_info->num_total_input_channels = pstr_space_enc->n_input_channels;
340 pstr_space_info->dmx_delay = pstr_space_enc->pstr_delay->num_info_dmx_delay;
341 pstr_space_info->codec_delay = pstr_space_enc->pstr_delay->num_info_codec_delay;
342 pstr_space_info->decoder_delay = pstr_space_enc->pstr_delay->num_info_decoder_delay;
343 pstr_space_info->pay_load_delay =
344 pstr_space_enc->pstr_delay->num_bitstream_frame_buffer_size - 1;
345 pstr_space_info->num_discard_out_frames = pstr_space_enc->num_discard_out_frames;
346 pstr_space_info->p_ssc_buf = &pstr_space_enc->ssc_buf;
347 }
348
ixheaace_mps_212_duplicate_parameter_set(const ixheaace_mps_spatial_frame * const pstr_spatial_frame_from,const WORD32 set_from,ixheaace_mps_spatial_frame * const pstr_spatial_frame_to,const WORD32 set_to)349 static VOID ixheaace_mps_212_duplicate_parameter_set(
350 const ixheaace_mps_spatial_frame *const pstr_spatial_frame_from, const WORD32 set_from,
351 ixheaace_mps_spatial_frame *const pstr_spatial_frame_to, const WORD32 set_to) {
352 WORD32 box;
353 for (box = 0; box < IXHEAACE_MPS_MAX_NUM_BOXES; box++) {
354 memcpy(pstr_spatial_frame_to->ott_data.cld[box][set_to],
355 pstr_spatial_frame_from->ott_data.cld[box][set_from],
356 sizeof(pstr_spatial_frame_from->ott_data.cld[0][0]));
357 pstr_spatial_frame_to->cld_lossless_data.bs_xxx_data_mode[box][set_to] =
358 pstr_spatial_frame_from->cld_lossless_data.bs_xxx_data_mode[box][set_from];
359 pstr_spatial_frame_to->cld_lossless_data.bs_data_pair[box][set_to] =
360 pstr_spatial_frame_from->cld_lossless_data.bs_data_pair[box][set_from];
361 pstr_spatial_frame_to->cld_lossless_data.bs_quant_coarse_xxx[box][set_to] =
362 pstr_spatial_frame_from->cld_lossless_data.bs_quant_coarse_xxx[box][set_from];
363 pstr_spatial_frame_to->cld_lossless_data.bs_freq_res_stride_xxx[box][set_to] =
364 pstr_spatial_frame_from->cld_lossless_data.bs_freq_res_stride_xxx[box][set_from];
365
366 memcpy(pstr_spatial_frame_to->ott_data.icc[box][set_to],
367 pstr_spatial_frame_from->ott_data.icc[box][set_from],
368 sizeof(pstr_spatial_frame_from->ott_data.icc[0][0]));
369 pstr_spatial_frame_to->icc_lossless_data.bs_xxx_data_mode[box][set_to] =
370 pstr_spatial_frame_from->icc_lossless_data.bs_xxx_data_mode[box][set_from];
371 pstr_spatial_frame_to->icc_lossless_data.bs_data_pair[box][set_to] =
372 pstr_spatial_frame_from->icc_lossless_data.bs_data_pair[box][set_from];
373 pstr_spatial_frame_to->icc_lossless_data.bs_quant_coarse_xxx[box][set_to] =
374 pstr_spatial_frame_from->icc_lossless_data.bs_quant_coarse_xxx[box][set_from];
375 pstr_spatial_frame_to->icc_lossless_data.bs_freq_res_stride_xxx[box][set_to] =
376 pstr_spatial_frame_from->icc_lossless_data.bs_freq_res_stride_xxx[box][set_from];
377 }
378 }
379
ixheaace_mps_212_encode(const ixheaace_mps_pstr_space_structure pstr_space_enc,const ixheaace_mps_buf_descr * ptr_in_buf_desc,const ixheaace_mps_buf_descr * ptr_out_buf_desc,const ixheaace_mps_in_args * pstr_in_args,ixheaace_mps_out_args * pstr_out_args,WORD32 aot,WORD8 * ptr_scratch)380 static IA_ERRORCODE ixheaace_mps_212_encode(
381 const ixheaace_mps_pstr_space_structure pstr_space_enc,
382 const ixheaace_mps_buf_descr *ptr_in_buf_desc, const ixheaace_mps_buf_descr *ptr_out_buf_desc,
383 const ixheaace_mps_in_args *pstr_in_args, ixheaace_mps_out_args *pstr_out_args, WORD32 aot,
384 WORD8 *ptr_scratch) {
385 IA_ERRORCODE error = IA_NO_ERROR;
386 WORD32 num_output_samples;
387 WORD32 i, ch, ps, win_cnt, ts, slot;
388 WORD32 curr_trans_pos = -1;
389 WORD32 num_ch_in;
390 WORD32 num_ch_in_with_dmx;
391 WORD32 num_ch_out;
392 WORD32 num_samples_per_channel;
393 WORD32 num_output_samples_max;
394 WORD32 num_frame_time_slots;
395 WORD32 num_frame_time_slots_reduction;
396 ixheaace_mps_spatial_frame *pstr_frame_data = NULL;
397 UWORD8 *ptr_bitstream_delay_buffer;
398 const FLOAT32 *ptr_input_samples =
399 (const FLOAT32 *)ptr_in_buf_desc->pp_base[IXHEAACE_MPS_INPUT_BUFFER_IDX];
400
401 FLOAT32 *const ptr_output_samples =
402 (FLOAT32 *)ptr_out_buf_desc->pp_base[IXHEAACE_MPS_OUTUT_BUFFER_IDX];
403
404 const WORD32 num_output_samples_buffer_size =
405 ptr_out_buf_desc->p_buf_size[IXHEAACE_MPS_OUTUT_BUFFER_IDX] /
406 ptr_out_buf_desc->p_ele_size[IXHEAACE_MPS_OUTUT_BUFFER_IDX];
407 num_ch_in = pstr_space_enc->n_input_channels;
408 num_ch_in_with_dmx = num_ch_in;
409 num_ch_out = pstr_space_enc->n_output_channels;
410 num_samples_per_channel = pstr_in_args->num_input_samples / num_ch_in_with_dmx;
411 num_output_samples_max = num_samples_per_channel * num_ch_out;
412 num_frame_time_slots = pstr_space_enc->num_frame_time_slots;
413 num_frame_time_slots_reduction = pstr_space_enc->num_frame_time_slots >> 1;
414 if ((0 != pstr_in_args->num_input_samples % num_ch_in_with_dmx)) {
415 return IA_EXHEAACE_CONFIG_NONFATAL_MPS_INVALID_CONFIG;
416 }
417 pstr_frame_data = &pstr_space_enc->pstr_bitstream_formatter->frame;
418
419 if (aot != AOT_USAC) {
420 if (pstr_space_enc->num_discard_out_frames > 0) {
421 pstr_space_enc->independency_count = 0;
422 pstr_space_enc->independency_flag = 1;
423 } else {
424 pstr_space_enc->independency_flag = (pstr_space_enc->independency_count == 0) ? 1 : 0;
425 if (pstr_space_enc->independency_factor > 0) {
426 pstr_space_enc->independency_count++;
427 pstr_space_enc->independency_count =
428 pstr_space_enc->independency_count % ((WORD32)pstr_space_enc->independency_factor);
429 } else {
430 pstr_space_enc->independency_count = -1;
431 }
432 }
433 }
434
435 error = ixheaace_mps_212_feed_de_inter_pre_scale(
436 pstr_space_enc, ptr_input_samples, ptr_output_samples, pstr_in_args->num_input_samples,
437 pstr_in_args->is_input_inter_leaved, pstr_in_args->input_buffer_size_per_channel,
438 &pstr_out_args->num_samples_consumed);
439 if (error) {
440 return error;
441 }
442
443 if (pstr_space_enc->n_samples_next != pstr_space_enc->n_samples_valid) {
444 return IA_EXHEAACE_CONFIG_NONFATAL_MPS_INVALID_CONFIG;
445 }
446
447 for (ch = 0; ch < num_ch_in; ch++) {
448 for (slot = 0; slot < num_frame_time_slots; slot++) {
449 ixheaace_cmplx_str *pstr_cmplx_data;
450
451 pstr_cmplx_data =
452 pstr_space_enc
453 ->cmplx_hybrid_in[ch][pstr_space_enc->n_update_hybrid_position_time_slots +
454 num_frame_time_slots - num_frame_time_slots_reduction + slot];
455 memset(pstr_cmplx_data, 0, 2 * pstr_space_enc->num_hybrid_bands * sizeof(WORD32));
456 }
457 }
458
459 for (ch = 0; ch < num_ch_in; ch++) {
460 FLOAT32 qmf_in_real[MAX_QMF_BANDS];
461 FLOAT32 qmf_in_imag[MAX_QMF_BANDS];
462 FLOAT32 p_work_buffer[MAX_QMF_BANDS << 1];
463 FLOAT32 *ptr_pre_gain = pstr_space_enc->pstr_static_gain->pre_gain;
464 for (ts = 0; ts < num_frame_time_slots; ts++) {
465 FLOAT32 *ptr_spec_real;
466 FLOAT32 *ptr_spec_imag;
467
468 FLOAT32 *ptr_time_in =
469 &pstr_space_enc->time_signal_in[ch][(ts * pstr_space_enc->num_qmf_bands)];
470
471 ixheaace_mps_212_apply_dc_filter(pstr_space_enc->pstr_dc_filter[ch], ptr_time_in,
472 ptr_time_in, pstr_space_enc->num_qmf_bands);
473
474 error = ixheaace_mps_212_qmf_analysis_filtering_slot(pstr_space_enc->pstr_qmf_filter_in[ch],
475 qmf_in_real, qmf_in_imag, ptr_time_in,
476 1, p_work_buffer, ptr_scratch);
477 if (error != IA_NO_ERROR) {
478 return error;
479 }
480
481 ptr_spec_real = qmf_in_real;
482 ptr_spec_imag = qmf_in_imag;
483 if (1.0f != ptr_pre_gain[ch]) {
484 for (i = 0; i < pstr_space_enc->num_hybrid_bands; i++) {
485 pstr_space_enc
486 ->cmplx_hybrid_in[ch][pstr_space_enc->n_analysis_lookahead_time_slots + ts][i]
487 .re = ptr_spec_real[i] * ptr_pre_gain[ch];
488 pstr_space_enc
489 ->cmplx_hybrid_in[ch][pstr_space_enc->n_analysis_lookahead_time_slots + ts][i]
490 .im = ptr_spec_imag[i] * ptr_pre_gain[ch];
491 }
492 } else {
493 for (i = 0; i < pstr_space_enc->num_hybrid_bands; i++) {
494 pstr_space_enc
495 ->cmplx_hybrid_in[ch][pstr_space_enc->n_analysis_lookahead_time_slots + ts][i]
496 .re = ptr_spec_real[i];
497 pstr_space_enc
498 ->cmplx_hybrid_in[ch][pstr_space_enc->n_analysis_lookahead_time_slots + ts][i]
499 .im = ptr_spec_imag[i];
500 }
501 }
502 }
503 }
504
505 for (ch = 0; ch < num_ch_in; ch++) {
506 for (slot = 0; slot < (WORD32)(pstr_space_enc->n_update_hybrid_position_time_slots +
507 num_frame_time_slots - num_frame_time_slots_reduction);
508 slot++) {
509 memmove(pstr_space_enc->cmplx_hybrid_in[ch][slot],
510 pstr_space_enc->cmplx_hybrid_in_static[ch][slot],
511 sizeof(ixheaace_cmplx_str) * pstr_space_enc->num_hybrid_bands);
512 }
513
514 for (slot = 0; slot < (WORD32)(pstr_space_enc->n_update_hybrid_position_time_slots +
515 num_frame_time_slots - num_frame_time_slots_reduction);
516 slot++) {
517 memmove(pstr_space_enc->cmplx_hybrid_in_static[ch][slot],
518 pstr_space_enc->cmplx_hybrid_in[ch][num_frame_time_slots + slot],
519 sizeof(ixheaace_cmplx_str) * pstr_space_enc->num_hybrid_bands);
520 }
521
522 error = ixheaace_mps_212_onset_detect_apply(
523 pstr_space_enc->pstr_onset_detect[ch], num_frame_time_slots,
524 &pstr_space_enc->cmplx_hybrid_in[ch][pstr_space_enc->n_analysis_lookahead_time_slots],
525 pstr_space_enc->tr_prev_pos[1], pstr_space_enc->pp_tr_curr_pos[ch]);
526 if (error) {
527 return error;
528 }
529
530 if (pstr_space_enc->use_frame_keep == 0) {
531 pstr_space_enc->pp_tr_curr_pos[ch][0] = -1;
532 }
533
534 if ((pstr_space_enc->pp_tr_curr_pos[ch][0] >= 0) &&
535 ((curr_trans_pos < 0) || (pstr_space_enc->pp_tr_curr_pos[ch][0] < curr_trans_pos))) {
536 curr_trans_pos = pstr_space_enc->pp_tr_curr_pos[ch][0];
537 }
538 }
539 if (pstr_space_enc->use_frame_keep == 1) {
540 if ((curr_trans_pos != -1) || (pstr_space_enc->independency_flag == 1)) {
541 pstr_space_enc->avoid_keep = NUM_KEEP_WINDOWS;
542 curr_trans_pos = -1;
543 }
544 }
545
546 pstr_space_enc->tr_prev_pos[0] = MAX(-1, pstr_space_enc->tr_prev_pos[1] - num_frame_time_slots);
547 pstr_space_enc->tr_prev_pos[1] = curr_trans_pos;
548
549 for (ch = 0; ch < num_ch_in; ch++) {
550 error = ixheaace_mps_212_onset_detect_update(pstr_space_enc->pstr_onset_detect[ch],
551 num_frame_time_slots);
552 if (error) {
553 return error;
554 }
555 }
556
557 ixheaace_mps_212_frame_window_get_window(
558 pstr_space_enc->h_frame_window, pstr_space_enc->tr_prev_pos, num_frame_time_slots,
559 &pstr_frame_data->framing_info, pstr_space_enc->ptr_frame_window_ana,
560 &pstr_space_enc->frame_win_list, pstr_space_enc->avoid_keep);
561
562 for (ps = 0, win_cnt = 0; ps < pstr_space_enc->frame_win_list.win_list_cnt; ++ps) {
563 if (pstr_space_enc->frame_win_list.dat[ps].hold == IXHEAACE_MPS_FRAME_WINDOWING_HOLD) {
564 ixheaace_mps_212_duplicate_parameter_set(&pstr_space_enc->save_frame, 0, pstr_frame_data,
565 ps);
566 } else {
567 WORD32 num_analysis_length_time_slots, analysis_start_time_slot;
568 FLOAT32 *ptr_frame_window_ana;
569 num_analysis_length_time_slots = ixheaace_mps_212_get_analysis_length_time_slots(
570 pstr_space_enc->ptr_frame_window_ana[win_cnt],
571 pstr_space_enc->num_analysis_length_time_slots);
572
573 analysis_start_time_slot = ixheaace_mps_212_get_analysis_start_time_slot(
574 pstr_space_enc->ptr_frame_window_ana[win_cnt],
575 pstr_space_enc->num_analysis_length_time_slots);
576
577 ptr_frame_window_ana = pstr_space_enc->ptr_frame_window_ana[win_cnt];
578
579 error = ixheaace_mps_212_space_tree_apply(
580 pstr_space_enc->pstr_space_tree, ps, num_ch_in, num_analysis_length_time_slots,
581 analysis_start_time_slot, pstr_space_enc->num_hybrid_bands, ptr_frame_window_ana,
582 pstr_space_enc->cmplx_hybrid_in, pstr_space_enc->cmplx_hybrid_in, pstr_frame_data,
583 pstr_space_enc->avoid_keep);
584 if (error) {
585 return error;
586 }
587
588 ixheaace_mps_212_duplicate_parameter_set(pstr_frame_data, ps, &pstr_space_enc->save_frame,
589 0);
590 ++win_cnt;
591 }
592 if (pstr_space_enc->avoid_keep > 0) {
593 pstr_space_enc->avoid_keep--;
594 }
595 }
596
597 memset(&pstr_frame_data->smg_data, 0, sizeof(pstr_frame_data->smg_data));
598
599 ptr_bitstream_delay_buffer =
600 (UWORD8 *)ptr_out_buf_desc->pp_base[IXHEAACE_MPS_BITSTREAM_BUFFER_IDX];
601 pstr_frame_data->bs_independency_flag = pstr_space_enc->independency_flag;
602
603 error = ixheaace_mps_212_write_spatial_frame(
604 ptr_bitstream_delay_buffer, MAX_MPEGS_BYTES,
605 &pstr_space_enc->pn_output_bits[pstr_space_enc->n_bitstream_buffer_write],
606 pstr_space_enc->pstr_bitstream_formatter, aot);
607 if (error) {
608 return error;
609 }
610
611 if ((pstr_space_enc->num_discard_out_frames == 0) &&
612 (IXHEAACE_MPS_BITSTREAM_BUFFER_IDX != -1)) {
613 const WORD32 idx = IXHEAACE_MPS_BITSTREAM_BUFFER_IDX;
614 const WORD32 out_bits =
615 pstr_space_enc->pn_output_bits[pstr_space_enc->n_bitstream_buffer_read];
616
617 if (((out_bits + 7) / 8) >
618 (WORD32)(ptr_out_buf_desc->p_buf_size[idx] / ptr_out_buf_desc->p_ele_size[idx])) {
619 pstr_out_args->num_output_bits = 0;
620 return IA_EXHEAACE_EXE_NONFATAL_MPS_ENCODE_ERROR;
621 }
622 pstr_out_args->num_output_bits = out_bits;
623 } else {
624 pstr_out_args->num_output_bits = 0;
625 }
626
627 pstr_space_enc->n_bitstream_buffer_read =
628 (pstr_space_enc->n_bitstream_buffer_read + 1) % pstr_space_enc->n_bitstream_delay_buffer;
629 pstr_space_enc->n_bitstream_buffer_write =
630 (pstr_space_enc->n_bitstream_buffer_write + 1) % pstr_space_enc->n_bitstream_delay_buffer;
631
632 num_output_samples =
633 (pstr_space_enc->num_discard_out_frames == 0) ? (num_output_samples_max) : 0;
634 if (num_output_samples > num_output_samples_buffer_size) {
635 return IA_EXHEAACE_CONFIG_NONFATAL_MPS_INVALID_CONFIG;
636 }
637 pstr_out_args->num_output_samples = num_output_samples;
638
639 if (pstr_space_enc->num_discard_out_frames > 0) {
640 pstr_space_enc->num_discard_out_frames--;
641 }
642 pstr_space_enc->n_samples_valid = 0;
643
644 return error;
645 }
646
ixheaace_mps_212_init(ixheaace_mps_pstr_space_structure pstr_space_enc,const WORD32 dmx_delay,WORD32 aot)647 static IA_ERRORCODE ixheaace_mps_212_init(ixheaace_mps_pstr_space_structure pstr_space_enc,
648 const WORD32 dmx_delay, WORD32 aot) {
649 IA_ERRORCODE error = IA_NO_ERROR;
650 WORD32 ch;
651 WORD32 num_ch_in_arb_dmx;
652 ixheaace_mps_space_tree_description space_tree_description;
653 ixheaace_mps_onset_detect_config onset_detect_config;
654 ixheaace_mps_frame_win_config frame_window_config;
655
656 error = ixheaace_mps_212_configure(pstr_space_enc, &pstr_space_enc->user);
657 if (error) {
658 return error;
659 }
660 pstr_space_enc->b_enc_mode_212_only = pstr_space_enc->setup->b_enc_mode_212;
661
662 if (pstr_space_enc->num_frame_time_slots < 1) {
663 return IA_EXHEAACE_CONFIG_NONFATAL_MPS_INVALID_CONFIG;
664 }
665 pstr_space_enc->n_frame_length =
666 pstr_space_enc->num_qmf_bands * pstr_space_enc->num_frame_time_slots;
667
668 if (pstr_space_enc->use_frame_keep == 1) {
669 pstr_space_enc->num_analysis_length_time_slots = 3 * pstr_space_enc->num_frame_time_slots;
670 pstr_space_enc->n_update_hybrid_position_time_slots = pstr_space_enc->num_frame_time_slots;
671 } else {
672 pstr_space_enc->num_analysis_length_time_slots = 2 * pstr_space_enc->num_frame_time_slots;
673 pstr_space_enc->n_update_hybrid_position_time_slots = 0;
674 }
675
676 pstr_space_enc->n_analysis_lookahead_time_slots =
677 pstr_space_enc->num_analysis_length_time_slots -
678 3 * pstr_space_enc->num_frame_time_slots / 2;
679
680 ixheaace_mps_212_calc_parameter_band_to_hybrid_band_offset(
681 pstr_space_enc->num_hybrid_bands, pstr_space_enc->ptr_parameter_band_2_hybrid_band_offset,
682 aot);
683
684 error =
685 ixheaace_mps_212_fill_space_tree_setup(pstr_space_enc, &pstr_space_enc->space_tree_setup);
686 if (error) {
687 return error;
688 }
689 error = ixheaace_mps_212_space_tree_init(
690 pstr_space_enc->pstr_space_tree, &pstr_space_enc->space_tree_setup,
691 pstr_space_enc->ptr_parameter_band_2_hybrid_band_offset, pstr_space_enc->use_frame_keep,
692 aot);
693 if (error) {
694 return error;
695 }
696
697 space_tree_description = pstr_space_enc->pstr_space_tree->descr;
698 pstr_space_enc->n_input_channels = space_tree_description.num_out_channels;
699 pstr_space_enc->n_output_channels = space_tree_description.num_in_channels;
700 frame_window_config.num_time_slots_max = pstr_space_enc->num_frame_time_slots;
701 frame_window_config.frame_keep_flag = pstr_space_enc->use_frame_keep;
702 onset_detect_config.max_time_slots = pstr_space_enc->num_frame_time_slots;
703 onset_detect_config.lower_bound_onset_detection =
704 ((2 * 1725 * pstr_space_enc->num_qmf_bands) / pstr_space_enc->num_sample_rate);
705 onset_detect_config.upper_bound_onset_detection = pstr_space_enc->num_hybrid_bands;
706 num_ch_in_arb_dmx = 0;
707
708 for (ch = 0; ch < pstr_space_enc->n_input_channels; ch++) {
709 ixheaace_mps_212_qmf_init_filter_bank(
710 pstr_space_enc->pstr_qmf_filter_in[ch],
711 pstr_space_enc->pstr_qmf_filter_in[ch]->ptr_filter_states, 1,
712 pstr_space_enc->num_qmf_bands, pstr_space_enc->num_qmf_bands,
713 pstr_space_enc->num_qmf_bands);
714 if (error) {
715 return error;
716 }
717 ixheaace_mps_212_init_dc_filter(pstr_space_enc->pstr_dc_filter[ch],
718 pstr_space_enc->num_sample_rate);
719 error = ixheaace_mps_212_onset_detect_init(pstr_space_enc->pstr_onset_detect[ch],
720 &onset_detect_config, 1);
721 if (error) {
722 return error;
723 }
724 }
725
726 error =
727 ixheaace_mps_212_frame_window_init(pstr_space_enc->h_frame_window, &frame_window_config);
728 if (error) {
729 return error;
730 }
731
732 error = ixheaace_mps_212_static_gain_init(pstr_space_enc->pstr_static_gain,
733 pstr_space_enc->pstr_static_gain_config);
734 if (error) {
735 return error;
736 }
737
738 error = ixheaace_mps_212_init_enhanced_time_domain_dmx(
739 pstr_space_enc->pstr_enhanced_time_dmx, pstr_space_enc->pstr_static_gain->pre_gain,
740 pstr_space_enc->pstr_static_gain->post_gain, pstr_space_enc->n_frame_length);
741 if (error) {
742 return error;
743 }
744
745 memset(pstr_space_enc->pstr_bitstream_formatter, 0, sizeof(ixheaace_mps_spatial_frame));
746 pstr_space_enc->pstr_bitstream_formatter->frame.bs_independency_flag = 1;
747 pstr_space_enc->pstr_bitstream_formatter->frame.framing_info.num_param_sets = 1;
748
749 error = ixheaace_mps_212_fill_spatial_specific_config(
750 pstr_space_enc, &pstr_space_enc->pstr_bitstream_formatter->spatial_specific_config);
751 if (error) {
752 return error;
753 }
754
755 error = ixheaace_mps_212_write_spatial_specific_config(
756 &pstr_space_enc->pstr_bitstream_formatter->spatial_specific_config,
757 pstr_space_enc->ssc_buf.ptr_ssc, MAX_SSC_BYTES, &pstr_space_enc->ssc_buf.num_ssc_size_bits,
758 aot);
759 if (error) {
760 return error;
761 }
762
763 error = ixheaace_mps_212_init_delay_compensation(pstr_space_enc, dmx_delay, aot);
764 if (error) {
765 return error;
766 }
767
768 pstr_space_enc->n_samples_next =
769 pstr_space_enc->n_frame_length * (pstr_space_enc->n_input_channels + num_ch_in_arb_dmx);
770 pstr_space_enc->n_samples_valid = 0;
771
772 return error;
773 }
774
ixheaace_mps_open(ixheaace_mps_pstr_space_structure * pstr_space_enc_structure,ixheaace_mps_212_memory_struct * pstr_mps_memory)775 static VOID ixheaace_mps_open(ixheaace_mps_pstr_space_structure *pstr_space_enc_structure,
776 ixheaace_mps_212_memory_struct *pstr_mps_memory) {
777 WORD32 ch;
778 WORD32 param;
779 ixheaace_mps_pstr_space_structure pstr_space_enc = NULL;
780 pstr_space_enc = &pstr_mps_memory->mp4_space_encoder_instance;
781 if (NULL != pstr_space_enc) {
782 memset(pstr_space_enc, 0, sizeof(struct ixheaace_mps_space_structure));
783 }
784 pstr_space_enc->setup = &pstr_mps_memory->setup;
785 pstr_space_enc->setup->max_sampling_rate = MAX_SAMPLING_RATE;
786 pstr_space_enc->setup->max_frame_time_slots = MAX_FRAME_TIME_SLOT;
787 pstr_space_enc->setup->max_analysis_length_time_slots =
788 3 * pstr_space_enc->setup->max_frame_time_slots;
789 pstr_space_enc->setup->max_qmf_bands =
790 ixheaace_mps_212_space_get_num_qmf_bands(pstr_space_enc->setup->max_sampling_rate);
791 pstr_space_enc->setup->max_hybrid_bands = pstr_space_enc->setup->max_qmf_bands;
792 pstr_space_enc->setup->max_frame_length =
793 pstr_space_enc->setup->max_qmf_bands * pstr_space_enc->setup->max_frame_time_slots;
794 pstr_space_enc->setup->max_ch_in = 2;
795 pstr_space_enc->setup->max_ch_out = 1;
796 pstr_space_enc->setup->max_ch_tot_out = pstr_space_enc->setup->max_ch_out;
797 pstr_space_enc->setup->b_enc_mode_212 = 1;
798 pstr_space_enc->setup->max_hybrid_in_static_slots = 24;
799
800 pstr_space_enc->pstr_static_gain_config = &pstr_mps_memory->static_gain_config;
801 pstr_space_enc->pstr_enhanced_time_dmx = &pstr_mps_memory->enhanced_time_dmx;
802 pstr_space_enc->pstr_enhanced_time_dmx->sinus_window = pstr_mps_memory->sinus_window_flt;
803 pstr_space_enc->ptr_parameter_band_2_hybrid_band_offset =
804 pstr_mps_memory->parameter_band_2_hybrid_band_offset;
805 ixheaace_mps_212_space_tree_open(&pstr_space_enc->pstr_space_tree, pstr_mps_memory);
806 pstr_space_enc->pstr_qmf_filter_in = pstr_mps_memory->pstr_qmf_filter_bank;
807 for (ch = 0; ch < pstr_space_enc->setup->max_ch_in; ch++) {
808 pstr_space_enc->pstr_qmf_filter_in[ch] = &pstr_mps_memory->qmf_filter_bank[ch];
809 pstr_space_enc->pstr_qmf_filter_in[ch]->ptr_filter_states =
810 &pstr_mps_memory->ptr_filter_states[ch];
811 pstr_space_enc->pstr_dc_filter[ch] = &pstr_mps_memory->dc_filter[ch];
812 pstr_space_enc->pstr_onset_detect[ch] = &pstr_mps_memory->onset_detect[ch];
813 pstr_space_enc->pstr_onset_detect[ch]->p_energy_hist =
814 &pstr_mps_memory->energy_hist_float[ch][0];
815 }
816 pstr_space_enc->h_frame_window = &pstr_mps_memory->frame_window;
817 pstr_space_enc->pstr_static_gain = &pstr_mps_memory->static_gain;
818 pstr_space_enc->pstr_bitstream_formatter = &pstr_mps_memory->bitstream;
819 pstr_space_enc->ssc_buf.ptr_ssc = pstr_mps_memory->ssc;
820 pstr_space_enc->pstr_delay = &pstr_mps_memory->delay;
821 pstr_space_enc->pn_output_bits = pstr_mps_memory->n_output_bits;
822 for (param = 0; param < MAX_NUM_PARAMS; param++) {
823 pstr_space_enc->ptr_frame_window_ana[param] =
824 &pstr_mps_memory->frame_window_ana_flt[param][0];
825 }
826 pstr_space_enc->pstr_enhanced_time_dmx->max_frame_length =
827 pstr_space_enc->setup->max_frame_length;
828 for (ch = 0; ch < pstr_space_enc->setup->max_ch_in; ch++) {
829 pstr_space_enc->pstr_onset_detect[ch]->max_time_slots =
830 pstr_space_enc->setup->max_frame_time_slots;
831 pstr_space_enc->pstr_onset_detect[ch]->min_trans_dist = 8;
832 pstr_space_enc->pstr_onset_detect[ch]->avg_energy_dist = 16;
833 pstr_space_enc->pstr_onset_detect[ch]->avg_energy_dist_scale = 4;
834 }
835 pstr_space_enc->pstr_static_gain_config->fixed_gain_dmx = IXHEAACE_MPS_DMX_GAIN_DEFAULT;
836 pstr_space_enc->pstr_static_gain_config->pre_gain_factor_db = 0;
837
838 if (NULL != pstr_space_enc_structure) {
839 *pstr_space_enc_structure = pstr_space_enc;
840 }
841 }
842
ixheaace_mps_212_get_closest_bit_rate(const WORD32 audio_object_type,const UWORD32 sampling_rate,const UWORD32 sbr_ratio,UWORD32 bitrate)843 static WORD32 ixheaace_mps_212_get_closest_bit_rate(const WORD32 audio_object_type,
844 const UWORD32 sampling_rate,
845 const UWORD32 sbr_ratio, UWORD32 bitrate) {
846 UWORD32 idx;
847 WORD32 target_bitrate = -1;
848
849 for (idx = 0; idx < sizeof(mps_config_tab) / sizeof(ixheaace_mps_config_table); idx++) {
850 if ((mps_config_tab[idx].sampling_rate == sampling_rate) &&
851 (mps_config_tab[idx].audio_object_type == audio_object_type) &&
852 (mps_config_tab[idx].sbr_ratio == sbr_ratio)) {
853 target_bitrate =
854 MIN(MAX(bitrate, mps_config_tab[idx].bitrate_min), mps_config_tab[idx].bitrate_max);
855 }
856 }
857
858 return target_bitrate;
859 }
860
ixheaace_mps_212_write_spatial_specific_config_data(ixheaace_mps_pstr_struct pstr_mps_enc,ixheaace_bit_buf_handle pstr_bit_buf)861 static WORD32 ixheaace_mps_212_write_spatial_specific_config_data(
862 ixheaace_mps_pstr_struct pstr_mps_enc, ixheaace_bit_buf_handle pstr_bit_buf) {
863 WORD32 idx;
864 WORD32 ssc_bits = 0;
865 WORD32 written_bits = 0;
866 ixheaace_mps_space_info pstr_space_encoder_info;
867 ixheaace_mps_212_get_info(pstr_mps_enc->ptr_sac_encoder, &pstr_space_encoder_info);
868
869 for (idx = 0; idx<pstr_space_encoder_info.p_ssc_buf->num_ssc_size_bits>> 3; idx++) {
870 ixheaace_write_bits(pstr_bit_buf, pstr_space_encoder_info.p_ssc_buf->ptr_ssc[idx], 8);
871 written_bits += 8;
872 }
873 ixheaace_write_bits(
874 pstr_bit_buf, pstr_space_encoder_info.p_ssc_buf->ptr_ssc[idx],
875 (UWORD8)(pstr_space_encoder_info.p_ssc_buf->num_ssc_size_bits - written_bits));
876
877 ssc_bits = pstr_space_encoder_info.p_ssc_buf->num_ssc_size_bits;
878 return ssc_bits;
879 }
880
ixheaace_mps_212_open(VOID ** pstr_handle_mps,ixheaace_mps_212_memory_struct * pstr_mps_memory)881 VOID ixheaace_mps_212_open(VOID **pstr_handle_mps,
882 ixheaace_mps_212_memory_struct *pstr_mps_memory) {
883 ixheaace_mps_pstr_struct pstr_mps_enc = NULL;
884 pstr_mps_enc = &pstr_mps_memory->mps_encoder_instance;
885 memset(pstr_mps_enc, 0, sizeof(ixheaace_mps_struct));
886 ixheaace_mps_open(&pstr_mps_enc->ptr_sac_encoder, pstr_mps_memory);
887 *pstr_handle_mps = pstr_mps_enc;
888 }
889
ixheaace_mps_212_close(VOID ** pstr_handle_mps)890 VOID ixheaace_mps_212_close(VOID **pstr_handle_mps) {
891 ixheaace_mps_pstr_struct *pstr_mps_enc = (ixheaace_mps_pstr_struct *)pstr_handle_mps;
892 if (*pstr_mps_enc != NULL) {
893 *pstr_mps_enc = NULL;
894 }
895 }
896
ixheaace_mps_212_initialise(VOID * pstr_handle_mps,const WORD32 audio_object_type,const UWORD32 sampling_rate,WORD32 * ptr_bitrate,const UWORD32 sbr_ratio,const UWORD32 frame_length,const UWORD32 input_buffer_size_per_channel,const UWORD32 core_coder_delay,WORD8 * ptr_scratch)897 IA_ERRORCODE ixheaace_mps_212_initialise(VOID *pstr_handle_mps, const WORD32 audio_object_type,
898 const UWORD32 sampling_rate, WORD32 *ptr_bitrate,
899 const UWORD32 sbr_ratio, const UWORD32 frame_length,
900 const UWORD32 input_buffer_size_per_channel,
901 const UWORD32 core_coder_delay, WORD8 *ptr_scratch) {
902 IA_ERRORCODE error = IA_NO_ERROR;
903 const UWORD32 fs_low = 27713;
904 const UWORD32 fs_high = 55426;
905 const UWORD32 no_inter_frame_coding = 0;
906 UWORD32 num_time_slots = 0, num_qmf_bands_ld = 0;
907 ixheaace_mps_pstr_struct pstr_mps_enc = (ixheaace_mps_pstr_struct)pstr_handle_mps;
908 switch (sbr_ratio) {
909 case 1:
910 if (!(sampling_rate < fs_low)) {
911 return IA_EXHEAACE_INIT_FATAL_MPS_INIT_FAILED;
912 }
913 break;
914 case 2:
915 case 4:
916 if (!((sampling_rate >= fs_low) && (sampling_rate < fs_high))) {
917 return IA_EXHEAACE_INIT_FATAL_MPS_INIT_FAILED;
918 }
919 break;
920 case 0:
921 default:;
922 }
923
924 num_qmf_bands_ld = (sampling_rate < fs_low) ? 5 : ((sampling_rate > fs_high) ? 7 : 6);
925 num_time_slots = frame_length >> num_qmf_bands_ld;
926 *ptr_bitrate = ixheaace_mps_212_get_closest_bit_rate(audio_object_type, sampling_rate,
927 sbr_ratio, *ptr_bitrate);
928
929 pstr_mps_enc->ptr_sac_encoder->user.b_ld_mode = ((no_inter_frame_coding == 1) ? 1 : 2);
930 pstr_mps_enc->ptr_sac_encoder->user.sample_rate = sampling_rate;
931 pstr_mps_enc->ptr_sac_encoder->user.frame_time_slots = num_time_slots;
932 if (audio_object_type == AOT_AAC_ELD) {
933 pstr_mps_enc->ptr_sac_encoder->user.num_param_bands = IXHEAACE_MPS_SAC_BANDS_ld;
934 pstr_mps_enc->ptr_sac_encoder->user.independency_factor = 20;
935 } else {
936 pstr_mps_enc->ptr_sac_encoder->user.num_param_bands = IXHEAACE_MPS_SAC_BANDS_usac;
937 pstr_mps_enc->ptr_sac_encoder->user.independency_factor = 25;
938 }
939
940 pstr_mps_enc->ptr_sac_encoder->user.b_use_coarse_quant = 0;
941 pstr_mps_enc->ptr_sac_encoder->user.quant_mode = IXHEAACE_MPS_QUANTMODE_FINE;
942 pstr_mps_enc->ptr_sac_encoder->user.time_alignment = 0;
943 pstr_mps_enc->audio_object_type = audio_object_type;
944 error =
945 ixheaace_mps_212_init(pstr_mps_enc->ptr_sac_encoder, core_coder_delay, audio_object_type);
946 if (error) {
947 return IA_EXHEAACE_INIT_FATAL_MPS_INIT_FAILED;
948 }
949
950 pstr_mps_enc->in_buf_desc.pp_base = (VOID **)&pstr_mps_enc->p_in_buffer;
951 pstr_mps_enc->in_buf_desc.p_buf_size = pstr_mps_enc->p_in_buffer_size;
952 pstr_mps_enc->in_buf_desc.p_ele_size = pstr_mps_enc->p_in_buffer_el_size;
953 pstr_mps_enc->in_buf_desc.p_buf_type = pstr_mps_enc->p_in_buffer_type;
954 pstr_mps_enc->in_buf_desc.num_bufs = 1;
955
956 pstr_mps_enc->out_buf_desc.pp_base = (VOID **)&pstr_mps_enc->p_out_buffer;
957 pstr_mps_enc->out_buf_desc.p_buf_size = pstr_mps_enc->p_out_buffer_size;
958 pstr_mps_enc->out_buf_desc.p_ele_size = pstr_mps_enc->p_out_buffer_el_size;
959 pstr_mps_enc->out_buf_desc.p_buf_type = pstr_mps_enc->p_out_buffer_type;
960 pstr_mps_enc->out_buf_desc.num_bufs = 2;
961
962 pstr_mps_enc->p_in_buffer[0] = NULL;
963 pstr_mps_enc->p_in_buffer_size[0] = 0;
964 pstr_mps_enc->p_in_buffer_el_size[0] = sizeof(FLOAT32);
965 pstr_mps_enc->p_in_buffer_type[0] = IXHEAACE_MPS_INPUT_BUFFER_IDX;
966
967 pstr_mps_enc->p_out_buffer[0] = NULL;
968 pstr_mps_enc->p_out_buffer_size[0] = 0;
969 pstr_mps_enc->p_out_buffer_el_size[0] = sizeof(FLOAT32);
970 pstr_mps_enc->p_out_buffer_type[0] = IXHEAACE_MPS_OUTUT_BUFFER_IDX;
971
972 pstr_mps_enc->p_out_buffer[1] = NULL;
973 pstr_mps_enc->p_out_buffer_size[1] = 0;
974 pstr_mps_enc->p_out_buffer_el_size[1] = sizeof(UWORD8);
975 pstr_mps_enc->p_out_buffer_type[1] = IXHEAACE_MPS_BITSTREAM_BUFFER_IDX;
976
977 pstr_mps_enc->in_args.is_input_inter_leaved = 0;
978 pstr_mps_enc->in_args.input_buffer_size_per_channel = input_buffer_size_per_channel;
979
980 pstr_mps_enc->ptr_scratch = ptr_scratch;
981
982 return error;
983 }
984
ixheaace_mps_212_process(VOID * pstr_handle_mps,FLOAT32 * const ptr_audio_samples,const WORD32 num_audio_samples,ixheaace_mps_enc_ext_payload * pstr_mps_ext_payload)985 IA_ERRORCODE ixheaace_mps_212_process(VOID *pstr_handle_mps, FLOAT32 *const ptr_audio_samples,
986 const WORD32 num_audio_samples,
987 ixheaace_mps_enc_ext_payload *pstr_mps_ext_payload) {
988 IA_ERRORCODE error = IA_NO_ERROR;
989 ixheaace_mps_pstr_struct pstr_mps_enc = (ixheaace_mps_pstr_struct)pstr_handle_mps;
990 WORD32 aot = pstr_mps_enc->audio_object_type;
991 WORD32 sac_header_flag = 0;
992 WORD32 sac_out_buffer_offset = 0;
993
994 if (aot == AOT_AAC_ELD) {
995 pstr_mps_enc->sac_out_buffer[0] = (sac_header_flag == 0) ? 0x3 : 0x7;
996 sac_out_buffer_offset += 1;
997 }
998
999 pstr_mps_enc->p_in_buffer[0] = (VOID *)ptr_audio_samples;
1000 pstr_mps_enc->in_args.num_input_samples = num_audio_samples;
1001
1002 pstr_mps_enc->p_out_buffer[0] = (VOID *)ptr_audio_samples;
1003 pstr_mps_enc->p_out_buffer_size[0] = sizeof(FLOAT32) * ((WORD32)num_audio_samples) / 2;
1004
1005 pstr_mps_enc->p_out_buffer[1] = (VOID *)&pstr_mps_enc->sac_out_buffer[sac_out_buffer_offset];
1006 pstr_mps_enc->p_out_buffer_size[1] =
1007 sizeof(pstr_mps_enc->sac_out_buffer) - sac_out_buffer_offset;
1008
1009 error = ixheaace_mps_212_encode(pstr_mps_enc->ptr_sac_encoder, &pstr_mps_enc->in_buf_desc,
1010 &pstr_mps_enc->out_buf_desc, &pstr_mps_enc->in_args,
1011 &pstr_mps_enc->out_args, aot, pstr_mps_enc->ptr_scratch);
1012 if (error) {
1013 return error;
1014 }
1015
1016 pstr_mps_ext_payload->p_data = (UWORD8 *)pstr_mps_enc->sac_out_buffer;
1017 pstr_mps_ext_payload->data_size = pstr_mps_enc->out_args.num_output_bits;
1018 if (aot == AOT_AAC_ELD) {
1019 pstr_mps_ext_payload->data_size += 8 * (sac_out_buffer_offset - 1);
1020 }
1021 pstr_mps_ext_payload->data_type = IXHEAACE_MPS_EXT_LDSAC_DATA;
1022 pstr_mps_ext_payload->associated_ch_element = -1;
1023
1024 return error;
1025 }
1026
ixheaace_mps_212_get_spatial_specific_config(VOID * pstr_handle_mps,WORD8 * ptr_out_buffer,WORD32 buf_size,WORD32 aot)1027 WORD32 ixheaace_mps_212_get_spatial_specific_config(VOID *pstr_handle_mps, WORD8 *ptr_out_buffer,
1028 WORD32 buf_size, WORD32 aot) {
1029 ixheaace_bit_buf bit_buf;
1030 ixheaace_bit_buf_handle pstr_bit_buf =
1031 ia_enhaacplus_enc_create_bitbuffer(&bit_buf, (UWORD8 *)ptr_out_buffer, buf_size);
1032 ixheaace_mps_212_write_spatial_specific_config_data(pstr_handle_mps, pstr_bit_buf);
1033 if (aot == AOT_AAC_ELD) {
1034 ixheaace_byte_align_buffer(pstr_bit_buf);
1035 }
1036 return ia_enhaacplus_enc_get_bits_available(pstr_bit_buf);
1037 }
1038
ixheaace_mps_515_scratch_size(VOID)1039 WORD32 ixheaace_mps_515_scratch_size(VOID) {
1040 WORD32 size = 0;
1041 size += ((MAX_INPUT_CHANNELS * MAX_BUFFER_SIZE) * sizeof(FLOAT32));
1042 size += ((MAX_OUTPUT_CHANNELS * MAX_BUFFER_SIZE) * sizeof(FLOAT32));
1043 size +=
1044 (((MAX_INPUT_CHANNELS * MAX_BUFFER_SIZE) + (2 * MAX_BUFFER_SIZE) + (2 * MAX_BUFFER_SIZE)) *
1045 sizeof(FLOAT32));
1046 size += (((6 * MAX_TIME_SLOTS * NUM_QMF_BANDS) + (6 * MAX_TIME_SLOTS * NUM_QMF_BANDS) +
1047 (6 * MAX_TIME_SLOTS * NUM_QMF_BANDS) + (6 * MAX_TIME_SLOTS * NUM_QMF_BANDS) +
1048 (6 * MAX_TIME_SLOTS * MAX_HYBRID_BANDS) + (6 * MAX_TIME_SLOTS * MAX_HYBRID_BANDS)) *
1049 sizeof(FLOAT32));
1050 size += (INPUT_LEN_DOWNSAMPLE * IXHEAACE_MAX_CH_IN_BS_ELE * UPSAMPLE_FAC * sizeof(FLOAT32));
1051 size += (INPUT_LEN_DOWNSAMPLE * IXHEAACE_MAX_CH_IN_BS_ELE * UPSAMPLE_FAC * sizeof(FLOAT32));
1052 size = IXHEAAC_GET_SIZE_ALIGNED(size, BYTE_ALIGN_8);
1053 return size;
1054 }
1055
ixheaace_mps_515_open(VOID ** pstr_handle_mps,WORD32 sample_freq,WORD32 tree_config,ixheaace_bit_buf_handle pstr_bitstream,WORD32 * ptr_bits_written,ixheaace_mps_515_memory_struct * pstr_mps_memory,WORD32 flag_480)1056 IA_ERRORCODE ixheaace_mps_515_open(VOID **pstr_handle_mps, WORD32 sample_freq, WORD32 tree_config,
1057 ixheaace_bit_buf_handle pstr_bitstream,
1058 WORD32 *ptr_bits_written,
1059 ixheaace_mps_515_memory_struct *pstr_mps_memory,
1060 WORD32 flag_480) {
1061 WORD32 i;
1062 IA_ERRORCODE error = IA_NO_ERROR;
1063 ixheaace_mps_sac_specific_config *pstr_mps_specific_config;
1064 ixheaace_mps_sac_pstr_enc pstr_mps_enc = &pstr_mps_memory->spatial_enc_instance;
1065
1066 ixheaace_mps_sac_pstr_qmf_ana_filter_bank pstr_qmf_ana_bank = &pstr_mps_enc->qmf_fltbank;
1067 ixheaace_mps_sac_pstr_qmf_synth_filter_bank pstr_qmf_synth_bank =
1068 &pstr_mps_enc->qmf_synth_fltbank;
1069
1070 memset(pstr_mps_enc, 0, sizeof(ixheaace_mps_sac_enc));
1071 pstr_mps_enc->tree_config = tree_config;
1072 switch (tree_config) {
1073 case 5151:
1074 case 5152:
1075 pstr_mps_enc->output_channels = 1;
1076 break;
1077 case 525:
1078 pstr_mps_enc->output_channels = 2;
1079 }
1080 if (flag_480) {
1081 pstr_mps_enc->time_slots = 15;
1082 } else {
1083 pstr_mps_enc->time_slots = 16;
1084 }
1085
1086 pstr_mps_enc->frame_size = NUM_QMF_BANDS * pstr_mps_enc->time_slots;
1087
1088 pstr_qmf_ana_bank->p_filter = ia_mps_enc_qmf_64_640;
1089
1090 pstr_qmf_synth_bank->p_filter = ia_mps_enc_qmf_64_640;
1091 pstr_qmf_synth_bank->alt_sin_twiddle = sbr_alt_sin_twiddle;
1092 pstr_qmf_synth_bank->cos_twiddle = sbr_cos_twiddle;
1093 pstr_qmf_synth_bank->sin_twiddle = sbr_sin_twiddle;
1094
1095 for (i = 0; i < 6; i++) {
1096 memset(&pstr_mps_enc->filterbank[i], 0, sizeof(ixheaace_mps_sac_sbr_encoder_ana_filter_bank));
1097
1098 memset(&pstr_mps_enc->hyb_state[i], 0, sizeof(ixheaace_mps_hyb_filter_state));
1099 }
1100
1101 pstr_mps_enc->bitstream_formatter = &pstr_mps_memory->bsf_memory_instance;
1102 pstr_mps_specific_config = &pstr_mps_enc->bitstream_formatter->spatial_specific_config;
1103
1104 memset(pstr_mps_specific_config, 0, sizeof(ixheaace_mps_sac_specific_config));
1105
1106 pstr_mps_enc->bitstream_formatter->current_frame.bs_independency_flag_count = 0;
1107 pstr_mps_specific_config->bs_sampling_frequency = sample_freq;
1108
1109 switch (tree_config) {
1110 case 5151:
1111 pstr_mps_specific_config->bs_tree_config = IXHEAACE_MPS_TREE_5151;
1112 pstr_mps_specific_config->ott_config[4].bs_ott_bands = 2;
1113 break;
1114
1115 case 5152:
1116 pstr_mps_specific_config->bs_tree_config = IXHEAACE_MPS_TREE_5152;
1117 pstr_mps_specific_config->ott_config[2].bs_ott_bands = 2;
1118 break;
1119
1120 case 525:
1121 pstr_mps_specific_config->bs_tree_config = IXHEAACE_MPS_TREE_525;
1122 pstr_mps_specific_config->ott_config[0].bs_ott_bands = 2;
1123 pstr_mps_specific_config->ttt_config->bs_ttt_bands_low = PARAMETER_BANDS;
1124 pstr_mps_specific_config->ttt_config->bs_ttt_mode_low = 5;
1125 }
1126
1127 pstr_mps_specific_config->bs_frame_length = pstr_mps_enc->time_slots - 1;
1128 pstr_mps_specific_config->bs_freq_res = 2;
1129
1130 pstr_mps_specific_config->bs_fixed_gain_sur = 2;
1131 pstr_mps_specific_config->bs_fixed_gain_lfe = 1;
1132 pstr_mps_specific_config->bs_fixed_gain_dmx = 0;
1133
1134 error = ixheaace_mps_515_write_spatial_specific_config(pstr_bitstream,
1135 pstr_mps_enc->bitstream_formatter);
1136
1137 *ptr_bits_written = ia_enhaacplus_enc_get_bits_available(pstr_bitstream);
1138 *pstr_handle_mps = pstr_mps_enc;
1139 return error;
1140 }
1141
ixheaace_mps_515_apply(ixheaace_mps_sac_enc * pstr_mps_enc,FLOAT32 * ptr_audio_input,FLOAT32 * ptr_audio_output,ixheaace_bit_buf_handle pstr_bitstream,VOID * ptr_scratch)1142 IA_ERRORCODE ixheaace_mps_515_apply(ixheaace_mps_sac_enc *pstr_mps_enc, FLOAT32 *ptr_audio_input,
1143 FLOAT32 *ptr_audio_output,
1144 ixheaace_bit_buf_handle pstr_bitstream, VOID *ptr_scratch) {
1145 IA_ERRORCODE error = IA_NO_ERROR;
1146 FLOAT32 *pstr_scratch = (FLOAT32 *)ptr_scratch;
1147
1148 FLOAT32 *in = (FLOAT32 *)pstr_scratch;
1149 memset(in, 0, sizeof(*in) * MAX_INPUT_CHANNELS * MAX_BUFFER_SIZE);
1150 pstr_scratch += MAX_INPUT_CHANNELS * MAX_BUFFER_SIZE;
1151
1152 FLOAT32 *out = (FLOAT32 *)pstr_scratch;
1153 memset(out, 0, sizeof(*out) * 2 * MAX_BUFFER_SIZE);
1154 pstr_scratch += 2 * MAX_BUFFER_SIZE;
1155
1156 FLOAT32 *out1 = (FLOAT32 *)pstr_scratch;
1157 memset(out1, 0, sizeof(*out1) * 2 * MAX_BUFFER_SIZE);
1158 pstr_scratch += 2 * MAX_BUFFER_SIZE;
1159
1160 FLOAT32 *m_qmf_real = (FLOAT32 *)pstr_scratch;
1161 memset(m_qmf_real, 0, sizeof(*m_qmf_real) * 6 * MAX_TIME_SLOTS * NUM_QMF_BANDS);
1162 pstr_scratch += 6 * MAX_TIME_SLOTS * NUM_QMF_BANDS;
1163
1164 FLOAT32 *m_qmf_imag = (FLOAT32 *)pstr_scratch;
1165 memset(m_qmf_imag, 0, sizeof(*m_qmf_imag) * 6 * MAX_TIME_SLOTS * NUM_QMF_BANDS);
1166 pstr_scratch += 6 * MAX_TIME_SLOTS * NUM_QMF_BANDS;
1167
1168 FLOAT32 *m_hybrid_real = (FLOAT32 *)pstr_scratch;
1169 memset(m_hybrid_real, 0, sizeof(*m_hybrid_real) * 6 * MAX_TIME_SLOTS * MAX_HYBRID_BANDS);
1170 pstr_scratch += 6 * MAX_TIME_SLOTS * MAX_HYBRID_BANDS;
1171
1172 FLOAT32 *m_hybrid_imag = (FLOAT32 *)pstr_scratch;
1173 memset(m_hybrid_imag, 0, sizeof(*m_hybrid_imag) * 6 * MAX_TIME_SLOTS * MAX_HYBRID_BANDS);
1174 pstr_scratch += 6 * MAX_TIME_SLOTS * MAX_HYBRID_BANDS;
1175
1176 FLOAT32 *m_qmf_real_out = (FLOAT32 *)pstr_scratch;
1177 memset(m_qmf_real_out, 0, sizeof(*m_qmf_real_out) * 6 * MAX_TIME_SLOTS * NUM_QMF_BANDS);
1178 pstr_scratch += 6 * MAX_TIME_SLOTS * NUM_QMF_BANDS;
1179
1180 FLOAT32 *m_qmf_imag_out = (FLOAT32 *)pstr_scratch;
1181 memset(m_qmf_imag_out, 0, sizeof(*m_qmf_imag_out) * 6 * MAX_TIME_SLOTS * NUM_QMF_BANDS);
1182
1183 ixheaace_mps_sac_spatial_frame *pstr_frame_data;
1184 ixheaace_mps_sac_pstr_qmf_ana_filter_bank pstr_qmf_ana_bank = &pstr_mps_enc->qmf_fltbank;
1185 ixheaace_mps_sac_pstr_qmf_synth_filter_bank pstr_qmf_synth_bank =
1186 &pstr_mps_enc->qmf_synth_fltbank;
1187
1188 WORD32 i, j, k, l;
1189
1190 FLOAT32 p_pre_scale[6] = {1.f, 1.f, 1.f, 0.3162f, 0.7071f, 0.7071f};
1191 for (i = 0; i < DELAY_COMPENSATION; i++) {
1192 for (j = 0; j < 6; j++) {
1193 pstr_mps_enc->in1[j][i] = pstr_mps_enc->in1[j][i + pstr_mps_enc->frame_size];
1194 }
1195 }
1196
1197 for (i = 0; i < pstr_mps_enc->frame_size; i++) {
1198 for (j = 0; j < 6; j++) {
1199 pstr_mps_enc->in1[j][i + DELAY_COMPENSATION] = ptr_audio_input[i * 6 + j] * p_pre_scale[j];
1200 }
1201 }
1202
1203 for (i = 0; i < pstr_mps_enc->frame_size; i++) {
1204 for (j = 0; j < 6; j++) {
1205 in[j * MAX_BUFFER_SIZE + i] = ptr_audio_input[i * 6 + j] * p_pre_scale[j];
1206 }
1207 }
1208
1209 for (i = 0; i < pstr_mps_enc->frame_size; i++) {
1210 if (pstr_mps_enc->output_channels == 1)
1211 out1[i] = in[i] + in[MAX_BUFFER_SIZE + i] + in[2 * MAX_BUFFER_SIZE + i] +
1212 in[3 * MAX_BUFFER_SIZE + i] + in[4 * MAX_BUFFER_SIZE + i] +
1213 in[5 * MAX_BUFFER_SIZE + i];
1214 else {
1215 out1[i] = in[i] + 0.7071f * (in[2 * MAX_BUFFER_SIZE + i] + in[3 * MAX_BUFFER_SIZE + i]) +
1216 in[4 * MAX_BUFFER_SIZE + i];
1217 out1[MAX_BUFFER_SIZE + i] =
1218 in[MAX_BUFFER_SIZE + i] +
1219 0.7071f * (in[2 * MAX_BUFFER_SIZE + i] + in[3 * MAX_BUFFER_SIZE + i]) +
1220 in[5 * MAX_BUFFER_SIZE + i];
1221 }
1222 }
1223
1224 for (i = 0; i < pstr_mps_enc->frame_size; i++) {
1225 for (j = 0; j < 6; j++) {
1226 in[j * MAX_BUFFER_SIZE + i] = pstr_mps_enc->in1[j][i];
1227 }
1228 }
1229
1230 for (l = 0; l < pstr_mps_enc->time_slots; l++) {
1231 for (j = 0; j < 6; j++) {
1232 ixheaace_mps_515_calculate_ana_filterbank(
1233 &pstr_mps_enc->filterbank[j], in + (j * MAX_BUFFER_SIZE) + (l * 64),
1234 m_qmf_real + (j * MAX_TIME_SLOTS * NUM_QMF_BANDS) + (l * NUM_QMF_BANDS),
1235 m_qmf_imag + (j * MAX_TIME_SLOTS * NUM_QMF_BANDS) + (l * NUM_QMF_BANDS),
1236 pstr_qmf_ana_bank);
1237 }
1238 }
1239
1240 for (k = 0; k < 6; k++) {
1241 ixheaace_mps_515_apply_ana_hyb_filterbank(
1242 &pstr_mps_enc->hyb_state[k], m_qmf_real + (k * MAX_TIME_SLOTS * NUM_QMF_BANDS),
1243 m_qmf_imag + (k * MAX_TIME_SLOTS * NUM_QMF_BANDS), pstr_mps_enc->time_slots,
1244 m_hybrid_real + (k * MAX_TIME_SLOTS * MAX_HYBRID_BANDS),
1245 m_hybrid_imag + k * MAX_TIME_SLOTS * MAX_HYBRID_BANDS);
1246 }
1247
1248 pstr_frame_data = &pstr_mps_enc->bitstream_formatter->current_frame;
1249 switch (pstr_mps_enc->tree_config) {
1250 case 5151:
1251 ixheaace_mps_515_ott_box(pstr_mps_enc->time_slots, m_hybrid_real, m_hybrid_imag,
1252 m_hybrid_real + MAX_TIME_SLOTS * MAX_HYBRID_BANDS,
1253 m_hybrid_imag + MAX_TIME_SLOTS * MAX_HYBRID_BANDS,
1254 pstr_frame_data->ott_data.cld[3][0],
1255 pstr_frame_data->ott_data.icc[3][0]);
1256 ixheaace_mps_515_ott_box(
1257 pstr_mps_enc->time_slots, m_hybrid_real + 4 * MAX_TIME_SLOTS * MAX_HYBRID_BANDS,
1258 m_hybrid_imag + 4 * MAX_TIME_SLOTS * MAX_HYBRID_BANDS,
1259 m_hybrid_real + 5 * MAX_TIME_SLOTS * MAX_HYBRID_BANDS,
1260 m_hybrid_imag + 5 * MAX_TIME_SLOTS * MAX_HYBRID_BANDS,
1261 pstr_frame_data->ott_data.cld[2][0], pstr_frame_data->ott_data.icc[2][0]);
1262 ixheaace_mps_515_ott_box(
1263 pstr_mps_enc->time_slots, m_hybrid_real + 2 * MAX_TIME_SLOTS * MAX_HYBRID_BANDS,
1264 m_hybrid_imag + 2 * MAX_TIME_SLOTS * MAX_HYBRID_BANDS,
1265 m_hybrid_real + 3 * MAX_TIME_SLOTS * MAX_HYBRID_BANDS,
1266 m_hybrid_imag + 3 * MAX_TIME_SLOTS * MAX_HYBRID_BANDS,
1267 pstr_frame_data->ott_data.cld[4][0], pstr_frame_data->ott_data.icc[4][0]);
1268 ixheaace_mps_515_ott_box(pstr_mps_enc->time_slots, m_hybrid_real, m_hybrid_imag,
1269 m_hybrid_real + 2 * MAX_TIME_SLOTS * MAX_HYBRID_BANDS,
1270 m_hybrid_imag + 2 * MAX_TIME_SLOTS * MAX_HYBRID_BANDS,
1271 pstr_frame_data->ott_data.cld[1][0],
1272 pstr_frame_data->ott_data.icc[1][0]);
1273 ixheaace_mps_515_ott_box(pstr_mps_enc->time_slots, m_hybrid_real, m_hybrid_imag,
1274 m_hybrid_real + 4 * MAX_TIME_SLOTS * MAX_HYBRID_BANDS,
1275 m_hybrid_imag + 4 * MAX_TIME_SLOTS * MAX_HYBRID_BANDS,
1276 pstr_frame_data->ott_data.cld[0][0],
1277 pstr_frame_data->ott_data.icc[0][0]);
1278
1279 break;
1280 case 5152:
1281 ixheaace_mps_515_ott_box(pstr_mps_enc->time_slots, m_hybrid_real, m_hybrid_imag,
1282 m_hybrid_real + 4 * MAX_TIME_SLOTS * MAX_HYBRID_BANDS,
1283 m_hybrid_imag + 4 * MAX_TIME_SLOTS * MAX_HYBRID_BANDS,
1284 pstr_frame_data->ott_data.cld[3][0],
1285 pstr_frame_data->ott_data.icc[3][0]);
1286 ixheaace_mps_515_ott_box(
1287 pstr_mps_enc->time_slots, m_hybrid_real + MAX_TIME_SLOTS * MAX_HYBRID_BANDS,
1288 m_hybrid_imag + MAX_TIME_SLOTS * MAX_HYBRID_BANDS,
1289 m_hybrid_real + 5 * MAX_TIME_SLOTS * MAX_HYBRID_BANDS,
1290 m_hybrid_imag + 5 * MAX_TIME_SLOTS * MAX_HYBRID_BANDS,
1291 pstr_frame_data->ott_data.cld[4][0], pstr_frame_data->ott_data.icc[4][0]);
1292 ixheaace_mps_515_ott_box(
1293 pstr_mps_enc->time_slots, m_hybrid_real + 2 * MAX_TIME_SLOTS * MAX_HYBRID_BANDS,
1294 m_hybrid_imag + 2 * MAX_TIME_SLOTS * MAX_HYBRID_BANDS,
1295 m_hybrid_real + 3 * MAX_TIME_SLOTS * MAX_HYBRID_BANDS,
1296 m_hybrid_imag + 3 * MAX_TIME_SLOTS * MAX_HYBRID_BANDS,
1297 pstr_frame_data->ott_data.cld[2][0], pstr_frame_data->ott_data.icc[2][0]);
1298 ixheaace_mps_515_ott_box(pstr_mps_enc->time_slots, m_hybrid_real, m_hybrid_imag,
1299 m_hybrid_real + MAX_TIME_SLOTS * MAX_HYBRID_BANDS,
1300 m_hybrid_imag + MAX_TIME_SLOTS * MAX_HYBRID_BANDS,
1301 pstr_frame_data->ott_data.cld[1][0],
1302 pstr_frame_data->ott_data.icc[1][0]);
1303 ixheaace_mps_515_ott_box(pstr_mps_enc->time_slots, m_hybrid_real, m_hybrid_imag,
1304 m_hybrid_real + 2 * MAX_TIME_SLOTS * MAX_HYBRID_BANDS,
1305 m_hybrid_imag + 2 * MAX_TIME_SLOTS * MAX_HYBRID_BANDS,
1306 pstr_frame_data->ott_data.cld[0][0],
1307 pstr_frame_data->ott_data.icc[0][0]);
1308 break;
1309 case 525:
1310 ixheaace_mps_515_ott_box(pstr_mps_enc->time_slots, m_hybrid_real, m_hybrid_imag,
1311 m_hybrid_real + 4 * MAX_TIME_SLOTS * MAX_HYBRID_BANDS,
1312 m_hybrid_imag + 4 * MAX_TIME_SLOTS * MAX_HYBRID_BANDS,
1313 pstr_frame_data->ott_data.cld[1][0],
1314 pstr_frame_data->ott_data.icc[1][0]);
1315 ixheaace_mps_515_ott_box(
1316 pstr_mps_enc->time_slots, m_hybrid_real + MAX_TIME_SLOTS * MAX_HYBRID_BANDS,
1317 m_hybrid_imag + MAX_TIME_SLOTS * MAX_HYBRID_BANDS,
1318 m_hybrid_real + 5 * MAX_TIME_SLOTS * MAX_HYBRID_BANDS,
1319 m_hybrid_imag + 5 * MAX_TIME_SLOTS * MAX_HYBRID_BANDS,
1320 pstr_frame_data->ott_data.cld[2][0], pstr_frame_data->ott_data.icc[2][0]);
1321 ixheaace_mps_515_ott_box(
1322 pstr_mps_enc->time_slots, m_hybrid_real + 2 * MAX_TIME_SLOTS * MAX_HYBRID_BANDS,
1323 m_hybrid_imag + 2 * MAX_TIME_SLOTS * MAX_HYBRID_BANDS,
1324 m_hybrid_real + 3 * MAX_TIME_SLOTS * MAX_HYBRID_BANDS,
1325 m_hybrid_imag + 3 * MAX_TIME_SLOTS * MAX_HYBRID_BANDS,
1326 pstr_frame_data->ott_data.cld[0][0], pstr_frame_data->ott_data.icc[0][0]);
1327 ixheaace_mps_515_ttt_box(pstr_mps_enc->time_slots, m_hybrid_real, m_hybrid_imag,
1328 m_hybrid_real + MAX_TIME_SLOTS * MAX_HYBRID_BANDS,
1329 m_hybrid_imag + MAX_TIME_SLOTS * MAX_HYBRID_BANDS,
1330 m_hybrid_real + 2 * MAX_TIME_SLOTS * MAX_HYBRID_BANDS,
1331 m_hybrid_imag + 2 * MAX_TIME_SLOTS * MAX_HYBRID_BANDS,
1332 pstr_frame_data->ttt_data.cpc_cld1[0][0],
1333 pstr_frame_data->ttt_data.cpc_cld2[0][0]);
1334 }
1335
1336 pstr_frame_data->framing_info.bs_framing_type = 1;
1337 pstr_frame_data->framing_info.bs_num_param_sets = 1;
1338
1339 pstr_frame_data->framing_info.bs_param_slots[0] = 31;
1340 if (pstr_frame_data->bs_independency_flag_count == 0) {
1341 pstr_frame_data->bs_independency_flag = 1;
1342 }
1343 pstr_frame_data->bs_independency_flag_count =
1344 (pstr_frame_data->bs_independency_flag_count + 1) % 10;
1345
1346 error = ixheaace_mps_515_write_spatial_frame(pstr_bitstream, pstr_mps_enc->bitstream_formatter);
1347 if (error) {
1348 return error;
1349 }
1350
1351 if (pstr_mps_enc->output_channels == 1) {
1352 ixheaace_mps_515_apply_syn_hyb_filterbank(
1353 m_hybrid_real, m_hybrid_imag, pstr_mps_enc->time_slots, m_qmf_real_out, m_qmf_imag_out);
1354
1355 ixheaace_mps_515_calculate_sbr_syn_filterbank(m_qmf_real_out, m_qmf_imag_out, out, 0,
1356 pstr_qmf_synth_bank, pstr_mps_enc->time_slots,
1357 pstr_mps_enc->sbr_qmf_states_synthesis);
1358
1359 for (j = 0; j < pstr_mps_enc->frame_size; j++) {
1360 ptr_audio_output[j] = out1[j];
1361 }
1362 } else {
1363 ixheaace_mps_515_apply_syn_hyb_filterbank(
1364 m_hybrid_real, m_hybrid_imag, pstr_mps_enc->time_slots, m_qmf_real_out, m_qmf_imag_out);
1365 ixheaace_mps_515_apply_syn_hyb_filterbank(m_hybrid_real + MAX_TIME_SLOTS * MAX_HYBRID_BANDS,
1366 m_hybrid_imag + MAX_TIME_SLOTS * MAX_HYBRID_BANDS,
1367 pstr_mps_enc->time_slots,
1368 m_qmf_real_out + MAX_TIME_SLOTS * MAX_HYBRID_BANDS,
1369 m_qmf_imag_out + MAX_TIME_SLOTS * MAX_HYBRID_BANDS);
1370
1371 ixheaace_mps_515_calculate_sbr_syn_filterbank(m_qmf_real_out, m_qmf_imag_out, out, 0,
1372 pstr_qmf_synth_bank, pstr_mps_enc->time_slots,
1373 pstr_mps_enc->sbr_qmf_states_synthesis);
1374 ixheaace_mps_515_calculate_sbr_syn_filterbank(
1375 m_qmf_real_out + MAX_TIME_SLOTS * MAX_HYBRID_BANDS,
1376 m_qmf_imag_out + MAX_TIME_SLOTS * MAX_HYBRID_BANDS, out + MAX_BUFFER_SIZE, 1,
1377 pstr_qmf_synth_bank, pstr_mps_enc->time_slots, pstr_mps_enc->sbr_qmf_states_synthesis);
1378
1379 for (j = 0; j < pstr_mps_enc->frame_size; j++) {
1380 ptr_audio_output[2 * j] = out1[j];
1381 ptr_audio_output[2 * j + 1] = out1[MAX_BUFFER_SIZE + j];
1382 }
1383 }
1384 return IA_NO_ERROR;
1385 }
1386
ixheaace_mps_515_close(ixheaace_mps_sac_enc * pstr_mps_enc)1387 VOID ixheaace_mps_515_close(ixheaace_mps_sac_enc *pstr_mps_enc) {
1388 if (pstr_mps_enc != NULL) {
1389 pstr_mps_enc->bitstream_formatter = NULL;
1390 }
1391 }
1392