king
/
v811_spc009
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '8f4c154c05'
${ noResults }
v811_spc009/external/libxaac/decoder/ixheaacd_aac_imdct.c

2493 lines
67 KiB
Raw Blame History

/******************************************************************************
* *
* Copyright (C) 2018 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*****************************************************************************
* Originally developed and contributed by Ittiam Systems Pvt. Ltd, Bangalore
*/
#include "ixheaacd_sbr_common.h"
#include "ixheaacd_type_def.h"
#include "ixheaacd_constants.h"
#include "ixheaacd_basic_ops32.h"
#include "ixheaacd_basic_ops16.h"
#include "ixheaacd_basic_ops40.h"
#include "ixheaacd_basic_ops.h"
#include "ixheaacd_defines.h"
#include "ixheaacd_common_rom.h"
#include "ixheaacd_basic_funcs.h"
#include "ixheaacd_aac_rom.h"
#include "ixheaacd_aac_imdct.h"
#include "ixheaacd_intrinsics.h"
#include "ixheaacd_basic_op.h"
#include "ixheaacd_function_selector.h"
#include "ixheaacd_audioobjtypes.h"
#include "ixheaacd_tns.h"
#define DIG_REV(i, m, j) \
do { \
unsigned _ = (i); \
_ = ((_ & 0x33333333) << 2) | ((_ & ~0x33333333) >> 2); \
_ = ((_ & 0x0F0F0F0F) << 4) | ((_ & ~0x0F0F0F0F) >> 4); \
_ = ((_ & 0x00FF00FF) << 8) | ((_ & ~0x00FF00FF) >> 8); \
_ = ((_ & 0x0000FFFF) << 16) | ((_ & ~0x0000FFFF) >> 16); \
(j) = _ >> (m); \
} while (0)
#define MPYHIRC(x, y) \
\
(((WORD32)((short)(x >> 16) * (unsigned short)(y & 0x0000FFFF) + 0x4000) >> \
15) + \
((WORD32)((short)(x >> 16) * (short)((y) >> 16)) << 1))
#define MPYLUHS(x, y) \
((WORD32)((unsigned short)(x & 0x0000FFFF) * (short)(y >> 16)))
#define MDCT_LEN 480
#define FFT15X2 30
#define MDCT_LEN_BY2 240
#define FFT5 5
#define FFT16 16
#define FFT15 15
#define FFT16X2 32
WORD32 ixheaacd_fft5out[FFT15X2];
static PLATFORM_INLINE WORD32 ixheaacd_shr32_drc(WORD32 a, WORD32 b) {
WORD32 out_val;
b = ((UWORD32)(b << 24) >> 24);
if (b >= 31) {
if (a < 0)
out_val = -1;
else
out_val = 0;
} else {
a = ixheaacd_add32_sat(a, (1 << (b - 1)));
out_val = (WORD32)a >> b;
}
return out_val;
}
static PLATFORM_INLINE WORD32 ixheaacd_mult32x16hin32_drc(WORD32 a, WORD32 b) {
WORD32 result;
WORD64 temp_result;
temp_result = (WORD64)a * (WORD64)(b >> 16);
result = (WORD32)(temp_result >> 16);
return (result);
}
static PLATFORM_INLINE WORD32 ixheaacd_mult32x16lin32(WORD32 a, WORD32 b) {
WORD32 result;
WORD64 temp_result;
temp_result = (WORD64)a * (WORD64)(((b & 0xFFFF) << 16) >> 16);
result = (WORD32)(temp_result >> 16);
return (result);
}
static PLATFORM_INLINE WORD32 ixheaacd_mac32x16lin32(WORD32 a, WORD32 b,
WORD32 c) {
WORD32 result;
result = a + ixheaacd_mult32x16lin32(b, c);
return (result);
}
static PLATFORM_INLINE WORD32 ixheaacd_mult32x16lin32_drc(WORD32 a, WORD32 b) {
WORD32 result;
WORD64 temp_result;
temp_result = (WORD64)a * (WORD64)(((b & 0xFFFF) << 16) >> 16);
if (temp_result < (WORD64)MIN_32)
result = MIN_32;
else if (temp_result > (WORD64)MAX_32)
result = MAX_32;
else
result = (WORD32)(temp_result);
return (result);
}
WORD16 ixheaacd_neg_expo_inc_dec(WORD16 neg_expo) { return (neg_expo + 2); }
WORD16 ixheaacd_neg_expo_inc_arm(WORD16 neg_expo) { return (neg_expo + 3); }
VOID ixheaacd_pretwiddle_compute_dec(
WORD32 *spec_data1, WORD32 *spec_data2, WORD32 *out_ptr,
ia_aac_dec_imdct_tables_struct *ptr_imdct_tables, WORD npoints4,
WORD32 neg_expo) {
WORD32 i;
WORD32 tempr, tempi;
WORD32 tempr1, tempi1;
WORD32 npoints2 = npoints4 * 2;
WORD32 *out_ptr1 = out_ptr + (npoints2 << 1) - 1;
const WORD16 *cos_sin_ptr = ptr_imdct_tables->cosine_array_2048_256;
WORD16 cos = 0, cos1 = 0, sin = 0, sin1 = 0;
if (neg_expo < 0) {
neg_expo = -neg_expo;
if (npoints4 == 256) {
cos = *cos_sin_ptr++;
sin = *cos_sin_ptr++;
} else if (npoints4 == 32) {
cos = *cos_sin_ptr++;
sin = *cos_sin_ptr;
cos_sin_ptr += 15;
}
tempr = *spec_data1++;
tempi = *spec_data2--;
*out_ptr =
ixheaacd_mac32x16in32(ixheaacd_mult32x16in32(tempr, cos), tempi, sin);
*out_ptr = ixheaacd_shl32(*out_ptr, neg_expo);
out_ptr++;
*out_ptr = ixheaacd_sub32(ixheaacd_mult32x16in32(tempi, cos),
ixheaacd_mult32x16in32(tempr, sin));
*out_ptr = ixheaacd_shl32(*out_ptr, neg_expo);
out_ptr++;
for (i = 0; i < npoints4 - 1; i++) {
if (npoints4 == 256) {
sin = *cos_sin_ptr++;
cos = *cos_sin_ptr++;
} else if (npoints4 == 32) {
sin = *cos_sin_ptr++;
cos = *cos_sin_ptr;
cos_sin_ptr += 15;
}
tempi1 = *spec_data1++;
tempr = *spec_data1++;
tempr1 = *spec_data2--;
tempi = *spec_data2--;
*out_ptr1 = ixheaacd_sub32(ixheaacd_mult32x16in32(tempi1, cos),
ixheaacd_mult32x16in32(tempr1, sin));
*out_ptr1 = ixheaacd_shl32(*out_ptr1, neg_expo);
out_ptr1--;
*out_ptr1 = ixheaacd_mac32x16in32(ixheaacd_mult32x16in32(tempr1, cos),
tempi1, sin);
*out_ptr1 = ixheaacd_shl32(*out_ptr1, neg_expo);
out_ptr1--;
*out_ptr =
ixheaacd_mac32x16in32(ixheaacd_mult32x16in32(tempr, sin), tempi, cos);
*out_ptr = ixheaacd_shl32(*out_ptr, neg_expo);
out_ptr++;
*out_ptr = ixheaacd_sub32(ixheaacd_mult32x16in32(tempi, sin),
ixheaacd_mult32x16in32(tempr, cos));
*out_ptr = ixheaacd_shl32(*out_ptr, neg_expo);
out_ptr++;
}
cos1 = *cos_sin_ptr++;
sin1 = *cos_sin_ptr;
tempr1 = *spec_data2;
tempi1 = *spec_data1;
*out_ptr1 = ixheaacd_sub32(ixheaacd_mult32x16in32(tempi1, cos1),
ixheaacd_mult32x16in32(tempr1, sin1));
*out_ptr1 = ixheaacd_shl32(*out_ptr1, neg_expo);
out_ptr1--;
*out_ptr1 = ixheaacd_mac32x16in32(ixheaacd_mult32x16in32(tempr1, cos1),
tempi1, sin1);
*out_ptr1 = ixheaacd_shl32(*out_ptr1, neg_expo);
out_ptr1--;
} else {
if (npoints4 == 256) {
cos = *cos_sin_ptr++;
sin = *cos_sin_ptr++;
} else if (npoints4 == 32) {
cos = *cos_sin_ptr++;
sin = *cos_sin_ptr;
cos_sin_ptr += 15;
}
tempr = *spec_data1++;
tempi = *spec_data2--;
*out_ptr =
ixheaacd_mac32x16in32(ixheaacd_mult32x16in32(tempr, cos), tempi, sin);
*out_ptr = ixheaacd_shr32(*out_ptr, neg_expo);
out_ptr++;
*out_ptr = ixheaacd_sub32(ixheaacd_mult32x16in32(tempi, cos),
ixheaacd_mult32x16in32(tempr, sin));
*out_ptr = ixheaacd_shr32(*out_ptr, neg_expo);
out_ptr++;
for (i = 0; i < npoints4 - 1; i++) {
if (npoints4 == 256) {
sin = *cos_sin_ptr++;
cos = *cos_sin_ptr++;
} else if (npoints4 == 32) {
sin = *cos_sin_ptr++;
cos = *cos_sin_ptr;
cos_sin_ptr += 15;
}
tempi1 = *spec_data1++;
tempr = *spec_data1++;
tempr1 = *spec_data2--;
tempi = *spec_data2--;
*out_ptr1 = ixheaacd_sub32(ixheaacd_mult32x16in32(tempi1, cos),
ixheaacd_mult32x16in32(tempr1, sin));
*out_ptr1 = ixheaacd_shr32(*out_ptr1, neg_expo);
out_ptr1--;
*out_ptr1 = ixheaacd_mac32x16in32(ixheaacd_mult32x16in32(tempr1, cos),
tempi1, sin);
*out_ptr1 = ixheaacd_shr32(*out_ptr1, neg_expo);
out_ptr1--;
*out_ptr =
ixheaacd_mac32x16in32(ixheaacd_mult32x16in32(tempr, sin), tempi, cos);
*out_ptr = ixheaacd_shr32(*out_ptr, neg_expo);
out_ptr++;
*out_ptr = ixheaacd_sub32(ixheaacd_mult32x16in32(tempi, sin),
ixheaacd_mult32x16in32(tempr, cos));
*out_ptr = ixheaacd_shr32(*out_ptr, neg_expo);
out_ptr++;
}
cos1 = *cos_sin_ptr++;
sin1 = *cos_sin_ptr;
tempr1 = *spec_data2;
tempi1 = *spec_data1;
*out_ptr1 = ixheaacd_sub32(ixheaacd_mult32x16in32(tempi1, cos1),
ixheaacd_mult32x16in32(tempr1, sin1));
*out_ptr1 = ixheaacd_shr32(*out_ptr1, neg_expo);
out_ptr1--;
*out_ptr1 = ixheaacd_mac32x16in32(ixheaacd_mult32x16in32(tempr1, cos1),
tempi1, sin1);
*out_ptr1 = ixheaacd_shr32(*out_ptr1, neg_expo);
out_ptr1--;
}
}
VOID ixheaacd_post_twiddle_dec(WORD32 out_ptr[], WORD32 spec_data[],
ia_aac_dec_imdct_tables_struct *ptr_imdct_tables,
WORD npoints) {
WORD i;
WORD16 cos, cos1, sin, sin1;
WORD32 *spec_data1 = spec_data + npoints - 1;
WORD32 *out_ptr1 = out_ptr + npoints - 1;
WORD16 adjust = 50, adjust1 = -50;
const WORD16 *cos_sin_ptr = ptr_imdct_tables->cosine_array_2048_256;
if (npoints == 1024) {
WORD32 tempr, tempi, outi, outr, temp1, temp2;
tempr = *spec_data++;
tempi = *spec_data++;
cos = *cos_sin_ptr;
cos_sin_ptr++;
sin = *cos_sin_ptr;
cos_sin_ptr++;
outi = ixheaacd_sub32(ixheaacd_mult32x16in32(tempr, sin),
ixheaacd_mult32x16in32(tempi, cos));
outr =
ixheaacd_mac32x16in32(ixheaacd_mult32x16in32(tempr, cos), tempi, sin);
temp1 = ixheaacd_mult32x16in32(outi, adjust1);
temp2 = ixheaacd_mult32x16in32(outr, adjust);
outr = outr + temp1;
outi = outi + temp2;
*out_ptr1-- = outi;
*out_ptr++ = outr;
for (i = 0; i < (npoints / 2 - 2); i++) {
sin = *cos_sin_ptr++;
cos = *cos_sin_ptr++;
tempi = *spec_data1--;
tempr = *spec_data1--;
outi = ixheaacd_sub32(ixheaacd_mult32x16in32(tempr, sin),
ixheaacd_mult32x16in32(tempi, cos));
outr =
ixheaacd_mac32x16in32(ixheaacd_mult32x16in32(tempr, cos), tempi, sin);
temp1 = ixheaacd_mult32x16in32(outi, adjust1);
temp2 = ixheaacd_mult32x16in32(outr, adjust);
outr = outr + temp1;
outi = outi + temp2;
*out_ptr++ = outi;
*out_ptr1-- = outr;
i++;
tempr = *spec_data++;
tempi = *spec_data++;
outi = ixheaacd_sub32(ixheaacd_mult32x16in32(tempr, cos),
ixheaacd_mult32x16in32(tempi, sin));
outr =
ixheaacd_mac32x16in32(ixheaacd_mult32x16in32(tempr, sin), tempi, cos);
temp1 = ixheaacd_mult32x16in32(outi, adjust1);
temp2 = ixheaacd_mult32x16in32(outr, adjust);
outr = outr + temp1;
outi = outi + temp2;
*out_ptr1-- = outi;
*out_ptr++ = outr;
}
cos1 = *cos_sin_ptr++;
sin1 = *cos_sin_ptr;
tempi = *spec_data1--;
tempr = *spec_data1--;
outi = ixheaacd_sub32(ixheaacd_mult32x16in32(tempr, sin1),
ixheaacd_mult32x16in32(tempi, cos1));
outr =
ixheaacd_mac32x16in32(ixheaacd_mult32x16in32(tempr, cos1), tempi, sin1);
temp1 = ixheaacd_mult32x16in32(outi, adjust1);
temp2 = ixheaacd_mult32x16in32(outr, adjust);
outr = outr + temp1;
outi = outi + temp2;
*out_ptr++ = outi;
*out_ptr1-- = outr;
} else if (npoints == 128) {
WORD32 tempr, tempi, outi, outr, temp1, temp2;
tempr = *spec_data++;
tempi = *spec_data++;
cos = *cos_sin_ptr++;
sin = *cos_sin_ptr;
cos_sin_ptr += 15;
outi = ixheaacd_sub32(ixheaacd_mult32x16in32(tempr, sin),
ixheaacd_mult32x16in32(tempi, cos));
outr =
ixheaacd_mac32x16in32(ixheaacd_mult32x16in32(tempr, cos), tempi, sin);
temp1 = ixheaacd_mult32x16in32(outi, -(201 << 1));
temp2 = ixheaacd_mult32x16in32(outr, 201 << 1);
outr = outr + temp1;
outi = outi + temp2;
*out_ptr1-- = outi;
*out_ptr++ = outr;
for (i = 0; i < (npoints / 2 - 2); i++) {
sin = *cos_sin_ptr++;
cos = *cos_sin_ptr;
cos_sin_ptr += 15;
tempi = *spec_data1--;
tempr = *spec_data1--;
outi = ixheaacd_sub32(ixheaacd_mult32x16in32(tempr, sin),
ixheaacd_mult32x16in32(tempi, cos));
outr =
ixheaacd_mac32x16in32(ixheaacd_mult32x16in32(tempr, cos), tempi, sin);
temp1 = ixheaacd_mult32x16in32(outi, -(201 << 1));
temp2 = ixheaacd_mult32x16in32(outr, 201 << 1);
outr = outr + temp1;
outi = outi + temp2;
*out_ptr++ = outi;
*out_ptr1-- = outr;
i++;
tempr = *spec_data++;
tempi = *spec_data++;
outi = ixheaacd_sub32(ixheaacd_mult32x16in32(tempr, cos),
ixheaacd_mult32x16in32(tempi, sin));
outr =
ixheaacd_mac32x16in32(ixheaacd_mult32x16in32(tempr, sin), tempi, cos);
temp1 = ixheaacd_mult32x16in32(outi, -(201 << 1));
temp2 = ixheaacd_mult32x16in32(outr, 201 << 1);
outr = outr + temp1;
outi = outi + temp2;
*out_ptr1-- = outi;
*out_ptr++ = outr;
}
cos1 = *cos_sin_ptr++;
sin1 = *cos_sin_ptr;
tempi = *spec_data1--;
tempr = *spec_data1--;
outi = ixheaacd_sub32(ixheaacd_mult32x16in32(tempr, sin1),
ixheaacd_mult32x16in32(tempi, cos1));
outr =
ixheaacd_mac32x16in32(ixheaacd_mult32x16in32(tempr, cos1), tempi, sin1);
temp1 = ixheaacd_mult32x16in32(outi, -(201 << 1));
temp2 = ixheaacd_mult32x16in32(outr, 201 << 1);
outr = outr + temp1;
outi = outi + temp2;
*out_ptr++ = outi;
*out_ptr1-- = outr;
}
}
VOID ixheaacd_post_twid_overlap_add_dec(
WORD16 pcm_out[], WORD32 spec_data[],
ia_aac_dec_imdct_tables_struct *ptr_imdct_tables, WORD npoints,
WORD32 *ptr_overlap_buf, WORD16 q_shift, const WORD16 *window,
WORD16 ch_fac) {
WORD i;
WORD16 cos, cos1, sin, sin1;
WORD32 size = npoints / 2;
WORD16 *pcmout1 = pcm_out + (ch_fac * size);
const WORD16 *cos_sin_ptr = ptr_imdct_tables->cosine_array_2048_256;
pcm_out = pcmout1 - ch_fac;
spec_data += size;
if (q_shift > 0) {
WORD32 tempr, tempi, outr, outi, win1, accu, temp1, temp2;
WORD16 adjust, adjust1;
WORD32 overlap_data;
tempr = *(spec_data - size);
tempi = *(spec_data - size + 1);
adjust = 50;
adjust1 = -50;
cos = *cos_sin_ptr++;
sin = *cos_sin_ptr++;
outi = ixheaacd_sub32(ixheaacd_mult32x16in32(tempr, sin),
ixheaacd_mult32x16in32(tempi, cos));
outr = ixheaacd_add32(ixheaacd_mult32x16in32(tempr, cos),
ixheaacd_mult32x16in32(tempi, sin));
overlap_data = *ptr_overlap_buf;
temp1 = ixheaacd_mult32x16in32(outi, adjust1);
temp2 = ixheaacd_mult32x16in32(outr, adjust);
outr = outr + temp1;
outi = outi + temp2;
*ptr_overlap_buf++ = ixheaacd_shr32_drc(outr, 16 - q_shift);
win1 = *((WORD32 *)window + size - 1);
accu = ixheaacd_sub32_sat(
ixheaacd_shl32_sat(ixheaacd_mult32x16lin32(outi, win1), q_shift),
ixheaacd_mult32x16lin32_drc(overlap_data, (WORD16)(win1 >> 16)));
*pcm_out = ixheaacd_round16(ixheaacd_shl32_sat(accu, 2));
pcm_out -= ch_fac;
accu = ixheaacd_sub32_sat(
ixheaacd_shl32_sat(
ixheaacd_mult32x16hin32_drc(ixheaacd_negate32(outi), win1),
q_shift),
ixheaacd_mult32x16lin32_drc(overlap_data, (WORD16)(win1)));
*pcmout1 = ixheaacd_round16(ixheaacd_shl32_sat(accu, 2));
pcmout1 += ch_fac;
for (i = size - 2; i != 0;) {
sin = *cos_sin_ptr++;
cos = *cos_sin_ptr++;
tempr = *(spec_data + i);
tempi = *(spec_data + i + 1);
outr = ixheaacd_add32(ixheaacd_mult32x16in32(tempr, cos),
ixheaacd_mult32x16in32(tempi, sin));
outi = ixheaacd_sub32(ixheaacd_mult32x16in32(tempr, sin),
ixheaacd_mult32x16in32(tempi, cos));
temp1 = ixheaacd_mult32x16in32(outi, adjust1);
temp2 = ixheaacd_mult32x16in32(outr, adjust);
outr = outr + temp1;
outi = outi + temp2;
overlap_data = *ptr_overlap_buf;
*ptr_overlap_buf++ = ixheaacd_shr32_drc(outi, 16 - q_shift);
win1 = *((WORD32 *)window + i);
accu = ixheaacd_sub32_sat(
ixheaacd_shl32_sat(ixheaacd_mult32x16lin32(outr, win1), q_shift),
ixheaacd_mult32x16lin32_drc(overlap_data, (WORD16)(win1 >> 16)));
*pcm_out = ixheaacd_round16(ixheaacd_shl32_sat(accu, 2));
pcm_out -= ch_fac;
accu = ixheaacd_sub32_sat(
ixheaacd_shl32_sat(
ixheaacd_mult32x16hin32_drc(ixheaacd_negate32(outr), win1),
q_shift),
ixheaacd_mult32x16lin32_drc(overlap_data, (WORD16)win1));
*pcmout1 = ixheaacd_round16(ixheaacd_shl32_sat(accu, 2));
pcmout1 += ch_fac;
tempr = *(spec_data - i);
tempi = *(spec_data - i + 1);
i -= 2;
outi = ixheaacd_sub32(ixheaacd_mult32x16in32(tempr, cos),
ixheaacd_mult32x16in32(tempi, sin));
outr = ixheaacd_add32(ixheaacd_mult32x16in32(tempr, sin),
ixheaacd_mult32x16in32(tempi, cos));
overlap_data = *ptr_overlap_buf;
temp1 = ixheaacd_mult32x16in32(outi, adjust1);
temp2 = ixheaacd_mult32x16in32(outr, adjust);
outr = outr + temp1;
outi = outi + temp2;
*ptr_overlap_buf++ = ixheaacd_shr32_drc(outr, 16 - q_shift);
win1 = *((WORD32 *)window + i + 1);
accu = ixheaacd_sub32_sat(
ixheaacd_shl32_sat(ixheaacd_mult32x16lin32(outi, win1), q_shift),
ixheaacd_mult32x16lin32_drc(overlap_data, (WORD16)(win1 >> 16)));
*pcm_out = ixheaacd_round16(ixheaacd_shl32_sat(accu, 2));
pcm_out -= ch_fac;
accu = ixheaacd_sub32_sat(
ixheaacd_shl32_sat(
ixheaacd_mult32x16hin32_drc(ixheaacd_negate32(outi), win1),
q_shift),
ixheaacd_mult32x16lin32_drc(overlap_data, (WORD16)(win1)));
*pcmout1 = ixheaacd_round16(ixheaacd_shl32_sat(accu, 2));
pcmout1 += ch_fac;
}
cos1 = *cos_sin_ptr++;
sin1 = *cos_sin_ptr;
tempr = *(spec_data + i);
tempi = *(spec_data + i + 1);
outr = ixheaacd_add32(ixheaacd_mult32x16in32(tempr, cos1),
ixheaacd_mult32x16in32(tempi, sin1));
outi = ixheaacd_sub32(ixheaacd_mult32x16in32(tempr, sin1),
ixheaacd_mult32x16in32(tempi, cos1));
temp1 = ixheaacd_mult32x16in32(outi, adjust1);
temp2 = ixheaacd_mult32x16in32(outr, adjust);
outr = outr + temp1;
outi = outi + temp2;
overlap_data = *ptr_overlap_buf;
*ptr_overlap_buf++ = ixheaacd_shr32_drc(outi, 16 - q_shift);
win1 = *((WORD32 *)window + i);
accu = ixheaacd_sub32_sat(
ixheaacd_shl32_sat(ixheaacd_mult32x16lin32(outr, win1), q_shift),
ixheaacd_mult32x16lin32_drc(overlap_data, (WORD16)(win1 >> 16)));
*pcm_out = ixheaacd_round16(ixheaacd_shl32_sat(accu, 2));
pcm_out -= ch_fac;
accu = ixheaacd_sub32_sat(
ixheaacd_shl32_sat(
ixheaacd_mult32x16hin32_drc(ixheaacd_negate32(outr), win1),
q_shift),
ixheaacd_mult32x16lin32_drc(overlap_data, (WORD16)win1));
*pcmout1 = ixheaacd_round16(ixheaacd_shl32_sat(accu, 2));
pcmout1 += ch_fac;
} else {
q_shift = -q_shift;
{
WORD32 tempr, tempi, temp1, temp2, outr, outi, win1, accu;
WORD16 adjust, adjust1;
WORD16 overlap_data;
tempr = *(spec_data - size);
tempi = *(spec_data - size + 1);
adjust = 50;
adjust1 = -50;
cos = *cos_sin_ptr++;
sin = *cos_sin_ptr++;
outi = ixheaacd_sub32(ixheaacd_mult32x16in32(tempr, sin),
ixheaacd_mult32x16in32(tempi, cos));
outr = ixheaacd_add32(ixheaacd_mult32x16in32(tempr, cos),
ixheaacd_mult32x16in32(tempi, sin));
overlap_data = *ptr_overlap_buf;
temp1 = ixheaacd_mult32x16in32(outi, adjust1);
temp2 = ixheaacd_mult32x16in32(outr, adjust);
outr = outr + temp1;
outi = outi + temp2;
*ptr_overlap_buf++ = ixheaacd_shr32_drc(outr, 16 + q_shift);
win1 = *((WORD32 *)window + size - 1);
accu = ixheaacd_sub32_sat(
ixheaacd_shr32(ixheaacd_mult32x16lin32(outi, win1), q_shift),
ixheaacd_mult32x16lin32_drc(overlap_data, (WORD16)(win1 >> 16)));
*pcm_out = ixheaacd_round16(ixheaacd_shl32_sat(accu, 2));
pcm_out -= ch_fac;
accu = ixheaacd_sub32_sat(
ixheaacd_shr32(
ixheaacd_mult32x16hin32_drc(ixheaacd_negate32(outi), win1),
q_shift),
ixheaacd_mult32x16lin32_drc(overlap_data, (WORD16)(win1)));
*pcmout1 = ixheaacd_round16(ixheaacd_shl32_sat(accu, 2));
pcmout1 += ch_fac;
for (i = size - 2; i != 0;) {
sin = *cos_sin_ptr++;
cos = *cos_sin_ptr++;
tempr = *(spec_data + i);
tempi = *(spec_data + i + 1);
outr = ixheaacd_add32(ixheaacd_mult32x16in32(tempr, cos),
ixheaacd_mult32x16in32(tempi, sin));
outi = ixheaacd_sub32(ixheaacd_mult32x16in32(tempr, sin),
ixheaacd_mult32x16in32(tempi, cos));
overlap_data = *ptr_overlap_buf;
temp1 = ixheaacd_mult32x16in32(outi, adjust1);
temp2 = ixheaacd_mult32x16in32(outr, adjust);
outr = outr + temp1;
outi = outi + temp2;
*ptr_overlap_buf++ = ixheaacd_shr32_drc(outi, 16 + q_shift);
win1 = *((WORD32 *)window + i);
accu = ixheaacd_sub32_sat(
ixheaacd_shr32(ixheaacd_mult32x16lin32(outr, win1), q_shift),
ixheaacd_mult32x16lin32_drc(overlap_data, (WORD16)(win1 >> 16)));
*pcm_out = ixheaacd_round16(ixheaacd_shl32_sat(accu, 2));
pcm_out -= ch_fac;
accu = ixheaacd_sub32_sat(
ixheaacd_shr32(
ixheaacd_mult32x16hin32_drc(ixheaacd_negate32(outr), win1),
q_shift),
ixheaacd_mult32x16lin32_drc(overlap_data, (WORD16)win1));
*pcmout1 = ixheaacd_round16(ixheaacd_shl32_sat(accu, 2));
pcmout1 += ch_fac;
tempr = *(spec_data - i);
tempi = *(spec_data - i + 1);
i -= 2;
outi = ixheaacd_sub32(ixheaacd_mult32x16in32(tempr, cos),
ixheaacd_mult32x16in32(tempi, sin));
outr = ixheaacd_add32(ixheaacd_mult32x16in32(tempr, sin),
ixheaacd_mult32x16in32(tempi, cos));
overlap_data = *ptr_overlap_buf;
temp1 = ixheaacd_mult32x16in32(outi, adjust1);
temp2 = ixheaacd_mult32x16in32(outr, adjust);
outr = outr + temp1;
outi = outi + temp2;
*ptr_overlap_buf++ = ixheaacd_shr32_drc(outr, 16 + q_shift);
win1 = *((WORD32 *)window + i + 1);
accu = ixheaacd_sub32_sat(
ixheaacd_shr32(ixheaacd_mult32x16lin32(outi, win1), q_shift),
ixheaacd_mult32x16lin32_drc(overlap_data, (WORD16)(win1 >> 16)));
*pcm_out = ixheaacd_round16(ixheaacd_shl32_sat(accu, 2));
pcm_out -= ch_fac;
accu = ixheaacd_sub32_sat(
ixheaacd_shr32(
ixheaacd_mult32x16hin32_drc(ixheaacd_negate32(outi), win1),
q_shift),
ixheaacd_mult32x16lin32_drc(overlap_data, (WORD16)(win1)));
*pcmout1 = ixheaacd_round16(ixheaacd_shl32_sat(accu, 2));
pcmout1 += ch_fac;
}
cos1 = *cos_sin_ptr++;
sin1 = *cos_sin_ptr++;
tempr = *(spec_data + i);
tempi = *(spec_data + i + 1);
outr = ixheaacd_add32(ixheaacd_mult32x16in32(tempr, cos1),
ixheaacd_mult32x16in32(tempi, sin1));
outi = ixheaacd_sub32(ixheaacd_mult32x16in32(tempr, sin1),
ixheaacd_mult32x16in32(tempi, cos1));
overlap_data = *ptr_overlap_buf;
temp1 = ixheaacd_mult32x16in32(outi, adjust1);
temp2 = ixheaacd_mult32x16in32(outr, adjust);
outr = outr + temp1;
outi = outi + temp2;
*ptr_overlap_buf++ = ixheaacd_shr32_drc(outi, 16 + q_shift);
win1 = *((WORD32 *)window + i);
accu = ixheaacd_sub32_sat(
ixheaacd_shr32(ixheaacd_mult32x16lin32(outr, win1), q_shift),
ixheaacd_mult32x16lin32_drc(overlap_data, (WORD16)(win1 >> 16)));
*pcm_out = ixheaacd_round16(ixheaacd_shl32_sat(accu, 2));
pcm_out -= ch_fac;
accu = ixheaacd_sub32_sat(
ixheaacd_shr32(
ixheaacd_mult32x16hin32_drc(ixheaacd_negate32(outr), win1),
q_shift),
ixheaacd_mult32x16lin32_drc(overlap_data, (WORD16)win1));
*pcmout1 = ixheaacd_round16(ixheaacd_shl32_sat(accu, 2));
pcmout1 += ch_fac;
}
}
}
VOID ixheaacd_imdct_using_fft_dec(
ia_aac_dec_imdct_tables_struct *ptr_imdct_tables, WORD32 npoints,
WORD32 *ptr_x, WORD32 *ptr_y)
{
WORD32 i, j, k, k1, n_stages;
WORD32 x0r, x0i, x1r, x1i, x2r, x2i, x3r, x3i, x4r, x4i, x5r, x5i, x6r, x6i,
x7r, x7i;
WORD32 del, nodespacing, in_loop_cnt, tmp, twiddle_val, *ptr_tmp;
const WORD32 *ptr_twiddle;
WORD8 *ptr_dig_rev_table;
n_stages = ixheaacd_norm32(npoints);
n_stages = (30 - n_stages) / 3;
ptr_tmp = ptr_y;
ptr_twiddle = ptr_imdct_tables->fft_twiddle;
ptr_dig_rev_table = ((npoints << 1) == 1024)
? ptr_imdct_tables->dig_rev_table8_long
: ptr_imdct_tables->dig_rev_table8_short;
for (i = npoints; i != 0; i -= 8) {
WORD32 *data = ptr_x;
data = data + (*ptr_dig_rev_table++ << 1);
x0r = *data;
x0i = *(data + 1);
data += (npoints >> 1);
x2r = *data;
x2i = *(data + 1);
data += (npoints >> 1);
x4r = *data;
x4i = *(data + 1);
data += (npoints >> 1);
x6r = *data;
x6i = *(data + 1);
data -= 5 * (npoints >> 2);
x0r = x0r + x4r;
x0i = x0i + x4i;
x4r = x0r - (x4r << 1);
x4i = x0i - (x4i << 1);
x2r = x2r + x6r;
x2i = x2i + x6i;
x6r = x2r - (x6r << 1);
x6i = x2i - (x6i << 1);
x0r = x0r + x2r;
x0i = x0i + x2i;
x2r = x0r - (x2r << 1);
x2i = x0i - (x2i << 1);
x4r = x4r + x6i;
x4i = x4i - x6r;
tmp = x6r;
x6r = x4r - (x6i << 1);
x6i = x4i + (tmp << 1);
x1r = *data;
x1i = *(data + 1);
data += (npoints >> 1);
x3r = *data;
x3i = *(data + 1);
data += (npoints >> 1);
x5r = *data;
x5i = *(data + 1);
data += (npoints >> 1);
x7r = *data;
x7i = *(data + 1);
data -= 7 * (npoints >> 2);
x1r = x1r + x5r;
x1i = x1i + x5i;
x5r = x1r - (x5r << 1);
x5i = x1i - (x5i << 1);
x3r = x3r + x7r;
x3i = x3i + x7i;
x7r = x3r - (x7r << 1);
x7i = x3i - (x7i << 1);
x1r = x1r + x3r;
x1i = x1i + x3i;
x3r = x1r - (x3r << 1);
x3i = x1i - (x3i << 1);
x5r = x5r + x5i;
x5i = x5r - (x5i << 1);
x7r = x7r + x7i;
x7i = x7r - (x7i << 1);
x7i = x5r - x7i;
x5r = x7i - (x5r << 1);
x5i = x7r - x5i;
x7r = x5i - (x7r << 1);
x7i = x7i << 1;
x5r = x5r << 1;
x5i = x5i << 1;
x7r = x7r << 1;
x0r = x0r + x1r;
x0i = x0i + x1i;
x1r = x0r - (x1r << 1);
x1i = x0i - (x1i << 1);
x2r = x2r + x3i;
tmp = x2r - (x3i << 1);
x2i = x2i - x3r;
x3i = x2i + (x3r << 1);
*ptr_tmp = x0r;
*(ptr_tmp + 1) = x0i;
ptr_tmp += 4;
*ptr_tmp = x2r;
*(ptr_tmp + 1) = x2i;
ptr_tmp += 4;
*ptr_tmp = x1r;
*(ptr_tmp + 1) = x1i;
ptr_tmp += 4;
*ptr_tmp = tmp;
*(ptr_tmp + 1) = x3i;
ptr_tmp -= 10;
tmp = 0x5A82;
x7i = x4r + (ixheaacd_mult32x16lin32(x7i, tmp));
x4r = x7i - (x4r << 1);
x7r = x4i + (ixheaacd_mult32x16lin32(x7r, tmp));
x4i = x7r - (x4i << 1);
x5i = x6r + (ixheaacd_mult32x16lin32(x5i, tmp));
x6r = x5i - (x6r << 1);
x5r = x6i + (ixheaacd_mult32x16lin32(x5r, tmp));
x6i = x5r - (x6i << 1);
*ptr_tmp = x7i;
*(ptr_tmp + 1) = x7r;
ptr_tmp += 4;
*ptr_tmp = x5i;
*(ptr_tmp + 1) = x5r;
ptr_tmp += 4;
*ptr_tmp = -x4r;
*(ptr_tmp + 1) = -x4i;
ptr_tmp += 4;
*ptr_tmp = -x6r;
*(ptr_tmp + 1) = -x6i;
ptr_tmp += 2;
}
del = 8;
nodespacing = 64;
in_loop_cnt = npoints >> 6;
for (k1 = n_stages - 2; k1 > 0; k1--) {
WORD32 *data = ptr_y;
const WORD32 *twiddles;
for (i = 0; i != npoints; i += 8 * del) {
data = ptr_y + (i << 1);
x0r = *data;
x0i = *(data + 1);
data += (del << 2);
x2r = *data;
x2i = *(data + 1);
data += (del << 2);
x4r = *data;
x4i = *(data + 1);
data += (del << 2);
x6r = *data;
x6i = *(data + 1);
data -= 5 * (del << 1);
x0r = x0r + x4r;
x0i = x0i + x4i;
x4r = x0r - (x4r << 1);
x4i = x0i - (x4i << 1);
x2r = x2r + x6r;
x2i = x2i + x6i;
x6r = x2r - (x6r << 1);
x6i = x2i - (x6i << 1);
x0r = x0r + x2r;
x0i = x0i + x2i;
x2r = x0r - (x2r << 1);
x2i = x0i - (x2i << 1);
x4r = x4r + x6i;
x4i = x4i - x6r;
tmp = x6r;
x6r = x4r - (x6i << 1);
x6i = x4i + (tmp << 1);
x1r = *data;
x1i = *(data + 1);
data += (del << 2);
x3r = *data;
x3i = *(data + 1);
data += (del << 2);
x5r = *data;
x5i = *(data + 1);
data += (del << 2);
x7r = *data;
x7i = *(data + 1);
data -= 7 * (del << 1);
x1r = x1r + x5r;
x1i = x1i + x5i;
x5r = x1r - (x5r << 1);
x5i = x1i - (x5i << 1);
x3r = x3r + x7r;
x3i = x3i + x7i;
x7r = x3r - (x7r << 1);
x7i = x3i - (x7i << 1);
x1r = x1r + x3r;
x1i = x1i + x3i;
x3r = x1r - (x3r << 1);
x3i = x1i - (x3i << 1);
x5r = x5r + x5i;
x5i = x5r - (x5i << 1);
x7r = x7r + x7i;
x7i = x7r - (x7i << 1);
x7i = x5r - x7i;
x5r = x7i - (x5r << 1);
x5i = x7r - x5i;
x7r = x5i - (x7r << 1);
x7i = x7i << 1;
x5r = x5r << 1;
x5i = x5i << 1;
x7r = x7r << 1;
x0r = x0r + x1r;
x0i = x0i + x1i;
x1r = x0r - (x1r << 1);
x1i = x0i - (x1i << 1);
x2r = x2r + x3i;
tmp = x2r - (x3i << 1);
x2i = x2i - x3r;
x3i = x2i + (x3r << 1);
*data = x0r;
*(data + 1) = x0i;
data += (del << 2);
*data = x2r;
*(data + 1) = x2i;
data += (del << 2);
*data = x1r;
*(data + 1) = x1i;
data += (del << 2);
*data = tmp;
*(data + 1) = x3i;
data -= 5 * (del << 1);
tmp = 0x5A82;
x7i = x4r + (ixheaacd_mult32x16lin32(x7i, tmp));
x4r = x7i - (x4r << 1);
x7r = x4i + (ixheaacd_mult32x16lin32(x7r, tmp));
x4i = x7r - (x4i << 1);
x5i = x6r + (ixheaacd_mult32x16lin32(x5i, tmp));
x6r = x5i - (x6r << 1);
x5r = x6i + (ixheaacd_mult32x16lin32(x5r, tmp));
x6i = x5r - (x6i << 1);
*data = x7i;
*(data + 1) = x7r;
data += (del << 2);
*data = x5i;
*(data + 1) = x5r;
data += (del << 2);
*data = -x4r;
*(data + 1) = -x4i;
data += (del << 2);
*data = -x6r;
*(data + 1) = -x6i;
data -= 7 * (del << 1);
}
twiddles = ptr_twiddle;
data = ptr_y;
for (j = nodespacing; j < nodespacing * del; j += nodespacing) {
data = data + 2;
for (k = in_loop_cnt; k != 0; k--) {
data += (del << 2);
x2r = *data;
x2i = *(data + 1);
data += (del << 2);
x4r = *data;
x4i = *(data + 1);
data += (del << 2);
x6r = *data;
x6i = *(data + 1);
data -= 6 * (del << 1);
twiddles += (j >> 2);
twiddle_val = *(twiddles);
tmp = (ixheaacd_mult32x16lin32(x2r, twiddle_val) -
ixheaacd_mult32x16hin32_drc(x2i, twiddle_val));
x2i = (ixheaacd_mac32x16lin32(
ixheaacd_mult32x16hin32_drc(x2r, twiddle_val), x2i,
twiddle_val))
<< 1;
x2r = tmp << 1;
twiddles += (j >> 2);
twiddle_val = *(twiddles);
tmp = (ixheaacd_mult32x16lin32(x4r, twiddle_val) -
ixheaacd_mult32x16hin32_drc(x4i, twiddle_val));
x4i = (ixheaacd_mac32x16lin32(
ixheaacd_mult32x16hin32_drc(x4r, twiddle_val), x4i,
twiddle_val))
<< 1;
x4r = tmp << 1;
twiddles += (j >> 2);
twiddle_val = *(twiddles);
tmp = (ixheaacd_mult32x16lin32(x6r, twiddle_val) -
ixheaacd_mult32x16hin32_drc(x6i, twiddle_val));
x6i = (ixheaacd_mac32x16lin32(
ixheaacd_mult32x16hin32_drc(x6r, twiddle_val), x6i,
twiddle_val))
<< 1;
x6r = tmp << 1;
x0r = *data;
x0i = *(data + 1);
data += (del << 1);
x0r = x0r + x4r;
x0i = x0i + x4i;
x4r = x0r - (x4r << 1);
x4i = x0i - (x4i << 1);
x2r = x2r + x6r;
x2i = x2i + x6i;
x6r = x2r - (x6r << 1);
x6i = x2i - (x6i << 1);
x0r = x0r + x2r;
x0i = x0i + x2i;
x2r = x0r - (x2r << 1);
x2i = x0i - (x2i << 1);
x4r = x4r + x6i;
x4i = x4i - x6r;
tmp = x6r;
x6r = x4r - (x6i << 1);
x6i = x4i + (tmp << 1);
x1r = *data;
x1i = *(data + 1);
data += (del << 2);
twiddles -= 5 * (j >> 3);
twiddle_val = *(twiddles);
tmp = (ixheaacd_mult32x16lin32(x1r, twiddle_val) -
ixheaacd_mult32x16hin32_drc(x1i, twiddle_val));
x1i = (ixheaacd_mac32x16lin32(
ixheaacd_mult32x16hin32_drc(x1r, twiddle_val), x1i,
twiddle_val))
<< 1;
x1r = tmp << 1;
x3r = *data;
x3i = *(data + 1);
data += (del << 2);
twiddles += (j >> 2);
twiddle_val = *(twiddles);
tmp = (ixheaacd_mult32x16lin32(x3r, twiddle_val) -
ixheaacd_mult32x16hin32_drc(x3i, twiddle_val));
x3i = (ixheaacd_mac32x16lin32(
ixheaacd_mult32x16hin32_drc(x3r, twiddle_val), x3i, twiddle_val));
x3r = tmp;
x5r = *data;
x5i = *(data + 1);
data += (del << 2);
twiddles += (j >> 2);
twiddle_val = *(twiddles);
tmp = (ixheaacd_mult32x16lin32(x5r, twiddle_val) -
ixheaacd_mult32x16hin32_drc(x5i, twiddle_val));
x5i = (ixheaacd_mac32x16lin32(
ixheaacd_mult32x16hin32_drc(x5r, twiddle_val), x5i, twiddle_val));
x5r = tmp;
x7r = *data;
x7i = *(data + 1);
data -= 7 * (del << 1);
twiddles += (j >> 2);
twiddle_val = *(twiddles);
twiddles -= 7 * (j >> 3);
tmp = (ixheaacd_mult32x16lin32(x7r, twiddle_val) -
ixheaacd_mult32x16hin32_drc(x7i, twiddle_val));
x7i = (ixheaacd_mac32x16lin32(
ixheaacd_mult32x16hin32_drc(x7r, twiddle_val), x7i, twiddle_val));
x7r = tmp;
x1r = x1r + (x5r << 1);
x1i = x1i + (x5i << 1);
x5r = x1r - (x5r << 2);
x5i = x1i - (x5i << 2);
x3r = x3r + x7r;
x3i = x3i + x7i;
x7r = x3r - (x7r << 1);
x7i = x3i - (x7i << 1);
x1r = x1r + (x3r << 1);
x1i = x1i + (x3i << 1);
x3r = x1r - (x3r << 2);
x3i = x1i - (x3i << 2);
x5r = x5r + x5i;
x5i = x5r - (x5i << 1);
x7r = x7r + x7i;
x7i = x7r - (x7i << 1);
x7i = x5r - (x7i << 1);
x5r = x7i - (x5r << 1);
x5i = (x7r << 1) - x5i;
x7r = x5i - (x7r << 2);
x7i = x7i << 1;
x5r = x5r << 1;
x5i = x5i << 1;
x7r = x7r << 1;
x0r = x0r + x1r;
x0i = x0i + x1i;
x1r = x0r - (x1r << 1);
x1i = x0i - (x1i << 1);
x2r = x2r + x3i;
tmp = x2r - (x3i << 1);
x2i = x2i - x3r;
x3i = x2i + (x3r << 1);
*data = x0r;
*(data + 1) = x0i;
data += (del << 2);
*data = x2r;
*(data + 1) = x2i;
data += (del << 2);
*data = x1r;
*(data + 1) = x1i;
data += (del << 2);
*data = tmp;
*(data + 1) = x3i;
data -= 5 * (del << 1);
tmp = 0x5A82;
x7i = x4r + (ixheaacd_mult32x16lin32(x7i, tmp));
x4r = x7i - (x4r << 1);
x7r = x4i + (ixheaacd_mult32x16lin32(x7r, tmp));
x4i = x7r - (x4i << 1);
x5i = x6r + (ixheaacd_mult32x16lin32(x5i, tmp));
x6r = x5i - (x6r << 1);
x5r = x6i + (ixheaacd_mult32x16lin32(x5r, tmp));
x6i = x5r - (x6i << 1);
*data = x7i;
*(data + 1) = x7r;
data += (del << 2);
*data = x5i;
*(data + 1) = x5r;
data += (del << 2);
*data = -x4r;
*(data + 1) = -x4i;
data += (del << 2);
*data = -x6r;
*(data + 1) = -x6i;
data -= 7 * (del << 1);
data += (del << 4);
}
data -= npoints << 1;
}
nodespacing >>= 3;
del <<= 3;
in_loop_cnt >>= 3;
}
{
WORD32 *data = ptr_y;
const WORD32 *twiddles;
twiddles = ptr_twiddle;
data = ptr_y;
data = data - 2;
for (j = 0; j < nodespacing * del; j += nodespacing) {
data = data + 2;
{
data += (del << 2);
x2r = *data;
x2i = *(data + 1);
data += (del << 2);
x4r = *data;
x4i = *(data + 1);
data += (del << 2);
x6r = *data;
x6i = *(data + 1);
data -= 6 * (del << 1);
twiddles += (j >> 2);
twiddle_val = *(twiddles);
tmp = (ixheaacd_mult32x16lin32(x2r, twiddle_val) -
ixheaacd_mult32x16hin32_drc(x2i, twiddle_val));
x2i = (ixheaacd_mac32x16lin32(
ixheaacd_mult32x16hin32_drc(x2r, twiddle_val), x2i,
twiddle_val))
<< 1;
x2r = tmp << 1;
twiddles += (j >> 2);
twiddle_val = *(twiddles);
tmp = (ixheaacd_mult32x16lin32(x4r, twiddle_val) -
ixheaacd_mult32x16hin32_drc(x4i, twiddle_val));
x4i = (ixheaacd_mac32x16lin32(
ixheaacd_mult32x16hin32_drc(x4r, twiddle_val), x4i,
twiddle_val))
<< 1;
x4r = tmp << 1;
twiddles += (j >> 2);
twiddle_val = *(twiddles);
tmp = (ixheaacd_mult32x16lin32(x6r, twiddle_val) -
ixheaacd_mult32x16hin32_drc(x6i, twiddle_val));
x6i = (ixheaacd_mac32x16lin32(
ixheaacd_mult32x16hin32_drc(x6r, twiddle_val), x6i,
twiddle_val))
<< 1;
x6r = tmp << 1;
x0r = *data;
x0i = *(data + 1);
data += (del << 1);
x0r = x0r + x4r;
x0i = x0i + x4i;
x4r = x0r - (x4r << 1);
x4i = x0i - (x4i << 1);
x2r = x2r + x6r;
x2i = x2i + x6i;
x6r = x2r - (x6r << 1);
x6i = x2i - (x6i << 1);
x0r = x0r + x2r;
x0i = x0i + x2i;
x2r = x0r - (x2r << 1);
x2i = x0i - (x2i << 1);
x4r = x4r + x6i;
x4i = x4i - x6r;
tmp = x6r;
x6r = x4r - (x6i << 1);
x6i = x4i + (tmp << 1);
x1r = *data;
x1i = *(data + 1);
data += (del << 2);
twiddles -= 5 * (j >> 3);
twiddle_val = *(twiddles);
tmp = (ixheaacd_mult32x16lin32(x1r, twiddle_val) -
ixheaacd_mult32x16hin32_drc(x1i, twiddle_val));
x1i = (ixheaacd_mac32x16lin32(
ixheaacd_mult32x16hin32_drc(x1r, twiddle_val), x1i,
twiddle_val))
<< 1;
x1r = tmp << 1;
x3r = *data;
x3i = *(data + 1);
data += (del << 2);
twiddles += (j >> 2);
twiddle_val = *(twiddles);
tmp = (ixheaacd_mult32x16lin32(x3r, twiddle_val) -
ixheaacd_mult32x16hin32_drc(x3i, twiddle_val));
x3i = (ixheaacd_mac32x16lin32(
ixheaacd_mult32x16hin32_drc(x3r, twiddle_val), x3i, twiddle_val));
x3r = tmp;
x5r = *data;
x5i = *(data + 1);
data += (del << 2);
twiddles += (j >> 2);
twiddle_val = *(twiddles);
tmp = (ixheaacd_mult32x16lin32(x5r, twiddle_val) -
ixheaacd_mult32x16hin32_drc(x5i, twiddle_val));
x5i = (ixheaacd_mac32x16lin32(
ixheaacd_mult32x16hin32_drc(x5r, twiddle_val), x5i, twiddle_val));
x5r = tmp;
x7r = *data;
x7i = *(data + 1);
data -= 7 * (del << 1);
twiddles += (j >> 2);
twiddle_val = *(twiddles);
twiddles -= 7 * (j >> 3);
tmp = (ixheaacd_mult32x16lin32(x7r, twiddle_val) -
ixheaacd_mult32x16hin32_drc(x7i, twiddle_val));
x7i = (ixheaacd_mac32x16lin32(
ixheaacd_mult32x16hin32_drc(x7r, twiddle_val), x7i, twiddle_val));
x7r = tmp;
x1r = x1r + (x5r << 1);
x1i = x1i + (x5i << 1);
x5r = x1r - (x5r << 2);
x5i = x1i - (x5i << 2);
x3r = x3r + x7r;
x3i = x3i + x7i;
x7r = x3r - (x7r << 1);
x7i = x3i - (x7i << 1);
x1r = x1r + (x3r << 1);
x1i = x1i + (x3i << 1);
x3r = x1r - (x3r << 2);
x3i = x1i - (x3i << 2);
x5r = x5r + x5i;
x5i = x5r - (x5i << 1);
x7r = x7r + x7i;
x7i = x7r - (x7i << 1);
x7i = x5r - (x7i << 1);
x5r = x7i - (x5r << 1);
x5i = (x7r << 1) - x5i;
x7r = x5i - (x7r << 2);
x7i = x7i << 1;
x5r = x5r << 1;
x5i = x5i << 1;
x7r = x7r << 1;
x0r = x0r + x1r;
x0i = x0i + x1i;
x1r = x0r - (x1r << 1);
x1i = x0i - (x1i << 1);
x2r = x2r + x3i;
tmp = x2r - (x3i << 1);
x2i = x2i - x3r;
x3i = x2i + (x3r << 1);
*data = x0r;
*(data + 1) = x0i;
data += (del << 2);
*data = x2r;
*(data + 1) = x2i;
data += (del << 2);
*data = x1r;
*(data + 1) = x1i;
data += (del << 2);
*data = tmp;
*(data + 1) = x3i;
data -= 5 * (del << 1);
tmp = 0x5A82;
x7i = x4r + (ixheaacd_mult32x16lin32(x7i, tmp));
x4r = x7i - (x4r << 1);
x7r = x4i + (ixheaacd_mult32x16lin32(x7r, tmp));
x4i = x7r - (x4i << 1);
x5i = x6r + (ixheaacd_mult32x16lin32(x5i, tmp));
x6r = x5i - (x6r << 1);
x5r = x6i + (ixheaacd_mult32x16lin32(x5r, tmp));
x6i = x5r - (x6i << 1);
*data = x7i;
*(data + 1) = x7r;
data += (del << 2);
*data = x5i;
*(data + 1) = x5r;
data += (del << 2);
*data = -x4r;
*(data + 1) = -x4i;
data += (del << 2);
*data = -x6r;
*(data + 1) = -x6i;
data -= 7 * (del << 1);
data += (del << 4);
}
data -= npoints << 1;
}
nodespacing >>= 3;
del <<= 3;
in_loop_cnt >>= 3;
}
}
WORD32 ixheaacd_inverse_transform(
WORD32 spec_data[], WORD32 scratch[],
ia_aac_dec_imdct_tables_struct *ptr_imdct_tables, WORD32 expo,
WORD32 npoints) {
(*ixheaacd_pretwiddle_compute)(spec_data, spec_data + npoints - 1, scratch,
ptr_imdct_tables, (npoints >> 2), expo);
(*ixheaacd_imdct_using_fft)(ptr_imdct_tables, npoints >> 1, scratch,
spec_data);
expo += 2;
return expo;
}
VOID ixheaacd_mdct_480_ld(WORD32 *inp, WORD32 *scratch, WORD32 *mdct_scale,
WORD32 mdct_flag,
ia_aac_dec_imdct_tables_struct *imdct_tables_ptr,
WORD32 object_type) {
WORD32 expo, neg_expo = 0, k;
WORD32 const_mltfac = 1145324612;
expo = (*ixheaacd_calc_max_spectral_line)(inp, MDCT_LEN) - 1;
;
memcpy(scratch, inp, sizeof(WORD32) * MDCT_LEN);
neg_expo = 7 - expo;
ixheaacd_pre_twiddle(inp, scratch, 480, imdct_tables_ptr->cosine_array_960,
neg_expo);
ixheaacd_fft_480_ld(inp, scratch, imdct_tables_ptr);
if (object_type == AOT_ER_AAC_LD) {
ixheaacd_post_twiddle_ld(inp, scratch, imdct_tables_ptr->cosine_array_960,
480);
} else if (object_type == AOT_ER_AAC_ELD) {
ixheaacd_post_twiddle_eld(inp + (480), scratch,
imdct_tables_ptr->cosine_array_960, 480);
}
if (0 == mdct_flag) {
WORD32 *data = inp;
if (object_type != AOT_ER_AAC_ELD) {
for (k = MDCT_LEN - 1; k >= 0; k -= 2) {
*data = ixheaacd_mult32_shl(*data, const_mltfac);
data++;
*data = ixheaacd_mult32_shl(*data, const_mltfac);
data++;
}
neg_expo += 1;
} else {
data = inp + 480;
for (k = (MDCT_LEN << 1) - 1; k >= 0; k -= 2) {
*data = ixheaacd_mult32_shl(*data, const_mltfac);
data++;
*data = ixheaacd_mult32_shl(*data, const_mltfac);
data++;
}
neg_expo += 1;
}
}
*mdct_scale = neg_expo + 3;
}
VOID ixheaacd_inverse_transform_512(
WORD32 data[], WORD32 temp[], WORD32 *imdct_scale, WORD32 *cos_sin_ptr,
ia_aac_dec_imdct_tables_struct *imdct_tables_ptr, WORD32 object_type) {
WORD32 n;
WORD32 npoints_2;
WORD16 expo, neg_expo;
n = 512;
npoints_2 = n >> 1;
expo = (*ixheaacd_calc_max_spectral_line)(data, n) - 1;
memcpy(temp, data, sizeof(WORD32) * n);
neg_expo = 7 - expo;
ixheaacd_pre_twiddle(data, temp, n, cos_sin_ptr, neg_expo);
(*ixheaacd_fft32x32_ld)(imdct_tables_ptr, npoints_2, data, temp);
neg_expo = (*ixheaacd_neg_expo_inc)(neg_expo);
*imdct_scale = neg_expo + 1;
if (object_type == AOT_ER_AAC_ELD)
ixheaacd_post_twiddle_eld((data + n), temp, cos_sin_ptr, n);
else
ixheaacd_post_twiddle_ld((data), temp, cos_sin_ptr, n);
}
VOID ixheaacd_fft_480_ld(WORD32 *inp, WORD32 *op,
ia_aac_dec_imdct_tables_struct *imdct_tables_ptr) {
WORD32 i;
WORD32 *buf1, *buf2;
UWORD8 *re_arr_tab_sml_240_ptr;
(*ixheaacd_aac_ld_dec_rearrange)(inp, op, MDCT_LEN_BY2,
imdct_tables_ptr->re_arr_tab_16);
buf1 = op;
buf2 = inp;
for (i = 0; i < FFT15; i++) {
(*ixheaacd_fft32x32_ld2)(imdct_tables_ptr, 16, buf1, buf2);
buf1 += (FFT16X2);
buf2 += (FFT16X2);
}
re_arr_tab_sml_240_ptr = imdct_tables_ptr->re_arr_tab_sml_240;
buf1 = inp;
for (i = 0; i < FFT16; i++) {
(*ixheaacd_fft_15_ld)(buf1, op, ixheaacd_fft5out, re_arr_tab_sml_240_ptr);
re_arr_tab_sml_240_ptr += FFT15;
buf1 += 2;
}
}
VOID ixheaacd_pre_twiddle(WORD32 *xptr, WORD32 *data, WORD32 n,
WORD32 *cos_sin_ptr, WORD32 neg_expo) {
WORD npoints_4, i;
WORD32 tempr, tempi, temp;
WORD32 c, c1, s, s1;
WORD32 *in_ptr1, *in_ptr2;
npoints_4 = n >> 2;
in_ptr1 = data;
in_ptr2 = data + n - 1;
if (neg_expo >= 0) {
for (i = npoints_4 - 1; i >= 0; i--) {
c = *cos_sin_ptr++;
c1 = *cos_sin_ptr++;
s = *cos_sin_ptr++;
s1 = *cos_sin_ptr++;
tempr = *in_ptr1;
tempi = *in_ptr2;
in_ptr1 += 2;
in_ptr2 -= 2;
temp =
-ixheaacd_add32(ixheaacd_mult32(tempr, c), ixheaacd_mult32(tempi, s));
*xptr++ = ixheaacd_shr32(temp, neg_expo);
temp =
ixheaacd_sub32(ixheaacd_mult32(tempr, s), ixheaacd_mult32(tempi, c));
*xptr++ = ixheaacd_shr32(temp, neg_expo);
tempr = *in_ptr1;
tempi = *in_ptr2;
in_ptr1 += 2;
in_ptr2 -= 2;
temp = -ixheaacd_add32(ixheaacd_mult32(tempr, c1),
ixheaacd_mult32(tempi, s1));
*xptr++ = ixheaacd_shr32(temp, neg_expo);
temp = ixheaacd_sub32(ixheaacd_mult32(tempr, s1),
ixheaacd_mult32(tempi, c1));
*xptr++ = ixheaacd_shr32(temp, neg_expo);
}
} else {
neg_expo = -neg_expo;
for (i = npoints_4 - 1; i >= 0; i--) {
c = *cos_sin_ptr++;
c1 = *cos_sin_ptr++;
s = *cos_sin_ptr++;
s1 = *cos_sin_ptr++;
tempr = *in_ptr1;
tempi = *in_ptr2;
in_ptr1 += 2;
in_ptr2 -= 2;
temp =
-ixheaacd_add32(ixheaacd_mult32(tempr, c), ixheaacd_mult32(tempi, s));
*xptr++ = ixheaacd_shl32(temp, neg_expo);
temp =
ixheaacd_sub32(ixheaacd_mult32(tempr, s), ixheaacd_mult32(tempi, c));
*xptr++ = ixheaacd_shl32(temp, neg_expo);
tempr = *in_ptr1;
tempi = *in_ptr2;
in_ptr1 += 2;
in_ptr2 -= 2;
temp = -ixheaacd_add32(ixheaacd_mult32(tempr, c1),
ixheaacd_mult32(tempi, s1));
*xptr++ = ixheaacd_shl32(temp, neg_expo);
temp = ixheaacd_sub32(ixheaacd_mult32(tempr, s1),
ixheaacd_mult32(tempi, c1));
*xptr++ = ixheaacd_shl32(temp, neg_expo);
}
}
}
VOID ixheaacd_post_twiddle_ld(WORD32 out[], WORD32 x[],
const WORD32 *cos_sin_ptr, WORD m) {
WORD i;
WORD32 *ptr_x = &x[0];
WORD32 *ptr_out, *ptr_out1;
ptr_out = &out[0];
ptr_out1 = &out[m - 1];
for (i = (m >> 2) - 1; i >= 0; i--) {
WORD32 c, c1, s, s1;
WORD32 re, im;
c = *cos_sin_ptr++;
c1 = *cos_sin_ptr++;
s = *cos_sin_ptr++;
s1 = *cos_sin_ptr++;
re = *ptr_x++;
im = *ptr_x++;
*ptr_out1 = ixheaacd_sub32(ixheaacd_mult32(im, c), ixheaacd_mult32(re, s));
*ptr_out = -ixheaacd_add32(ixheaacd_mult32(re, c), ixheaacd_mult32(im, s));
ptr_out += 2;
ptr_out1 -= 2;
re = *ptr_x++;
im = *ptr_x++;
*ptr_out1 =
ixheaacd_sub32(ixheaacd_mult32(im, c1), ixheaacd_mult32(re, s1));
*ptr_out =
-ixheaacd_add32(ixheaacd_mult32(re, c1), ixheaacd_mult32(im, s1));
ptr_out += 2;
ptr_out1 -= 2;
}
}
VOID ixheaacd_post_twiddle_eld(WORD32 out[], WORD32 x[],
const WORD32 *cos_sin_ptr, WORD m) {
WORD i = 0;
WORD32 *ptr_x = &x[0];
WORD32 *ptr_out_767, *ptr_out_256;
WORD32 *ptr_out_768, *ptr_out_255;
WORD32 *ptr_out_0, *ptr_out_1279;
WORD32 tempr, tempi;
ptr_out_767 = &out[m + (m >> 1) - 1 - 2 * i];
ptr_out_256 = &out[(m >> 1) + 2 * i];
ptr_out_768 = &out[m + (m >> 1) + 2 * i];
ptr_out_255 = &out[(m >> 1) - 1 - 2 * i];
for (i = 0; i < (m >> 3); i++) {
WORD32 c, c1, s, s1;
WORD32 re, im;
c = *cos_sin_ptr++;
c1 = *cos_sin_ptr++;
s = *cos_sin_ptr++;
s1 = *cos_sin_ptr++;
re = *ptr_x++;
im = *ptr_x++;
tempi = ixheaacd_sub32(ixheaacd_mult32(im, c), ixheaacd_mult32(re, s));
tempr = -ixheaacd_add32(ixheaacd_mult32(re, c), ixheaacd_mult32(im, s));
*ptr_out_767 = tempr;
*ptr_out_256 = tempi;
*ptr_out_768 = *ptr_out_767;
*ptr_out_255 = -*ptr_out_256;
ptr_out_256 += 2;
ptr_out_767 -= 2;
ptr_out_768 += 2;
ptr_out_255 -= 2;
re = *ptr_x++;
im = *ptr_x++;
tempi = ixheaacd_sub32(ixheaacd_mult32(im, c1), ixheaacd_mult32(re, s1));
tempr = -ixheaacd_add32(ixheaacd_mult32(re, c1), ixheaacd_mult32(im, s1));
*ptr_out_767 = tempr;
*ptr_out_256 = tempi;
*ptr_out_768 = *ptr_out_767;
*ptr_out_255 = -*ptr_out_256;
ptr_out_256 += 2;
ptr_out_767 -= 2;
ptr_out_768 += 2;
ptr_out_255 -= 2;
}
ptr_out_0 = &out[2 * 2 * i - (m >> 1)];
ptr_out_1279 = &out[m + m + (m >> 1) - 1 - 2 * 2 * i];
for (; i < (m >> 2); i++) {
WORD32 c, c1, s, s1;
WORD32 re, im;
c = *cos_sin_ptr++;
c1 = *cos_sin_ptr++;
s = *cos_sin_ptr++;
s1 = *cos_sin_ptr++;
re = *ptr_x++;
im = *ptr_x++;
tempi = ixheaacd_sub32(ixheaacd_mult32(im, c), ixheaacd_mult32(re, s));
tempr = -ixheaacd_add32(ixheaacd_mult32(re, c), ixheaacd_mult32(im, s));
*ptr_out_767 = tempr;
*ptr_out_256 = tempi;
*ptr_out_0 = -*ptr_out_767;
*ptr_out_1279 = *ptr_out_256;
ptr_out_256 += 2;
ptr_out_767 -= 2;
ptr_out_0 += 2;
ptr_out_1279 -= 2;
re = *ptr_x++;
im = *ptr_x++;
tempi = ixheaacd_sub32(ixheaacd_mult32(im, c1), ixheaacd_mult32(re, s1));
tempr = -ixheaacd_add32(ixheaacd_mult32(re, c1), ixheaacd_mult32(im, s1));
*ptr_out_767 = tempr;
*ptr_out_256 = tempi;
*ptr_out_0 = -*ptr_out_767;
*ptr_out_1279 = *ptr_out_256;
ptr_out_256 += 2;
ptr_out_767 -= 2;
ptr_out_0 += 2;
ptr_out_1279 -= 2;
}
}
VOID ixheaacd_fft32x32_ld_dec(ia_aac_dec_imdct_tables_struct *imdct_tables_ptr,
WORD32 npoints, WORD32 *ptr_x, WORD32 *ptr_y) {
WORD32 i, j, l1, l2, h2, predj, tw_offset, stride, fft_jmp;
WORD32 xt0_0, yt0_0, xt1_0, yt1_0, xt2_0, yt2_0;
WORD32 xh0_0, xh1_0, xh20_0, xh21_0, xl0_0, xl1_0, xl20_0, xl21_0;
WORD32 xh0_1, xh1_1, xl0_1, xl1_1;
WORD32 x_0, x_1, x_2, x_3, x_l1_0, x_l1_1, x_l2_0, x_l2_1;
WORD32 xh0_2, xh1_2, xl0_2, xl1_2, xh0_3, xh1_3, xl0_3, xl1_3;
WORD32 x_4, x_5, x_6, x_7, x_h2_0, x_h2_1;
WORD32 x_8, x_9, x_a, x_b, x_c, x_d, x_e, x_f;
WORD32 si10, si20, si30, co10, co20, co30;
WORD32 *w;
WORD32 *x, *x2, *x0;
WORD32 *y0, *y1, *y2, *y3;
WORD32 n00, n10, n20, n30, n01, n11, n21, n31;
WORD32 n02, n12, n22, n32, n03, n13, n23, n33;
WORD32 n0, j0;
WORD32 radix;
WORD32 norm;
WORD32 m;
WORD32 *ptr_w;
if (npoints == 256)
ptr_w = imdct_tables_ptr->w_256;
else
ptr_w = imdct_tables_ptr->w_16;
for (i = 31, m = 1; (npoints & (1 << i)) == 0; i--, m++)
;
radix = m & 1 ? 2 : 4;
norm = m - 2;
stride = npoints;
tw_offset = 0;
fft_jmp = 6 * stride;
while (stride > radix) {
j = 0;
fft_jmp >>= 2;
h2 = stride >> 1;
l1 = stride;
l2 = stride + (stride >> 1);
x = ptr_x;
w = ptr_w + tw_offset;
tw_offset += fft_jmp;
stride >>= 2;
for (i = 0; i < npoints; i += 4) {
co10 = w[j + 1];
si10 = w[j + 0];
co20 = w[j + 3];
si20 = w[j + 2];
co30 = w[j + 5];
si30 = w[j + 4];
x_0 = x[0];
x_1 = x[1];
x_l1_0 = x[l1];
x_l1_1 = x[l1 + 1];
x_l2_0 = x[l2];
x_l2_1 = x[l2 + 1];
x_h2_0 = x[h2];
x_h2_1 = x[h2 + 1];
xh0_0 = ixheaacd_add32_sat(x_0, x_l1_0);
xh1_0 = ixheaacd_add32_sat(x_1, x_l1_1);
xl0_0 = ixheaacd_sub32_sat(x_0, x_l1_0);
xl1_0 = ixheaacd_sub32_sat(x_1, x_l1_1);
xh20_0 = ixheaacd_add32_sat(x_h2_0, x_l2_0);
xh21_0 = ixheaacd_add32_sat(x_h2_1, x_l2_1);
xl20_0 = ixheaacd_sub32_sat(x_h2_0, x_l2_0);
xl21_0 = ixheaacd_sub32_sat(x_h2_1, x_l2_1);
x0 = x;
x2 = x0;
j += 6;
x += 2;
predj = (j - fft_jmp);
if (!predj) x += fft_jmp;
if (!predj) j = 0;
x0[0] = ixheaacd_add32_sat(xh0_0, xh20_0);
x0[1] = ixheaacd_add32_sat(xh1_0, xh21_0);
xt0_0 = ixheaacd_sub32_sat(xh0_0, xh20_0);
yt0_0 = ixheaacd_sub32_sat(xh1_0, xh21_0);
xt1_0 = ixheaacd_add32_sat(xl0_0, xl21_0);
yt2_0 = ixheaacd_add32_sat(xl1_0, xl20_0);
xt2_0 = ixheaacd_sub32_sat(xl0_0, xl21_0);
yt1_0 = ixheaacd_sub32_sat(xl1_0, xl20_0);
x2[h2] =
MPYHIRC(si10, yt1_0) + MPYHIRC(co10, xt1_0) +
(((MPYLUHS(si10, yt1_0) + MPYLUHS(co10, xt1_0) + 0x8000) >> 16) << 1);
x2[h2 + 1] =
MPYHIRC(co10, yt1_0) - MPYHIRC(si10, xt1_0) +
(((MPYLUHS(co10, yt1_0) - MPYLUHS(si10, xt1_0) + 0x8000) >> 16) << 1);
x2[l1] =
MPYHIRC(si20, yt0_0) + MPYHIRC(co20, xt0_0) +
(((MPYLUHS(si20, yt0_0) + MPYLUHS(co20, xt0_0) + 0x8000) >> 16) << 1);
x2[l1 + 1] =
MPYHIRC(co20, yt0_0) - MPYHIRC(si20, xt0_0) +
(((MPYLUHS(co20, yt0_0) - MPYLUHS(si20, xt0_0) + 0x8000) >> 16) << 1);
x2[l2] =
MPYHIRC(si30, yt2_0) + MPYHIRC(co30, xt2_0) +
(((MPYLUHS(si30, yt2_0) + MPYLUHS(co30, xt2_0) + 0x8000) >> 16) << 1);
x2[l2 + 1] =
MPYHIRC(co30, yt2_0) - MPYHIRC(si30, xt2_0) +
(((MPYLUHS(co30, yt2_0) - MPYLUHS(si30, xt2_0) + 0x8000) >> 16) << 1);
}
}
y0 = ptr_y;
y2 = ptr_y + (WORD32)npoints;
x0 = ptr_x;
x2 = ptr_x + (WORD32)(npoints >> 1);
if (radix == 2) {
y1 = y0 + (WORD32)(npoints >> 2);
y3 = y2 + (WORD32)(npoints >> 2);
l1 = norm + 1;
j0 = 8;
n0 = npoints >> 1;
} else {
y1 = y0 + (WORD32)(npoints >> 1);
y3 = y2 + (WORD32)(npoints >> 1);
l1 = norm + 2;
j0 = 4;
n0 = npoints >> 2;
}
j = 0;
for (i = 0; i < npoints; i += 8) {
DIG_REV(j, l1, h2);
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];
x0 += 8;
xh0_0 = ixheaacd_add32_sat(x_0, x_4);
xh1_0 = ixheaacd_add32_sat(x_1, x_5);
xl0_0 = ixheaacd_sub32_sat(x_0, x_4);
xl1_0 = ixheaacd_sub32_sat(x_1, x_5);
xh0_1 = ixheaacd_add32_sat(x_2, x_6);
xh1_1 = ixheaacd_add32_sat(x_3, x_7);
xl0_1 = ixheaacd_sub32_sat(x_2, x_6);
xl1_1 = ixheaacd_sub32_sat(x_3, x_7);
n00 = ixheaacd_add32_sat(xh0_0, xh0_1);
n01 = ixheaacd_add32_sat(xh1_0, xh1_1);
n10 = ixheaacd_add32_sat(xl0_0, xl1_1);
n11 = ixheaacd_sub32_sat(xl1_0, xl0_1);
n20 = ixheaacd_sub32_sat(xh0_0, xh0_1);
n21 = ixheaacd_sub32_sat(xh1_0, xh1_1);
n30 = ixheaacd_sub32_sat(xl0_0, xl1_1);
n31 = ixheaacd_add32_sat(xl1_0, xl0_1);
if (radix == 2) {
n00 = ixheaacd_add32_sat(x_0, x_2);
n01 = ixheaacd_add32_sat(x_1, x_3);
n20 = ixheaacd_sub32_sat(x_0, x_2);
n21 = ixheaacd_sub32_sat(x_1, x_3);
n10 = ixheaacd_add32_sat(x_4, x_6);
n11 = ixheaacd_add32_sat(x_5, x_7);
n30 = ixheaacd_sub32_sat(x_4, x_6);
n31 = ixheaacd_sub32_sat(x_5, x_7);
}
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;
x_8 = x2[0];
x_9 = x2[1];
x_a = x2[2];
x_b = x2[3];
x_c = x2[4];
x_d = x2[5];
x_e = x2[6];
x_f = x2[7];
x2 += 8;
xh0_2 = ixheaacd_add32_sat(x_8, x_c);
xh1_2 = ixheaacd_add32_sat(x_9, x_d);
xl0_2 = ixheaacd_sub32_sat(x_8, x_c);
xl1_2 = ixheaacd_sub32_sat(x_9, x_d);
xh0_3 = ixheaacd_add32_sat(x_a, x_e);
xh1_3 = ixheaacd_add32_sat(x_b, x_f);
xl0_3 = ixheaacd_sub32_sat(x_a, x_e);
xl1_3 = ixheaacd_sub32_sat(x_b, x_f);
n02 = ixheaacd_add32_sat(xh0_2, xh0_3);
n03 = ixheaacd_add32_sat(xh1_2, xh1_3);
n12 = ixheaacd_add32_sat(xl0_2, xl1_3);
n13 = ixheaacd_sub32_sat(xl1_2, xl0_3);
n22 = ixheaacd_sub32_sat(xh0_2, xh0_3);
n23 = ixheaacd_sub32_sat(xh1_2, xh1_3);
n32 = ixheaacd_sub32_sat(xl0_2, xl1_3);
n33 = ixheaacd_add32_sat(xl1_2, xl0_3);
if (radix == 2) {
n02 = ixheaacd_add32_sat(x_8, x_a);
n03 = ixheaacd_add32_sat(x_9, x_b);
n22 = ixheaacd_sub32_sat(x_8, x_a);
n23 = ixheaacd_sub32_sat(x_9, x_b);
n12 = ixheaacd_add32_sat(x_c, x_e);
n13 = ixheaacd_add32_sat(x_d, x_f);
n32 = ixheaacd_sub32_sat(x_c, x_e);
n33 = ixheaacd_sub32_sat(x_d, x_f);
}
y0[2 * h2 + 2] = n02;
y0[2 * h2 + 3] = n03;
y1[2 * h2 + 2] = n12;
y1[2 * h2 + 3] = n13;
y2[2 * h2 + 2] = n22;
y2[2 * h2 + 3] = n23;
y3[2 * h2 + 2] = n32;
y3[2 * h2 + 3] = n33;
j += j0;
if (j == n0) {
j += n0;
x0 += (WORD32)npoints >> 1;
x2 += (WORD32)npoints >> 1;
}
}
}
VOID ixheaacd_rearrange_dec(WORD32 *ip, WORD32 *op, WORD32 mdct_len_2,
UWORD8 *re_arr_tab) {
WORD32 n, i = 0;
for (n = 0; n < mdct_len_2; n++) {
WORD32 idx = re_arr_tab[n] << 1;
op[i++] = ip[idx];
op[i++] = ip[idx + 1];
}
}
VOID ixheaacd_fft_15_ld_dec(WORD32 *inp, WORD32 *op, WORD32 *fft3out,
UWORD8 *re_arr_tab_sml_240_ptr) {
WORD32 i, n, idx;
WORD32 *buf1, *buf2, *buf1a;
WORD32 add_r, sub_r;
WORD32 add_i, sub_i;
WORD32 x01_real, x_01_imag, temp;
WORD32 p1, p2, p3, p4;
WORD32 sinmu = 1859775393;
WORD32 cos_51 = 2042378317;
WORD32 cos_52 = -1652318768;
WORD32 cos_53 = -780119100;
WORD32 cos_54 = 1200479854;
WORD32 cos_55 = -1342177280;
WORD32 r1, r2, r3, r4;
WORD32 s1, s2, s3, s4, t, temp1, temp2;
WORD32 *fft3outptr = fft3out;
WORD32 xr_0, xr_1, xr_2;
WORD32 xi_0, xi_1, xi_2;
buf2 = fft3out;
buf1 = buf1a = fft3out;
n = 0;
{
*buf1++ = inp[0];
*buf1++ = inp[1];
*buf1++ = inp[96];
*buf1++ = inp[97];
*buf1++ = inp[192];
*buf1++ = inp[193];
*buf1++ = inp[288];
*buf1++ = inp[289];
*buf1++ = inp[384];
*buf1++ = inp[385];
r1 = ixheaacd_add32_sat(buf1a[2], buf1a[8]);
r4 = ixheaacd_sub32_sat(buf1a[2], buf1a[8]);
r3 = ixheaacd_add32_sat(buf1a[4], buf1a[6]);
r2 = ixheaacd_sub32_sat(buf1a[4], buf1a[6]);
t = ixheaacd_mult32_shl(ixheaacd_sub32_sat(r1, r3), cos_54);
r1 = ixheaacd_add32_sat(r1, r3);
temp1 = ixheaacd_add32_sat(buf1a[0], r1);
r1 = ixheaacd_add32_sat(
temp1, ixheaacd_shl32_sat((ixheaacd_mult32_shl(r1, cos_55)), 1));
r3 = ixheaacd_sub32_sat(r1, t);
r1 = ixheaacd_add32_sat(r1, t);
t = ixheaacd_mult32_shl(ixheaacd_add32_sat(r4, r2), cos_51);
r4 = ixheaacd_add32_sat(
t, ixheaacd_shl32_sat(ixheaacd_mult32_shl(r4, cos_52), 1));
r2 = ixheaacd_add32_sat(t, ixheaacd_mult32_shl(r2, cos_53));
s1 = ixheaacd_add32_sat(buf1a[3], buf1a[9]);
s4 = ixheaacd_sub32_sat(buf1a[3], buf1a[9]);
s3 = ixheaacd_add32_sat(buf1a[5], buf1a[7]);
s2 = ixheaacd_sub32_sat(buf1a[5], buf1a[7]);
t = ixheaacd_mult32_shl(ixheaacd_sub32_sat(s1, s3), cos_54);
s1 = ixheaacd_add32_sat(s1, s3);
temp2 = ixheaacd_add32_sat(buf1a[1], s1);
s1 = ixheaacd_add32_sat(
temp2, ixheaacd_shl32_sat((ixheaacd_mult32_shl(s1, cos_55)), 1));
s3 = ixheaacd_sub32_sat(s1, t);
s1 = ixheaacd_add32_sat(s1, t);
t = ixheaacd_mult32_shl(ixheaacd_add32_sat(s4, s2), cos_51);
s4 = ixheaacd_add32_sat(
t, ixheaacd_shl32_sat((ixheaacd_mult32_shl(s4, cos_52)), 1));
s2 = ixheaacd_add32_sat(t, (ixheaacd_mult32_shl(s2, cos_53)));
*buf2++ = temp1;
*buf2++ = temp2;
*buf2++ = ixheaacd_add32_sat(r1, s2);
*buf2++ = ixheaacd_sub32_sat(s1, r2);
*buf2++ = ixheaacd_sub32_sat(r3, s4);
*buf2++ = ixheaacd_add32_sat(s3, r4);
*buf2++ = ixheaacd_add32_sat(r3, s4);
*buf2++ = ixheaacd_sub32_sat(s3, r4);
*buf2++ = ixheaacd_sub32_sat(r1, s2);
*buf2++ = ixheaacd_add32_sat(s1, r2);
buf1a = buf1;
*buf1++ = inp[160];
*buf1++ = inp[161];
*buf1++ = inp[256];
*buf1++ = inp[257];
*buf1++ = inp[352];
*buf1++ = inp[353];
*buf1++ = inp[448];
*buf1++ = inp[449];
*buf1++ = inp[64];
*buf1++ = inp[65];
r1 = ixheaacd_add32_sat(buf1a[2], buf1a[8]);
r4 = ixheaacd_sub32_sat(buf1a[2], buf1a[8]);
r3 = ixheaacd_add32_sat(buf1a[4], buf1a[6]);
r2 = ixheaacd_sub32_sat(buf1a[4], buf1a[6]);
t = ixheaacd_mult32_shl(ixheaacd_sub32_sat(r1, r3), cos_54);
r1 = ixheaacd_add32_sat(r1, r3);
temp1 = ixheaacd_add32_sat(buf1a[0], r1);
r1 = ixheaacd_add32_sat(
temp1, ixheaacd_shl32_sat((ixheaacd_mult32_shl(r1, cos_55)), 1));
r3 = ixheaacd_sub32_sat(r1, t);
r1 = ixheaacd_add32_sat(r1, t);
t = ixheaacd_mult32_shl(ixheaacd_add32_sat(r4, r2), cos_51);
r4 = ixheaacd_add32_sat(
t, ixheaacd_shl32_sat(ixheaacd_mult32_shl(r4, cos_52), 1));
r2 = ixheaacd_add32_sat(t, ixheaacd_mult32_shl(r2, cos_53));
s1 = ixheaacd_add32_sat(buf1a[3], buf1a[9]);
s4 = ixheaacd_sub32_sat(buf1a[3], buf1a[9]);
s3 = ixheaacd_add32_sat(buf1a[5], buf1a[7]);
s2 = ixheaacd_sub32_sat(buf1a[5], buf1a[7]);
t = ixheaacd_mult32_shl(ixheaacd_sub32_sat(s1, s3), cos_54);
s1 = ixheaacd_add32_sat(s1, s3);
temp2 = ixheaacd_add32_sat(buf1a[1], s1);
s1 = ixheaacd_add32_sat(
temp2, ixheaacd_shl32_sat((ixheaacd_mult32_shl(s1, cos_55)), 1));
s3 = ixheaacd_sub32_sat(s1, t);
s1 = ixheaacd_add32_sat(s1, t);
t = ixheaacd_mult32_shl(ixheaacd_add32_sat(s4, s2), cos_51);
s4 = ixheaacd_add32_sat(
t, ixheaacd_shl32_sat((ixheaacd_mult32_shl(s4, cos_52)), 1));
s2 = ixheaacd_add32_sat(t, (ixheaacd_mult32_shl(s2, cos_53)));
*buf2++ = temp1;
*buf2++ = temp2;
*buf2++ = ixheaacd_add32_sat(r1, s2);
*buf2++ = ixheaacd_sub32_sat(s1, r2);
*buf2++ = ixheaacd_sub32_sat(r3, s4);
*buf2++ = ixheaacd_add32_sat(s3, r4);
*buf2++ = ixheaacd_add32_sat(r3, s4);
*buf2++ = ixheaacd_sub32_sat(s3, r4);
*buf2++ = ixheaacd_sub32_sat(r1, s2);
*buf2++ = ixheaacd_add32_sat(s1, r2);
buf1a = buf1;
;
*buf1++ = inp[320];
*buf1++ = inp[321];
*buf1++ = inp[416];
*buf1++ = inp[417];
*buf1++ = inp[32];
*buf1++ = inp[33];
*buf1++ = inp[128];
*buf1++ = inp[129];
*buf1++ = inp[224];
*buf1++ = inp[225];
r1 = ixheaacd_add32_sat(buf1a[2], buf1a[8]);
r4 = ixheaacd_sub32_sat(buf1a[2], buf1a[8]);
r3 = ixheaacd_add32_sat(buf1a[4], buf1a[6]);
r2 = ixheaacd_sub32_sat(buf1a[4], buf1a[6]);
t = ixheaacd_mult32_shl(ixheaacd_sub32_sat(r1, r3), cos_54);
r1 = ixheaacd_add32_sat(r1, r3);
temp1 = ixheaacd_add32_sat(buf1a[0], r1);
r1 = ixheaacd_add32_sat(
temp1, ixheaacd_shl32_sat((ixheaacd_mult32_shl(r1, cos_55)), 1));
r3 = ixheaacd_sub32_sat(r1, t);
r1 = ixheaacd_add32_sat(r1, t);
t = ixheaacd_mult32_shl(ixheaacd_add32_sat(r4, r2), cos_51);
r4 = ixheaacd_add32_sat(
t, ixheaacd_shl32_sat(ixheaacd_mult32_shl(r4, cos_52), 1));
r2 = ixheaacd_add32_sat(t, ixheaacd_mult32_shl(r2, cos_53));
s1 = ixheaacd_add32_sat(buf1a[3], buf1a[9]);
s4 = ixheaacd_sub32_sat(buf1a[3], buf1a[9]);
s3 = ixheaacd_add32_sat(buf1a[5], buf1a[7]);
s2 = ixheaacd_sub32_sat(buf1a[5], buf1a[7]);
t = ixheaacd_mult32_shl(ixheaacd_sub32_sat(s1, s3), cos_54);
s1 = ixheaacd_add32_sat(s1, s3);
temp2 = ixheaacd_add32_sat(buf1a[1], s1);
s1 = ixheaacd_add32_sat(
temp2, ixheaacd_shl32_sat((ixheaacd_mult32_shl(s1, cos_55)), 1));
s3 = ixheaacd_sub32_sat(s1, t);
s1 = ixheaacd_add32_sat(s1, t);
t = ixheaacd_mult32_shl(ixheaacd_add32_sat(s4, s2), cos_51);
s4 = ixheaacd_add32_sat(
t, ixheaacd_shl32_sat((ixheaacd_mult32_shl(s4, cos_52)), 1));
s2 = ixheaacd_add32_sat(t, (ixheaacd_mult32_shl(s2, cos_53)));
*buf2++ = temp1;
*buf2++ = temp2;
*buf2++ = ixheaacd_add32_sat(r1, s2);
*buf2++ = ixheaacd_sub32_sat(s1, r2);
*buf2++ = ixheaacd_sub32_sat(r3, s4);
*buf2++ = ixheaacd_add32_sat(s3, r4);
*buf2++ = ixheaacd_add32_sat(r3, s4);
*buf2++ = ixheaacd_sub32_sat(s3, r4);
*buf2++ = ixheaacd_sub32_sat(r1, s2);
*buf2++ = ixheaacd_add32_sat(s1, r2);
buf1a = buf1;
;
}
n = 0;
for (i = 0; i < FFT5; i++) {
xr_0 = fft3outptr[0];
xi_0 = fft3outptr[1];
xr_1 = fft3outptr[10];
xi_1 = fft3outptr[11];
xr_2 = fft3outptr[20];
xi_2 = fft3outptr[21];
x01_real = ixheaacd_add32_sat(xr_0, xr_1);
x_01_imag = ixheaacd_add32_sat(xi_0, xi_1);
add_r = ixheaacd_add32_sat(xr_1, xr_2);
add_i = ixheaacd_add32_sat(xi_1, xi_2);
sub_r = ixheaacd_sub32_sat(xr_1, xr_2);
sub_i = ixheaacd_sub32_sat(xi_1, xi_2);
p1 = add_r >> 1;
p2 = ixheaacd_mult32_shl(sub_i, sinmu);
p3 = ixheaacd_mult32_shl(sub_r, sinmu);
p4 = add_i >> 1;
temp = ixheaacd_sub32_sat(xr_0, p1);
temp1 = ixheaacd_add32_sat(xi_0, p3);
temp2 = ixheaacd_sub32_sat(xi_0, p3);
idx = re_arr_tab_sml_240_ptr[n++] << 1;
op[idx] = ixheaacd_add32_sat(x01_real, xr_2);
op[idx + 1] = ixheaacd_add32_sat(x_01_imag, xi_2);
idx = re_arr_tab_sml_240_ptr[n++] << 1;
op[idx] = ixheaacd_add32_sat(temp, p2);
op[idx + 1] = ixheaacd_sub32_sat(temp2, p4);
idx = re_arr_tab_sml_240_ptr[n++] << 1;
op[idx] = ixheaacd_sub32_sat(temp, p2);
op[idx + 1] = ixheaacd_sub32_sat(temp1, p4);
fft3outptr += 2;
}
}
Reference in new issue View Git Blame Copy Permalink