FFmpeg coverage


Directory: ../../../ffmpeg/
File: src/libavcodec/flacdsp_lpc_template.c
Date: 2024-02-16 17:37:06
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 162488 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 183331566 times.
✓ Branch 1 taken 81244 times.
366825620 for (i = order; i < len; i += 2) {
54 366663132 int s = smp[i-order];
55 366663132 sum_type p0 = 0, p1 = 0;
56
2/2
✓ Branch 0 taken 5723294 times.
✓ Branch 1 taken 177608272 times.
366663132 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 157001496 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.
355216544 switch (order) {
93 314002992 case 8: LPC1( 8)
94 349776956 case 7: LPC1( 7)
95 350287778 case 6: LPC1( 6)
96 350826446 case 5: LPC1( 5)
97 355066050 case 4: LPC1( 4)
98 355198112 case 3: LPC1( 3)
99 355198112 case 2: LPC1( 2)
100 355216544 case 1: LPC1( 1)
101 }
102 }
103 366663132 res[i ] = smp[i ] - CLIP(p0 >> shift);
104 366663132 res[i+1] = smp[i+1] - CLIP(p1 >> shift);
105 }
106 162488 }
107
108 162488 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 642991 times.
✓ Branch 1 taken 81244 times.
1448470 for (i = 0; i < order; i++)
113 1285982 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 72789 times.
✓ Branch 8 taken 704 times.
162488 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 145578 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 162488 }
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