FFmpeg coverage


Directory: ../../../ffmpeg/
File: src/libavcodec/celp_filters.c
Date: 2021-09-24 20:55:06
Exec Total Coverage
Lines: 94 103 91.3%
Branches: 23 32 71.9%

Line Branch Exec Source
1 /*
2 * various filters for ACELP-based codecs
3 *
4 * Copyright (c) 2008 Vladimir Voroshilov
5 *
6 * This file is part of FFmpeg.
7 *
8 * FFmpeg is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
12 *
13 * FFmpeg is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with FFmpeg; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21 */
22
23 #include <stdint.h>
24 #include <string.h>
25
26 #include "config.h"
27 #include "celp_filters.h"
28 #include "libavutil/avassert.h"
29 #include "libavutil/common.h"
30
31 void ff_celp_convolve_circ(int16_t* fc_out, const int16_t* fc_in,
32 const int16_t* filter, int len)
33 {
34 int i, k;
35
36 memset(fc_out, 0, len * sizeof(int16_t));
37
38 /* Since there are few pulses over an entire subframe (i.e. almost
39 all fc_in[i] are zero) it is faster to loop over fc_in first. */
40 for (i = 0; i < len; i++) {
41 if (fc_in[i]) {
42 for (k = 0; k < i; k++)
43 fc_out[k] += (fc_in[i] * filter[len + k - i]) >> 15;
44
45 for (k = i; k < len; k++)
46 fc_out[k] += (fc_in[i] * filter[ k - i]) >> 15;
47 }
48 }
49 }
50
51 35007 void ff_celp_circ_addf(float *out, const float *in,
52 const float *lagged, int lag, float fac, int n)
53 {
54 int k;
55
2/2
✓ Branch 0 taken 970211 times.
✓ Branch 1 taken 35007 times.
1005218 for (k = 0; k < lag; k++)
56 970211 out[k] = in[k] + fac * lagged[n + k - lag];
57
2/2
✓ Branch 0 taken 945373 times.
✓ Branch 1 taken 35007 times.
980380 for (; k < n; k++)
58 945373 out[k] = in[k] + fac * lagged[ k - lag];
59 35007 }
60
61 26892 int ff_celp_lp_synthesis_filter(int16_t *out, const int16_t *filter_coeffs,
62 const int16_t *in, int buffer_length,
63 int filter_length, int stop_on_overflow,
64 int shift, int rounder)
65 {
66 int i,n;
67
68
2/2
✓ Branch 0 taken 1125760 times.
✓ Branch 1 taken 26892 times.
1152652 for (n = 0; n < buffer_length; n++) {
69 1125760 int sum = rounder, sum1;
70
2/2
✓ Branch 0 taken 11257600 times.
✓ Branch 1 taken 1125760 times.
12383360 for (i = 1; i <= filter_length; i++)
71 11257600 sum -= (unsigned)(filter_coeffs[i-1] * out[n-i]);
72
73 1125760 sum1 = ((sum >> 12) + in[n]) >> shift;
74 1125760 sum = av_clip_int16(sum1);
75
76
3/4
✓ Branch 0 taken 975520 times.
✓ Branch 1 taken 150240 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 975520 times.
1125760 if (stop_on_overflow && sum != sum1)
77 return 1;
78
79 1125760 out[n] = sum;
80 }
81
82 26892 return 0;
83 }
84
85 699709 void ff_celp_lp_synthesis_filterf(float *out, const float *filter_coeffs,
86 const float* in, int buffer_length,
87 int filter_length)
88 {
89 int i,n;
90
91 #if 0 // Unoptimized code path for improved readability
92 for (n = 0; n < buffer_length; n++) {
93 out[n] = in[n];
94 for (i = 1; i <= filter_length; i++)
95 out[n] -= filter_coeffs[i-1] * out[n-i];
96 }
97 #else
98 float out0, out1, out2, out3;
99 float old_out0, old_out1, old_out2, old_out3;
100 float a,b,c;
101
102 699709 a = filter_coeffs[0];
103 699709 b = filter_coeffs[1];
104 699709 c = filter_coeffs[2];
105 699709 b -= filter_coeffs[0] * filter_coeffs[0];
106 699709 c -= filter_coeffs[1] * filter_coeffs[0];
107 699709 c -= filter_coeffs[0] * b;
108
109 av_assert2((filter_length&1)==0 && filter_length>=4);
110
111 699709 old_out0 = out[-4];
112 699709 old_out1 = out[-3];
113 699709 old_out2 = out[-2];
114 699709 old_out3 = out[-1];
115
2/2
✓ Branch 0 taken 6950830 times.
✓ Branch 1 taken 699709 times.
7650539 for (n = 0; n <= buffer_length - 4; n+=4) {
116 float tmp0,tmp1,tmp2;
117 float val;
118
119 6950830 out0 = in[0];
120 6950830 out1 = in[1];
121 6950830 out2 = in[2];
122 6950830 out3 = in[3];
123
124 6950830 out0 -= filter_coeffs[2] * old_out1;
125 6950830 out1 -= filter_coeffs[2] * old_out2;
126 6950830 out2 -= filter_coeffs[2] * old_out3;
127
128 6950830 out0 -= filter_coeffs[1] * old_out2;
129 6950830 out1 -= filter_coeffs[1] * old_out3;
130
131 6950830 out0 -= filter_coeffs[0] * old_out3;
132
133 6950830 val = filter_coeffs[3];
134
135 6950830 out0 -= val * old_out0;
136 6950830 out1 -= val * old_out1;
137 6950830 out2 -= val * old_out2;
138 6950830 out3 -= val * old_out3;
139
140
2/2
✓ Branch 0 taken 25895024 times.
✓ Branch 1 taken 6950830 times.
32845854 for (i = 5; i < filter_length; i += 2) {
141 25895024 old_out3 = out[-i];
142 25895024 val = filter_coeffs[i-1];
143
144 25895024 out0 -= val * old_out3;
145 25895024 out1 -= val * old_out0;
146 25895024 out2 -= val * old_out1;
147 25895024 out3 -= val * old_out2;
148
149 25895024 old_out2 = out[-i-1];
150
151 25895024 val = filter_coeffs[i];
152
153 25895024 out0 -= val * old_out2;
154 25895024 out1 -= val * old_out3;
155 25895024 out2 -= val * old_out0;
156 25895024 out3 -= val * old_out1;
157
158 25895024 FFSWAP(float, old_out0, old_out2);
159 25895024 old_out1 = old_out3;
160 }
161
162 6950830 tmp0 = out0;
163 6950830 tmp1 = out1;
164 6950830 tmp2 = out2;
165
166 6950830 out3 -= a * tmp2;
167 6950830 out2 -= a * tmp1;
168 6950830 out1 -= a * tmp0;
169
170 6950830 out3 -= b * tmp1;
171 6950830 out2 -= b * tmp0;
172
173 6950830 out3 -= c * tmp0;
174
175
176 6950830 out[0] = out0;
177 6950830 out[1] = out1;
178 6950830 out[2] = out2;
179 6950830 out[3] = out3;
180
181 6950830 old_out0 = out0;
182 6950830 old_out1 = out1;
183 6950830 old_out2 = out2;
184 6950830 old_out3 = out3;
185
186 6950830 out += 4;
187 6950830 in += 4;
188 }
189
190 699709 out -= n;
191 699709 in -= n;
192
2/2
✓ Branch 0 taken 116114 times.
✓ Branch 1 taken 699709 times.
815823 for (; n < buffer_length; n++) {
193 116114 out[n] = in[n];
194
2/2
✓ Branch 0 taken 3315744 times.
✓ Branch 1 taken 116114 times.
3431858 for (i = 1; i <= filter_length; i++)
195 3315744 out[n] -= filter_coeffs[i-1] * out[n-i];
196 }
197 #endif
198 699709 }
199
200 19599 void ff_celp_lp_zero_synthesis_filterf(float *out, const float *filter_coeffs,
201 const float *in, int buffer_length,
202 int filter_length)
203 {
204 int i,n;
205
206
2/2
✓ Branch 0 taken 1135040 times.
✓ Branch 1 taken 19599 times.
1154639 for (n = 0; n < buffer_length; n++) {
207 1135040 out[n] = in[n];
208
2/2
✓ Branch 0 taken 12934400 times.
✓ Branch 1 taken 1135040 times.
14069440 for (i = 1; i <= filter_length; i++)
209 12934400 out[n] += filter_coeffs[i-1] * in[n-i];
210 }
211 19599 }
212
213 36 void ff_celp_filter_init(CELPFContext *c)
214 {
215 36 c->celp_lp_synthesis_filterf = ff_celp_lp_synthesis_filterf;
216 36 c->celp_lp_zero_synthesis_filterf = ff_celp_lp_zero_synthesis_filterf;
217
218 if(HAVE_MIPSFPU)
219 ff_celp_filter_init_mips(c);
220 36 }
221