king
/
v811_spc009
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '8f4c154c05'
${ noResults }
v811_spc009/external/libxaac/decoder/ixheaacd_sbrdec_initfuncs.c

1140 lines
42 KiB
Raw Blame History

/******************************************************************************
* *
* 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)));
}
VOID 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;
}
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)
ixheaacd_create_psdec(
sbr_persistent_mem->str_sbr_dec_inst.pstr_ps_stereo_dec,
sbr_persistent_mem, &ptr_overlap_buf[512 * 4]);
else
ixheaacd_create_psdec(
sbr_persistent_mem->str_sbr_dec_inst.pstr_ps_stereo_dec,
sbr_persistent_mem, ptr_overlap_buf);
}
}
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 VOID
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;
}
static PLATFORM_INLINE VOID 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;
}
VOID 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;
}
static PLATFORM_INLINE VOID 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;
}
static PLATFORM_INLINE VOID 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));
qmf_filter_state_size = QMF_FILTER_STATE_SYN_SIZE;
if (down_sample_flag) {
L = NO_SYNTHESIS_CHANNELS_DOWN_SAMPLED;
ptr_sbr_qmf->usb = NO_SYNTHESIS_CHANNELS_DOWN_SAMPLED;
} else {
L = NO_SYNTHESIS_CHANNELS;
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;
}
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);
ixheaacd_create_hf_generator(&hs->str_hf_generator,
hs->str_codec_qmf_bank.num_time_slots, chan,
sbr_persistent_mem, ps_enable);
hs->ptr_sbr_overlap_buf = sbr_persistent_mem->ptr_sbr_overlap_buf[chan];
return 0;
}
Reference in new issue View Git Blame Copy Permalink