wrapper/libxaac
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
libxaac/encoder/ixheaace_fft.c
akshayragir833 e78e1c43c3
Code refactoring and minor fixes (#36) 
Co-authored-by: Akshay Ragir <100833@ittiam.com>
2023-07-07 16:15:45 +05:30

2485 lines
71 KiB
C
Raw Permalink Blame History

/******************************************************************************
* *
* 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 <string.h>
#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);
}
Reference in a new issue View git blame Copy permalink