1 /******************************************************************************
2 * *
3 * Copyright (C) 2018 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 #include <string.h>
21 #include "ixheaacd_sbr_common.h"
22 #include "ixheaac_type_def.h"
23
24 #include "ixheaac_constants.h"
25 #include "ixheaac_basic_ops32.h"
26 #include "ixheaac_basic_ops16.h"
27 #include "ixheaac_basic_ops40.h"
28 #include "ixheaac_basic_ops.h"
29 #include "ixheaacd_defines.h"
30 #include "ixheaacd_error_codes.h"
31
32 #include "ixheaacd_intrinsics.h"
33 #include "ixheaac_sbr_const.h"
34 #include "ixheaac_basic_op.h"
35 #include "ixheaacd_defines.h"
36 #include "ixheaacd_bitbuffer.h"
37 #include "ixheaacd_pns.h"
38
39 #include "ixheaacd_aac_rom.h"
40 #include "ixheaacd_pulsedata.h"
41
42 #include "ixheaacd_drc_data_struct.h"
43 #include "ixheaacd_lt_predict.h"
44 #include "ixheaacd_cnst.h"
45 #include "ixheaacd_ec_defines.h"
46 #include "ixheaacd_ec_struct_def.h"
47 #include "ixheaacd_channelinfo.h"
48 #include "ixheaacd_drc_dec.h"
49
50 #include "ixheaacd_sbrdecoder.h"
51
52 #include "ixheaacd_sbrdecsettings.h"
53 #include "ixheaacd_sbr_scale.h"
54 #include "ixheaacd_lpp_tran.h"
55 #include "ixheaacd_env_extr_part.h"
56 #include "ixheaacd_sbr_rom.h"
57 #include "ixheaacd_hybrid.h"
58 #include "ixheaacd_ps_dec.h"
59 #include "ixheaacd_ps_bitdec.h"
60 #include "ixheaacd_env_extr.h"
61 #include "ixheaacd_common_rom.h"
62 #include "ixheaacd_freq_sca.h"
63
64 #include "ixheaacd_qmf_dec.h"
65
66 #include "ixheaacd_env_calc.h"
67
68 #include "ixheaacd_pvc_dec.h"
69 #include "ixheaacd_sbr_dec.h"
70 #include "ixheaacd_env_dec.h"
71 #include "ixheaacd_basic_funcs.h"
72 #include "ixheaacd_sbr_crc.h"
73
74 #include "ixheaacd_audioobjtypes.h"
75
ixheaacd_ec_set_frame_error_flag(ia_sbr_element_stream_struct * pstr_sbr_element,WORD32 value)76 static VOID ixheaacd_ec_set_frame_error_flag(ia_sbr_element_stream_struct *pstr_sbr_element,
77 WORD32 value) {
78 if (pstr_sbr_element != NULL) {
79 switch (value) {
80 case FRAME_ERROR_ALLSLOTS:
81 pstr_sbr_element->frame_error_flag[0] = FRAME_ERROR;
82 pstr_sbr_element->frame_error_flag[1] = FRAME_ERROR;
83 break;
84 default:
85 pstr_sbr_element->frame_error_flag[pstr_sbr_element->use_frame_slot] = value;
86 }
87 }
88 }
89
ixheaacd_downmix_to_monosbr(WORD16 * core_sample_buf,WORD32 ch_fac)90 VOID ixheaacd_downmix_to_monosbr(WORD16 *core_sample_buf, WORD32 ch_fac) {
91 WORD32 i;
92 WORD16 *ptr1 = &core_sample_buf[0];
93 WORD16 *ptr2 = &core_sample_buf[1];
94
95 for (i = MAX_FRAME_SIZE - 1; i >= 0; i--) {
96 *ptr1 = ((*ptr1 >> 1) + (*ptr2 >> 1));
97
98 ptr1 += ch_fac;
99 ptr2 += ch_fac;
100 }
101 }
102
ixheaacd_sbr_dec_reset(ia_sbr_dec_struct * ptr_sbr_dec,ia_sbr_header_data_struct * ptr_header_data,FLAG low_pow_flag,ixheaacd_misc_tables * pstr_common_tables,WORD32 pitch_in_bins,WORD32 audio_object_type,WORD32 * ptr_work_buf_core)103 static WORD32 ixheaacd_sbr_dec_reset(ia_sbr_dec_struct *ptr_sbr_dec,
104 ia_sbr_header_data_struct *ptr_header_data,
105 FLAG low_pow_flag,
106 ixheaacd_misc_tables *pstr_common_tables,
107 WORD32 pitch_in_bins,
108 WORD32 audio_object_type,
109 WORD32 *ptr_work_buf_core) {
110 WORD32 old_lsb, new_lsb;
111 WORD32 l;
112 WORD32 err = 0;
113 WORD32 num_time_slots = ptr_sbr_dec->str_codec_qmf_bank.num_time_slots;
114 WORD32 upsample_ratio_idx = ptr_header_data->sbr_ratio_idx;
115 WORD32 op_delay = 6 + SBR_HF_ADJ_OFFSET;
116 WORD32 hbe_flag = ptr_header_data->hbe_flag;
117 WORD32 usac_flag = ptr_header_data->usac_flag;
118
119 if (ptr_header_data->is_usf_4) {
120 op_delay = op_delay + 6;
121 }
122
123 ixheaacd_reset_sbrenvelope_calc(&ptr_sbr_dec->str_sbr_calc_env);
124
125 new_lsb = ptr_header_data->pstr_freq_band_data->sub_band_start;
126 ptr_sbr_dec->str_synthesis_qmf_bank.lsb = new_lsb;
127 ptr_sbr_dec->str_synthesis_qmf_bank.usb =
128 ptr_header_data->pstr_freq_band_data->sub_band_end;
129
130 old_lsb = ptr_sbr_dec->str_synthesis_qmf_bank.lsb;
131 ptr_sbr_dec->str_codec_qmf_bank.lsb = 0;
132 ptr_sbr_dec->str_codec_qmf_bank.usb = old_lsb;
133
134 {
135 WORD32 *plpc_filt_states_real =
136 &ptr_sbr_dec->str_hf_generator.lpc_filt_states_real[0][old_lsb];
137 WORD32 *plpc_filt_states_real_1 =
138 &ptr_sbr_dec->str_hf_generator.lpc_filt_states_real[1][old_lsb];
139
140 WORD32 *plpc_filt_states_imag =
141 &ptr_sbr_dec->str_hf_generator.lpc_filt_states_imag[0][old_lsb];
142 WORD32 *plpc_filt_states_imag_1 =
143 &ptr_sbr_dec->str_hf_generator.lpc_filt_states_imag[1][old_lsb];
144
145 for (l = new_lsb - old_lsb - 1; l >= 0; l--) {
146 *plpc_filt_states_real++ = *plpc_filt_states_real_1++ = 0L;
147
148 if (!low_pow_flag) {
149 *plpc_filt_states_imag++ = *plpc_filt_states_imag_1++ = 0L;
150 }
151 }
152 }
153 if (1) {
154 WORD32 start_band;
155 WORD32 stop_band;
156 WORD32 start_slot = SBR_HF_ADJ_OFFSET;
157 WORD32 k;
158
159 start_band = ptr_header_data->pstr_freq_band_data->qmf_sb_prev;
160 stop_band = ptr_header_data->pstr_freq_band_data->sub_band_start;
161 if (usac_flag && !hbe_flag) {
162 for (l = 0; l < SBR_HF_ADJ_OFFSET; l++) {
163 for (k = start_band; k < stop_band; k++) {
164 ptr_sbr_dec->qmf_buf_real[l][k] = 0.0;
165 ptr_sbr_dec->qmf_buf_imag[l][k] = 0.0;
166 }
167 }
168 for (l = start_slot; l < op_delay; l++) {
169 for (k = start_band; k < stop_band; k++) {
170 ptr_sbr_dec->qmf_buf_real[l][k] = 0.0;
171 ptr_sbr_dec->qmf_buf_imag[l][k] = 0.0;
172 }
173 }
174 }
175 if (ptr_sbr_dec->p_hbe_txposer != NULL && (usac_flag || hbe_flag)) {
176 WORD32 k, i;
177 WORD32 dft_hbe_flag = ptr_header_data->esbr_hq;
178 if (dft_hbe_flag == 1) {
179 err = ixheaacd_dft_hbe_data_reinit(
180 ptr_sbr_dec->p_hbe_txposer,
181 ptr_header_data->pstr_freq_band_data->freq_band_table,
182 ptr_header_data->pstr_freq_band_data->num_sf_bands);
183 } else {
184 err = ixheaacd_qmf_hbe_data_reinit(
185 ptr_sbr_dec->p_hbe_txposer,
186 ptr_header_data->pstr_freq_band_data->freq_band_table,
187 ptr_header_data->pstr_freq_band_data->num_sf_bands,
188 ptr_header_data->is_usf_4);
189 }
190 if (err) return err;
191
192 for (k = 0; k < 2; k++) {
193 if (!((upsample_ratio_idx == SBR_UPSAMPLE_IDX_4_1) && (k == 0))) {
194 WORD32 xpos_delay = num_time_slots * k;
195 if (upsample_ratio_idx == SBR_UPSAMPLE_IDX_4_1) {
196 xpos_delay = num_time_slots * k - 32;
197 }
198
199 for (i = 0; i < 8; i++) {
200 memmove(ptr_sbr_dec->ph_vocod_qmf_real[i],
201 ptr_sbr_dec->ph_vocod_qmf_real[num_time_slots + i],
202 64 * sizeof(FLOAT32));
203 memmove(ptr_sbr_dec->ph_vocod_qmf_imag[i],
204 ptr_sbr_dec->ph_vocod_qmf_imag[num_time_slots + i],
205 64 * sizeof(FLOAT32));
206 }
207 if (dft_hbe_flag == 1) {
208 err = ixheaacd_dft_hbe_apply(
209 ptr_sbr_dec->p_hbe_txposer,
210 ptr_sbr_dec->qmf_buf_real + op_delay + xpos_delay,
211 ptr_sbr_dec->qmf_buf_imag + op_delay + xpos_delay, num_time_slots,
212 ptr_sbr_dec->ph_vocod_qmf_real + op_delay,
213 ptr_sbr_dec->ph_vocod_qmf_imag + op_delay, pitch_in_bins,
214 (FLOAT32 *)ptr_work_buf_core);
215 if (err)
216 return err;
217 } else {
218 err = ixheaacd_qmf_hbe_apply(
219 ptr_sbr_dec->p_hbe_txposer,
220 ptr_sbr_dec->qmf_buf_real + op_delay + xpos_delay,
221 ptr_sbr_dec->qmf_buf_imag + op_delay + xpos_delay, num_time_slots,
222 ptr_sbr_dec->ph_vocod_qmf_real + op_delay,
223 ptr_sbr_dec->ph_vocod_qmf_imag + op_delay, pitch_in_bins,
224 ptr_header_data);
225 if (err) return err;
226 }
227
228 if (upsample_ratio_idx == SBR_UPSAMPLE_IDX_4_1) {
229 ixheaacd_hbe_repl_spec(&ptr_sbr_dec->p_hbe_txposer->x_over_qmf[0],
230 ptr_sbr_dec->ph_vocod_qmf_real + op_delay,
231 ptr_sbr_dec->ph_vocod_qmf_imag + op_delay,
232 num_time_slots,
233 ptr_sbr_dec->p_hbe_txposer->max_stretch);
234 }
235 }
236 }
237 }
238 }
239
240 if (!usac_flag) {
241 err |= ixheaacd_reset_hf_generator(&ptr_sbr_dec->str_hf_generator,
242 ptr_header_data, audio_object_type);
243
244 ixheaacd_derive_lim_band_tbl(
245 ptr_header_data,
246 ptr_sbr_dec->str_hf_generator.pstr_settings->str_patch_param,
247 ptr_sbr_dec->str_hf_generator.pstr_settings->num_patches,
248 pstr_common_tables);
249 }
250
251 return err;
252 }
253
ixheaacd_prepare_upsamp(ia_sbr_header_data_struct ** ptr_header_data,ia_sbr_channel_struct * pstr_sbr_channel[2],WORD32 num_channels)254 VOID ixheaacd_prepare_upsamp(ia_sbr_header_data_struct **ptr_header_data,
255 ia_sbr_channel_struct *pstr_sbr_channel[2],
256 WORD32 num_channels) {
257 WORD32 lr;
258 ia_sbr_qmf_filter_bank_struct *sbr_qmf_bank;
259
260 for (lr = 0; lr < num_channels; lr++) {
261 ptr_header_data[lr]->pstr_freq_band_data->sub_band_start =
262 NO_ANALYSIS_CHANNELS;
263 ptr_header_data[lr]->pstr_freq_band_data->sub_band_end =
264 NO_SYNTHESIS_CHANNELS;
265
266 sbr_qmf_bank = &pstr_sbr_channel[lr]->str_sbr_dec.str_synthesis_qmf_bank;
267 sbr_qmf_bank->lsb = NO_ANALYSIS_CHANNELS;
268 sbr_qmf_bank->usb = NO_SYNTHESIS_CHANNELS;
269
270 sbr_qmf_bank = &pstr_sbr_channel[lr]->str_sbr_dec.str_codec_qmf_bank;
271 sbr_qmf_bank->lsb = 0;
272 sbr_qmf_bank->usb = NO_ANALYSIS_CHANNELS;
273 ptr_header_data[lr]->sync_state = UPSAMPLING;
274 }
275 return;
276 }
277
ixheaacd_copy_prev_ps_params(ia_ps_dec_struct * ps_config_curr,ia_ps_dec_config_struct * ps_config_prev,WORD32 frame_status)278 static VOID ixheaacd_copy_prev_ps_params(ia_ps_dec_struct *ps_config_curr,
279 ia_ps_dec_config_struct *ps_config_prev,
280 WORD32 frame_status) {
281 if (frame_status == 0) {
282 ps_config_curr->enable_iid = ps_config_prev->enable_iid;
283 ps_config_curr->iid_mode = ps_config_prev->iid_mode;
284 ps_config_curr->enable_icc = ps_config_prev->enable_icc;
285 ps_config_curr->icc_mode = ps_config_prev->icc_mode;
286 ps_config_curr->frame_class = ps_config_prev->frame_class;
287 ps_config_curr->freq_res_ipd = ps_config_prev->freq_res_ipd;
288 memcpy(ps_config_curr->border_position, ps_config_prev->border_position,
289 sizeof(ps_config_curr->border_position));
290 memcpy(ps_config_curr->iid_dt, ps_config_prev->iid_dt, sizeof(ps_config_curr->iid_dt));
291 memcpy(ps_config_curr->iid_par_table, ps_config_prev->iid_par_table,
292 sizeof(ps_config_curr->iid_par_table));
293 memcpy(ps_config_curr->icc_dt, ps_config_prev->icc_dt, sizeof(ps_config_curr->icc_dt));
294 memcpy(ps_config_curr->icc_par_table, ps_config_prev->icc_par_table,
295 sizeof(ps_config_curr->icc_par_table));
296 } else {
297 ps_config_prev->enable_iid = ps_config_curr->enable_iid;
298 ps_config_prev->iid_mode = ps_config_curr->iid_mode;
299 ps_config_prev->enable_icc = ps_config_curr->enable_icc;
300 ps_config_prev->icc_mode = ps_config_curr->icc_mode;
301 ps_config_prev->frame_class = ps_config_curr->frame_class;
302 ps_config_prev->freq_res_ipd = ps_config_curr->freq_res_ipd;
303 memcpy(ps_config_prev->border_position, ps_config_curr->border_position,
304 sizeof(ps_config_prev->border_position));
305 memcpy(ps_config_prev->iid_dt, ps_config_curr->iid_dt, sizeof(ps_config_prev->iid_dt));
306 memcpy(ps_config_prev->iid_par_table, ps_config_curr->iid_par_table,
307 sizeof(ps_config_prev->iid_par_table));
308 memcpy(ps_config_prev->icc_dt, ps_config_curr->icc_dt, sizeof(ps_config_prev->icc_dt));
309 memcpy(ps_config_prev->icc_par_table, ps_config_curr->icc_par_table,
310 sizeof(ps_config_prev->icc_par_table));
311 }
312 }
ixheaacd_applysbr(ia_handle_sbr_dec_inst_struct self,ia_aac_dec_sbr_bitstream_struct * p_sbr_bit_stream,WORD16 * core_sample_buf,WORD16 * codec_num_channels,FLAG frame_status,FLAG down_samp_flag,FLAG down_mix_flag,ia_sbr_scr_struct * sbr_scratch_struct,WORD32 ps_enable,WORD32 ch_fac,WORD32 slot_element,ia_bit_buf_struct * it_bit_buff,ia_drc_dec_struct * pstr_drc_dec,WORD eld_sbr_flag,WORD32 audio_object_type,WORD32 init_flag,WORD32 ldmps_present,WORD32 frame_size,WORD32 heaac_mps_present,WORD32 ec_flag,FLAG first_frame)313 IA_ERRORCODE ixheaacd_applysbr(
314 ia_handle_sbr_dec_inst_struct self, ia_aac_dec_sbr_bitstream_struct *p_sbr_bit_stream,
315 WORD16 *core_sample_buf, WORD16 *codec_num_channels, FLAG frame_status, FLAG down_samp_flag,
316 FLAG down_mix_flag, ia_sbr_scr_struct *sbr_scratch_struct, WORD32 ps_enable, WORD32 ch_fac,
317 WORD32 slot_element, ia_bit_buf_struct *it_bit_buff, ia_drc_dec_struct *pstr_drc_dec,
318 WORD eld_sbr_flag, WORD32 audio_object_type, WORD32 init_flag, WORD32 ldmps_present,
319 WORD32 frame_size, WORD32 heaac_mps_present, WORD32 ec_flag, FLAG first_frame) {
320 WORD32 k;
321 FLAG prev_ps_flag = 0;
322 FLAG ps_flag = 0;
323 FLAG stereo = 0;
324 FLAG low_pow_flag = 0;
325 FLAG header_flag = 1;
326 FLAG dual_mono = 0;
327 WORD32 err = 0;
328 WORD32 num_channels = *codec_num_channels;
329 FLAG prev_stereo;
330 WORD32 ele_channels = 0;
331 WORD32 num_elements = p_sbr_bit_stream->no_elements;
332 WORD32 usac_flag = self->aot_usac_flag;
333 WORD32 total_bits_left = 0;
334
335 ia_sbr_channel_struct *pstr_sbr_channel[2];
336 ia_sbr_header_data_struct *ptr_header_data[MAXNRSBRCHANNELS];
337
338 WORD32 initial_sync_state;
339
340 ia_sbr_header_data_struct *ptr_sbr_dflt_header =
341 (ia_sbr_header_data_struct *)(&self->str_sbr_dflt_header);
342
343 ia_sbr_frame_info_data_struct *ptr_frame_data[2];
344 self->num_delay_frames = 1;
345 self->ptr_mps_data = NULL;
346
347 if (!ec_flag || !usac_flag) {
348 for (k = 0; k < 2; k++) {
349 ptr_frame_data[k] = (ia_sbr_frame_info_data_struct *)self->frame_buffer[k];
350
351 pstr_sbr_channel[k] = self->pstr_sbr_channel[k];
352
353 ptr_header_data[k] = self->pstr_sbr_header[k];
354
355 if (audio_object_type == AOT_ER_AAC_ELD) {
356 ptr_frame_data[k]->eld_sbr_flag = eld_sbr_flag;
357 ptr_frame_data[k]->num_time_slots = ptr_header_data[0]->num_time_slots;
358 }
359
360 ptr_frame_data[k]->usac_independency_flag = self->usac_independency_flag;
361 ptr_frame_data[k]->mps_sbr_flag = (self->stereo_config_idx == 3) ? 1 : 0;
362 ptr_frame_data[k]->stereo_config_idx = self->stereo_config_idx;
363 ptr_frame_data[k]->inter_tes_flag = self->inter_tes_flag;
364 ptr_frame_data[k]->sbr_mode = self->sbr_mode;
365
366 if (!usac_flag) {
367 ptr_frame_data[k]->usac_independency_flag = 0;
368 ptr_frame_data[k]->mps_sbr_flag = 0;
369 ptr_frame_data[k]->stereo_config_idx = -1;
370 ptr_frame_data[k]->inter_tes_flag = 0;
371 ptr_frame_data[k]->sbr_mode = ORIG_SBR;
372 }
373 }
374
375 if (init_flag) {
376 ptr_frame_data[1]->reset_flag = 1;
377 ptr_frame_data[0]->reset_flag = 1;
378 }
379
380 for (k = 0; k < *codec_num_channels; k++) {
381 ptr_header_data[k]->usac_flag = self->aot_usac_flag;
382 ptr_header_data[k]->enh_sbr = self->enh_sbr;
383 ptr_header_data[k]->enh_sbr_ps =
384 ((self->enh_sbr_ps) | (ptr_header_data[k]->channel_mode == PS_STEREO));
385
386 ptr_header_data[k]->usac_independency_flag = self->usac_independency_flag;
387 ptr_header_data[k]->hbe_flag = self->hbe_flag;
388 ptr_header_data[k]->pvc_flag = self->pvc_flag;
389
390 if (!usac_flag) {
391 ptr_header_data[k]->usac_independency_flag = 0;
392 ptr_header_data[k]->hbe_flag = 0;
393 ptr_header_data[k]->pvc_flag = 0;
394 }
395 if (self->enh_sbr)
396 {
397 ptr_header_data[k]->esbr_hq = self->esbr_hq;
398 }
399
400 if (!usac_flag && (!(audio_object_type == AOT_ER_AAC_ELD ||
401 audio_object_type == AOT_ER_AAC_LD)) && self->enh_sbr) {
402 ptr_header_data[k]->hbe_flag = 1;
403 }
404 }
405
406 initial_sync_state = ptr_header_data[0]->sync_state;
407
408 low_pow_flag = !usac_flag;
409 self->pstr_sbr_tables->sbr_rand_ph = self->pstr_sbr_tables->env_calc_tables_ptr->sbr_rand_ph;
410
411 if (ps_enable) {
412 if (num_channels == 1) {
413 low_pow_flag = 0;
414 }
415 }
416
417 if (audio_object_type == AOT_ER_AAC_ELD || (ps_enable && heaac_mps_present)) {
418 low_pow_flag = 0;
419 }
420
421 prev_stereo = (ptr_header_data[0]->channel_mode == SBR_STEREO);
422
423 if (ps_enable) prev_ps_flag = (ptr_header_data[0]->channel_mode == PS_STEREO);
424
425 ptr_header_data[0]->err_flag_prev = ptr_header_data[0]->err_flag;
426
427 if (p_sbr_bit_stream->no_elements == 0) {
428 frame_status = 0;
429 ptr_header_data[0]->sync_state = UPSAMPLING;
430 if (num_channels == 2) ptr_header_data[1]->sync_state = UPSAMPLING;
431 }
432
433 if ((usac_flag)) {
434 if ((p_sbr_bit_stream->no_elements) && (p_sbr_bit_stream->str_sbr_ele->size_payload > 0)) {
435 num_elements = p_sbr_bit_stream->no_elements;
436 } else {
437 num_elements = 0;
438 }
439 }
440
441 for (k = 0; k < num_elements; k++) {
442 struct ia_bit_buf_struct local_bit_buf = {0};
443 ia_sbr_element_stream_struct *ptr_bit_str_ele = &p_sbr_bit_stream->str_sbr_ele[k];
444 ele_channels = (p_sbr_bit_stream->str_sbr_ele[0].sbr_ele_id == SBR_ID_CPE) ? 2 : 1;
445 if (!frame_status && ptr_header_data[k]->sync_state == SBR_ACTIVE && ec_flag) {
446 ixheaacd_ec_set_frame_error_flag(ptr_bit_str_ele, FRAME_ERROR_ALLSLOTS);
447 }
448
449 switch (ptr_bit_str_ele->sbr_ele_id) {
450 case SBR_ID_SCE:
451 case SBR_ID_CCE:
452 if (num_channels == 2) {
453 dual_mono = 1;
454 }
455 stereo = 0;
456 break;
457 case SBR_ID_CPE:
458 stereo = 1;
459 ptr_header_data[1] = ptr_header_data[0];
460
461 memcpy(self->pstr_sbr_header[1], self->pstr_sbr_header[0],
462 sizeof(ia_sbr_header_data_struct));
463 break;
464 default:
465 frame_status = 0;
466 }
467
468 if (frame_status) {
469 if (!usac_flag) {
470 if (!(audio_object_type == AOT_ER_AAC_LD || audio_object_type == AOT_ER_AAC_ELD)
471 && self->enh_sbr) {
472 WORD8 tmp[1024];
473 WORD32 tmp_payload;
474 memcpy(&tmp[0], ptr_bit_str_ele->ptr_sbr_data, ptr_bit_str_ele->size_payload);
475 memcpy(ptr_bit_str_ele->ptr_sbr_data, ptr_bit_str_ele->ptr_prev_sbr_data,
476 ptr_bit_str_ele->prev_size_payload);
477 memcpy(ptr_bit_str_ele->ptr_prev_sbr_data, &tmp[0], ptr_bit_str_ele->size_payload);
478 tmp_payload = ptr_bit_str_ele->size_payload;
479 ptr_bit_str_ele->size_payload = ptr_bit_str_ele->prev_size_payload;
480 ptr_bit_str_ele->prev_size_payload = tmp_payload;
481 }
482 if (!ptr_bit_str_ele->size_payload) {
483 continue;
484 }
485
486 ixheaacd_create_init_bit_buf(&local_bit_buf, (UWORD8 *)ptr_bit_str_ele->ptr_sbr_data,
487 ptr_bit_str_ele->size_payload);
488 it_bit_buff = &local_bit_buf;
489 it_bit_buff->xaac_jmp_buf = self->xaac_jmp_buf;
490 total_bits_left = it_bit_buff->cnt_bits;
491
492 if (audio_object_type == AOT_ER_AAC_ELD) {
493 if (eld_sbr_flag != 1) {
494 ixheaacd_read_bits_buf(&local_bit_buf, LEN_NIBBLE);
495 }
496 } else {
497 ixheaacd_read_bits_buf(&local_bit_buf, LEN_NIBBLE);
498 }
499 }
500 if (ptr_bit_str_ele->extension_type == SBR_EXTENSION_CRC) {
501 WORD32 crc_bits = 0;
502 WORD32 crc_check_flag = 0;
503 crc_check_flag = 1;
504 crc_bits = (((ptr_bit_str_ele->size_payload - 1) << 3) + (4 - SBR_CYC_REDCY_CHK_BITS));
505
506 if (crc_bits < 0) {
507 crc_check_flag = 0;
508 frame_status = 0;
509 }
510 if (crc_check_flag) frame_status = ixheaacd_sbr_crccheck(it_bit_buff, crc_bits);
511 }
512
513 if (!usac_flag) header_flag = ixheaacd_read_bits_buf(it_bit_buff, 1);
514
515 if (audio_object_type != AOT_ER_AAC_ELD) {
516 if (header_flag) {
517 header_flag = ixheaacd_sbr_read_header_data(ptr_header_data[k], it_bit_buff, stereo,
518 ptr_sbr_dflt_header);
519 if (usac_flag) {
520 if ((self->ptr_pvc_data_str->prev_pvc_mode == 0) &&
521 (ptr_header_data[k]->pvc_mode != 0)) {
522 self->ptr_pvc_data_str->prev_pvc_id = 0;
523 }
524 self->ptr_pvc_data_str->prev_pvc_mode = ptr_header_data[k]->pvc_mode;
525 if (ptr_header_data[k]->pvc_mode == 0) {
526 ptr_frame_data[k]->sbr_mode = ORIG_SBR;
527 } else {
528 ptr_frame_data[k]->sbr_mode = PVC_SBR;
529 }
530 }
531 if (header_flag == SBR_RESET) {
532 err = ixheaacd_calc_frq_bnd_tbls(ptr_header_data[k],
533
534 self->pstr_common_tables);
535 if (!err) {
536 WORD32 lr;
537 WORD32 lr1 = ps_enable ? 2 : num_channels;
538 for (lr = 0; lr < lr1; lr++) {
539 if (ldmps_present != 1) ptr_frame_data[lr]->reset_flag = 1;
540 if ((SBR_NOT_INITIALIZED == ptr_header_data[lr]->sync_state) && !usac_flag) {
541 ptr_frame_data[lr]->sbr_patching_mode = 1;
542 ptr_frame_data[lr]->over_sampling_flag = 0;
543 ptr_frame_data[lr]->pitch_in_bins = 0;
544 ptr_header_data[lr]->pre_proc_flag = 0;
545 }
546 err |= ixheaacd_sbr_dec_reset(
547 &(pstr_sbr_channel[lr]->str_sbr_dec), ptr_header_data[k], low_pow_flag,
548 self->pstr_common_tables, ptr_frame_data[k]->pitch_in_bins,
549 audio_object_type, sbr_scratch_struct->ptr_work_buf_core);
550 if (err < 0) return err;
551 }
552 }
553
554 if (err == 0) {
555 ptr_header_data[k]->sync_state = SBR_ACTIVE;
556 }
557 }
558 }
559 } else {
560 if (header_flag) {
561 header_flag = ixheaacd_sbr_read_header_data(ptr_header_data[k], it_bit_buff, stereo,
562 ptr_sbr_dflt_header);
563 if (usac_flag) {
564 if ((self->ptr_pvc_data_str->prev_pvc_mode == 0) &&
565 (ptr_header_data[k]->pvc_mode != 0)) {
566 self->ptr_pvc_data_str->prev_pvc_id = 0;
567 }
568 self->ptr_pvc_data_str->prev_pvc_mode = ptr_header_data[k]->pvc_mode;
569 if (ptr_header_data[k]->pvc_mode == 0) {
570 ptr_frame_data[k]->sbr_mode = ORIG_SBR;
571 } else {
572 ptr_frame_data[k]->sbr_mode = PVC_SBR;
573 }
574 }
575
576 if (header_flag == SBR_RESET) {
577 err = ixheaacd_calc_frq_bnd_tbls(ptr_header_data[k],
578
579 self->pstr_common_tables);
580 if (err) {
581 return err;
582 }
583 }
584 }
585
586 {
587 WORD32 lr;
588 WORD32 lr1 = ps_enable ? 2 : num_channels;
589 for (lr = 0; lr < lr1; lr++) {
590 if (ldmps_present != 1) ptr_frame_data[lr]->reset_flag = 1;
591 if (ptr_header_data[k]->status) {
592 err |= ixheaacd_sbr_dec_reset(
593 &(pstr_sbr_channel[lr]->str_sbr_dec), ptr_header_data[k], low_pow_flag,
594 self->pstr_common_tables, ptr_frame_data[k]->pitch_in_bins, audio_object_type,
595 sbr_scratch_struct->ptr_work_buf_core);
596 if (err < 0) return err;
597 }
598 }
599 ptr_header_data[k]->status = 0;
600 }
601
602 if (err == 0) {
603 ptr_header_data[k]->sync_state = SBR_ACTIVE;
604 }
605 }
606 }
607
608 if (err || (ptr_header_data[k]->sync_state == SBR_NOT_INITIALIZED)) {
609 WORD32 lr1 = ps_enable ? 2 : num_channels;
610 ixheaacd_prepare_upsamp(ptr_header_data, pstr_sbr_channel, lr1);
611 if (err) return err;
612 }
613
614 if (frame_status && (ptr_header_data[k]->sync_state == SBR_ACTIVE)) {
615 if (stereo) {
616 frame_status = ixheaacd_sbr_read_cpe(ptr_header_data[0], ptr_frame_data, it_bit_buff,
617 self->pstr_sbr_tables, audio_object_type);
618 if (usac_flag && (frame_status == 0)) return -1;
619 if (frame_status < 0) return frame_status;
620 } else {
621 if (ps_enable) {
622 if (down_mix_flag) {
623 self->pstr_ps_stereo_dec->force_mono = 1;
624 } else {
625 self->pstr_ps_stereo_dec->force_mono = 0;
626 }
627 } else {
628 self->pstr_ps_stereo_dec = 0;
629 }
630 if (ptr_frame_data[k]->sbr_mode == ORIG_SBR) {
631 frame_status = ixheaacd_sbr_read_sce(
632 ptr_header_data[k], ptr_frame_data[k], self->pstr_ps_stereo_dec, it_bit_buff,
633 self->pstr_sbr_tables, audio_object_type, ec_flag);
634 if (usac_flag && (frame_status == 0)) return -1;
635 if (frame_status < 0) return frame_status;
636 if (ec_flag && self->pstr_ps_stereo_dec != NULL) {
637 ixheaacd_copy_prev_ps_params(self->pstr_ps_stereo_dec, &self->str_ps_config_prev,
638 frame_status);
639 }
640 } else if (ptr_frame_data[k]->sbr_mode == PVC_SBR) {
641 frame_status = ixheaacd_sbr_read_pvc_sce(ptr_frame_data[k], it_bit_buff, 0,
642 self->ptr_pvc_data_str,
643 self->pstr_sbr_tables, ptr_header_data[k]);
644 if (frame_status < 0) return frame_status;
645 }
646 }
647 ptr_header_data[k]->enh_sbr_ps =
648 ((self->enh_sbr_ps) | (ptr_header_data[0]->channel_mode == PS_STEREO));
649 if ((audio_object_type != AOT_ER_AAC_ELD) && (audio_object_type != AOT_USAC)) {
650 WORD32 total_bits_read;
651 total_bits_read = ixheaacd_no_bits_read(it_bit_buff);
652 if (total_bits_read > (ptr_bit_str_ele->size_payload << 3) ||
653 total_bits_read < ((ptr_bit_str_ele->size_payload << 3) - 8)) {
654 frame_status = 0;
655 }
656 if (ec_flag) {
657 if (!frame_status) {
658 ixheaacd_ec_set_frame_error_flag(ptr_bit_str_ele, FRAME_ERROR);
659 } else {
660 ixheaacd_ec_set_frame_error_flag(ptr_bit_str_ele, FRAME_OK);
661 }
662 }
663 }
664 }
665 if ((ldmps_present == 1) && (it_bit_buff)) {
666 WORD32 bits_decoded = (it_bit_buff->size - it_bit_buff->cnt_bits);
667 self->ptr_mps_data = (WORD8 *)it_bit_buff->ptr_read_next;
668 self->left_mps_bits = (total_bits_left - bits_decoded);
669 self->mps_bits_pos = it_bit_buff->bit_pos;
670 }
671 if (ec_flag) {
672 if (frame_status && !init_flag) {
673 ptr_bit_str_ele->use_frame_slot =
674 (ptr_bit_str_ele->use_frame_slot + 1) % (self->num_delay_frames + 1);
675 }
676 if (ptr_header_data[0]->sync_state == SBR_ACTIVE) {
677 ptr_header_data[k]->err_flag =
678 ptr_bit_str_ele->frame_error_flag[ptr_bit_str_ele->use_frame_slot];
679 }
680 }
681 }
682
683 if (!usac_flag) {
684 if (!frame_status || (ptr_header_data[0]->sync_state != SBR_ACTIVE) ||
685 ptr_header_data[0]->err_flag) {
686 ptr_header_data[0]->err_flag = 1;
687 stereo = (num_channels == 2) ? 1 : 0;
688 if (ptr_header_data[0]->channel_mode == 0) {
689 ptr_header_data[0]->channel_mode = stereo ? SBR_STEREO : SBR_MONO;
690 }
691 }
692
693 if (!(stereo || dual_mono)) {
694 ptr_frame_data[0]->coupling_mode = COUPLING_OFF;
695 ptr_frame_data[1]->coupling_mode = COUPLING_OFF;
696 }
697
698 if (ptr_header_data[0]->sync_state == SBR_NOT_INITIALIZED && (!ec_flag || init_flag)) {
699 WORD32 lr1 = ps_enable ? 2 : num_channels;
700 ixheaacd_prepare_upsamp(ptr_header_data, pstr_sbr_channel, lr1);
701 }
702 }
703
704 if (ptr_header_data[0]->sync_state == SBR_ACTIVE) {
705 if (ptr_frame_data[0]->sbr_mode == PVC_SBR) {
706 err = ixheaacd_dec_sbrdata_for_pvc(ptr_header_data[0], ptr_frame_data[0],
707 pstr_sbr_channel[0]->pstr_prev_frame_data,
708 audio_object_type);
709 if (err) return err;
710 } else if (ptr_frame_data[0]->sbr_mode == ORIG_SBR) {
711 err = ixheaacd_dec_sbrdata(
712 ptr_header_data[0], ptr_header_data[1], ptr_frame_data[0],
713 pstr_sbr_channel[0]->pstr_prev_frame_data,
714 (stereo || dual_mono) ? ptr_frame_data[1] : NULL,
715 (stereo || dual_mono) ? pstr_sbr_channel[1]->pstr_prev_frame_data : NULL,
716 self->pstr_common_tables, ldmps_present, audio_object_type, ec_flag);
717
718 if (err) return err;
719 }
720
721 if (ptr_header_data[0]->channel_mode == PS_STEREO &&
722 (audio_object_type != AOT_ER_AAC_ELD && audio_object_type != AOT_ER_AAC_LD)) {
723 ixheaacd_decode_ps_data(self->pstr_ps_stereo_dec, frame_size);
724 ps_flag = 1;
725 self->ps_present = ps_flag;
726 }
727 if (ptr_header_data[0]->enh_sbr_ps && self->enh_sbr) {
728 ps_flag = 1;
729 self->ps_present = ps_flag;
730 }
731 ptr_frame_data[0]->max_qmf_subband_aac =
732 ptr_header_data[0]->pstr_freq_band_data->sub_band_start;
733 if (stereo) {
734 ptr_frame_data[1]->max_qmf_subband_aac =
735 ptr_header_data[1]->pstr_freq_band_data->sub_band_start;
736 }
737 if (ldmps_present == 1) {
738 ptr_frame_data[0]->rate = 1;
739 if (stereo) {
740 ptr_frame_data[1]->rate = 1;
741 }
742 }
743 }
744 if (audio_object_type == AOT_ER_AAC_ELD && ec_flag) {
745 if ((initial_sync_state == SBR_NOT_INITIALIZED) && ptr_header_data[0]->err_flag) {
746 ptr_header_data[0]->sync_state = SBR_NOT_INITIALIZED;
747 }
748 } else {
749 if (audio_object_type != AOT_ER_AAC_ELD) {
750 if ((initial_sync_state == SBR_NOT_INITIALIZED) && ptr_header_data[0]->err_flag) {
751 ptr_header_data[0]->sync_state = SBR_NOT_INITIALIZED;
752 }
753 } else {
754 ptr_header_data[0]->sync_state = SBR_ACTIVE;
755 }
756 }
757
758 if ((num_channels == 2) && !(stereo || dual_mono)) {
759 ixheaacd_downmix_to_monosbr(&core_sample_buf[slot_element], ch_fac);
760 }
761
762 if ((!prev_stereo && !prev_ps_flag) && (ps_flag)) {
763 WORD32 copy_size;
764 if (down_samp_flag)
765 copy_size = QMF_FILTER_STATE_SYN_SIZE_DOWN_SAMPLED;
766 else
767 copy_size = QMF_FILTER_STATE_SYN_SIZE;
768
769 memcpy(pstr_sbr_channel[1]->str_sbr_dec.str_synthesis_qmf_bank.filter_states,
770 pstr_sbr_channel[0]->str_sbr_dec.str_synthesis_qmf_bank.filter_states,
771 copy_size * sizeof(WORD16));
772
773 pstr_sbr_channel[1]->str_sbr_dec.str_sbr_scale_fact.st_syn_scale =
774 pstr_sbr_channel[0]->str_sbr_dec.str_sbr_scale_fact.st_syn_scale;
775 }
776
777 if ((!prev_stereo && stereo && (num_channels == 2)) &&
778 (audio_object_type != AOT_ER_AAC_ELD)) {
779 WORD32 copy_size;
780 if (down_samp_flag)
781 copy_size = QMF_FILTER_STATE_SYN_SIZE_DOWN_SAMPLED;
782 else
783 copy_size = QMF_FILTER_STATE_SYN_SIZE;
784
785 memcpy(pstr_sbr_channel[1]->str_sbr_dec.str_synthesis_qmf_bank.filter_states,
786 pstr_sbr_channel[0]->str_sbr_dec.str_synthesis_qmf_bank.filter_states,
787 copy_size * sizeof(WORD16));
788
789 pstr_sbr_channel[1]->str_sbr_dec.str_sbr_scale_fact.st_syn_scale =
790 pstr_sbr_channel[0]->str_sbr_dec.str_sbr_scale_fact.st_syn_scale;
791
792 memcpy(pstr_sbr_channel[1]->str_sbr_dec.str_codec_qmf_bank.anal_filter_states,
793 pstr_sbr_channel[0]->str_sbr_dec.str_codec_qmf_bank.anal_filter_states,
794 QMF_FILTER_STATE_ANA_SIZE * sizeof(WORD16));
795
796 pstr_sbr_channel[1]->str_sbr_dec.str_sbr_scale_fact.st_lb_scale =
797 pstr_sbr_channel[0]->str_sbr_dec.str_sbr_scale_fact.st_lb_scale;
798
799 memcpy(pstr_sbr_channel[1]->str_sbr_dec.ptr_sbr_overlap_buf,
800 pstr_sbr_channel[0]->str_sbr_dec.ptr_sbr_overlap_buf,
801 MAX_OV_COLS * NO_SYNTHESIS_CHANNELS * sizeof(WORD32));
802
803 pstr_sbr_channel[1]->str_sbr_dec.str_sbr_scale_fact.ov_lb_scale =
804 pstr_sbr_channel[0]->str_sbr_dec.str_sbr_scale_fact.ov_lb_scale;
805 pstr_sbr_channel[1]->str_sbr_dec.str_sbr_scale_fact.ov_hb_scale =
806 pstr_sbr_channel[0]->str_sbr_dec.str_sbr_scale_fact.ov_hb_scale;
807 }
808 pstr_sbr_channel[0]->str_sbr_dec.time_sample_buf = self->time_sample_buf[0];
809 if (self->pstr_ps_stereo_dec != NULL &&
810 (ps_enable || self->enh_sbr_ps) && self->enh_sbr) {
811 self->pstr_ps_stereo_dec->pp_qmf_buf_real[0] =
812 pstr_sbr_channel[0]->str_sbr_dec.pp_qmf_buf_real;
813 self->pstr_ps_stereo_dec->pp_qmf_buf_imag[0] =
814 pstr_sbr_channel[0]->str_sbr_dec.pp_qmf_buf_imag;
815 self->pstr_ps_stereo_dec->pp_qmf_buf_real[1] =
816 pstr_sbr_channel[1]->str_sbr_dec.pp_qmf_buf_real;
817 self->pstr_ps_stereo_dec->pp_qmf_buf_imag[1] =
818 pstr_sbr_channel[1]->str_sbr_dec.pp_qmf_buf_imag;
819 self->pstr_ps_stereo_dec->time_sample_buf[0] = self->time_sample_buf[0];
820 self->pstr_ps_stereo_dec->time_sample_buf[1] = self->time_sample_buf[1];
821 }
822 } else {
823 for (k = 0; k < 2; k++) {
824 ptr_frame_data[k] = (ia_sbr_frame_info_data_struct *)self->frame_buffer[k];
825
826 pstr_sbr_channel[k] = self->pstr_sbr_channel[k];
827
828 ptr_header_data[k] = self->pstr_sbr_header[k];
829 ptr_header_data[k]->usac_flag = self->aot_usac_flag;
830 }
831
832 if ((p_sbr_bit_stream->no_elements) && (p_sbr_bit_stream->str_sbr_ele->size_payload > 0)) {
833 num_elements = p_sbr_bit_stream->no_elements;
834 } else {
835 num_elements = 0;
836 }
837
838 for (k = 0; k < num_elements; k++) {
839 ia_sbr_element_stream_struct *ptr_bit_str_ele = &p_sbr_bit_stream->str_sbr_ele[k];
840 ele_channels = (p_sbr_bit_stream->str_sbr_ele[0].sbr_ele_id == SBR_ID_CPE) ? 2 : 1;
841 {
842 switch (ptr_bit_str_ele->sbr_ele_id) {
843 case SBR_ID_SCE:
844 case SBR_ID_CCE:
845 if (num_channels == 2) {
846 dual_mono = 1;
847 }
848 stereo = 0;
849 break;
850 case SBR_ID_CPE:
851 stereo = 1;
852 ptr_header_data[1] = ptr_header_data[0];
853
854 memcpy(self->pstr_sbr_header[1], self->pstr_sbr_header[0],
855 sizeof(ia_sbr_header_data_struct));
856 break;
857 default:
858 frame_status = 0;
859 }
860 }
861 }
862 }
863 if (ec_flag) {
864 for (k = 0; k < 2; k++) {
865 if (pstr_sbr_channel[k]->str_sbr_dec.band_count == 0) {
866 pstr_sbr_channel[k]->str_sbr_dec.band_count =
867 pstr_sbr_channel[k]->str_sbr_dec.str_codec_qmf_bank.no_channels;
868 }
869 }
870 }
871 if (ec_flag && usac_flag && !first_frame && !self->sbr_parse_complete) {
872 return IA_FATAL_ERROR;
873 }
874 if (!ec_flag || !first_frame || init_flag) {
875 if (pstr_drc_dec == NULL) {
876 WORD32 err_code = 0;
877 err_code = ixheaacd_sbr_dec(
878 &pstr_sbr_channel[0]->str_sbr_dec, core_sample_buf + slot_element, ptr_header_data[0],
879 ptr_frame_data[0], pstr_sbr_channel[0]->pstr_prev_frame_data, self->pstr_ps_stereo_dec,
880 &pstr_sbr_channel[1]->str_sbr_dec.str_synthesis_qmf_bank,
881 &pstr_sbr_channel[1]->str_sbr_dec.str_sbr_scale_fact,
882 (ptr_header_data[0]->sync_state == SBR_ACTIVE), low_pow_flag,
883 sbr_scratch_struct->ptr_work_buf_core, self->pstr_sbr_tables, self->pstr_common_tables,
884 ch_fac, self->ptr_pvc_data_str, 0, NULL, audio_object_type, ldmps_present, self,
885 heaac_mps_present, ec_flag);
886 if (err_code) return err_code;
887 if (self->enh_sbr)
888 {
889 if (!self->enh_sbr_ps) {
890 if ((ptr_header_data[0]->sync_state == SBR_ACTIVE) && !ptr_frame_data[0]->mps_sbr_flag
891 && ch_fac != 2) {
892 ptr_header_data[0]->pstr_freq_band_data[0].qmf_sb_prev =
893 ptr_header_data[0]->pstr_freq_band_data->sub_band_start;
894 }
895 } else {
896 if (ptr_header_data[0]->sync_state == SBR_ACTIVE) {
897 ptr_header_data[0]->pstr_freq_band_data[0].qmf_sb_prev =
898 ptr_header_data[0]->pstr_freq_band_data->sub_band_start;
899 }
900 }
901 }
902 } else {
903 WORD32 err_code = 0;
904 err_code = ixheaacd_sbr_dec(
905 &pstr_sbr_channel[0]->str_sbr_dec, core_sample_buf + slot_element, ptr_header_data[0],
906 ptr_frame_data[0], pstr_sbr_channel[0]->pstr_prev_frame_data, self->pstr_ps_stereo_dec,
907 &pstr_sbr_channel[1]->str_sbr_dec.str_synthesis_qmf_bank,
908 &pstr_sbr_channel[1]->str_sbr_dec.str_sbr_scale_fact,
909 (ptr_header_data[0]->sync_state == SBR_ACTIVE), low_pow_flag,
910 sbr_scratch_struct->ptr_work_buf_core, self->pstr_sbr_tables, self->pstr_common_tables,
911 ch_fac, self->ptr_pvc_data_str, pstr_drc_dec->drc_on,
912 pstr_drc_dec->str_drc_channel_data[0].drc_factors_sbr, audio_object_type, ldmps_present,
913 self, heaac_mps_present, ec_flag);
914 if (err_code) return err_code;
915 if (self->enh_sbr)
916 {
917 if (!self->enh_sbr_ps) {
918 if ((ptr_header_data[0]->sync_state == SBR_ACTIVE) && !ptr_frame_data[0]->mps_sbr_flag
919 && num_channels != 2) {
920 ptr_header_data[0]->pstr_freq_band_data[0].qmf_sb_prev =
921 ptr_header_data[0]->pstr_freq_band_data->sub_band_start;
922 }
923 } else {
924 if (ptr_header_data[0]->sync_state == SBR_ACTIVE) {
925 ptr_header_data[0]->pstr_freq_band_data[0].qmf_sb_prev =
926 ptr_header_data[0]->pstr_freq_band_data->sub_band_start;
927 }
928 }
929 }
930 }
931
932 if (!down_mix_flag && (stereo || dual_mono) && (num_channels == 2)) {
933 pstr_sbr_channel[1]->str_sbr_dec.time_sample_buf = self->time_sample_buf[1];
934
935 if (ele_channels == 1 && usac_flag) {
936 WORD32 err_code =
937 ixheaacd_esbr_dec(&pstr_sbr_channel[1]->str_sbr_dec, ptr_header_data[1],
938 ptr_frame_data[1], (ptr_header_data[1]->sync_state == SBR_ACTIVE),
939 low_pow_flag, self->pstr_sbr_tables, ch_fac);
940 if (err_code) return err_code;
941 } else {
942 if (pstr_drc_dec == NULL) {
943 WORD32 err_code = ixheaacd_sbr_dec(
944 &pstr_sbr_channel[1]->str_sbr_dec, core_sample_buf + slot_element + 1,
945 ptr_header_data[1], ptr_frame_data[1], pstr_sbr_channel[1]->pstr_prev_frame_data,
946 NULL, NULL, NULL, (ptr_header_data[1]->sync_state == SBR_ACTIVE), low_pow_flag,
947 sbr_scratch_struct->ptr_work_buf_core, self->pstr_sbr_tables,
948 self->pstr_common_tables, ch_fac, self->ptr_pvc_data_str, 0, NULL,
949 audio_object_type, ldmps_present, self, heaac_mps_present, ec_flag);
950 if (err_code) return err_code;
951 if (self->enh_sbr)
952 {
953 if (!self->enh_sbr_ps) {
954 if ((ptr_header_data[1]->sync_state == SBR_ACTIVE) &&
955 !ptr_frame_data[0]->mps_sbr_flag) {
956 ptr_header_data[1]->pstr_freq_band_data[0].qmf_sb_prev =
957 ptr_header_data[1]->pstr_freq_band_data->sub_band_start;
958 }
959 } else {
960 if (ptr_header_data[1]->sync_state == SBR_ACTIVE) {
961 ptr_header_data[1]->pstr_freq_band_data[0].qmf_sb_prev =
962 ptr_header_data[1]->pstr_freq_band_data->sub_band_start;
963 }
964 }
965 }
966 } else {
967 WORD32 err_code = ixheaacd_sbr_dec(
968 &pstr_sbr_channel[1]->str_sbr_dec, core_sample_buf + slot_element + 1,
969 ptr_header_data[1], ptr_frame_data[1], pstr_sbr_channel[1]->pstr_prev_frame_data,
970 NULL, NULL, NULL, (ptr_header_data[1]->sync_state == SBR_ACTIVE), low_pow_flag,
971 sbr_scratch_struct->ptr_work_buf_core, self->pstr_sbr_tables,
972 self->pstr_common_tables, ch_fac, self->ptr_pvc_data_str, pstr_drc_dec->drc_on,
973 pstr_drc_dec->str_drc_channel_data[1].drc_factors_sbr, audio_object_type,
974 ldmps_present, self, heaac_mps_present, ec_flag);
975 if (err_code) return err_code;
976 if (self->enh_sbr)
977 {
978 if (!self->enh_sbr_ps) {
979 if ((ptr_header_data[1]->sync_state == SBR_ACTIVE) &&
980 !ptr_frame_data[0]->mps_sbr_flag) {
981 ptr_header_data[1]->pstr_freq_band_data[0].qmf_sb_prev =
982 ptr_header_data[1]->pstr_freq_band_data->sub_band_start;
983 }
984 } else {
985 if (ptr_header_data[1]->sync_state == SBR_ACTIVE) {
986 ptr_header_data[1]->pstr_freq_band_data[0].qmf_sb_prev =
987 ptr_header_data[1]->pstr_freq_band_data->sub_band_start;
988 }
989 }
990 }
991 }
992 }
993
994 } else {
995 if (audio_object_type != AOT_ER_AAC_ELD && audio_object_type != AOT_ER_AAC_LD)
996
997 {
998 if (sub_d((WORD16)ptr_header_data[0]->channel_mode, PS_STEREO) == 0) {
999 num_channels = 2;
1000 }
1001 if (ptr_header_data[0]->enh_sbr_ps && self->enh_sbr) {
1002 num_channels = 2;
1003 }
1004 }
1005 }
1006 *codec_num_channels = num_channels;
1007 self->sbr_mode = ptr_frame_data[0]->sbr_mode;
1008
1009 if ((audio_object_type == AOT_ER_AAC_ELD) || (audio_object_type == AOT_ER_AAC_LD) ||
1010 !self->enh_sbr) {
1011 if (pstr_drc_dec != NULL) {
1012 WORD32 i, j;
1013 for (i = 0; i < *codec_num_channels; i++) {
1014 for (j = 0; j < 32; j++) {
1015 memcpy(pstr_drc_dec->str_drc_channel_data[i].drc_factors_sbr[j],
1016 pstr_drc_dec->str_drc_channel_data[i].drc_factors_sbr[j + 32],
1017 64 * sizeof(WORD32));
1018 }
1019 }
1020 }
1021 }
1022 if (ec_flag) {
1023 self->band_count[0] = pstr_sbr_channel[0]->str_sbr_dec.band_count;
1024 self->band_count[1] = pstr_sbr_channel[1]->str_sbr_dec.band_count;
1025 }
1026 }
1027
1028 return SBRDEC_OK;
1029 }
1030
ixheaacd_parse_sbr(ia_handle_sbr_dec_inst_struct self,ia_aac_dec_sbr_bitstream_struct * p_sbr_bit_stream,WORD16 * codec_num_channels,FLAG frame_status,ia_sbr_scr_struct * sbr_scratch_struct,ia_bit_buf_struct * it_bit_buff,WORD32 audio_object_type)1031 IA_ERRORCODE ixheaacd_parse_sbr(ia_handle_sbr_dec_inst_struct self,
1032 ia_aac_dec_sbr_bitstream_struct *p_sbr_bit_stream,
1033 WORD16 *codec_num_channels, FLAG frame_status,
1034 ia_sbr_scr_struct *sbr_scratch_struct,
1035 ia_bit_buf_struct *it_bit_buff, WORD32 audio_object_type) {
1036 WORD32 k;
1037 FLAG ps_flag = 0;
1038 FLAG stereo = 0;
1039 FLAG low_pow_flag = 0;
1040 FLAG header_flag = 1;
1041 FLAG dual_mono = 0;
1042 WORD32 err = 0;
1043 WORD32 num_channels = *codec_num_channels;
1044 FLAG prev_stereo;
1045 WORD32 num_elements = p_sbr_bit_stream->no_elements;
1046 WORD32 usac_flag = self->aot_usac_flag;
1047
1048 ia_sbr_channel_struct *pstr_sbr_channel[2];
1049 ia_sbr_header_data_struct *ptr_header_data[MAXNRSBRCHANNELS];
1050
1051 WORD32 initial_sync_state;
1052
1053 ia_sbr_header_data_struct *ptr_sbr_dflt_header =
1054 (ia_sbr_header_data_struct *)(&self->str_sbr_dflt_header);
1055
1056 ia_sbr_frame_info_data_struct *ptr_frame_data[2];
1057
1058 self->num_delay_frames = 1;
1059
1060 self->ptr_mps_data = NULL;
1061
1062 if (usac_flag && self->ec_flag) {
1063 for (k = 0; k < 2; k++) {
1064 ptr_frame_data[k] = (ia_sbr_frame_info_data_struct *)self->frame_buffer[k];
1065
1066 pstr_sbr_channel[k] = self->pstr_sbr_channel[k];
1067
1068 ptr_header_data[k] = self->pstr_sbr_header[k];
1069
1070 ptr_frame_data[k]->usac_independency_flag = self->usac_independency_flag;
1071 ptr_frame_data[k]->mps_sbr_flag = (self->stereo_config_idx == 3) ? 1 : 0;
1072 ptr_frame_data[k]->stereo_config_idx = self->stereo_config_idx;
1073 ptr_frame_data[k]->inter_tes_flag = self->inter_tes_flag;
1074 ptr_frame_data[k]->sbr_mode = self->sbr_mode;
1075 }
1076
1077 for (k = 0; k < *codec_num_channels; k++) {
1078 ptr_header_data[k]->usac_flag = self->aot_usac_flag;
1079
1080 ptr_header_data[k]->enh_sbr = self->enh_sbr;
1081 ptr_header_data[k]->enh_sbr_ps =
1082 ((self->enh_sbr_ps) | (ptr_header_data[k]->channel_mode == PS_STEREO));
1083 ptr_header_data[k]->usac_independency_flag = self->usac_independency_flag;
1084 ptr_header_data[k]->hbe_flag = self->hbe_flag;
1085 ptr_header_data[k]->pvc_flag = self->pvc_flag;
1086
1087 ptr_header_data[k]->esbr_hq = self->esbr_hq;
1088 }
1089
1090 initial_sync_state = ptr_header_data[0]->sync_state;
1091
1092 low_pow_flag = 0;
1093 self->pstr_sbr_tables->sbr_rand_ph = self->pstr_sbr_tables->env_calc_tables_ptr->sbr_rand_ph;
1094
1095 prev_stereo = (ptr_header_data[0]->channel_mode == SBR_STEREO);
1096
1097 ptr_header_data[0]->err_flag_prev = ptr_header_data[0]->err_flag;
1098
1099 if (p_sbr_bit_stream->no_elements == 0) {
1100 frame_status = 0;
1101 ptr_header_data[0]->sync_state = UPSAMPLING;
1102 if (num_channels == 2) ptr_header_data[1]->sync_state = UPSAMPLING;
1103 }
1104
1105 if ((p_sbr_bit_stream->no_elements) && (p_sbr_bit_stream->str_sbr_ele->size_payload > 0)) {
1106 num_elements = p_sbr_bit_stream->no_elements;
1107 } else {
1108 num_elements = 0;
1109 }
1110
1111 for (k = 0; k < num_elements; k++) {
1112 ia_sbr_element_stream_struct *ptr_bit_str_ele = &p_sbr_bit_stream->str_sbr_ele[k];
1113
1114 switch (ptr_bit_str_ele->sbr_ele_id) {
1115 case SBR_ID_SCE:
1116 case SBR_ID_CCE:
1117 if (num_channels == 2) {
1118 dual_mono = 1;
1119 }
1120 stereo = 0;
1121 break;
1122 case SBR_ID_CPE:
1123 stereo = 1;
1124 ptr_header_data[1] = ptr_header_data[0];
1125
1126 memcpy(self->pstr_sbr_header[1], self->pstr_sbr_header[0],
1127 sizeof(*(self->pstr_sbr_header[1])));
1128 break;
1129 default:
1130 frame_status = 0;
1131 }
1132
1133 if (frame_status) {
1134 if (ptr_bit_str_ele->extension_type == SBR_EXTENSION_CRC) {
1135 WORD32 crc_bits = 0;
1136 WORD32 crc_check_flag = 0;
1137 crc_check_flag = 1;
1138 crc_bits = (((ptr_bit_str_ele->size_payload - 1) << 3) + (4 - SBR_CYC_REDCY_CHK_BITS));
1139
1140 if (crc_bits < 0) {
1141 crc_check_flag = 0;
1142 frame_status = 0;
1143 }
1144 if (crc_check_flag && frame_status == 1)
1145 frame_status = ixheaacd_sbr_crccheck(it_bit_buff, crc_bits);
1146 }
1147
1148 if (frame_status == 1) {
1149 header_flag = ixheaacd_sbr_read_header_data(ptr_header_data[k], it_bit_buff, stereo,
1150 ptr_sbr_dflt_header);
1151 }
1152 if (usac_flag) {
1153 if ((self->ptr_pvc_data_str->prev_pvc_mode == 0) &&
1154 (ptr_header_data[k]->pvc_mode != 0)) {
1155 self->ptr_pvc_data_str->prev_pvc_id = 0;
1156 }
1157 self->ptr_pvc_data_str->prev_pvc_mode = ptr_header_data[k]->pvc_mode;
1158 if (ptr_header_data[k]->pvc_mode == 0) {
1159 ptr_frame_data[k]->sbr_mode = ORIG_SBR;
1160 } else {
1161 ptr_frame_data[k]->sbr_mode = PVC_SBR;
1162 }
1163 }
1164 if (header_flag == SBR_RESET) {
1165 err = ixheaacd_calc_frq_bnd_tbls(ptr_header_data[k],
1166
1167 self->pstr_common_tables);
1168 if (!err) {
1169 WORD32 lr;
1170 WORD32 lr1 = num_channels;
1171 for (lr = 0; lr < lr1; lr++) {
1172 ptr_frame_data[lr]->reset_flag = 1;
1173 if ((SBR_NOT_INITIALIZED == ptr_header_data[lr]->sync_state) && !usac_flag) {
1174 ptr_frame_data[lr]->sbr_patching_mode = 1;
1175 ptr_frame_data[lr]->over_sampling_flag = 0;
1176 ptr_frame_data[lr]->pitch_in_bins = 0;
1177 ptr_header_data[lr]->pre_proc_flag = 0;
1178 }
1179
1180 err |= ixheaacd_sbr_dec_reset(
1181 &(pstr_sbr_channel[lr]->str_sbr_dec), ptr_header_data[k], low_pow_flag,
1182 self->pstr_common_tables, ptr_frame_data[k]->pitch_in_bins, audio_object_type,
1183 sbr_scratch_struct->ptr_work_buf_core);
1184 if (err < 0) {
1185 if (self->ec_flag) {
1186 self->frame_ok = 0;
1187 } else {
1188 return err;
1189 }
1190 }
1191 }
1192 }
1193
1194 if (err == 0) {
1195 ptr_header_data[k]->sync_state = SBR_ACTIVE;
1196 }
1197 }
1198 }
1199
1200 if (err || (ptr_header_data[k]->sync_state == SBR_NOT_INITIALIZED)) {
1201 WORD32 lr1 = num_channels;
1202 ixheaacd_prepare_upsamp(ptr_header_data, pstr_sbr_channel, lr1);
1203 if (err && !self->ec_flag) {
1204 return err;
1205 }
1206 }
1207
1208 if (frame_status && (ptr_header_data[k]->sync_state == SBR_ACTIVE)) {
1209 if (stereo) {
1210 frame_status = ixheaacd_sbr_read_cpe(ptr_header_data[0], ptr_frame_data, it_bit_buff,
1211 self->pstr_sbr_tables, audio_object_type);
1212 if (frame_status < 0) return frame_status;
1213 } else {
1214 self->pstr_ps_stereo_dec = 0;
1215
1216 if (ptr_frame_data[k]->sbr_mode == ORIG_SBR) {
1217 frame_status = ixheaacd_sbr_read_sce(ptr_header_data[k], ptr_frame_data[k],
1218 self->pstr_ps_stereo_dec, it_bit_buff,
1219 self->pstr_sbr_tables, audio_object_type, 0);
1220 if (frame_status < 0) return frame_status;
1221 } else if (ptr_frame_data[k]->sbr_mode == PVC_SBR) {
1222 frame_status = ixheaacd_sbr_read_pvc_sce(ptr_frame_data[k], it_bit_buff, 0,
1223 self->ptr_pvc_data_str,
1224 self->pstr_sbr_tables, ptr_header_data[k]);
1225 if (frame_status < 0) return frame_status;
1226 }
1227 }
1228 ptr_header_data[k]->enh_sbr_ps =
1229 ((self->enh_sbr_ps) | (ptr_header_data[0]->channel_mode == PS_STEREO));
1230 {
1231 WORD32 total_bits_read;
1232 total_bits_read = ixheaacd_no_bits_read(it_bit_buff);
1233 if (total_bits_read > (ptr_bit_str_ele->size_payload << 3) ||
1234 total_bits_read < ((ptr_bit_str_ele->size_payload << 3) - 8)) {
1235 frame_status = 0;
1236 }
1237 }
1238 } else {
1239 if (frame_status && self->ec_flag) {
1240 err = IA_XHEAAC_DEC_EXE_NONFATAL_SBR_PARSE_ERROR;
1241 self->sbr_parse_err_flag = 1;
1242 }
1243 if (!frame_status) {
1244 ixheaacd_ec_set_frame_error_flag(ptr_bit_str_ele, FRAME_ERROR);
1245 } else {
1246 ixheaacd_ec_set_frame_error_flag(ptr_bit_str_ele, FRAME_OK);
1247 }
1248 }
1249 }
1250 if (ptr_header_data[0]->sync_state == SBR_ACTIVE) {
1251 if (ptr_frame_data[0]->sbr_mode == PVC_SBR) {
1252 err = ixheaacd_dec_sbrdata_for_pvc(ptr_header_data[0], ptr_frame_data[0],
1253 pstr_sbr_channel[0]->pstr_prev_frame_data,
1254 audio_object_type);
1255 if (err) {
1256 if (self->ec_flag) {
1257 self->frame_ok = 0;
1258 } else {
1259 return err;
1260 }
1261 }
1262 } else if (ptr_frame_data[0]->sbr_mode == ORIG_SBR) {
1263 err = ixheaacd_dec_sbrdata(
1264 ptr_header_data[0], ptr_header_data[1], ptr_frame_data[0],
1265 pstr_sbr_channel[0]->pstr_prev_frame_data,
1266 (stereo || dual_mono) ? ptr_frame_data[1] : NULL,
1267 (stereo || dual_mono) ? pstr_sbr_channel[1]->pstr_prev_frame_data : NULL,
1268 self->pstr_common_tables, 0, audio_object_type, self->ec_flag);
1269
1270 if (err) {
1271 if (self->ec_flag) {
1272 self->frame_ok = 0;
1273 } else {
1274 return err;
1275 }
1276 }
1277 }
1278
1279 if (ptr_header_data[0]->channel_mode == PS_STEREO &&
1280 (audio_object_type != AOT_ER_AAC_ELD && audio_object_type != AOT_ER_AAC_LD)) {
1281 ixheaacd_decode_ps_data(self->pstr_ps_stereo_dec, 1024);
1282 ps_flag = 1;
1283 self->ps_present = ps_flag;
1284 }
1285
1286 if (ptr_header_data[0]->enh_sbr_ps) {
1287 ps_flag = 1;
1288 self->ps_present = ps_flag;
1289 }
1290
1291 ptr_frame_data[0]->max_qmf_subband_aac =
1292 ptr_header_data[0]->pstr_freq_band_data->sub_band_start;
1293 if (stereo) {
1294 ptr_frame_data[1]->max_qmf_subband_aac =
1295 ptr_header_data[1]->pstr_freq_band_data->sub_band_start;
1296 }
1297 }
1298 if (audio_object_type != AOT_ER_AAC_ELD) {
1299 if ((initial_sync_state == SBR_NOT_INITIALIZED) && ptr_header_data[0]->err_flag) {
1300 ptr_header_data[0]->sync_state = SBR_NOT_INITIALIZED;
1301 }
1302 } else {
1303 ptr_header_data[0]->sync_state = SBR_ACTIVE;
1304 }
1305
1306 if ((!prev_stereo && stereo && (num_channels == 2)) &&
1307 (audio_object_type != AOT_ER_AAC_ELD)) {
1308 memcpy(pstr_sbr_channel[1]->str_sbr_dec.str_synthesis_qmf_bank.filter_states,
1309 pstr_sbr_channel[0]->str_sbr_dec.str_synthesis_qmf_bank.filter_states,
1310 QMF_FILTER_STATE_SYN_SIZE * sizeof(WORD16));
1311
1312 pstr_sbr_channel[1]->str_sbr_dec.str_sbr_scale_fact.st_syn_scale =
1313 pstr_sbr_channel[0]->str_sbr_dec.str_sbr_scale_fact.st_syn_scale;
1314
1315 memcpy(pstr_sbr_channel[1]->str_sbr_dec.str_codec_qmf_bank.anal_filter_states,
1316 pstr_sbr_channel[0]->str_sbr_dec.str_codec_qmf_bank.anal_filter_states,
1317 QMF_FILTER_STATE_ANA_SIZE * sizeof(WORD16));
1318
1319 pstr_sbr_channel[1]->str_sbr_dec.str_sbr_scale_fact.st_lb_scale =
1320 pstr_sbr_channel[0]->str_sbr_dec.str_sbr_scale_fact.st_lb_scale;
1321
1322 memcpy(pstr_sbr_channel[1]->str_sbr_dec.ptr_sbr_overlap_buf,
1323 pstr_sbr_channel[0]->str_sbr_dec.ptr_sbr_overlap_buf,
1324 MAX_OV_COLS * NO_SYNTHESIS_CHANNELS * sizeof(WORD32));
1325
1326 pstr_sbr_channel[1]->str_sbr_dec.str_sbr_scale_fact.ov_lb_scale =
1327 pstr_sbr_channel[0]->str_sbr_dec.str_sbr_scale_fact.ov_lb_scale;
1328 pstr_sbr_channel[1]->str_sbr_dec.str_sbr_scale_fact.ov_hb_scale =
1329 pstr_sbr_channel[0]->str_sbr_dec.str_sbr_scale_fact.ov_hb_scale;
1330 }
1331
1332 pstr_sbr_channel[0]->str_sbr_dec.time_sample_buf = self->time_sample_buf[0];
1333 self->sbr_parse_complete = 1;
1334 }
1335
1336 return err;
1337 }