| /****************************************************************************** |
| * * |
| * Copyright (C) 2018 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at: |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| * |
| ***************************************************************************** |
| * Originally developed and contributed by Ittiam Systems Pvt. Ltd, Bangalore |
| */ |
| #include <string.h> |
| #include "ixheaacd_sbr_common.h" |
| #include <ixheaacd_type_def.h> |
| |
| #include "ixheaacd_constants.h" |
| #include <ixheaacd_basic_ops32.h> |
| #include <ixheaacd_basic_ops16.h> |
| #include <ixheaacd_basic_ops40.h> |
| #include "ixheaacd_basic_ops.h" |
| #include "ixheaacd_defines.h" |
| |
| #include "ixheaacd_intrinsics.h" |
| #include "ixheaacd_sbr_const.h" |
| #include <ixheaacd_basic_op.h> |
| #include "ixheaacd_defines.h" |
| #include "ixheaacd_bitbuffer.h" |
| #include "ixheaacd_pns.h" |
| |
| #include <ixheaacd_aac_rom.h> |
| #include "ixheaacd_pulsedata.h" |
| |
| #include "ixheaacd_drc_data_struct.h" |
| #include "ixheaacd_lt_predict.h" |
| #include "ixheaacd_channelinfo.h" |
| #include "ixheaacd_drc_dec.h" |
| |
| #include "ixheaacd_sbrdecoder.h" |
| |
| #include "ixheaacd_sbrdecsettings.h" |
| #include "ixheaacd_sbr_scale.h" |
| #include "ixheaacd_lpp_tran.h" |
| #include "ixheaacd_env_extr_part.h" |
| #include <ixheaacd_sbr_rom.h> |
| #include "ixheaacd_hybrid.h" |
| #include "ixheaacd_ps_dec.h" |
| #include "ixheaacd_ps_bitdec.h" |
| #include "ixheaacd_env_extr.h" |
| #include "ixheaacd_common_rom.h" |
| #include "ixheaacd_freq_sca.h" |
| |
| #include "ixheaacd_qmf_dec.h" |
| |
| #include "ixheaacd_env_calc.h" |
| |
| #include "ixheaacd_pvc_dec.h" |
| #include "ixheaacd_sbr_dec.h" |
| #include "ixheaacd_env_dec.h" |
| #include "ixheaacd_basic_funcs.h" |
| #include "ixheaacd_sbr_crc.h" |
| #include "ixheaacd_error_standards.h" |
| #include "ixheaacd_sbrqmftrans.h" |
| |
| #include "ixheaacd_audioobjtypes.h" |
| |
| #define ALIGN_SIZE64(x) ((((x) + 7) >> 3) << 3) |
| |
| WORD32 ixheaacd_getsize_sbr_persistent() { |
| return (ALIGN_SIZE64(sizeof(ia_sbr_pers_struct))); |
| } |
| |
| WORD32 ixheaacd_esbr_hbe_data_init( |
| ia_esbr_hbe_txposer_struct *pstr_esbr_hbe_txposer, |
| const WORD32 num_aac_samples, WORD32 samp_fac_4_flag, |
| const WORD32 num_out_samples, VOID *persistent_hbe_mem) { |
| WORD32 i; |
| WORD32 used_persistent = 0; |
| |
| if (pstr_esbr_hbe_txposer) { |
| memset(pstr_esbr_hbe_txposer, 0, sizeof(ia_esbr_hbe_txposer_struct)); |
| |
| pstr_esbr_hbe_txposer->core_frame_length = num_aac_samples; |
| |
| pstr_esbr_hbe_txposer->no_bins = num_out_samples / NO_QMF_SYNTH_CHANNELS; |
| |
| pstr_esbr_hbe_txposer->hbe_qmf_in_len = |
| pstr_esbr_hbe_txposer->no_bins / 2 + HBE_OPER_WIN_LEN - 1; |
| pstr_esbr_hbe_txposer->hbe_qmf_out_len = |
| 2 * pstr_esbr_hbe_txposer->hbe_qmf_in_len; |
| |
| pstr_esbr_hbe_txposer->ptr_input_buf = |
| (FLOAT32 *)((WORD8 *)persistent_hbe_mem); |
| used_persistent += |
| (num_aac_samples + NO_QMF_SYNTH_CHANNELS) * sizeof(FLOAT32); |
| |
| pstr_esbr_hbe_txposer->qmf_in_buf = |
| (FLOAT32 **)((WORD8 *)persistent_hbe_mem + used_persistent); |
| used_persistent += |
| pstr_esbr_hbe_txposer->hbe_qmf_in_len * sizeof(FLOAT32 *); |
| |
| for (i = 0; i < pstr_esbr_hbe_txposer->hbe_qmf_in_len; i++) { |
| pstr_esbr_hbe_txposer->qmf_in_buf[i] = |
| (FLOAT32 *)((WORD8 *)persistent_hbe_mem + used_persistent); |
| |
| used_persistent += (TWICE_QMF_SYNTH_CHANNELS_NUM * sizeof(FLOAT32)); |
| } |
| |
| pstr_esbr_hbe_txposer->qmf_out_buf = |
| (FLOAT32 **)((WORD8 *)persistent_hbe_mem + used_persistent); |
| used_persistent += |
| (pstr_esbr_hbe_txposer->hbe_qmf_out_len * sizeof(FLOAT32 *)); |
| |
| for (i = 0; i < pstr_esbr_hbe_txposer->hbe_qmf_out_len; i++) { |
| pstr_esbr_hbe_txposer->qmf_out_buf[i] = |
| (FLOAT32 *)((WORD8 *)persistent_hbe_mem + used_persistent); |
| used_persistent += (TWICE_QMF_SYNTH_CHANNELS_NUM * sizeof(FLOAT32)); |
| } |
| pstr_esbr_hbe_txposer->upsamp_4_flag = samp_fac_4_flag; |
| } |
| |
| return 0; |
| } |
| |
| VOID ixheaacd_set_sbr_persistent_table_pointer( |
| VOID *sbr_persistent_mem_v, ia_sbr_tables_struct *sbr_tables_ptr, |
| ixheaacd_misc_tables *pstr_common_tables) { |
| ia_sbr_pers_struct *sbr_persistent_mem = |
| (ia_sbr_pers_struct *)sbr_persistent_mem_v; |
| sbr_persistent_mem->str_sbr_dec_inst.pstr_sbr_tables = sbr_tables_ptr; |
| sbr_persistent_mem->str_sbr_dec_inst.pstr_common_tables = pstr_common_tables; |
| } |
| |
| VOID ixheaacd_set_sbr_persistent_buffers(VOID *sbr_persistent_mem_v, |
| WORD32 *persistent_used, |
| WORD32 num_channel, WORD ps_enable) { |
| WORD32 i = 0; |
| WORD32 used_persistent = *persistent_used; |
| WORD32 temp, temp1, temp2, temp3; |
| struct ia_sbr_pers_struct *sbr_persistent_mem = |
| (struct ia_sbr_pers_struct *)sbr_persistent_mem_v; |
| |
| struct ia_sbr_dec_inst_struct *p_str_sbr_dec_inst = |
| &sbr_persistent_mem->str_sbr_dec_inst; |
| |
| memset(sbr_persistent_mem, 0, sizeof(struct ia_sbr_pers_struct)); |
| |
| sbr_persistent_mem->sbr_qmf_analy_states = |
| (WORD16 *)((WORD8 *)sbr_persistent_mem_v + used_persistent); |
| temp = num_channel * ((QMF_FILTER_STATE_ANA_SIZE + 2 * NO_ANALYSIS_CHANNELS) * |
| sizeof(WORD16)); |
| used_persistent += temp; |
| |
| sbr_persistent_mem->sbr_qmf_analy_states_32 = |
| (WORD32 *)((WORD8 *)sbr_persistent_mem_v + used_persistent); |
| temp1 = |
| num_channel * |
| ((QMF_FILTER_STATE_ANA_SIZE + 2 * NO_ANALYSIS_CHANNELS) * sizeof(WORD32)); |
| used_persistent += temp1; |
| |
| sbr_persistent_mem->sbr_qmf_synth_states = |
| (WORD16 *)((WORD8 *)sbr_persistent_mem_v + used_persistent); |
| |
| temp2 = |
| (num_channel * ((QMF_FILTER_STATE_SYN_SIZE + 2 * NO_SYNTHESIS_CHANNELS) * |
| sizeof(WORD16))); |
| used_persistent += temp2; |
| |
| sbr_persistent_mem->sbr_qmf_synth_states_32 = |
| (WORD32 *)((WORD8 *)sbr_persistent_mem_v + used_persistent); |
| |
| temp3 = |
| (num_channel * ((QMF_FILTER_STATE_SYN_SIZE + 2 * NO_SYNTHESIS_CHANNELS) * |
| sizeof(WORD32))); |
| used_persistent += temp3; |
| |
| memset(sbr_persistent_mem->sbr_qmf_analy_states, 0, |
| (temp + temp1 + temp2 + temp3)); |
| |
| for (i = 0; i < num_channel; i++) { |
| sbr_persistent_mem->ptr_sbr_overlap_buf[i] = |
| (WORD32 *)((WORD8 *)sbr_persistent_mem_v + used_persistent); |
| |
| if (ps_enable) { |
| memset(sbr_persistent_mem->ptr_sbr_overlap_buf[i], 0, |
| 2 * MAX_OV_COLS * NO_SYNTHESIS_CHANNELS * sizeof(WORD32)); |
| used_persistent += |
| 2 * MAX_OV_COLS * NO_SYNTHESIS_CHANNELS * sizeof(WORD32); |
| } else { |
| memset(sbr_persistent_mem->ptr_sbr_overlap_buf[i], 0, |
| MAX_OV_COLS * NO_SYNTHESIS_CHANNELS * sizeof(WORD32)); |
| used_persistent += MAX_OV_COLS * NO_SYNTHESIS_CHANNELS * sizeof(WORD32); |
| } |
| } |
| |
| for (i = 0; i < num_channel; i++) { |
| WORD32 j; |
| sbr_persistent_mem->sbr_lpc_filter_states_real[i] = |
| (WORD32 **)((WORD8 *)sbr_persistent_mem_v + used_persistent); |
| used_persistent += LPC_ORDER * sizeof(WORD32 *); |
| for (j = 0; j < LPC_ORDER; j++) { |
| sbr_persistent_mem->sbr_lpc_filter_states_real[i][j] = |
| (WORD32 *)((WORD8 *)sbr_persistent_mem_v + used_persistent); |
| |
| used_persistent += NO_ANALYSIS_CHANNELS * sizeof(WORD32); |
| |
| memset(sbr_persistent_mem->sbr_lpc_filter_states_real[i][j], 0, |
| NO_ANALYSIS_CHANNELS * sizeof(WORD32)); |
| } |
| } |
| |
| if (ps_enable) { |
| for (i = 0; i < num_channel; i++) { |
| WORD32 j; |
| |
| sbr_persistent_mem->sbr_lpc_filter_states_imag[i] = |
| (WORD32 **)((WORD8 *)sbr_persistent_mem_v + used_persistent); |
| used_persistent += LPC_ORDER * sizeof(WORD32 *); |
| for (j = 0; j < LPC_ORDER; j++) { |
| sbr_persistent_mem->sbr_lpc_filter_states_imag[i][j] = |
| (WORD32 *)((WORD8 *)sbr_persistent_mem_v + used_persistent); |
| |
| used_persistent += NO_ANALYSIS_CHANNELS * sizeof(WORD32); |
| |
| memset(sbr_persistent_mem->sbr_lpc_filter_states_imag[i][j], 0, |
| NO_ANALYSIS_CHANNELS * sizeof(WORD32)); |
| } |
| } |
| } |
| for (i = 0; i < num_channel; i++) { |
| WORD32 initial_used = used_persistent; |
| WORD32 temp_used = used_persistent; |
| |
| sbr_persistent_mem->sbr_smooth_gain_buf[i] = |
| (WORD16 *)((WORD8 *)sbr_persistent_mem_v + temp_used); |
| temp_used += 2 * MAX_FREQ_COEFFS * sizeof(WORD16); |
| |
| sbr_persistent_mem->sbr_smooth_noise_buf[i] = |
| (WORD16 *)((WORD8 *)sbr_persistent_mem_v + temp_used); |
| |
| temp_used += MAX_FREQ_COEFFS * sizeof(WORD16); |
| |
| p_str_sbr_dec_inst->pstr_freq_band_data[i] = |
| (VOID *)((WORD8 *)sbr_persistent_mem_v + temp_used); |
| |
| temp_used += ALIGN_SIZE64(sizeof(ia_freq_band_data_struct)); |
| |
| sbr_persistent_mem->pstr_prev_frame_data[i] = |
| (VOID *)((WORD8 *)sbr_persistent_mem_v + temp_used); |
| |
| temp_used += ALIGN_SIZE64(sizeof(ia_sbr_prev_frame_data_struct)); |
| |
| p_str_sbr_dec_inst->pstr_sbr_channel[i] = |
| (VOID *)((WORD8 *)sbr_persistent_mem_v + temp_used); |
| |
| temp_used += ALIGN_SIZE64(sizeof(ia_sbr_channel_struct)); |
| |
| p_str_sbr_dec_inst->pstr_sbr_header[i] = |
| (VOID *)((WORD8 *)sbr_persistent_mem_v + temp_used); |
| |
| temp_used += ALIGN_SIZE64(sizeof(ia_sbr_header_data_struct)); |
| |
| memset(sbr_persistent_mem->sbr_smooth_gain_buf[i], 0, |
| temp_used - initial_used); |
| |
| used_persistent = temp_used; |
| } |
| |
| if (ps_enable) { |
| p_str_sbr_dec_inst->pstr_ps_stereo_dec = |
| (ia_ps_dec_struct *)((WORD8 *)sbr_persistent_mem_v + used_persistent); |
| |
| memset(p_str_sbr_dec_inst->pstr_ps_stereo_dec, 0, sizeof(ia_ps_dec_struct)); |
| |
| used_persistent += sizeof(ia_ps_dec_struct); |
| } |
| |
| p_str_sbr_dec_inst->frame_buffer[0] = |
| (VOID *)((WORD8 *)sbr_persistent_mem_v + used_persistent); |
| memset(p_str_sbr_dec_inst->frame_buffer[0], 0, |
| (sizeof(ia_sbr_frame_info_data_struct) + |
| MAX_FREQ_COEFFS * sizeof(WORD32) * 2 + 8)); |
| used_persistent = used_persistent + (sizeof(ia_sbr_frame_info_data_struct) + |
| MAX_FREQ_COEFFS * sizeof(WORD32) + 8); |
| |
| p_str_sbr_dec_inst->frame_buffer[1] = |
| (VOID *)((WORD8 *)sbr_persistent_mem_v + used_persistent); |
| memset(p_str_sbr_dec_inst->frame_buffer[1], 0, |
| (sizeof(ia_sbr_frame_info_data_struct) + |
| MAX_FREQ_COEFFS * sizeof(WORD32) * 2 + 8)); |
| used_persistent = used_persistent + (sizeof(ia_sbr_frame_info_data_struct) + |
| MAX_FREQ_COEFFS * sizeof(WORD32) + 8); |
| |
| { |
| WORD32 index = 0; |
| p_str_sbr_dec_inst->ptr_pvc_data_str = |
| (ia_pvc_data_struct *)((WORD8 *)sbr_persistent_mem_v + used_persistent); |
| memset(p_str_sbr_dec_inst->ptr_pvc_data_str, 0, sizeof(ia_pvc_data_struct)); |
| used_persistent += sizeof(ia_pvc_data_struct); |
| |
| p_str_sbr_dec_inst->pstr_sbr_channel[0]->str_sbr_dec.p_hbe_txposer = |
| (ia_esbr_hbe_txposer_struct *)((WORD8 *)sbr_persistent_mem_v + |
| used_persistent); |
| memset(p_str_sbr_dec_inst->pstr_sbr_channel[0]->str_sbr_dec.p_hbe_txposer, |
| 0, sizeof(ia_esbr_hbe_txposer_struct)); |
| used_persistent += sizeof(ia_esbr_hbe_txposer_struct); |
| |
| if (num_channel == 2) { |
| p_str_sbr_dec_inst->pstr_sbr_channel[1]->str_sbr_dec.p_hbe_txposer = |
| (ia_esbr_hbe_txposer_struct *)((WORD8 *)sbr_persistent_mem_v + |
| used_persistent); |
| memset(p_str_sbr_dec_inst->pstr_sbr_channel[1]->str_sbr_dec.p_hbe_txposer, |
| 0, sizeof(ia_esbr_hbe_txposer_struct)); |
| used_persistent += sizeof(ia_esbr_hbe_txposer_struct); |
| } |
| |
| p_str_sbr_dec_inst->hbe_txposer_buffers = |
| (VOID *)((WORD8 *)sbr_persistent_mem_v + used_persistent); |
| memset(p_str_sbr_dec_inst->hbe_txposer_buffers, 0, |
| num_channel * MAX_HBE_PERSISTENT_SIZE); |
| used_persistent += num_channel * MAX_HBE_PERSISTENT_SIZE; |
| |
| p_str_sbr_dec_inst->pstr_sbr_channel[0]->str_sbr_dec.pp_qmf_buf_real = |
| (FLOAT32 **)((WORD8 *)sbr_persistent_mem_v + used_persistent); |
| memset(p_str_sbr_dec_inst->pstr_sbr_channel[0]->str_sbr_dec.pp_qmf_buf_real, |
| 0, MAX_QMF_BUF_LEN * sizeof(FLOAT32 *)); |
| used_persistent += MAX_QMF_BUF_LEN * sizeof(FLOAT32 *); |
| |
| p_str_sbr_dec_inst->pstr_sbr_channel[0]->str_sbr_dec.pp_qmf_buf_imag = |
| (FLOAT32 **)((WORD8 *)sbr_persistent_mem_v + used_persistent); |
| memset(p_str_sbr_dec_inst->pstr_sbr_channel[0]->str_sbr_dec.pp_qmf_buf_imag, |
| 0, MAX_QMF_BUF_LEN); |
| used_persistent += MAX_QMF_BUF_LEN * sizeof(FLOAT32 *); |
| |
| if (num_channel == 2) { |
| p_str_sbr_dec_inst->pstr_sbr_channel[1]->str_sbr_dec.pp_qmf_buf_real = |
| (FLOAT32 **)((WORD8 *)sbr_persistent_mem_v + used_persistent); |
| memset( |
| p_str_sbr_dec_inst->pstr_sbr_channel[1]->str_sbr_dec.pp_qmf_buf_real, |
| 0, MAX_QMF_BUF_LEN * sizeof(FLOAT32 *)); |
| used_persistent += MAX_QMF_BUF_LEN * sizeof(FLOAT32 *); |
| |
| p_str_sbr_dec_inst->pstr_sbr_channel[1]->str_sbr_dec.pp_qmf_buf_imag = |
| (FLOAT32 **)((WORD8 *)sbr_persistent_mem_v + used_persistent); |
| memset( |
| p_str_sbr_dec_inst->pstr_sbr_channel[1]->str_sbr_dec.pp_qmf_buf_imag, |
| 0, MAX_QMF_BUF_LEN * sizeof(FLOAT32 *)); |
| used_persistent += MAX_QMF_BUF_LEN * sizeof(FLOAT32 *); |
| } |
| |
| for (index = 0; index < MAX_QMF_BUF_LEN; index++) { |
| p_str_sbr_dec_inst->pstr_sbr_channel[0] |
| ->str_sbr_dec.pp_qmf_buf_real[index] = |
| (FLOAT32 *)((WORD8 *)sbr_persistent_mem_v + used_persistent); |
| used_persistent += MAX_QMF_BUF_LEN * sizeof(FLOAT32); |
| } |
| |
| for (index = 0; index < MAX_QMF_BUF_LEN; index++) { |
| p_str_sbr_dec_inst->pstr_sbr_channel[0] |
| ->str_sbr_dec.pp_qmf_buf_imag[index] = |
| (FLOAT32 *)((WORD8 *)sbr_persistent_mem_v + used_persistent); |
| used_persistent += MAX_QMF_BUF_LEN * sizeof(FLOAT32); |
| } |
| |
| if (num_channel == 2) { |
| for (index = 0; index < MAX_QMF_BUF_LEN; index++) { |
| p_str_sbr_dec_inst->pstr_sbr_channel[1] |
| ->str_sbr_dec.pp_qmf_buf_real[index] = |
| (FLOAT32 *)((WORD8 *)sbr_persistent_mem_v + used_persistent); |
| used_persistent += MAX_QMF_BUF_LEN * sizeof(FLOAT32); |
| } |
| |
| for (index = 0; index < MAX_QMF_BUF_LEN; index++) { |
| p_str_sbr_dec_inst->pstr_sbr_channel[1] |
| ->str_sbr_dec.pp_qmf_buf_imag[index] = |
| (FLOAT32 *)((WORD8 *)sbr_persistent_mem_v + used_persistent); |
| used_persistent += MAX_QMF_BUF_LEN * sizeof(FLOAT32); |
| } |
| } |
| } |
| |
| *persistent_used = used_persistent; |
| } |
| |
| WORD32 ia_enhaacplus_dec_get_sbr_buffers_size(WORD32 channels) { |
| WORD32 sbr_buffers_size = 0; |
| WORD32 temp, temp2; |
| WORD32 num_channel = channels; |
| WORD32 i; |
| |
| temp = num_channel * ((QMF_FILTER_STATE_ANA_SIZE + 2 * NO_ANALYSIS_CHANNELS) * |
| sizeof(WORD16)); |
| sbr_buffers_size += temp; |
| |
| temp2 = |
| (num_channel * ((QMF_FILTER_STATE_SYN_SIZE + 2 * NO_SYNTHESIS_CHANNELS) * |
| sizeof(WORD16))); |
| sbr_buffers_size += temp2; |
| |
| for (i = 0; i < num_channel; i++) { |
| sbr_buffers_size += |
| 2 * MAX_OV_COLS * NO_SYNTHESIS_CHANNELS * sizeof(WORD32); |
| } |
| |
| for (i = 0; i < num_channel; i++) { |
| int j; |
| sbr_buffers_size += LPC_ORDER * sizeof(VOID *); |
| |
| for (j = 0; j < LPC_ORDER; j++) { |
| sbr_buffers_size += NO_ANALYSIS_CHANNELS * sizeof(WORD32); |
| } |
| } |
| |
| for (i = 0; i < num_channel; i++) { |
| int j; |
| sbr_buffers_size += LPC_ORDER * sizeof(WORD32); |
| for (j = 0; j < LPC_ORDER; j++) { |
| sbr_buffers_size += NO_ANALYSIS_CHANNELS * sizeof(WORD32); |
| } |
| } |
| |
| for (i = 0; i < num_channel; i++) { |
| WORD32 temp_used = sbr_buffers_size; |
| |
| temp_used += 2 * MAX_FREQ_COEFFS * sizeof(WORD16); |
| temp_used += MAX_FREQ_COEFFS * sizeof(WORD16); |
| temp_used += ALIGN_SIZE64(sizeof(ia_freq_band_data_struct)); |
| temp_used += ALIGN_SIZE64(sizeof(ia_sbr_prev_frame_data_struct)); |
| temp_used += ALIGN_SIZE64(sizeof(ia_sbr_channel_struct)); |
| temp_used += ALIGN_SIZE64(sizeof(ia_sbr_header_data_struct)); |
| |
| sbr_buffers_size = temp_used; |
| } |
| |
| sbr_buffers_size += sizeof(ia_ps_dec_struct); |
| |
| return sbr_buffers_size; |
| } |
| |
| static PLATFORM_INLINE VOID ixheaacd_init_headerdata( |
| ia_sbr_header_data_struct *ptr_header_data, WORD32 sample_rate_dec, |
| WORD32 samp_per_frame, ia_freq_band_data_struct *freq_band_data, |
| ia_sbr_tables_struct *sbr_tables, WORD audio_obj_type) { |
| ia_freq_band_data_struct *pstr_freq_band_data = freq_band_data; |
| WORD32 tmp; |
| |
| if (audio_obj_type != AOT_ER_AAC_ELD) { |
| memcpy(ptr_header_data, |
| &sbr_tables->env_extr_tables_ptr->str_sbr_default_header, |
| sizeof(ia_sbr_header_data_struct)); |
| } |
| |
| if (audio_obj_type == AOT_ER_AAC_ELD) ptr_header_data->time_step -= 1; |
| |
| pstr_freq_band_data->freq_band_table[LOW] = |
| pstr_freq_band_data->freq_band_tbl_lo; |
| pstr_freq_band_data->freq_band_table[HIGH] = |
| pstr_freq_band_data->freq_band_tbl_hi; |
| ptr_header_data->pstr_freq_band_data = pstr_freq_band_data; |
| |
| ptr_header_data->core_frame_size = samp_per_frame; |
| ptr_header_data->out_sampling_freq = sample_rate_dec << 1; |
| |
| if (audio_obj_type != AOT_ER_AAC_ELD) { |
| tmp = ptr_header_data->time_step + 4; |
| |
| if (tmp < 0) |
| ptr_header_data->num_time_slots = |
| ixheaacd_extract16l(samp_per_frame << (-tmp)); |
| else |
| ptr_header_data->num_time_slots = |
| ixheaacd_extract16l(samp_per_frame >> tmp); |
| } else { |
| ptr_header_data->time_step = 1; |
| |
| ptr_header_data->num_time_slots = |
| (samp_per_frame / 32 >> (ptr_header_data->time_step - 1)); |
| } |
| } |
| |
| VOID ixheaacd_setesbr_flags(VOID *sbr_persistent_mem_v, FLAG pvc_flag, |
| FLAG hbe_flag, FLAG inter_tes_flag) { |
| ia_sbr_pers_struct *sbr_persistent_mem; |
| sbr_persistent_mem = (ia_sbr_pers_struct *)sbr_persistent_mem_v; |
| sbr_persistent_mem->str_sbr_dec_inst.hbe_flag = hbe_flag; |
| sbr_persistent_mem->str_sbr_dec_inst.pvc_flag = pvc_flag; |
| sbr_persistent_mem->str_sbr_dec_inst.inter_tes_flag = inter_tes_flag; |
| return; |
| } |
| |
| ia_handle_sbr_dec_inst_struct ixheaacd_init_sbr( |
| WORD32 sample_rate_dec, WORD32 samp_per_frame, FLAG *down_sample_flag, |
| VOID *sbr_persistent_mem_v, WORD32 *ptr_overlap_buf, WORD32 channel, |
| WORD32 ps_enable, WORD32 sbr_ratio_idx, WORD32 output_frame_size, |
| WORD32 *use_hbe, VOID *p_usac_dflt_header, |
| ia_sbr_header_data_struct str_sbr_config, WORD32 audio_object_type) { |
| WORD16 i; |
| WORD16 err; |
| ia_sbr_header_data_struct *ptr_header_data[MAXNRSBRCHANNELS]; |
| ia_sbr_dec_struct *ptr_sbr_dec[2]; |
| ia_qmf_dec_tables_struct *qmf_dec_tables_ptr; |
| ia_sbr_pers_struct *sbr_persistent_mem; |
| |
| sbr_persistent_mem = (ia_sbr_pers_struct *)sbr_persistent_mem_v; |
| ptr_sbr_dec[0] = |
| &sbr_persistent_mem->str_sbr_dec_inst.pstr_sbr_channel[0]->str_sbr_dec; |
| ptr_sbr_dec[1] = |
| &sbr_persistent_mem->str_sbr_dec_inst.pstr_sbr_channel[1]->str_sbr_dec; |
| |
| qmf_dec_tables_ptr = |
| sbr_persistent_mem->str_sbr_dec_inst.pstr_sbr_tables->qmf_dec_tables_ptr; |
| |
| if (sample_rate_dec > 48000) { |
| *down_sample_flag = 1; |
| } |
| |
| for (i = 0; i < channel; i++) { |
| if (audio_object_type == AOT_ER_AAC_ELD) { |
| memcpy(sbr_persistent_mem->str_sbr_dec_inst.pstr_sbr_header[i], |
| &str_sbr_config, sizeof(ia_sbr_header_data_struct)); |
| } |
| ptr_header_data[i] = |
| sbr_persistent_mem->str_sbr_dec_inst.pstr_sbr_header[i]; |
| |
| ixheaacd_init_headerdata( |
| ptr_header_data[i], sample_rate_dec, samp_per_frame, |
| sbr_persistent_mem->str_sbr_dec_inst.pstr_freq_band_data[i], |
| sbr_persistent_mem->str_sbr_dec_inst.pstr_sbr_tables, |
| audio_object_type); |
| |
| err = ixheaacd_create_sbrdec( |
| |
| sbr_persistent_mem->str_sbr_dec_inst.pstr_common_tables, |
| sbr_persistent_mem->str_sbr_dec_inst.pstr_sbr_channel[i], |
| ptr_header_data[i], i, *down_sample_flag, sbr_persistent_mem, ps_enable, |
| audio_object_type); |
| |
| ptr_header_data[i]->status = 1; |
| |
| if (err) { |
| return NULL; |
| } |
| } |
| |
| if (channel != 1) { |
| if (ps_enable) { |
| if (audio_object_type == AOT_ER_AAC_ELD) |
| err = (WORD16)ixheaacd_create_psdec( |
| sbr_persistent_mem->str_sbr_dec_inst.pstr_ps_stereo_dec, |
| sbr_persistent_mem, &ptr_overlap_buf[512 * 4]); |
| else |
| err = (WORD16)ixheaacd_create_psdec( |
| sbr_persistent_mem->str_sbr_dec_inst.pstr_ps_stereo_dec, |
| sbr_persistent_mem, ptr_overlap_buf); |
| if (err) { |
| return NULL; |
| } |
| } |
| } |
| |
| if (use_hbe != NULL) { |
| ia_sbr_header_data_struct *ptr_sbr_dflt_header = |
| &sbr_persistent_mem->str_sbr_dec_inst.str_sbr_dflt_header; |
| ia_sbr_header_data_struct *ptr_usac_dflt_header = |
| (ia_sbr_header_data_struct *)p_usac_dflt_header; |
| struct ia_sbr_dec_inst_struct *p_str_sbr_dec_inst = |
| &sbr_persistent_mem->str_sbr_dec_inst; |
| VOID *hbe_txposer_buffers = p_str_sbr_dec_inst->hbe_txposer_buffers; |
| |
| ptr_header_data[0] = p_str_sbr_dec_inst->pstr_sbr_header[0]; |
| ptr_header_data[1] = p_str_sbr_dec_inst->pstr_sbr_header[1]; |
| |
| ptr_header_data[0]->sbr_ratio_idx = sbr_ratio_idx; |
| ptr_header_data[0]->output_framesize = output_frame_size; |
| ptr_header_data[0]->pstr_freq_band_data->sub_band_start = 64; |
| ptr_header_data[0]->esbr_start_up = 1; |
| ptr_header_data[0]->esbr_start_up_pvc = 1; |
| |
| if (channel > 1) { |
| ptr_header_data[1]->sbr_ratio_idx = sbr_ratio_idx; |
| ptr_header_data[1]->output_framesize = output_frame_size; |
| ptr_header_data[1]->pstr_freq_band_data->sub_band_start = 64; |
| ptr_header_data[1]->esbr_start_up = 1; |
| ptr_header_data[1]->esbr_start_up_pvc = 1; |
| } |
| if (hbe_txposer_buffers != NULL && (use_hbe[0] == 1)) { |
| ixheaacd_esbr_hbe_data_init(ptr_sbr_dec[0]->p_hbe_txposer, samp_per_frame, |
| sbr_ratio_idx == SBR_UPSAMPLE_IDX_4_1 ? 1 : 0, |
| output_frame_size, hbe_txposer_buffers); |
| |
| hbe_txposer_buffers = |
| (WORD8 *)hbe_txposer_buffers + MAX_HBE_PERSISTENT_SIZE; |
| |
| ixheaacd_esbr_hbe_data_init(ptr_sbr_dec[1]->p_hbe_txposer, samp_per_frame, |
| sbr_ratio_idx == SBR_UPSAMPLE_IDX_4_1 ? 1 : 0, |
| output_frame_size, hbe_txposer_buffers); |
| } |
| |
| p_str_sbr_dec_inst->ptr_pvc_data_str->prev_first_bnd_idx = -1; |
| p_str_sbr_dec_inst->ptr_pvc_data_str->prev_pvc_rate = -1; |
| p_str_sbr_dec_inst->ptr_pvc_data_str->prev_sbr_mode = UNKNOWN_SBR; |
| |
| p_str_sbr_dec_inst->pstr_sbr_channel[0] |
| ->str_sbr_dec.str_codec_qmf_bank.num_time_slots = |
| output_frame_size / 64; |
| p_str_sbr_dec_inst->pstr_sbr_channel[1] |
| ->str_sbr_dec.str_codec_qmf_bank.num_time_slots = |
| output_frame_size / 64; |
| |
| ptr_header_data[0]->core_frame_size = samp_per_frame; |
| ptr_header_data[1]->core_frame_size = samp_per_frame; |
| |
| switch (sbr_ratio_idx) { |
| case SBR_UPSAMPLE_IDX_0_0: |
| ptr_sbr_dec[0]->str_codec_qmf_bank.no_channels = 32; |
| ptr_sbr_dec[0]->str_codec_qmf_bank.esbr_cos_twiddle = |
| (WORD32 *)qmf_dec_tables_ptr->esbr_sin_cos_twiddle_l32; |
| ptr_sbr_dec[0]->str_codec_qmf_bank.esbr_alt_sin_twiddle = |
| (WORD32 *)qmf_dec_tables_ptr->esbr_alt_sin_twiddle_l32; |
| ptr_sbr_dec[0]->str_codec_qmf_bank.esbr_t_cos = |
| (WORD32 *)qmf_dec_tables_ptr->esbr_t_cos_sin_l32; |
| ptr_header_data[0]->is_usf_4 = 0; |
| ptr_header_data[0]->upsamp_fac = 1; |
| |
| ptr_sbr_dec[1]->str_codec_qmf_bank.no_channels = 32; |
| ptr_sbr_dec[0]->str_codec_qmf_bank.esbr_cos_twiddle = |
| (WORD32 *)qmf_dec_tables_ptr->esbr_sin_cos_twiddle_l32; |
| ptr_sbr_dec[0]->str_codec_qmf_bank.esbr_alt_sin_twiddle = |
| (WORD32 *)qmf_dec_tables_ptr->esbr_alt_sin_twiddle_l32; |
| ptr_sbr_dec[0]->str_codec_qmf_bank.esbr_t_cos = |
| (WORD32 *)qmf_dec_tables_ptr->esbr_t_cos_sin_l32; |
| ptr_header_data[1]->is_usf_4 = 0; |
| ptr_header_data[1]->upsamp_fac = 1; |
| break; |
| case SBR_UPSAMPLE_IDX_2_1: |
| ptr_sbr_dec[0]->str_codec_qmf_bank.no_channels = 32; |
| ptr_sbr_dec[0]->str_codec_qmf_bank.esbr_cos_twiddle = |
| (WORD32 *)qmf_dec_tables_ptr->esbr_sin_cos_twiddle_l32; |
| ptr_sbr_dec[0]->str_codec_qmf_bank.esbr_alt_sin_twiddle = |
| (WORD32 *)qmf_dec_tables_ptr->esbr_alt_sin_twiddle_l32; |
| ptr_sbr_dec[0]->str_codec_qmf_bank.esbr_t_cos = |
| (WORD32 *)qmf_dec_tables_ptr->esbr_t_cos_sin_l32; |
| ptr_header_data[0]->is_usf_4 = 0; |
| ptr_header_data[0]->upsamp_fac = 2; |
| |
| ptr_sbr_dec[1]->str_codec_qmf_bank.no_channels = 32; |
| ptr_sbr_dec[1]->str_codec_qmf_bank.esbr_cos_twiddle = |
| (WORD32 *)qmf_dec_tables_ptr->esbr_sin_cos_twiddle_l32; |
| ptr_sbr_dec[1]->str_codec_qmf_bank.esbr_alt_sin_twiddle = |
| (WORD32 *)qmf_dec_tables_ptr->esbr_alt_sin_twiddle_l32; |
| ptr_sbr_dec[1]->str_codec_qmf_bank.esbr_t_cos = |
| (WORD32 *)qmf_dec_tables_ptr->esbr_t_cos_sin_l32; |
| ptr_header_data[1]->is_usf_4 = 0; |
| ptr_header_data[1]->upsamp_fac = 2; |
| break; |
| case SBR_UPSAMPLE_IDX_8_3: |
| ptr_sbr_dec[0]->str_codec_qmf_bank.no_channels = 24; |
| ptr_sbr_dec[0]->str_codec_qmf_bank.filter_pos_32 = |
| qmf_dec_tables_ptr->esbr_qmf_c_24; |
| ptr_sbr_dec[0]->str_codec_qmf_bank.analy_win_coeff_32 = |
| qmf_dec_tables_ptr->esbr_qmf_c_24; |
| ptr_sbr_dec[0]->str_codec_qmf_bank.esbr_cos_twiddle = |
| (WORD32 *)qmf_dec_tables_ptr->esbr_sin_cos_twiddle_l24; |
| ptr_sbr_dec[0]->str_codec_qmf_bank.esbr_alt_sin_twiddle = |
| (WORD32 *)qmf_dec_tables_ptr->esbr_alt_sin_twiddle_l24; |
| ptr_sbr_dec[0]->str_codec_qmf_bank.esbr_t_cos = |
| (WORD32 *)qmf_dec_tables_ptr->esbr_t_cos_sin_l24; |
| |
| ptr_header_data[0]->is_usf_4 = 0; |
| ptr_header_data[0]->upsamp_fac = 2; |
| |
| ptr_sbr_dec[1]->str_codec_qmf_bank.no_channels = 24; |
| ptr_sbr_dec[1]->str_codec_qmf_bank.filter_pos_32 = |
| qmf_dec_tables_ptr->esbr_qmf_c_24; |
| ptr_sbr_dec[1]->str_codec_qmf_bank.analy_win_coeff_32 = |
| qmf_dec_tables_ptr->esbr_qmf_c_24; |
| ptr_sbr_dec[1]->str_codec_qmf_bank.esbr_cos_twiddle = |
| (WORD32 *)qmf_dec_tables_ptr->esbr_sin_cos_twiddle_l24; |
| ptr_sbr_dec[1]->str_codec_qmf_bank.esbr_alt_sin_twiddle = |
| (WORD32 *)qmf_dec_tables_ptr->esbr_alt_sin_twiddle_l24; |
| ptr_sbr_dec[1]->str_codec_qmf_bank.esbr_t_cos = |
| (WORD32 *)qmf_dec_tables_ptr->esbr_t_cos_sin_l24; |
| |
| ptr_header_data[1]->is_usf_4 = 0; |
| ptr_header_data[1]->upsamp_fac = 2; |
| break; |
| case SBR_UPSAMPLE_IDX_4_1: |
| ptr_sbr_dec[0]->str_codec_qmf_bank.no_channels = 16; |
| ptr_sbr_dec[0]->str_codec_qmf_bank.esbr_cos_twiddle = |
| (WORD32 *)qmf_dec_tables_ptr->esbr_sin_cos_twiddle_l16; |
| ptr_sbr_dec[0]->str_codec_qmf_bank.esbr_alt_sin_twiddle = |
| (WORD32 *)qmf_dec_tables_ptr->esbr_alt_sin_twiddle_l16; |
| ptr_sbr_dec[0]->str_codec_qmf_bank.esbr_t_cos = |
| (WORD32 *)qmf_dec_tables_ptr->esbr_t_cos_sin_l16; |
| ptr_header_data[0]->is_usf_4 = 1; |
| ptr_header_data[0]->upsamp_fac = 4; |
| ptr_header_data[0]->out_sampling_freq = |
| ptr_header_data[0]->out_sampling_freq * 2; |
| |
| ptr_sbr_dec[1]->str_codec_qmf_bank.no_channels = 16; |
| ptr_sbr_dec[1]->str_codec_qmf_bank.esbr_cos_twiddle = |
| (WORD32 *)qmf_dec_tables_ptr->esbr_sin_cos_twiddle_l16; |
| ptr_sbr_dec[1]->str_codec_qmf_bank.esbr_alt_sin_twiddle = |
| (WORD32 *)qmf_dec_tables_ptr->esbr_alt_sin_twiddle_l16; |
| ptr_sbr_dec[1]->str_codec_qmf_bank.esbr_t_cos = |
| (WORD32 *)qmf_dec_tables_ptr->esbr_t_cos_sin_l16; |
| ptr_header_data[1]->is_usf_4 = 1; |
| ptr_header_data[1]->upsamp_fac = 4; |
| ptr_header_data[1]->out_sampling_freq = |
| ptr_header_data[1]->out_sampling_freq * 2; |
| break; |
| } |
| |
| ptr_sbr_dflt_header->start_freq = ptr_usac_dflt_header->start_freq; |
| ptr_sbr_dflt_header->stop_freq = ptr_usac_dflt_header->stop_freq; |
| |
| if (ptr_usac_dflt_header->header_extra_1) { |
| ptr_sbr_dflt_header->freq_scale = ptr_usac_dflt_header->freq_scale; |
| ptr_sbr_dflt_header->alter_scale = ptr_usac_dflt_header->alter_scale; |
| ptr_sbr_dflt_header->noise_bands = ptr_usac_dflt_header->noise_bands; |
| } else { |
| ptr_sbr_dflt_header->freq_scale = SBR_FREQ_SCALE_DEFAULT; |
| ptr_sbr_dflt_header->alter_scale = SBR_ALTER_SCALE_DEFAULT; |
| ptr_sbr_dflt_header->noise_bands = SBR_NOISE_BANDS_DEFAULT; |
| } |
| |
| if (ptr_usac_dflt_header->header_extra_2) { |
| ptr_sbr_dflt_header->limiter_bands = ptr_usac_dflt_header->limiter_bands; |
| ptr_sbr_dflt_header->limiter_gains = ptr_usac_dflt_header->limiter_gains; |
| ptr_sbr_dflt_header->interpol_freq = ptr_usac_dflt_header->interpol_freq; |
| ptr_sbr_dflt_header->smoothing_mode = |
| ptr_usac_dflt_header->smoothing_mode; |
| } else { |
| ptr_sbr_dflt_header->limiter_bands = SBR_LIMITER_BANDS_DEFAULT; |
| ptr_sbr_dflt_header->limiter_gains = SBR_LIMITER_GAINS_DEFAULT; |
| ptr_sbr_dflt_header->interpol_freq = SBR_INTERPOL_FREQ_DEFAULT; |
| ptr_sbr_dflt_header->smoothing_mode = SBR_SMOOTHING_LENGTH_DEFAULT; |
| } |
| } |
| return &(sbr_persistent_mem->str_sbr_dec_inst); |
| } |
| |
| static PLATFORM_INLINE WORD16 ixheaacd_create_sbr_env_calc( |
| |
| ixheaacd_misc_tables *pstr_common_table, ia_sbr_calc_env_struct *hs, |
| WORD16 chan, VOID *sbr_persistent_mem_v, |
| ia_sbr_header_data_struct *ptr_header_data, WORD audio_object_type) { |
| WORD16 err; |
| ia_sbr_pers_struct *sbr_persistent_mem = |
| (ia_sbr_pers_struct *)sbr_persistent_mem_v; |
| |
| err = 0; |
| memset(&hs->harm_flags_prev[0], 0, sizeof(WORD8) * MAX_FREQ_COEFFS); |
| |
| hs->harm_index = 0; |
| |
| hs->filt_buf_me = sbr_persistent_mem->sbr_smooth_gain_buf[chan]; |
| hs->filt_buf_noise_m = sbr_persistent_mem->sbr_smooth_noise_buf[chan]; |
| hs->tansient_env_prev = -1; |
| |
| ixheaacd_reset_sbrenvelope_calc(hs); |
| |
| if ((chan == 0) && (audio_object_type == AOT_ER_AAC_ELD)) { |
| err = ixheaacd_calc_frq_bnd_tbls(ptr_header_data, pstr_common_table); |
| } |
| |
| return err; |
| } |
| |
| static PLATFORM_INLINE VOID ixheaacd_init_sbr_prev_framedata( |
| ia_sbr_prev_frame_data_struct *ptr_prev_data, WORD16 time_slots) { |
| WORD16 *psfb_nrg_prev = ptr_prev_data->sfb_nrg_prev; |
| WORD16 *psfb_noise_level = ptr_prev_data->prev_noise_level; |
| WORD32 *ppsbr_invf_mode = ptr_prev_data->sbr_invf_mode; |
| |
| memset(psfb_nrg_prev, 0, sizeof(WORD16) * (MAX_FREQ_COEFFS)); |
| memset(psfb_noise_level, 0, sizeof(WORD16) * (MAX_NOISE_COEFFS)); |
| |
| memset(ppsbr_invf_mode, 0, sizeof(WORD32) * MAX_INVF_BANDS); |
| |
| ptr_prev_data->end_position = time_slots; |
| ptr_prev_data->coupling_mode = COUPLING_OFF; |
| ptr_prev_data->amp_res = 0; |
| ptr_prev_data->max_qmf_subband_aac = 0; |
| } |
| |
| static PLATFORM_INLINE WORD32 |
| ixheaacd_create_hyb_filterbank(ia_hybrid_struct *ptr_hybrid, WORD32 **p_ptr, |
| ia_sbr_tables_struct *sbr_tables_ptr) { |
| WORD16 i, ptr_step; |
| WORD32 *ptr = (WORD32 *)*p_ptr; |
| |
| ptr_hybrid->ptr_resol = sbr_tables_ptr->ps_tables_ptr->hyb_resol; |
| ptr_hybrid->ptr_qmf_buf = HYBRID_FILTER_LENGTH - 1; |
| |
| ptr_hybrid->ptr_temp_re = ptr; |
| ptr += NO_HYBRID_CHANNELS_HIGH; |
| ptr_hybrid->ptr_temp_im = ptr; |
| ptr += NO_HYBRID_CHANNELS_HIGH; |
| |
| memset(ptr_hybrid->ptr_temp_re, 0, |
| 2 * NO_HYBRID_CHANNELS_HIGH * sizeof(WORD32)); |
| |
| ptr_step = ixheaacd_add16(1, ptr_hybrid->ptr_qmf_buf); |
| ptr_hybrid->ptr_work_re = ptr; |
| ptr += 16; |
| ptr_hybrid->ptr_work_im = ptr; |
| ptr += 16; |
| |
| for (i = 0; i < NO_QMF_CHANNELS_IN_HYBRID; i++) { |
| ptr_hybrid->ptr_qmf_buf_re[i] = ptr; |
| ptr += ptr_hybrid->ptr_qmf_buf; |
| |
| ptr_hybrid->ptr_qmf_buf_im[i] = ptr; |
| ptr += ptr_hybrid->ptr_qmf_buf; |
| |
| memset(ptr_hybrid->ptr_qmf_buf_re[i], 0, |
| 2 * ptr_hybrid->ptr_qmf_buf * sizeof(WORD32)); |
| } |
| |
| *p_ptr = ptr; |
| |
| return 0; |
| } |
| |
| static PLATFORM_INLINE WORD16 ixheaacd_create_hf_generator( |
| ia_sbr_hf_generator_struct *ptr_hf_gen_str, WORD16 num_columns, WORD16 chan, |
| VOID *sbr_persistent_mem_v, WORD32 ps_enable) { |
| WORD16 i; |
| ia_sbr_pers_struct *sbr_persistent_mem = |
| (ia_sbr_pers_struct *)sbr_persistent_mem_v; |
| |
| ptr_hf_gen_str->pstr_settings = &sbr_persistent_mem->str_sbr_tran_settings; |
| |
| ptr_hf_gen_str->lpc_filt_states_real[0] = |
| sbr_persistent_mem->sbr_lpc_filter_states_real[chan][0]; |
| ptr_hf_gen_str->lpc_filt_states_real[1] = |
| sbr_persistent_mem->sbr_lpc_filter_states_real[chan][1]; |
| |
| if (ps_enable) { |
| ptr_hf_gen_str->lpc_filt_states_imag[0] = |
| sbr_persistent_mem->sbr_lpc_filter_states_imag[chan][0]; |
| ptr_hf_gen_str->lpc_filt_states_imag[1] = |
| sbr_persistent_mem->sbr_lpc_filter_states_imag[chan][1]; |
| } |
| |
| for (i = 0; i < LPC_ORDER; i++) { |
| memset(ptr_hf_gen_str->lpc_filt_states_real[i], 0, |
| NO_ANALYSIS_CHANNELS * sizeof(WORD32)); |
| |
| if (ps_enable) |
| memset(ptr_hf_gen_str->lpc_filt_states_imag[i], 0, |
| NO_ANALYSIS_CHANNELS * sizeof(WORD32)); |
| } |
| |
| if (chan == 0) { |
| ptr_hf_gen_str->pstr_settings->num_columns = num_columns; |
| } |
| return 0; |
| } |
| |
| WORD32 ixheaacd_create_psdec(ia_ps_dec_struct *ptr_ps_dec, |
| VOID *sbr_persistent_mem_v, |
| WORD32 *ptr_overlap_buf) { |
| ia_sbr_pers_struct *sbr_persistent_mem = |
| (ia_sbr_pers_struct *)sbr_persistent_mem_v; |
| |
| WORD16 *ptr1 = (WORD16 *)&( |
| sbr_persistent_mem->ptr_sbr_overlap_buf[MAXNRSBRCHANNELS - 1][0]); |
| WORD32 *ptr2 = (WORD32 *)&ptr_overlap_buf[512]; |
| WORD16 *initial_ptr; |
| WORD16 delay; |
| WORD32 temp; |
| |
| ia_sbr_tables_struct *sbr_tables_ptr = |
| sbr_persistent_mem->str_sbr_dec_inst.pstr_sbr_tables; |
| |
| memset(ptr_ps_dec, 0, sizeof(ia_ps_dec_struct)); |
| |
| ptr_ps_dec->ps_data_present = 0; |
| ptr_ps_dec->enable_iid = 0; |
| ptr_ps_dec->enable_icc = 0; |
| ptr_ps_dec->enable_ext = 0; |
| ptr_ps_dec->iid_mode = 0; |
| ptr_ps_dec->icc_mode = 0; |
| |
| ptr_ps_dec->ptr_hyb_left_re = ptr2; |
| ptr2 += 16; |
| ptr_ps_dec->ptr_hyb_left_im = ptr2; |
| ptr2 += 16; |
| ptr_ps_dec->ptr_hyb_right_re = ptr2; |
| ptr2 += 16; |
| ptr_ps_dec->ptr_hyb_right_im = ptr2; |
| ptr2 += 16; |
| |
| memset(ptr_ps_dec->ptr_hyb_left_re, 0, sizeof(WORD32) * 16 * 4); |
| |
| ixheaacd_create_hyb_filterbank(&ptr_ps_dec->str_hybrid, &ptr2, |
| sbr_tables_ptr); |
| |
| ptr_ps_dec->peak_decay_diff = ptr2; |
| ptr2 += NUM_OF_BINS; |
| ptr_ps_dec->energy_prev = ptr2; |
| ptr2 += NUM_OF_BINS; |
| ptr_ps_dec->peak_decay_diff_prev = ptr2; |
| ptr2 += NUM_OF_BINS; |
| |
| memset(ptr_ps_dec->peak_decay_diff, 0, 3 * sizeof(WORD32) * NUM_OF_BINS); |
| |
| ptr_ps_dec->delay_buf_idx = 0; |
| ptr_ps_dec->delay_buf_idx_long = 0; |
| |
| memset(ptr_ps_dec->delay_buf_qmf_sub_re_im, 0, |
| 2 * 16 * DEL_ALL_PASS * sizeof(WORD16)); |
| memset(ptr_ps_dec->delay_buf_qmf_sub_ser_re_im, 0, |
| 2 * 16 * NUM_SER_AP_LINKS * 5 * sizeof(WORD16)); |
| |
| initial_ptr = ptr1; |
| ptr_ps_dec->delay_buf_qmf_ser_re_im = (VOID *)ptr1; |
| ptr1 += 2 * NUM_SER_AP_LINKS * 32 * 5; |
| |
| delay = 2; |
| ptr_ps_dec->delay_buf_qmf_ap_re_im = (VOID *)ptr1; |
| ptr1 += 2 * delay * 32; |
| |
| delay = HIGH_DEL; |
| ptr_ps_dec->delay_buf_qmf_ld_re_im = (VOID *)ptr1; |
| ptr1 += 2 * delay * SMALL_DEL_STRT; |
| |
| delay = SMALL_DEL; |
| ptr_ps_dec->delay_buf_qmf_sd_re_im = (VOID *)ptr1; |
| ptr1 += |
| 2 * delay * (NUM_OF_QUAD_MIRROR_FILTER_ICC_CHNLS - |
| (NUM_OF_QUAD_MIRROR_FILTER_ALL_PASS_CHNLS + SMALL_DEL_STRT)); |
| |
| temp = ptr1 - initial_ptr; |
| memset(ptr_ps_dec->delay_buf_qmf_ser_re_im, 0, temp * sizeof(WORD16)); |
| |
| memset(ptr_ps_dec->delay_buf_idx_ser, 0, NUM_SER_AP_LINKS * sizeof(WORD16)); |
| memcpy(ptr_ps_dec->delay_sample_ser, |
| sbr_tables_ptr->ps_tables_ptr->rev_link_delay_ser, |
| NUM_SER_AP_LINKS * sizeof(WORD16)); |
| |
| memset(ptr_ps_dec->h11_h12_vec, 0xff, |
| (NO_IID_GROUPS + 2) * 2 * sizeof(WORD16)); |
| memset(ptr_ps_dec->h21_h22_vec, 0, sizeof(ptr_ps_dec->h21_h22_vec)); |
| |
| return 0; |
| } |
| |
| static PLATFORM_INLINE WORD32 ixheaacd_create_cplx_anal_qmfbank( |
| ia_sbr_qmf_filter_bank_struct *ptr_sbr_qmf, |
| ia_sbr_scale_fact_struct *sbr_scale_factor, WORD16 no_bins, WORD16 usb, |
| WORD16 chan, WORD16 *sbr_qmf_analy_states, WORD32 *sbr_qmf_analy_states_32, |
| ia_qmf_dec_tables_struct *qmf_dec_tables_ptr, WORD32 audio_object_type) { |
| memset(ptr_sbr_qmf, 0, sizeof(ia_sbr_qmf_filter_bank_struct)); |
| |
| if (audio_object_type != AOT_ER_AAC_ELD && |
| audio_object_type != AOT_ER_AAC_LD) { |
| ptr_sbr_qmf->analy_win_coeff = qmf_dec_tables_ptr->qmf_c; |
| } else { |
| ptr_sbr_qmf->analy_win_coeff = qmf_dec_tables_ptr->qmf_c_eld3; |
| } |
| |
| ptr_sbr_qmf->analy_win_coeff_32 = qmf_dec_tables_ptr->esbr_qmf_c; |
| |
| ptr_sbr_qmf->no_channels = NO_ANALYSIS_CHANNELS; |
| ptr_sbr_qmf->num_time_slots = no_bins; |
| |
| ptr_sbr_qmf->lsb = 0; |
| ptr_sbr_qmf->usb = usb; |
| |
| ptr_sbr_qmf->anal_filter_states = |
| &(sbr_qmf_analy_states[chan ? QMF_FILTER_STATE_ANA_SIZE : 0]); |
| |
| memset(ptr_sbr_qmf->anal_filter_states, 0, |
| sizeof(WORD16) * QMF_FILTER_STATE_ANA_SIZE); |
| |
| ptr_sbr_qmf->anal_filter_states_32 = |
| &(sbr_qmf_analy_states_32[chan ? QMF_FILTER_STATE_ANA_SIZE : 0]); |
| |
| memset(ptr_sbr_qmf->anal_filter_states_32, 0, |
| sizeof(WORD32) * QMF_FILTER_STATE_ANA_SIZE); |
| |
| ptr_sbr_qmf->core_samples_buffer = ptr_sbr_qmf->anal_filter_states; |
| |
| ptr_sbr_qmf->state_new_samples_pos_low_32 = |
| ptr_sbr_qmf->anal_filter_states_32; |
| if (audio_object_type != AOT_ER_AAC_ELD && |
| audio_object_type != AOT_ER_AAC_LD) { |
| ptr_sbr_qmf->filter_pos = (WORD16 *)qmf_dec_tables_ptr->qmf_c; |
| } else { |
| ptr_sbr_qmf->filter_pos = (WORD16 *)qmf_dec_tables_ptr->qmf_c_eld3; |
| } |
| |
| ptr_sbr_qmf->filter_pos_32 = (WORD32 *)qmf_dec_tables_ptr->esbr_qmf_c; |
| |
| sbr_scale_factor->st_lb_scale = 0; |
| |
| sbr_scale_factor->st_syn_scale = -6; |
| |
| if (audio_object_type == AOT_ER_AAC_ELD || |
| audio_object_type == AOT_ER_AAC_LD) { |
| ptr_sbr_qmf->filter_2 = ptr_sbr_qmf->filter_pos + 32; |
| ptr_sbr_qmf->fp1_anal = ptr_sbr_qmf->anal_filter_states; |
| ptr_sbr_qmf->fp2_anal = |
| ptr_sbr_qmf->anal_filter_states + NO_ANALYSIS_CHANNELS; |
| } |
| |
| return 0; |
| } |
| |
| static PLATFORM_INLINE WORD32 ixheaacd_create_cplx_synt_qmfbank( |
| ia_sbr_qmf_filter_bank_struct *ptr_sbr_qmf, WORD16 no_bins, WORD16 lsb, |
| WORD16 usb, WORD16 chan, FLAG down_sample_flag, |
| WORD16 *sbr_qmf_synth_states, WORD32 *sbr_qmf_synth_states_32, |
| ia_qmf_dec_tables_struct *qmf_dec_tables_ptr, WORD32 audio_object_type) { |
| WORD32 L; |
| |
| WORD32 qmf_filter_state_size; |
| |
| memset(ptr_sbr_qmf, 0, sizeof(ia_sbr_qmf_filter_bank_struct)); |
| |
| if (down_sample_flag) { |
| L = NO_SYNTHESIS_CHANNELS_DOWN_SAMPLED; |
| qmf_filter_state_size = QMF_FILTER_STATE_SYN_SIZE_DOWN_SAMPLED; |
| ptr_sbr_qmf->usb = NO_SYNTHESIS_CHANNELS_DOWN_SAMPLED; |
| } else { |
| L = NO_SYNTHESIS_CHANNELS; |
| qmf_filter_state_size = QMF_FILTER_STATE_SYN_SIZE; |
| ptr_sbr_qmf->usb = usb; |
| } |
| |
| ptr_sbr_qmf->ixheaacd_drc_offset = 0; |
| if (audio_object_type != AOT_ER_AAC_ELD && |
| audio_object_type != AOT_ER_AAC_LD) { |
| ptr_sbr_qmf->filter_pos_syn = (WORD16 *)qmf_dec_tables_ptr->qmf_c; |
| ptr_sbr_qmf->p_filter = qmf_dec_tables_ptr->qmf_c; |
| } else { |
| ptr_sbr_qmf->filter_pos_syn = (WORD16 *)qmf_dec_tables_ptr->qmf_c_eld; |
| ptr_sbr_qmf->p_filter = qmf_dec_tables_ptr->qmf_c_eld; |
| } |
| |
| ptr_sbr_qmf->filter_pos_syn_32 = (WORD32 *)qmf_dec_tables_ptr->esbr_qmf_c; |
| ptr_sbr_qmf->p_filter_32 = qmf_dec_tables_ptr->esbr_qmf_c; |
| |
| ptr_sbr_qmf->no_channels = L; |
| ptr_sbr_qmf->qmf_filter_state_size = qmf_filter_state_size; |
| ptr_sbr_qmf->num_time_slots = no_bins; |
| ptr_sbr_qmf->lsb = lsb; |
| |
| ptr_sbr_qmf->filter_states = |
| &sbr_qmf_synth_states[chan ? qmf_filter_state_size : 0]; |
| |
| memset(ptr_sbr_qmf->filter_states, 0, sizeof(WORD16) * qmf_filter_state_size); |
| |
| ptr_sbr_qmf->filter_states_32 = |
| &sbr_qmf_synth_states_32[chan ? qmf_filter_state_size : 0]; |
| |
| memset(ptr_sbr_qmf->filter_states_32, 0, |
| sizeof(WORD32) * qmf_filter_state_size); |
| |
| if (audio_object_type == AOT_ER_AAC_ELD || |
| audio_object_type == AOT_ER_AAC_LD) { |
| ptr_sbr_qmf->fp1_syn = ptr_sbr_qmf->filter_states; |
| ptr_sbr_qmf->fp2_syn = |
| ptr_sbr_qmf->filter_states + ptr_sbr_qmf->no_channels; |
| ptr_sbr_qmf->sixty4 = NO_SYNTHESIS_CHANNELS; |
| } |
| |
| return 0; |
| } |
| |
| WORD16 ixheaacd_create_sbrdec(ixheaacd_misc_tables *pstr_common_table, |
| ia_sbr_channel_struct *ptr_sbr_channel, |
| ia_sbr_header_data_struct *ptr_header_data, |
| WORD16 chan, FLAG down_sample_flag, |
| VOID *sbr_persistent_mem_v, WORD ps_enable, |
| WORD audio_object_type) |
| |
| { |
| WORD16 err; |
| WORD16 time_slots; |
| WORD16 no_bins; |
| ia_sbr_pers_struct *sbr_persistent_mem = |
| (ia_sbr_pers_struct *)sbr_persistent_mem_v; |
| ia_sbr_dec_struct *hs = &(ptr_sbr_channel->str_sbr_dec); |
| |
| time_slots = ptr_header_data->num_time_slots; |
| |
| no_bins = (WORD16)(time_slots * ptr_header_data->time_step); |
| |
| hs->str_sbr_scale_fact.ov_lb_scale = INT_BITS - 1; |
| hs->str_sbr_scale_fact.hb_scale = INT_BITS - 1; |
| hs->str_sbr_scale_fact.ov_hb_scale = INT_BITS - 1; |
| hs->str_sbr_scale_fact.st_syn_scale = INT_BITS - 1; |
| |
| ptr_sbr_channel->pstr_prev_frame_data = |
| sbr_persistent_mem->pstr_prev_frame_data[chan]; |
| |
| err = ixheaacd_create_sbr_env_calc(pstr_common_table, &hs->str_sbr_calc_env, |
| chan, sbr_persistent_mem, ptr_header_data, |
| audio_object_type); |
| |
| if (err) { |
| return (-1); |
| } |
| |
| ixheaacd_create_cplx_anal_qmfbank( |
| &hs->str_codec_qmf_bank, &hs->str_sbr_scale_fact, no_bins, |
| ptr_header_data->pstr_freq_band_data->sub_band_start, chan, |
| sbr_persistent_mem->sbr_qmf_analy_states, |
| sbr_persistent_mem->sbr_qmf_analy_states_32, |
| sbr_persistent_mem->str_sbr_dec_inst.pstr_sbr_tables->qmf_dec_tables_ptr, |
| audio_object_type); |
| |
| ixheaacd_create_cplx_synt_qmfbank( |
| &hs->str_synthesis_qmf_bank, no_bins, |
| ptr_header_data->pstr_freq_band_data->sub_band_start, |
| ptr_header_data->pstr_freq_band_data->sub_band_end, chan, |
| down_sample_flag, sbr_persistent_mem->sbr_qmf_synth_states, |
| sbr_persistent_mem->sbr_qmf_synth_states_32, |
| sbr_persistent_mem->str_sbr_dec_inst.pstr_sbr_tables->qmf_dec_tables_ptr, |
| audio_object_type); |
| |
| ixheaacd_init_sbr_prev_framedata(ptr_sbr_channel->pstr_prev_frame_data, |
| time_slots); |
| |
| err = ixheaacd_create_hf_generator(&hs->str_hf_generator, |
| hs->str_codec_qmf_bank.num_time_slots, |
| chan, sbr_persistent_mem, ps_enable); |
| |
| if (err) { |
| return (-1); |
| } |
| |
| hs->ptr_sbr_overlap_buf = sbr_persistent_mem->ptr_sbr_overlap_buf[chan]; |
| |
| return 0; |
| } |
