mirror of
https://github.com/mollyim/webrtc.git
synced 2025-05-14 14:20:45 +01:00
7ba22b8eea
The audio processing code is using parts of the iSAC codec to do voice activity detection (VAD), but it's undesirable for it to pull in the entire iSAC codec as a dependency. So this CL factors out the parts of iSAC that's needed for VAD to a separate build target. Bug: webrtc:8396 Change-Id: I884e25d8fd0bc815fca664352b0573b4b173880e Reviewed-on: https://webrtc-review.googlesource.com/69640 Reviewed-by: Henrik Lundin <henrik.lundin@webrtc.org> Commit-Queue: Karl Wiberg <kwiberg@webrtc.org> Cr-Commit-Position: refs/heads/master@{#23110}
496 lines
17 KiB
C
496 lines
17 KiB
C
/*
|
|
* Copyright (c) 2011 The WebRTC project authors. All Rights Reserved.
|
|
*
|
|
* Use of this source code is governed by a BSD-style license
|
|
* that can be found in the LICENSE file in the root of the source
|
|
* tree. An additional intellectual property rights grant can be found
|
|
* in the file PATENTS. All contributing project authors may
|
|
* be found in the AUTHORS file in the root of the source tree.
|
|
*/
|
|
|
|
#include <math.h>
|
|
#include <string.h>
|
|
|
|
#include "modules/audio_coding/codecs/isac/main/source/lpc_analysis.h"
|
|
#include "modules/audio_coding/codecs/isac/main/source/settings.h"
|
|
#include "modules/audio_coding/codecs/isac/main/source/codec.h"
|
|
#include "modules/audio_coding/codecs/isac/main/source/entropy_coding.h"
|
|
#include "modules/audio_coding/codecs/isac/main/source/filter_functions.h"
|
|
#include "modules/audio_coding/codecs/isac/main/source/isac_vad.h"
|
|
|
|
/* window */
|
|
/* Matlab generation code:
|
|
* t = (1:256)/257; r = 1-(1-t).^.45; w = sin(r*pi).^3; w = w/sum(w); plot((1:256)/8, w); grid;
|
|
* for k=1:16, fprintf(1, '%.8f, ', w(k*16 + (-15:0))); fprintf(1, '\n'); end
|
|
*/
|
|
static const double kLpcCorrWindow[WINLEN] = {
|
|
0.00000000, 0.00000001, 0.00000004, 0.00000010, 0.00000020,
|
|
0.00000035, 0.00000055, 0.00000083, 0.00000118, 0.00000163,
|
|
0.00000218, 0.00000283, 0.00000361, 0.00000453, 0.00000558, 0.00000679,
|
|
0.00000817, 0.00000973, 0.00001147, 0.00001342, 0.00001558,
|
|
0.00001796, 0.00002058, 0.00002344, 0.00002657, 0.00002997,
|
|
0.00003365, 0.00003762, 0.00004190, 0.00004651, 0.00005144, 0.00005673,
|
|
0.00006236, 0.00006837, 0.00007476, 0.00008155, 0.00008875,
|
|
0.00009636, 0.00010441, 0.00011290, 0.00012186, 0.00013128,
|
|
0.00014119, 0.00015160, 0.00016252, 0.00017396, 0.00018594, 0.00019846,
|
|
0.00021155, 0.00022521, 0.00023946, 0.00025432, 0.00026978,
|
|
0.00028587, 0.00030260, 0.00031998, 0.00033802, 0.00035674,
|
|
0.00037615, 0.00039626, 0.00041708, 0.00043863, 0.00046092, 0.00048396,
|
|
0.00050775, 0.00053233, 0.00055768, 0.00058384, 0.00061080,
|
|
0.00063858, 0.00066720, 0.00069665, 0.00072696, 0.00075813,
|
|
0.00079017, 0.00082310, 0.00085692, 0.00089164, 0.00092728, 0.00096384,
|
|
0.00100133, 0.00103976, 0.00107914, 0.00111947, 0.00116077,
|
|
0.00120304, 0.00124630, 0.00129053, 0.00133577, 0.00138200,
|
|
0.00142924, 0.00147749, 0.00152676, 0.00157705, 0.00162836, 0.00168070,
|
|
0.00173408, 0.00178850, 0.00184395, 0.00190045, 0.00195799,
|
|
0.00201658, 0.00207621, 0.00213688, 0.00219860, 0.00226137,
|
|
0.00232518, 0.00239003, 0.00245591, 0.00252284, 0.00259079, 0.00265977,
|
|
0.00272977, 0.00280078, 0.00287280, 0.00294582, 0.00301984,
|
|
0.00309484, 0.00317081, 0.00324774, 0.00332563, 0.00340446,
|
|
0.00348421, 0.00356488, 0.00364644, 0.00372889, 0.00381220, 0.00389636,
|
|
0.00398135, 0.00406715, 0.00415374, 0.00424109, 0.00432920,
|
|
0.00441802, 0.00450754, 0.00459773, 0.00468857, 0.00478001,
|
|
0.00487205, 0.00496464, 0.00505775, 0.00515136, 0.00524542, 0.00533990,
|
|
0.00543476, 0.00552997, 0.00562548, 0.00572125, 0.00581725,
|
|
0.00591342, 0.00600973, 0.00610612, 0.00620254, 0.00629895,
|
|
0.00639530, 0.00649153, 0.00658758, 0.00668341, 0.00677894, 0.00687413,
|
|
0.00696891, 0.00706322, 0.00715699, 0.00725016, 0.00734266,
|
|
0.00743441, 0.00752535, 0.00761540, 0.00770449, 0.00779254,
|
|
0.00787947, 0.00796519, 0.00804963, 0.00813270, 0.00821431, 0.00829437,
|
|
0.00837280, 0.00844949, 0.00852436, 0.00859730, 0.00866822,
|
|
0.00873701, 0.00880358, 0.00886781, 0.00892960, 0.00898884,
|
|
0.00904542, 0.00909923, 0.00915014, 0.00919805, 0.00924283, 0.00928436,
|
|
0.00932252, 0.00935718, 0.00938821, 0.00941550, 0.00943890,
|
|
0.00945828, 0.00947351, 0.00948446, 0.00949098, 0.00949294,
|
|
0.00949020, 0.00948262, 0.00947005, 0.00945235, 0.00942938, 0.00940099,
|
|
0.00936704, 0.00932738, 0.00928186, 0.00923034, 0.00917268,
|
|
0.00910872, 0.00903832, 0.00896134, 0.00887763, 0.00878706,
|
|
0.00868949, 0.00858478, 0.00847280, 0.00835343, 0.00822653, 0.00809199,
|
|
0.00794970, 0.00779956, 0.00764145, 0.00747530, 0.00730103,
|
|
0.00711857, 0.00692787, 0.00672888, 0.00652158, 0.00630597,
|
|
0.00608208, 0.00584994, 0.00560962, 0.00536124, 0.00510493, 0.00484089,
|
|
0.00456935, 0.00429062, 0.00400505, 0.00371310, 0.00341532,
|
|
0.00311238, 0.00280511, 0.00249452, 0.00218184, 0.00186864,
|
|
0.00155690, 0.00124918, 0.00094895, 0.00066112, 0.00039320, 0.00015881
|
|
};
|
|
|
|
static void WebRtcIsac_GetVars(const double* input,
|
|
const int16_t* pitchGains_Q12,
|
|
double* oldEnergy,
|
|
double* varscale) {
|
|
double nrg[4], chng, pg;
|
|
int k;
|
|
|
|
double pitchGains[4]={0,0,0,0};;
|
|
|
|
/* Calculate energies of first and second frame halfs */
|
|
nrg[0] = 0.0001;
|
|
for (k = QLOOKAHEAD/2; k < (FRAMESAMPLES_QUARTER + QLOOKAHEAD) / 2; k++) {
|
|
nrg[0] += input[k]*input[k];
|
|
}
|
|
nrg[1] = 0.0001;
|
|
for ( ; k < (FRAMESAMPLES_HALF + QLOOKAHEAD) / 2; k++) {
|
|
nrg[1] += input[k]*input[k];
|
|
}
|
|
nrg[2] = 0.0001;
|
|
for ( ; k < (FRAMESAMPLES*3/4 + QLOOKAHEAD) / 2; k++) {
|
|
nrg[2] += input[k]*input[k];
|
|
}
|
|
nrg[3] = 0.0001;
|
|
for ( ; k < (FRAMESAMPLES + QLOOKAHEAD) / 2; k++) {
|
|
nrg[3] += input[k]*input[k];
|
|
}
|
|
|
|
/* Calculate average level change */
|
|
chng = 0.25 * (fabs(10.0 * log10(nrg[3] / nrg[2])) +
|
|
fabs(10.0 * log10(nrg[2] / nrg[1])) +
|
|
fabs(10.0 * log10(nrg[1] / nrg[0])) +
|
|
fabs(10.0 * log10(nrg[0] / *oldEnergy)));
|
|
|
|
|
|
/* Find average pitch gain */
|
|
pg = 0.0;
|
|
for (k=0; k<4; k++)
|
|
{
|
|
pitchGains[k] = ((float)pitchGains_Q12[k])/4096;
|
|
pg += pitchGains[k];
|
|
}
|
|
pg *= 0.25;
|
|
|
|
/* If pitch gain is low and energy constant - increase noise level*/
|
|
/* Matlab code:
|
|
pg = 0:.01:.45; plot(pg, 0.0 + 1.0 * exp( -1.0 * exp(-200.0 * pg.*pg.*pg) / (1.0 + 0.4 * 0) ))
|
|
*/
|
|
*varscale = 0.0 + 1.0 * exp( -1.4 * exp(-200.0 * pg*pg*pg) / (1.0 + 0.4 * chng) );
|
|
|
|
*oldEnergy = nrg[3];
|
|
}
|
|
|
|
static void WebRtcIsac_GetVarsUB(const double* input,
|
|
double* oldEnergy,
|
|
double* varscale) {
|
|
double nrg[4], chng;
|
|
int k;
|
|
|
|
/* Calculate energies of first and second frame halfs */
|
|
nrg[0] = 0.0001;
|
|
for (k = 0; k < (FRAMESAMPLES_QUARTER) / 2; k++) {
|
|
nrg[0] += input[k]*input[k];
|
|
}
|
|
nrg[1] = 0.0001;
|
|
for ( ; k < (FRAMESAMPLES_HALF) / 2; k++) {
|
|
nrg[1] += input[k]*input[k];
|
|
}
|
|
nrg[2] = 0.0001;
|
|
for ( ; k < (FRAMESAMPLES*3/4) / 2; k++) {
|
|
nrg[2] += input[k]*input[k];
|
|
}
|
|
nrg[3] = 0.0001;
|
|
for ( ; k < (FRAMESAMPLES) / 2; k++) {
|
|
nrg[3] += input[k]*input[k];
|
|
}
|
|
|
|
/* Calculate average level change */
|
|
chng = 0.25 * (fabs(10.0 * log10(nrg[3] / nrg[2])) +
|
|
fabs(10.0 * log10(nrg[2] / nrg[1])) +
|
|
fabs(10.0 * log10(nrg[1] / nrg[0])) +
|
|
fabs(10.0 * log10(nrg[0] / *oldEnergy)));
|
|
|
|
|
|
/* If pitch gain is low and energy constant - increase noise level*/
|
|
/* Matlab code:
|
|
pg = 0:.01:.45; plot(pg, 0.0 + 1.0 * exp( -1.0 * exp(-200.0 * pg.*pg.*pg) / (1.0 + 0.4 * 0) ))
|
|
*/
|
|
*varscale = exp( -1.4 / (1.0 + 0.4 * chng) );
|
|
|
|
*oldEnergy = nrg[3];
|
|
}
|
|
|
|
void WebRtcIsac_GetLpcCoefLb(double *inLo, double *inHi, MaskFiltstr *maskdata,
|
|
double signal_noise_ratio, const int16_t *pitchGains_Q12,
|
|
double *lo_coeff, double *hi_coeff)
|
|
{
|
|
int k, n, j, pos1, pos2;
|
|
double varscale;
|
|
|
|
double DataLo[WINLEN], DataHi[WINLEN];
|
|
double corrlo[ORDERLO+2], corrlo2[ORDERLO+1];
|
|
double corrhi[ORDERHI+1];
|
|
double k_veclo[ORDERLO], k_vechi[ORDERHI];
|
|
|
|
double a_LO[ORDERLO+1], a_HI[ORDERHI+1];
|
|
double tmp, res_nrg;
|
|
|
|
double FwdA, FwdB;
|
|
|
|
/* hearing threshold level in dB; higher value gives more noise */
|
|
const double HearThresOffset = -28.0;
|
|
|
|
/* bandwdith expansion factors for low- and high band */
|
|
const double gammaLo = 0.9;
|
|
const double gammaHi = 0.8;
|
|
|
|
/* less-noise-at-low-frequencies factor */
|
|
double aa;
|
|
|
|
|
|
/* convert from dB to signal level */
|
|
const double H_T_H = pow(10.0, 0.05 * HearThresOffset);
|
|
double S_N_R = pow(10.0, 0.05 * signal_noise_ratio) / 3.46; /* divide by sqrt(12) */
|
|
|
|
/* change quallevel depending on pitch gains and level fluctuations */
|
|
WebRtcIsac_GetVars(inLo, pitchGains_Q12, &(maskdata->OldEnergy), &varscale);
|
|
|
|
/* less-noise-at-low-frequencies factor */
|
|
aa = 0.35 * (0.5 + 0.5 * varscale);
|
|
|
|
/* replace data in buffer by new look-ahead data */
|
|
for (pos1 = 0; pos1 < QLOOKAHEAD; pos1++)
|
|
maskdata->DataBufferLo[pos1 + WINLEN - QLOOKAHEAD] = inLo[pos1];
|
|
|
|
for (k = 0; k < SUBFRAMES; k++) {
|
|
|
|
/* Update input buffer and multiply signal with window */
|
|
for (pos1 = 0; pos1 < WINLEN - UPDATE/2; pos1++) {
|
|
maskdata->DataBufferLo[pos1] = maskdata->DataBufferLo[pos1 + UPDATE/2];
|
|
maskdata->DataBufferHi[pos1] = maskdata->DataBufferHi[pos1 + UPDATE/2];
|
|
DataLo[pos1] = maskdata->DataBufferLo[pos1] * kLpcCorrWindow[pos1];
|
|
DataHi[pos1] = maskdata->DataBufferHi[pos1] * kLpcCorrWindow[pos1];
|
|
}
|
|
pos2 = k * UPDATE/2;
|
|
for (n = 0; n < UPDATE/2; n++, pos1++) {
|
|
maskdata->DataBufferLo[pos1] = inLo[QLOOKAHEAD + pos2];
|
|
maskdata->DataBufferHi[pos1] = inHi[pos2++];
|
|
DataLo[pos1] = maskdata->DataBufferLo[pos1] * kLpcCorrWindow[pos1];
|
|
DataHi[pos1] = maskdata->DataBufferHi[pos1] * kLpcCorrWindow[pos1];
|
|
}
|
|
|
|
/* Get correlation coefficients */
|
|
WebRtcIsac_AutoCorr(corrlo, DataLo, WINLEN, ORDERLO+1); /* computing autocorrelation */
|
|
WebRtcIsac_AutoCorr(corrhi, DataHi, WINLEN, ORDERHI);
|
|
|
|
|
|
/* less noise for lower frequencies, by filtering/scaling autocorrelation sequences */
|
|
corrlo2[0] = (1.0+aa*aa) * corrlo[0] - 2.0*aa * corrlo[1];
|
|
tmp = (1.0 + aa*aa);
|
|
for (n = 1; n <= ORDERLO; n++) {
|
|
corrlo2[n] = tmp * corrlo[n] - aa * (corrlo[n-1] + corrlo[n+1]);
|
|
}
|
|
tmp = (1.0+aa) * (1.0+aa);
|
|
for (n = 0; n <= ORDERHI; n++) {
|
|
corrhi[n] = tmp * corrhi[n];
|
|
}
|
|
|
|
/* add white noise floor */
|
|
corrlo2[0] += 1e-6;
|
|
corrhi[0] += 1e-6;
|
|
|
|
|
|
FwdA = 0.01;
|
|
FwdB = 0.01;
|
|
|
|
/* recursive filtering of correlation over subframes */
|
|
for (n = 0; n <= ORDERLO; n++) {
|
|
maskdata->CorrBufLo[n] = FwdA * maskdata->CorrBufLo[n] + corrlo2[n];
|
|
corrlo2[n] = ((1.0-FwdA)*FwdB) * maskdata->CorrBufLo[n] + (1.0-FwdB) * corrlo2[n];
|
|
}
|
|
for (n = 0; n <= ORDERHI; n++) {
|
|
maskdata->CorrBufHi[n] = FwdA * maskdata->CorrBufHi[n] + corrhi[n];
|
|
corrhi[n] = ((1.0-FwdA)*FwdB) * maskdata->CorrBufHi[n] + (1.0-FwdB) * corrhi[n];
|
|
}
|
|
|
|
/* compute prediction coefficients */
|
|
WebRtcIsac_LevDurb(a_LO, k_veclo, corrlo2, ORDERLO);
|
|
WebRtcIsac_LevDurb(a_HI, k_vechi, corrhi, ORDERHI);
|
|
|
|
/* bandwidth expansion */
|
|
tmp = gammaLo;
|
|
for (n = 1; n <= ORDERLO; n++) {
|
|
a_LO[n] *= tmp;
|
|
tmp *= gammaLo;
|
|
}
|
|
|
|
/* residual energy */
|
|
res_nrg = 0.0;
|
|
for (j = 0; j <= ORDERLO; j++) {
|
|
for (n = 0; n <= j; n++) {
|
|
res_nrg += a_LO[j] * corrlo2[j-n] * a_LO[n];
|
|
}
|
|
for (n = j+1; n <= ORDERLO; n++) {
|
|
res_nrg += a_LO[j] * corrlo2[n-j] * a_LO[n];
|
|
}
|
|
}
|
|
|
|
/* add hearing threshold and compute the gain */
|
|
*lo_coeff++ = S_N_R / (sqrt(res_nrg) / varscale + H_T_H);
|
|
|
|
/* copy coefficients to output array */
|
|
for (n = 1; n <= ORDERLO; n++) {
|
|
*lo_coeff++ = a_LO[n];
|
|
}
|
|
|
|
|
|
/* bandwidth expansion */
|
|
tmp = gammaHi;
|
|
for (n = 1; n <= ORDERHI; n++) {
|
|
a_HI[n] *= tmp;
|
|
tmp *= gammaHi;
|
|
}
|
|
|
|
/* residual energy */
|
|
res_nrg = 0.0;
|
|
for (j = 0; j <= ORDERHI; j++) {
|
|
for (n = 0; n <= j; n++) {
|
|
res_nrg += a_HI[j] * corrhi[j-n] * a_HI[n];
|
|
}
|
|
for (n = j+1; n <= ORDERHI; n++) {
|
|
res_nrg += a_HI[j] * corrhi[n-j] * a_HI[n];
|
|
}
|
|
}
|
|
|
|
/* add hearing threshold and compute of the gain */
|
|
*hi_coeff++ = S_N_R / (sqrt(res_nrg) / varscale + H_T_H);
|
|
|
|
/* copy coefficients to output array */
|
|
for (n = 1; n <= ORDERHI; n++) {
|
|
*hi_coeff++ = a_HI[n];
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/******************************************************************************
|
|
* WebRtcIsac_GetLpcCoefUb()
|
|
*
|
|
* Compute LP coefficients and correlation coefficients. At 12 kHz LP
|
|
* coefficients of the first and the last sub-frame is computed. At 16 kHz
|
|
* LP coefficients of 4th, 8th and 12th sub-frames are computed. We always
|
|
* compute correlation coefficients of all sub-frames.
|
|
*
|
|
* Inputs:
|
|
* -inSignal : Input signal
|
|
* -maskdata : a structure keeping signal from previous frame.
|
|
* -bandwidth : specifies if the codec is in 0-16 kHz mode or
|
|
* 0-12 kHz mode.
|
|
*
|
|
* Outputs:
|
|
* -lpCoeff : pointer to a buffer where A-polynomials are
|
|
* written to (first coeff is 1 and it is not
|
|
* written)
|
|
* -corrMat : a matrix where correlation coefficients of each
|
|
* sub-frame are written to one row.
|
|
* -varscale : a scale used to compute LPC gains.
|
|
*/
|
|
void
|
|
WebRtcIsac_GetLpcCoefUb(
|
|
double* inSignal,
|
|
MaskFiltstr* maskdata,
|
|
double* lpCoeff,
|
|
double corrMat[][UB_LPC_ORDER + 1],
|
|
double* varscale,
|
|
int16_t bandwidth)
|
|
{
|
|
int frameCntr, activeFrameCntr, n, pos1, pos2;
|
|
int16_t criterion1;
|
|
int16_t criterion2;
|
|
int16_t numSubFrames = SUBFRAMES * (1 + (bandwidth == isac16kHz));
|
|
double data[WINLEN];
|
|
double corrSubFrame[UB_LPC_ORDER+2];
|
|
double reflecCoeff[UB_LPC_ORDER];
|
|
|
|
double aPolynom[UB_LPC_ORDER+1];
|
|
double tmp;
|
|
|
|
/* bandwdith expansion factors */
|
|
const double gamma = 0.9;
|
|
|
|
/* change quallevel depending on pitch gains and level fluctuations */
|
|
WebRtcIsac_GetVarsUB(inSignal, &(maskdata->OldEnergy), varscale);
|
|
|
|
/* replace data in buffer by new look-ahead data */
|
|
for(frameCntr = 0, activeFrameCntr = 0; frameCntr < numSubFrames;
|
|
frameCntr++)
|
|
{
|
|
if(frameCntr == SUBFRAMES)
|
|
{
|
|
// we are in 16 kHz
|
|
varscale++;
|
|
WebRtcIsac_GetVarsUB(&inSignal[FRAMESAMPLES_HALF],
|
|
&(maskdata->OldEnergy), varscale);
|
|
}
|
|
/* Update input buffer and multiply signal with window */
|
|
for(pos1 = 0; pos1 < WINLEN - UPDATE/2; pos1++)
|
|
{
|
|
maskdata->DataBufferLo[pos1] = maskdata->DataBufferLo[pos1 +
|
|
UPDATE/2];
|
|
data[pos1] = maskdata->DataBufferLo[pos1] * kLpcCorrWindow[pos1];
|
|
}
|
|
pos2 = frameCntr * UPDATE/2;
|
|
for(n = 0; n < UPDATE/2; n++, pos1++, pos2++)
|
|
{
|
|
maskdata->DataBufferLo[pos1] = inSignal[pos2];
|
|
data[pos1] = maskdata->DataBufferLo[pos1] * kLpcCorrWindow[pos1];
|
|
}
|
|
|
|
/* Get correlation coefficients */
|
|
/* computing autocorrelation */
|
|
WebRtcIsac_AutoCorr(corrSubFrame, data, WINLEN, UB_LPC_ORDER+1);
|
|
memcpy(corrMat[frameCntr], corrSubFrame,
|
|
(UB_LPC_ORDER+1)*sizeof(double));
|
|
|
|
criterion1 = ((frameCntr == 0) || (frameCntr == (SUBFRAMES - 1))) &&
|
|
(bandwidth == isac12kHz);
|
|
criterion2 = (((frameCntr+1) % 4) == 0) &&
|
|
(bandwidth == isac16kHz);
|
|
if(criterion1 || criterion2)
|
|
{
|
|
/* add noise */
|
|
corrSubFrame[0] += 1e-6;
|
|
/* compute prediction coefficients */
|
|
WebRtcIsac_LevDurb(aPolynom, reflecCoeff, corrSubFrame,
|
|
UB_LPC_ORDER);
|
|
|
|
/* bandwidth expansion */
|
|
tmp = gamma;
|
|
for (n = 1; n <= UB_LPC_ORDER; n++)
|
|
{
|
|
*lpCoeff++ = aPolynom[n] * tmp;
|
|
tmp *= gamma;
|
|
}
|
|
activeFrameCntr++;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/******************************************************************************
|
|
* WebRtcIsac_GetLpcGain()
|
|
*
|
|
* Compute the LPC gains for each sub-frame, given the LPC of each sub-frame
|
|
* and the corresponding correlation coefficients.
|
|
*
|
|
* Inputs:
|
|
* -signal_noise_ratio : the desired SNR in dB.
|
|
* -numVecs : number of sub-frames
|
|
* -corrMat : a matrix of correlation coefficients where
|
|
* each row is a set of correlation coefficients of
|
|
* one sub-frame.
|
|
* -varscale : a scale computed when WebRtcIsac_GetLpcCoefUb()
|
|
* is called.
|
|
*
|
|
* Outputs:
|
|
* -gain : pointer to a buffer where LP gains are written.
|
|
*
|
|
*/
|
|
void
|
|
WebRtcIsac_GetLpcGain(
|
|
double signal_noise_ratio,
|
|
const double* filtCoeffVecs,
|
|
int numVecs,
|
|
double* gain,
|
|
double corrMat[][UB_LPC_ORDER + 1],
|
|
const double* varscale)
|
|
{
|
|
int16_t j, n;
|
|
int16_t subFrameCntr;
|
|
double aPolynom[ORDERLO + 1];
|
|
double res_nrg;
|
|
|
|
const double HearThresOffset = -28.0;
|
|
const double H_T_H = pow(10.0, 0.05 * HearThresOffset);
|
|
/* divide by sqrt(12) = 3.46 */
|
|
const double S_N_R = pow(10.0, 0.05 * signal_noise_ratio) / 3.46;
|
|
|
|
aPolynom[0] = 1;
|
|
for(subFrameCntr = 0; subFrameCntr < numVecs; subFrameCntr++)
|
|
{
|
|
if(subFrameCntr == SUBFRAMES)
|
|
{
|
|
// we are in second half of a SWB frame. use new varscale
|
|
varscale++;
|
|
}
|
|
memcpy(&aPolynom[1], &filtCoeffVecs[(subFrameCntr * (UB_LPC_ORDER + 1)) +
|
|
1], sizeof(double) * UB_LPC_ORDER);
|
|
|
|
/* residual energy */
|
|
res_nrg = 0.0;
|
|
for(j = 0; j <= UB_LPC_ORDER; j++)
|
|
{
|
|
for(n = 0; n <= j; n++)
|
|
{
|
|
res_nrg += aPolynom[j] * corrMat[subFrameCntr][j-n] *
|
|
aPolynom[n];
|
|
}
|
|
for(n = j+1; n <= UB_LPC_ORDER; n++)
|
|
{
|
|
res_nrg += aPolynom[j] * corrMat[subFrameCntr][n-j] *
|
|
aPolynom[n];
|
|
}
|
|
}
|
|
|
|
/* add hearing threshold and compute the gain */
|
|
gain[subFrameCntr] = S_N_R / (sqrt(res_nrg) / *varscale + H_T_H);
|
|
}
|
|
}
|