/****************************************************************************** * * * Copyright (C) 2023 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 #include "ixheaac_type_def.h" #include "ixheaac_constants.h" #include "ixheaace_psy_const.h" #include "ixheaace_tns.h" #include "ixheaace_tns_params.h" #include "ixheaace_rom.h" #include "ixheaace_common_rom.h" #include "ixheaace_bitbuffer.h" #include "ixheaace_aac_constants.h" #include "ixheaace_fft.h" #include "ixheaac_basic_ops32.h" #include "ixheaac_basic_ops40.h" #include "ixheaac_basic_ops.h" #include "iusace_basic_ops_flt.h" static VOID ia_enhaacplus_enc_shift_mdct_delay_buffer(FLOAT32 *ptr_mdct_delay_buffer, const FLOAT32 *ptr_time_signal, WORD32 ch_increment, WORD32 long_frame_len) { WORD32 i; FLOAT32 *ptr_mdct_buff = ptr_mdct_delay_buffer; if (ch_increment == 2) { const FLOAT32 *ptr_input = ptr_time_signal; FLOAT32 temp1, temp2, temp3, temp4; temp1 = *ptr_input++; ptr_input++; temp2 = *ptr_input++; ptr_input++; temp3 = *ptr_input++; ptr_input++; for (i = ((long_frame_len >> 2) - 2); i >= 0; i--) { *ptr_mdct_buff++ = temp1; temp4 = *ptr_input++; ptr_input++; *ptr_mdct_buff++ = temp2; *ptr_mdct_buff++ = temp3; *ptr_mdct_buff++ = temp4; temp1 = *ptr_input++; ptr_input++; temp2 = *ptr_input++; ptr_input++; temp3 = *ptr_input++; ptr_input++; } *ptr_mdct_buff++ = temp1; temp4 = *ptr_input; *ptr_mdct_buff++ = temp2; *ptr_mdct_buff++ = temp3; *ptr_mdct_buff++ = temp4; } else { for (i = 0; i < long_frame_len; i += 2) { *ptr_mdct_buff++ = ptr_time_signal[i * ch_increment]; *ptr_mdct_buff++ = ptr_time_signal[(i + 1) * ch_increment]; } } } static VOID ia_eaacp_enc_inverse_transform_512(FLOAT32 *ptr_data, FLOAT32 *ptr_win_buf, const FLOAT32 *ptr_cos_sin_tbl, WORD8 *ptr_scratch) { WORD32 n = FRAME_LEN_512; WORD32 n_by_2 = n >> 1; ixheaace_scratch_mem *pstr_scratch = (ixheaace_scratch_mem *)ptr_scratch; ia_eaacp_enc_pre_twiddle_aac(ptr_win_buf, ptr_data, n, ptr_cos_sin_tbl); ia_enhaacplus_enc_complex_fft(ptr_win_buf, n_by_2, pstr_scratch); ia_enhaacplus_enc_post_twiddle(ptr_data, ptr_win_buf, ptr_cos_sin_tbl, n); } static VOID ixheaace_pre_mdct(FLOAT32 *ptr_x, WORD32 m, const FLOAT32 *ptr_sine_window) { WORD32 i; FLOAT32 wre, wim, re1, re2, im1, im2; for (i = 0; i < m / 4; i++) { re1 = ptr_x[2 * i]; im2 = ptr_x[2 * i + 1]; re2 = ptr_x[m - 2 - 2 * i]; im1 = ptr_x[m - 1 - 2 * i]; wim = ptr_sine_window[i * 2]; wre = ptr_sine_window[m - 1 - 2 * i]; ptr_x[2 * i] = im1 * wim + re1 * wre; ptr_x[2 * i + 1] = im1 * wre - re1 * wim; wim = ptr_sine_window[m - 2 - 2 * i]; wre = ptr_sine_window[2 * i + 1]; ptr_x[m - 2 - 2 * i] = im2 * wim + re2 * wre; ptr_x[m - 1 - 2 * i] = im2 * wre - re2 * wim; } } static VOID ia_enhaacplus_enc_tranform_mac4(FLOAT32 *ptr_op, const FLOAT32 *ptr_win, FLOAT32 *ptr_buf1, FLOAT32 *ptr_buf2, FLOAT32 *ptr_buf3, FLOAT32 *ptr_buf4, UWORD32 len, WORD32 increment) { WORD32 i; if (increment > 0) { for (i = len >> 2; i > 0; i--) { *ptr_op = ((ptr_win[0] * (*ptr_buf1++)) + (ptr_win[1] * (*ptr_buf2++))); *ptr_op = (*ptr_op + (ptr_win[2] * (*ptr_buf3--))); *ptr_op = (*ptr_op + (ptr_win[3] * (*ptr_buf4--))); ptr_op++; *ptr_op = ((ptr_win[4] * (*ptr_buf1++)) + (ptr_win[5] * (*ptr_buf2++))); *ptr_op = (*ptr_op + (ptr_win[6] * (*ptr_buf3--))); *ptr_op = (*ptr_op + (ptr_win[7] * (*ptr_buf4--))); ptr_op++; *ptr_op = ((ptr_win[8] * (*ptr_buf1++)) + (ptr_win[9] * (*ptr_buf2++))); *ptr_op = (*ptr_op + (ptr_win[10] * (*ptr_buf3--))); *ptr_op = (*ptr_op + (ptr_win[11] * (*ptr_buf4--))); ptr_op++; *ptr_op = ((ptr_win[12] * (*ptr_buf1++)) + (ptr_win[13] * (*ptr_buf2++))); *ptr_op = (*ptr_op + (ptr_win[14] * (*ptr_buf3--))); *ptr_op = (*ptr_op + (ptr_win[15] * (*ptr_buf4--))); ptr_op++; ptr_win += 16; } } else { for (i = len >> 2; i > 0; i--) { *ptr_op = ((ptr_win[0] * (*ptr_buf1++)) + (ptr_win[1] * (*ptr_buf2++))); *ptr_op = (*ptr_op + (ptr_win[2] * (*ptr_buf3--))); *ptr_op = (*ptr_op + (ptr_win[3] * (*ptr_buf4--))); ptr_op--; *ptr_op = ((ptr_win[4] * (*ptr_buf1++)) + (ptr_win[5] * (*ptr_buf2++))); *ptr_op = (*ptr_op + (ptr_win[6] * (*ptr_buf3--))); *ptr_op = (*ptr_op + (ptr_win[7] * (*ptr_buf4--))); ptr_op--; *ptr_op = ((ptr_win[8] * (*ptr_buf1++)) + (ptr_win[9] * (*ptr_buf2++))); *ptr_op = (*ptr_op + (ptr_win[10] * (*ptr_buf3--))); *ptr_op = (*ptr_op + (ptr_win[11] * (*ptr_buf4--))); ptr_op--; *ptr_op = ((ptr_win[12] * (*ptr_buf1++)) + (ptr_win[13] * (*ptr_buf2++))); *ptr_op = (*ptr_op + (ptr_win[14] * (*ptr_buf3--))); *ptr_op = (*ptr_op + (ptr_win[15] * (*ptr_buf4--))); ptr_op--; ptr_win += 16; } } } static VOID ia_enhaacplus_enc_tranform_mac3(FLOAT32 *ptr_op, const FLOAT32 *ptr_win, FLOAT32 *ptr_buf1, FLOAT32 *ptr_buf2, FLOAT32 *ptr_buf3, UWORD32 len, WORD32 increment) { WORD32 i; if (increment > 0) { for (i = len >> 2; i > 0; i--) { *ptr_op = ((ptr_win[0] * (*ptr_buf1++)) + (ptr_win[1] * (*ptr_buf2--))); *ptr_op = (*ptr_op + (ptr_win[2] * (*ptr_buf3--))); ptr_op++; *ptr_op = ((ptr_win[3] * (*ptr_buf1++)) + (ptr_win[4] * (*ptr_buf2--))); *ptr_op = (*ptr_op + (ptr_win[5] * (*ptr_buf3--))); ptr_op++; *ptr_op = ((ptr_win[6] * (*ptr_buf1++)) + (ptr_win[7] * (*ptr_buf2--))); *ptr_op = (*ptr_op + (ptr_win[8] * (*ptr_buf3--))); ptr_op++; *ptr_op = ((ptr_win[9] * (*ptr_buf1++)) + (ptr_win[10] * (*ptr_buf2--))); *ptr_op = (*ptr_op + (ptr_win[11] * (*ptr_buf3--))); ptr_op++; ptr_win += 12; } } else { for (i = len >> 2; i > 0; i--) { *ptr_op = ((ptr_win[0] * (*ptr_buf1++)) + (ptr_win[1] * (*ptr_buf2--))); *ptr_op = (*ptr_op + (ptr_win[2] * (*ptr_buf3--))); ptr_op--; *ptr_op = ((ptr_win[3] * (*ptr_buf1++)) + (ptr_win[4] * (*ptr_buf2--))); *ptr_op = (*ptr_op + (ptr_win[5] * (*ptr_buf3--))); ptr_op--; *ptr_op = ((ptr_win[6] * (*ptr_buf1++)) + (ptr_win[7] * (*ptr_buf2--))); *ptr_op = (*ptr_op + (ptr_win[8] * (*ptr_buf3--))); ptr_op--; *ptr_op = ((ptr_win[9] * (*ptr_buf1++)) + (ptr_win[10] * (*ptr_buf2--))); *ptr_op = (*ptr_op + (ptr_win[11] * (*ptr_buf3--))); ptr_op--; ptr_win += 12; } } } VOID ia_enhaacplus_enc_transform_real(FLOAT32 *ptr_mdct_delay_buffer, const FLOAT32 *ptr_time_signal, WORD32 ch_increment, FLOAT32 *ptr_real_out, ixheaace_mdct_tables *pstr_mdct_tab, FLOAT32 *ptr_shared_buffer1, WORD8 *ptr_shared_buffer5, WORD32 long_frame_len) { WORD32 n, n1; FLOAT32 *ptr_windowed_buf = ptr_shared_buffer1; const FLOAT32 *ptr_ws1; WORD32 i, len = long_frame_len; FLOAT32 *ptr_real_in; FLOAT32 *ptr_data1, *ptr_data2, *ptr_data3, *ptr_data4; FLOAT32 *ptr_op1; ptr_real_in = ptr_mdct_delay_buffer; n = long_frame_len << 1; n1 = long_frame_len >> 1; ptr_ws1 = (long_frame_len == FRAME_LEN_512) ? pstr_mdct_tab->win_512_ld : pstr_mdct_tab->win_480_ld; ptr_op1 = ptr_real_out; ptr_data1 = &ptr_real_in[n1]; ptr_data2 = &ptr_real_in[n + n1]; ptr_data3 = &ptr_real_in[n1 - 1]; ptr_data4 = &ptr_real_in[n + n1 - 1]; ia_enhaacplus_enc_tranform_mac4(ptr_op1, ptr_ws1, ptr_data1, ptr_data2, ptr_data3, ptr_data4, n1, 1); ptr_ws1 += ((SIZE_T)n1 << 2); for (i = 0; i < long_frame_len << 1; i++) { ptr_mdct_delay_buffer[i] = ptr_mdct_delay_buffer[long_frame_len + i]; } ia_enhaacplus_enc_shift_mdct_delay_buffer(&ptr_mdct_delay_buffer[2 * long_frame_len], ptr_time_signal, ch_increment, long_frame_len); ptr_op1 = &ptr_real_out[long_frame_len - 1]; ptr_data1 = &ptr_real_in[n + len - n1]; ptr_data2 = &ptr_real_in[len - n1]; ptr_data3 = &ptr_real_in[len - n1 - 1]; ptr_data4 = &ptr_real_in[n + len - n1 - 1]; ia_enhaacplus_enc_tranform_mac4(ptr_op1, ptr_ws1, ptr_data1, ptr_data2, ptr_data3, ptr_data4, (n1 >> 1), -1); ptr_op1 -= (n1 >> 1); ptr_ws1 += ((SIZE_T)n1 << 1); ptr_data2 += (n1 >> 1); ptr_data3 -= (n1 >> 1); ptr_data4 -= (n1 >> 1); ia_enhaacplus_enc_tranform_mac3(ptr_op1, ptr_ws1, ptr_data2, ptr_data3, ptr_data4, (n1 >> 1), -1); if (long_frame_len == FRAME_LEN_480) { ia_aac_ld_enc_mdct_480(ptr_real_out, ptr_windowed_buf, 1, pstr_mdct_tab); } else { ia_eaacp_enc_inverse_transform_512(ptr_real_out, ptr_windowed_buf, pstr_mdct_tab->cosine_array_1024, ptr_shared_buffer5); } } static VOID ia_eaacp_enc_pre_twiddle_compute(FLOAT32 *ptr_in1, FLOAT32 *ptr_in2, FLOAT32 *ptr_x, const FLOAT32 *ptr_cos_sin, WORD n_by_4) { WORD32 i; FLOAT32 temp_r, temp_i; FLOAT32 temp_r1, temp_i1; FLOAT32 *ptr_x1 = ptr_x + (SIZE_T)((n_by_4 << 2) - 1); FLOAT32 c, c1, s, s1; for (i = 0; i < n_by_4; i++) { c = *ptr_cos_sin++; s = *ptr_cos_sin++; s1 = *ptr_cos_sin++; c1 = *ptr_cos_sin++; temp_r = *ptr_in1++; temp_i1 = *ptr_in1++; temp_i = *ptr_in2--; temp_r1 = *ptr_in2--; *ptr_x = ((temp_r * c) + (temp_i * s)); ptr_x++; *ptr_x = ((temp_i * c) - (temp_r * s)); ptr_x++; *ptr_x1 = ((temp_i1 * c1) - (temp_r1 * s1)); ptr_x1--; *ptr_x1 = ((temp_r1 * c1) + (temp_i1 * s1)); ptr_x1--; } } VOID ia_enhaacplus_enc_post_twiddle(FLOAT32 *ptr_out, FLOAT32 *ptr_x, const FLOAT32 *ptr_cos_sin_tbl, WORD m) { WORD i; FLOAT32 c, c1, s, s1; FLOAT32 tmp_var; FLOAT32 tempr, tempr1, tempi, tempi1; FLOAT32 *ptr_out1 = ptr_out + m - 1; FLOAT32 *ptr_x1 = ptr_x + m - 1; for (i = 0; i < (m >> 2); i++) { c = *ptr_cos_sin_tbl++; s = *ptr_cos_sin_tbl++; s1 = *ptr_cos_sin_tbl++; c1 = *ptr_cos_sin_tbl++; tempr = *ptr_x++; tempi = *ptr_x++; tempi1 = *ptr_x1--; tempr1 = *ptr_x1--; tmp_var = ((tempr * c) + (tempi * s)); *ptr_out++ = tmp_var; tmp_var = ((tempr * s) - (tempi * c)); *ptr_out1-- = tmp_var; tmp_var = ((tempr1 * c1) + (tempi1 * s1)); *ptr_out1-- = tmp_var; tmp_var = ((tempr1 * s1) - (tempi1 * c1)); *ptr_out++ = tmp_var; } } VOID ia_eaacp_enc_pre_twiddle_aac(FLOAT32 *ptr_x, FLOAT32 *ptr_data, WORD32 n, const FLOAT32 *ptr_cos_array) { WORD n_by_4; FLOAT32 *ptr_in1, *ptr_in2; n_by_4 = n >> 2; ptr_in1 = ptr_data; ptr_in2 = ptr_data + n - 1; ia_eaacp_enc_pre_twiddle_compute(ptr_in1, ptr_in2, ptr_x, ptr_cos_array, n_by_4); } static PLATFORM_INLINE WORD8 ia_enhaacplus_enc_calc_norm(WORD32 a) { WORD8 norm_val; if (a == 0) { norm_val = 31; } else { if (a == (WORD32)0xffffffffL) { norm_val = 31; } else { if (a < 0) { a = ~a; } for (norm_val = 0; a < (WORD32)0x40000000L; norm_val++) { a <<= 1; } } } return norm_val; } static PLATFORM_INLINE VOID ia_enhaacplus_enc_complex_3point_fft(FLOAT32 *ptr_in, FLOAT32 *ptr_out) { FLOAT32 add_r, sub_r; FLOAT32 add_i, sub_i; FLOAT32 x_01_r, x_01_i, temp; FLOAT32 p1, p2, p3, p4; FLOAT64 sin_mu = 0.866025403784439f; x_01_r = ptr_in[0] + ptr_in[2]; x_01_i = ptr_in[1] + ptr_in[3]; add_r = ptr_in[2] + ptr_in[4]; add_i = ptr_in[3] + ptr_in[5]; sub_r = ptr_in[2] - ptr_in[4]; sub_i = ptr_in[3] - ptr_in[5]; p1 = add_r / (FLOAT32)2.0f; p4 = add_i / (FLOAT32)2.0f; p2 = (FLOAT32)((FLOAT64)sub_i * sin_mu); p3 = (FLOAT32)((FLOAT64)sub_r * sin_mu); temp = ptr_in[0] - p1; ptr_out[0] = x_01_r + ptr_in[4]; ptr_out[1] = x_01_i + ptr_in[5]; ptr_out[2] = temp + p2; ptr_out[3] = (ptr_in[1] - p3) - p4; ptr_out[4] = temp - p2; ptr_out[5] = (ptr_in[1] + p3) - p4; } VOID ia_enhaacplus_enc_complex_fft_p2(FLOAT32 *ptr_x, WORD32 nlength, FLOAT32 *ptr_scratch_fft_p2_y) { WORD32 i, j, k, n_stages, h2; FLOAT32 x0_r, x0_i, x1_r, x1_i, x2_r, x2_i, x3_r, x3_i; WORD32 del, nodespacing, in_loop_cnt; WORD32 not_power_4; WORD32 dig_rev_shift; FLOAT32 *ptr_p2_y = ptr_scratch_fft_p2_y; WORD32 mpass = nlength; WORD32 npoints = nlength; FLOAT32 *ptr_y = ptr_p2_y; const FLOAT64 *ptr_w; FLOAT32 *ptr_inp; FLOAT32 tmk; const FLOAT64 *ptr_twiddles; FLOAT32 *ptr_data; FLOAT64 w_1, w_2, w_3, w_4, w_5, w_6; WORD32 sec_loop_cnt; FLOAT32 tmp; memset(ptr_y, 0, nlength * 2 * sizeof(*ptr_y)); dig_rev_shift = ia_enhaacplus_enc_calc_norm(mpass) + 1 - 16; n_stages = 30 - ia_enhaacplus_enc_calc_norm(mpass); not_power_4 = n_stages & 1; n_stages = n_stages >> 1; ptr_w = ia_enhaacplus_enc_twiddle_table_fft_32x32; dig_rev_shift = MAX(dig_rev_shift, 0); for (i = 0; i < npoints; i += 4) { ptr_inp = ptr_x; DIG_REV_NEW(i, dig_rev_shift, h2); if (not_power_4) { h2 += 1; h2 &= ~1; } ptr_inp += (h2); x0_r = *ptr_inp; x0_i = *(ptr_inp + 1); ptr_inp += (npoints >> 1); x1_r = *ptr_inp; x1_i = *(ptr_inp + 1); ptr_inp += (npoints >> 1); x2_r = *ptr_inp; x2_i = *(ptr_inp + 1); ptr_inp += (npoints >> 1); x3_r = *ptr_inp; x3_i = *(ptr_inp + 1); x0_r = x0_r + x2_r; x0_i = x0_i + x2_i; tmk = x0_r - x2_r; x2_r = tmk - x2_r; tmk = x0_i - x2_i; x2_i = tmk - x2_i; x1_r = x1_r + x3_r; x1_i = x1_i + x3_i; tmk = x1_r - x3_r; x3_r = tmk - x3_r; tmk = x1_i - x3_i; x3_i = tmk - x3_i; x0_r = x0_r + x1_r; x0_i = x0_i + x1_i; tmk = x0_r - x1_r; x1_r = tmk - x1_r; tmk = x0_i - x1_i; x1_i = tmk - x1_i; x2_r = x2_r + x3_i; x2_i = x2_i - x3_r; tmk = x2_r - x3_i; x3_i = tmk - x3_i; tmk = x2_i + x3_r; x3_r = tmk + x3_r; *ptr_y++ = x0_r; *ptr_y++ = x0_i; *ptr_y++ = x2_r; *ptr_y++ = x2_i; *ptr_y++ = x1_r; *ptr_y++ = x1_i; *ptr_y++ = x3_i; *ptr_y++ = x3_r; } ptr_y -= 2 * npoints; del = 4; nodespacing = 64; in_loop_cnt = npoints >> 4; for (i = n_stages - 1; i > 0; i--) { ptr_twiddles = ptr_w; ptr_data = ptr_y; for (k = in_loop_cnt; k != 0; k--) { x0_r = (*ptr_data); x0_i = (*(ptr_data + 1)); ptr_data += ((SIZE_T)del << 1); x1_r = (*ptr_data); x1_i = (*(ptr_data + 1)); ptr_data += ((SIZE_T)del << 1); x2_r = (*ptr_data); x2_i = (*(ptr_data + 1)); ptr_data += ((SIZE_T)del << 1); x3_r = (*ptr_data); x3_i = (*(ptr_data + 1)); ptr_data -= 3 * (del << 1); x0_r = x0_r + x2_r; x0_i = x0_i + x2_i; x2_r = x0_r - (x2_r * 2); x2_i = x0_i - (x2_i * 2); x1_r = x1_r + x3_r; x1_i = x1_i + x3_i; x3_r = x1_r - (x3_r * 2); x3_i = x1_i - (x3_i * 2); x0_r = x0_r + x1_r; x0_i = x0_i + x1_i; x1_r = x0_r - (x1_r * 2); x1_i = x0_i - (x1_i * 2); x2_r = x2_r + x3_i; x2_i = x2_i - x3_r; x3_i = x2_r - (x3_i * 2); x3_r = x2_i + (x3_r * 2); *ptr_data = x0_r; *(ptr_data + 1) = x0_i; ptr_data += ((SIZE_T)del << 1); *ptr_data = x2_r; *(ptr_data + 1) = x2_i; ptr_data += ((SIZE_T)del << 1); *ptr_data = x1_r; *(ptr_data + 1) = x1_i; ptr_data += ((SIZE_T)del << 1); *ptr_data = x3_i; *(ptr_data + 1) = x3_r; ptr_data += ((SIZE_T)del << 1); } ptr_data = ptr_y + 2; sec_loop_cnt = (nodespacing * del); sec_loop_cnt = (sec_loop_cnt / 4) + (sec_loop_cnt / 8) - (sec_loop_cnt / 16) + (sec_loop_cnt / 32) - (sec_loop_cnt / 64) + (sec_loop_cnt / 128) - (sec_loop_cnt / 256); for (j = nodespacing; j <= sec_loop_cnt; j += nodespacing) { w_1 = *(ptr_twiddles + j); w_4 = *(ptr_twiddles + j + 257); w_2 = *(ptr_twiddles + ((SIZE_T)j << 1)); w_5 = *(ptr_twiddles + ((SIZE_T)j << 1) + 257); w_3 = *(ptr_twiddles + j + ((SIZE_T)j << 1)); w_6 = *(ptr_twiddles + j + ((SIZE_T)j << 1) + 257); for (k = in_loop_cnt; k != 0; k--) { ptr_data += ((SIZE_T)del << 1); x1_r = *ptr_data; x1_i = *(ptr_data + 1); ptr_data += ((SIZE_T)del << 1); x2_r = *ptr_data; x2_i = *(ptr_data + 1); ptr_data += ((SIZE_T)del << 1); x3_r = *ptr_data; x3_i = *(ptr_data + 1); ptr_data -= 3 * (del << 1); tmp = (FLOAT32)(ixheaace_dmult((FLOAT64)x1_r, w_1) - ixheaace_dmult((FLOAT64)x1_i, w_4)); x1_i = (FLOAT32)ixheaace_dmac(ixheaace_dmult((FLOAT64)x1_r, w_4), (FLOAT64)x1_i, w_1); x1_r = tmp; tmp = (FLOAT32)(ixheaace_dmult((FLOAT64)x2_r, w_2) - ixheaace_dmult((FLOAT64)x2_i, w_5)); x2_i = (FLOAT32)ixheaace_dmac(ixheaace_dmult((FLOAT64)x2_r, w_5), (FLOAT64)x2_i, w_2); x2_r = tmp; tmp = (FLOAT32)(ixheaace_dmult((FLOAT64)x3_r, w_3) - ixheaace_dmult((FLOAT64)x3_i, w_6)); x3_i = (FLOAT32)ixheaace_dmac(ixheaace_dmult((FLOAT64)x3_r, w_6), (FLOAT64)x3_i, w_3); x3_r = tmp; x0_r = (*ptr_data); x0_i = (*(ptr_data + 1)); x0_r = x0_r + (x2_r); x0_i = x0_i + (x2_i); x2_r = x0_r - (x2_r * 2); x2_i = x0_i - (x2_i * 2); x1_r = x1_r + x3_r; x1_i = x1_i + x3_i; x3_r = x1_r - (x3_r * 2); x3_i = x1_i - (x3_i * 2); x0_r = x0_r + (x1_r); x0_i = x0_i + (x1_i); x1_r = x0_r - (x1_r * 2); x1_i = x0_i - (x1_i * 2); x2_r = x2_r + (x3_i); x2_i = x2_i - (x3_r); x3_i = x2_r - (x3_i * 2); x3_r = x2_i + (x3_r * 2); *ptr_data = x0_r; *(ptr_data + 1) = x0_i; ptr_data += ((SIZE_T)del << 1); *ptr_data = x2_r; *(ptr_data + 1) = x2_i; ptr_data += ((SIZE_T)del << 1); *ptr_data = x1_r; *(ptr_data + 1) = x1_i; ptr_data += ((SIZE_T)del << 1); *ptr_data = x3_i; *(ptr_data + 1) = x3_r; ptr_data += ((SIZE_T)del << 1); } ptr_data -= 2 * npoints; ptr_data += 2; } for (; j <= (nodespacing * del) >> 1; j += nodespacing) { w_1 = *(ptr_twiddles + j); w_4 = *(ptr_twiddles + j + 257); w_2 = *(ptr_twiddles + ((SIZE_T)j << 1)); w_5 = *(ptr_twiddles + ((SIZE_T)j << 1) + 257); w_3 = *(ptr_twiddles + j + ((SIZE_T)j << 1) - 256); w_6 = *(ptr_twiddles + j + ((SIZE_T)j << 1) + 1); for (k = in_loop_cnt; k != 0; k--) { ptr_data += ((SIZE_T)del << 1); x1_r = *ptr_data; x1_i = *(ptr_data + 1); ptr_data += ((SIZE_T)del << 1); x2_r = *ptr_data; x2_i = *(ptr_data + 1); ptr_data += ((SIZE_T)del << 1); x3_r = *ptr_data; x3_i = *(ptr_data + 1); ptr_data -= 3 * (del << 1); tmp = (FLOAT32)(ixheaace_dmult((FLOAT64)x1_r, w_1) - ixheaace_dmult((FLOAT64)x1_i, w_4)); x1_i = (FLOAT32)ixheaace_dmac(ixheaace_dmult((FLOAT64)x1_r, w_4), (FLOAT64)x1_i, w_1); x1_r = tmp; tmp = (FLOAT32)(ixheaace_dmult((FLOAT64)x2_r, w_2) - ixheaace_dmult((FLOAT64)x2_i, w_5)); x2_i = (FLOAT32)ixheaace_dmac(ixheaace_dmult((FLOAT64)x2_r, w_5), (FLOAT64)x2_i, w_2); x2_r = tmp; tmp = (FLOAT32)(ixheaace_dmult((FLOAT64)x3_r, w_6) + ixheaace_dmult((FLOAT64)x3_i, w_3)); x3_i = (FLOAT32)(-ixheaace_dmult((FLOAT64)x3_r, w_3) + ixheaace_dmult((FLOAT64)x3_i, w_6)); x3_r = tmp; x0_r = (*ptr_data); x0_i = (*(ptr_data + 1)); x0_r = x0_r + (x2_r); x0_i = x0_i + (x2_i); x2_r = x0_r - (x2_r * 2); x2_i = x0_i - (x2_i * 2); x1_r = x1_r + x3_r; x1_i = x1_i + x3_i; x3_r = x1_r - (x3_r * 2); x3_i = x1_i - (x3_i * 2); x0_r = x0_r + (x1_r); x0_i = x0_i + (x1_i); x1_r = x0_r - (x1_r * 2); x1_i = x0_i - (x1_i * 2); x2_r = x2_r + (x3_i); x2_i = x2_i - (x3_r); x3_i = x2_r - (x3_i * 2); x3_r = x2_i + (x3_r * 2); *ptr_data = x0_r; *(ptr_data + 1) = x0_i; ptr_data += ((SIZE_T)del << 1); *ptr_data = x2_r; *(ptr_data + 1) = x2_i; ptr_data += ((SIZE_T)del << 1); *ptr_data = x1_r; *(ptr_data + 1) = x1_i; ptr_data += ((SIZE_T)del << 1); *ptr_data = x3_i; *(ptr_data + 1) = x3_r; ptr_data += ((SIZE_T)del << 1); } ptr_data -= 2 * npoints; ptr_data += 2; } for (; j <= sec_loop_cnt * 2; j += nodespacing) { w_1 = *(ptr_twiddles + j); w_4 = *(ptr_twiddles + j + 257); w_2 = *(ptr_twiddles + (SIZE_T)((j << 1) - 256)); w_5 = *(ptr_twiddles + (SIZE_T)((j << 1) + 1)); w_3 = *(ptr_twiddles + (SIZE_T)(j + (j << 1) - 256)); w_6 = *(ptr_twiddles + (SIZE_T)(j + (j << 1) + 1)); for (k = in_loop_cnt; k != 0; k--) { ptr_data += ((SIZE_T)del << 1); x1_r = *ptr_data; x1_i = *(ptr_data + 1); ptr_data += ((SIZE_T)del << 1); x2_r = *ptr_data; x2_i = *(ptr_data + 1); ptr_data += ((SIZE_T)del << 1); x3_r = *ptr_data; x3_i = *(ptr_data + 1); ptr_data -= 3 * (del << 1); tmp = (FLOAT32)(ixheaace_dmult((FLOAT64)x1_r, w_1) - ixheaace_dmult((FLOAT64)x1_i, w_4)); x1_i = (FLOAT32)ixheaace_dmac(ixheaace_dmult(x1_r, w_4), x1_i, w_1); x1_r = tmp; tmp = (FLOAT32)(ixheaace_dmult((FLOAT64)x2_r, w_5) + ixheaace_dmult((FLOAT64)x2_i, w_2)); x2_i = (FLOAT32)(-ixheaace_dmult(x2_r, w_2) + ixheaace_dmult(x2_i, w_5)); x2_r = tmp; tmp = (FLOAT32)(ixheaace_dmult((FLOAT64)x3_r, w_6) + ixheaace_dmult((FLOAT64)x3_i, w_3)); x3_i = (FLOAT32)(-ixheaace_dmult((FLOAT64)x3_r, w_3) + ixheaace_dmult((FLOAT64)x3_i, w_6)); x3_r = tmp; x0_r = (*ptr_data); x0_i = (*(ptr_data + 1)); x0_r = x0_r + (x2_r); x0_i = x0_i + (x2_i); x2_r = x0_r - (x2_r * 2); x2_i = x0_i - (x2_i * 2); x1_r = x1_r + x3_r; x1_i = x1_i + x3_i; x3_r = x1_r - (x3_r * 2); x3_i = x1_i - (x3_i * 2); x0_r = x0_r + (x1_r); x0_i = x0_i + (x1_i); x1_r = x0_r - (x1_r * 2); x1_i = x0_i - (x1_i * 2); x2_r = x2_r + (x3_i); x2_i = x2_i - (x3_r); x3_i = x2_r - (x3_i * 2); x3_r = x2_i + (x3_r * 2); *ptr_data = x0_r; *(ptr_data + 1) = x0_i; ptr_data += ((SIZE_T)del << 1); *ptr_data = x2_r; *(ptr_data + 1) = x2_i; ptr_data += ((SIZE_T)del << 1); *ptr_data = x1_r; *(ptr_data + 1) = x1_i; ptr_data += ((SIZE_T)del << 1); *ptr_data = x3_i; *(ptr_data + 1) = x3_r; ptr_data += ((SIZE_T)del << 1); } ptr_data -= 2 * npoints; ptr_data += 2; } for (; j < nodespacing * del; j += nodespacing) { w_1 = *(ptr_twiddles + j); w_4 = *(ptr_twiddles + j + 257); w_2 = *(ptr_twiddles + (SIZE_T)((j << 1) - 256)); w_5 = *(ptr_twiddles + (SIZE_T)((j << 1) + 1)); w_3 = *(ptr_twiddles + (SIZE_T)(j + (j << 1) - 512)); w_6 = *(ptr_twiddles + (SIZE_T)(j + (j << 1) - 512 + 257)); for (k = in_loop_cnt; k != 0; k--) { ptr_data += ((SIZE_T)del << 1); x1_r = *ptr_data; x1_i = *(ptr_data + 1); ptr_data += ((SIZE_T)del << 1); x2_r = *ptr_data; x2_i = *(ptr_data + 1); ptr_data += ((SIZE_T)del << 1); x3_r = *ptr_data; x3_i = *(ptr_data + 1); ptr_data -= 3 * (del << 1); tmp = (FLOAT32)(ixheaace_dmult((FLOAT64)x1_r, w_1) - ixheaace_dmult((FLOAT64)x1_i, w_4)); x1_i = (FLOAT32)ixheaace_dmac(ixheaace_dmult((FLOAT64)x1_r, w_4), (FLOAT64)x1_i, w_1); x1_r = tmp; tmp = (FLOAT32)(ixheaace_dmult((FLOAT64)x2_r, w_5) + ixheaace_dmult((FLOAT64)x2_i, w_2)); x2_i = (FLOAT32)(-ixheaace_dmult((FLOAT64)x2_r, w_2) + ixheaace_dmult((FLOAT64)x2_i, w_5)); x2_r = tmp; tmp = (FLOAT32)(-ixheaace_dmult((FLOAT64)x3_r, w_3) + ixheaace_dmult((FLOAT64)x3_i, w_6)); x3_i = (FLOAT32)ixheaace_dmac(ixheaace_dmult((FLOAT64)x3_r, w_6), (FLOAT64)x3_i, w_3); x3_r = tmp; x0_r = (*ptr_data); x0_i = (*(ptr_data + 1)); x0_r = x0_r + (x2_r); x0_i = x0_i + (x2_i); x2_r = x0_r - (x2_r * 2); x2_i = x0_i - (x2_i * 2); x1_r = x1_r + x3_r; x1_i = x1_i - x3_i; x3_r = x1_r - (x3_r * 2); x3_i = x1_i + (x3_i * 2); x0_r = x0_r + (x1_r); x0_i = x0_i + (x1_i); x1_r = x0_r - (x1_r * 2); x1_i = x0_i - (x1_i * 2); x2_r = x2_r + (x3_i); x2_i = x2_i - (x3_r); x3_i = x2_r - (x3_i * 2); x3_r = x2_i + (x3_r * 2); *ptr_data = x0_r; *(ptr_data + 1) = x0_i; ptr_data += ((SIZE_T)del << 1); *ptr_data = x2_r; *(ptr_data + 1) = x2_i; ptr_data += ((SIZE_T)del << 1); *ptr_data = x1_r; *(ptr_data + 1) = x1_i; ptr_data += ((SIZE_T)del << 1); *ptr_data = x3_i; *(ptr_data + 1) = x3_r; ptr_data += ((SIZE_T)del << 1); } ptr_data -= 2 * npoints; ptr_data += 2; } nodespacing >>= 2; del <<= 2; in_loop_cnt >>= 2; } if (not_power_4) { ptr_twiddles = ptr_w; nodespacing <<= 1; for (j = del / 2; j != 0; j--) { w_1 = *ptr_twiddles; w_4 = *(ptr_twiddles + 257); ptr_twiddles += nodespacing; x0_r = *ptr_y; x0_i = *(ptr_y + 1); ptr_y += ((SIZE_T)del << 1); x1_r = *ptr_y; x1_i = *(ptr_y + 1); tmp = (FLOAT32)(ixheaace_dmult((FLOAT64)x1_r, w_1) - ixheaace_dmult((FLOAT64)x1_i, w_4)); x1_i = (FLOAT32)ixheaace_dmac(ixheaace_dmult((FLOAT64)x1_r, w_4), (FLOAT64)x1_i, w_1); x1_r = tmp; *ptr_y = (x0_r) - (x1_r); *(ptr_y + 1) = (x0_i) - (x1_i); ptr_y -= ((SIZE_T)del << 1); *ptr_y = (x0_r) + (x1_r); *(ptr_y + 1) = (x0_i) + (x1_i); ptr_y += 2; } ptr_twiddles = ptr_w; for (j = del / 2; j != 0; j--) { w_1 = *ptr_twiddles; w_4 = *(ptr_twiddles + 257); ptr_twiddles += nodespacing; x0_r = *ptr_y; x0_i = *(ptr_y + 1); ptr_y += ((SIZE_T)del << 1); x1_r = *ptr_y; x1_i = *(ptr_y + 1); tmp = (FLOAT32)(ixheaace_dmult((FLOAT64)x1_r, w_4) + ixheaace_dmult((FLOAT64)x1_i, w_1)) /*/2*/; x1_i = (FLOAT32)(-ixheaace_dmult((FLOAT64)x1_r, w_1) + ixheaace_dmult((FLOAT64)x1_i, w_4)) /*/2*/; x1_r = tmp; *ptr_y = (x0_r) - (x1_r); *(ptr_y + 1) = (x0_i) - (x1_i); ptr_y -= ((SIZE_T)del << 1); *ptr_y = (x0_r) + (x1_r); *(ptr_y + 1) = (x0_i) + (x1_i); ptr_y += 2; } } for (i = 0; i < nlength; i++) { *(ptr_x + 2 * i) = ptr_p2_y[2 * i]; *(ptr_x + 2 * i + 1) = ptr_p2_y[2 * i + 1]; } } static VOID ia_enhaacplus_enc_complex_fft_p3(FLOAT32 *ptr_data, WORD32 nlength, ixheaace_scratch_mem *pstr_scratch) { WORD32 i, j; FLOAT32 *ptr_data_3 = pstr_scratch->p_fft_p3_data_3; FLOAT32 *ptr_p3_y = pstr_scratch->p_fft_p3_y; WORD32 cnfac; WORD32 mpass = nlength; FLOAT32 *ptr_x = ptr_data; FLOAT32 *ptr_y = ptr_p3_y; cnfac = 0; const FLOAT64 *ptr_w1_r, *ptr_w1_i; FLOAT32 tmp; ptr_w1_r = ia_enhaacplus_enc_twiddle_table_3pr; ptr_w1_i = ia_enhaacplus_enc_twiddle_table_3pi; while (mpass % 3 == 0) { mpass /= 3; cnfac++; } for (i = 0; i < 3 * cnfac; i++) { for (j = 0; j < mpass; j++) { ptr_data_3[2 * j] = ptr_data[3 * (2 * j) + (2 * i)]; ptr_data_3[2 * j + 1] = ptr_data[3 * (2 * j) + 1 + (2 * i)]; } ia_enhaacplus_enc_complex_fft_p2(ptr_data_3, mpass, pstr_scratch->p_fft_p2_y); for (j = 0; j < mpass; j++) { ptr_data[3 * (2 * j) + (2 * i)] = ptr_data_3[2 * j]; ptr_data[3 * (2 * j) + 1 + (2 * i)] = ptr_data_3[2 * j + 1]; } } { for (i = 0; i < nlength; i += 3) { tmp = (FLOAT32)((FLOAT64)ptr_data[2 * i] * (*ptr_w1_r) - (FLOAT64)ptr_data[2 * i + 1] * (*ptr_w1_i)); ptr_data[2 * i + 1] = (FLOAT32)((FLOAT64)ptr_data[2 * i] * (*ptr_w1_i) + (FLOAT64)ptr_data[2 * i + 1] * (*ptr_w1_r)); ptr_data[2 * i] = tmp; ptr_w1_r++; ptr_w1_i++; tmp = (FLOAT32)((FLOAT64)ptr_data[2 * (i + 1)] * (*ptr_w1_r) - (FLOAT64)ptr_data[2 * (i + 1) + 1] * (*ptr_w1_i)); ptr_data[2 * (i + 1) + 1] = (FLOAT32)((FLOAT64)ptr_data[2 * (i + 1)] * (*ptr_w1_i) + (FLOAT64)ptr_data[2 * (i + 1) + 1] * (*ptr_w1_r)); ptr_data[2 * (i + 1)] = tmp; ptr_w1_r++; ptr_w1_i++; tmp = (FLOAT32)((FLOAT64)ptr_data[2 * (i + 2)] * (*ptr_w1_r) - (FLOAT64)ptr_data[2 * (i + 2) + 1] * (*ptr_w1_i)); ptr_data[2 * (i + 2) + 1] = (FLOAT32)((FLOAT64)ptr_data[2 * (i + 2)] * (*ptr_w1_i) + (FLOAT64)ptr_data[2 * (i + 2) + 1] * (*ptr_w1_r)); ptr_data[2 * (i + 2)] = tmp; ptr_w1_r += 3 * (128 / mpass - 1) + 1; ptr_w1_i += 3 * (128 / mpass - 1) + 1; } } for (i = 0; i < mpass; i++) { ia_enhaacplus_enc_complex_3point_fft(ptr_x, ptr_y); ptr_x = ptr_x + 6; ptr_y = ptr_y + 6; } for (i = 0; i < mpass; i++) { ptr_data[2 * i] = ptr_p3_y[6 * i]; ptr_data[2 * i + 1] = ptr_p3_y[6 * i + 1]; } for (i = 0; i < mpass; i++) { ptr_data[2 * (i + mpass)] = ptr_p3_y[6 * i + 2]; ptr_data[2 * (i + mpass) + 1] = ptr_p3_y[6 * i + 3]; } for (i = 0; i < mpass; i++) { ptr_data[2 * (i + 2 * mpass)] = ptr_p3_y[6 * i + 4]; ptr_data[2 * (i + 2 * mpass) + 1] = ptr_p3_y[6 * i + 5]; } } VOID ia_enhaacplus_enc_complex_fft(FLOAT32 *ptr_data, WORD32 len, ixheaace_scratch_mem *pstr_scratch) { if (len & (len - 1)) { ia_enhaacplus_enc_complex_fft_p3(ptr_data, len, pstr_scratch); } else { ia_enhaacplus_enc_complex_fft_p2(ptr_data, len, pstr_scratch->p_fft_p2_y); } } static VOID ixheaace_post_mdct(FLOAT32 *ptr_x, WORD32 m, const FLOAT32 *ptr_trig_data, WORD32 step, WORD32 trig_data_size) { WORD32 i; FLOAT32 w_re, w_im, re1, re2, im1, im2; const FLOAT32 *ptr_sin = ptr_trig_data; const FLOAT32 *ptr_cos = ptr_trig_data + trig_data_size; w_im = *ptr_sin; w_re = *ptr_cos; for (i = 0; i < m / 4; i++) { re1 = ptr_x[2 * i]; im1 = ptr_x[2 * i + 1]; re2 = ptr_x[m - 2 - 2 * i]; im2 = ptr_x[m - 1 - 2 * i]; ptr_x[2 * i] = (re1 * w_re + im1 * w_im); ptr_x[m - 1 - 2 * i] = (re1 * w_im - im1 * w_re); ptr_sin += step; ptr_cos -= step; w_im = *ptr_sin; w_re = *ptr_cos; ptr_x[m - 2 - 2 * i] = (re2 * w_im + im2 * w_re); ptr_x[2 * i + 1] = (re2 * w_re - im2 * w_im); } } static VOID ixheaace_cplx_mult_twid(FLOAT32 *ptr_re, FLOAT32 *ptr_im, FLOAT32 a, FLOAT32 b, FLOAT32 twid_table, FLOAT32 twid_table_h) { *ptr_re = (a * twid_table) - (b * twid_table_h); *ptr_im = (a * twid_table_h) + (b * twid_table); } static VOID ixheaace_cfft_15_twiddle(FLOAT32 *ptr_inp) { const FLOAT32 *ptr_tw_flt = &ixheaace_mix_rad_twid_tbl[0]; const FLOAT32 *ptr_tw_flt_h = &ixheaace_mix_rad_twid_tbl_h[0]; FLOAT32 accu1, accu2; WORD32 i, j; ptr_inp += 12; for (j = 0; j < 2; j++) { for (i = 0; i < 4; i++) { ixheaace_cplx_mult_twid(&accu1, &accu2, ptr_inp[2 * i + 0], ptr_inp[2 * i + 1], ptr_tw_flt[i], ptr_tw_flt_h[i]); ptr_inp[2 * i + 0] = accu1; ptr_inp[2 * i + 1] = accu2; } ptr_inp += 10; ptr_tw_flt += 4; ptr_tw_flt_h += 4; } } static VOID ixheaace_cfft_15_480(FLOAT32 *ptr_inp, FLOAT32 *ptr_op, FLOAT32 *ptr_fft3_out) { WORD32 i, idx; FLOAT32 *ptr_buf1, *ptr_buf2, *ptr_buf3; FLOAT32 add_r, sub_r; FLOAT32 add_i, sub_i; FLOAT32 x_01_r, x_01_i, temp; FLOAT32 p1, p2, p3, p4; FLOAT32 sin_mu_flt = 0.866027832f; FLOAT32 c51_flt = 0.951049805f; FLOAT32 c52_flt = -0.76940918f; FLOAT32 c53_flt = -0.36328125f; FLOAT32 c54_flt = 0.559020996f; FLOAT32 c55_flt = -0.625f; FLOAT32 r1, r2, r3, r4; FLOAT32 s1, s2, s3, s4, t, temp1, temp2; FLOAT32 *ptr_out_fft3 = ptr_fft3_out; FLOAT32 xr_0, xr_1, xr_2; FLOAT32 xi_0, xi_1, xi_2; ptr_buf2 = ptr_fft3_out; ptr_buf1 = ptr_buf3 = ptr_fft3_out; for (i = 0; i < FFT3; i++) { *ptr_buf1++ = ptr_inp[0 + 64 * i]; *ptr_buf1++ = ptr_inp[1 + 64 * i]; *ptr_buf1++ = ptr_inp[192 + 64 * i]; *ptr_buf1++ = ptr_inp[193 + 64 * i]; *ptr_buf1++ = ptr_inp[384 + 64 * i]; *ptr_buf1++ = ptr_inp[385 + 64 * i]; *ptr_buf1++ = ptr_inp[576 + 64 * i]; *ptr_buf1++ = ptr_inp[577 + 64 * i]; *ptr_buf1++ = ptr_inp[768 + 64 * i]; *ptr_buf1++ = ptr_inp[769 + 64 * i]; r1 = ptr_buf3[2] + ptr_buf3[8]; r4 = ptr_buf3[2] - ptr_buf3[8]; r3 = ptr_buf3[4] + ptr_buf3[6]; r2 = ptr_buf3[4] - ptr_buf3[6]; t = ((r1 - r3) * c54_flt); r1 = r1 + r3; temp1 = ptr_buf3[0] + r1; r1 = temp1 + ((r1 * c55_flt) * 2); r3 = r1 - t; r1 = r1 + t; t = ((r4 + r2) * c51_flt); r4 = t + ((r4 * c52_flt) * 2); r2 = t + (r2 * c53_flt); s1 = ptr_buf3[3] + ptr_buf3[9]; s4 = ptr_buf3[3] - ptr_buf3[9]; s3 = ptr_buf3[5] + ptr_buf3[7]; s2 = ptr_buf3[5] - ptr_buf3[7]; t = ((s1 - s3) * c54_flt); s1 = s1 + s3; temp2 = ptr_buf3[1] + s1; s1 = temp2 + (((s1 * c55_flt)) * 2); s3 = s1 - t; s1 = s1 + t; t = ((s4 + s2) * c51_flt); s4 = t + (((s4 * c52_flt)) * 2); s2 = t + ((s2 * c53_flt)); *ptr_buf2++ = temp1; *ptr_buf2++ = temp2; *ptr_buf2++ = r1 + s2; *ptr_buf2++ = s1 - r2; *ptr_buf2++ = r3 - s4; *ptr_buf2++ = s3 + r4; *ptr_buf2++ = r3 + s4; *ptr_buf2++ = s3 - r4; *ptr_buf2++ = r1 - s2; *ptr_buf2++ = s1 + r2; ptr_buf3 = ptr_buf1; } idx = 0; ixheaace_cfft_15_twiddle(ptr_out_fft3); for (i = 0; i < FFT5; i++) { xr_0 = ptr_out_fft3[0]; xi_0 = ptr_out_fft3[1]; xr_1 = ptr_out_fft3[10]; xi_1 = ptr_out_fft3[11]; xr_2 = ptr_out_fft3[20]; xi_2 = ptr_out_fft3[21]; x_01_r = (xr_0 + xr_1); x_01_i = (xi_0 + xi_1); add_r = (xr_1 + xr_2); add_i = (xi_1 + xi_2); sub_r = (xr_1 - xr_2); sub_i = (xi_1 - xi_2); p1 = add_r / 2; p2 = (sub_i * sin_mu_flt); p3 = (sub_r * sin_mu_flt); p4 = add_i / 2; temp = (xr_0 - p1); temp1 = (xi_0 + p3); temp2 = (xi_0 - p3); ptr_op[idx] = (x_01_r + xr_2); ptr_op[idx + 1] = (x_01_i + xi_2); idx = idx + 320; ptr_op[idx] = (temp + p2); ptr_op[idx + 1] = (temp2 - p4); idx = idx + 320; ptr_op[idx] = (temp - p2); ptr_op[idx + 1] = (temp1 - p4); ptr_out_fft3 += 2; idx = idx - 576; } } static VOID ixheaace_cfft_twiddle_mult(FLOAT32 *ptr_inp, FLOAT32 *ptr_op, WORD32 dim1, WORD32 dim2, const FLOAT32 *ptr_tw_flt, const FLOAT32 *ptr_tw_h_flt) { FLOAT32 accu1, accu2; WORD32 i, j; WORD32 step_val = (dim2 - 1) << 1; for (i = 0; i < dim2; i++) { ptr_op[0] = ptr_inp[0]; ptr_op[1] = ptr_inp[1]; ptr_op += 2; ptr_inp += 2; } for (j = 0; j < (dim1 - 1); j++) { ptr_op[0] = ptr_inp[0]; ptr_op[1] = ptr_inp[1]; ptr_inp += 2; ptr_op += 2; for (i = 0; i < (dim2 - 1); i++) { ixheaace_cplx_mult_twid(&accu1, &accu2, ptr_inp[2 * i + 0], ptr_inp[2 * i + 1], ptr_tw_flt[i], ptr_tw_h_flt[i]); ptr_op[2 * i + 0] = accu1; ptr_op[2 * i + 1] = accu2; } ptr_inp += step_val; ptr_op += step_val; ptr_tw_flt += (dim2 - 1); ptr_tw_h_flt += (dim2 - 1); } } static VOID ixheaace_cfft_32_480(FLOAT32 *ptr_in, FLOAT32 *ptr_out) { WORD32 i, l1, l2, h2; FLOAT32 xh0_0, xh1_0, xl0_0, xl1_0; FLOAT32 xh0_1, xh1_1, xl0_1, xl1_1; FLOAT32 x_0, x_1, x_2, x_3; FLOAT32 x_4, x_5, x_6, x_7; FLOAT32 *ptr_x; FLOAT32 *ptr_y; FLOAT32 interm_y[FFT32X2]; FLOAT32 n00, n10, n20, n30, n01, n11, n21, n31; FLOAT32 inp_0qi, inp_0qr; FLOAT32 inp_1qi, inp_1qr; FLOAT32 inp_2qi, inp_2qr; FLOAT32 inp_3qi, inp_3qr; FLOAT32 mul_0qi, mul_0qr; FLOAT32 mul_1qi, mul_1qr; FLOAT32 mul_2qi, mul_2qr; FLOAT32 mul_3qi, mul_3qr; FLOAT32 sum_0qi, sum_0qr; FLOAT32 sum_1qi, sum_1qr; FLOAT32 sum_2qi, sum_2qr; FLOAT32 sum_3qi, sum_3qr; WORD32 idx1 = 0, idx2 = FFT15 * FFT32; FLOAT32 mul_i, mul_r; ptr_x = ptr_in; // This computes first and second stage butterflies. So, 4-point FFT is done. for (i = 0; i < 8; i++) { x_0 = ptr_x[0]; x_1 = ptr_x[1]; x_2 = ptr_x[16]; x_3 = ptr_x[16 + 1]; x_4 = ptr_x[32]; x_5 = ptr_x[32 + 1]; x_6 = ptr_x[48]; x_7 = ptr_x[48 + 1]; xh0_0 = x_0 + x_4; xh1_0 = x_1 + x_5; xl0_0 = x_0 - x_4; xl1_0 = x_1 - x_5; xh0_1 = x_2 + x_6; xh1_1 = x_3 + x_7; xl0_1 = x_2 - x_6; xl1_1 = x_3 - x_7; n00 = xh0_0 + xh0_1; n01 = xh1_0 + xh1_1; n10 = xl0_0 + xl1_1; n11 = xl1_0 - xl0_1; n20 = xh0_0 - xh0_1; n21 = xh1_0 - xh1_1; n30 = xl0_0 - xl1_1; n31 = xl1_0 + xl0_1; ptr_x[0] = n00; ptr_x[1] = n01; ptr_x[16] = n10; ptr_x[16 + 1] = n11; ptr_x[32] = n20; ptr_x[32 + 1] = n21; ptr_x[48] = n30; ptr_x[48 + 1] = n31; ptr_x += 2; } // This computes third and fourth stage butterflies. So, next 4-point FFT is done. { h2 = 16 >> 1; l1 = 16; l2 = 16 + (16 >> 1); ptr_x = ptr_in; ptr_y = &interm_y[0]; /* Butter fly summation in 2 steps */ inp_0qr = ptr_x[0]; inp_0qi = ptr_x[1]; inp_1qr = ptr_x[4]; inp_1qi = ptr_x[5]; inp_2qr = ptr_x[8]; inp_2qi = ptr_x[9]; inp_3qr = ptr_x[12]; inp_3qi = ptr_x[13]; mul_0qr = inp_0qr; mul_0qi = inp_0qi; mul_1qr = inp_1qr; mul_1qi = inp_1qi; mul_2qr = inp_2qr; mul_2qi = inp_2qi; mul_3qr = inp_3qr; mul_3qi = inp_3qi; sum_0qr = mul_0qr + mul_2qr; sum_0qi = mul_0qi + mul_2qi; sum_1qr = mul_0qr - mul_2qr; sum_1qi = mul_0qi - mul_2qi; sum_2qr = mul_1qr + mul_3qr; sum_2qi = mul_1qi + mul_3qi; sum_3qr = mul_1qr - mul_3qr; sum_3qi = mul_1qi - mul_3qi; ptr_y[0] = sum_0qr + sum_2qr; ptr_y[1] = sum_0qi + sum_2qi; ptr_y[h2] = sum_1qr + sum_3qi; ptr_y[h2 + 1] = sum_1qi - sum_3qr; ptr_y[l1] = sum_0qr - sum_2qr; ptr_y[l1 + 1] = sum_0qi - sum_2qi; ptr_y[l2] = sum_1qr - sum_3qi; ptr_y[l2 + 1] = sum_1qi + sum_3qr; ptr_y += 2; ptr_x += 16; /* 2nd butter fly */ inp_0qr = ptr_x[0]; inp_0qi = ptr_x[1]; inp_1qr = ptr_x[4]; inp_1qi = ptr_x[5]; inp_2qr = ptr_x[8]; inp_2qi = ptr_x[9]; inp_3qr = ptr_x[12]; inp_3qi = ptr_x[13]; mul_0qr = inp_0qr; mul_0qi = inp_0qi; mul_1qr = (inp_1qr * 0.461929321f) + (inp_1qi * 0.191329956f); mul_1qi = (inp_1qr * -0.191329956f) + (inp_1qi * 0.461929321f); mul_2qr = ((inp_2qr + inp_2qi) * 0.353546143f); mul_2qi = ((-inp_2qr + inp_2qi) * 0.353546143f); mul_3qr = (inp_3qr * 0.191329956f) + (inp_3qi * 0.461929321f); mul_3qi = (inp_3qr * -0.461929321f) + (inp_3qi * 0.191329956f); sum_0qr = mul_0qr + (mul_2qr * 2); sum_0qi = mul_0qi + (mul_2qi * 2); sum_1qr = mul_0qr - (mul_2qr * 2); sum_1qi = mul_0qi - (mul_2qi * 2); sum_2qr = mul_1qr + mul_3qr; sum_2qi = mul_1qi + mul_3qi; sum_3qr = mul_1qr - mul_3qr; sum_3qi = mul_1qi - mul_3qi; ptr_y[0] = sum_0qr + (sum_2qr * 2); ptr_y[1] = sum_0qi + (sum_2qi * 2); ptr_y[h2] = sum_1qr + (sum_3qi * 2); ptr_y[h2 + 1] = sum_1qi - (sum_3qr * 2); ptr_y[l1] = sum_0qr - (sum_2qr * 2); ptr_y[l1 + 1] = sum_0qi - (sum_2qi * 2); ptr_y[l2] = sum_1qr - (sum_3qi * 2); ptr_y[l2 + 1] = sum_1qi + (sum_3qr * 2); ptr_y += 2; ptr_x += 16; /* 3rd butter fly */ inp_0qr = ptr_x[0]; inp_0qi = ptr_x[1]; inp_1qr = ptr_x[4]; inp_1qi = ptr_x[5]; inp_2qr = ptr_x[8]; inp_2qi = ptr_x[9]; inp_3qr = ptr_x[12]; inp_3qi = ptr_x[13]; mul_0qr = inp_0qr; mul_0qi = inp_0qi; mul_1qr = ((inp_1qr + inp_1qi) * 0.353546143f); mul_1qi = ((-inp_1qr + inp_1qi) * 0.353546143f); mul_2qr = inp_2qi; mul_2qi = inp_2qr; mul_3qr = ((-inp_3qr + inp_3qi) * 0.353546143f); mul_3qi = ((inp_3qr + inp_3qi) * -0.353546143f); sum_0qr = mul_0qr + mul_2qr; sum_0qi = mul_0qi - mul_2qi; sum_1qr = mul_0qr - mul_2qr; sum_1qi = mul_0qi + mul_2qi; sum_2qr = mul_1qr + mul_3qr; sum_2qi = mul_1qi + mul_3qi; sum_3qr = mul_1qr - mul_3qr; sum_3qi = mul_1qi - mul_3qi; ptr_y[0] = sum_0qr + (sum_2qr * 2); ptr_y[1] = sum_0qi + (sum_2qi * 2); ptr_y[h2] = sum_1qr + (sum_3qi * 2); ptr_y[h2 + 1] = sum_1qi - (sum_3qr * 2); ptr_y[l1] = sum_0qr - (sum_2qr * 2); ptr_y[l1 + 1] = sum_0qi - (sum_2qi * 2); ptr_y[l2] = sum_1qr - (sum_3qi * 2); ptr_y[l2 + 1] = sum_1qi + (sum_3qr * 2); ptr_y += 2; ptr_x += 16; /* 4th butter fly */ inp_0qr = ptr_x[0]; inp_0qi = ptr_x[1]; inp_1qr = ptr_x[4]; inp_1qi = ptr_x[5]; inp_2qr = ptr_x[8]; inp_2qi = ptr_x[9]; inp_3qr = ptr_x[12]; inp_3qi = ptr_x[13]; mul_0qr = inp_0qr; mul_0qi = inp_0qi; mul_1qr = (inp_1qr * 0.191329956f) + (inp_1qi * 0.461929321f); mul_1qi = (inp_1qr * -0.461929321f) + (inp_1qi * 0.191329956f); mul_2qr = ((-inp_2qr + inp_2qi) * 0.353546143f); mul_2qi = ((inp_2qr + inp_2qi) * -0.353546143f); mul_3qr = (inp_3qr * -0.461929321f) + (inp_3qi * -0.191329956f); mul_3qi = (inp_3qr * 0.191329956f) + (inp_3qi * -0.461929321f); sum_0qr = mul_0qr + (mul_2qr * 2); sum_0qi = mul_0qi + (mul_2qi * 2); sum_1qr = mul_0qr - (mul_2qr * 2); sum_1qi = mul_0qi - (mul_2qi * 2); sum_2qr = mul_1qr + mul_3qr; sum_2qi = mul_1qi + mul_3qi; sum_3qr = mul_1qr - mul_3qr; sum_3qi = mul_1qi - mul_3qi; ptr_y[0] = sum_0qr + (sum_2qr * 2); ptr_y[1] = sum_0qi + (sum_2qi * 2); ptr_y[h2] = sum_1qr + (sum_3qi * 2); ptr_y[h2 + 1] = sum_1qi - (sum_3qr * 2); ptr_y[l1] = sum_0qr - (sum_2qr * 2); ptr_y[l1 + 1] = sum_0qi - (sum_2qi * 2); ptr_y[l2] = sum_1qr - (sum_3qi * 2); ptr_y[l2 + 1] = sum_1qi + (sum_3qr * 2); ptr_x = ptr_in; ptr_y = &interm_y[32]; /* Butter fly summation in 2 steps */ inp_0qr = ptr_x[2]; inp_0qi = ptr_x[3]; inp_1qr = ptr_x[6]; inp_1qi = ptr_x[7]; inp_2qr = ptr_x[10]; inp_2qi = ptr_x[11]; inp_3qr = ptr_x[14]; inp_3qi = ptr_x[15]; mul_0qr = inp_0qr; mul_0qi = inp_0qi; mul_1qr = inp_1qr; mul_1qi = inp_1qi; mul_2qr = inp_2qr; mul_2qi = inp_2qi; mul_3qr = inp_3qr; mul_3qi = inp_3qi; sum_0qr = mul_0qr + mul_2qr; sum_0qi = mul_0qi + mul_2qi; sum_1qr = mul_0qr - mul_2qr; sum_1qi = mul_0qi - mul_2qi; sum_2qr = mul_1qr + mul_3qr; sum_2qi = mul_1qi + mul_3qi; sum_3qr = mul_1qr - mul_3qr; sum_3qi = mul_1qi - mul_3qi; ptr_y[0] = sum_0qr + sum_2qr; ptr_y[1] = sum_0qi + sum_2qi; ptr_y[h2] = sum_1qr + sum_3qi; ptr_y[h2 + 1] = sum_1qi - sum_3qr; ptr_y[l1] = sum_0qr - sum_2qr; ptr_y[l1 + 1] = sum_0qi - sum_2qi; ptr_y[l2] = sum_1qr - sum_3qi; ptr_y[l2 + 1] = sum_1qi + sum_3qr; ptr_y += 2; ptr_x += 16; /* 2nd butter fly */ inp_0qr = ptr_x[2]; inp_0qi = ptr_x[3]; inp_1qr = ptr_x[6]; inp_1qi = ptr_x[7]; inp_2qr = ptr_x[10]; inp_2qi = ptr_x[11]; inp_3qr = ptr_x[14]; inp_3qi = ptr_x[15]; mul_0qr = inp_0qr; mul_0qi = inp_0qi; mul_1qr = (inp_1qr * 0.461929321f) + (inp_1qi * 0.191329956f); mul_1qi = (inp_1qr * -0.191329956f) + (inp_1qi * 0.461929321f); mul_2qr = ((inp_2qr + inp_2qi) * 0.353546143f); mul_2qi = ((-inp_2qr + inp_2qi) * 0.353546143f); mul_3qr = (inp_3qr * 0.191329956f) + (inp_3qi * 0.461929321f); mul_3qi = (inp_3qr * -0.461929321f) + (inp_3qi * 0.191329956f); sum_0qr = mul_0qr + (mul_2qr * 2); sum_0qi = mul_0qi + (mul_2qi * 2); sum_1qr = mul_0qr - (mul_2qr * 2); sum_1qi = mul_0qi - (mul_2qi * 2); sum_2qr = mul_1qr + mul_3qr; sum_2qi = mul_1qi + mul_3qi; sum_3qr = mul_1qr - mul_3qr; sum_3qi = mul_1qi - mul_3qi; ptr_y[0] = sum_0qr + (sum_2qr * 2); ptr_y[1] = sum_0qi + (sum_2qi * 2); ptr_y[h2] = sum_1qr + (sum_3qi * 2); ptr_y[h2 + 1] = sum_1qi - (sum_3qr * 2); ptr_y[l1] = sum_0qr - (sum_2qr * 2); ptr_y[l1 + 1] = sum_0qi - (sum_2qi * 2); ptr_y[l2] = sum_1qr - (sum_3qi * 2); ptr_y[l2 + 1] = sum_1qi + (sum_3qr * 2); ptr_y += 2; ptr_x += 16; /* 3rd butter fly */ inp_0qr = ptr_x[2]; inp_0qi = ptr_x[3]; inp_1qr = ptr_x[6]; inp_1qi = ptr_x[7]; inp_2qr = ptr_x[10]; inp_2qi = ptr_x[11]; inp_3qr = ptr_x[14]; inp_3qi = ptr_x[15]; mul_0qr = inp_0qr; mul_0qi = inp_0qi; mul_1qr = ((inp_1qr + inp_1qi) * 0.353546143f); mul_1qi = ((-inp_1qr + inp_1qi) * 0.353546143f); mul_2qr = inp_2qi; mul_2qi = inp_2qr; mul_3qr = ((-inp_3qr + inp_3qi) * 0.353546143f); mul_3qi = ((inp_3qr + inp_3qi) * -0.353546143f); sum_0qr = mul_0qr + mul_2qr; sum_0qi = mul_0qi - mul_2qi; sum_1qr = mul_0qr - mul_2qr; sum_1qi = mul_0qi + mul_2qi; sum_2qr = mul_1qr + mul_3qr; sum_2qi = mul_1qi + mul_3qi; sum_3qr = mul_1qr - mul_3qr; sum_3qi = mul_1qi - mul_3qi; ptr_y[0] = sum_0qr + (sum_2qr * 2); ptr_y[1] = sum_0qi + (sum_2qi * 2); ptr_y[h2] = sum_1qr + (sum_3qi * 2); ptr_y[h2 + 1] = sum_1qi - (sum_3qr * 2); ptr_y[l1] = sum_0qr - (sum_2qr * 2); ptr_y[l1 + 1] = sum_0qi - (sum_2qi * 2); ptr_y[l2] = sum_1qr - (sum_3qi * 2); ptr_y[l2 + 1] = sum_1qi + (sum_3qr * 2); ptr_y += 2; ptr_x += 16; /* 4th butter fly */ inp_0qr = ptr_x[2]; inp_0qi = ptr_x[3]; inp_1qr = ptr_x[6]; inp_1qi = ptr_x[7]; inp_2qr = ptr_x[10]; inp_2qi = ptr_x[11]; inp_3qr = ptr_x[14]; inp_3qi = ptr_x[15]; mul_0qr = inp_0qr; mul_0qi = inp_0qi; mul_1qr = (inp_1qr * 0.191329956f) + (inp_1qi * 0.461929321f); mul_1qi = (inp_1qr * -0.461929321f) + (inp_1qi * 0.191329956f); mul_2qr = ((-inp_2qr + inp_2qi) * 0.353546143f); mul_2qi = ((inp_2qr + inp_2qi) * -0.353546143f); mul_3qr = (inp_3qr * -0.461929321f) + (inp_3qi * -0.191329956f); mul_3qi = (inp_3qr * 0.191329956f) + (inp_3qi * -0.461929321f); sum_0qr = mul_0qr + (mul_2qr * 2); sum_0qi = mul_0qi + (mul_2qi * 2); sum_1qr = mul_0qr - (mul_2qr * 2); sum_1qi = mul_0qi - (mul_2qi * 2); sum_2qr = mul_1qr + mul_3qr; sum_2qi = mul_1qi + mul_3qi; sum_3qr = mul_1qr - mul_3qr; sum_3qi = mul_1qi - mul_3qi; ptr_y[0] = sum_0qr + (sum_2qr * 2); ptr_y[1] = sum_0qi + (sum_2qi * 2); ptr_y[h2] = sum_1qr + (sum_3qi * 2); ptr_y[h2 + 1] = sum_1qi - (sum_3qr * 2); ptr_y[l1] = sum_0qr - (sum_2qr * 2); ptr_y[l1 + 1] = sum_0qi - (sum_2qi * 2); ptr_y[l2] = sum_1qr - (sum_3qi * 2); ptr_y[l2 + 1] = sum_1qi + (sum_3qr * 2); } // Last stage of 32 point FFT { ptr_y = ptr_out; ptr_y[idx1] = interm_y[0] + interm_y[32]; ptr_y[idx1 + 1] = interm_y[1] + interm_y[33]; ptr_y[idx2] = interm_y[0] - interm_y[32]; ptr_y[idx2 + 1] = interm_y[1] - interm_y[33]; idx1 += FFT15X2; idx2 += FFT15X2; for (i = 1; i < FFT16; i++) { mul_r = (interm_y[FFT32 + 2 * i + 0] * ixheaace_fft_mix_rad_twid_tbl_32[i - 1]) - (interm_y[FFT32 + 2 * i + 1] * ixheaace_fft_mix_rad_twid_tbl_h_32[i - 1]); mul_i = (interm_y[FFT32 + 2 * i + 0] * ixheaace_fft_mix_rad_twid_tbl_h_32[i - 1]) + (interm_y[FFT32 + 2 * i + 1] * ixheaace_fft_mix_rad_twid_tbl_32[i - 1]); mul_r = mul_r / 2; mul_i = mul_i / 2; ptr_y[idx1] = interm_y[2 * i + 0] + (mul_r * 2); ptr_y[idx1 + 1] = interm_y[2 * i + 1] + (mul_i * 2); ptr_y[idx2] = interm_y[2 * i + 0] - (mul_r * 2); ptr_y[idx2 + 1] = interm_y[2 * i + 1] - (mul_i * 2); idx1 += FFT15X2; idx2 += FFT15X2; } } } static VOID ixheaace_dec_rearrange_short_flt(FLOAT32 *ptr_in, FLOAT32 *ptr_out, WORD32 N, const WORD16 *ptr_re_arr_tab) { WORD32 n, i = 0; for (n = 0; n < N; n++) { WORD32 idx = ptr_re_arr_tab[n] << 1; ptr_out[i++] = ptr_in[idx]; ptr_out[i++] = ptr_in[idx + 1]; } } static VOID ixheaace_fft_5_flt(FLOAT32 *ptr_in, FLOAT32 *ptr_out) { FLOAT32 C51 = 0.951056516f; FLOAT32 C52 = -0.769420885f; FLOAT32 C53 = -0.363271264f; FLOAT32 C54 = 0.559016994f; FLOAT32 C55 = -0.625f; FLOAT32 r1, r2, r3, r4; FLOAT32 s1, s2, s3, s4, t, temp1, temp2; r1 = (ptr_in[2] + ptr_in[8]); r4 = (ptr_in[2] - ptr_in[8]); r3 = (ptr_in[4] + ptr_in[6]); r2 = (ptr_in[4] - ptr_in[6]); t = ((r1 - r3) * C54); r1 = (r1 + r3); temp1 = (ptr_in[0] + r1); r1 = (temp1 + (((r1 * C55)) * 2)); r3 = (r1 - t); r1 = (r1 + t); t = ((r4 + r2) * C51); r4 = (t + ((r4 * C52) * 2)); r2 = (t + (r2 * C53)); s1 = (ptr_in[3] + ptr_in[9]); s4 = (ptr_in[3] - ptr_in[9]); s3 = (ptr_in[5] + ptr_in[7]); s2 = (ptr_in[5] - ptr_in[7]); t = ((s1 - s3) * C54); s1 = (s1 + s3); temp2 = (ptr_in[1] + s1); s1 = (temp2 + (((s1 * C55)) * 2)); s3 = (s1 - t); s1 = (s1 + t); t = ((s4 + s2) * C51); s4 = (t + (((s4 * C52)) * 2)); s2 = (t + ((s2 * C53))); ptr_out[0] = temp1; ptr_out[1] = temp2; ptr_out[2] = (r1 + s2); ptr_out[3] = (s1 - r2); ptr_out[4] = (r3 - s4); ptr_out[5] = (s3 + r4); ptr_out[6] = (r3 + s4); ptr_out[7] = (s3 - r4); ptr_out[8] = (r1 - s2); ptr_out[9] = (s1 + r2); } static VOID ixheaace_fft_3_flt(FLOAT32 *ptr_in, FLOAT32 *ptr_out) { FLOAT32 add_r, sub_r; FLOAT32 add_i, sub_i; FLOAT32 x_01_r, x_01_i, temp; FLOAT32 p1, p2, p3, p4; FLOAT32 sinmu = 0.866025404f; x_01_r = (ptr_in[0] + ptr_in[2]); x_01_i = (ptr_in[1] + ptr_in[3]); add_r = (ptr_in[2] + ptr_in[4]); add_i = (ptr_in[3] + ptr_in[5]); sub_r = (ptr_in[2] - ptr_in[4]); sub_i = (ptr_in[3] - ptr_in[5]); p1 = add_r / 2; p2 = (sub_i * sinmu); p3 = (sub_r * sinmu); p4 = add_i / 2; temp = (ptr_in[0] - p1); ptr_out[0] = (x_01_r + ptr_in[4]); ptr_out[1] = (x_01_i + ptr_in[5]); ptr_out[2] = (temp + p2); ptr_out[3] = ((ptr_in[1] - p3) - p4); ptr_out[4] = (temp - p2); ptr_out[5] = ((ptr_in[1] + p3) - p4); } static VOID ixheaace_pre_twiddle_120(FLOAT32 *ptr_in, FLOAT32 *ptr_data, WORD32 n, const FLOAT32 *ptr_cos_sin_tbl) { WORD npoints_4, i; FLOAT32 tempr, tempi, temp; FLOAT32 c, c1, s, s1; FLOAT32 *ptr_in1, *ptr_in2; FLOAT32 *ptr_x = ptr_in + (n - 1); npoints_4 = n >> 2; ptr_in1 = ptr_data; ptr_in2 = ptr_data + n - 1; for (i = 0; i < npoints_4; i++) { c = *ptr_cos_sin_tbl++; s = *ptr_cos_sin_tbl++; tempr = *ptr_in1++; tempi = *ptr_in2--; temp = -((tempr * c) + (tempi * s)); *ptr_in++ = temp; temp = -((tempi * c) - (tempr * s)); *ptr_in++ = temp; c1 = *ptr_cos_sin_tbl++; s1 = *ptr_cos_sin_tbl++; tempi = *ptr_in1++; tempr = *ptr_in2--; temp = -((tempi * c1) - (tempr * s1)); *ptr_x-- = temp; temp = -((tempr * c1) + (tempi * s1)); *ptr_x-- = temp; } } static VOID ixheaace_post_twiddle_120(FLOAT32 *ptr_out, FLOAT32 *ptr_x, const FLOAT32 *ptr_cos_sin_tbl, WORD m) { WORD i; FLOAT32 c, c1, s, s1; FLOAT32 tempr, tempi, temp; FLOAT32 *ptr_in2 = ptr_x + (m - 1); FLOAT32 *ptr_in1 = ptr_x; FLOAT32 *ptr_x1 = ptr_out; FLOAT32 *ptr_x2 = ptr_out + (m - 1); for (i = 0; i < m; i += 4) { c = *ptr_cos_sin_tbl++; s = *ptr_cos_sin_tbl++; c1 = *ptr_cos_sin_tbl++; s1 = *ptr_cos_sin_tbl++; tempr = *ptr_in1++; tempi = *ptr_in1++; temp = -((tempr * s) - (tempi * c)); *ptr_x2-- = temp; temp = -((tempr * c) + (tempi * s)); *ptr_x1++ = temp; tempi = *ptr_in2--; tempr = *ptr_in2--; temp = -((tempr * s1) - (tempi * c1)); *ptr_x1++ = temp; temp = -((tempr * c1) + (tempi * s1)); *ptr_x2-- = temp; } } static VOID ixheaace_fft_960_15(FLOAT32 *ptr_in_flt, FLOAT32 *ptr_out_flt) { WORD32 i; FLOAT32 *ptr_buf1_flt, *ptr_buf2_flt; ixheaace_dec_rearrange_short_flt(ptr_in_flt, ptr_out_flt, FFT15, re_arr_tab_5); ptr_buf1_flt = ptr_out_flt; ptr_buf2_flt = ptr_in_flt; for (i = 0; i < FFT3; i++) { ixheaace_fft_5_flt(ptr_buf1_flt, ptr_buf2_flt); ptr_buf1_flt += (FFT5 * 2); ptr_buf2_flt += (FFT5 * 2); } ixheaace_dec_rearrange_short_flt(ptr_in_flt, ptr_out_flt, FFT15, re_arr_tab_3); ptr_buf1_flt = ptr_out_flt; ptr_buf2_flt = ptr_in_flt; for (i = 0; i < FFT5; i++) { ixheaace_fft_3_flt(ptr_buf1_flt, ptr_buf2_flt); ptr_buf1_flt += (FFT3 * 2); ptr_buf2_flt += (FFT3 * 2); } ixheaace_dec_rearrange_short_flt(ptr_in_flt, ptr_out_flt, FFT15, re_arr_tab_sml); } static VOID ixheaace_fft_120(WORD32 npoints, FLOAT32 *ptr_x_flt, FLOAT32 *ptr_y_flt) { WORD32 i; FLOAT32 *ptr_buf1_flt, *ptr_buf2_flt; FLOAT32 *ptr_in_flt, *ptr_out_flt; ptr_in_flt = ptr_x_flt; ptr_out_flt = ptr_y_flt; ixheaace_dec_rearrange_short_flt(ptr_in_flt, ptr_out_flt, 60, re_arr_tab_4); ptr_buf1_flt = ptr_out_flt; ptr_buf2_flt = ptr_in_flt; for (i = 0; i < FFT15; i++) { { FLOAT32 x_0, x_1, x_2, x_3, x_4, x_5, x_6, x_7; FLOAT32 *y0, *y1, *y2, *y3; FLOAT32 *x0; FLOAT32 xh0_0, xh1_0, xh0_1, xh1_1, xl0_0, xl1_0, xl0_1, xl1_1; WORD32 h2; FLOAT32 n00, n01, n10, n11, n20, n21, n30, n31; ptr_x_flt = ptr_buf1_flt; ptr_y_flt = ptr_buf2_flt; npoints = 4; h2 = 0; y0 = ptr_y_flt; y2 = ptr_y_flt + (WORD32)npoints; x0 = ptr_x_flt; y1 = y0 + (WORD32)(npoints >> 1); y3 = y2 + (WORD32)(npoints >> 1); x_0 = x0[0]; x_1 = x0[1]; x_2 = x0[2]; x_3 = x0[3]; x_4 = x0[4]; x_5 = x0[5]; x_6 = x0[6]; x_7 = x0[7]; xh0_0 = x_0 + x_4; xh1_0 = x_1 + x_5; xl0_0 = x_0 - x_4; xl1_0 = x_1 - x_5; xh0_1 = x_2 + x_6; xh1_1 = x_3 + x_7; xl0_1 = x_2 - x_6; xl1_1 = x_3 - x_7; n00 = xh0_0 + xh0_1; n01 = xh1_0 + xh1_1; n10 = xl0_0 + xl1_1; n11 = xl1_0 - xl0_1; n20 = xh0_0 - xh0_1; n21 = xh1_0 - xh1_1; n30 = xl0_0 - xl1_1; n31 = xl1_0 + xl0_1; y0[2 * h2] = n00; y0[2 * h2 + 1] = n01; y1[2 * h2] = n10; y1[2 * h2 + 1] = n11; y2[2 * h2] = n20; y2[2 * h2 + 1] = n21; y3[2 * h2] = n30; y3[2 * h2 + 1] = n31; } ptr_buf1_flt += (FFT4 * 2); ptr_buf2_flt += (FFT4 * 2); } ixheaace_dec_rearrange_short_flt(ptr_in_flt, ptr_out_flt, 60, re_arr_tab_15_4); ptr_buf1_flt = ptr_out_flt; ptr_buf2_flt = ptr_in_flt; for (i = 0; i < FFT4; i++) { ixheaace_fft_960_15(ptr_buf1_flt, ptr_buf2_flt); ptr_buf1_flt += (FFT15 * 2); ptr_buf2_flt += (FFT15 * 2); } ixheaace_dec_rearrange_short_flt(ptr_in_flt, ptr_out_flt, 60, re_arr_tab_120); } static VOID ixheaace_cfft_480(FLOAT32 *ptr_inp, FLOAT32 *ptr_op) { WORD32 i; FLOAT32 *ptr_buf1, *ptr_buf2; FLOAT32 fft5_out[FFT15X2] = {0}; ptr_buf1 = ptr_inp; ptr_buf2 = ptr_op; for (i = 0; i < FFT32; i++) { ixheaace_cfft_15_480(ptr_buf1, ptr_buf2, &fft5_out[0]); ptr_buf1 += 2; ptr_buf2 += 2; } ixheaace_cfft_twiddle_mult(ptr_op, ptr_inp, FFT15, FFT32, ixheaace_fft_mix_rad_twid_tbl_480, ixheaace_fft_mix_rad_twid_h_tbl_480); ptr_buf1 = ptr_inp; ptr_buf2 = ptr_op; for (i = 0; i < FFT15; i++) { ixheaace_cfft_32_480(ptr_buf1, ptr_buf2); ptr_buf1 += (FFT32X2); ptr_buf2 += 2; } } static VOID ixheaace_pre_twiddle_960(FLOAT32 *ptr_x, FLOAT32 *ptr_data, WORD32 n, const FLOAT32 *ptr_cos_sin_tbl) { WORD npoints_4, i; FLOAT32 tempr, tempi, temp; FLOAT32 c, c1, s, s1; FLOAT32 *ptr_in_1, *ptr_in_2; FLOAT32 *ptr_x_1 = ptr_x + (n - 1); npoints_4 = n >> 2; ptr_in_1 = ptr_data; ptr_in_2 = ptr_data + n - 1; for (i = 0; i < npoints_4; i++) { c = *ptr_cos_sin_tbl++; s = *ptr_cos_sin_tbl++; tempr = *ptr_in_1++; tempi = *ptr_in_2--; temp = -((tempr * c) + (tempi * s)); *ptr_x++ = temp; temp = -((tempi * c) - (tempr * s)); *ptr_x++ = temp; c1 = *ptr_cos_sin_tbl++; s1 = *ptr_cos_sin_tbl++; tempi = *ptr_in_1++; tempr = *ptr_in_2--; temp = -((tempi * c1) - (tempr * s1)); *ptr_x_1-- = temp; temp = -((tempr * c1) + (tempi * s1)); *ptr_x_1-- = temp; } } static VOID ixheaace_post_twiddle_960(FLOAT32 *ptr_out, FLOAT32 *ptr_x, const FLOAT32 *ptr_cos_sin_tbl, WORD m) { WORD i; FLOAT32 c, c1, s, s1; FLOAT32 tempr, tempi, temp; FLOAT32 *ptr_in2 = ptr_x + (m - 1); FLOAT32 *ptr_in1 = ptr_x; FLOAT32 *ptr_x1 = ptr_out; FLOAT32 *ptr_x2 = ptr_out + (m - 1); for (i = 0; i < m; i += 4) { c = *ptr_cos_sin_tbl++; s = *ptr_cos_sin_tbl++; c1 = *ptr_cos_sin_tbl++; s1 = *ptr_cos_sin_tbl++; tempr = *ptr_in1++; tempi = *ptr_in1++; temp = -((tempr * s) - (tempi * c)); *ptr_x2-- = temp; temp = -((tempr * c) + (tempi * s)); *ptr_x1++ = temp; tempi = *ptr_in2--; tempr = *ptr_in2--; temp = -((tempr * s1) - (tempi * c1)); *ptr_x1++ = temp; temp = -((tempr * c1) + (tempi * s1)); *ptr_x2-- = temp; } } static VOID ixheaace_mdct_960(FLOAT32 *ptr_input_flt, WORD8 *ptr_scratch) { FLOAT32 *ptr_scratch_flt = (FLOAT32 *)ptr_scratch; FLOAT32 const_mult_fac = 3.142857143f; FLOAT32 *ptr_data = ptr_input_flt; WORD32 k; memcpy(ptr_scratch_flt, ptr_input_flt, sizeof(*ptr_scratch_flt) * FRAME_LEN_960); ixheaace_pre_twiddle_960(ptr_input_flt, ptr_scratch_flt, FRAME_LEN_960, cos_sin_table_flt); ixheaace_cfft_480(ptr_input_flt, ptr_scratch_flt); ixheaace_post_twiddle_960(ptr_input_flt, ptr_scratch_flt, cos_sin_table_flt, FRAME_LEN_960); for (k = FRAME_LEN_960 - 1; k >= 0; k -= 2) { *ptr_data = (*ptr_data * const_mult_fac); ptr_data++; *ptr_data = (*ptr_data * const_mult_fac); ptr_data++; } } static VOID ixheaace_mdct_120(FLOAT32 *ptr_input_flt, WORD8 *ptr_scratch) { WORD32 n, k; WORD32 n_by_2; FLOAT32 *ptr_scratch_flt = (FLOAT32 *)ptr_scratch; FLOAT32 const_mltfac = 3.142857143f; FLOAT32 *ptr_data = ptr_input_flt; n = 120; n_by_2 = n >> 1; memcpy(ptr_scratch_flt, ptr_input_flt, sizeof(*ptr_scratch_flt) * n); ixheaace_pre_twiddle_120(ptr_input_flt, ptr_scratch_flt, n, ixheaace_cosine_array_240); ixheaace_fft_120(n_by_2, ptr_input_flt, ptr_scratch_flt); ixheaace_post_twiddle_120(ptr_input_flt, ptr_scratch_flt, ixheaace_cosine_array_240, n); for (k = n - 1; k >= 0; k -= 2) { *ptr_data = (*ptr_data * const_mltfac); ptr_data++; *ptr_data = (*ptr_data * const_mltfac); ptr_data++; } } static VOID ixheaace_mdct(FLOAT32 *ptr_dct_data, const FLOAT32 *ptr_trig_data, const FLOAT32 *ptr_sine_window, WORD32 n, WORD32 ld_n, WORD8 *ptr_scratch) { ixheaace_pre_mdct(ptr_dct_data, n, ptr_sine_window); ixheaace_scratch_mem *pstr_scratch = (ixheaace_scratch_mem *)ptr_scratch; ia_enhaacplus_enc_complex_fft(ptr_dct_data, n / 2, pstr_scratch); ixheaace_post_mdct(ptr_dct_data, n, ptr_trig_data, 1 << (LD_FFT_TWIDDLE_TABLE_SIZE - (ld_n - 1)), FFT_TWIDDLE_TABLE_SIZE); } static VOID ixheaace_shift_mdct_delay_buffer(FLOAT32 *ptr_mdct_delay_buffer, const FLOAT32 *ptr_time_signal, WORD32 ch_increment, WORD32 frame_len) { WORD32 i; WORD32 blk_switch_offset = frame_len; switch (frame_len) { case FRAME_LEN_1024: blk_switch_offset = BLK_SWITCH_OFFSET_LC_128; memmove(ptr_mdct_delay_buffer, ptr_mdct_delay_buffer + frame_len, (blk_switch_offset - frame_len) * sizeof(*ptr_mdct_delay_buffer)); break; case FRAME_LEN_960: blk_switch_offset = BLK_SWITCH_OFFSET_LC_120; memmove(ptr_mdct_delay_buffer, ptr_mdct_delay_buffer + frame_len, (blk_switch_offset - frame_len) * sizeof(*ptr_mdct_delay_buffer)); break; case FRAME_LEN_512: case FRAME_LEN_480: blk_switch_offset = frame_len; break; } for (i = 0; i < frame_len; i++) { ptr_mdct_delay_buffer[blk_switch_offset - frame_len + i] = ptr_time_signal[i * ch_increment]; } } VOID ixheaace_transform_real_lc_ld(FLOAT32 *ptr_mdct_delay_buffer, const FLOAT32 *ptr_time_signal, WORD32 ch_increment, FLOAT32 *ptr_real_out, WORD32 block_type, WORD32 frame_len, WORD8 *ptr_scratch) { WORD32 i, w; FLOAT32 ws1, ws2; FLOAT32 *ptr_dct_in; WORD32 frame_len_short = FRAME_LEN_SHORT_128; WORD32 ls_trans = LS_TRANS_128; WORD32 trans_offset = TRANSFORM_OFFSET_SHORT_128; const FLOAT32 *ptr_window; if (frame_len == FRAME_LEN_960) { ls_trans = LS_TRANS_120; trans_offset = TRANSFORM_OFFSET_SHORT_120; frame_len_short = FRAME_LEN_SHORT_120; } switch (block_type) { case LONG_WINDOW: ptr_dct_in = ptr_real_out; ptr_window = &long_window_KBD[0]; switch (frame_len) { case FRAME_LEN_1024: ptr_window = &long_window_KBD[0]; break; case FRAME_LEN_960: ptr_window = &long_window_sine_960[0]; break; case FRAME_LEN_512: ptr_window = &long_window_sine_ld[0]; break; case FRAME_LEN_480: ptr_window = &long_window_sine_ld_480[0]; break; } for (i = 0; i < frame_len / 2; i++) { ws1 = ptr_mdct_delay_buffer[i] * ptr_window[i]; ws2 = ptr_mdct_delay_buffer[(frame_len - i - 1)] * ptr_window[frame_len - i - 1]; ptr_dct_in[frame_len / 2 + i] = ws1 - ws2; } ixheaace_shift_mdct_delay_buffer(ptr_mdct_delay_buffer, ptr_time_signal, ch_increment, frame_len); for (i = 0; i < frame_len / 2; i++) { ws1 = ptr_mdct_delay_buffer[i] * ptr_window[frame_len - i - 1]; ws2 = ptr_mdct_delay_buffer[(frame_len - i - 1)] * ptr_window[i]; ptr_dct_in[frame_len / 2 - i - 1] = -(ws1 + ws2); } switch (frame_len) { case FRAME_LEN_1024: ixheaace_mdct(ptr_dct_in, fft_twiddle_tab, long_window_sine, frame_len, 10, ptr_scratch); break; case FRAME_LEN_960: ixheaace_mdct_960(ptr_dct_in, ptr_scratch); break; case FRAME_LEN_512: case FRAME_LEN_480: ixheaace_mdct(ptr_dct_in, fft_twiddle_tab, ptr_window, frame_len, 9, ptr_scratch); break; } break; case START_WINDOW: ptr_dct_in = ptr_real_out; ptr_window = &long_window_KBD[0]; switch (frame_len) { case FRAME_LEN_1024: ptr_window = &long_window_KBD[0]; break; case FRAME_LEN_960: ptr_window = &long_window_sine_960[0]; break; } for (i = 0; i < frame_len / 2; i++) { ws1 = ptr_mdct_delay_buffer[i] * ptr_window[i]; ws2 = ptr_mdct_delay_buffer[(frame_len - i - 1)] * ptr_window[frame_len - i - 1]; ptr_dct_in[frame_len / 2 + i] = ws1 - ws2; } ixheaace_shift_mdct_delay_buffer(ptr_mdct_delay_buffer, ptr_time_signal, ch_increment, frame_len); if (frame_len == FRAME_LEN_1024) { ptr_window = &short_window_sine[0]; } else if (frame_len == FRAME_LEN_960) { ptr_window = &short_window_sine_120[0]; } for (i = 0; i < ls_trans; i++) { ws1 = ptr_mdct_delay_buffer[i]; ws2 = 0.0f; ptr_dct_in[frame_len / 2 - i - 1] = -(ws1 + ws2); } for (i = 0; i < frame_len_short / 2; i++) { ws1 = ptr_mdct_delay_buffer[i + ls_trans] * ptr_window[frame_len_short - i - 1]; ws2 = ptr_mdct_delay_buffer[(frame_len - i - 1 - ls_trans)] * ptr_window[i]; ptr_dct_in[frame_len / 2 - i - 1 - ls_trans] = -(ws1 + ws2); } if (frame_len == FRAME_LEN_960) { ixheaace_mdct_960(ptr_dct_in, ptr_scratch); } else { ixheaace_mdct(ptr_dct_in, fft_twiddle_tab, long_window_sine, frame_len, 10, ptr_scratch); } break; case STOP_WINDOW: ptr_window = &long_window_KBD[0]; ptr_dct_in = ptr_real_out; if (frame_len == FRAME_LEN_1024) { ptr_window = &short_window_sine[0]; } else if (frame_len == FRAME_LEN_960) { ptr_window = &short_window_sine_120[0]; } for (i = 0; i < ls_trans; i++) { ws1 = 0.0f; ws2 = ptr_mdct_delay_buffer[(frame_len - i - 1)]; ptr_dct_in[frame_len / 2 + i] = ws1 - ws2; } for (i = 0; i < frame_len_short / 2; i++) { ws1 = ptr_mdct_delay_buffer[(i + ls_trans)] * ptr_window[i]; ws2 = ptr_mdct_delay_buffer[(frame_len - ls_trans - i - 1)] * ptr_window[frame_len_short - i - 1]; ptr_dct_in[frame_len / 2 + i + ls_trans] = ws1 - ws2; } ixheaace_shift_mdct_delay_buffer(ptr_mdct_delay_buffer, ptr_time_signal, ch_increment, frame_len); if (frame_len == FRAME_LEN_1024) { ptr_window = &long_window_KBD[0]; } else if (frame_len == FRAME_LEN_960) { ptr_window = &long_window_sine_960[0]; } for (i = 0; i < frame_len / 2; i++) { ws1 = ptr_mdct_delay_buffer[i] * ptr_window[frame_len - i - 1]; ws2 = ptr_mdct_delay_buffer[(frame_len - i - 1)] * ptr_window[i]; ptr_dct_in[frame_len / 2 - i - 1] = -(ws1 + ws2); } if (frame_len == FRAME_LEN_960) { ixheaace_mdct_960(ptr_dct_in, ptr_scratch); } else { ixheaace_mdct(ptr_dct_in, fft_twiddle_tab, long_window_sine, frame_len, 10, ptr_scratch); } break; case SHORT_WINDOW: ptr_window = &short_window_sine[0]; if (frame_len == FRAME_LEN_1024) { ptr_window = &short_window_sine[0]; } else if (frame_len == FRAME_LEN_960) { ptr_window = &short_window_sine_120[0]; } for (w = 0; w < TRANS_FAC; w++) { ptr_dct_in = ptr_real_out + w * frame_len_short; for (i = 0; i < frame_len_short / 2; i++) { ws1 = ptr_mdct_delay_buffer[trans_offset + w * frame_len_short + i] * ptr_window[i]; ws2 = ptr_mdct_delay_buffer[trans_offset + w * frame_len_short + frame_len_short - i - 1] * ptr_window[frame_len_short - i - 1]; ptr_dct_in[frame_len_short / 2 + i] = ws1 - ws2; ws1 = ptr_mdct_delay_buffer[trans_offset + w * frame_len_short + frame_len_short + i] * ptr_window[frame_len_short - i - 1]; ws2 = ptr_mdct_delay_buffer[trans_offset + w * frame_len_short + frame_len_short * 2 - i - 1] * ptr_window[i]; ptr_dct_in[frame_len_short / 2 - i - 1] = -(ws1 + ws2); } if (frame_len == FRAME_LEN_960) { ixheaace_mdct_120(ptr_dct_in, ptr_scratch); } else { ixheaace_mdct(ptr_dct_in, fft_twiddle_tab, short_window_sine, frame_len_short, 7, ptr_scratch); } } ixheaace_shift_mdct_delay_buffer(ptr_mdct_delay_buffer, ptr_time_signal, ch_increment, frame_len); break; } } VOID ia_enhaacplus_enc_transform_real_eld(FLOAT32 *ptr_mdct_delay_buffer, const FLOAT32 *ptr_time_signal, WORD32 ch_increment, FLOAT32 *ptr_real_out, WORD8 *ptr_shared_buffer5, WORD32 frame_len) { WORD32 i, loop_len; FLOAT32 w1, w2; FLOAT32 *ptr_curr_data, *ptr_prev1_data, *ptr_prev2_data, *ptr_prev3_data; const FLOAT32 *ptr_win0, *ptr_win1, *ptr_win2, *ptr_win3; loop_len = frame_len / 4; ptr_curr_data = &ptr_mdct_delay_buffer[3 * frame_len]; ptr_prev1_data = &ptr_mdct_delay_buffer[2 * frame_len]; ptr_prev2_data = &ptr_mdct_delay_buffer[frame_len]; ptr_prev3_data = &ptr_mdct_delay_buffer[0]; ptr_win0 = &low_delay_window_eld[0]; ptr_win1 = &low_delay_window_eld[frame_len]; ptr_win2 = &low_delay_window_eld[2 * frame_len]; ptr_win3 = &low_delay_window_eld[3 * frame_len]; memmove(&ptr_mdct_delay_buffer[0], &ptr_mdct_delay_buffer[frame_len], (3 * frame_len) * sizeof(ptr_mdct_delay_buffer[0])); for (i = 0; i < frame_len; i++) { ptr_curr_data[i] = ptr_time_signal[i * ch_increment]; } for (i = 0; i < loop_len; i++) { w1 = ptr_prev3_data[(frame_len / 2) + loop_len + i] * ptr_win3[(frame_len / 2) - 1 - i]; w1 += ptr_prev3_data[(frame_len / 2) + loop_len - 1 - i] * ptr_win3[(frame_len / 2) + i]; w2 = (-ptr_prev1_data[(frame_len / 2) + loop_len + i] * ptr_win1[(frame_len / 2) - 1 - i]); w2 += (-ptr_prev1_data[(frame_len / 2) + loop_len - 1 - i] * ptr_win1[(frame_len / 2) + i]); ptr_real_out[i] = w1 + w2; } for (i = 0; i < loop_len; i++) { w1 = (-ptr_prev2_data[(frame_len / 2) + loop_len + i] * ptr_win2[(frame_len / 2) - 1 - i]); w1 += ptr_prev2_data[(frame_len / 2) + loop_len - 1 - i] * ptr_win2[(frame_len / 2) + i]; w2 = ptr_curr_data[(frame_len / 2) + loop_len + i] * ptr_win0[(frame_len / 2) - 1 - i]; w2 += (-ptr_curr_data[(frame_len / 2) + loop_len - 1 - i] * ptr_win0[(frame_len / 2) + i]); ptr_real_out[frame_len - 1 - i] = w1 + w2; } for (i = 0; i < loop_len; i++) { w1 = ptr_prev2_data[loop_len - 1 - i] * ptr_win3[i]; w1 += ptr_prev3_data[loop_len + i] * ptr_win3[frame_len - 1 - i]; w2 = (-ptr_curr_data[loop_len - 1 - i] * ptr_win1[i]); w2 += (-ptr_prev1_data[loop_len + i] * ptr_win1[frame_len - 1 - i]); ptr_real_out[(frame_len / 2) - 1 - i] = w1 + w2; } for (i = 0; i < loop_len; i++) { w1 = -(ptr_prev1_data[loop_len - 1 - i] * ptr_win2[i]); w1 += ptr_prev2_data[loop_len + i] * ptr_win2[frame_len - 1 - i]; /* First 128 coeffcients are zeros in the window table so they are not used in the code here*/ w2 = (-ptr_curr_data[loop_len + i] * ptr_win0[frame_len - 1 - i]); ptr_real_out[(frame_len / 2) + i] = w1 + w2; } ixheaace_mdct(ptr_real_out, fft_twiddle_tab, long_window_sine_ld, frame_len, 9, ptr_shared_buffer5); }