392 lines
12 KiB
C
392 lines
12 KiB
C
/******************************************************************************
|
|
* *
|
|
* 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 <stdlib.h>
|
|
#include "ixheaacd_type_def.h"
|
|
#include "ixheaacd_constants.h"
|
|
#include "ixheaacd_bitbuffer.h"
|
|
#include "ixheaacd_interface.h"
|
|
#include "ixheaacd_common_rom.h"
|
|
#include "ixheaacd_sbrdecsettings.h"
|
|
#include "ixheaacd_sbr_scale.h"
|
|
#include "ixheaacd_env_extr_part.h"
|
|
#include "ixheaacd_sbr_rom.h"
|
|
#include "ixheaacd_hybrid.h"
|
|
#include "ixheaacd_ps_dec.h"
|
|
#include "ixheaacd_config.h"
|
|
#include "ixheaacd_qmf_dec.h"
|
|
#include "ixheaacd_mps_polyphase.h"
|
|
#include "ixheaacd_mps_struct_def.h"
|
|
#include "ixheaacd_mps_res_rom.h"
|
|
#include "ixheaacd_mps_aac_struct.h"
|
|
#include "ixheaacd_mps_dec.h"
|
|
#include "ixheaacd_function_selector.h"
|
|
|
|
extern const FLOAT32
|
|
ixheaacd_mps_polyphase_filter_coeff[10 * MAX_NUM_QMF_BANDS_SAC / 2];
|
|
extern const FLOAT32 ixheaacd_mps_post_twid[30];
|
|
extern const FLOAT32 ixheaacd_mps_pre_twid[64];
|
|
|
|
extern const FLOAT32 ixheaacd_ldmps_polyphase_filter_coeff[1280];
|
|
|
|
extern const FLOAT32 ixheaacd_ldmps_pre_twid[32];
|
|
extern const FLOAT32 ixheaacd_mps_post_re_32[64];
|
|
extern const FLOAT32 ixheaacd_mps_post_im_32[64];
|
|
|
|
|
|
VOID ixheaacd_mps_synt_init(FLOAT32 state[POLY_PHASE_SYNTH_SIZE]) {
|
|
memset(state, 0, sizeof(FLOAT32) * POLY_PHASE_SYNTH_SIZE);
|
|
}
|
|
|
|
VOID ixheaacd_mps_synt_post_fft_twiddle_dec(WORD32 resolution, FLOAT32 *fin_re,
|
|
FLOAT32 *fin_im,
|
|
const FLOAT32 *table_re,
|
|
const FLOAT32 *table_im,
|
|
FLOAT32 *state) {
|
|
WORD32 l;
|
|
for (l = 0; l < 2 * resolution; l++) {
|
|
state[2 * resolution - l - 1] =
|
|
((fin_re[l] * table_re[l]) + (fin_im[l] * table_im[l]));
|
|
}
|
|
}
|
|
|
|
VOID ixheaacd_mps_synt_out_calc_dec(WORD32 resolution, FLOAT32 *out,
|
|
FLOAT32 *state,
|
|
const FLOAT32 *filter_coeff) {
|
|
WORD32 l, k;
|
|
FLOAT32 *out1, *out2, *state1, *state2;
|
|
out1 = out;
|
|
out2 = out + resolution;
|
|
state1 = state;
|
|
state2 = state + (3 * resolution);
|
|
|
|
for (k = 0; k < 5; k++) {
|
|
for (l = 0; l < resolution; l++) {
|
|
*out1++ = (*state1++) * (*filter_coeff++);
|
|
*out2++ = (*state2++) * (*filter_coeff++);
|
|
}
|
|
out1 += resolution;
|
|
out2 += resolution;
|
|
state1 += (3 * resolution);
|
|
state2 += (3 * resolution);
|
|
}
|
|
}
|
|
|
|
VOID ixheaacd_mps_synt_out_calc_dec_ldmps(WORD32 resolution, FLOAT32 *out,
|
|
FLOAT32 *state, const FLOAT32 *filter_coeff) {
|
|
WORD32 l, k;
|
|
FLOAT32 *out1, *out2, *state1, *state2;
|
|
const FLOAT32 *filter1, *filter2;
|
|
filter1 = filter_coeff;
|
|
filter2 = filter_coeff + resolution;
|
|
out1 = out;
|
|
out2 = out + resolution;
|
|
state1 = state;
|
|
state2 = state + (3 * resolution);
|
|
|
|
for (k = 0; k < 5; k++) {
|
|
for (l = 0; l < resolution; l++) {
|
|
*out1++ = (*state1++) * (*filter1++);
|
|
*out2++ = (*state2++) * (*filter2++);
|
|
}
|
|
filter1 += resolution;
|
|
filter2 += resolution;
|
|
out1 += resolution;
|
|
out2 += resolution;
|
|
state1 += (3 * resolution);
|
|
state2 += (3 * resolution);
|
|
}
|
|
}
|
|
|
|
VOID ixheaacd_mps_synt_out_calc_dec_ldmps_32(WORD32 resolution, FLOAT32 *out,
|
|
FLOAT32 *state, const FLOAT32 *filter_coeff) {
|
|
WORD32 l, k;
|
|
FLOAT32 *out1, *out2, *state1, *state2;
|
|
const FLOAT32 *filter1, *filter2;
|
|
filter1 = filter_coeff;
|
|
filter2 = filter_coeff + 2 * resolution;
|
|
out1 = out;
|
|
out2 = out + resolution;
|
|
state1 = state;
|
|
state2 = state + (3 * resolution);
|
|
|
|
for (k = 0; k < 5; k++) {
|
|
for (l = 0; l < resolution; l++) {
|
|
*out1++ = ((*state1++) * (filter1[2*l] + filter1[2*l+1])/2);
|
|
*out2++ = ((*state2++) * (filter2[2 * l] + filter2[2 * l + 1])/2);
|
|
}
|
|
filter1 += 4 * resolution;
|
|
filter2 += 4 * resolution;
|
|
out1 += resolution;
|
|
out2 += resolution;
|
|
state1 += (3 * resolution);
|
|
state2 += (3 * resolution);
|
|
}
|
|
}
|
|
|
|
VOID ixheaacd_mps_synth_pre_twidle(FLOAT32 *out_re, FLOAT32 *out_im,
|
|
FLOAT32 *c_in, WORD32 len) {
|
|
WORD32 i;
|
|
FLOAT32 *c_s = c_in;
|
|
FLOAT32 *p_re_s = out_re;
|
|
FLOAT32 *p_im_s = out_im;
|
|
FLOAT32 *c_e = c_in + (len << 1) - 1;
|
|
FLOAT32 *p_im_e = out_im + len - 1;
|
|
FLOAT32 *p_re_e = out_re + len - 1;
|
|
const FLOAT32 *prtw = ixheaacd_mps_pre_twid;
|
|
|
|
for (i = 0; i < len; i += 4) {
|
|
*p_re_s = ((*c_s++) * (*prtw));
|
|
p_re_s++;
|
|
*p_im_s = -((*c_s--) * (*prtw));
|
|
p_im_s++;
|
|
*p_im_s = ((*c_e--) * (*prtw));
|
|
p_im_s--;
|
|
*p_re_s = ((*c_e++) * (*prtw++));
|
|
p_re_s--;
|
|
*p_im_s += ((*c_e--) * (*prtw));
|
|
p_im_s++;
|
|
*p_re_s += ((*c_e--) * (*prtw));
|
|
p_re_s++;
|
|
*p_re_s -= ((*c_s++) * (*prtw));
|
|
p_re_s++;
|
|
*p_im_s += ((*c_s++) * (*prtw++));
|
|
p_im_s++;
|
|
*p_im_e = ((*c_e--) * (*prtw));
|
|
p_im_e--;
|
|
*p_re_e = -((*c_e++) * (*prtw));
|
|
p_re_e--;
|
|
*p_re_e = ((*c_s++) * (*prtw));
|
|
p_re_e++;
|
|
*p_im_e = ((*c_s--) * (*prtw++));
|
|
p_im_e++;
|
|
*p_re_e += ((*c_s++) * (*prtw));
|
|
p_re_e--;
|
|
*p_im_e += ((*c_s++) * (*prtw));
|
|
p_im_e--;
|
|
*p_im_e -= ((*c_e--) * (*prtw));
|
|
p_im_e--;
|
|
*p_re_e += ((*c_e--) * (*prtw++));
|
|
p_re_e--;
|
|
}
|
|
}
|
|
|
|
VOID ixheaacd_mps_synth_post_twidle(FLOAT32 *state, FLOAT32 *out_re,
|
|
FLOAT32 *out_im, WORD32 len) {
|
|
WORD32 i;
|
|
{
|
|
FLOAT32 x_0, x_1, x_2, x_3;
|
|
FLOAT32 *p_re_e, *p_im_e;
|
|
const FLOAT32 *potw = ixheaacd_mps_post_twid;
|
|
FLOAT32 *p_re_s = out_re;
|
|
FLOAT32 *p_im_s = out_im;
|
|
|
|
p_re_e = p_re_s + (len - 2);
|
|
p_im_e = p_im_s + (len - 2);
|
|
x_0 = *p_re_e;
|
|
x_1 = *(p_re_e + 1);
|
|
x_2 = *p_im_e;
|
|
x_3 = *(p_im_e + 1);
|
|
|
|
*(p_re_e + 1) = -*(p_re_s + 1);
|
|
*(p_im_e + 1) = -*p_im_s;
|
|
*p_im_s = *(p_im_s + 1);
|
|
|
|
for (i = 5; i < len; i += 4) {
|
|
FLOAT32 twdr = *potw++;
|
|
FLOAT32 twdi = *potw++;
|
|
FLOAT32 tmp;
|
|
|
|
*p_re_e = (x_0 * twdi);
|
|
*p_re_e += (x_1 * twdr);
|
|
p_re_e--;
|
|
p_re_s++;
|
|
*p_re_s = (x_0 * twdr);
|
|
*p_re_s -= (x_1 * twdi);
|
|
p_re_s++;
|
|
x_1 = *p_re_e--;
|
|
x_0 = *p_re_e++;
|
|
*p_re_e = (*p_re_s++ * twdi);
|
|
*p_re_e += -(*p_re_s * twdr);
|
|
p_re_e--;
|
|
tmp = (*p_re_s-- * twdi);
|
|
*p_re_s = tmp + (*p_re_s * twdr);
|
|
|
|
*p_im_e = -(x_2 * twdr);
|
|
*p_im_e += (x_3 * twdi);
|
|
p_im_e--;
|
|
p_im_s++;
|
|
*p_im_s = -(x_2 * twdi);
|
|
*p_im_s -= (x_3 * twdr);
|
|
p_im_s++;
|
|
x_3 = *p_im_e--;
|
|
x_2 = *p_im_e++;
|
|
*p_im_e = -(*p_im_s++ * twdr);
|
|
*p_im_e -= (*p_im_s * twdi);
|
|
p_im_e--;
|
|
tmp = (*p_im_s-- * twdr);
|
|
*p_im_s = tmp - (*p_im_s * twdi);
|
|
}
|
|
|
|
*p_re_e = 0.7071067f * (x_1 + x_0);
|
|
*p_im_e = 0.7071067f * (x_3 - x_2);
|
|
*(p_re_s + 1) = -0.7071067f * (x_1 - x_0);
|
|
*(p_im_s + 1) = -0.7071067f * (x_3 + x_2);
|
|
}
|
|
|
|
for (i = 0; i < len; i++) {
|
|
state[i] = out_im[i] - out_re[i];
|
|
state[len + i] = out_im[len - i - 1] + out_re[len - i - 1];
|
|
state[len - i - 1] = out_im[len - i - 1] - out_re[len - i - 1];
|
|
state[2 * len - i - 1] = out_im[i] + out_re[i];
|
|
}
|
|
}
|
|
|
|
VOID ixheaacd_mps_synt_pre_twiddle_dec(FLOAT32 *ptr_in, const FLOAT32 *table,
|
|
FLOAT32 *fin_re, FLOAT32 *fin_im,
|
|
WORD32 resolution) {
|
|
WORD32 k;
|
|
FLOAT32 *c_s = ptr_in;
|
|
FLOAT32 *p_re_s = fin_re;
|
|
FLOAT32 *p_im_s = fin_im;
|
|
FLOAT32 *c_e = ptr_in + (resolution << 1) - 1;
|
|
FLOAT32 *p_im_e = fin_im + resolution - 1;
|
|
FLOAT32 *p_re_e = fin_re + resolution - 1;
|
|
|
|
for (k = 0; k < resolution; k += 2) {
|
|
*p_re_s = (*c_s++) * (*table);
|
|
*p_im_s = (*c_s) * (*table);
|
|
|
|
*p_re_e = (*c_e--) * (*table);
|
|
*p_im_e = -(*c_e) * (*table++);
|
|
|
|
*p_re_s += (*c_s--) * (*table);
|
|
*p_im_s += -(*c_s++) * (*table);
|
|
p_re_s++;
|
|
p_im_s++;
|
|
c_s++;
|
|
|
|
*p_re_e += (*c_e++) * (*table);
|
|
*p_im_e += (*c_e--) * (*table++);
|
|
p_re_e--;
|
|
p_im_e--;
|
|
c_e--;
|
|
}
|
|
}
|
|
|
|
VOID ixheaacd_mps_synt_calc(ia_mps_dec_state_struct *self) {
|
|
WORD32 k, l, ts, ch;
|
|
FLOAT32 *state, *tmp_state, *out;
|
|
const FLOAT32 *filt_coeff;
|
|
FLOAT32 *tmp_buf = self->tmp_buf;
|
|
FLOAT32 fin_re[64] = {0};
|
|
FLOAT32 fin_im[64] = {0};
|
|
|
|
WORD32 resolution = self->resolution;
|
|
WORD32 m_resolution = resolution >> 1;
|
|
const FLOAT32 *ixheaacd_mps_post_re, *ixheaacd_mps_post_im;
|
|
VOID(*ixheaacd_mps_synt_out_calc_pointer)
|
|
(WORD32 resolution, FLOAT32 *out, FLOAT32 *state, const FLOAT32 *filter_coeff);
|
|
|
|
if (self->ldmps_config.ldmps_present_flag)
|
|
{
|
|
ixheaacd_mps_synt_out_calc_pointer = &ixheaacd_mps_synt_out_calc_dec_ldmps;
|
|
filt_coeff = ixheaacd_ldmps_polyphase_filter_coeff;
|
|
}
|
|
else
|
|
{
|
|
ixheaacd_mps_synt_out_calc_pointer = ixheaacd_mps_synt_out_calc;
|
|
filt_coeff = ixheaacd_mps_polyphase_filter_coeff;
|
|
}
|
|
if (self->qmf_band_count == 32)
|
|
{
|
|
for (ch = 0; ch < self->out_ch_count; ch++) {
|
|
tmp_state = self->qmf_filt_state[ch];
|
|
state = &tmp_buf[self->time_slots * 2 * resolution];
|
|
memcpy(state, tmp_state, sizeof(FLOAT32) * 18 * resolution);
|
|
out = &tmp_buf[74 * MAX_NUM_QMF_BANDS_SAC];
|
|
|
|
ixheaacd_mps_post_re = ixheaacd_mps_post_re_32;
|
|
ixheaacd_mps_post_im = ixheaacd_mps_post_im_32;
|
|
|
|
for (ts = 0; ts < self->time_slots; ts++) {
|
|
|
|
state -= (2 * resolution);
|
|
|
|
ixheaacd_mps_synt_pre_twiddle_dec(&self->qmf_out_dir[ch][ts][0].re,
|
|
ixheaacd_ldmps_pre_twid, fin_re, fin_im, resolution);
|
|
|
|
for (k = resolution; k < 2 * resolution; k++)
|
|
{
|
|
fin_re[k] = 0;
|
|
fin_im[k] = 0;
|
|
}
|
|
|
|
ixheaacd_mps_complex_fft(fin_re, fin_im, 2 * resolution);
|
|
|
|
ixheaacd_mps_synt_post_fft_twiddle_dec(resolution, fin_re, fin_im,
|
|
ixheaacd_mps_post_re,
|
|
ixheaacd_mps_post_im, state);
|
|
|
|
ixheaacd_mps_synt_out_calc_dec_ldmps_32(resolution, out, state, filt_coeff);
|
|
|
|
for (k = 0; k < resolution; k++) {
|
|
FLOAT32 acc = out[k];
|
|
for (l = 1; l < 10; l++) {
|
|
acc += out[resolution * l + k];
|
|
}
|
|
self->output_buffer[ch][self->qmf_band_count * ts + k] = acc;
|
|
}
|
|
}
|
|
memcpy(tmp_state, state, sizeof(FLOAT32) * 18 * resolution);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (ch = 0; ch < self->out_ch_count; ch++) {
|
|
tmp_state = self->qmf_filt_state[ch];
|
|
state = &tmp_buf[self->time_slots * 2 * resolution];
|
|
memcpy(state, tmp_state, sizeof(FLOAT32) * 18 * resolution);
|
|
out = &tmp_buf[74 * MAX_NUM_QMF_BANDS_SAC];
|
|
|
|
for (ts = 0; ts < self->time_slots; ts++) {
|
|
|
|
state -= (2 * resolution);
|
|
|
|
ixheaacd_mps_synth_pre_twidle(
|
|
fin_re, fin_im, &self->qmf_out_dir[ch][ts][0].re, resolution);
|
|
|
|
ixheaacd_mps_synth_calc_fft(fin_re, fin_im, m_resolution);
|
|
|
|
ixheaacd_mps_synth_post_twidle(state, fin_re, fin_im, resolution);
|
|
(*ixheaacd_mps_synt_out_calc_pointer)(resolution, out, state, filt_coeff);
|
|
|
|
for (k = 0; k < resolution; k++) {
|
|
FLOAT32 acc = out[k];
|
|
for (l = 1; l < 10; l++) {
|
|
acc += out[resolution * l + k];
|
|
}
|
|
self->output_buffer[ch][self->qmf_band_count * ts + k] = acc;
|
|
}
|
|
}
|
|
memcpy(tmp_state, state, sizeof(FLOAT32) * 18 * resolution);
|
|
}
|
|
}
|
|
}
|