| /****************************************************************************** |
| * * |
| * 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 "ixheaac_type_def.h" |
| #include "ixheaac_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); |
| } |
| } |
| } |
