wrapper/libxaac
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
libxaac/encoder/iusace_tcx_enc.c
Akshay Ragir a00a8d3c2c Fix for the Divide-by-zero in iusace_tcx_fac_encode 
These changes handle the Divide-by-zero runtime error
reported by correcting the TCX pre-shaping and
shaping related parameters.

Bug: ossFuzz:61899
Test: poc in bug
2023-09-01 21:42:20 +05:30

844 lines
26 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 <math.h>
#include "ixheaac_type_def.h"
#include "ixheaace_adjust_threshold_data.h"
#include "iusace_bitbuffer.h"
/* DRC */
#include "impd_drc_common_enc.h"
#include "impd_drc_uni_drc.h"
#include "impd_drc_tables.h"
#include "impd_drc_api.h"
#include "impd_drc_uni_drc_eq.h"
#include "impd_drc_uni_drc_filter_bank.h"
#include "impd_drc_gain_enc.h"
#include "impd_drc_struct_def.h"
#include "iusace_cnst.h"
#include "iusace_tns_usac.h"
#include "iusace_psy_mod.h"
#include "iusace_tns_usac.h"
#include "iusace_config.h"
#include "iusace_fft.h"
#include "iusace_tcx_mdct.h"
#include "iusace_arith_enc.h"
#include "iusace_fd_qc_util.h"
#include "iusace_fd_quant.h"
#include "iusace_block_switch_const.h"
#include "iusace_block_switch_struct_def.h"
#include "iusace_ms.h"
#include "iusace_signal_classifier.h"
#include "ixheaace_sbr_header.h"
#include "ixheaace_config.h"
#include "ixheaace_asc_write.h"
#include "iusace_main.h"
#include "iusace_lpd_rom.h"
#include "iusace_lpd.h"
#include "iusace_avq_enc.h"
#include "ixheaace_common_utils.h"
const UWORD32 iusace_pow10_gain_div28[128] = {
1024, 1112, 1207, 1311, 1423, 1545, 1677, 1821, 1977,
2146, 2330, 2530, 2747, 2983, 3238, 3516, 3817, 4144,
4499, 4885, 5304, 5758, 6252, 6788, 7370, 8001, 8687,
9432, 10240, 11118, 12071, 13105, 14228, 15448, 16772, 18210,
19770, 21465, 23305, 25302, 27471, 29825, 32382, 35157, 38171,
41442, 44994, 48851, 53038, 57584, 62519, 67878, 73696, 80012,
86870, 94316, 102400, 111177, 120706, 131052, 142284, 154480, 167720,
182096, 197703, 214649, 233047, 253021, 274708, 298254, 323817, 351572,
381706, 414422, 449943, 488508, 530378, 575838, 625193, 678779, 736958,
800124, 868703, 943161, 1024000, 1111768, 1207059, 1310517, 1422843, 1544797,
1677203, 1820958, 1977034, 2146488, 2330466, 2530213, 2747080, 2982536, 3238172,
3515720, 3817056, 4144220, 4499426, 4885077, 5303782, 5758375, 6251932, 6787792,
7369581, 8001236, 8687031, 9431606, 10240000, 11117682, 12070591, 13105175, 14228434,
15447969, 16772032, 18209581, 19770345, 21464883, 23304662, 25302131, 27470805, 29825358,
32381723, 35157197};
static const FLOAT64 iusace_lpc_pre_twid_cos[ORDER + 1] = {1.0,
0.99969881867944277,
0.99879545613814691,
0.99729045666498317,
0.99518472640441780,
0.99247953486470630,
0.98917650991010153,
0.98527764316379052,
0.98078527933727178,
0.97570212991605565,
0.97003125425052761,
0.96377606826277584,
0.95694033551585822,
0.94952817722361749,
0.94154406823678738,
0.93299279849944938,
0.92387952832938047};
static const FLOAT64 iusace_lpc_pre_twid_sin[ORDER + 1] = {0,
0.024541229205697054,
0.049067675691753569,
0.073564563785488826,
0.098017143048367339,
0.12241067304257494,
0.14673047482398086,
0.17096188429473480,
0.19509032737506427,
0.21910124070226658,
0.24298017568754085,
0.26671274855909161,
0.29028467796767482,
0.31368175059826858,
0.33688984485751389,
0.35989503740419343,
0.38268344246110436};
static VOID iusace_lpc_mdct(FLOAT32 *ptr_lpc_coeffs, FLOAT32 *mdct_gains, WORD32 length,
iusace_scratch_mem *pstr_scratch) {
FLOAT32 *in_out = pstr_scratch->p_in_out_tcx;
WORD32 i;
for (i = 0; i < ORDER + 1; i++) {
in_out[2 * i] = (FLOAT32)(ptr_lpc_coeffs[i] * iusace_lpc_pre_twid_cos[i]);
in_out[2 * i + 1] = (FLOAT32)(-ptr_lpc_coeffs[i] * iusace_lpc_pre_twid_sin[i]);
}
for (; i < length; i++) {
in_out[2 * i] = 0.f;
in_out[2 * i + 1] = 0.f;
}
iusace_complex_fft(in_out, length, pstr_scratch);
for (i = 0; i<length>> 1; i++) {
mdct_gains[i] = (FLOAT32)(
1.0f / sqrt(in_out[2 * i] * in_out[2 * i] + in_out[2 * i + 1] * in_out[2 * i + 1]));
}
return;
}
UWORD32 iusace_rounded_sqrt(UWORD32 pos_num) {
UWORD32 num = pos_num;
UWORD32 value = 0;
UWORD32 bit_set = 1 << 30;
while (bit_set > num) {
bit_set >>= 2;
}
while (bit_set) {
if (num >= value + bit_set) {
num -= value + bit_set;
value += bit_set << 1;
}
value >>= 1;
bit_set >>= 2;
}
num = value + 1;
if (num * num - pos_num < pos_num - value * value) {
return num;
}
return value;
}
static VOID iusace_noise_shaping(FLOAT32 *rr, WORD32 lg, WORD32 M, FLOAT32 *gain1,
FLOAT32 *gain2) {
WORD32 i, k;
FLOAT32 r, r_prev, g1, g2, a = 0, b = 0;
k = lg/M;
r_prev = 0;
for (i = 0; i < lg; i++) {
if ((i % k) == 0) {
g1 = gain1[i / k];
g2 = gain2[i / k];
a = 2.0f * g1 * g2 / (g1 + g2);
b = (g2 - g1) / (g1 + g2);
}
r = a * rr[i] + b * r_prev;
rr[i] = r;
r_prev = r;
}
return;
}
static VOID iusace_pre_shaping(FLOAT32 *rr, WORD32 lg, WORD32 M, FLOAT32 *gain1, FLOAT32 *gain2) {
WORD32 i, k;
FLOAT32 r, r_prev, g1, g2, a = 0, b = 0;
k = lg / M;
r_prev = 0;
for (i = 0; i < lg; i++) {
if ((i % k) == 0) {
g1 = gain1[i / k];
g2 = gain2[i / k];
a = (g1 + g2) / (2.0f * g1 * g2);
b = (g1 - g2) / (2.0f * g1 * g2);
}
r = a * rr[i] + b * r_prev;
r_prev = rr[i];
rr[i] = r;
}
return;
}
static VOID iusace_adapt_lo_freq_emph(FLOAT32 *signal, WORD32 length) {
WORD32 i, j, i_max;
FLOAT32 max_energy, factor, temp;
i_max = length >> 2;
max_energy = 0.01f;
for (i = 0; i < i_max; i += 8) {
temp = 0.01f;
for (j = i; j < i + 8; j++) {
temp += signal[j] * signal[j];
}
if (temp > max_energy) {
max_energy = temp;
}
}
factor = 10.0f;
for (i = 0; i < i_max; i += 8) {
temp = 0.01f;
for (j = i; j < i + 8; j++) {
temp += signal[j] * signal[j];
}
temp = (FLOAT32)sqrt(sqrt(max_energy / temp));
if (temp < factor) {
factor = temp;
}
for (j = i; j < i + 8; j++) {
signal[j] *= factor;
}
}
return;
}
static VOID iusace_adapt_lo_freq_deemph(FLOAT32 *signal, WORD32 length, FLOAT32 *gains) {
WORD32 i, j, i_max;
FLOAT32 max_energy, factor, energy, rm;
i_max = length >> 2;
max_energy = 0.01f;
for (i = 0; i < i_max; i += 8) {
energy = 0.01f;
for (j = i; j < i + 8; j++) {
energy += signal[j] * signal[j];
}
if (energy > max_energy) {
max_energy = energy;
}
}
factor = 0.1f;
for (i = 0; i < i_max; i += 8) {
energy = 0.01f;
for (j = i; j < i + 8; j++) {
energy += signal[j] * signal[j];
}
rm = (FLOAT32)sqrt(energy / max_energy);
if (rm > factor) {
factor = rm;
}
for (j = i; j < i + 8; j++) {
signal[j] *= factor;
}
gains[i / 8] = factor;
}
return;
}
VOID iusace_tcx_fac_encode(ia_usac_data_struct *usac_data, FLOAT32 *lpc_coeffs,
FLOAT32 *lpc_coeffs_quant, FLOAT32 *speech, WORD32 frame_len,
WORD32 num_bits_per_supfrm, ia_usac_lpd_state_struct *lpd_state,
WORD32 *params, WORD32 *n_param, WORD32 ch_idx, WORD32 k_idx) {
ia_usac_td_encoder_struct *st = usac_data->td_encoder[ch_idx];
iusace_scratch_mem *pstr_scratch = &usac_data->str_scratch;
FLOAT32 *weighted_sig = &pstr_scratch->p_wsig_buf[k_idx * st->len_subfrm];
FLOAT32 *wsynth = pstr_scratch->p_wsyn_tcx_buf;
FLOAT32 *synth = pstr_scratch->p_synth_tcx_buf;
WORD32 i, k, n, mode, i_subfr, lg, lext, index, target_bits;
FLOAT32 tmp, gain, fac_ns, energy, gain_tcx, nsfill_en_thres;
FLOAT32 *ptr_lp_flt_coeffs, lp_flt_coeffs[ORDER + 1];
const FLOAT32 *sine_window_prev, *sine_window;
FLOAT32 mem_tcx_q;
FLOAT32 *xn;
FLOAT32 *xn1 = pstr_scratch->p_xn1_tcx;
FLOAT32 *xn_buf = pstr_scratch->p_xn_buf_tcx;
FLOAT32 *x = pstr_scratch->p_x_tcx;
FLOAT32 *x_tmp = pstr_scratch->p_x_tmp_tcx;
FLOAT32 *en = pstr_scratch->p_en_tcx;
FLOAT32 sq_gain;
FLOAT32 gain_prev, gain_next;
FLOAT32 *alfd_gains = pstr_scratch->p_alfd_gains_tcx;
FLOAT32 *sq_enc = pstr_scratch->p_sq_enc_tcx;
WORD32 *sq_quant = pstr_scratch->p_sq_quant_tcx;
FLOAT32 sq_err_energy;
WORD32 max_k;
FLOAT32 *gain1 = pstr_scratch->p_gain1_tcx;
FLOAT32 *gain2 = pstr_scratch->p_gain2_tcx;
FLOAT32 *facelp = pstr_scratch->p_facelp_tcx;
FLOAT32 *xn2 = pstr_scratch->p_xn2_tcx;
FLOAT32 *fac_window = pstr_scratch->p_fac_window_tcx;
FLOAT32 *x1 = pstr_scratch->p_x1_tcx;
FLOAT32 *x2 = pstr_scratch->p_x2_tcx;
WORD32 *y = pstr_scratch->p_y_tcx;
WORD32 TTT;
FLOAT32 corr = 0;
WORD32 len_subfrm = st->len_subfrm;
WORD32 fac_length = len_subfrm >> 1;
WORD32 fac_len_prev, fac_len;
if (frame_len == 4 * st->len_subfrm) {
if (st->last_was_short) {
fac_len_prev = (st->len_frame) / 16;
} else {
fac_len_prev = st->len_subfrm / 2;
}
if (st->next_is_short) {
fac_len = (st->len_frame) / 16;
} else {
fac_len = st->len_subfrm / 2;
}
} else if (frame_len == 2 * st->len_subfrm) {
if (k_idx == 0 && st->last_was_short) {
fac_len_prev = (st->len_frame) / 16;
} else {
fac_len_prev = st->len_subfrm / 2;
}
if (k_idx == 2 && st->next_is_short) {
fac_len = (st->len_frame) / 16;
} else {
fac_len = st->len_subfrm / 2;
}
} else {
if (k_idx == 0 && st->last_was_short) {
fac_len_prev = (st->len_frame) / 16;
} else {
fac_len_prev = st->len_subfrm / 2;
}
if (k_idx == 3 && st->next_is_short) {
fac_len = (st->len_frame) / 16;
} else {
fac_len = st->len_subfrm / 2;
}
}
memset(xn_buf, 0, (128 + frame_len + 128) * sizeof(FLOAT32));
mode = frame_len / len_subfrm;
if (mode > 2) {
mode = 3;
}
if (lpd_state->mode == 0) {
params += fac_len_prev;
}
switch (fac_len_prev) {
case 64:
sine_window_prev = iusace_sin_window_128;
break;
default:
sine_window_prev = iusace_sin_window_256;
break;
}
switch (fac_len) {
case 64:
sine_window = iusace_sin_window_128;
break;
default:
sine_window = iusace_sin_window_256;
break;
}
lg = frame_len;
lext = fac_length;
xn = xn_buf + fac_length;
*n_param = lg;
target_bits = num_bits_per_supfrm - 10;
for (i = 0; i < fac_length; i++) {
xn_buf[i] = lpd_state->tcx_mem[i + 128 - fac_length];
}
memcpy(xn, speech, (frame_len + fac_length) * sizeof(FLOAT32));
tmp = xn[-1];
iusace_apply_deemph(xn, TILT_FAC, frame_len, &tmp);
memcpy(lpd_state->tcx_mem, &xn[frame_len - 128], 128 * sizeof(FLOAT32));
memcpy(&xn[frame_len], &speech[frame_len], lext * sizeof(FLOAT32));
iusace_apply_deemph(&xn[frame_len], TILT_FAC, lext, &tmp);
for (i = 0; i < ORDER + fac_len_prev; i++) {
xn1[i] = xn_buf[fac_length - ORDER + i];
}
for (i = 0; i < ORDER + fac_len; i++) {
xn2[i] = xn_buf[frame_len - ORDER + i];
}
if (lpd_state->mode >= -1) {
for (i = 0; i < fac_length - fac_len_prev; i++) {
xn_buf[i] = 0.0f;
}
for (i = fac_length - fac_len_prev; i < (fac_length + fac_len_prev); i++) {
xn_buf[i] *= sine_window_prev[i - fac_length + fac_len_prev];
}
for (i = 0; i < (2 * fac_len); i++) {
xn_buf[frame_len + fac_length - fac_len + i] *= sine_window[(2 * fac_len) - 1 - i];
}
for (i = 0; i < fac_length - fac_len; i++) {
xn_buf[frame_len + fac_length + fac_len + i] = 0.0f;
}
}
iusace_tcx_mdct_main(xn_buf, x, (2 * fac_length), frame_len - (2 * fac_length),
(2 * fac_length), pstr_scratch);
iusace_get_weighted_lpc(lpc_coeffs_quant + (ORDER + 1), lp_flt_coeffs);
iusace_lpc_mdct(lp_flt_coeffs, gain1, ((FDNS_RESOLUTION * len_subfrm) / LEN_FRAME) << 1,
pstr_scratch);
iusace_get_weighted_lpc(lpc_coeffs_quant + (2 * (ORDER + 1)), lp_flt_coeffs);
iusace_lpc_mdct(lp_flt_coeffs, gain2, ((FDNS_RESOLUTION * len_subfrm) / LEN_FRAME) << 1,
pstr_scratch);
iusace_pre_shaping(x, lg, ((FDNS_RESOLUTION * len_subfrm) / LEN_FRAME), gain1, gain2);
for (i = 0; i < lg; i++) {
x_tmp[i] = x[i];
}
iusace_adapt_lo_freq_emph(x, lg);
sq_gain = iusace_calc_sq_gain(x, target_bits, lg, pstr_scratch->p_sq_gain_en);
for (i = 0; i < lg; i++) {
sq_enc[i] = x[i] / sq_gain;
if (sq_enc[i] > 0.f)
sq_quant[i] = ((WORD32)(0.5f + sq_enc[i]));
else
sq_quant[i] = ((WORD32)(-0.5f + sq_enc[i]));
}
for (i = 0; i < lg; i++) {
params[i + 2] = sq_quant[i];
x[i] = (FLOAT32)sq_quant[i];
}
for (i = 0; i < lg; i++) {
en[i] = x[i] * x[i];
}
if (mode == 3) {
tmp = 0.9441f;
} else if (mode == 2) {
tmp = 0.8913f;
} else {
tmp = 0.7943f;
}
energy = 0.0f;
for (i = 0; i < lg; i++) {
if (en[i] > energy) {
energy = en[i];
}
en[i] = energy;
energy *= tmp;
}
energy = 0.0f;
for (i = lg - 1; i >= 0; i--) {
if (en[i] > energy) {
energy = en[i];
}
en[i] = energy;
energy *= tmp;
}
nsfill_en_thres = 0.707f;
tmp = 0.0625f;
k = 1;
for (i = 0; i < lg; i++) {
if (en[i] <= nsfill_en_thres) {
tmp += sq_enc[i] * sq_enc[i];
k++;
}
}
iusace_adapt_lo_freq_deemph(x, lg, alfd_gains);
energy = 1e-6f;
for (i = 0; i < lg; i++) {
corr += x_tmp[i] * x[i];
energy += x[i] * x[i];
}
gain_tcx = (corr / energy);
if (gain_tcx == 0.0f) {
gain_tcx = sq_gain;
}
energy = 0.0001f;
for (i = 0; i < lg; i++) {
tmp = x_tmp[i] - gain_tcx * x[i];
energy += tmp * tmp;
}
tmp = (FLOAT32)sqrt((energy * (2.0f / (FLOAT32)lg)) / (FLOAT32)lg);
for (i = 0; i < frame_len; i++) {
wsynth[i] = weighted_sig[i] + tmp;
}
energy = 0.01f;
for (i = 0; i < lg; i++) {
energy += x[i] * x[i];
}
tmp = (FLOAT32)(2.0f * sqrt(energy) / (FLOAT32)lg);
gain = gain_tcx * tmp;
index = (WORD32)floor(0.5f + (28.0f * (FLOAT32)log10(gain)));
if (index < 0) {
index = 0;
}
if (index > 127) {
index = 127;
}
params[1] = index;
gain_tcx = (FLOAT32)pow(10.0f, ((FLOAT32)index) / 28.0f) / tmp;
st->gain_tcx = gain_tcx;
sq_err_energy = 0.f;
n = 0;
for (k = lg / 2; k < lg;) {
tmp = 0.f;
max_k = MIN(lg, k + 8);
for (i = k; i < max_k; i++) {
tmp += (FLOAT32)sq_quant[i] * sq_quant[i];
}
if (tmp == 0.f) {
tmp = 0.f;
for (i = k; i < max_k; i++) {
tmp += sq_enc[i] * sq_enc[i];
}
sq_err_energy += (FLOAT32)log10((tmp / (FLOAT64)8) + 0.000000001);
n += 1;
}
k = max_k;
}
if (n > 0) {
fac_ns = (FLOAT32)pow(10., sq_err_energy / (FLOAT64)(2 * n));
} else {
fac_ns = 0.f;
}
tmp = 8.0f - (16.0f * fac_ns);
index = (WORD32)floor(tmp + 0.5);
if (index < 0) {
index = 0;
}
if (index > 7) {
index = 7;
}
params[0] = index;
iusace_noise_shaping(x, lg, ((FDNS_RESOLUTION * len_subfrm) / LEN_FRAME), gain1, gain2);
iusace_tcx_imdct(x, xn_buf, (2 * fac_length), frame_len - (2 * fac_length), (2 * fac_length),
pstr_scratch);
for (i = 0; i < frame_len + (2 * fac_length); i++) {
xn_buf[i] = xn_buf[i] * (2.0f / lg);
}
for (i = 0; i < fac_len_prev; i++) {
fac_window[i] = sine_window_prev[i] * sine_window_prev[(2 * fac_len_prev) - 1 - i];
fac_window[fac_len_prev + i] =
1.0f - (sine_window_prev[fac_len_prev + i] * sine_window_prev[fac_len_prev + i]);
}
for (i = 0; i < fac_len_prev; i++) {
xn1[ORDER + i] -= sq_gain * xn_buf[fac_length + i] * sine_window_prev[fac_len_prev + i];
}
for (i = 0; i < fac_len; i++) {
xn2[ORDER + i] -= sq_gain * xn_buf[i + frame_len] * sine_window[(2 * fac_len) - 1 - i];
}
for (i = 0; i < ORDER; i++) {
xn1[i] -= lpd_state->tcx_quant[1 + 128 - ORDER + i];
xn2[i] -= sq_gain * xn_buf[frame_len - ORDER + i];
}
for (i = 0; i < fac_len_prev; i++) {
facelp[i] = lpd_state->tcx_quant[1 + 128 + i] * fac_window[fac_len_prev + i] +
lpd_state->tcx_quant[1 + 128 - 1 - i] * fac_window[fac_len_prev - 1 - i];
}
energy = 0.0f;
for (i = 0; i < fac_len_prev; i++) energy += xn1[ORDER + i] * xn1[ORDER + i];
energy *= 2.0f;
tmp = 0.0f;
for (i = 0; i < fac_len_prev; i++) tmp += facelp[i] * facelp[i];
if (tmp > energy)
gain = (FLOAT32)sqrt(energy / tmp);
else
gain = 1.0f;
for (i = 0; i < fac_len_prev; i++) {
xn1[ORDER + i] -= gain * facelp[i];
}
iusace_get_weighted_lpc(lpc_coeffs_quant + (ORDER + 1), lp_flt_coeffs);
iusace_compute_lp_residual(lp_flt_coeffs, xn1 + ORDER, x1, fac_len_prev);
iusace_get_weighted_lpc(lpc_coeffs_quant + (2 * (ORDER + 1)), lp_flt_coeffs);
iusace_compute_lp_residual(lp_flt_coeffs, xn2 + ORDER, x2, fac_len);
iusace_tcx_mdct(x1, x1, fac_len_prev, pstr_scratch);
iusace_tcx_mdct(x2, x2, fac_len, pstr_scratch);
gain_prev = (FLOAT32)(sq_gain * 0.5f * sqrt(((FLOAT32)fac_len_prev) / (FLOAT32)frame_len));
gain_next = (FLOAT32)(sq_gain * 0.5f * sqrt(((FLOAT32)fac_len) / (FLOAT32)frame_len));
for (i = 0; i < fac_len_prev; i++) {
x1[i] /= gain_prev;
}
for (i = 0; i < fac_len; i++) {
x2[i] /= gain_next;
}
for (i = 0; i < fac_len_prev / 4; i++) {
k = i * lg / (8 * fac_len_prev);
x1[i] /= alfd_gains[k];
}
for (i = 0; i < fac_len / 4; i++) {
k = i * lg / (8 * fac_len);
x2[i] /= alfd_gains[k];
}
for (i = 0; i < fac_len; i += 8) {
iusace_find_nearest_neighbor(&x2[i], &y[i]);
}
for (i = 0; i < fac_len; i++) {
lpd_state->avq_params[i] = y[i];
x2[i] = (FLOAT32)y[i];
}
for (i = 0; i < fac_len_prev; i += 8) {
iusace_find_nearest_neighbor(&x1[i], &y[i]);
}
for (i = 0; i < fac_len_prev; i++) {
x1[i] = (FLOAT32)y[i];
}
gain_prev = (FLOAT32)(gain_tcx * 0.5f * sqrt(((FLOAT32)fac_len_prev) / (FLOAT32)frame_len));
gain_next = (FLOAT32)(gain_tcx * 0.5f * sqrt(((FLOAT32)fac_len) / (FLOAT32)frame_len));
for (i = 0; i < fac_len_prev; i++) {
x1[i] *= gain_prev;
}
for (i = 0; i < fac_len; i++) {
x2[i] *= gain_next;
}
for (i = 0; i<fac_len_prev>> 2; i++) {
k = i * lg / (fac_len_prev << 3);
x1[i] *= alfd_gains[k];
}
for (i = 0; i<fac_len>> 2; i++) {
k = i * lg / (fac_len << 3);
x2[i] *= alfd_gains[k];
}
iusace_tcx_mdct(x1, xn1, fac_len_prev, pstr_scratch);
iusace_tcx_mdct(x2, xn2, fac_len, pstr_scratch);
FLOAT32 coeff1 = (2.0f / (FLOAT32)fac_len_prev), coeff2 = (2.0f / (FLOAT32)fac_len);
for (i = 0; i < fac_len_prev; i++) {
xn1[i] = xn1[i] * coeff1;
}
for (i = 0; i < fac_len; i++) {
xn2[i] = xn2[i] * coeff2;
}
memset(xn1 + fac_len_prev, 0, fac_len_prev * sizeof(FLOAT32));
memset(xn2 + fac_len, 0, fac_len * sizeof(FLOAT32));
iusace_get_weighted_lpc(lpc_coeffs_quant + (ORDER + 1), lp_flt_coeffs);
iusace_synthesis_tool_float(lp_flt_coeffs, xn1, xn1, 2 * fac_len_prev, xn1 + fac_len_prev,
pstr_scratch->p_buf_synthesis_tool);
iusace_get_weighted_lpc(lpc_coeffs_quant + (2 * (ORDER + 1)), lp_flt_coeffs);
iusace_synthesis_tool_float(lp_flt_coeffs, xn2, xn2, fac_len, xn2 + fac_len,
pstr_scratch->p_buf_synthesis_tool);
for (i = 0; i < fac_len_prev; i++) {
xn1[i] += facelp[i];
}
for (i = 0; i < frame_len + (fac_length << 1); i++) {
xn_buf[i] *= gain_tcx;
}
if (lpd_state->mode >= -1) {
for (i = 0; i < (2 * fac_len_prev); i++) {
xn_buf[i + fac_length - fac_len_prev] *= sine_window_prev[i];
}
for (i = 0; i < fac_length - fac_len_prev; i++) {
xn_buf[i] = 0.0f;
}
}
for (i = 0; i < (2 * fac_len); i++) {
xn_buf[i + frame_len + fac_length - fac_len] *= sine_window[(2 * fac_len) - 1 - i];
}
for (i = 0; i < fac_length - fac_len; i++) {
xn_buf[i + frame_len + fac_length + fac_len] = 0.0f;
}
if (lpd_state->mode != 0) {
for (i = 0; i < (2 * fac_length); i++) {
xn_buf[i] += lpd_state->tcx_quant[1 + 128 - fac_length + i];
}
mem_tcx_q = lpd_state->tcx_quant[128 - fac_length];
} else {
for (i = 0; i < fac_len_prev; i++) {
params[i - fac_len_prev] = y[i];
}
for (i = 0; i < (2 * fac_len_prev); i++) {
xn_buf[i + fac_length] += xn1[i];
}
mem_tcx_q = lpd_state->tcx_quant[128];
}
memcpy(lpd_state->tcx_quant, xn_buf + frame_len + fac_length - 128 - 1,
(1 + 256) * sizeof(FLOAT32));
for (i = 0; i < fac_len; i++) {
xn_buf[i + frame_len + (fac_length - fac_len)] += xn2[i];
}
if (lpd_state->mode > 0) {
iusace_apply_preemph(xn_buf, TILT_FAC, fac_length, &mem_tcx_q);
ptr_lp_flt_coeffs = lpd_state->lpc_coeffs_quant;
TTT = fac_length % LEN_SUBFR;
if (TTT != 0) {
memcpy(&(lpd_state->synth[ORDER + 128 - fac_length]), &xn_buf[0], TTT * sizeof(FLOAT32));
iusace_compute_lp_residual(ptr_lp_flt_coeffs, &(lpd_state->synth[ORDER + 128 - fac_length]),
&(lpd_state->acelp_exc[(2 * len_subfrm) - fac_length]), TTT);
ptr_lp_flt_coeffs += (ORDER + 1);
}
for (i_subfr = TTT; i_subfr < fac_length; i_subfr += LEN_SUBFR) {
memcpy(&(lpd_state->synth[ORDER + 128 - fac_length + i_subfr]), &xn_buf[i_subfr],
LEN_SUBFR * sizeof(FLOAT32));
iusace_compute_lp_residual(
ptr_lp_flt_coeffs, &(lpd_state->synth[ORDER + 128 - fac_length + i_subfr]),
&(lpd_state->acelp_exc[(2 * len_subfrm) - fac_length + i_subfr]), LEN_SUBFR);
ptr_lp_flt_coeffs += (ORDER + 1);
}
ptr_lp_flt_coeffs = lpd_state->lpc_coeffs;
for (i_subfr = 0; i_subfr < fac_length; i_subfr += LEN_SUBFR) {
iusace_get_weighted_lpc(ptr_lp_flt_coeffs, lp_flt_coeffs);
iusace_compute_lp_residual(lp_flt_coeffs,
&(lpd_state->synth[ORDER + 128 - fac_length + i_subfr]),
&(lpd_state->wsynth[1 + 128 - fac_length + i_subfr]), LEN_SUBFR);
ptr_lp_flt_coeffs += (ORDER + 1);
}
tmp = lpd_state->wsynth[0 + 128 - fac_length];
iusace_apply_deemph(&(lpd_state->wsynth[1 + 128 - fac_length]), TILT_FAC, fac_length, &tmp);
}
k = ((frame_len / LEN_SUBFR) - 2) * (ORDER + 1);
memcpy(lpd_state->lpc_coeffs, lpc_coeffs + k, 2 * (ORDER + 1) * sizeof(FLOAT32));
memcpy(lpd_state->lpc_coeffs_quant, lpc_coeffs_quant + (2 * (ORDER + 1)),
(ORDER + 1) * sizeof(FLOAT32));
memcpy(lpd_state->lpc_coeffs_quant + (ORDER + 1), lpd_state->lpc_coeffs_quant,
(ORDER + 1) * sizeof(FLOAT32));
memcpy(synth - 128, &(lpd_state->synth[ORDER]), 128 * sizeof(FLOAT32));
lpd_state->tcx_fac = xn[frame_len - 1];
iusace_apply_preemph(xn, TILT_FAC, frame_len, &mem_tcx_q);
for (i_subfr = 0; i_subfr < frame_len; i_subfr += LEN_SUBFR) {
memcpy(&synth[i_subfr], &xn[i_subfr], LEN_SUBFR * sizeof(FLOAT32));
iusace_compute_lp_residual(lpc_coeffs_quant + (2 * (ORDER + 1)), &synth[i_subfr],
&xn[i_subfr], LEN_SUBFR);
}
memcpy(lpd_state->synth, synth + frame_len - (ORDER + 128), (ORDER + 128) * sizeof(FLOAT32));
if (frame_len == len_subfrm) {
memcpy(x, lpd_state->acelp_exc + len_subfrm, len_subfrm * sizeof(FLOAT32));
memcpy(lpd_state->acelp_exc, x, len_subfrm * sizeof(FLOAT32));
memcpy(lpd_state->acelp_exc + len_subfrm, xn, len_subfrm * sizeof(FLOAT32));
} else {
memcpy(lpd_state->acelp_exc, xn + frame_len - (2 * len_subfrm),
2 * len_subfrm * sizeof(FLOAT32));
}
memcpy(wsynth - 128, &(lpd_state->wsynth[1]), 128 * sizeof(FLOAT32));
ptr_lp_flt_coeffs = lpc_coeffs;
for (i_subfr = 0; i_subfr < frame_len; i_subfr += LEN_SUBFR) {
iusace_get_weighted_lpc(ptr_lp_flt_coeffs, lp_flt_coeffs);
iusace_compute_lp_residual(lp_flt_coeffs, &synth[i_subfr], &wsynth[i_subfr], LEN_SUBFR);
ptr_lp_flt_coeffs += (ORDER + 1);
}
tmp = wsynth[-1];
iusace_apply_deemph(wsynth, TILT_FAC, frame_len, &tmp);
memcpy(lpd_state->wsynth, wsynth + frame_len - (1 + 128), (1 + 128) * sizeof(FLOAT32));
lpd_state->mode = mode;
lpd_state->num_bits = 10 + target_bits;
return;
}
Reference in a new issue View git blame Copy permalink