FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/libavcodec/lpc.c
Date: 2026-10-25 01:46:33
Exec Total Coverage
Lines: 161 171 94.2%
Functions: 10 10 100.0%
Branches: 90 108 83.3%
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 8436 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 51812 times.
✓ Branch 1 taken 8436 times.
 60248 for (int i = 0; i < max_order; i++)
43 51812 gen0[i] = gen1[i] = autoc[i + 1];
44
45 8436 err = autoc[0];
46
1/2
✓ Branch 0 taken 8436 times.
✗ Branch 1 not taken.
 8436 ref[0] = -gen1[0] / ((LPC_USE_FIXED || err) ? err : 1);
47 8436 err += gen1[0] * ref[0];
48
2/2
✓ Branch 0 taken 8286 times.
✓ Branch 1 taken 150 times.
 8436 if (error)
49 8286 error[0] = err;
50
2/2
✓ Branch 0 taken 43376 times.
✓ Branch 1 taken 8436 times.
 51812 for (int i = 1; i < max_order; i++) {
51
2/2
✓ Branch 0 taken 134616 times.
✓ Branch 1 taken 43376 times.
 177992 for (int j = 0; j < max_order - i; j++) {
52 134616 gen1[j] = gen1[j + 1] + ref[i - 1] * gen0[j];
53 134616 gen0[j] = gen1[j + 1] * ref[i - 1] + gen0[j];
54 }
55
1/2
✓ Branch 0 taken 43376 times.
✗ Branch 1 not taken.
 43376 ref[i] = -gen1[0] / ((LPC_USE_FIXED || err) ? err : 1);
56 43376 err += gen1[0] * ref[i];
57
2/2
✓ Branch 0 taken 42026 times.
✓ Branch 1 taken 1350 times.
 43376 if (error)
58 42026 error[i] = err;
59 }
60 8436 }
61
62
63 /**
64 * Apply Welch window function to audio block
65 */
66 4889 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 4889 times.
 4889 if (len == 1) {
74 ✗ w_data[0] = 0.0;
75 ✗ return;
76 }
77
78 4889 n2 = (len >> 1);
79 4889 c = 2.0 / (len - 1.0);
80
81
2/2
✓ Branch 0 taken 8 times.
✓ Branch 1 taken 4881 times.
 4889 if (len & 1) {
82
2/2
✓ Branch 0 taken 15832 times.
✓ Branch 1 taken 8 times.
 15840 for(i=0; i<n2; i++) {
83 15832 w = c - i - 1.0;
84 15832 w = 1.0 - (w * w);
85 15832 w_data[i] = data[i] * w;
86 15832 w_data[len-1-i] = data[len-1-i] * w;
87 }
88 8 w_data[n2] = 0.0;
89 8 return;
90 }
91
92 4881 w_data+=n2;
93 4881 data+=n2;
94
2/2
✓ Branch 0 taken 10529946 times.
✓ Branch 1 taken 4881 times.
 10534827 for(i=0; i<n2; i++) {
95 10529946 w = c - n2 + i;
96 10529946 w = 1.0 - (w * w);
97 10529946 w_data[-i-1] = data[-i-1] * w;
98 10529946 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 11803 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 53069 times.
✓ Branch 1 taken 11803 times.
 64872 for(j=0; j<lag; j+=2){
112 53069 double sum0 = 1.0, sum1 = 1.0;
113
2/2
✓ Branch 0 taken 144357464 times.
✓ Branch 1 taken 53069 times.
 144410533 for(i=j; i<len; i++){
114 144357464 sum0 += data[i] * data[i-j];
115 144357464 sum1 += data[i] * data[i-j-1];
116 }
117 53069 autoc[j ] = sum0;
118 53069 autoc[j+1] = sum1;
119 }
120
121
2/2
✓ Branch 0 taken 11403 times.
✓ Branch 1 taken 400 times.
 11803 if(j==lag){
122 11403 double sum = 1.0;
123
2/2
✓ Branch 0 taken 22694297 times.
✓ Branch 1 taken 11403 times.
 22705700 for(i=j-1; i<len; i++){
124 22694297 sum += data[i] * data[i-j];
125 }
126 11403 autoc[j] = sum;
127 }
128 11803 }
129
130 /**
131 * Quantize LPC coefficients
132 */
133 12604 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 12604 qmax = (1 << (precision - 1)) - 1;
144
145 /* find maximum coefficient value */
146 12604 cmax = 0.0;
147
2/2
✓ Branch 0 taken 64387 times.
✓ Branch 1 taken 12604 times.
 76991 for(i=0; i<order; i++) {
148
2/2
✓ Branch 0 taken 45837 times.
✓ Branch 1 taken 18550 times.
 64387 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 12604 times.
 12604 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 12604 sh = max_shift;
160
3/4
✓ Branch 0 taken 22630 times.
✓ Branch 1 taken 12604 times.
✓ Branch 2 taken 22630 times.
✗ Branch 3 not taken.
 35234 while((cmax * (1 << sh) > qmax) && (sh > min_shift)) {
161 22630 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 12604 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 12604 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 12604 error=0;
175
2/2
✓ Branch 0 taken 64387 times.
✓ Branch 1 taken 12604 times.
 76991 for(i=0; i<order; i++) {
176 64387 error -= lpc_in[i] * (1 << sh);
177 64387 lpc_out[i] = av_clip(lrintf(error), -qmax, qmax);
178 64387 error -= lpc_out[i];
179 }
180 12604 *shift = sh;
181 }
182
183 9772 static int estimate_best_order(double *ref, int min_order, int max_order)
184 {
185 int i, est;
186
187 9772 est = min_order;
188
2/2
✓ Branch 0 taken 65451 times.
✓ Branch 1 taken 174 times.
 65625 for(i=max_order-1; i>=min_order-1; i--) {
189
2/2
✓ Branch 0 taken 9598 times.
✓ Branch 1 taken 55853 times.
 65451 if(ref[i] > 0.10) {
190 9598 est = i+1;
191 9598 break;
192 }
193 }
194 9772 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 8286 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 8286 double signal = 0.0f, avg_err = 0.0f;
214 8286 double autoc[MAX_LPC_ORDER+1] = {0}, error[MAX_LPC_ORDER+1] = {0};
215 8286 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 1134294 times.
✓ Branch 1 taken 8286 times.
 1142580 for (i = 0; i <= len / 2; i++) {
221
2/2
✓ Branch 0 taken 1013586 times.
✓ Branch 1 taken 120708 times.
 1134294 double weight = apply_window ? a - b*cos((2*M_PI*i)/(len - 1)) : 1.0;
222 1134294 s->windowed_samples[i] = weight*samples[i];
223 1134294 s->windowed_samples[len-1-i] = weight*samples[len-1-i];
224 }
225
226 8286 s->lpc_compute_autocorr(s->windowed_samples, len, order, autoc);
227 8286 signal = autoc[0];
228 8286 compute_ref_coefs(autoc, order, ref, error);
229
2/2
✓ Branch 0 taken 50312 times.
✓ Branch 1 taken 8286 times.
 58598 for (i = 0; i < order; i++)
230 50312 avg_err = (avg_err + error[i])/2.0f;
231
1/2
✓ Branch 0 taken 8286 times.
✗ Branch 1 not taken.
 8286 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 10008 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 10008 double ref[MAX_LPC_ORDER] = { 0 };
249 double lpc[MAX_LPC_ORDER][MAX_LPC_ORDER];
250 10008 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 9802 times.
✓ Branch 1 taken 206 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 9802 times.
 10008 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 9991 times.
✓ Branch 1 taken 17 times.
✓ Branch 2 taken 9991 times.
✗ Branch 3 not taken.
 10008 if (blocksize != s->blocksize || max_order != s->max_order ||
259
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 9990 times.
 9991 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 7419 times.
 10008 if(lpc_passes <= 0)
265 2589 lpc_passes = 2;
266
267
4/6
✓ Branch 0 taken 206 times.
✓ Branch 1 taken 9802 times.
✓ Branch 2 taken 206 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 206 times.
✗ Branch 5 not taken.
 10008 if (lpc_type == FF_LPC_TYPE_LEVINSON || (lpc_type == FF_LPC_TYPE_CHOLESKY && lpc_passes > 1)) {
268 10008 s->lpc_apply_welch_window(samples, blocksize, s->windowed_samples);
269
270 10008 s->lpc_compute_autocorr(s->windowed_samples, blocksize, max_order, autoc);
271
272 10008 compute_lpc_coefs(autoc, 0, max_order, &lpc[0][0], MAX_LPC_ORDER, 0, 1, NULL);
273
274
2/2
✓ Branch 0 taken 104490 times.
✓ Branch 1 taken 10008 times.
 114498 for(i=0; i<max_order; i++)
275 104490 ref[i] = fabs(lpc[i][i]);
276
277 10008 pass++;
278 }
279
280
2/2
✓ Branch 0 taken 206 times.
✓ Branch 1 taken 9802 times.
 10008 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 10008 opt_order = max_order;
326
327
2/2
✓ Branch 0 taken 9772 times.
✓ Branch 1 taken 236 times.
 10008 if(omethod == ORDER_METHOD_EST) {
328 9772 opt_order = estimate_best_order(ref, min_order, max_order);
329 9772 i = opt_order-1;
330 9772 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 10008 return opt_order;
340 }
341
342 194 av_cold int ff_lpc_init(LPCContext *s, int blocksize, int max_order,
343 enum FFLPCType lpc_type)
344 {
345 194 s->blocksize = blocksize;
346 194 s->max_order = max_order;
347 194 s->lpc_type = lpc_type;
348
349 194 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 194 times.
 194 if (!s->windowed_buffer)
352 ✗ return AVERROR(ENOMEM);
353 194 s->windowed_samples = s->windowed_buffer + FFALIGN(max_order, 4);
354
355 194 s->lpc_apply_welch_window = lpc_apply_welch_window_c;
356 194 s->lpc_compute_autocorr = lpc_compute_autocorr_c;
357
358 #if ARCH_RISCV
359 ff_lpc_init_riscv(s);
360 #elif ARCH_X86
361 194 ff_lpc_init_x86(s);
362 #endif
363
364 194 return 0;
365 }
366
367 194 av_cold void ff_lpc_end(LPCContext *s)
368 {
369 194 av_freep(&s->windowed_buffer);
370 194 }
371