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_lpp_tran.c

1134 lines
36 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 <stdio.h>
#include <string.h>
#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_basic_op.h"
#include "ixheaacd_intrinsics.h"
#include "ixheaacd_common_rom.h"
#include "ixheaacd_basic_funcs.h"
#include "ixheaacd_sbr_scale.h"
#include "ixheaacd_sbrdecsettings.h"
#include "ixheaacd_lpp_tran.h"
#include "ixheaacd_bitbuffer.h"
#include "ixheaacd_defines.h"
#include "ixheaacd_pns.h"
#include "ixheaacd_aac_rom.h"
#include "ixheaacd_pulsedata.h"
#include "ixheaacd_drc_data_struct.h"
#include "ixheaacd_lt_predict.h"
#include "ixheaacd_channelinfo.h"
#include "ixheaacd_drc_dec.h"
#include "ixheaacd_sbrdecoder.h"
#include "ixheaacd_sbr_scale.h"
#include "ixheaacd_lpp_tran.h"
#include "ixheaacd_env_extr_part.h"
#include "ixheaacd_sbr_rom.h"
#include "ixheaacd_hybrid.h"
#include "ixheaacd_ps_dec.h"
#include "ixheaacd_env_extr.h"
#include "ixheaacd_intrinsics.h"
#include "ixheaacd_basic_funcs.h"
#include "ixheaacd_qmf_dec.h"
#include "ixheaacd_env_calc.h"
#include "ixheaacd_sbr_const.h"
#include "ixheaacd_pvc_dec.h"
#include "ixheaacd_sbr_dec.h"
#include "ixheaacd_function_selector.h"
#include "ixheaacd_audioobjtypes.h"
#define LPC_SCALE_FACTOR 2
#define SHIFT 5
static PLATFORM_INLINE WORD32 ixheaacd_mult32x16hin32(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_mac32x16hin32(WORD32 a, WORD32 b,
WORD32 c) {
WORD32 result;
result = a + ixheaacd_mult32x16hin32(b, c);
return (result);
}
static PLATFORM_INLINE WORD32 ixheaacd_macn32x16hin32(WORD32 a, WORD32 b,
WORD32 c) {
WORD32 result;
result = a - ixheaacd_mult32x16hin32(b, c);
return (result);
}
VOID ixheaacd_filterstep3(WORD16 a0r, WORD16 a0i, WORD16 a1r, WORD16 a1i,
WORD32 start_indx, WORD32 stop_idx, WORD32 low_band,
WORD32 high_band, WORD32 *qmf_buffer) {
WORD32 i;
WORD32 prev1r, prev1i;
WORD32 prev2r, prev2i;
WORD16 coef1r = (a0r);
WORD16 coef1i = (a0i);
WORD16 coef2r = (a1r);
WORD16 coef2i = (a1i);
WORD32 *p_src, *p_dst;
WORD32 qmf_real, qmf_imag;
WORD32 curr, curi;
p_src = qmf_buffer + low_band + ((start_indx) << 7);
prev2r = *p_src;
p_src += 64;
prev2i = *p_src;
p_src += 64;
prev1r = *p_src;
p_src += 64;
prev1i = *p_src;
p_src += 64;
p_dst = qmf_buffer + high_band + ((start_indx + 2) << 7);
for (i = stop_idx - start_indx; i != 0; i--) {
WORD32 accu;
curr = *p_src;
p_src += 64;
curi = *p_src;
p_src += 64;
qmf_real = (curr >> LPC_SCALE_FACTOR);
qmf_imag = (curi >> LPC_SCALE_FACTOR);
accu = ixheaacd_sub32(
ixheaacd_add32(ixheaacd_sub32(ixheaacd_mult32x16in32(prev1r, coef1r),
ixheaacd_mult32x16in32(prev1i, coef1i)),
ixheaacd_mult32x16in32(prev2r, coef2r)),
ixheaacd_mult32x16in32(prev2i, coef2i));
*p_dst = ixheaacd_add32(qmf_real, (accu << 1));
p_dst += 64;
accu = ixheaacd_add32(
ixheaacd_add32_sat(
ixheaacd_add32_sat(ixheaacd_mult32x16in32(prev1r, coef1i),
ixheaacd_mult32x16in32(prev1i, coef1r)),
ixheaacd_mult32x16in32(prev2r, coef2i)),
ixheaacd_mult32x16in32(prev2i, coef2r));
*p_dst = ixheaacd_add32(qmf_imag, (accu << 1));
p_dst += 64;
prev2r = prev1r;
prev1r = curr;
prev2i = prev1i;
prev1i = curi;
}
}
VOID ixheaacd_covariance_matrix_calc_dec(
WORD32 *sub_sign_xlow, ixheaacd_lpp_trans_cov_matrix *cov_matrix,
WORD32 count) {
WORD32 j, k;
WORD32 ixheaacd_drc_offset = 2;
WORD32 len = 38;
WORD32 factor;
WORD32 max_val, q_factor;
WORD32 temp1, temp2, temp3, temp4;
WORD32 *temp_buf_ptr = sub_sign_xlow;
for (k = count; k > 0; k--) {
WORD32 t_phi_01 = 0, t_phi_02 = 0, t_phi_11 = 0;
WORD32 t_phi_12 = 0, t_phi_22 = 0;
factor = -3;
j = ixheaacd_drc_offset;
sub_sign_xlow = temp_buf_ptr;
temp1 = ixheaacd_shl32_dir(*sub_sign_xlow, factor);
sub_sign_xlow += 64;
temp2 = ixheaacd_shl32_dir(*sub_sign_xlow, factor);
sub_sign_xlow += 64;
for (; (j = j + 3) < ixheaacd_drc_offset + len;) {
temp3 = ixheaacd_shl32_dir(*sub_sign_xlow, factor);
sub_sign_xlow += 64;
t_phi_01 += ixheaacd_mult32x16hin32(temp3, temp2);
t_phi_02 += ixheaacd_mult32x16hin32(temp3, temp1);
t_phi_11 += ixheaacd_mult32x16hin32(temp2, temp2);
temp1 = ixheaacd_shl32_dir(*sub_sign_xlow, factor);
sub_sign_xlow += 64;
t_phi_01 += ixheaacd_mult32x16hin32(temp1, temp3);
t_phi_02 += ixheaacd_mult32x16hin32(temp1, temp2);
t_phi_11 += ixheaacd_mult32x16hin32(temp3, temp3);
temp2 = ixheaacd_shl32_dir(*sub_sign_xlow, factor);
sub_sign_xlow += 64;
t_phi_01 += ixheaacd_mult32x16hin32(temp2, temp1);
t_phi_02 += ixheaacd_mult32x16hin32(temp2, temp3);
t_phi_11 += ixheaacd_mult32x16hin32(temp1, temp1);
}
temp3 = ixheaacd_shl32_dir(*sub_sign_xlow, factor);
sub_sign_xlow += 64;
t_phi_01 += ixheaacd_mult32x16hin32(temp3, temp2);
t_phi_02 += ixheaacd_mult32x16hin32(temp3, temp1);
t_phi_11 += ixheaacd_mult32x16hin32(temp2, temp2);
temp1 = ixheaacd_shl32_dir(*sub_sign_xlow, factor);
sub_sign_xlow += 64;
t_phi_01 += ixheaacd_mult32x16hin32(temp1, temp3);
t_phi_02 += ixheaacd_mult32x16hin32(temp1, temp2);
t_phi_11 += ixheaacd_mult32x16hin32(temp3, temp3);
temp2 = ixheaacd_shl32_dir(*temp_buf_ptr, factor);
temp4 = ixheaacd_shl32_dir(*(temp_buf_ptr + 64), factor);
t_phi_12 = (t_phi_01 - ixheaacd_mult32x16hin32(temp1, temp3) +
ixheaacd_mult32x16hin32(temp4, temp2));
t_phi_22 = (t_phi_11 - ixheaacd_mult32x16hin32(temp3, temp3) +
ixheaacd_mult32x16hin32(temp2, temp2));
max_val = ixheaacd_abs32_nrm(t_phi_01);
max_val = max_val | ixheaacd_abs32_nrm(t_phi_02);
max_val = max_val | ixheaacd_abs32_nrm(t_phi_12);
max_val = max_val | (t_phi_11);
max_val = max_val | (t_phi_22);
q_factor = ixheaacd_pnorm32(max_val);
cov_matrix->phi_11 = (t_phi_11 << q_factor);
cov_matrix->phi_22 = (t_phi_22 << q_factor);
cov_matrix->phi_01 = (t_phi_01 << q_factor);
cov_matrix->phi_02 = (t_phi_02 << q_factor);
cov_matrix->phi_12 = (t_phi_12 << q_factor);
cov_matrix->d = ixheaacd_sub32_sat(
ixheaacd_mult32(cov_matrix->phi_22, cov_matrix->phi_11),
ixheaacd_mult32(cov_matrix->phi_12, cov_matrix->phi_12));
cov_matrix++;
temp_buf_ptr++;
}
return;
}
VOID ixheaacd_covariance_matrix_calc_2_dec(
ixheaacd_lpp_trans_cov_matrix *cov_matrix,
WORD32 *real_buffer, WORD32 num_bands, WORD16 slots) {
WORD32 k;
WORD32 *img_buffer;
WORD32 *ptr_real = real_buffer;
ixheaacd_lpp_trans_cov_matrix *pac_arr = cov_matrix;
for (k = 0; k < num_bands; k++) {
WORD32 t_phi_11 = 0, t_phi_01 = 0, t_phi_01_i = 0;
WORD32 prev_real, prev_imag, curr_real, curr_imag;
real_buffer = ptr_real;
img_buffer = real_buffer + 64;
cov_matrix = pac_arr;
prev_real = real_buffer[-128];
prev_imag = img_buffer[-128];
curr_real = real_buffer[0];
curr_imag = img_buffer[0];
curr_real = ixheaacd_shr32(curr_real, 3);
curr_imag = ixheaacd_shr32(curr_imag, 3);
prev_real = ixheaacd_shr32(prev_real, 3);
prev_imag = ixheaacd_shr32(prev_imag, 3);
t_phi_01 = ixheaacd_mult32x16hin32(curr_real, prev_real);
t_phi_01 = ixheaacd_mac32x16hin32(t_phi_01, curr_imag, prev_imag);
t_phi_01_i = ixheaacd_mult32x16hin32(curr_imag, prev_real);
t_phi_01_i = ixheaacd_macn32x16hin32(t_phi_01_i, curr_real, prev_imag);
t_phi_11 = ixheaacd_mult32x16hin32(prev_real, prev_real);
t_phi_11 = ixheaacd_mac32x16hin32(t_phi_11, prev_imag, prev_imag);
{
WORD n;
WORD32 *real1 = &real_buffer[128];
WORD32 *imag1 = &img_buffer[128];
prev_real = curr_real;
prev_imag = curr_imag;
for (n = ((slots - 2) >> 1); n; n--) {
curr_real = *real1;
real1 += 128;
curr_imag = *imag1;
imag1 += 128;
curr_real = ixheaacd_shr32(curr_real, 3);
curr_imag = ixheaacd_shr32(curr_imag, 3);
t_phi_01 = ixheaacd_mac32x16hin32(t_phi_01, curr_real, prev_real);
t_phi_01 = ixheaacd_mac32x16hin32(t_phi_01, curr_imag, prev_imag);
t_phi_01_i = ixheaacd_mac32x16hin32(t_phi_01_i, curr_imag, prev_real);
t_phi_01_i = ixheaacd_macn32x16hin32(t_phi_01_i, curr_real, prev_imag);
t_phi_11 = ixheaacd_mac32x16hin32(t_phi_11, prev_real, prev_real);
t_phi_11 = ixheaacd_mac32x16hin32(t_phi_11, prev_imag, prev_imag);
prev_real = *real1;
real1 += 128;
prev_imag = *imag1;
imag1 += 128;
prev_real = ixheaacd_shr32(prev_real, 3);
prev_imag = ixheaacd_shr32(prev_imag, 3);
t_phi_01 = ixheaacd_mac32x16hin32(t_phi_01, prev_real, curr_real);
t_phi_01 = ixheaacd_mac32x16hin32(t_phi_01, prev_imag, curr_imag);
t_phi_01_i = ixheaacd_mac32x16hin32(t_phi_01_i, prev_imag, curr_real);
t_phi_01_i = ixheaacd_macn32x16hin32(t_phi_01_i, prev_real, curr_imag);
t_phi_11 = ixheaacd_mac32x16hin32(t_phi_11, curr_real, curr_real);
t_phi_11 = ixheaacd_mac32x16hin32(t_phi_11, curr_imag, curr_imag);
}
if (slots & 0x01) {
curr_real = *real1;
curr_imag = *imag1;
curr_real = ixheaacd_shr32(curr_real, 3);
curr_imag = ixheaacd_shr32(curr_imag, 3);
t_phi_01 = ixheaacd_mac32x16hin32(t_phi_01, curr_real, prev_real);
t_phi_01 = ixheaacd_mac32x16hin32(t_phi_01, curr_imag, prev_imag);
t_phi_01_i = ixheaacd_mac32x16hin32(t_phi_01_i, curr_imag, prev_real);
t_phi_01_i = ixheaacd_macn32x16hin32(t_phi_01_i, curr_real, prev_imag);
t_phi_11 = ixheaacd_mac32x16hin32(t_phi_11, prev_real, prev_real);
t_phi_11 = ixheaacd_mac32x16hin32(t_phi_11, prev_imag, prev_imag);
}
}
{
WORD32 t_phi_22 = t_phi_11;
WORD32 curr_real = real_buffer[-2 * 128];
WORD32 curr_imag = img_buffer[-2 * 128];
curr_real = ixheaacd_shr32(curr_real, 3);
curr_imag = ixheaacd_shr32(curr_imag, 3);
t_phi_22 = ixheaacd_mac32x16hin32(t_phi_22, curr_real, curr_real);
t_phi_22 = ixheaacd_mac32x16hin32(t_phi_22, curr_imag, curr_imag);
curr_real = real_buffer[(slots - 2) * 128];
curr_imag = img_buffer[(slots - 2) * 128];
curr_real = ixheaacd_shr32(curr_real, 3);
curr_imag = ixheaacd_shr32(curr_imag, 3);
t_phi_11 = ixheaacd_mac32x16hin32(t_phi_11, curr_real, curr_real);
t_phi_11 = ixheaacd_mac32x16hin32(t_phi_11, curr_imag, curr_imag);
cov_matrix->phi_11 = t_phi_11;
cov_matrix->phi_22 = t_phi_22;
}
{
WORD32 t_phi_12 = t_phi_01;
t_phi_12 = ixheaacd_mac32x16hin32(t_phi_12, real_buffer[-128] >> 3,
real_buffer[-2 * 128] >> 3);
t_phi_12 = ixheaacd_mac32x16hin32(t_phi_12, img_buffer[-128] >> 3,
img_buffer[-2 * 128] >> 3);
t_phi_01 =
ixheaacd_mac32x16hin32(t_phi_01, real_buffer[(slots - 1) * 128] >> 3,
real_buffer[(slots - 2) * 128] >> 3);
t_phi_01 =
ixheaacd_mac32x16hin32(t_phi_01, img_buffer[(slots - 1) * 128] >> 3,
img_buffer[(slots - 2) * 128] >> 3);
cov_matrix->phi_01 = t_phi_01;
cov_matrix->phi_12 = t_phi_12;
}
{
WORD32 t_phi_12_i = t_phi_01_i;
t_phi_12_i = ixheaacd_mac32x16hin32(t_phi_12_i, img_buffer[-128] >> 3,
real_buffer[-2 * 128] >> 3);
t_phi_12_i = ixheaacd_macn32x16hin32(t_phi_12_i, real_buffer[-128] >> 3,
img_buffer[-2 * 128] >> 3);
t_phi_01_i =
ixheaacd_mac32x16hin32(t_phi_01_i, img_buffer[(slots - 1) * 128] >> 3,
real_buffer[(slots - 2) * 128] >> 3);
t_phi_01_i = ixheaacd_macn32x16hin32(t_phi_01_i,
real_buffer[(slots - 1) * 128] >> 3,
img_buffer[(slots - 2) * 128] >> 3);
cov_matrix->phi_01_im = t_phi_01_i;
cov_matrix->phi_12_im = t_phi_12_i;
}
{
WORD16 n, len_by_4, p;
WORD32 t_phi_02 = 0x00, t_phi_02_i = 0x00;
len_by_4 = (slots >> 2);
p = 0;
for (n = 0; n < len_by_4; n++) {
WORD32 real1, real2, imag1, imag2;
real1 = real_buffer[p * 128];
real2 = real_buffer[(p - 2) * 128];
imag1 = img_buffer[p * 128];
imag2 = img_buffer[(p - 2) * 128];
real1 = ixheaacd_shr32(real1, 3);
real2 = ixheaacd_shr32(real2, 3);
imag1 = ixheaacd_shr32(imag1, 3);
imag2 = ixheaacd_shr32(imag2, 3);
t_phi_02 = ixheaacd_mac32x16hin32(t_phi_02, real1, real2);
t_phi_02 = ixheaacd_mac32x16hin32(t_phi_02, imag1, imag2);
t_phi_02_i = ixheaacd_mac32x16hin32(t_phi_02_i, imag1, real2);
t_phi_02_i = ixheaacd_macn32x16hin32(t_phi_02_i, real1, imag2);
real1 = real_buffer[(p + 1) * 128];
real2 = real_buffer[(p - 1) * 128];
imag1 = img_buffer[(p + 1) * 128];
imag2 = img_buffer[(p - 1) * 128];
real1 = ixheaacd_shr32(real1, 3);
real2 = ixheaacd_shr32(real2, 3);
imag1 = ixheaacd_shr32(imag1, 3);
imag2 = ixheaacd_shr32(imag2, 3);
t_phi_02 = ixheaacd_mac32x16hin32(t_phi_02, real1, real2);
t_phi_02 = ixheaacd_mac32x16hin32(t_phi_02, imag1, imag2);
t_phi_02_i = ixheaacd_mac32x16hin32(t_phi_02_i, imag1, real2);
t_phi_02_i = ixheaacd_macn32x16hin32(t_phi_02_i, real1, imag2);
real1 = real_buffer[(p + 2) * 128];
real2 = real_buffer[p * 128];
imag1 = img_buffer[(p + 2) * 128];
imag2 = img_buffer[p * 128];
real1 = ixheaacd_shr32(real1, 3);
real2 = ixheaacd_shr32(real2, 3);
imag1 = ixheaacd_shr32(imag1, 3);
imag2 = ixheaacd_shr32(imag2, 3);
t_phi_02 = ixheaacd_mac32x16hin32(t_phi_02, real1, real2);
t_phi_02 = ixheaacd_mac32x16hin32(t_phi_02, imag1, imag2);
t_phi_02_i = ixheaacd_mac32x16hin32(t_phi_02_i, imag1, real2);
t_phi_02_i = ixheaacd_macn32x16hin32(t_phi_02_i, real1, imag2);
real1 = real_buffer[(p + 3) * 128];
real2 = real_buffer[(p + 1) * 128];
imag1 = img_buffer[(p + 3) * 128];
imag2 = img_buffer[(p + 1) * 128];
real1 = ixheaacd_shr32(real1, 3);
real2 = ixheaacd_shr32(real2, 3);
imag1 = ixheaacd_shr32(imag1, 3);
imag2 = ixheaacd_shr32(imag2, 3);
t_phi_02 = ixheaacd_mac32x16hin32(t_phi_02, real1, real2);
t_phi_02 = ixheaacd_mac32x16hin32(t_phi_02, imag1, imag2);
t_phi_02_i = ixheaacd_mac32x16hin32(t_phi_02_i, imag1, real2);
t_phi_02_i = ixheaacd_macn32x16hin32(t_phi_02_i, real1, imag2);
p += 4;
}
n = ixheaacd_shl16(len_by_4, 2);
for (; n < slots; n++) {
WORD32 real1, real2, imag1, imag2;
real1 = real_buffer[(n * 128)];
real2 = real_buffer[(n - 2) * 128];
imag1 = img_buffer[n * 128];
imag2 = img_buffer[(n - 2) * 128];
real1 = ixheaacd_shr32(real1, 3);
real2 = ixheaacd_shr32(real2, 3);
imag1 = ixheaacd_shr32(imag1, 3);
imag2 = ixheaacd_shr32(imag2, 3);
t_phi_02 = ixheaacd_mac32x16hin32(t_phi_02, real1, real2);
t_phi_02 = ixheaacd_mac32x16hin32(t_phi_02, imag1, imag2);
t_phi_02_i = ixheaacd_mac32x16hin32(t_phi_02_i, imag1, real2);
t_phi_02_i = ixheaacd_macn32x16hin32(t_phi_02_i, real1, imag2);
}
cov_matrix->phi_02 = t_phi_02;
cov_matrix->phi_02_im = t_phi_02_i;
}
ptr_real++;
pac_arr++;
}
}
static PLATFORM_INLINE VOID ixheaacd_filt_step3_lp(WORD len, WORD32 coef1,
WORD32 coef2,
WORD32 *pqmf_real_low,
WORD32 *pqmf_real_high) {
WORD32 prev1;
WORD32 prev2;
WORD32 i;
prev2 = *pqmf_real_low;
pqmf_real_low += 64;
prev1 = *pqmf_real_low;
pqmf_real_low += 64;
for (i = len; i >= 0; i -= 2) {
WORD32 curr = *pqmf_real_low;
WORD32 temp = ixheaacd_mult32x16hin32(prev2, coef2);
pqmf_real_low += 64;
*pqmf_real_high = ixheaacd_add32_sat(
(curr >> LPC_SCALE_FACTOR),
(ixheaacd_shl32_sat(ixheaacd_mac32x16hin32(temp, prev1, coef1), 1)));
pqmf_real_high += 64;
prev2 = *pqmf_real_low;
temp = ixheaacd_mult32x16hin32(prev1, coef2);
pqmf_real_low += 64;
*pqmf_real_high = ixheaacd_add32_sat(
(prev2 >> LPC_SCALE_FACTOR),
(ixheaacd_shl32_sat(ixheaacd_mac32x16hin32(temp, curr, coef1), 1)));
pqmf_real_high += 64;
prev1 = prev2;
prev2 = curr;
}
}
VOID ixheaacd_filter1_lp(ia_sbr_hf_generator_struct *hf_generator,
ixheaacd_lpp_trans_cov_matrix *cov_matrix_seq,
WORD32 *bw_array, WORD16 *degree_alias,
WORD32 start_idx, WORD32 stop_idx,
WORD32 max_qmf_subband, WORD32 start_patch,
WORD32 stop_patch, WORD32 *sub_sig_x) {
WORD16 k1, k1_below = 0, k1_below2 = 0;
WORD32 i;
WORD16 alpha_real[LPC_ORDER];
WORD32 low_band, high_band;
WORD32 patch;
WORD16 bw = 0;
WORD32 a0r, a1r;
WORD num_patches = hf_generator->pstr_settings->num_patches;
ia_patch_param_struct *patch_param =
hf_generator->pstr_settings->str_patch_param;
WORD32 bw_index[MAX_NUM_PATCHES];
memset(bw_index, 0, sizeof(WORD32) * num_patches);
for (low_band = start_patch; low_band < stop_patch; low_band++) {
ixheaacd_lpp_trans_cov_matrix *p_cov_matrix = &cov_matrix_seq[low_band];
alpha_real[1] = 0;
alpha_real[0] = 0;
if (p_cov_matrix->d != 0) {
WORD32 tmp_r, temp_real, modulus_d;
WORD16 inverse_d;
WORD32 norm_d;
norm_d = ixheaacd_norm32(p_cov_matrix->d);
inverse_d =
(WORD16)(*ixheaacd_fix_div)(0x40000000, (p_cov_matrix->d << norm_d));
modulus_d = ixheaacd_abs32(p_cov_matrix->d);
tmp_r =
(ixheaacd_sub32_sat(
ixheaacd_mult32(p_cov_matrix->phi_01, p_cov_matrix->phi_12),
ixheaacd_mult32(p_cov_matrix->phi_02, p_cov_matrix->phi_11)) >>
LPC_SCALE_FACTOR);
temp_real = ixheaacd_abs32(tmp_r);
if (temp_real < modulus_d) {
alpha_real[1] = (WORD16)(
(ixheaacd_mult32x16in32_shl_sat(tmp_r, inverse_d) << norm_d) >> 15);
}
tmp_r =
(ixheaacd_sub32_sat(
ixheaacd_mult32(p_cov_matrix->phi_02, p_cov_matrix->phi_12),
ixheaacd_mult32(p_cov_matrix->phi_01, p_cov_matrix->phi_22)) >>
LPC_SCALE_FACTOR);
temp_real = ixheaacd_abs32(tmp_r);
if (temp_real < modulus_d) {
alpha_real[0] = (WORD16)(
(ixheaacd_mult32x16in32_shl_sat(tmp_r, inverse_d) << norm_d) >> 15);
}
}
if (p_cov_matrix->phi_11 == 0) {
k1 = 0;
} else {
if (ixheaacd_abs32_sat(p_cov_matrix->phi_01) >= p_cov_matrix->phi_11) {
if (p_cov_matrix->phi_01 < 0) {
k1 = 0x7fff;
} else {
k1 = (WORD16)-0x8000;
}
} else {
k1 = -((WORD16)(
(*ixheaacd_fix_div)(p_cov_matrix->phi_01, p_cov_matrix->phi_11)));
}
}
if (low_band > 1) {
WORD16 deg = ixheaacd_sub16_sat(
0x7fff, ixheaacd_mult16_shl_sat(k1_below, k1_below));
degree_alias[low_band] = 0;
if (((low_band & 1) == 0) && (k1 < 0)) {
if (k1_below < 0) {
degree_alias[low_band] = 0x7fff;
if (k1_below2 > 0) {
degree_alias[low_band - 1] = deg;
}
} else {
if (k1_below2 > 0) {
degree_alias[low_band] = deg;
}
}
}
if (((low_band & 1) != 0) && (k1 > 0)) {
if (k1_below > 0) {
degree_alias[low_band] = 0x7fff;
if (k1_below2 < 0) {
degree_alias[low_band - 1] = deg;
}
} else {
if (k1_below2 < 0) {
degree_alias[low_band] = deg;
}
}
}
}
k1_below2 = k1_below;
k1_below = k1;
patch = 0;
while (patch < num_patches) {
ia_patch_param_struct *p_loc_patch_param = &patch_param[patch];
WORD32 bw_vec, bw_idx;
WORD16 alpha1, alpha2;
high_band = (((low_band + p_loc_patch_param->dst_end_band) << 8) >> 8);
if ((low_band < p_loc_patch_param->src_start_band) ||
(low_band >= p_loc_patch_param->src_end_band) ||
(high_band < max_qmf_subband)) {
patch++;
continue;
}
bw_idx = bw_index[patch];
while (high_band >= hf_generator->pstr_settings->bw_borders[bw_idx]) {
bw_idx++;
bw_index[patch] = bw_idx;
}
bw_vec = bw_array[bw_idx];
alpha1 = alpha_real[0];
alpha2 = alpha_real[1];
bw = ixheaacd_extract16h(bw_vec);
a0r = ixheaacd_mult16x16in32_shl(bw, alpha1);
bw = ixheaacd_mult16_shl_sat(bw, bw);
a1r = ixheaacd_mult16x16in32_shl(bw, alpha2);
{
WORD32 *p_sub_signal_xlow = sub_sig_x + low_band + ((start_idx) << 6);
WORD32 *p_sub_signal_xhigh =
sub_sig_x + high_band + ((start_idx + 2) << 6);
WORD32 len = stop_idx - start_idx - 1;
if (bw > 0) {
ixheaacd_filt_step3_lp(len, a0r, a1r, p_sub_signal_xlow,
p_sub_signal_xhigh);
} else {
p_sub_signal_xlow += 128;
for (i = len; i >= 0; i--) {
*p_sub_signal_xhigh = *p_sub_signal_xlow >> LPC_SCALE_FACTOR;
p_sub_signal_xlow += 64;
p_sub_signal_xhigh += 64;
}
}
}
patch++;
}
}
}
VOID ixheaacd_clr_subsamples(WORD32 *ptr_qmf_buf, WORD32 num, WORD32 size) {
WORD32 i;
for (i = num; i >= 0; i--) {
memset(ptr_qmf_buf, 0, sizeof(WORD32) * (size));
ptr_qmf_buf += 64;
}
}
VOID ixheaacd_low_pow_hf_generator(ia_sbr_hf_generator_struct *hf_generator,
WORD32 **qmf_real, WORD16 *degree_alias,
WORD32 start_idx, WORD32 stop_idx,
WORD32 num_if_bands, WORD32 max_qmf_subband,
WORD32 *sbr_invf_mode,
WORD32 *sbr_invf_mode_prev, WORD32 norm_max,
WORD32 *sub_sig_x) {
WORD32 bw_array[MAX_NUM_PATCHES];
WORD32 i;
WORD32 start_patch, stop_patch, low_band, high_band;
ia_patch_param_struct *patch_param =
hf_generator->pstr_settings->str_patch_param;
WORD32 patch;
ixheaacd_lpp_trans_cov_matrix cov_matrix_seq[MAX_COLS];
WORD32 actual_stop_band;
WORD32 num_patches = hf_generator->pstr_settings->num_patches;
stop_idx = (hf_generator->pstr_settings->num_columns + stop_idx);
ixheaacd_invfilt_level_emphasis(hf_generator, num_if_bands, sbr_invf_mode,
sbr_invf_mode_prev, bw_array);
actual_stop_band =
ixheaacd_add16(patch_param[num_patches - 1].dst_start_band,
patch_param[num_patches - 1].num_bands_in_patch);
{
WORD32 *p_qmf_real;
WORD32 len = 6, num;
if (len > stop_idx) len = stop_idx;
p_qmf_real = &qmf_real[start_idx][actual_stop_band];
num = (len - start_idx - 1);
ixheaacd_clr_subsamples(p_qmf_real, num,
(NO_SYNTHESIS_CHANNELS - actual_stop_band));
if (actual_stop_band < 32) {
num = (stop_idx - len - 1);
p_qmf_real = &qmf_real[len][actual_stop_band];
ixheaacd_clr_subsamples(p_qmf_real, num,
(NO_ANALYSIS_CHANNELS - actual_stop_band));
}
}
start_patch = ixheaacd_max16(
1, ixheaacd_sub16(hf_generator->pstr_settings->start_patch, 2));
stop_patch = patch_param[0].dst_start_band;
{
WORD32 *ptr = &sub_sig_x[0];
WORD32 *plpc_filt_states_real = &hf_generator->lpc_filt_states_real[0][0];
for (i = LPC_ORDER; i != 0; i--) {
memcpy(ptr, plpc_filt_states_real, sizeof(WORD32) * (stop_patch));
ptr += NO_SYNTHESIS_CHANNELS;
plpc_filt_states_real += 32;
}
}
if (norm_max != 30) {
(*ixheaacd_covariance_matrix_calc)(sub_sig_x + start_patch,
&cov_matrix_seq[start_patch],
(stop_patch - start_patch));
} else {
memset(&cov_matrix_seq[0], 0,
sizeof(ixheaacd_lpp_trans_cov_matrix) * stop_patch);
}
ixheaacd_filter1_lp(hf_generator, cov_matrix_seq, bw_array, degree_alias,
start_idx, stop_idx, max_qmf_subband, start_patch,
stop_patch, sub_sig_x);
start_patch = hf_generator->pstr_settings->start_patch;
stop_patch = hf_generator->pstr_settings->stop_patch;
for (low_band = start_patch; low_band < stop_patch; low_band++) {
WORD32 src_start_band, src_end_band, dst_start_band, dst_end_band;
patch = 0;
while (patch < num_patches) {
ia_patch_param_struct *ptr_loc_patch_param = &patch_param[patch];
src_start_band = ptr_loc_patch_param->src_start_band;
src_end_band = ptr_loc_patch_param->src_end_band;
dst_start_band = ptr_loc_patch_param->dst_start_band;
dst_end_band = ptr_loc_patch_param->dst_end_band;
high_band = (low_band + ptr_loc_patch_param->dst_end_band);
if ((low_band < src_start_band) || (low_band >= src_end_band) ||
(high_band >= NO_SYNTHESIS_CHANNELS)) {
patch++;
continue;
}
if ((high_band != dst_start_band)) {
degree_alias[high_band] = degree_alias[low_band];
}
patch++;
}
}
memcpy(hf_generator->bw_array_prev, bw_array, sizeof(WORD32) * num_if_bands);
}
VOID ixheaacd_hf_generator(ia_sbr_hf_generator_struct *hf_generator,
ia_sbr_scale_fact_struct *scale_factor,
WORD32 **qmf_real, WORD32 **qmf_imag, WORD32 factor,
WORD32 start_idx, WORD32 stop_idx,
WORD32 num_if_bands, WORD32 max_qmf_subband,
WORD32 *sbr_invf_mode, WORD32 *sbr_invf_mode_prev,
WORD32 *sub_sig_x, WORD audio_object_type) {
WORD32 bw_index[MAX_NUM_PATCHES];
WORD32 bw_array[MAX_NUM_PATCHES];
WORD32 i, j;
WORD32 start_patch, stop_patch, low_band, high_band;
ia_patch_param_struct *patch_param =
hf_generator->pstr_settings->str_patch_param;
WORD32 patch;
WORD16 alpha_real[LPC_ORDER];
WORD16 a0r, a1r;
WORD16 alpha_imag[LPC_ORDER];
WORD16 a0i = 0, a1i = 0;
WORD16 bw = 0;
ixheaacd_lpp_trans_cov_matrix cov_matrix;
ixheaacd_lpp_trans_cov_matrix cov_matrix_seq[MAX_COLS];
WORD32 common_scale;
WORD32 actual_stop_band;
WORD32 num_patches = hf_generator->pstr_settings->num_patches;
start_idx = (start_idx * factor);
stop_idx = (hf_generator->pstr_settings->num_columns + (stop_idx * factor));
ixheaacd_invfilt_level_emphasis(hf_generator, num_if_bands, sbr_invf_mode,
sbr_invf_mode_prev, bw_array);
actual_stop_band =
ixheaacd_add16(patch_param[num_patches - 1].dst_start_band,
patch_param[num_patches - 1].num_bands_in_patch);
for (i = start_idx; i < stop_idx; i++) {
WORD32 *p_qmf_real = &qmf_real[i][actual_stop_band];
WORD32 *p_qmf_imag = &qmf_imag[i][actual_stop_band];
for (j = NO_SYNTHESIS_CHANNELS - actual_stop_band; j != 0; j--) {
*p_qmf_real++ = 0;
*p_qmf_imag++ = 0;
}
}
memset(bw_index, 0, sizeof(WORD32) * num_patches);
common_scale =
ixheaacd_min32(scale_factor->ov_lb_scale, scale_factor->lb_scale);
start_patch = hf_generator->pstr_settings->start_patch;
stop_patch = hf_generator->pstr_settings->stop_patch;
{
WORD32 *ptr;
for (i = 0; i < LPC_ORDER; i++) {
ptr = sub_sig_x + (start_patch) + i * 128;
memcpy(ptr, &hf_generator->lpc_filt_states_real[i][start_patch],
sizeof(WORD32) * (stop_patch - start_patch));
memcpy(ptr + 64, &hf_generator->lpc_filt_states_imag[i][start_patch],
sizeof(WORD32) * (stop_patch - start_patch));
}
}
if (audio_object_type != AOT_ER_AAC_ELD &&
audio_object_type != AOT_ER_AAC_LD) {
(*ixheaacd_covariance_matrix_calc_2)(
&cov_matrix_seq[start_patch],
(sub_sig_x + start_patch + LPC_ORDER * 128), (stop_patch - start_patch),
38);
} else {
(*ixheaacd_covariance_matrix_calc_2)(
&cov_matrix_seq[start_patch],
(sub_sig_x + start_patch + LPC_ORDER * 128), (stop_patch - start_patch),
16);
}
for (low_band = start_patch; low_band < stop_patch; low_band++) {
FLAG reset_lpc_coeff = 0;
WORD32 max_val;
WORD32 q_shift;
WORD32 v;
max_val = ixheaacd_abs32_nrm(cov_matrix_seq[low_band].phi_01);
max_val = max_val | ixheaacd_abs32_nrm(cov_matrix_seq[low_band].phi_02);
max_val = max_val | ixheaacd_abs32_nrm(cov_matrix_seq[low_band].phi_12);
max_val = max_val | (cov_matrix_seq[low_band].phi_11);
max_val = max_val | (cov_matrix_seq[low_band].phi_22);
max_val = max_val | ixheaacd_abs32_nrm(cov_matrix_seq[low_band].phi_01_im);
max_val = max_val | ixheaacd_abs32_nrm(cov_matrix_seq[low_band].phi_02_im);
max_val = max_val | ixheaacd_abs32_nrm(cov_matrix_seq[low_band].phi_12_im);
q_shift = ixheaacd_pnorm32(max_val);
cov_matrix.phi_11 = (cov_matrix_seq[low_band].phi_11 << q_shift);
cov_matrix.phi_22 = (cov_matrix_seq[low_band].phi_22 << q_shift);
cov_matrix.phi_01 = (cov_matrix_seq[low_band].phi_01 << q_shift);
cov_matrix.phi_02 = (cov_matrix_seq[low_band].phi_02 << q_shift);
cov_matrix.phi_12 = (cov_matrix_seq[low_band].phi_12 << q_shift);
cov_matrix.phi_01_im = (cov_matrix_seq[low_band].phi_01_im << q_shift);
cov_matrix.phi_02_im = (cov_matrix_seq[low_band].phi_02_im << q_shift);
cov_matrix.phi_12_im = (cov_matrix_seq[low_band].phi_12_im << q_shift);
max_val = ixheaacd_mult32(cov_matrix.phi_12, cov_matrix.phi_12);
max_val = ixheaacd_add32_sat(
max_val, ixheaacd_mult32(cov_matrix.phi_12_im, cov_matrix.phi_12_im));
v = ixheaacd_sub32_sat(
ixheaacd_mult32(cov_matrix.phi_11, cov_matrix.phi_22), max_val)
<< 1;
cov_matrix.d = v;
alpha_real[1] = 0;
alpha_imag[1] = 0;
if (cov_matrix.d != 0) {
WORD32 tmp_r, temp_real, modulus_d;
WORD32 tmp_i, temp_imag;
WORD16 inverse_d;
WORD32 norm_d;
norm_d = ixheaacd_norm32(cov_matrix.d);
inverse_d =
(WORD16)(*ixheaacd_fix_div)(0x40000000, (cov_matrix.d << norm_d));
modulus_d = ixheaacd_abs32_sat(cov_matrix.d);
tmp_r =
(ixheaacd_sub32_sat(
ixheaacd_sub32_sat(
ixheaacd_mult32(cov_matrix.phi_01, cov_matrix.phi_12),
ixheaacd_mult32(cov_matrix.phi_01_im, cov_matrix.phi_12_im)),
ixheaacd_mult32(cov_matrix.phi_02, cov_matrix.phi_11))) >>
(LPC_SCALE_FACTOR - 1);
tmp_i = (ixheaacd_sub32_sat(
ixheaacd_add32_sat(
ixheaacd_mult32(cov_matrix.phi_01_im, cov_matrix.phi_12),
ixheaacd_mult32(cov_matrix.phi_01, cov_matrix.phi_12_im)),
ixheaacd_mult32(cov_matrix.phi_02_im, cov_matrix.phi_11))) >>
(LPC_SCALE_FACTOR - 1);
temp_imag = ixheaacd_abs32(tmp_i);
temp_real = ixheaacd_abs32(tmp_r);
if (temp_real >= modulus_d) {
reset_lpc_coeff = 1;
} else {
alpha_real[1] = (WORD16)(
(ixheaacd_mult32x16in32(tmp_r, inverse_d) << (norm_d + 1)) >> 15);
}
if (temp_imag >= modulus_d) {
reset_lpc_coeff = 1;
} else {
alpha_imag[1] = (WORD16)(
(ixheaacd_mult32x16in32(tmp_i, inverse_d) << (norm_d + 1)) >> 15);
}
}
alpha_real[0] = 0;
alpha_imag[0] = 0;
if (cov_matrix.phi_11 != 0) {
WORD32 tmp_r, temp_real;
WORD32 tmp_i = 0, temp_imag = 0;
WORD16 inverse_r11;
WORD32 norm_r11;
norm_r11 = ixheaacd_norm32(cov_matrix.phi_11);
inverse_r11 = (WORD16)(*ixheaacd_fix_div)(
0x40000000, (cov_matrix.phi_11 << norm_r11));
tmp_r = ixheaacd_add32_sat(
ixheaacd_add32(
(cov_matrix.phi_01 >> (LPC_SCALE_FACTOR + 1)),
ixheaacd_mult32x16in32(cov_matrix.phi_12, alpha_real[1])),
ixheaacd_mult32x16in32(cov_matrix.phi_12_im, alpha_imag[1]));
tmp_i = ixheaacd_sub32_sat(
ixheaacd_add32(
(cov_matrix.phi_01_im >> (LPC_SCALE_FACTOR + 1)),
ixheaacd_mult32x16in32(cov_matrix.phi_12, alpha_imag[1])),
ixheaacd_mult32x16in32(cov_matrix.phi_12_im, alpha_real[1]));
tmp_r = tmp_r << 1;
tmp_i = tmp_i << 1;
temp_imag = ixheaacd_abs32(tmp_i);
temp_real = ixheaacd_abs32(tmp_r);
if (temp_real >= cov_matrix.phi_11) {
reset_lpc_coeff = 1;
} else {
alpha_real[0] = (WORD16)(
(ixheaacd_mult32x16in32(ixheaacd_sub32_sat(0, tmp_r), inverse_r11)
<< (norm_r11 + 1)) >>
15);
}
if (temp_imag >= cov_matrix.phi_11) {
reset_lpc_coeff = 1;
} else {
alpha_imag[0] = (WORD16)(
(ixheaacd_mult32x16in32(ixheaacd_sub32_sat(0, tmp_i), inverse_r11)
<< (norm_r11 + 1)) >>
15);
}
}
if (ixheaacd_add32_sat((alpha_real[0] * alpha_real[0]),
(alpha_imag[0] * alpha_imag[0])) >= 0x40000000L) {
reset_lpc_coeff = 1;
}
if (ixheaacd_add32_sat((alpha_real[1] * alpha_real[1]),
(alpha_imag[1] * alpha_imag[1])) >= 0x40000000L) {
reset_lpc_coeff = 1;
}
if (reset_lpc_coeff) {
alpha_real[0] = 0;
alpha_real[1] = 0;
alpha_imag[0] = 0;
alpha_imag[1] = 0;
}
patch = 0;
while (patch < num_patches) {
high_band = (low_band + patch_param[patch].dst_end_band);
if ((low_band < patch_param[patch].src_start_band) ||
(low_band >= patch_param[patch].src_end_band)) {
patch++;
continue;
}
if (high_band < max_qmf_subband) {
patch++;
continue;
}
while ((bw_index[patch] < MAX_NUM_PATCHES - 1) &&
(bw_index[patch] < MAX_NUM_NOISE_VALUES) &&
(high_band >=
hf_generator->pstr_settings->bw_borders[bw_index[patch]])) {
bw_index[patch]++;
}
bw = ixheaacd_extract16h(bw_array[bw_index[patch]]);
a0r = ixheaacd_mult16_shl_sat(bw, alpha_real[0]);
a0i = ixheaacd_mult16_shl_sat(bw, alpha_imag[0]);
bw = ixheaacd_mult16_shl_sat(bw, bw);
a1r = ixheaacd_mult16_shl_sat(bw, alpha_real[1]);
a1i = ixheaacd_mult16_shl_sat(bw, alpha_imag[1]);
if (bw > 0) {
ixheaacd_filterstep3(a0r, a0i, a1r, a1i, start_idx, stop_idx, low_band,
high_band, sub_sig_x);
} else {
WORD32 *p_src = sub_sig_x + low_band + ((start_idx + 2) << 7);
WORD32 *p_dst = sub_sig_x + high_band + ((start_idx + 2) << 7);
for (i = stop_idx - start_idx; i != 0; i--) {
*(p_dst) = *(p_src) >> LPC_SCALE_FACTOR;
p_src += 64;
p_dst += 64;
*(p_dst) = *(p_src) >> LPC_SCALE_FACTOR;
p_src += 64;
p_dst += 64;
}
}
patch++;
}
}
memcpy(hf_generator->bw_array_prev, bw_array, sizeof(WORD32) * num_if_bands);
scale_factor->hb_scale = (WORD16)(common_scale - LPC_SCALE_FACTOR);
}
Reference in new issue View Git Blame Copy Permalink