37 for(i=0; i<lp_order-1; i++)
38 for(j=i; j>=0 && lsfq[j] > lsfq[j+1]; j--)
39 FFSWAP(int16_t, lsfq[j], lsfq[j+1]);
41 for(i=0; i<lp_order; i++)
43 lsfq[i] =
FFMAX(lsfq[i], lsfq_min);
44 lsfq_min = lsfq[i] + lsfq_min_distance;
46 lsfq[lp_order-1] =
FFMIN(lsfq[lp_order-1], lsfq_max);
53 for (i = 0; i <
size; i++)
54 prev = lsf[i] =
FFMAX(lsf[i], prev + min_spacing);
61 32767, 32738, 32617, 32421, 32145, 31793, 31364, 30860,
62 30280, 29629, 28905, 28113, 27252, 26326, 25336, 24285,
63 23176, 22011, 20793, 19525, 18210, 16851, 15451, 14014,
64 12543, 11043, 9515, 7965, 6395, 4810, 3214, 1609,
65 1, -1607, -3211, -4808, -6393, -7962, -9513, -11040,
66 -12541, -14012, -15449, -16848, -18207, -19523, -20791, -22009,
67 -23174, -24283, -25334, -26324, -27250, -28111, -28904, -29627,
68 -30279, -30858, -31363, -31792, -32144, -32419, -32616, -32736, -32768,
76 assert(arg <= 0x3fff);
86 for(i=0; i<lp_order; i++)
88 lsp[i] =
ff_cos(lsf[i] * 20861 >> 15);
95 for(i = 0; i < lp_order; i++)
96 lsp[i] = cos(2.0 * M_PI * lsf[i]);
104 static void lsp2poly(
int* f,
const int16_t* lsp,
int lp_half_order)
111 for(i=2; i<=lp_half_order; i++)
117 f[1] -= lsp[2*i-2] << 8;
132 for(i=1; i<lp_half_order+1; i++)
134 int ff1 = f1[i] + f1[i-1];
135 int ff2 = f2[i] - f2[i-1];
138 lp[i] = (ff1 + ff2) >> 11;
139 lp[(lp_half_order << 1) + 1 - i] = (ff1 - ff2) >> 11;
145 int lp_half_order = lp_order >> 1;
148 double *qa = buf + 1;
156 for (i = 1, j = lp_order - 1; i < lp_half_order; i++, j--) {
157 double paf = pa[i] * (1 + lsp[lp_order - 1]);
158 double qaf = (qa[i] - qa[i-2]) * (1 - lsp[lp_order - 1]);
159 lp[i-1] = (paf + qaf) * 0.5;
160 lp[j-1] = (paf - qaf) * 0.5;
163 lp[lp_half_order - 1] = (1.0 + lsp[lp_order - 1]) *
164 pa[lp_half_order] * 0.5;
166 lp[lp_order - 1] = lsp[lp_order - 1];
169 void ff_acelp_lp_decode(int16_t* lp_1st, int16_t* lp_2nd,
const int16_t* lsp_2nd,
const int16_t* lsp_prev,
int lp_order)
175 for(i=0; i<lp_order; i++)
176 lsp_1st[i] = (lsp_2nd[i] + lsp_prev[i]) >> 1;
191 for(i=2; i<=lp_half_order; i++)
193 double val = -2 * lsp[2*i];
194 f[i] = val * f[i-1] + 2*f[i-2];
196 f[j] += f[j-1] * val + f[j-2];
204 float *lpc2 = lpc + (lp_half_order << 1) - 1;
211 while (lp_half_order--) {
212 double paf = pa[lp_half_order+1] + pa[lp_half_order];
213 double qaf = qa[lp_half_order+1] - qa[lp_half_order];
215 lpc [ lp_half_order] = 0.5*(paf+qaf);
216 lpc2[-lp_half_order] = 0.5*(paf-qaf);
224 for (i = 0; i < len - 1; i++)
225 for (j = i; j >= 0 && vals[j] > vals[j+1]; j--)
226 FFSWAP(
float, vals[j], vals[j+1]);
static const int16_t tab_cos[65]
static void lsp2poly(int *f, const int16_t *lsp, int lp_half_order)
decodes polynomial coefficients from LSP
void ff_acelp_lsf2lsp(int16_t *lsp, const int16_t *lsf, int lp_order)
Convert LSF to LSP.
static int16_t ff_cos(uint16_t arg)
void ff_acelp_reorder_lsf(int16_t *lsfq, int lsfq_min_distance, int lsfq_min, int lsfq_max, int lp_order)
(I.F) means fixed-point value with F fractional and I integer bits
void ff_lsp2polyf(const double *lsp, double *f, int lp_half_order)
Compute the Pa / (1 + z(-1)) or Qa / (1 - z(-1)) coefficients needed for LSP to LPC conversion...
void ff_amrwb_lsp2lpc(const double *lsp, float *lp, int lp_order)
LSP to LP conversion (5.2.4 of AMR-WB)
Libavcodec external API header.
void ff_acelp_lp_decode(int16_t *lp_1st, int16_t *lp_2nd, const int16_t *lsp_2nd, const int16_t *lsp_prev, int lp_order)
Interpolate LSP for the first subframe and convert LSP -> LP for both subframes (3.2.5 and 3.2.6 of G.729)
void ff_acelp_lspd2lpc(const double *lsp, float *lpc, int lp_half_order)
Reconstruct LPC coefficients from the line spectral pair frequencies.
void ff_acelp_lsp2lpc(int16_t *lp, const int16_t *lsp, int lp_half_order)
LSP to LP conversion (3.2.6 of G.729)
#define MAX_LP_HALF_ORDER
void ff_acelp_lsf2lspd(double *lsp, const float *lsf, int lp_order)
Floating point version of ff_acelp_lsf2lsp()
#define FFSWAP(type, a, b)
void ff_set_min_dist_lsf(float *lsf, double min_spacing, int size)
Adjust the quantized LSFs so they are increasing and not too close.
void ff_sort_nearly_sorted_floats(float *vals, int len)
Sort values in ascending order.