FFmpeg coverage


Directory: ../../../ffmpeg/
File: src/libavcodec/flacdsp_lpc_template.c
Date: 2024-10-04 17:46:48
Exec Total Coverage
Lines: 43 64 67.2%
Functions: 4 4 100.0%
Branches: 23 49 46.9%

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 #include <stdint.h>
20 #include "libavutil/common.h"
21 #include "mathops.h"
22
23 #undef FUNC
24 #undef sum_type
25 #undef MUL
26 #undef CLIP
27 #undef FSUF
28
29 #define FUNC(n) AV_JOIN(n ## _, SAMPLE_SIZE)
30
31 #if SAMPLE_SIZE == 32
32 # define sum_type int64_t
33 # define MUL(a, b) MUL64(a, b)
34 # define CLIP(x) av_clipl_int32(x)
35 #else
36 # define sum_type int32_t
37 # define MUL(a, b) ((a) * (b))
38 # define CLIP(x) (x)
39 #endif
40
41 #define LPC1(x) { \
42 int c = coefs[(x)-1]; \
43 p0 += MUL(c, s); \
44 s = smp[i-(x)+1]; \
45 p1 += MUL(c, s); \
46 }
47
48 162988 static av_always_inline void FUNC(lpc_encode_unrolled)(int32_t *res,
49 const int32_t *smp, int len, int order,
50 const int32_t *coefs, int shift, int big)
51 {
52 int i;
53
2/2
✓ Branch 0 taken 183881816 times.
✓ Branch 1 taken 81494 times.
367926620 for (i = order; i < len; i += 2) {
54 367763632 int s = smp[i-order];
55 367763632 sum_type p0 = 0, p1 = 0;
56
2/2
✓ Branch 0 taken 5723294 times.
✓ Branch 1 taken 178158522 times.
367763632 if (big) {
57
2/25
✗ Branch 0 not taken.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✗ Branch 9 not taken.
✗ Branch 10 not taken.
✗ Branch 11 not taken.
✗ Branch 12 not taken.
✗ Branch 13 not taken.
✗ Branch 14 not taken.
✗ Branch 15 not taken.
✗ Branch 16 not taken.
✗ Branch 17 not taken.
✗ Branch 18 not taken.
✗ Branch 19 not taken.
✓ Branch 20 taken 3395124 times.
✗ Branch 21 not taken.
✓ Branch 22 taken 2328170 times.
✗ Branch 23 not taken.
✗ Branch 24 not taken.
11446588 switch (order) {
58 case 32: LPC1(32)
59 case 31: LPC1(31)
60 case 30: LPC1(30)
61 case 29: LPC1(29)
62 case 28: LPC1(28)
63 case 27: LPC1(27)
64 case 26: LPC1(26)
65 case 25: LPC1(25)
66 case 24: LPC1(24)
67 case 23: LPC1(23)
68 case 22: LPC1(22)
69 case 21: LPC1(21)
70 case 20: LPC1(20)
71 case 19: LPC1(19)
72 case 18: LPC1(18)
73 case 17: LPC1(17)
74 case 16: LPC1(16)
75 case 15: LPC1(15)
76 case 14: LPC1(14)
77 case 13: LPC1(13)
78 6790248 case 12: LPC1(12)
79 6790248 case 11: LPC1(11)
80 11446588 case 10: LPC1(10)
81 11446588 case 9: LPC1( 9)
82 11446588 LPC1( 8)
83 11446588 LPC1( 7)
84 11446588 LPC1( 6)
85 11446588 LPC1( 5)
86 11446588 LPC1( 4)
87 11446588 LPC1( 3)
88 11446588 LPC1( 2)
89 11446588 LPC1( 1)
90 }
91 } else {
92
7/9
✓ Branch 0 taken 157551746 times.
✓ Branch 1 taken 17886982 times.
✓ Branch 2 taken 255411 times.
✓ Branch 3 taken 269334 times.
✓ Branch 4 taken 2119802 times.
✓ Branch 5 taken 66031 times.
✗ Branch 6 not taken.
✓ Branch 7 taken 9216 times.
✗ Branch 8 not taken.
356317044 switch (order) {
93 315103492 case 8: LPC1( 8)
94 350877456 case 7: LPC1( 7)
95 351388278 case 6: LPC1( 6)
96 351926946 case 5: LPC1( 5)
97 356166550 case 4: LPC1( 4)
98 356298612 case 3: LPC1( 3)
99 356298612 case 2: LPC1( 2)
100 356317044 case 1: LPC1( 1)
101 }
102 }
103 367763632 res[i ] = smp[i ] - CLIP(p0 >> shift);
104 367763632 res[i+1] = smp[i+1] - CLIP(p1 >> shift);
105 }
106 162988 }
107
108 162988 static void FUNC(flac_lpc_encode_c)(int32_t *res, const int32_t *smp, int len,
109 int order, const int32_t *coefs, int shift)
110 {
111 int i;
112
2/2
✓ Branch 0 taken 644991 times.
✓ Branch 1 taken 81494 times.
1452970 for (i = 0; i < order; i++)
113 1289982 res[i] = smp[i];
114 #if CONFIG_SMALL
115 for (i = order; i < len; i += 2) {
116 int j;
117 int s = smp[i];
118 sum_type p0 = 0, p1 = 0;
119 for (j = 0; j < order; j++) {
120 int c = coefs[j];
121 p1 += MUL(c, s);
122 s = smp[i-j-1];
123 p0 += MUL(c, s);
124 }
125 res[i ] = smp[i ] - CLIP(p0 >> shift);
126 res[i+1] = smp[i+1] - CLIP(p1 >> shift);
127 }
128 #else
129
8/9
✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 29 times.
✓ Branch 3 taken 323 times.
✓ Branch 4 taken 117 times.
✓ Branch 5 taken 111 times.
✓ Branch 6 taken 7167 times.
✓ Branch 7 taken 73039 times.
✓ Branch 8 taken 704 times.
162988 switch (order) {
130 8 case 1: FUNC(lpc_encode_unrolled)(res, smp, len, 1, coefs, shift, 0); break;
131 case 2: FUNC(lpc_encode_unrolled)(res, smp, len, 2, coefs, shift, 0); break;
132 58 case 3: FUNC(lpc_encode_unrolled)(res, smp, len, 3, coefs, shift, 0); break;
133 646 case 4: FUNC(lpc_encode_unrolled)(res, smp, len, 4, coefs, shift, 0); break;
134 234 case 5: FUNC(lpc_encode_unrolled)(res, smp, len, 5, coefs, shift, 0); break;
135 222 case 6: FUNC(lpc_encode_unrolled)(res, smp, len, 6, coefs, shift, 0); break;
136 14334 case 7: FUNC(lpc_encode_unrolled)(res, smp, len, 7, coefs, shift, 0); break;
137 146078 case 8: FUNC(lpc_encode_unrolled)(res, smp, len, 8, coefs, shift, 0); break;
138 1408 default: FUNC(lpc_encode_unrolled)(res, smp, len, order, coefs, shift, 1); break;
139 }
140 #endif
141 162988 }
142
143 /* Comment for clarity/de-obfuscation.
144 *
145 * for (int i = order; i < len; i++) {
146 * int32_t p = 0;
147 * for (int j = 0; j < order; j++) {
148 * int c = coefs[j];
149 * int s = smp[(i-1)-j];
150 * p += c*s;
151 * }
152 * res[i] = smp[i] - (p >> shift);
153 * }
154 *
155 * The CONFIG_SMALL code above simplifies to this, in the case of SAMPLE_SIZE
156 * not being equal to 32 (at the present time that means for 16-bit audio). The
157 * code above does 2 samples per iteration. Commit bfdd5bc (made all the way
158 * back in 2007) says that way is faster.
159 */
160