wrapper/libxaac
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
libxaac/encoder/ixheaace_hybrid.c
Nikhil Bhavikatti 797de4d1e9
USAC along with DRC support for libxaac encoder (#37)
2023-07-14 13:04:15 +05:30

370 lines
11 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_error_standards.h"
#include "ixheaace_error_codes.h"
#include "ixheaace_common_rom.h"
#include "ixheaace_sbr_def.h"
#include "ixheaace_resampler.h"
#include "ixheaace_sbr_rom.h"
#include "ixheaace_sbr_hybrid.h"
#include "ixheaace_aac_constants.h"
VOID ia_enhaacplus_enc_fft(complex *out, WORD32 N, ixheaace_common_tables *);
static VOID ixheaace_four_chan_filtering(const FLOAT32 *ptr_qmf_real, const FLOAT32 *ptr_qmf_imag,
FLOAT32 **ptr_hyb_real, FLOAT32 **ptr_hyb_imag,
WORD32 ch_offset, const FLOAT32 *ptr_p4_13,
ixheaace_common_tables *pstr_common_tab) {
WORD32 i, k, n;
WORD32 mid_tap = IXHEAACE_HYBRID_FILTER_DELAY;
FLOAT32 cum[8], *ptr_cum;
FLOAT32 tmp1, tmp2, tmp_p4;
FLOAT32 real, imag;
const FLOAT32 *ptr_re, *ptr_im;
FLOAT32 *ptr_hy_im, *ptr_hy_re;
ptr_re = &ptr_qmf_real[0];
ptr_im = &ptr_qmf_imag[0];
ptr_hy_re = &ptr_hyb_real[0][ch_offset];
ptr_hy_im = &ptr_hyb_imag[0][ch_offset];
for (i = IXHEAACE_QMF_TIME_SLOTS - 1; i >= 0; i--) {
real = imag = 0;
for (k = 0; k < 16; k += 4) {
tmp_p4 = ptr_p4_13[k];
tmp1 = ptr_re[k];
tmp2 = ptr_im[k];
tmp1 = tmp_p4 * tmp1;
real = real - tmp1;
tmp1 = tmp_p4 * tmp2;
imag = imag + tmp1;
}
cum[3] = imag;
cum[2] = real;
real = imag = 0;
for (k = 3; k < 15; k += 4) {
tmp_p4 = ptr_p4_13[k];
tmp1 = ptr_re[k];
tmp2 = ptr_im[k];
tmp1 = tmp_p4 * tmp1;
real = real + tmp1;
tmp1 = tmp_p4 * tmp2;
imag = imag + tmp1;
}
tmp1 = imag + real;
cum[7] = tmp1 * IXHEAACE_COS_PI_BY_4;
tmp1 = imag - real;
cum[6] = tmp1 * IXHEAACE_COS_PI_BY_4;
cum[1] = ptr_p4_13[mid_tap] * ptr_re[mid_tap];
cum[0] = ptr_p4_13[mid_tap] * ptr_im[mid_tap];
real = imag = 0;
for (k = 1; k < 13; k += 4) {
tmp_p4 = ptr_p4_13[k];
tmp1 = ptr_re[k];
tmp2 = ptr_im[k];
tmp1 = tmp_p4 * tmp1;
real = real + tmp1;
tmp1 = tmp_p4 * tmp2;
imag = imag + tmp1;
}
tmp1 = real - imag;
cum[5] = tmp1 * IXHEAACE_COS_PI_BY_4;
tmp1 = real + imag;
cum[4] = tmp1 * IXHEAACE_COS_PI_BY_4;
ia_enhaacplus_enc_fft((complex *)cum, 4, pstr_common_tab);
ptr_cum = &cum[0];
for (n = 3; n >= 0; n--) {
tmp1 = *ptr_cum++;
tmp2 = *ptr_cum++;
*ptr_hy_im++ = tmp1;
*ptr_hy_re++ = tmp2;
}
ptr_re++;
ptr_im++;
ptr_hy_re += IXHEAACE_QMF_TIME_SLOTS - 4;
ptr_hy_im += IXHEAACE_QMF_TIME_SLOTS - 4;
}
}
static VOID ixheaace_eight_chan_filtering(const FLOAT32 *ptr_qmf_real,
const FLOAT32 *ptr_qmf_imag, FLOAT32 **ptr_hyb_real,
FLOAT32 **ptr_hyb_imag, const FLOAT32 *ptr_p8_13,
ixheaace_common_tables *pstr_common_tab)
{
LOOPINDEX i, n;
LOOPINDEX mid_tap = IXHEAACE_HYBRID_FILTER_DELAY;
FLOAT32 real, imag;
FLOAT32 cum[16], *ptr_cum;
FLOAT32 tmp1, tmp2, tmp3;
const FLOAT32 *ptr_re, *ptr_im;
FLOAT32 *ptr_hy_re, *ptr_hy_im;
ptr_re = &ptr_qmf_real[0];
ptr_im = &ptr_qmf_imag[0];
ptr_hy_re = &ptr_hyb_real[0][0];
ptr_hy_im = &ptr_hyb_imag[0][0];
for (i = IXHEAACE_QMF_TIME_SLOTS - 1; i >= 0; i--) {
tmp1 = ptr_p8_13[4] * ptr_re[4];
tmp2 = ptr_p8_13[12] * ptr_re[12];
tmp3 = ptr_im[4];
real = tmp1 + tmp2;
tmp2 = ptr_im[12];
tmp1 = ptr_p8_13[4] * tmp3;
tmp2 = ptr_p8_13[12] * tmp2;
imag = tmp1 + tmp2;
tmp1 = imag - real;
cum[5] = tmp1 * IXHEAACE_COS_PI_BY_4;
tmp1 = imag + real;
tmp3 = ptr_re[3];
cum[4] = -tmp1 * IXHEAACE_COS_PI_BY_4;
tmp2 = ptr_re[11];
tmp1 = ptr_p8_13[3] * tmp3;
tmp2 = ptr_p8_13[11] * tmp2;
tmp3 = ptr_im[3];
real = tmp1 + tmp2;
tmp2 = ptr_im[11];
tmp1 = ptr_p8_13[3] * tmp3;
tmp2 = ptr_p8_13[11] * tmp2;
imag = tmp1 + tmp2;
tmp1 = imag * IXHEAACE_COS_PI_BY_8;
tmp2 = real * IXHEAACE_SIN_PI_BY_8;
cum[13] = tmp1 - tmp2;
tmp1 = imag * IXHEAACE_SIN_PI_BY_8;
tmp2 = real * IXHEAACE_COS_PI_BY_8;
tmp3 = ptr_re[2];
cum[12] = -tmp1 - tmp2;
tmp2 = ptr_re[10];
tmp1 = ptr_p8_13[2] * tmp3;
tmp2 = ptr_p8_13[10] * tmp2;
tmp3 = ptr_im[2];
cum[2] = -tmp1 - tmp2;
tmp2 = ptr_im[10];
tmp1 = ptr_p8_13[2] * tmp3;
tmp2 = ptr_p8_13[10] * tmp2;
cum[3] = tmp1 + tmp2;
tmp1 = ptr_p8_13[1] * ptr_re[1];
tmp2 = ptr_p8_13[9] * ptr_re[9];
real = tmp1 + tmp2;
tmp1 = ptr_p8_13[1] * ptr_im[1];
tmp2 = ptr_p8_13[9] * ptr_im[9];
imag = tmp1 + tmp2;
tmp1 = imag * IXHEAACE_COS_PI_BY_8;
tmp2 = real * IXHEAACE_SIN_PI_BY_8;
cum[11] = tmp1 + tmp2;
tmp1 = imag * IXHEAACE_SIN_PI_BY_8;
tmp2 = real * IXHEAACE_COS_PI_BY_8;
cum[10] = tmp1 - tmp2;
tmp1 = ptr_p8_13[0] * ptr_re[0];
tmp2 = ptr_p8_13[8] * ptr_re[8];
real = tmp1 + tmp2;
tmp1 = ptr_p8_13[0] * ptr_im[0];
tmp2 = ptr_p8_13[8] * ptr_im[8];
imag = tmp1 + tmp2;
tmp1 = imag + real;
cum[7] = tmp1 * IXHEAACE_COS_PI_BY_4;
tmp1 = imag - real;
cum[6] = tmp1 * IXHEAACE_COS_PI_BY_4;
real = ptr_p8_13[7] * ptr_re[7];
imag = ptr_p8_13[7] * ptr_im[7];
tmp1 = imag * IXHEAACE_SIN_PI_BY_8;
tmp2 = real * IXHEAACE_COS_PI_BY_8;
cum[15] = tmp1 + tmp2;
tmp1 = imag * IXHEAACE_COS_PI_BY_8;
tmp2 = real * IXHEAACE_SIN_PI_BY_8;
cum[14] = tmp1 - tmp2;
cum[1] = ptr_p8_13[mid_tap] * ptr_re[mid_tap];
cum[0] = ptr_p8_13[mid_tap] * ptr_im[mid_tap];
real = ptr_p8_13[5] * ptr_re[5];
imag = ptr_p8_13[5] * ptr_im[5];
tmp1 = real * IXHEAACE_COS_PI_BY_8;
tmp2 = imag * IXHEAACE_SIN_PI_BY_8;
cum[9] = tmp1 - tmp2;
tmp1 = real * IXHEAACE_SIN_PI_BY_8;
tmp2 = imag * IXHEAACE_COS_PI_BY_8;
cum[8] = tmp1 + tmp2;
ia_enhaacplus_enc_fft((complex *)cum, 8, pstr_common_tab);
ptr_cum = &cum[0];
for (n = 7; n >= 0; n--) {
tmp1 = *ptr_cum++;
tmp2 = *ptr_cum++;
*ptr_hy_im++ = tmp1;
*ptr_hy_re++ = tmp2;
}
ptr_re++;
ptr_im++;
ptr_hy_re += IXHEAACE_QMF_TIME_SLOTS - 8;
ptr_hy_im += IXHEAACE_QMF_TIME_SLOTS - 8;
}
}
IA_ERRORCODE ixheaace_hybrid_analysis(const FLOAT32 **ptr_qmf_real_in,
const FLOAT32 **ptr_qmf_imag_in, FLOAT32 **ptr_hyb_real_in,
FLOAT32 **ptr_hyb_imag_in, ixheaace_pstr_hybrid pstr_hybrid,
ixheaace_str_ps_tab *pstr_ps_tab,
ixheaace_common_tables *pstr_common_tab) {
WORD32 band, i;
ixheaace_hybrid_res hybrid_res;
WORD32 ch_offset = 0;
FLOAT32 *ptr_re, *ptr_im;
const FLOAT32 *ptr_qmf_real, *ptr_qmf_imag;
FLOAT32 tmp1, tmp2;
for (band = 0; band < IXHEAACE_NUM_QMF_BANDS_IN_HYBRID; band++) {
hybrid_res = (ixheaace_hybrid_res)pstr_ps_tab->a_hyb_res[band];
memcpy(pstr_hybrid->ptr_work_real, pstr_hybrid->ptr_qmf_buf_real[band],
IXHEAACE_QMF_BUFFER_MOVE * sizeof(FLOAT32));
memcpy(pstr_hybrid->ptr_work_imag, pstr_hybrid->ptr_qmf_buf_imag[band],
IXHEAACE_QMF_BUFFER_MOVE * sizeof(FLOAT32));
ptr_re = &pstr_hybrid->ptr_work_real[IXHEAACE_QMF_BUFFER_MOVE];
ptr_im = &pstr_hybrid->ptr_work_imag[IXHEAACE_QMF_BUFFER_MOVE];
ptr_qmf_real = &ptr_qmf_real_in[0][band];
ptr_qmf_imag = &ptr_qmf_imag_in[0][band];
for (i = IXHEAACE_QMF_TIME_SLOTS - 1; i >= 0; i--) {
tmp1 = *ptr_qmf_real;
tmp2 = *ptr_qmf_imag;
ptr_qmf_real += IXHEAACE_QMF_CHANNELS;
ptr_qmf_imag += IXHEAACE_QMF_CHANNELS;
*ptr_im++ = tmp2;
*ptr_re++ = tmp1;
}
ptr_re = &pstr_hybrid->ptr_qmf_buf_real[band][0];
ptr_im = &pstr_hybrid->ptr_qmf_buf_imag[band][0];
ptr_qmf_real = &ptr_qmf_real_in[IXHEAACE_QMF_TIME_SLOTS - IXHEAACE_QMF_BUFFER_MOVE][band];
ptr_qmf_imag = &ptr_qmf_imag_in[IXHEAACE_QMF_TIME_SLOTS - IXHEAACE_QMF_BUFFER_MOVE][band];
for (i = 0; i < IXHEAACE_QMF_BUFFER_MOVE; i++) {
tmp1 = *ptr_qmf_real;
ptr_qmf_real += IXHEAACE_QMF_CHANNELS;
tmp2 = *ptr_qmf_imag;
ptr_qmf_imag += IXHEAACE_QMF_CHANNELS;
*ptr_re++ = tmp1;
*ptr_im++ = tmp2;
}
switch (hybrid_res) {
case IXHEAACE_HYBRID_4_CPLX:
ixheaace_four_chan_filtering(pstr_hybrid->ptr_work_real, pstr_hybrid->ptr_work_imag,
ptr_hyb_real_in, ptr_hyb_imag_in, ch_offset,
pstr_ps_tab->p4_13, pstr_common_tab);
break;
case IXHEAACE_HYBRID_8_CPLX:
ixheaace_eight_chan_filtering(pstr_hybrid->ptr_work_real, pstr_hybrid->ptr_work_imag,
ptr_hyb_real_in, ptr_hyb_imag_in, pstr_ps_tab->p8_13,
pstr_common_tab);
break;
default:
return IA_EXHEAACE_EXE_FATAL_PS_INVALID_HYBRID_RES_VAL;
break;
}
ch_offset += hybrid_res;
}
return IA_NO_ERROR;
}
VOID ixheaace_hybrid_synthesis(const FLOAT32 **ptr_hybrid_real_flt,
const FLOAT32 **ptr_hybrid_imag_flt, FLOAT32 **ptr_qmf_real_flt,
FLOAT32 **ptr_qmf_imag_flt, const WORD32 *ptr_hyb_res) {
WORD32 k, n, band;
ixheaace_hybrid_res hybrid_res;
WORD32 ch_offset = 0;
FLOAT32 temp1, temp2;
FLOAT32 *ptr_qmf_real;
FLOAT32 *ptr_qmf_imag;
for (band = 0; band < IXHEAACE_NUM_QMF_BANDS_IN_HYBRID; band++) {
const FLOAT32 *ptr_hybrid_real = &ptr_hybrid_real_flt[0][ch_offset];
const FLOAT32 *ptr_hybrid_imag = &ptr_hybrid_imag_flt[0][ch_offset];
hybrid_res = (ixheaace_hybrid_res)ptr_hyb_res[band];
ptr_qmf_real = &ptr_qmf_real_flt[0][band];
ptr_qmf_imag = &ptr_qmf_imag_flt[0][band];
for (n = 0; n < IXHEAACE_QMF_TIME_SLOTS; n++) {
FLOAT32 temo_real = 0, temo_imag = 0;
for (k = hybrid_res - 1; k >= 0; k--) {
temp1 = *ptr_hybrid_real++;
temp2 = *ptr_hybrid_imag++;
temo_real += temp1;
temo_imag += temp2;
}
ptr_hybrid_real += IXHEAACE_QMF_TIME_SLOTS - hybrid_res;
ptr_hybrid_imag += IXHEAACE_QMF_TIME_SLOTS - hybrid_res;
*ptr_qmf_real = temo_real;
ptr_qmf_real += IXHEAACE_QMF_CHANNELS;
*ptr_qmf_imag = temo_imag;
ptr_qmf_imag += IXHEAACE_QMF_CHANNELS;
}
ch_offset += hybrid_res;
}
}
Reference in a new issue View git blame Copy permalink