FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/libavcodec/h264dsp_template.c
Date: 2026-04-24 19:58:39
Exec Total Coverage
Lines: 162 162 100.0%
Functions: 74 140 52.9%
Branches: 70 70 100.0%
Line Branch Exec Source
1 /*
2 * H.26L/H.264/AVC/JVT/14496-10/... encoder/decoder
3 * Copyright (c) 2003-2011 Michael Niedermayer <michaelni@gmx.at>
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 /**
23 * @file
24 * H.264 / AVC / MPEG-4 part10 DSP functions.
25 * @author Michael Niedermayer <michaelni@gmx.at>
26 */
27
28 #include "bit_depth_template.c"
29
30 #define op_scale1(x) block[x] = av_clip_pixel( (block[x]*weight + offset) >> log2_denom )
31 #define op_scale2(x) dst[x] = av_clip_pixel( (src[x]*weights + dst[x]*weightd + offset) >> (log2_denom+1))
32 #define H264_WEIGHT(W) \
33 static void FUNCC(weight_h264_pixels ## W)(uint8_t *_block, ptrdiff_t stride, int height, \
34 int log2_denom, int weight, int offset) \
35 { \
36 int y; \
37 pixel *block = (pixel*)_block; \
38 stride >>= sizeof(pixel)-1; \
39 offset = (unsigned)offset << (log2_denom + (BIT_DEPTH-8)); \
40 if(log2_denom) offset += 1<<(log2_denom-1); \
41 for (y = 0; y < height; y++, block += stride) { \
42 op_scale1(0); \
43 op_scale1(1); \
44 if(W==2) continue; \
45 op_scale1(2); \
46 op_scale1(3); \
47 if(W==4) continue; \
48 op_scale1(4); \
49 op_scale1(5); \
50 op_scale1(6); \
51 op_scale1(7); \
52 if(W==8) continue; \
53 op_scale1(8); \
54 op_scale1(9); \
55 op_scale1(10); \
56 op_scale1(11); \
57 op_scale1(12); \
58 op_scale1(13); \
59 op_scale1(14); \
60 op_scale1(15); \
61 } \
62 } \
63 static void FUNCC(biweight_h264_pixels ## W)(uint8_t *_dst, uint8_t *_src, ptrdiff_t stride, int height, \
64 int log2_denom, int weightd, int weights, int offset) \
65 { \
66 int y; \
67 pixel *dst = (pixel*)_dst; \
68 pixel *src = (pixel*)_src; \
69 stride >>= sizeof(pixel)-1; \
70 offset = (unsigned)offset << (BIT_DEPTH-8); \
71 offset = (unsigned)((offset + 1) | 1) << log2_denom; \
72 for (y = 0; y < height; y++, dst += stride, src += stride) { \
73 op_scale2(0); \
74 op_scale2(1); \
75 if(W==2) continue; \
76 op_scale2(2); \
77 op_scale2(3); \
78 if(W==4) continue; \
79 op_scale2(4); \
80 op_scale2(5); \
81 op_scale2(6); \
82 op_scale2(7); \
83 if(W==8) continue; \
84 op_scale2(8); \
85 op_scale2(9); \
86 op_scale2(10); \
87 op_scale2(11); \
88 op_scale2(12); \
89 op_scale2(13); \
90 op_scale2(14); \
91 op_scale2(15); \
92 } \
93 }
94
95
4/4
✓ Branch 0 taken 4090305 times.
✓ Branch 1 taken 723816 times.
✓ Branch 2 taken 9966344 times.
✓ Branch 3 taken 657768 times.
 29560930 H264_WEIGHT(16)
96
4/4
✓ Branch 0 taken 4743100 times.
✓ Branch 1 taken 595230 times.
✓ Branch 2 taken 3612752 times.
✓ Branch 3 taken 481070 times.
 17902164 H264_WEIGHT(8)
97
4/4
✓ Branch 0 taken 1280866 times.
✓ Branch 1 taken 152998 times.
✓ Branch 2 taken 3124080 times.
✓ Branch 3 taken 699838 times.
 9115888 H264_WEIGHT(4)
98
4/4
✓ Branch 0 taken 642584 times.
✓ Branch 1 taken 98228 times.
✓ Branch 2 taken 1261776 times.
✓ Branch 3 taken 447120 times.
 4005176 H264_WEIGHT(2)
99
100 #undef op_scale1
101 #undef op_scale2
102 #undef H264_WEIGHT
103
104 76186152 static av_always_inline av_flatten void FUNCC(h264_loop_filter_luma)(uint8_t *p_pix, ptrdiff_t xstride, ptrdiff_t ystride, int inner_iters, int alpha, int beta, int8_t *tc0)
105 {
106 76186152 pixel *pix = (pixel*)p_pix;
107 int i, d;
108 76186152 xstride >>= sizeof(pixel)-1;
109 76186152 ystride >>= sizeof(pixel)-1;
110 76186152 alpha <<= BIT_DEPTH - 8;
111 76186152 beta <<= BIT_DEPTH - 8;
112
2/2
✓ Branch 0 taken 152372304 times.
✓ Branch 1 taken 38093076 times.
 380930760 for( i = 0; i < 4; i++ ) {
113 304744608 const int tc_orig = tc0[i] * (1 << (BIT_DEPTH - 8));
114
2/2
✓ Branch 0 taken 25574964 times.
✓ Branch 1 taken 126797340 times.
 304744608 if( tc_orig < 0 ) {
115 51149928 pix += inner_iters*ystride;
116 51149928 continue;
117 }
118
2/2
✓ Branch 0 taken 504784768 times.
✓ Branch 1 taken 126797340 times.
 1263164216 for( d = 0; d < inner_iters; d++ ) {
119 1009569536 const int p0 = pix[-1*xstride];
120 1009569536 const int p1 = pix[-2*xstride];
121 1009569536 const int p2 = pix[-3*xstride];
122 1009569536 const int q0 = pix[0];
123 1009569536 const int q1 = pix[1*xstride];
124 1009569536 const int q2 = pix[2*xstride];
125
126
2/2
✓ Branch 0 taken 433120250 times.
✓ Branch 1 taken 71664518 times.
 1009569536 if( FFABS( p0 - q0 ) < alpha &&
127
2/2
✓ Branch 0 taken 326079529 times.
✓ Branch 1 taken 107040721 times.
 866240500 FFABS( p1 - p0 ) < beta &&
128
2/2
✓ Branch 0 taken 273247400 times.
✓ Branch 1 taken 52832129 times.
 652159058 FFABS( q1 - q0 ) < beta ) {
129
130 546494800 int tc = tc_orig;
131 int i_delta;
132
133
2/2
✓ Branch 0 taken 231823537 times.
✓ Branch 1 taken 41423863 times.
 546494800 if( FFABS( p2 - p0 ) < beta ) {
134
2/2
✓ Branch 0 taken 216716674 times.
✓ Branch 1 taken 15106863 times.
 463647074 if(tc_orig)
135 433433348 pix[-2*xstride] = p1 + av_clip( (( p2 + ( ( p0 + q0 + 1 ) >> 1 ) ) >> 1) - p1, -tc_orig, tc_orig );
136 463647074 tc++;
137 }
138
2/2
✓ Branch 0 taken 230672157 times.
✓ Branch 1 taken 42575243 times.
 546494800 if( FFABS( q2 - q0 ) < beta ) {
139
2/2
✓ Branch 0 taken 215593793 times.
✓ Branch 1 taken 15078364 times.
 461344314 if(tc_orig)
140 431187586 pix[ xstride] = q1 + av_clip( (( q2 + ( ( p0 + q0 + 1 ) >> 1 ) ) >> 1) - q1, -tc_orig, tc_orig );
141 461344314 tc++;
142 }
143
144 546494800 i_delta = av_clip( (((q0 - p0 ) * 4) + (p1 - q1) + 4) >> 3, -tc, tc );
145 546494800 pix[-xstride] = av_clip_pixel( p0 + i_delta ); /* p0' */
146 546494800 pix[0] = av_clip_pixel( q0 - i_delta ); /* q0' */
147 }
148 1009569536 pix += ystride;
149 }
150 }
151 76186152 }
152 38657528 static void FUNCC(h264_v_loop_filter_luma)(uint8_t *pix, ptrdiff_t stride, int alpha, int beta, int8_t *tc0)
153 {
154 38657528 FUNCC(h264_loop_filter_luma)(pix, stride, sizeof(pixel), 4, alpha, beta, tc0);
155 38657528 }
156 36927476 static void FUNCC(h264_h_loop_filter_luma)(uint8_t *pix, ptrdiff_t stride, int alpha, int beta, int8_t *tc0)
157 {
158 36927476 FUNCC(h264_loop_filter_luma)(pix, sizeof(pixel), stride, 4, alpha, beta, tc0);
159 36927476 }
160 601148 static void FUNCC(h264_h_loop_filter_luma_mbaff)(uint8_t *pix, ptrdiff_t stride, int alpha, int beta, int8_t *tc0)
161 {
162 601148 FUNCC(h264_loop_filter_luma)(pix, sizeof(pixel), stride, 2, alpha, beta, tc0);
163 601148 }
164
165 11428298 static av_always_inline av_flatten void FUNCC(h264_loop_filter_luma_intra)(uint8_t *p_pix, ptrdiff_t xstride, ptrdiff_t ystride, int inner_iters, int alpha, int beta)
166 {
167 11428298 pixel *pix = (pixel*)p_pix;
168 int d;
169 11428298 xstride >>= sizeof(pixel)-1;
170 11428298 ystride >>= sizeof(pixel)-1;
171 11428298 alpha <<= BIT_DEPTH - 8;
172 11428298 beta <<= BIT_DEPTH - 8;
173
2/2
✓ Branch 0 taken 88419624 times.
✓ Branch 1 taken 5714149 times.
 188267546 for( d = 0; d < 4 * inner_iters; d++ ) {
174 176839248 const int p2 = pix[-3*xstride];
175 176839248 const int p1 = pix[-2*xstride];
176 176839248 const int p0 = pix[-1*xstride];
177
178 176839248 const int q0 = pix[ 0*xstride];
179 176839248 const int q1 = pix[ 1*xstride];
180 176839248 const int q2 = pix[ 2*xstride];
181
182
2/2
✓ Branch 0 taken 77866445 times.
✓ Branch 1 taken 10553179 times.
 176839248 if( FFABS( p0 - q0 ) < alpha &&
183
2/2
✓ Branch 0 taken 62577847 times.
✓ Branch 1 taken 15288598 times.
 155732890 FFABS( p1 - p0 ) < beta &&
184
2/2
✓ Branch 0 taken 53999716 times.
✓ Branch 1 taken 8578131 times.
 125155694 FFABS( q1 - q0 ) < beta ) {
185
186
2/2
✓ Branch 0 taken 45015985 times.
✓ Branch 1 taken 8983731 times.
 107999432 if(FFABS( p0 - q0 ) < (( alpha >> 2 ) + 2 )){
187
2/2
✓ Branch 0 taken 40598649 times.
✓ Branch 1 taken 4417336 times.
 90031970 if( FFABS( p2 - p0 ) < beta)
188 {
189 81197298 const int p3 = pix[-4*xstride];
190 /* p0', p1', p2' */
191 81197298 pix[-1*xstride] = ( p2 + 2*p1 + 2*p0 + 2*q0 + q1 + 4 ) >> 3;
192 81197298 pix[-2*xstride] = ( p2 + p1 + p0 + q0 + 2 ) >> 2;
193 81197298 pix[-3*xstride] = ( 2*p3 + 3*p2 + p1 + p0 + q0 + 4 ) >> 3;
194 } else {
195 /* p0' */
196 8834672 pix[-1*xstride] = ( 2*p1 + p0 + q1 + 2 ) >> 2;
197 }
198
2/2
✓ Branch 0 taken 40360353 times.
✓ Branch 1 taken 4655632 times.
 90031970 if( FFABS( q2 - q0 ) < beta)
199 {
200 80720706 const int q3 = pix[3*xstride];
201 /* q0', q1', q2' */
202 80720706 pix[0*xstride] = ( p1 + 2*p0 + 2*q0 + 2*q1 + q2 + 4 ) >> 3;
203 80720706 pix[1*xstride] = ( p0 + q0 + q1 + q2 + 2 ) >> 2;
204 80720706 pix[2*xstride] = ( 2*q3 + 3*q2 + q1 + q0 + p0 + 4 ) >> 3;
205 } else {
206 /* q0' */
207 9311264 pix[0*xstride] = ( 2*q1 + q0 + p1 + 2 ) >> 2;
208 }
209 }else{
210 /* p0', q0' */
211 17967462 pix[-1*xstride] = ( 2*p1 + p0 + q1 + 2 ) >> 2;
212 17967462 pix[ 0*xstride] = ( 2*q1 + q0 + p1 + 2 ) >> 2;
213 }
214 }
215 176839248 pix += ystride;
216 }
217 11428298 }
218 4732792 static void FUNCC(h264_v_loop_filter_luma_intra)(uint8_t *pix, ptrdiff_t stride, int alpha, int beta)
219 {
220 4732792 FUNCC(h264_loop_filter_luma_intra)(pix, stride, sizeof(pixel), 4, alpha, beta);
221 4732792 }
222 5943816 static void FUNCC(h264_h_loop_filter_luma_intra)(uint8_t *pix, ptrdiff_t stride, int alpha, int beta)
223 {
224 5943816 FUNCC(h264_loop_filter_luma_intra)(pix, sizeof(pixel), stride, 4, alpha, beta);
225 5943816 }
226 751690 static void FUNCC(h264_h_loop_filter_luma_mbaff_intra)(uint8_t *pix, ptrdiff_t stride, int alpha, int beta)
227 {
228 751690 FUNCC(h264_loop_filter_luma_intra)(pix, sizeof(pixel), stride, 2, alpha, beta);
229 751690 }
230
231 90522606 static av_always_inline av_flatten void FUNCC(h264_loop_filter_chroma)(uint8_t *p_pix, ptrdiff_t xstride, ptrdiff_t ystride, int inner_iters, int alpha, int beta, int8_t *tc0)
232 {
233 90522606 pixel *pix = (pixel*)p_pix;
234 int i, d;
235 90522606 alpha <<= BIT_DEPTH - 8;
236 90522606 beta <<= BIT_DEPTH - 8;
237 90522606 xstride >>= sizeof(pixel)-1;
238 90522606 ystride >>= sizeof(pixel)-1;
239
2/2
✓ Branch 0 taken 181045212 times.
✓ Branch 1 taken 45261303 times.
 452613030 for( i = 0; i < 4; i++ ) {
240 362090424 const int tc = ((tc0[i] - 1U) << (BIT_DEPTH - 8)) + 1;
241
2/2
✓ Branch 0 taken 24259782 times.
✓ Branch 1 taken 156785430 times.
 362090424 if( tc <= 0 ) {
242 48519564 pix += inner_iters*ystride;
243 48519564 continue;
244 }
245
2/2
✓ Branch 0 taken 322037318 times.
✓ Branch 1 taken 156785430 times.
 957645496 for( d = 0; d < inner_iters; d++ ) {
246 644074636 const int p0 = pix[-1*xstride];
247 644074636 const int p1 = pix[-2*xstride];
248 644074636 const int q0 = pix[0];
249 644074636 const int q1 = pix[1*xstride];
250
251
2/2
✓ Branch 0 taken 315444426 times.
✓ Branch 1 taken 6592892 times.
 644074636 if( FFABS( p0 - q0 ) < alpha &&
252
2/2
✓ Branch 0 taken 296718277 times.
✓ Branch 1 taken 18726149 times.
 630888852 FFABS( p1 - p0 ) < beta &&
253
2/2
✓ Branch 0 taken 284182060 times.
✓ Branch 1 taken 12536217 times.
 593436554 FFABS( q1 - q0 ) < beta ) {
254
255 568364120 int delta = av_clip( ((q0 - p0) * 4 + (p1 - q1) + 4) >> 3, -tc, tc );
256
257 568364120 pix[-xstride] = av_clip_pixel( p0 + delta ); /* p0' */
258 568364120 pix[0] = av_clip_pixel( q0 - delta ); /* q0' */
259 }
260 644074636 pix += ystride;
261 }
262 }
263 90522606 }
264 49096084 static void FUNCC(h264_v_loop_filter_chroma)(uint8_t *pix, ptrdiff_t stride, int alpha, int beta, int8_t *tc0)
265 {
266 49096084 FUNCC(h264_loop_filter_chroma)(pix, stride, sizeof(pixel), 2, alpha, beta, tc0);
267 49096084 }
268 37352034 static void FUNCC(h264_h_loop_filter_chroma)(uint8_t *pix, ptrdiff_t stride, int alpha, int beta, int8_t *tc0)
269 {
270 37352034 FUNCC(h264_loop_filter_chroma)(pix, sizeof(pixel), stride, 2, alpha, beta, tc0);
271 37352034 }
272 1300812 static void FUNCC(h264_h_loop_filter_chroma_mbaff)(uint8_t *pix, ptrdiff_t stride, int alpha, int beta, int8_t *tc0)
273 {
274 1300812 FUNCC(h264_loop_filter_chroma)(pix, sizeof(pixel), stride, 1, alpha, beta, tc0);
275 1300812 }
276 2773256 static void FUNCC(h264_h_loop_filter_chroma422)(uint8_t *pix, ptrdiff_t stride, int alpha, int beta, int8_t *tc0)
277 {
278 2773256 FUNCC(h264_loop_filter_chroma)(pix, sizeof(pixel), stride, 4, alpha, beta, tc0);
279 2773256 }
280 420 static void FUNCC(h264_h_loop_filter_chroma422_mbaff)(uint8_t *pix, ptrdiff_t stride, int alpha, int beta, int8_t *tc0)
281 {
282 420 FUNCC(h264_loop_filter_chroma)(pix, sizeof(pixel), stride, 2, alpha, beta, tc0);
283 420 }
284
285 22284370 static av_always_inline av_flatten void FUNCC(h264_loop_filter_chroma_intra)(uint8_t *p_pix, ptrdiff_t xstride, ptrdiff_t ystride, int inner_iters, int alpha, int beta)
286 {
287 22284370 pixel *pix = (pixel*)p_pix;
288 int d;
289 22284370 xstride >>= sizeof(pixel)-1;
290 22284370 ystride >>= sizeof(pixel)-1;
291 22284370 alpha <<= BIT_DEPTH - 8;
292 22284370 beta <<= BIT_DEPTH - 8;
293
2/2
✓ Branch 0 taken 97007032 times.
✓ Branch 1 taken 11142185 times.
 216298434 for( d = 0; d < 4 * inner_iters; d++ ) {
294 194014064 const int p0 = pix[-1*xstride];
295 194014064 const int p1 = pix[-2*xstride];
296 194014064 const int q0 = pix[0];
297 194014064 const int q1 = pix[1*xstride];
298
299
2/2
✓ Branch 0 taken 94119709 times.
✓ Branch 1 taken 2887323 times.
 194014064 if( FFABS( p0 - q0 ) < alpha &&
300
2/2
✓ Branch 0 taken 89071232 times.
✓ Branch 1 taken 5048477 times.
 188239418 FFABS( p1 - p0 ) < beta &&
301
2/2
✓ Branch 0 taken 85515861 times.
✓ Branch 1 taken 3555371 times.
 178142464 FFABS( q1 - q0 ) < beta ) {
302
303 171031722 pix[-xstride] = ( 2*p1 + p0 + q1 + 2 ) >> 2; /* p0' */
304 171031722 pix[0] = ( 2*q1 + q0 + p1 + 2 ) >> 2; /* q0' */
305 }
306 194014064 pix += ystride;
307 }
308 22284370 }
309 9157420 static void FUNCC(h264_v_loop_filter_chroma_intra)(uint8_t *pix, ptrdiff_t stride, int alpha, int beta)
310 {
311 9157420 FUNCC(h264_loop_filter_chroma_intra)(pix, stride, sizeof(pixel), 2, alpha, beta);
312 9157420 }
313 9124688 static void FUNCC(h264_h_loop_filter_chroma_intra)(uint8_t *pix, ptrdiff_t stride, int alpha, int beta)
314 {
315 9124688 FUNCC(h264_loop_filter_chroma_intra)(pix, sizeof(pixel), stride, 2, alpha, beta);
316 9124688 }
317 1063524 static void FUNCC(h264_h_loop_filter_chroma_mbaff_intra)(uint8_t *pix, ptrdiff_t stride, int alpha, int beta)
318 {
319 1063524 FUNCC(h264_loop_filter_chroma_intra)(pix, sizeof(pixel), stride, 1, alpha, beta);
320 1063524 }
321 2499150 static void FUNCC(h264_h_loop_filter_chroma422_intra)(uint8_t *pix, ptrdiff_t stride, int alpha, int beta)
322 {
323 2499150 FUNCC(h264_loop_filter_chroma_intra)(pix, sizeof(pixel), stride, 4, alpha, beta);
324 2499150 }
325 439588 static void FUNCC(h264_h_loop_filter_chroma422_mbaff_intra)(uint8_t *pix, ptrdiff_t stride, int alpha, int beta)
326 {
327 439588 FUNCC(h264_loop_filter_chroma_intra)(pix, sizeof(pixel), stride, 2, alpha, beta);
328 439588 }
329