FFmpeg coverage


Directory: ../../../ffmpeg/
File: src/libavfilter/aap_template.c
Date: 2024-07-24 19:24:46
Exec Total Coverage
Lines: 0 114 0.0%
Functions: 0 8 0.0%
Branches: 0 58 0.0%

Line Branch Exec Source
1 /*
2 * This file is part of FFmpeg.
3 *
4 * FFmpeg is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
8 *
9 * FFmpeg is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with FFmpeg; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17 */
18
19 #undef ZERO
20 #undef ONE
21 #undef ftype
22 #undef SAMPLE_FORMAT
23 #if DEPTH == 32
24 #define SAMPLE_FORMAT float
25 #define ftype float
26 #define ONE 1.f
27 #define ZERO 0.f
28 #else
29 #define SAMPLE_FORMAT double
30 #define ftype double
31 #define ONE 1.0
32 #define ZERO 0.0
33 #endif
34
35 #define fn3(a,b) a##_##b
36 #define fn2(a,b) fn3(a,b)
37 #define fn(a) fn2(a, SAMPLE_FORMAT)
38
39 static ftype fn(fir_sample)(AudioAPContext *s, ftype sample, ftype *delay,
40 ftype *coeffs, ftype *tmp, int *offset)
41 {
42 const int order = s->order;
43 ftype output;
44
45 delay[*offset] = sample;
46
47 memcpy(tmp, coeffs + order - *offset, order * sizeof(ftype));
48 #if DEPTH == 32
49 output = s->fdsp->scalarproduct_float(delay, tmp, s->kernel_size);
50 #else
51 output = s->fdsp->scalarproduct_double(delay, tmp, s->kernel_size);
52 #endif
53
54 if (--(*offset) < 0)
55 *offset = order - 1;
56
57 return output;
58 }
59
60 static int fn(lup_decompose)(ftype **MA, const int N, const ftype tol, int *P)
61 {
62 for (int i = 0; i <= N; i++)
63 P[i] = i;
64
65 for (int i = 0; i < N; i++) {
66 ftype maxA = ZERO;
67 int imax = i;
68
69 for (int k = i; k < N; k++) {
70 ftype absA = fabs(MA[k][i]);
71 if (absA > maxA) {
72 maxA = absA;
73 imax = k;
74 }
75 }
76
77 if (maxA < tol)
78 return 0;
79
80 if (imax != i) {
81 FFSWAP(int, P[i], P[imax]);
82 FFSWAP(ftype *, MA[i], MA[imax]);
83 P[N]++;
84 }
85
86 for (int j = i + 1; j < N; j++) {
87 MA[j][i] /= MA[i][i];
88
89 for (int k = i + 1; k < N; k++)
90 MA[j][k] -= MA[j][i] * MA[i][k];
91 }
92 }
93
94 return 1;
95 }
96
97 static void fn(lup_invert)(ftype *const *MA, const int *P, const int N, ftype **IA)
98 {
99 for (int j = 0; j < N; j++) {
100 for (int i = 0; i < N; i++) {
101 IA[i][j] = P[i] == j ? ONE : ZERO;
102
103 for (int k = 0; k < i; k++)
104 IA[i][j] -= MA[i][k] * IA[k][j];
105 }
106
107 for (int i = N - 1; i >= 0; i--) {
108 for (int k = i + 1; k < N; k++)
109 IA[i][j] -= MA[i][k] * IA[k][j];
110
111 IA[i][j] /= MA[i][i];
112 }
113 }
114 }
115
116 static ftype fn(process_sample)(AudioAPContext *s, ftype input, ftype desired, int ch)
117 {
118 ftype *dcoeffs = (ftype *)s->dcoeffs->extended_data[ch];
119 ftype *coeffs = (ftype *)s->coeffs->extended_data[ch];
120 ftype *delay = (ftype *)s->delay->extended_data[ch];
121 ftype **itmpmp = (ftype **)&s->itmpmp[s->projection * ch];
122 ftype **tmpmp = (ftype **)&s->tmpmp[s->projection * ch];
123 ftype *tmpm = (ftype *)s->tmpm->extended_data[ch];
124 ftype *tmp = (ftype *)s->tmp->extended_data[ch];
125 ftype *e = (ftype *)s->e->extended_data[ch];
126 ftype *x = (ftype *)s->x->extended_data[ch];
127 ftype *w = (ftype *)s->w->extended_data[ch];
128 int *p = (int *)s->p->extended_data[ch];
129 int *offset = (int *)s->offset->extended_data[ch];
130 const int projection = s->projection;
131 const ftype delta = s->delta;
132 const int order = s->order;
133 const int length = projection + order;
134 const ftype mu = s->mu;
135 const ftype tol = 0.00001f;
136 ftype output;
137
138 x[offset[2] + length] = x[offset[2]] = input;
139 delay[offset[0] + order] = input;
140
141 output = fn(fir_sample)(s, input, delay, coeffs, tmp, offset);
142 e[offset[1]] = e[offset[1] + projection] = desired - output;
143
144 for (int i = 0; i < projection; i++) {
145 const int iprojection = i * projection;
146
147 for (int j = i; j < projection; j++) {
148 ftype sum = ZERO;
149 for (int k = 0; k < order; k++)
150 sum += x[offset[2] + i + k] * x[offset[2] + j + k];
151 tmpm[iprojection + j] = sum;
152 if (i != j)
153 tmpm[j * projection + i] = sum;
154 }
155
156 tmpm[iprojection + i] += delta;
157 }
158
159 fn(lup_decompose)(tmpmp, projection, tol, p);
160 fn(lup_invert)(tmpmp, p, projection, itmpmp);
161
162 for (int i = 0; i < projection; i++) {
163 ftype sum = ZERO;
164 for (int j = 0; j < projection; j++)
165 sum += itmpmp[i][j] * e[j + offset[1]];
166 w[i] = sum;
167 }
168
169 for (int i = 0; i < order; i++) {
170 ftype sum = ZERO;
171 for (int j = 0; j < projection; j++)
172 sum += x[offset[2] + i + j] * w[j];
173 dcoeffs[i] = sum;
174 }
175
176 for (int i = 0; i < order; i++)
177 coeffs[i] = coeffs[i + order] = coeffs[i] + mu * dcoeffs[i];
178
179 if (--offset[1] < 0)
180 offset[1] = projection - 1;
181
182 if (--offset[2] < 0)
183 offset[2] = length - 1;
184
185 switch (s->output_mode) {
186 case IN_MODE: output = input; break;
187 case DESIRED_MODE: output = desired; break;
188 case OUT_MODE: output = desired - output; break;
189 case NOISE_MODE: output = input - output; break;
190 case ERROR_MODE: break;
191 }
192 return output;
193 }
194
195 static int fn(filter_channels)(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
196 {
197 AudioAPContext *s = ctx->priv;
198 AVFrame *out = arg;
199 const int start = (out->ch_layout.nb_channels * jobnr) / nb_jobs;
200 const int end = (out->ch_layout.nb_channels * (jobnr+1)) / nb_jobs;
201
202 for (int c = start; c < end; c++) {
203 const ftype *input = (const ftype *)s->frame[0]->extended_data[c];
204 const ftype *desired = (const ftype *)s->frame[1]->extended_data[c];
205 ftype *output = (ftype *)out->extended_data[c];
206
207 for (int n = 0; n < out->nb_samples; n++) {
208 output[n] = fn(process_sample)(s, input[n], desired[n], c);
209 if (ctx->is_disabled)
210 output[n] = input[n];
211 }
212 }
213
214 return 0;
215 }
216