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

575 lines
19 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 <stdlib.h>
#include <string.h>
#include "ixheaacd_type_def.h"
#include "ixheaacd_interface.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_td_mdct.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_windows.h"
#include "ixheaacd_vec_baisc_ops.h"
#include "ixheaacd_constants.h"
#include "ixheaacd_function_selector.h"
#include "ixheaacd_basic_ops32.h"
#include "ixheaacd_basic_ops40.h"
#include "ixheaacd_func_def.h"
#include "ixheaacd_windows.h"
extern const WORD32 ixheaacd_pre_post_twid_cos_512[512];
extern const WORD32 ixheaacd_pre_post_twid_sin_512[512];
extern const WORD32 ixheaacd_pre_post_twid_cos_384[384];
extern const WORD32 ixheaacd_pre_post_twid_sin_384[384];
extern const WORD32 ixheaacd_pre_post_twid_cos_64[64];
extern const WORD32 ixheaacd_pre_post_twid_sin_64[64];
extern const WORD32 ixheaacd_pre_post_twid_cos_48[48];
extern const WORD32 ixheaacd_pre_post_twid_sin_48[48];
extern const FLOAT64 ixheaacd_power_10_table[28];
#define ABS(A) ((A) < 0 ? (-A) : (A))
static WORD32 ixheaacd_calc_max_spectralline(WORD32 *p_in_ibuffer, WORD32 n) {
WORD32 k, shiftp, itemp = 0;
for (k = 0; k < n; k++) {
if (ixheaacd_abs32_sat(p_in_ibuffer[k]) > itemp)
itemp = ixheaacd_abs32_sat(p_in_ibuffer[k]);
}
shiftp = ixheaacd_norm32(itemp);
return (shiftp);
}
static void ixheaacd_normalize(WORD32 *buff, WORD32 shift, WORD len) {
WORD32 i;
for (i = 0; i < len; i++) {
buff[i] = buff[i] << shift;
}
}
static FLOAT32 ixheaacd_pow10(WORD32 input) {
FLOAT32 output = 1;
while (input > 0) {
output *= 10;
input--;
}
return (output);
}
void ixheaacd_calc_pre_twid_dec(WORD32 *ptr_x, WORD32 *r_ptr, WORD32 *i_ptr,
WORD32 nlength, const WORD32 *cos_ptr,
const WORD32 *sin_ptr) {
WORD32 i;
WORD32 *ptr_y;
ptr_y = &ptr_x[2 * nlength - 1];
for (i = 0; i < nlength; i++) {
*r_ptr++ = ((ixheaacd_mult32(ixheaacd_negate32_sat(*ptr_x), (*cos_ptr)) -
ixheaacd_mult32((*ptr_y), (*sin_ptr))));
*i_ptr++ = ((ixheaacd_mult32((*ptr_y), (*cos_ptr++)) -
ixheaacd_mult32((*ptr_x), (*sin_ptr++))));
ptr_x += 2;
ptr_y -= 2;
}
}
void ixheaacd_calc_post_twid_dec(WORD32 *xptr, WORD32 *r_ptr, WORD32 *i_ptr,
WORD32 nlength, const WORD32 *cos_ptr,
const WORD32 *sin_ptr
) {
WORD32 i;
WORD32 *yptr;
yptr = &xptr[2 * nlength - 1];
for (i = 0; i < nlength; i++) {
*xptr = (-(ixheaacd_mult32((r_ptr[i]), (*cos_ptr)) -
ixheaacd_mult32((i_ptr[i]), (*sin_ptr))));
*yptr = (-(ixheaacd_mult32((i_ptr[i]), (*cos_ptr++)) +
ixheaacd_mult32((r_ptr[i]), (*sin_ptr++))));
xptr += 2;
yptr -= 2;
}
}
static WORD32 ixheaacd_fft_based_imdct(WORD32 *data, WORD32 npoints,
WORD32 *preshift, WORD32 *tmp_data) {
WORD32 *data_r;
WORD32 *data_i;
WORD32 nlength = npoints >> 1;
WORD32 err = 0;
const WORD32 *cos_ptr;
const WORD32 *sin_ptr;
data_r = tmp_data;
data_i = tmp_data + 512;
if (nlength == 512) {
cos_ptr = ixheaacd_pre_post_twid_cos_512;
sin_ptr = ixheaacd_pre_post_twid_sin_512;
} else if (nlength == 384) {
cos_ptr = ixheaacd_pre_post_twid_cos_384;
sin_ptr = ixheaacd_pre_post_twid_sin_384;
} else if (nlength == 64) {
cos_ptr = ixheaacd_pre_post_twid_cos_64;
sin_ptr = ixheaacd_pre_post_twid_sin_64;
} else if (nlength == 48) {
cos_ptr = ixheaacd_pre_post_twid_cos_48;
sin_ptr = ixheaacd_pre_post_twid_sin_48;
} else {
cos_ptr = ixheaacd_pre_post_twid_cos_48;
sin_ptr = ixheaacd_pre_post_twid_sin_48;
}
(*ixheaacd_calc_pre_twid)(data, data_r, data_i, nlength, cos_ptr, sin_ptr);
err = ixheaacd_complex_fft(data_r, data_i, nlength, 1, preshift);
if (err) return err;
(*ixheaacd_calc_post_twid)(data, data_r, data_i, nlength, cos_ptr, sin_ptr);
return err;
}
#define N_LONG_LEN_MAX 1024
WORD32 ixheaacd_acelp_imdct(WORD32 *imdct_in, WORD32 npoints, WORD8 *qshift,
WORD32 *tmp_data) {
WORD32 preshift = 0;
WORD32 i;
WORD32 k = (npoints / 2);
WORD32 err = 0;
while (((k & 1) == 0) & (k != 1)) {
k = k >> 1;
preshift++;
}
if ((k != 1)) {
for (i = 0; i < (npoints / 2); i++) {
imdct_in[i] = (imdct_in[i] / 3) << 1;
}
preshift++;
}
err = ixheaacd_fft_based_imdct(imdct_in, npoints / 2, &preshift, tmp_data);
if (err) return err;
preshift += 2;
*qshift -= preshift;
return err;
}
IA_ERRORCODE ixheaacd_cal_fac_data(ia_usac_data_struct *usac_data, WORD32 i_ch,
WORD32 n_long, WORD32 lfac,
WORD32 *fac_idata, WORD8 *q_fac) {
WORD32 gain_fac, scale, k, *i_aq, itemp = 0, *izir;
WORD32 int_aq[ORDER + 1] = {0};
WORD32 intzir[2 * LEN_FRAME] = {0};
WORD32 x_in[FAC_LENGTH] = {0};
FLOAT32 gain, ztemp, ftemp, pow10, rem10;
FLOAT32 qfac1;
WORD8 qshift1 = 0;
WORD8 qshift2 = 0;
WORD8 qshift3 = 0;
WORD32 preshift = 0;
IA_ERRORCODE err = IA_NO_ERROR;
FLOAT32 *last_lpc = usac_data->lpc_prev[i_ch];
FLOAT32 *acelp_in = usac_data->acelp_in[i_ch];
WORD32 *fac_data = usac_data->fac_data[i_ch];
WORD32 *ptr_scratch = &usac_data->scratch_buffer[0];
WORD32 quo = fac_data[0] / 28;
WORD32 rem = fac_data[0] % 28;
pow10 = ixheaacd_pow10(quo);
rem10 = (FLOAT32)ixheaacd_power_10_table[rem];
gain = pow10 * rem10;
scale = (WORD32)(ixheaacd_norm32((WORD32)((ABS(gain) + 1))));
gain_fac = (WORD32)(gain * (FLOAT32)((WORD64)1 << scale));
scale += 4;
qfac1 = 1.0f / (gain);
if (acelp_in != NULL) {
izir = intzir;
ftemp = 0.0;
for (k = 0; k < n_long / 4; k++) {
ztemp = acelp_in[k] * (qfac1);
if (ABS(ztemp) > ftemp) ftemp = ABS(ztemp);
}
itemp = (WORD32)(ftemp);
qshift3 = ixheaacd_norm32(itemp);
for (k = 0; k < n_long / 4; k++) {
izir[k] =
(WORD32)((acelp_in[k] * (qfac1)) * (FLOAT32)((WORD64)1 << qshift3));
}
} else
izir = NULL;
if (last_lpc != NULL) {
ftemp = 0.0;
i_aq = int_aq;
for (k = 0; k < ORDER + 1; k++) {
if (ABS(last_lpc[k]) > ftemp) ftemp = ABS(last_lpc[k]);
}
itemp = (WORD32)(ftemp);
qshift2 = ixheaacd_norm32(itemp);
for (k = 0; k < ORDER + 1; k++) {
i_aq[k] = (WORD32)(last_lpc[k] * (FLOAT32)((WORD64)1 << qshift2));
}
} else
i_aq = NULL;
for (k = 0; k < lfac; k++) {
if (ixheaacd_abs32_sat(fac_data[k + 1]) > itemp)
itemp = ixheaacd_abs32_sat(fac_data[k + 1]);
}
qshift1 = ixheaacd_norm32(itemp);
for (k = 0; k < lfac; k++) {
fac_data[k + 1] =
(WORD32)(fac_data[k + 1] * (FLOAT32)((WORD64)1 << qshift1));
}
for (k = 0; k < lfac / 2; k++) {
x_in[k] = fac_data[2 * k + 1];
x_in[lfac / 2 + k] = fac_data[lfac - 2 * k];
}
err = ixheaacd_fr_alias_cnx_fix(x_in, n_long / 4, lfac, i_aq, izir,
fac_idata + 16, &qshift1, qshift2, qshift3,
&preshift, ptr_scratch);
if (err) return err;
preshift += 4;
*q_fac = (qshift1 - preshift);
if (acelp_in != NULL) {
for (k = 0; k < 2 * lfac; k++) {
fac_idata[k] =
ixheaacd_mul32_sh(fac_idata[k + 16], gain_fac, (WORD8)(scale));
}
}
return IA_NO_ERROR;
}
static IA_ERRORCODE ixheaacd_fd_imdct_short(ia_usac_data_struct *usac_data,
WORD32 i_ch, WORD32 *fac_data_out,
offset_lengths *ixheaacd_drc_offset,
WORD8 fac_q) {
FLOAT32 qfac;
WORD32 overlap_data_buf[2 * N_LONG_LEN_MAX] = {0};
WORD32 *window_short, k, *window_short_prev_ptr;
WORD32 *overlap_data, *fp;
WORD32 *p_overlap_ibuffer = usac_data->overlap_data_ptr[i_ch];
WORD32 *p_in_ibuffer = usac_data->coef_fix[i_ch];
FLOAT32 *p_out_buffer = usac_data->time_sample_vector[i_ch];
WORD32 *p_out_ibuffer = usac_data->output_data_ptr[i_ch];
WORD32 *scratch_mem = usac_data->scratch_buffer;
WORD32 td_frame_prev = usac_data->td_frame_prev[i_ch];
WORD32 fac_apply = usac_data->fac_data_present[i_ch];
WORD8 shiftp, input_q, output_q, shift_olap = 14;
WORD32 max_shift;
WORD32 window_select = usac_data->window_shape[i_ch];
WORD32 window_select_prev = usac_data->window_shape_prev[i_ch];
ia_usac_lpd_decoder_handle st = usac_data->str_tddec[i_ch];
WORD32 err_code = 0;
max_shift =
ixheaacd_calc_max_spectralline(p_in_ibuffer, ixheaacd_drc_offset->n_long);
ixheaacd_normalize(p_in_ibuffer, max_shift, ixheaacd_drc_offset->n_long);
shiftp = max_shift + 6;
input_q = shiftp;
memcpy(overlap_data_buf, p_overlap_ibuffer,
sizeof(WORD32) * ixheaacd_drc_offset->n_long);
overlap_data = overlap_data_buf;
fp = overlap_data + ixheaacd_drc_offset->n_flat_ls;
for (k = 0; k < 8; k++) {
shiftp = input_q;
err_code = ixheaacd_acelp_imdct(
p_in_ibuffer + (k * ixheaacd_drc_offset->n_short),
2 * ixheaacd_drc_offset->n_short, &shiftp, scratch_mem);
if (err_code) return err_code;
}
max_shift =
ixheaacd_calc_max_spectralline(p_in_ibuffer, ixheaacd_drc_offset->n_long);
ixheaacd_normalize(p_in_ibuffer, max_shift - 1, ixheaacd_drc_offset->n_long);
shiftp += max_shift - 1;
err_code = ixheaacd_calc_window(&window_short, ixheaacd_drc_offset->n_short,
window_select);
if (err_code == -1) return err_code;
err_code =
ixheaacd_calc_window(&window_short_prev_ptr,
ixheaacd_drc_offset->n_trans_ls, window_select_prev);
if (err_code == -1) return err_code;
if (fac_apply)
ixheaacd_windowing_short1(p_in_ibuffer + ixheaacd_drc_offset->n_short / 2,
window_short_prev_ptr, fp, ixheaacd_drc_offset,
shiftp, shift_olap);
else
ixheaacd_windowing_short2(p_in_ibuffer + ixheaacd_drc_offset->n_short / 2,
window_short_prev_ptr, fp, ixheaacd_drc_offset,
shiftp, shift_olap);
output_q = ixheaacd_windowing_short3(
p_in_ibuffer, window_short + ixheaacd_drc_offset->n_short - 1,
fp + ixheaacd_drc_offset->n_short, ixheaacd_drc_offset->n_short, shiftp,
shift_olap);
p_in_ibuffer += ixheaacd_drc_offset->n_short;
fp += ixheaacd_drc_offset->n_short;
window_short_prev_ptr = window_short;
for (k = 1; k < 7; k++) {
output_q = ixheaacd_windowing_short4(
p_in_ibuffer, window_short_prev_ptr, fp,
window_short_prev_ptr + ixheaacd_drc_offset->n_short - 1,
ixheaacd_drc_offset->n_short, 1, shiftp, shift_olap, output_q);
p_in_ibuffer += ixheaacd_drc_offset->n_short;
fp += ixheaacd_drc_offset->n_short;
window_short_prev_ptr = window_short;
}
output_q = ixheaacd_windowing_short4(
p_in_ibuffer, window_short_prev_ptr, fp,
window_short_prev_ptr + ixheaacd_drc_offset->n_short - 1,
ixheaacd_drc_offset->n_short, 0, shiftp, shift_olap, output_q);
p_in_ibuffer += ixheaacd_drc_offset->n_short;
fp += ixheaacd_drc_offset->n_short;
if (fac_apply) {
ixheaacd_combine_fac(overlap_data + ixheaacd_drc_offset->n_flat_ls +
ixheaacd_drc_offset->lfac,
fac_data_out,
overlap_data + ixheaacd_drc_offset->n_flat_ls +
ixheaacd_drc_offset->lfac,
2 * ixheaacd_drc_offset->lfac, output_q, fac_q);
}
memset(overlap_data + 2 * ixheaacd_drc_offset->n_long -
ixheaacd_drc_offset->n_flat_ls,
0, sizeof(WORD32) * ixheaacd_drc_offset->n_flat_ls);
ixheaacd_scale_down(overlap_data, overlap_data,
ixheaacd_drc_offset->n_flat_ls, shift_olap, output_q);
ixheaacd_scale_down(p_overlap_ibuffer,
overlap_data + ixheaacd_drc_offset->n_long,
ixheaacd_drc_offset->n_long, output_q, shift_olap);
ixheaacd_scale_down(p_out_ibuffer, overlap_data, ixheaacd_drc_offset->n_long,
output_q, 15);
if (td_frame_prev) {
qfac = 1.0f / (FLOAT32)(1 << 15);
for (k = 0; k < ixheaacd_drc_offset->n_long; k++) {
p_out_buffer[k] = ((FLOAT32)p_out_ibuffer[k]) * qfac;
}
err_code = ixheaacd_lpd_bpf_fix(usac_data, 1, p_out_buffer, st);
if (err_code != 0) return err_code;
for (k = 0; k < ixheaacd_drc_offset->n_long; k++) {
p_out_ibuffer[k] = (WORD32)(p_out_buffer[k] * (1 << 15));
}
}
return 0;
}
static IA_ERRORCODE ixheaacd_fd_imdct_long(ia_usac_data_struct *usac_data,
WORD32 i_ch, WORD32 *fac_idata,
offset_lengths *ixheaacd_drc_offset,
WORD8 fac_q) {
FLOAT32 qfac;
WORD32 *window_long_prev, k, i, *window_short_prev_ptr;
WORD32 *p_in_ibuffer = usac_data->coef_fix[i_ch];
WORD32 *p_overlap_ibuffer = usac_data->overlap_data_ptr[i_ch];
WORD32 *p_out_ibuffer = usac_data->output_data_ptr[i_ch];
FLOAT32 *p_out_buffer = usac_data->time_sample_vector[i_ch];
WORD32 *scratch_mem = usac_data->scratch_buffer;
WORD32 n_long = usac_data->ccfl;
WORD32 td_frame_prev = usac_data->td_frame_prev[i_ch];
WORD32 fac_apply = usac_data->fac_data_present[i_ch];
WORD8 shiftp, output_q = 0, shift_olap = 14;
WORD32 max_shift;
WORD32 window_sequence = usac_data->window_sequence[i_ch];
WORD32 window_select_prev = usac_data->window_shape_prev[i_ch];
ia_usac_lpd_decoder_handle st = usac_data->str_tddec[i_ch];
WORD32 err_code = 0;
max_shift =
ixheaacd_calc_max_spectralline(p_in_ibuffer, ixheaacd_drc_offset->n_long);
ixheaacd_normalize(p_in_ibuffer, max_shift, ixheaacd_drc_offset->n_long);
shiftp = max_shift + 6;
err_code = ixheaacd_acelp_imdct(p_in_ibuffer, 2 * ixheaacd_drc_offset->n_long,
&shiftp, scratch_mem);
if (err_code) return err_code;
max_shift =
ixheaacd_calc_max_spectralline(p_in_ibuffer, ixheaacd_drc_offset->n_long);
ixheaacd_normalize(p_in_ibuffer, max_shift - 1, ixheaacd_drc_offset->n_long);
shiftp += max_shift - 1;
switch (window_sequence) {
case ONLY_LONG_SEQUENCE:
case LONG_START_SEQUENCE:
err_code = ixheaacd_calc_window(
&window_long_prev, ixheaacd_drc_offset->n_long, window_select_prev);
if (err_code == -1) return err_code;
output_q = ixheaacd_windowing_long1(
p_in_ibuffer + n_long / 2, p_overlap_ibuffer, window_long_prev,
window_long_prev + ixheaacd_drc_offset->n_long - 1, p_out_ibuffer,
ixheaacd_drc_offset->n_long, shiftp, shift_olap);
break;
case STOP_START_SEQUENCE:
case LONG_STOP_SEQUENCE:
err_code = ixheaacd_calc_window(&window_short_prev_ptr,
ixheaacd_drc_offset->n_trans_ls,
window_select_prev);
if (err_code == -1) return err_code;
if (fac_apply) {
output_q = ixheaacd_windowing_long2(
p_in_ibuffer + n_long / 2, window_short_prev_ptr, fac_idata,
p_overlap_ibuffer, p_out_ibuffer, ixheaacd_drc_offset, shiftp,
shift_olap, fac_q);
} else {
output_q = ixheaacd_windowing_long3(
p_in_ibuffer + n_long / 2, window_short_prev_ptr, p_overlap_ibuffer,
p_out_ibuffer,
window_short_prev_ptr + ixheaacd_drc_offset->n_trans_ls - 1,
ixheaacd_drc_offset, shiftp, shift_olap);
}
break;
}
for (i = 0; i < ixheaacd_drc_offset->n_long / 2; i++) {
p_overlap_ibuffer[ixheaacd_drc_offset->n_long / 2 + i] =
ixheaacd_negate32_sat(p_in_ibuffer[i]) >> (shiftp - shift_olap);
p_overlap_ibuffer[ixheaacd_drc_offset->n_long / 2 - i - 1] =
ixheaacd_negate32_sat(p_in_ibuffer[i]) >> (shiftp - shift_olap);
}
ixheaacd_scale_down_adj(p_out_ibuffer, p_out_ibuffer,
ixheaacd_drc_offset->n_long, output_q, 15);
if (td_frame_prev) {
qfac = 1.0f / (FLOAT32)(1 << 15);
for (k = 0; k < ixheaacd_drc_offset->n_long; k++) {
p_out_buffer[k] = ((FLOAT32)p_out_ibuffer[k]) * qfac;
}
err_code = ixheaacd_lpd_bpf_fix(usac_data, 0, p_out_buffer, st);
if (err_code != 0) return err_code;
for (k = 0; k < ixheaacd_drc_offset->n_long; k++) {
p_out_ibuffer[k] = (WORD32)(p_out_buffer[k] * (1 << 15));
}
}
return 0;
}
WORD32 ixheaacd_fd_frm_dec(ia_usac_data_struct *usac_data, WORD32 i_ch) {
WORD32 fac_idata[2 * FAC_LENGTH + 16];
offset_lengths ixheaacd_drc_offset;
WORD8 fac_q = 0;
WORD32 td_frame_prev = usac_data->td_frame_prev[i_ch];
WORD32 fac_apply = usac_data->fac_data_present[i_ch];
WORD32 window_sequence = usac_data->window_sequence[i_ch];
IA_ERRORCODE err = IA_NO_ERROR;
ixheaacd_drc_offset.n_long = usac_data->ccfl;
ixheaacd_drc_offset.n_short = ixheaacd_drc_offset.n_long >> 3;
memset(fac_idata, 0, sizeof(fac_idata));
if (td_frame_prev) {
if (window_sequence == EIGHT_SHORT_SEQUENCE) {
ixheaacd_drc_offset.lfac = ixheaacd_drc_offset.n_long >> 4;
} else {
ixheaacd_drc_offset.lfac = ixheaacd_drc_offset.n_long >> 3;
}
ixheaacd_drc_offset.n_flat_ls =
(ixheaacd_drc_offset.n_long - (ixheaacd_drc_offset.lfac) * 2) >> 1;
ixheaacd_drc_offset.n_trans_ls = (ixheaacd_drc_offset.lfac) << 1;
} else {
ixheaacd_drc_offset.lfac = FAC_LENGTH;
ixheaacd_drc_offset.n_flat_ls =
(ixheaacd_drc_offset.n_long - ixheaacd_drc_offset.n_short) >> 1;
ixheaacd_drc_offset.n_trans_ls = ixheaacd_drc_offset.n_short;
}
if (fac_apply) {
err = ixheaacd_cal_fac_data(usac_data, i_ch, ixheaacd_drc_offset.n_long,
ixheaacd_drc_offset.lfac, fac_idata, &fac_q);
if (err) return err;
}
if (window_sequence != EIGHT_SHORT_SEQUENCE) {
err = ixheaacd_fd_imdct_long(usac_data, i_ch, fac_idata,
&ixheaacd_drc_offset, fac_q);
if (err) return err;
} else {
err = ixheaacd_fd_imdct_short(usac_data, i_ch, fac_idata,
&ixheaacd_drc_offset, fac_q);
if (err) return err;
}
return err;
}
Reference in New Issue View Git Blame Copy Permalink