FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/libavcodec/lpc.c
Date: 2026-08-15 14:54:27
Exec Total Coverage
Lines: 161 171 94.2%
Functions: 10 10 100.0%
Branches: 92 108 85.2%
Line Branch Exec Source
1 /*
2 * LPC utility code
3 * Copyright (c) 2006 Justin Ruggles <justin.ruggles@gmail.com>
4 *
5 * This file is part of FFmpeg.
6 *
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 */
21
22 #include "libavutil/common.h"
23 #include "libavutil/lls.h"
24 #include "libavutil/mem.h"
25 #include "libavutil/mem_internal.h"
26
27 #define LPC_USE_DOUBLE
28 #include "lpc.h"
29 #include "lpc_functions.h"
30 #include "libavutil/avassert.h"
31
32 /**
33 * Schur recursion.
34 * Produces reflection coefficients from autocorrelation data.
35 */
36 4117 static inline void compute_ref_coefs(const LPC_TYPE *autoc, int max_order,
37 LPC_TYPE *ref, LPC_TYPE *error)
38 {
39 LPC_TYPE err;
40 LPC_TYPE gen0[MAX_LPC_ORDER], gen1[MAX_LPC_ORDER];
41
42
2/2
✓ Branch 0 taken 25467 times.
✓ Branch 1 taken 4117 times.
 29584 for (int i = 0; i < max_order; i++)
43 25467 gen0[i] = gen1[i] = autoc[i + 1];
44
45 4117 err = autoc[0];
46
1/2
✓ Branch 0 taken 4117 times.
✗ Branch 1 not taken.
 4117 ref[0] = -gen1[0] / ((LPC_USE_FIXED || err) ? err : 1);
47 4117 err += gen1[0] * ref[0];
48
2/2
✓ Branch 0 taken 3967 times.
✓ Branch 1 taken 150 times.
 4117 if (error)
49 3967 error[0] = err;
50
2/2
✓ Branch 0 taken 21350 times.
✓ Branch 1 taken 4117 times.
 25467 for (int i = 1; i < max_order; i++) {
51
2/2
✓ Branch 0 taken 67245 times.
✓ Branch 1 taken 21350 times.
 88595 for (int j = 0; j < max_order - i; j++) {
52 67245 gen1[j] = gen1[j + 1] + ref[i - 1] * gen0[j];
53 67245 gen0[j] = gen1[j + 1] * ref[i - 1] + gen0[j];
54 }
55
2/2
✓ Branch 0 taken 21338 times.
✓ Branch 1 taken 12 times.
 21350 ref[i] = -gen1[0] / ((LPC_USE_FIXED || err) ? err : 1);
56 21350 err += gen1[0] * ref[i];
57
2/2
✓ Branch 0 taken 20000 times.
✓ Branch 1 taken 1350 times.
 21350 if (error)
58 20000 error[i] = err;
59 }
60 4117 }
61
62
63 /**
64 * Apply Welch window function to audio block
65 */
66 4867 static void lpc_apply_welch_window_c(const int32_t *data, ptrdiff_t len,
67 double *w_data)
68 {
69 int i, n2;
70 double w;
71 double c;
72
73
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4867 times.
 4867 if (len == 1) {
74 ✗ w_data[0] = 0.0;
75 ✗ return;
76 }
77
78 4867 n2 = (len >> 1);
79 4867 c = 2.0 / (len - 1.0);
80
81
2/2
✓ Branch 0 taken 8 times.
✓ Branch 1 taken 4859 times.
 4867 if (len & 1) {
82
2/2
✓ Branch 0 taken 15355 times.
✓ Branch 1 taken 8 times.
 15363 for(i=0; i<n2; i++) {
83 15355 w = c - i - 1.0;
84 15355 w = 1.0 - (w * w);
85 15355 w_data[i] = data[i] * w;
86 15355 w_data[len-1-i] = data[len-1-i] * w;
87 }
88 8 w_data[n2] = 0.0;
89 8 return;
90 }
91
92 4859 w_data+=n2;
93 4859 data+=n2;
94
2/2
✓ Branch 0 taken 10484413 times.
✓ Branch 1 taken 4859 times.
 10489272 for(i=0; i<n2; i++) {
95 10484413 w = c - n2 + i;
96 10484413 w = 1.0 - (w * w);
97 10484413 w_data[-i-1] = data[-i-1] * w;
98 10484413 w_data[+i ] = data[+i ] * w;
99 }
100 }
101
102 /**
103 * Calculate autocorrelation data from audio samples
104 * A Welch window function is applied before calculation.
105 */
106 8834 static void lpc_compute_autocorr_c(const double *data, ptrdiff_t len, int lag,
107 double *autoc)
108 {
109 int i, j;
110
111
2/2
✓ Branch 0 taken 43905 times.
✓ Branch 1 taken 8834 times.
 52739 for(j=0; j<lag; j+=2){
112 43905 double sum0 = 1.0, sum1 = 1.0;
113
2/2
✓ Branch 0 taken 141466056 times.
✓ Branch 1 taken 43905 times.
 141509961 for(i=j; i<len; i++){
114 141466056 sum0 += data[i] * data[i-j];
115 141466056 sum1 += data[i] * data[i-j-1];
116 }
117 43905 autoc[j ] = sum0;
118 43905 autoc[j+1] = sum1;
119 }
120
121
2/2
✓ Branch 0 taken 8669 times.
✓ Branch 1 taken 165 times.
 8834 if(j==lag){
122 8669 double sum = 1.0;
123
2/2
✓ Branch 0 taken 21915583 times.
✓ Branch 1 taken 8669 times.
 21924252 for(i=j-1; i<len; i++){
124 21915583 sum += data[i] * data[i-j];
125 }
126 8669 autoc[j] = sum;
127 }
128 8834 }
129
130 /**
131 * Quantize LPC coefficients
132 */
133 12582 static void quantize_lpc_coefs(double *lpc_in, int order, int precision,
134 int32_t *lpc_out, int *shift, int min_shift,
135 int max_shift, int zero_shift)
136 {
137 int i;
138 double cmax, error;
139 int32_t qmax;
140 int sh;
141
142 /* define maximum levels */
143 12582 qmax = (1 << (precision - 1)) - 1;
144
145 /* find maximum coefficient value */
146 12582 cmax = 0.0;
147
2/2
✓ Branch 0 taken 64211 times.
✓ Branch 1 taken 12582 times.
 76793 for(i=0; i<order; i++) {
148
2/2
✓ Branch 0 taken 45683 times.
✓ Branch 1 taken 18528 times.
 64211 cmax= FFMAX(cmax, fabs(lpc_in[i]));
149 }
150
151 /* if maximum value quantizes to zero, return all zeros */
152
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 12582 times.
 12582 if(cmax * (1 << max_shift) < 1.0) {
153 ✗ *shift = zero_shift;
154 ✗ memset(lpc_out, 0, sizeof(int32_t) * order);
155 ✗ return;
156 }
157
158 /* calculate level shift which scales max coeff to available bits */
159 12582 sh = max_shift;
160
3/4
✓ Branch 0 taken 22572 times.
✓ Branch 1 taken 12582 times.
✓ Branch 2 taken 22572 times.
✗ Branch 3 not taken.
 35154 while((cmax * (1 << sh) > qmax) && (sh > min_shift)) {
161 22572 sh--;
162 }
163
164 /* since negative shift values are unsupported in decoder, scale down
165 coefficients instead */
166
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 12582 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 12582 if(sh == 0 && cmax > qmax) {
167 ✗ double scale = ((double)qmax) / cmax;
168 ✗ for(i=0; i<order; i++) {
169 ✗ lpc_in[i] *= scale;
170 }
171 }
172
173 /* output quantized coefficients and level shift */
174 12582 error=0;
175
2/2
✓ Branch 0 taken 64211 times.
✓ Branch 1 taken 12582 times.
 76793 for(i=0; i<order; i++) {
176 64211 error -= lpc_in[i] * (1 << sh);
177 64211 lpc_out[i] = av_clip(lrintf(error), -qmax, qmax);
178 64211 error -= lpc_out[i];
179 }
180 12582 *shift = sh;
181 }
182
183 9750 static int estimate_best_order(double *ref, int min_order, int max_order)
184 {
185 int i, est;
186
187 9750 est = min_order;
188
2/2
✓ Branch 0 taken 65429 times.
✓ Branch 1 taken 174 times.
 65603 for(i=max_order-1; i>=min_order-1; i--) {
189
2/2
✓ Branch 0 taken 9576 times.
✓ Branch 1 taken 55853 times.
 65429 if(ref[i] > 0.10) {
190 9576 est = i+1;
191 9576 break;
192 }
193 }
194 9750 return est;
195 }
196
197 150 int ff_lpc_calc_ref_coefs(LPCContext *s,
198 const int32_t *samples, int order, double *ref)
199 {
200 double autoc[MAX_LPC_ORDER + 1];
201
202 150 s->lpc_apply_welch_window(samples, s->blocksize, s->windowed_samples);
203 150 s->lpc_compute_autocorr(s->windowed_samples, s->blocksize, order, autoc);
204 150 compute_ref_coefs(autoc, order, ref, NULL);
205
206 150 return order;
207 }
208
209 3967 double ff_lpc_calc_ref_coefs_f(LPCContext *s, const float *samples, int len,
210 int order, double *ref, int apply_window)
211 {
212 int i;
213 3967 double signal = 0.0f, avg_err = 0.0f;
214 3967 double autoc[MAX_LPC_ORDER+1] = {0}, error[MAX_LPC_ORDER+1] = {0};
215 3967 const double a = 0.5f, b = 1.0f - a;
216
217 /* Apply windowing. apply_window == 0 uses a rectangular (unity) window: a Hann
218 * taper zeros the edges, which over a very short region (e.g. a short-block TNS
219 * region of a few dozen lines) discards most of the data and wrecks the fit. */
220
2/2
✓ Branch 0 taken 520595 times.
✓ Branch 1 taken 3967 times.
 524562 for (i = 0; i <= len / 2; i++) {
221
2/2
✓ Branch 0 taken 500734 times.
✓ Branch 1 taken 19861 times.
 520595 double weight = apply_window ? a - b*cos((2*M_PI*i)/(len - 1)) : 1.0;
222 520595 s->windowed_samples[i] = weight*samples[i];
223 520595 s->windowed_samples[len-1-i] = weight*samples[len-1-i];
224 }
225
226 3967 s->lpc_compute_autocorr(s->windowed_samples, len, order, autoc);
227 3967 signal = autoc[0];
228 3967 compute_ref_coefs(autoc, order, ref, error);
229
2/2
✓ Branch 0 taken 23967 times.
✓ Branch 1 taken 3967 times.
 27934 for (i = 0; i < order; i++)
230 23967 avg_err = (avg_err + error[i])/2.0f;
231
2/2
✓ Branch 0 taken 3965 times.
✓ Branch 1 taken 2 times.
 3967 return avg_err ? signal/avg_err : NAN;
232 }
233
234 /**
235 * Calculate LPC coefficients for multiple orders
236 *
237 * @param lpc_type LPC method for determining coefficients,
238 * see #FFLPCType for details
239 */
240 9986 int ff_lpc_calc_coefs(LPCContext *s,
241 const int32_t *samples, int blocksize, int min_order,
242 int max_order, int precision,
243 int32_t coefs[][MAX_LPC_ORDER], int *shift,
244 enum FFLPCType lpc_type, int lpc_passes,
245 int omethod, int min_shift, int max_shift, int zero_shift)
246 {
247 double autoc[MAX_LPC_ORDER+1];
248 9986 double ref[MAX_LPC_ORDER] = { 0 };
249 double lpc[MAX_LPC_ORDER][MAX_LPC_ORDER];
250 9986 int i, j, pass = 0;
251 int opt_order;
252
253 av_assert2(max_order >= MIN_LPC_ORDER && max_order <= MAX_LPC_ORDER &&
254 lpc_type > FF_LPC_TYPE_FIXED);
255
3/4
✓ Branch 0 taken 9780 times.
✓ Branch 1 taken 206 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 9780 times.
 9986 av_assert0(lpc_type == FF_LPC_TYPE_CHOLESKY || lpc_type == FF_LPC_TYPE_LEVINSON);
256
257 /* reinit LPC context if parameters have changed */
258
3/4
✓ Branch 0 taken 9969 times.
✓ Branch 1 taken 17 times.
✓ Branch 2 taken 9969 times.
✗ Branch 3 not taken.
 9986 if (blocksize != s->blocksize || max_order != s->max_order ||
259
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 9968 times.
 9969 lpc_type != s->lpc_type) {
260 18 ff_lpc_end(s);
261 18 ff_lpc_init(s, blocksize, max_order, lpc_type);
262 }
263
264
2/2
✓ Branch 0 taken 2589 times.
✓ Branch 1 taken 7397 times.
 9986 if(lpc_passes <= 0)
265 2589 lpc_passes = 2;
266
267
4/6
✓ Branch 0 taken 206 times.
✓ Branch 1 taken 9780 times.
✓ Branch 2 taken 206 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 206 times.
✗ Branch 5 not taken.
 9986 if (lpc_type == FF_LPC_TYPE_LEVINSON || (lpc_type == FF_LPC_TYPE_CHOLESKY && lpc_passes > 1)) {
268 9986 s->lpc_apply_welch_window(samples, blocksize, s->windowed_samples);
269
270 9986 s->lpc_compute_autocorr(s->windowed_samples, blocksize, max_order, autoc);
271
272 9986 compute_lpc_coefs(autoc, 0, max_order, &lpc[0][0], MAX_LPC_ORDER, 0, 1, NULL);
273
274
2/2
✓ Branch 0 taken 104314 times.
✓ Branch 1 taken 9986 times.
 114300 for(i=0; i<max_order; i++)
275 104314 ref[i] = fabs(lpc[i][i]);
276
277 9986 pass++;
278 }
279
280
2/2
✓ Branch 0 taken 206 times.
✓ Branch 1 taken 9780 times.
 9986 if (lpc_type == FF_LPC_TYPE_CHOLESKY) {
281 206 LLSModel *m = s->lls_models;
282 206 LOCAL_ALIGNED(32, double, var, [FFALIGN(MAX_LPC_ORDER+1,4)]);
283 206 double av_uninit(weight);
284 206 memset(var, 0, FFALIGN(MAX_LPC_ORDER+1,4)*sizeof(*var));
285
286 /* Avoids initializing with an unused value when lpc_passes == 1 */
287
1/2
✓ Branch 0 taken 206 times.
✗ Branch 1 not taken.
 206 if (lpc_passes > 1)
288
2/2
✓ Branch 0 taken 1648 times.
✓ Branch 1 taken 206 times.
 1854 for(j=0; j<max_order; j++)
289 1648 m[0].coeff[max_order-1][j] = -lpc[max_order-1][j];
290
291
2/2
✓ Branch 0 taken 206 times.
✓ Branch 1 taken 206 times.
 412 for(; pass<lpc_passes; pass++){
292 206 avpriv_init_lls(&m[pass&1], max_order);
293
294 206 weight=0;
295
2/2
✓ Branch 0 taken 836252 times.
✓ Branch 1 taken 206 times.
 836458 for(i=max_order; i<blocksize; i++){
296
2/2
✓ Branch 0 taken 7526268 times.
✓ Branch 1 taken 836252 times.
 8362520 for(j=0; j<=max_order; j++)
297 7526268 var[j]= samples[i-j];
298
299
1/2
✓ Branch 0 taken 836252 times.
✗ Branch 1 not taken.
 836252 if(pass){
300 double eval, inv, rinv;
301 836252 eval= m[pass&1].evaluate_lls(&m[(pass-1)&1], var+1, max_order-1);
302 836252 eval= (512>>pass) + fabs(eval - var[0]);
303 836252 inv = 1/eval;
304 836252 rinv = sqrt(inv);
305
2/2
✓ Branch 0 taken 7526268 times.
✓ Branch 1 taken 836252 times.
 8362520 for(j=0; j<=max_order; j++)
306 7526268 var[j] *= rinv;
307 836252 weight += inv;
308 }else
309 ✗ weight++;
310
311 836252 m[pass&1].update_lls(&m[pass&1], var);
312 }
313 206 avpriv_solve_lls(&m[pass&1], 0.001, 0);
314 }
315
316
2/2
✓ Branch 0 taken 1648 times.
✓ Branch 1 taken 206 times.
 1854 for(i=0; i<max_order; i++){
317
2/2
✓ Branch 0 taken 13184 times.
✓ Branch 1 taken 1648 times.
 14832 for(j=0; j<max_order; j++)
318 13184 lpc[i][j]=-m[(pass-1)&1].coeff[i][j];
319 1648 ref[i]= sqrt(m[(pass-1)&1].variance[i] / weight) * (blocksize - max_order) / 4000;
320 }
321
2/2
✓ Branch 0 taken 1442 times.
✓ Branch 1 taken 206 times.
 1648 for(i=max_order-1; i>0; i--)
322 1442 ref[i] = ref[i-1] - ref[i];
323 }
324
325 9986 opt_order = max_order;
326
327
2/2
✓ Branch 0 taken 9750 times.
✓ Branch 1 taken 236 times.
 9986 if(omethod == ORDER_METHOD_EST) {
328 9750 opt_order = estimate_best_order(ref, min_order, max_order);
329 9750 i = opt_order-1;
330 9750 quantize_lpc_coefs(lpc[i], i+1, precision, coefs[i], &shift[i],
331 min_shift, max_shift, zero_shift);
332 } else {
333
2/2
✓ Branch 0 taken 2832 times.
✓ Branch 1 taken 236 times.
 3068 for(i=min_order-1; i<max_order; i++) {
334 2832 quantize_lpc_coefs(lpc[i], i+1, precision, coefs[i], &shift[i],
335 min_shift, max_shift, zero_shift);
336 }
337 }
338
339 9986 return opt_order;
340 }
341
342 181 av_cold int ff_lpc_init(LPCContext *s, int blocksize, int max_order,
343 enum FFLPCType lpc_type)
344 {
345 181 s->blocksize = blocksize;
346 181 s->max_order = max_order;
347 181 s->lpc_type = lpc_type;
348
349 181 s->windowed_buffer = av_mallocz((blocksize + 2 + FFALIGN(max_order, 4)) *
350 sizeof(*s->windowed_samples));
351
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 181 times.
 181 if (!s->windowed_buffer)
352 ✗ return AVERROR(ENOMEM);
353 181 s->windowed_samples = s->windowed_buffer + FFALIGN(max_order, 4);
354
355 181 s->lpc_apply_welch_window = lpc_apply_welch_window_c;
356 181 s->lpc_compute_autocorr = lpc_compute_autocorr_c;
357
358 #if ARCH_RISCV
359 ff_lpc_init_riscv(s);
360 #elif ARCH_X86
361 181 ff_lpc_init_x86(s);
362 #endif
363
364 181 return 0;
365 }
366
367 181 av_cold void ff_lpc_end(LPCContext *s)
368 {
369 181 av_freep(&s->windowed_buffer);
370 181 }
371