rk3588-game
/
android13
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
android13/external/libxaac/decoder/ixheaacd_spectrum_dec.c

456 lines
13 KiB
C
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 <math.h>
#include <stdio.h>
#include <string.h>
#include "ixheaacd_type_def.h"
#include "ixheaacd_bitbuffer.h"
#include "ixheaacd_interface.h"
#include "ixheaacd_tns_usac.h"
#include "ixheaacd_cnst.h"
#include "ixheaacd_acelp_info.h"
#include "ixheaacd_sbrdecsettings.h"
#include "ixheaacd_info.h"
#include "ixheaacd_sbr_common.h"
#include "ixheaacd_drc_data_struct.h"
#include "ixheaacd_drc_dec.h"
#include "ixheaacd_sbrdecoder.h"
#include "ixheaacd_mps_polyphase.h"
#include "ixheaacd_sbr_const.h"
#include "ixheaacd_main.h"
#include "ixheaacd_arith_dec.h"
#include "ixheaacd_bit_extract.h"
#include "ixheaacd_func_def.h"
#include "ixheaacd_interface.h"
#include "ixheaacd_info.h"
#include "ixheaacd_defines.h"
#define MAX_NR_OF_SWB 120
VOID ixheaacd_calc_grp_offset(ia_sfb_info_struct *ptr_sfb_info, pUWORD8 group) {
WORD32 group_offset;
WORD32 group_idx;
WORD32 ixheaacd_drc_offset;
WORD16 *group_offset_p;
WORD32 sfb, len;
group_offset = 0;
group_idx = 0;
do {
ptr_sfb_info->group_len[group_idx] = group[group_idx] - group_offset;
group_offset = group[group_idx];
group_idx++;
} while (group_offset < 8);
ptr_sfb_info->num_groups = group_idx;
group_offset_p = ptr_sfb_info->sfb_idx_tbl;
ixheaacd_drc_offset = 0;
for (group_idx = 0; group_idx < ptr_sfb_info->num_groups; group_idx++) {
len = ptr_sfb_info->group_len[group_idx];
for (sfb = 0; sfb < ptr_sfb_info->sfb_per_sbk; sfb++) {
ixheaacd_drc_offset += ptr_sfb_info->sfb_width[sfb] * len;
*group_offset_p++ = ixheaacd_drc_offset;
}
}
}
VOID ixheaacd_read_tns_u(ia_sfb_info_struct *ptr_sfb_info,
ia_tns_frame_info_struct *pstr_tns_frame_info,
ia_bit_buf_struct *it_bit_buff) {
WORD32 j, k, top, coef_res, resolution, compress;
WORD32 short_flag, i;
WORD16 *sp, tmp, s_mask, n_mask;
ia_tns_filter_struct *tns_filt;
ia_tns_info_struct *pstr_tns_info;
static const WORD16 sgn_mask[] = {0x2, 0x4, 0x8};
static const WORD16 neg_mask[] = {(WORD16)0xfffc, (WORD16)0xfff8,
(WORD16)0xfff0};
WORD16 n_filt_bits;
WORD16 start_band_bits;
WORD16 order_bits;
short_flag = (!ptr_sfb_info->islong);
pstr_tns_frame_info->n_subblocks = ptr_sfb_info->max_win_len;
if (!short_flag) {
n_filt_bits = 2;
start_band_bits = 6;
order_bits = 4;
} else {
n_filt_bits = 1;
start_band_bits = 4;
order_bits = 3;
}
for (i = 0; i < pstr_tns_frame_info->n_subblocks; i++) {
pstr_tns_info = &pstr_tns_frame_info->str_tns_info[i];
if (!(pstr_tns_info->n_filt =
ixheaacd_read_bits_buf(it_bit_buff, n_filt_bits)))
continue;
pstr_tns_info->coef_res = coef_res =
ixheaacd_read_bits_buf(it_bit_buff, 1) + 3;
top = ptr_sfb_info->sfb_per_sbk;
tns_filt = &pstr_tns_info->str_filter[0];
for (j = pstr_tns_info->n_filt; j > 0; j--) {
tns_filt->stop_band = top;
top = tns_filt->start_band =
top - ixheaacd_read_bits_buf(it_bit_buff, start_band_bits);
tns_filt->order = ixheaacd_read_bits_buf(it_bit_buff, order_bits);
if (tns_filt->order) {
tns_filt->direction = ixheaacd_read_bits_buf(it_bit_buff, 1);
compress = ixheaacd_read_bits_buf(it_bit_buff, 1);
resolution = coef_res - compress;
s_mask = sgn_mask[resolution - 2];
n_mask = neg_mask[resolution - 2];
sp = tns_filt->coef;
for (k = tns_filt->order; k > 0; k--) {
tmp = ixheaacd_read_bits_buf(it_bit_buff, resolution);
*sp++ = (tmp & s_mask) ? (tmp | n_mask) : tmp;
}
}
tns_filt++;
}
}
}
VOID ixheaacd_scale_factor_data(ia_sfb_info_struct *info, WORD32 tot_sfb,
WORD32 max_sfb, WORD32 sfb_per_sbk,
WORD8 *ptr_code_book) {
WORD band;
WORD sect_cb;
WORD sect_len;
WORD8 *ptr_codebook = ptr_code_book;
WORD8 *temp_ptr_codebook = ptr_codebook;
WORD32 win_group = info->max_win_len;
memset(ptr_codebook, 0, 128);
band = 0;
while (band < tot_sfb || win_group != 0) {
sect_cb = 11;
sect_len = max_sfb;
band = band + sfb_per_sbk;
sect_len = sect_len - 1;
for (; sect_len >= 0; sect_len--) {
*temp_ptr_codebook++ = sect_cb;
}
ptr_codebook += 16;
temp_ptr_codebook = ptr_codebook;
win_group--;
}
return;
}
WORD32
ixheaacd_win_seq_select(WORD32 window_sequence_curr,
WORD32 window_sequence_last) {
WORD32 window_sequence;
switch (window_sequence_curr) {
case ONLY_LONG_SEQUENCE:
window_sequence = ONLY_LONG_SEQUENCE;
break;
case LONG_START_SEQUENCE:
if ((window_sequence_last == LONG_START_SEQUENCE) ||
(window_sequence_last == EIGHT_SHORT_SEQUENCE) ||
(window_sequence_last == STOP_START_SEQUENCE)) {
window_sequence = STOP_START_SEQUENCE;
} else {
window_sequence = LONG_START_SEQUENCE;
}
break;
case LONG_STOP_SEQUENCE:
window_sequence = LONG_STOP_SEQUENCE;
break;
case EIGHT_SHORT_SEQUENCE:
window_sequence = EIGHT_SHORT_SEQUENCE;
break;
default:
return -1;
}
return window_sequence;
}
VOID ixheaacd_tns_reset(ia_sfb_info_struct *ptr_sfb_info,
ia_tns_frame_info_struct *pstr_tns_frame_info) {
WORD32 s;
pstr_tns_frame_info->n_subblocks = ptr_sfb_info->max_win_len;
for (s = 0; s < pstr_tns_frame_info->n_subblocks; s++)
pstr_tns_frame_info->str_tns_info[s].n_filt = 0;
}
VOID ixheaacd_section_data(ia_usac_data_struct *usac_data,
ia_bit_buf_struct *g_bs, ia_sfb_info_struct *info,
WORD16 global_gain, pWORD16 factors, pUWORD8 groups,
WORD8 *ptr_code_book) {
WORD32 band;
WORD16 position = 0;
WORD32 group;
WORD16 factor = global_gain;
WORD8 *temp_codebook_ptr;
WORD16 *ptr_scale_fac, *temp_ptr_scale_fac;
WORD16 norm_val;
WORD32 window_grps, trans_sfb;
WORD16 index, length;
const UWORD16 *hscf = usac_data->huffman_code_book_scl;
const UWORD32 *idx_tab = usac_data->huffman_code_book_scl_index;
WORD32 start_bit_pos = g_bs->bit_pos;
UWORD8 *start_read_pos = g_bs->ptr_read_next;
UWORD8 *ptr_read_next = g_bs->ptr_read_next;
WORD32 bit_pos = 7 - g_bs->bit_pos;
WORD32 is_1_group = 1;
WORD32 bb = 0, i;
WORD32 increment;
WORD32 read_word =
ixheaacd_aac_showbits_32(ptr_read_next, g_bs->cnt_bits, &increment);
ptr_read_next = g_bs->ptr_read_next + increment;
trans_sfb = info->sfb_per_sbk;
temp_ptr_scale_fac = factors;
window_grps = info->max_win_len;
memset(factors, 0, MAXBANDS);
band = trans_sfb - 1;
for (group = 0; group < window_grps;) {
temp_codebook_ptr = &ptr_code_book[group * 16];
ptr_scale_fac = temp_ptr_scale_fac;
group = *groups++;
for (band = trans_sfb - 1; band >= 0; band--) {
WORD32 cb_num = *temp_codebook_ptr++;
if ((band == trans_sfb - 1) && (is_1_group == 1)) {
*temp_ptr_scale_fac = factor;
temp_ptr_scale_fac++;
continue;
}
if (cb_num == ZERO_HCB)
*temp_ptr_scale_fac++ = 0;
else {
WORD32 pns_band;
WORD16 curr_energy = 0;
UWORD32 read_word1;
read_word1 = read_word << bit_pos;
ixheaacd_huffman_decode(read_word1, &index, &length, hscf, idx_tab);
bit_pos += length;
ixheaacd_aac_read_byte_corr1(&ptr_read_next, &bit_pos, &read_word,
g_bs->ptr_bit_buf_end);
norm_val = index - 60;
if (cb_num > NOISE_HCB) {
position = position + norm_val;
*temp_ptr_scale_fac++ = -position;
} else if (cb_num < NOISE_HCB) {
factor = factor + norm_val;
*temp_ptr_scale_fac++ = factor;
} else {
curr_energy += norm_val;
pns_band = (group << 4) + trans_sfb - band - 1;
temp_ptr_scale_fac[pns_band] = curr_energy;
temp_ptr_scale_fac++;
}
}
}
is_1_group = 0;
if (!(info->islong)) {
for (bb++; bb < group; bb++) {
for (i = 0; i < trans_sfb; i++) {
ptr_scale_fac[i + trans_sfb] = ptr_scale_fac[i];
}
temp_ptr_scale_fac += trans_sfb;
ptr_scale_fac += trans_sfb;
}
}
}
ptr_read_next = ptr_read_next - increment;
ixheaacd_aac_read_byte_corr1(&ptr_read_next, &bit_pos, &read_word,
g_bs->ptr_bit_buf_end);
g_bs->ptr_read_next = ptr_read_next;
g_bs->bit_pos = 7 - bit_pos;
{
WORD32 bits_consumed;
bits_consumed = ((g_bs->ptr_read_next - start_read_pos) << 3) +
(start_bit_pos - g_bs->bit_pos);
g_bs->cnt_bits -= bits_consumed;
}
}
WORD32 ixheaacd_fd_channel_stream(
ia_usac_data_struct *usac_data,
ia_usac_tmp_core_coder_struct *pstr_core_coder, UWORD8 *max_sfb,
WORD32 window_sequence_last, WORD32 chn, WORD32 noise_filling, WORD32 ch,
ia_bit_buf_struct *it_bit_buff
)
{
WORD32 i;
WORD32 tot_sfb;
WORD32 noise_level = 0;
WORD32 arith_reset_flag;
WORD32 arth_size;
WORD16 global_gain;
WORD32 max_spec_coefficients;
WORD32 err_code = 0;
WORD32 noise_offset;
WORD32 *fac_data;
ia_sfb_info_struct *info;
WORD8 *ptr_code_book = (WORD8 *)&usac_data->scratch_buffer;
global_gain = ixheaacd_read_bits_buf(it_bit_buff, 8);
if (noise_filling) {
noise_level = ixheaacd_read_bits_buf(it_bit_buff, 3);
noise_offset = ixheaacd_read_bits_buf(it_bit_buff, 5);
} else {
noise_level = 0;
noise_offset = 0;
}
if (!pstr_core_coder->common_window) {
err_code = ixheaacd_ics_info(usac_data, chn, max_sfb, it_bit_buff,
window_sequence_last);
if (err_code == -1) return err_code;
}
info = usac_data->pstr_sfb_info[chn];
if (!pstr_core_coder->common_tw && usac_data->tw_mdct[0] == 1) {
usac_data->tw_data_present[chn] = ixheaacd_read_bits_buf(it_bit_buff, 1);
if (usac_data->tw_data_present[chn]) {
WORD32 i;
for (i = 0; i < NUM_TW_NODES; i++) {
usac_data->tw_ratio[chn][i] = ixheaacd_read_bits_buf(it_bit_buff, 3);
}
}
}
if (*max_sfb == 0) {
tot_sfb = 0;
} else {
i = 0;
tot_sfb = info->sfb_per_sbk;
while (usac_data->group_dis[chn][i++] < info->max_win_len) {
tot_sfb += info->sfb_per_sbk;
}
}
ixheaacd_scale_factor_data(info, tot_sfb, *max_sfb, info->sfb_per_sbk,
ptr_code_book);
if ((it_bit_buff->ptr_read_next > it_bit_buff->ptr_bit_buf_end - 3) &&
(it_bit_buff->size == it_bit_buff->max_size)) {
return -1;
}
ixheaacd_section_data(usac_data, it_bit_buff, info, global_gain,
usac_data->factors[chn], usac_data->group_dis[chn],
ptr_code_book);
if (pstr_core_coder->tns_data_present[ch] == 0)
ixheaacd_tns_reset(info, usac_data->pstr_tns[chn]);
if (pstr_core_coder->tns_data_present[ch] == 1)
ixheaacd_read_tns_u(info, usac_data->pstr_tns[chn], it_bit_buff);
if (*max_sfb > 0) {
max_spec_coefficients =
info->sfb_idx_tbl[*max_sfb - 1] / info->group_len[0];
} else {
max_spec_coefficients = 0;
}
if (usac_data->usac_independency_flg)
arith_reset_flag = 1;
else
arith_reset_flag = ixheaacd_read_bits_buf(it_bit_buff, 1);
switch (usac_data->window_sequence[chn]) {
case EIGHT_SHORT_SEQUENCE:
arth_size = usac_data->ccfl / 8;
break;
default:
arth_size = usac_data->ccfl;
break;
}
err_code = ixheaacd_ac_spectral_data(
usac_data, max_spec_coefficients, noise_level, noise_offset, arth_size,
it_bit_buff, *max_sfb, arith_reset_flag, noise_filling, chn);
if (err_code != 0) return err_code;
usac_data->fac_data_present[chn] = ixheaacd_read_bits_buf(it_bit_buff, 1);
if (usac_data->fac_data_present[chn]) {
WORD32 fac_len;
if ((usac_data->window_sequence[chn]) == EIGHT_SHORT_SEQUENCE) {
fac_len = (usac_data->ccfl) / 16;
} else {
fac_len = (usac_data->ccfl) / 8;
}
fac_data = usac_data->fac_data[chn];
fac_data[0] = ixheaacd_read_bits_buf(it_bit_buff, 7);
ixheaacd_fac_decoding(fac_len, 0, &fac_data[1], it_bit_buff);
}
return 0;
}
Reference in New Issue View Git Blame Copy Permalink