26 #define LPC_USE_DOUBLE 42 c = 2.0 / (len - 1.0);
48 w_data[
i] = data[
i] *
w;
49 w_data[len-1-
i] = data[len-1-
i] *
w;
59 w_data[-i-1] = data[-i-1] *
w;
60 w_data[+
i ] = data[+
i ] *
w;
73 for(j=0; j<lag; j+=2){
74 double sum0 = 1.0, sum1 = 1.0;
76 sum0 += data[
i] * data[i-j];
77 sum1 += data[
i] * data[i-j-1];
85 for(i=j-1; i<
len; i+=2){
86 sum += data[
i ] * data[i-j ]
87 + data[i+1] * data[i-j+1];
98 int max_shift,
int zero_shift)
106 qmax = (1 << (precision - 1)) - 1;
110 for(i=0; i<order; i++) {
115 if(cmax * (1 << max_shift) < 1.0) {
117 memset(lpc_out, 0,
sizeof(
int32_t) * order);
123 while((cmax * (1 << sh) > qmax) && (sh > min_shift)) {
129 if(sh == 0 && cmax > qmax) {
130 double scale = ((double)qmax) / cmax;
131 for(i=0; i<order; i++) {
138 for(i=0; i<order; i++) {
139 error -= lpc_in[
i] * (1 << sh);
151 for(i=max_order-1; i>=min_order-1; i--) {
173 int order,
double *
ref)
176 double signal = 0.0f, avg_err = 0.0f;
178 const double a = 0.5f,
b = 1.0f -
a;
181 for (i = 0; i <= len / 2; i++) {
190 for (i = 0; i < order; i++)
191 avg_err = (avg_err +
error[i])/2.0f;
192 return signal/avg_err;
203 int max_order,
int precision,
206 int omethod,
int min_shift,
int max_shift,
int zero_shift)
208 double autoc[MAX_LPC_ORDER+1];
235 for(i=0; i<max_order; i++)
236 ref[i] =
fabs(lpc[i][i]);
245 memset(var, 0,
FFALIGN(MAX_LPC_ORDER+1,4)*
sizeof(*var));
247 for(j=0; j<max_order; j++)
248 m[0].
coeff[max_order-1][j] = -lpc[max_order-1][j];
250 for(; pass<lpc_passes; pass++){
254 for(i=max_order; i<blocksize; i++){
255 for(j=0; j<=max_order; j++)
256 var[j]= samples[i-j];
259 double eval, inv, rinv;
260 eval= m[pass&1].
evaluate_lls(&m[(pass-1)&1], var+1, max_order-1);
261 eval= (512>>
pass) +
fabs(eval - var[0]);
264 for(j=0; j<=max_order; j++)
275 for(i=0; i<max_order; i++){
276 for(j=0; j<max_order; j++)
277 lpc[i][j]=-m[(pass-1)&1].
coeff[
i][j];
278 ref[
i]= sqrt(m[(pass-1)&1].variance[i] /
weight) * (blocksize - max_order) / 4000;
280 for(i=max_order-1; i>0; i--)
281 ref[i] = ref[i-1] - ref[i];
284 opt_order = max_order;
290 min_shift, max_shift, zero_shift);
292 for(i=min_order-1; i<max_order; i++) {
294 min_shift, max_shift, zero_shift);
static int shift(int a, int b)
Linear least squares model.
ptrdiff_t const GLvoid * data
static void lpc_compute_autocorr_c(const double *data, int len, int lag, double *autoc)
Calculate autocorrelation data from audio samples A Welch window function is applied before calculati...
#define LOCAL_ALIGNED(a, t, v,...)
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
static void error(const char *err)
static void compute_ref_coefs(const LPC_TYPE *autoc, int max_order, LPC_TYPE *ref, LPC_TYPE *error)
Schur recursion.
#define av_assert0(cond)
assert() equivalent, that is always enabled.
av_cold void ff_lpc_init_x86(LPCContext *c)
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
int ff_lpc_calc_ref_coefs(LPCContext *s, const int32_t *samples, int order, double *ref)
static __device__ float fabs(float a)
void(* lpc_apply_welch_window)(const int32_t *data, int len, double *w_data)
Apply a Welch window to an array of input samples.
double(* evaluate_lls)(struct LLSModel *m, const double *var, int order)
Inner product of var[] and the LPC coefs.
simple assert() macros that are a bit more flexible than ISO C assert().
av_cold void avpriv_init_lls(LLSModel *m, int indep_count)
static int estimate_best_order(double *ref, int min_order, int max_order)
av_cold void ff_lpc_end(LPCContext *s)
Uninitialize LPCContext.
static void lpc_apply_welch_window_c(const int32_t *data, int len, double *w_data)
Apply Welch window function to audio block.
static int AAC_RENAME() compute_lpc_coefs(const LPC_TYPE *autoc, int max_order, LPC_TYPE *lpc, int lpc_stride, int fail, int normalize)
Levinson-Durbin recursion.
void(* lpc_compute_autocorr)(const double *data, int len, int lag, double *autoc)
Perform autocorrelation on input samples with delay of 0 to lag.
void avpriv_solve_lls(LLSModel *m, double threshold, unsigned short min_order)
Levinson-Durbin recursion.
double ff_lpc_calc_ref_coefs_f(LPCContext *s, const float *samples, int len, int order, double *ref)
void(* update_lls)(struct LLSModel *m, const double *var)
Take the outer-product of var[] with itself, and add to the covariance matrix.
int ff_lpc_calc_coefs(LPCContext *s, const int32_t *samples, int blocksize, int min_order, int max_order, int precision, int32_t coefs[][MAX_LPC_ORDER], int *shift, enum FFLPCType lpc_type, int lpc_passes, int omethod, int min_shift, int max_shift, int zero_shift)
Calculate LPC coefficients for multiple orders.
double * windowed_samples
av_cold int ff_lpc_init(LPCContext *s, int blocksize, int max_order, enum FFLPCType lpc_type)
Initialize LPCContext.
static int weight(int i, int blen, int offset)
FFLPCType
LPC analysis type.
common internal and external API header
static int ref[MAX_W *MAX_W]
static void quantize_lpc_coefs(double *lpc_in, int order, int precision, int32_t *lpc_out, int *shift, int min_shift, int max_shift, int zero_shift)
Quantize LPC coefficients.
static const double coeff[2][5]
Filter the word “frame” indicates either a video frame or a group of audio samples
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions