mirror of https://git.ffmpeg.org/ffmpeg.git
Avoid duplicating compute_lpc_coefs() function in both the RA288 and AAC decoders.
Originally committed as revision 15193 to svn://svn.ffmpeg.org/ffmpeg/trunk
This commit is contained in:
Vitor Sessak
parent
287ba997b5
commit
1be0fc2909
|
|
@ -79,6 +79,7 @@
|
|||
#include "avcodec.h"
|
||||
#include "bitstream.h"
|
||||
#include "dsputil.h"
|
||||
#include "lpc.h"
|
||||
|
||||
#include "aac.h"
|
||||
#include "aactab.h"
|
||||
|
|
@ -634,7 +635,7 @@ static int decode_tns(AACContext * ac, TemporalNoiseShaping * tns,
|
|||
tmp2_idx = 2*coef_compress + coef_res;
|
||||
|
||||
for (i = 0; i < tns->order[w][filt]; i++)
|
||||
tns->coef[w][filt][i] = tns_tmp2_map[tmp2_idx][get_bits(gb, coef_len)];
|
||||
tns->coef[w][filt][i] = -tns_tmp2_map[tmp2_idx][get_bits(gb, coef_len)];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -1124,20 +1125,8 @@ static void apply_tns(float coef[1024], TemporalNoiseShaping * tns, IndividualCh
|
|||
if (order == 0)
|
||||
continue;
|
||||
|
||||
/* tns_decode_coef
|
||||
* FIXME: This duplicates the functionality of some double code in lpc.c.
|
||||
*/
|
||||
for (m = 0; m < order; m++) {
|
||||
float tmp;
|
||||
lpc[m] = tns->coef[w][filt][m];
|
||||
for (i = 0; i < m/2; i++) {
|
||||
tmp = lpc[i];
|
||||
lpc[i] += lpc[m] * lpc[m-1-i];
|
||||
lpc[m-1-i] += lpc[m] * tmp;
|
||||
}
|
||||
if(m & 1)
|
||||
lpc[i] += lpc[m] * lpc[i];
|
||||
}
|
||||
// tns_decode_coef
|
||||
compute_lpc_coefs(tns->coef[w][filt], order, lpc, 0, 0, 0);
|
||||
|
||||
start = ics->swb_offset[FFMIN(bottom, mmm)];
|
||||
end = ics->swb_offset[FFMIN( top, mmm)];
|
||||
|
|
|
|||
|
|
@ -21,46 +21,11 @@
|
|||
|
||||
#include "libavutil/lls.h"
|
||||
#include "dsputil.h"
|
||||
|
||||
#define LPC_USE_DOUBLE
|
||||
#include "lpc.h"
|
||||
|
||||
|
||||
/**
|
||||
* Levinson-Durbin recursion.
|
||||
* Produces LPC coefficients from autocorrelation data.
|
||||
*/
|
||||
static void compute_lpc_coefs(const double *autoc, int max_order,
|
||||
double lpc[][MAX_LPC_ORDER], double *ref)
|
||||
{
|
||||
int i, j;
|
||||
double err = autoc[0];
|
||||
double lpc_tmp[MAX_LPC_ORDER];
|
||||
|
||||
for(i=0; i<max_order; i++) {
|
||||
double r = -autoc[i+1];
|
||||
|
||||
for(j=0; j<i; j++)
|
||||
r -= lpc_tmp[j] * autoc[i-j];
|
||||
|
||||
r /= err;
|
||||
ref[i] = fabs(r);
|
||||
|
||||
err *= 1.0 - (r * r);
|
||||
|
||||
lpc_tmp[i] = r;
|
||||
for(j=0; j < i>>1; j++) {
|
||||
double tmp = lpc_tmp[j];
|
||||
lpc_tmp[j] += r * lpc_tmp[i-1-j];
|
||||
lpc_tmp[i-1-j] += r * tmp;
|
||||
}
|
||||
|
||||
if(i & 1)
|
||||
lpc_tmp[j] += lpc_tmp[j] * r;
|
||||
|
||||
for(j=0; j<=i; j++)
|
||||
lpc[i][j] = -lpc_tmp[j];
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Quantize LPC coefficients
|
||||
*/
|
||||
|
|
@ -106,7 +71,7 @@ static void quantize_lpc_coefs(double *lpc_in, int order, int precision,
|
|||
/* output quantized coefficients and level shift */
|
||||
error=0;
|
||||
for(i=0; i<order; i++) {
|
||||
error += lpc_in[i] * (1 << sh);
|
||||
error -= lpc_in[i] * (1 << sh);
|
||||
lpc_out[i] = av_clip(lrintf(error), -qmax, qmax);
|
||||
error -= lpc_out[i];
|
||||
}
|
||||
|
|
@ -147,7 +112,10 @@ int ff_lpc_calc_coefs(DSPContext *s,
|
|||
if(use_lpc == 1){
|
||||
s->flac_compute_autocorr(samples, blocksize, max_order, autoc);
|
||||
|
||||
compute_lpc_coefs(autoc, max_order, lpc, ref);
|
||||
compute_lpc_coefs(autoc, max_order, &lpc[0][0], MAX_LPC_ORDER, 0, 1);
|
||||
|
||||
for(i=0; i<max_order; i++)
|
||||
ref[i] = fabs(lpc[i][i]);
|
||||
}else{
|
||||
LLSModel m[2];
|
||||
double var[MAX_LPC_ORDER+1], weight;
|
||||
|
|
@ -179,7 +147,7 @@ int ff_lpc_calc_coefs(DSPContext *s,
|
|||
|
||||
for(i=0; i<max_order; i++){
|
||||
for(j=0; j<max_order; j++)
|
||||
lpc[i][j]= m[(pass-1)&1].coeff[i][j];
|
||||
lpc[i][j]=-m[(pass-1)&1].coeff[i][j];
|
||||
ref[i]= sqrt(m[(pass-1)&1].variance[i] / weight) * (blocksize - max_order) / 4000;
|
||||
}
|
||||
for(i=max_order-1; i>0; i--)
|
||||
|
|
|
|||
|
|
@ -45,4 +45,58 @@ int ff_lpc_calc_coefs(DSPContext *s,
|
|||
int32_t coefs[][MAX_LPC_ORDER], int *shift, int use_lpc,
|
||||
int omethod, int max_shift, int zero_shift);
|
||||
|
||||
#ifdef LPC_USE_DOUBLE
|
||||
#define LPC_type double
|
||||
#else
|
||||
#define LPC_type float
|
||||
#endif
|
||||
|
||||
/**
|
||||
* Levinson-Durbin recursion.
|
||||
* Produces LPC coefficients from autocorrelation data.
|
||||
*/
|
||||
static inline int compute_lpc_coefs(const LPC_type *autoc, int max_order,
|
||||
LPC_type *lpc, int lpc_stride, int fail,
|
||||
int normalize)
|
||||
{
|
||||
int i, j;
|
||||
LPC_type err;
|
||||
LPC_type *lpc_last = lpc;
|
||||
|
||||
if (normalize)
|
||||
err = *autoc++;
|
||||
|
||||
if (fail && (autoc[max_order - 1] == 0 || err <= 0))
|
||||
return -1;
|
||||
|
||||
for(i=0; i<max_order; i++) {
|
||||
LPC_type r = -autoc[i];
|
||||
|
||||
if (normalize) {
|
||||
for(j=0; j<i; j++)
|
||||
r -= lpc_last[j] * autoc[i-j-1];
|
||||
|
||||
r /= err;
|
||||
err *= 1.0 - (r * r);
|
||||
}
|
||||
|
||||
lpc[i] = r;
|
||||
|
||||
for(j=0; j < (i+1)>>1; j++) {
|
||||
LPC_type f = lpc_last[ j];
|
||||
LPC_type b = lpc_last[i-1-j];
|
||||
lpc[ j] = f + r * b;
|
||||
lpc[i-1-j] = b + r * f;
|
||||
}
|
||||
|
||||
if (fail && err < 0)
|
||||
return -1;
|
||||
|
||||
lpc_last = lpc;
|
||||
lpc += lpc_stride;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
#endif /* AVCODEC_LPC_H */
|
||||
|
|
|
|||
|
|
@ -23,6 +23,7 @@
|
|||
#define ALT_BITSTREAM_READER_LE
|
||||
#include "bitstream.h"
|
||||
#include "ra288.h"
|
||||
#include "lpc.h"
|
||||
|
||||
typedef struct {
|
||||
float sp_lpc[36]; ///< LPC coefficients for speech data (spec: A)
|
||||
|
|
@ -113,44 +114,6 @@ static void decode(RA288Context *ractx, float gain, int cb_coef)
|
|||
block[i] = av_clipf(block[i] + buffer[i], -4095, 4095);
|
||||
}
|
||||
|
||||
/**
|
||||
* Converts autocorrelation coefficients to LPC coefficients using the
|
||||
* Levinson-Durbin algorithm. See blocks 37 and 50 of the G.728 specification.
|
||||
*
|
||||
* @return 0 if success, -1 if fail
|
||||
*/
|
||||
static int eval_lpc_coeffs(const float *in, float *tgt, int n)
|
||||
{
|
||||
int i, j;
|
||||
double f0, f1, f2;
|
||||
|
||||
if (in[n] == 0)
|
||||
return -1;
|
||||
|
||||
if ((f0 = *in) <= 0)
|
||||
return -1;
|
||||
|
||||
in--; // To avoid a -1 subtraction in the inner loop
|
||||
|
||||
for (i=1; i <= n; i++) {
|
||||
f1 = in[i+1];
|
||||
|
||||
for (j=0; j < i - 1; j++)
|
||||
f1 += in[i-j]*tgt[j];
|
||||
|
||||
tgt[i-1] = f2 = -f1/f0;
|
||||
for (j=0; j < i >> 1; j++) {
|
||||
float temp = tgt[j] + tgt[i-j-2]*f2;
|
||||
tgt[i-j-2] += tgt[j]*f2;
|
||||
tgt[j] = temp;
|
||||
}
|
||||
if ((f0 += f1*f2) < 0)
|
||||
return -1;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void convolve(float *tgt, const float *src, int len, int n)
|
||||
{
|
||||
for (; n >= 0; n--)
|
||||
|
|
@ -210,13 +173,13 @@ static void backward_filter(RA288Context *ractx)
|
|||
do_hybrid_window(36, 40, 35, ractx->sp_block+1, temp1, ractx->sp_hist,
|
||||
ractx->sp_rec, syn_window);
|
||||
|
||||
if (!eval_lpc_coeffs(temp1, ractx->sp_lpc, 36))
|
||||
if (!compute_lpc_coefs(temp1, 36, ractx->sp_lpc, 0, 1, 1))
|
||||
colmult(ractx->sp_lpc, ractx->sp_lpc, syn_bw_tab, 36);
|
||||
|
||||
do_hybrid_window(10, 8, 20, ractx->gain_block+2, temp2, ractx->gain_hist,
|
||||
ractx->gain_rec, gain_window);
|
||||
|
||||
if (!eval_lpc_coeffs(temp2, ractx->gain_lpc, 10))
|
||||
if (!compute_lpc_coefs(temp2, 10, ractx->gain_lpc, 0, 1, 1))
|
||||
colmult(ractx->gain_lpc, ractx->gain_lpc, gain_bw_tab, 10);
|
||||
}
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue