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_sbrdecoder.c

751 lines
27 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_audioobjtypes.h"
VOID ixheaacd_downmix_to_monosbr(WORD16 *core_sample_buf, WORD32 ch_fac) {
WORD32 i;
WORD16 *ptr1 = &core_sample_buf[0];
WORD16 *ptr2 = &core_sample_buf[1];
for (i = MAX_FRAME_SIZE - 1; i >= 0; i--) {
*ptr1 = ((*ptr1 >> 1) + (*ptr2 >> 1));
ptr1 += ch_fac;
ptr2 += ch_fac;
}
}
static WORD32 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 old_lsb, new_lsb;
WORD32 l;
WORD32 err = 0;
WORD32 num_time_slots = ptr_sbr_dec->str_codec_qmf_bank.num_time_slots;
WORD32 upsample_ratio_idx = ptr_header_data->sbr_ratio_idx;
WORD32 op_delay = 6 + SBR_HF_ADJ_OFFSET;
WORD32 hbe_flag = ptr_header_data->hbe_flag;
WORD32 usac_flag = ptr_header_data->usac_flag;
if (ptr_header_data->is_usf_4) {
op_delay = op_delay + 6;
}
ixheaacd_reset_sbrenvelope_calc(&ptr_sbr_dec->str_sbr_calc_env);
new_lsb = ptr_header_data->pstr_freq_band_data->sub_band_start;
ptr_sbr_dec->str_synthesis_qmf_bank.lsb = new_lsb;
ptr_sbr_dec->str_synthesis_qmf_bank.usb =
ptr_header_data->pstr_freq_band_data->sub_band_end;
old_lsb = ptr_sbr_dec->str_synthesis_qmf_bank.lsb;
ptr_sbr_dec->str_codec_qmf_bank.lsb = 0;
ptr_sbr_dec->str_codec_qmf_bank.usb = old_lsb;
{
WORD32 *plpc_filt_states_real =
&ptr_sbr_dec->str_hf_generator.lpc_filt_states_real[0][old_lsb];
WORD32 *plpc_filt_states_real_1 =
&ptr_sbr_dec->str_hf_generator.lpc_filt_states_real[1][old_lsb];
WORD32 *plpc_filt_states_imag =
&ptr_sbr_dec->str_hf_generator.lpc_filt_states_imag[0][old_lsb];
WORD32 *plpc_filt_states_imag_1 =
&ptr_sbr_dec->str_hf_generator.lpc_filt_states_imag[1][old_lsb];
for (l = new_lsb - old_lsb - 1; l >= 0; l--) {
*plpc_filt_states_real++ = *plpc_filt_states_real_1++ = 0L;
if (!low_pow_flag) {
*plpc_filt_states_imag++ = *plpc_filt_states_imag_1++ = 0L;
}
}
}
if (usac_flag) {
WORD32 start_band;
WORD32 stop_band;
WORD32 start_slot = SBR_HF_ADJ_OFFSET;
WORD32 k;
start_band = ptr_header_data->pstr_freq_band_data->qmf_sb_prev;
stop_band = ptr_header_data->pstr_freq_band_data->sub_band_start;
if (!hbe_flag) {
for (l = 0; l < SBR_HF_ADJ_OFFSET; l++) {
for (k = start_band; k < stop_band; k++) {
ptr_sbr_dec->qmf_buf_real[l][k] = 0.0;
ptr_sbr_dec->qmf_buf_imag[l][k] = 0.0;
}
}
for (l = start_slot; l < op_delay; l++) {
for (k = start_band; k < stop_band; k++) {
ptr_sbr_dec->qmf_buf_real[l][k] = 0.0;
ptr_sbr_dec->qmf_buf_imag[l][k] = 0.0;
}
}
}
if (hbe_flag && ptr_sbr_dec->p_hbe_txposer != NULL) {
WORD32 k, i;
WORD32 err = ixheaacd_qmf_hbe_data_reinit(
ptr_sbr_dec->p_hbe_txposer,
ptr_header_data->pstr_freq_band_data->freq_band_table,
ptr_header_data->pstr_freq_band_data->num_sf_bands,
ptr_header_data->is_usf_4);
if (err) return err;
for (k = 0; k < 2; k++) {
if (!((upsample_ratio_idx == SBR_UPSAMPLE_IDX_4_1) && (k == 0))) {
WORD32 xpos_delay = num_time_slots * k;
if (upsample_ratio_idx == SBR_UPSAMPLE_IDX_4_1) {
xpos_delay = num_time_slots * k - 32;
}
for (i = 0; i < 8; i++) {
memmove(ptr_sbr_dec->ph_vocod_qmf_real[i],
ptr_sbr_dec->ph_vocod_qmf_real[num_time_slots + i],
64 * sizeof(FLOAT32));
memmove(ptr_sbr_dec->ph_vocod_qmf_imag[i],
ptr_sbr_dec->ph_vocod_qmf_imag[num_time_slots + i],
64 * sizeof(FLOAT32));
}
err = ixheaacd_qmf_hbe_apply(
ptr_sbr_dec->p_hbe_txposer,
ptr_sbr_dec->qmf_buf_real + op_delay + xpos_delay,
ptr_sbr_dec->qmf_buf_imag + op_delay + xpos_delay, num_time_slots,
ptr_sbr_dec->ph_vocod_qmf_real + op_delay,
ptr_sbr_dec->ph_vocod_qmf_imag + op_delay, pitch_in_bins);
if (err) return err;
if (upsample_ratio_idx == SBR_UPSAMPLE_IDX_4_1) {
ixheaacd_hbe_repl_spec(&ptr_sbr_dec->p_hbe_txposer->x_over_qmf[0],
ptr_sbr_dec->ph_vocod_qmf_real + op_delay,
ptr_sbr_dec->ph_vocod_qmf_imag + op_delay,
num_time_slots,
ptr_sbr_dec->p_hbe_txposer->max_stretch);
}
}
}
}
}
if (!usac_flag) {
err |= ixheaacd_reset_hf_generator(&ptr_sbr_dec->str_hf_generator,
ptr_header_data, audio_object_type);
ixheaacd_derive_lim_band_tbl(
ptr_header_data,
ptr_sbr_dec->str_hf_generator.pstr_settings->str_patch_param,
ptr_sbr_dec->str_hf_generator.pstr_settings->num_patches,
pstr_common_tables);
}
return err;
}
VOID ixheaacd_prepare_upsamp(ia_sbr_header_data_struct **ptr_header_data,
ia_sbr_channel_struct *pstr_sbr_channel[2],
WORD32 num_channels) {
WORD32 lr;
ia_sbr_qmf_filter_bank_struct *sbr_qmf_bank;
for (lr = 0; lr < num_channels; lr++) {
ptr_header_data[lr]->pstr_freq_band_data->sub_band_start =
NO_ANALYSIS_CHANNELS;
ptr_header_data[lr]->pstr_freq_band_data->sub_band_end =
NO_SYNTHESIS_CHANNELS;
sbr_qmf_bank = &pstr_sbr_channel[lr]->str_sbr_dec.str_synthesis_qmf_bank;
sbr_qmf_bank->lsb = NO_ANALYSIS_CHANNELS;
sbr_qmf_bank->usb = NO_SYNTHESIS_CHANNELS;
sbr_qmf_bank = &pstr_sbr_channel[lr]->str_sbr_dec.str_codec_qmf_bank;
sbr_qmf_bank->lsb = 0;
sbr_qmf_bank->usb = NO_ANALYSIS_CHANNELS;
ptr_header_data[lr]->sync_state = UPSAMPLING;
}
return;
}
IA_ERRORCODE 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 k;
FLAG prev_ps_flag = 0;
FLAG ps_flag = 0;
FLAG stereo = 0;
FLAG low_pow_flag = 0;
FLAG header_flag = 1;
FLAG dual_mono = 0;
WORD32 err = 0;
WORD32 num_channels = *codec_num_channels;
FLAG prev_stereo;
WORD32 ele_channels = 0;
WORD32 num_elements = p_sbr_bit_stream->no_elements;
WORD32 usac_flag = self->aot_usac_flag;
ia_sbr_channel_struct *pstr_sbr_channel[2];
ia_sbr_header_data_struct *ptr_header_data[MAXNRSBRCHANNELS];
WORD32 initial_sync_state;
ia_sbr_header_data_struct *ptr_sbr_dflt_header =
(ia_sbr_header_data_struct *)(&self->str_sbr_dflt_header);
ia_sbr_frame_info_data_struct *ptr_frame_data[2];
for (k = 0; k < 2; k++) {
ptr_frame_data[k] = (ia_sbr_frame_info_data_struct *)self->frame_buffer[k];
pstr_sbr_channel[k] = self->pstr_sbr_channel[k];
ptr_header_data[k] = self->pstr_sbr_header[k];
if (audio_object_type == AOT_ER_AAC_ELD) {
ptr_frame_data[k]->eld_sbr_flag = eld_sbr_flag;
ptr_frame_data[k]->num_time_slots = ptr_header_data[0]->num_time_slots;
}
ptr_frame_data[k]->usac_independency_flag = self->usac_independency_flag;
ptr_frame_data[k]->mps_sbr_flag = (self->stereo_config_idx == 3) ? 1 : 0;
ptr_frame_data[k]->stereo_config_idx = self->stereo_config_idx;
ptr_frame_data[k]->inter_tes_flag = self->inter_tes_flag;
ptr_frame_data[k]->sbr_mode = self->sbr_mode;
if (!usac_flag) {
ptr_frame_data[k]->usac_independency_flag = 0;
ptr_frame_data[k]->mps_sbr_flag = 0;
ptr_frame_data[k]->stereo_config_idx = -1;
ptr_frame_data[k]->inter_tes_flag = 0;
ptr_frame_data[k]->sbr_mode = ORIG_SBR;
}
}
for (k = 0; k < *codec_num_channels; k++) {
ptr_header_data[k]->usac_flag = self->aot_usac_flag;
ptr_header_data[k]->usac_independency_flag = self->usac_independency_flag;
ptr_header_data[k]->hbe_flag = self->hbe_flag;
ptr_header_data[k]->pvc_flag = self->pvc_flag;
if (!usac_flag) {
ptr_header_data[k]->usac_independency_flag = 0;
ptr_header_data[k]->hbe_flag = 0;
ptr_header_data[k]->pvc_flag = 0;
}
}
initial_sync_state = ptr_header_data[0]->sync_state;
low_pow_flag = !usac_flag;
self->pstr_sbr_tables->sbr_rand_ph =
self->pstr_sbr_tables->env_calc_tables_ptr->sbr_rand_ph;
if (ps_enable) {
if (num_channels == 1) {
low_pow_flag = 0;
}
}
if (audio_object_type == AOT_ER_AAC_ELD) {
low_pow_flag = 0;
}
prev_stereo = (ptr_header_data[0]->channel_mode == SBR_STEREO);
if (ps_enable) prev_ps_flag = (ptr_header_data[0]->channel_mode == PS_STEREO);
ptr_header_data[0]->err_flag_prev = ptr_header_data[0]->err_flag;
if (p_sbr_bit_stream->no_elements == 0) {
frame_status = 0;
ptr_header_data[0]->sync_state = UPSAMPLING;
if (num_channels == 2) ptr_header_data[1]->sync_state = UPSAMPLING;
}
if ((usac_flag)) {
if ((p_sbr_bit_stream->no_elements) &&
(p_sbr_bit_stream->str_sbr_ele->size_payload > 0)) {
num_elements = p_sbr_bit_stream->no_elements;
} else {
num_elements = 0;
}
}
for (k = 0; k < num_elements; k++) {
struct ia_bit_buf_struct local_bit_buf = {0};
ia_sbr_element_stream_struct *ptr_bit_str_ele =
&p_sbr_bit_stream->str_sbr_ele[k];
ele_channels =
(p_sbr_bit_stream->str_sbr_ele[0].sbr_ele_id == SBR_ID_CPE) ? 2 : 1;
switch (ptr_bit_str_ele->sbr_ele_id) {
case SBR_ID_SCE:
case SBR_ID_CCE:
if (num_channels == 2) {
dual_mono = 1;
}
stereo = 0;
break;
case SBR_ID_CPE:
stereo = 1;
ptr_header_data[1] = ptr_header_data[0];
memcpy(self->pstr_sbr_header[1], self->pstr_sbr_header[0],
sizeof(ia_sbr_header_data_struct));
break;
default:
frame_status = 0;
}
if (frame_status) {
if (!usac_flag) {
ixheaacd_create_init_bit_buf(&local_bit_buf,
(UWORD8 *)ptr_bit_str_ele->ptr_sbr_data,
ptr_bit_str_ele->size_payload);
it_bit_buff = &local_bit_buf;
it_bit_buff->xaac_jmp_buf = self->xaac_jmp_buf;
if (audio_object_type == AOT_ER_AAC_ELD) {
if (eld_sbr_flag != 1) {
ixheaacd_read_bits_buf(&local_bit_buf, LEN_NIBBLE);
}
} else {
ixheaacd_read_bits_buf(&local_bit_buf, LEN_NIBBLE);
}
}
if (ptr_bit_str_ele->extension_type == SBR_EXTENSION_CRC) {
WORD32 crc_bits = 0;
WORD32 crc_check_flag = 0;
crc_check_flag = 1;
crc_bits = (((ptr_bit_str_ele->size_payload - 1) << 3) +
(4 - SBR_CYC_REDCY_CHK_BITS));
if (crc_bits < 0) {
crc_check_flag = 0;
frame_status = 0;
}
if (crc_check_flag)
frame_status = ixheaacd_sbr_crccheck(it_bit_buff, crc_bits);
}
if (!usac_flag) header_flag = ixheaacd_read_bits_buf(it_bit_buff, 1);
if (audio_object_type != AOT_ER_AAC_ELD) {
if (header_flag) {
header_flag = ixheaacd_sbr_read_header_data(
ptr_header_data[k], it_bit_buff, stereo, ptr_sbr_dflt_header);
if (usac_flag) {
if ((self->ptr_pvc_data_str->prev_pvc_mode == 0) &&
(ptr_header_data[k]->pvc_mode != 0)) {
self->ptr_pvc_data_str->prev_pvc_id = 0;
}
self->ptr_pvc_data_str->prev_pvc_mode =
ptr_header_data[k]->pvc_mode;
if (ptr_header_data[k]->pvc_mode == 0) {
ptr_frame_data[k]->sbr_mode = ORIG_SBR;
} else {
ptr_frame_data[k]->sbr_mode = PVC_SBR;
}
}
if (header_flag == SBR_RESET) {
err = ixheaacd_calc_frq_bnd_tbls(ptr_header_data[k],
self->pstr_common_tables);
if (!err) {
WORD32 lr;
WORD32 lr1 = ps_enable ? 2 : num_channels;
for (lr = 0; lr < lr1; lr++) {
ptr_frame_data[lr]->reset_flag = 1;
err |= ixheaacd_sbr_dec_reset(
&(pstr_sbr_channel[lr]->str_sbr_dec), ptr_header_data[k],
low_pow_flag, self->pstr_common_tables,
ptr_frame_data[k]->pitch_in_bins, audio_object_type);
if (err < 0) return err;
}
}
if (err == 0) {
ptr_header_data[k]->sync_state = SBR_ACTIVE;
}
}
}
} else {
if (header_flag) {
header_flag = ixheaacd_sbr_read_header_data(
ptr_header_data[k], it_bit_buff, stereo, ptr_sbr_dflt_header);
if (usac_flag) {
if ((self->ptr_pvc_data_str->prev_pvc_mode == 0) &&
(ptr_header_data[k]->pvc_mode != 0)) {
self->ptr_pvc_data_str->prev_pvc_id = 0;
}
self->ptr_pvc_data_str->prev_pvc_mode =
ptr_header_data[k]->pvc_mode;
if (ptr_header_data[k]->pvc_mode == 0) {
ptr_frame_data[k]->sbr_mode = ORIG_SBR;
} else {
ptr_frame_data[k]->sbr_mode = PVC_SBR;
}
}
if (header_flag == SBR_RESET) {
err = ixheaacd_calc_frq_bnd_tbls(ptr_header_data[k],
self->pstr_common_tables);
if (err) {
return err;
}
}
}
{
WORD32 lr;
WORD32 lr1 = ps_enable ? 2 : num_channels;
for (lr = 0; lr < lr1; lr++) {
ptr_frame_data[lr]->reset_flag = 1;
if (ptr_header_data[k]->status) {
err |= ixheaacd_sbr_dec_reset(
&(pstr_sbr_channel[lr]->str_sbr_dec), ptr_header_data[k],
low_pow_flag, self->pstr_common_tables,
ptr_frame_data[k]->pitch_in_bins, audio_object_type);
if (err < 0) return err;
}
}
ptr_header_data[k]->status = 0;
}
if (err == 0) {
ptr_header_data[k]->sync_state = SBR_ACTIVE;
}
}
}
if (err || (ptr_header_data[k]->sync_state == SBR_NOT_INITIALIZED)) {
WORD32 lr1 = ps_enable ? 2 : num_channels;
ixheaacd_prepare_upsamp(ptr_header_data, pstr_sbr_channel, lr1);
if (err) return err;
}
if (frame_status && (ptr_header_data[k]->sync_state == SBR_ACTIVE)) {
if (stereo) {
frame_status = ixheaacd_sbr_read_cpe(ptr_header_data[0], ptr_frame_data,
it_bit_buff, self->pstr_sbr_tables,
audio_object_type);
} else {
if (ps_enable) {
if (down_mix_flag) {
self->pstr_ps_stereo_dec->force_mono = 1;
} else {
self->pstr_ps_stereo_dec->force_mono = 0;
}
} else {
self->pstr_ps_stereo_dec = 0;
}
if (ptr_frame_data[k]->sbr_mode == ORIG_SBR) {
frame_status = ixheaacd_sbr_read_sce(
ptr_header_data[k], ptr_frame_data[k], self->pstr_ps_stereo_dec,
it_bit_buff, self->pstr_sbr_tables, audio_object_type);
if (frame_status < 0) return frame_status;
} else if (ptr_frame_data[k]->sbr_mode == PVC_SBR) {
frame_status = ixheaacd_sbr_read_pvc_sce(
ptr_frame_data[k], it_bit_buff, 0, self->ptr_pvc_data_str,
self->pstr_sbr_tables, ptr_header_data[k]);
if (frame_status < 0) return frame_status;
}
}
if (audio_object_type != AOT_ER_AAC_ELD) {
WORD32 total_bits_read;
total_bits_read = ixheaacd_no_bits_read(it_bit_buff);
if (total_bits_read > (ptr_bit_str_ele->size_payload << 3) ||
total_bits_read < ((ptr_bit_str_ele->size_payload << 3) - 8)) {
frame_status = 0;
}
}
}
}
if (!usac_flag) {
if (!frame_status || (ptr_header_data[0]->sync_state != SBR_ACTIVE) ||
ptr_header_data[0]->err_flag) {
ptr_header_data[0]->err_flag = 1;
stereo = (num_channels == 2) ? 1 : 0;
if (ptr_header_data[0]->channel_mode == 0) {
ptr_header_data[0]->channel_mode = stereo ? SBR_STEREO : SBR_MONO;
}
}
if (!(stereo || dual_mono)) {
ptr_frame_data[0]->coupling_mode = COUPLING_OFF;
ptr_frame_data[1]->coupling_mode = COUPLING_OFF;
}
if (ptr_header_data[0]->sync_state == SBR_NOT_INITIALIZED) {
WORD32 lr1 = ps_enable ? 2 : num_channels;
ixheaacd_prepare_upsamp(ptr_header_data, pstr_sbr_channel, lr1);
}
}
if (ptr_header_data[0]->sync_state == SBR_ACTIVE) {
if (ptr_frame_data[0]->sbr_mode == PVC_SBR) {
err = ixheaacd_dec_sbrdata_for_pvc(
ptr_header_data[0], ptr_frame_data[0],
pstr_sbr_channel[0]->pstr_prev_frame_data);
if (err) return err;
} else if (ptr_frame_data[0]->sbr_mode == ORIG_SBR) {
err = ixheaacd_dec_sbrdata(
ptr_header_data[0], ptr_header_data[1], ptr_frame_data[0],
pstr_sbr_channel[0]->pstr_prev_frame_data,
(stereo || dual_mono) ? ptr_frame_data[1] : NULL,
(stereo || dual_mono) ? pstr_sbr_channel[1]->pstr_prev_frame_data
: NULL,
self->pstr_common_tables);
if (err) return err;
}
if (ptr_header_data[0]->channel_mode == PS_STEREO &&
(audio_object_type != AOT_ER_AAC_ELD &&
audio_object_type != AOT_ER_AAC_LD)) {
ixheaacd_decode_ps_data(self->pstr_ps_stereo_dec);
ps_flag = 1;
self->ps_present = ps_flag;
}
ptr_frame_data[0]->max_qmf_subband_aac =
ptr_header_data[0]->pstr_freq_band_data->sub_band_start;
if (stereo) {
ptr_frame_data[1]->max_qmf_subband_aac =
ptr_header_data[1]->pstr_freq_band_data->sub_band_start;
}
}
if (audio_object_type != AOT_ER_AAC_ELD) {
if ((initial_sync_state == SBR_NOT_INITIALIZED) &&
ptr_header_data[0]->err_flag) {
ptr_header_data[0]->sync_state = SBR_NOT_INITIALIZED;
}
} else {
ptr_header_data[0]->sync_state = SBR_ACTIVE;
}
if ((num_channels == 2) && !(stereo || dual_mono)) {
ixheaacd_downmix_to_monosbr(&core_sample_buf[slot_element], ch_fac);
}
if ((!prev_stereo && !prev_ps_flag) && (ps_flag)) {
WORD32 copy_size;
if (down_samp_flag)
copy_size = QMF_FILTER_STATE_SYN_SIZE_DOWN_SAMPLED;
else
copy_size = QMF_FILTER_STATE_SYN_SIZE;
memcpy(
pstr_sbr_channel[1]->str_sbr_dec.str_synthesis_qmf_bank.filter_states,
pstr_sbr_channel[0]->str_sbr_dec.str_synthesis_qmf_bank.filter_states,
copy_size * sizeof(WORD16));
pstr_sbr_channel[1]->str_sbr_dec.str_sbr_scale_fact.st_syn_scale =
pstr_sbr_channel[0]->str_sbr_dec.str_sbr_scale_fact.st_syn_scale;
}
if ((!prev_stereo && stereo && (num_channels == 2)) &&
(audio_object_type != AOT_ER_AAC_ELD)) {
WORD32 copy_size;
if (down_samp_flag)
copy_size = QMF_FILTER_STATE_SYN_SIZE_DOWN_SAMPLED;
else
copy_size = QMF_FILTER_STATE_SYN_SIZE;
memcpy(
pstr_sbr_channel[1]->str_sbr_dec.str_synthesis_qmf_bank.filter_states,
pstr_sbr_channel[0]->str_sbr_dec.str_synthesis_qmf_bank.filter_states,
copy_size * sizeof(WORD16));
pstr_sbr_channel[1]->str_sbr_dec.str_sbr_scale_fact.st_syn_scale =
pstr_sbr_channel[0]->str_sbr_dec.str_sbr_scale_fact.st_syn_scale;
memcpy(
pstr_sbr_channel[1]->str_sbr_dec.str_codec_qmf_bank.anal_filter_states,
pstr_sbr_channel[0]->str_sbr_dec.str_codec_qmf_bank.anal_filter_states,
QMF_FILTER_STATE_ANA_SIZE * sizeof(WORD16));
pstr_sbr_channel[1]->str_sbr_dec.str_sbr_scale_fact.st_lb_scale =
pstr_sbr_channel[0]->str_sbr_dec.str_sbr_scale_fact.st_lb_scale;
memcpy(pstr_sbr_channel[1]->str_sbr_dec.ptr_sbr_overlap_buf,
pstr_sbr_channel[0]->str_sbr_dec.ptr_sbr_overlap_buf,
MAX_OV_COLS * NO_SYNTHESIS_CHANNELS * sizeof(WORD32));
pstr_sbr_channel[1]->str_sbr_dec.str_sbr_scale_fact.ov_lb_scale =
pstr_sbr_channel[0]->str_sbr_dec.str_sbr_scale_fact.ov_lb_scale;
pstr_sbr_channel[1]->str_sbr_dec.str_sbr_scale_fact.ov_hb_scale =
pstr_sbr_channel[0]->str_sbr_dec.str_sbr_scale_fact.ov_hb_scale;
}
pstr_sbr_channel[0]->str_sbr_dec.time_sample_buf = self->time_sample_buf[0];
if (pstr_drc_dec == NULL) {
WORD32 err_code = 0;
err_code = ixheaacd_sbr_dec(
&pstr_sbr_channel[0]->str_sbr_dec, core_sample_buf + slot_element,
ptr_header_data[0], ptr_frame_data[0],
pstr_sbr_channel[0]->pstr_prev_frame_data, self->pstr_ps_stereo_dec,
&pstr_sbr_channel[1]->str_sbr_dec.str_synthesis_qmf_bank,
&pstr_sbr_channel[1]->str_sbr_dec.str_sbr_scale_fact,
(ptr_header_data[0]->sync_state == SBR_ACTIVE), low_pow_flag,
sbr_scratch_struct->ptr_work_buf_core, self->pstr_sbr_tables,
self->pstr_common_tables, ch_fac, self->ptr_pvc_data_str, 0, NULL,
audio_object_type);
if (err_code) return err_code;
} else {
WORD32 err_code = 0;
err_code = ixheaacd_sbr_dec(
&pstr_sbr_channel[0]->str_sbr_dec, core_sample_buf + slot_element,
ptr_header_data[0], ptr_frame_data[0],
pstr_sbr_channel[0]->pstr_prev_frame_data, self->pstr_ps_stereo_dec,
&pstr_sbr_channel[1]->str_sbr_dec.str_synthesis_qmf_bank,
&pstr_sbr_channel[1]->str_sbr_dec.str_sbr_scale_fact,
(ptr_header_data[0]->sync_state == SBR_ACTIVE), low_pow_flag,
sbr_scratch_struct->ptr_work_buf_core, self->pstr_sbr_tables,
self->pstr_common_tables, ch_fac, self->ptr_pvc_data_str,
pstr_drc_dec->drc_on,
pstr_drc_dec->str_drc_channel_data[0].drc_factors_sbr,
audio_object_type);
if (err_code) return err_code;
}
if (!down_mix_flag && (stereo || dual_mono) && (num_channels == 2)) {
pstr_sbr_channel[1]->str_sbr_dec.time_sample_buf = self->time_sample_buf[1];
if (ele_channels == 1 && usac_flag) {
WORD32 err_code = ixheaacd_esbr_dec(
&pstr_sbr_channel[1]->str_sbr_dec, ptr_header_data[1],
ptr_frame_data[1], (ptr_header_data[1]->sync_state == SBR_ACTIVE),
low_pow_flag, self->pstr_sbr_tables, ch_fac);
if (err_code) return err_code;
} else {
if (pstr_drc_dec == NULL) {
WORD32 err_code = ixheaacd_sbr_dec(
&pstr_sbr_channel[1]->str_sbr_dec,
core_sample_buf + slot_element + 1, ptr_header_data[1],
ptr_frame_data[1], pstr_sbr_channel[1]->pstr_prev_frame_data, NULL,
NULL, NULL, (ptr_header_data[1]->sync_state == SBR_ACTIVE),
low_pow_flag, sbr_scratch_struct->ptr_work_buf_core,
self->pstr_sbr_tables, self->pstr_common_tables, ch_fac,
self->ptr_pvc_data_str, 0, NULL, audio_object_type);
if (err_code) return err_code;
} else {
WORD32 err_code = ixheaacd_sbr_dec(
&pstr_sbr_channel[1]->str_sbr_dec,
core_sample_buf + slot_element + 1, ptr_header_data[1],
ptr_frame_data[1], pstr_sbr_channel[1]->pstr_prev_frame_data, NULL,
NULL, NULL, (ptr_header_data[1]->sync_state == SBR_ACTIVE),
low_pow_flag, sbr_scratch_struct->ptr_work_buf_core,
self->pstr_sbr_tables, self->pstr_common_tables, ch_fac,
self->ptr_pvc_data_str, pstr_drc_dec->drc_on,
pstr_drc_dec->str_drc_channel_data[1].drc_factors_sbr,
audio_object_type);
if (err_code) return err_code;
}
}
} else {
if (audio_object_type != AOT_ER_AAC_ELD &&
audio_object_type != AOT_ER_AAC_LD)
{
if (sub_d((WORD16)ptr_header_data[0]->channel_mode, PS_STEREO) == 0) {
num_channels = 2;
}
}
}
*codec_num_channels = num_channels;
self->sbr_mode = ptr_frame_data[0]->sbr_mode;
if (pstr_drc_dec != NULL) {
WORD32 i, j;
for (i = 0; i < *codec_num_channels; i++) {
for (j = 0; j < 32; j++) {
memcpy(pstr_drc_dec->str_drc_channel_data[i].drc_factors_sbr[j],
pstr_drc_dec->str_drc_channel_data[i].drc_factors_sbr[j + 32],
64 * sizeof(WORD32));
}
}
}
return SBRDEC_OK;
}
Reference in new issue View Git Blame Copy Permalink