FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/libavutil/tests/pixelutils.c
Date: 2024-11-20 23:03:26
Exec Total Coverage
Lines: 87 98 88.8%
Functions: 4 4 100.0%
Branches: 64 90 71.1%
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 <stdio.h>
20
21 #include "libavutil/avassert.h"
22 #include "libavutil/internal.h"
23 #include "libavutil/log.h"
24 #include "libavutil/mem.h"
25 #include "libavutil/pixdesc.h"
26 #include "libavutil/pixelutils.c"
27 #include "libavutil/pixfmt.h"
28
29 #define W1 320
30 #define H1 240
31 #define W2 640
32 #define H2 480
33
34 1 static void check_pixfmt_descriptors(void)
35 {
36 1 const AVPixFmtDescriptor *d, *last = NULL;
37 int i;
38
39
2/2
✓ Branch 1 taken 243 times.
✓ Branch 2 taken 1 times.
 244 for (i = AV_PIX_FMT_NONE, d = NULL; i++, d = av_pix_fmt_desc_next(d);) {
40 243 uint8_t fill[4][8 + 6 + 3] = {{ 0 }};
41 243 uint8_t *data[4] = { fill[0], fill[1], fill[2], fill[3] };
42 243 int linesize[4] = { 0, 0, 0, 0 };
43 uint16_t tmp[2];
44
45
2/4
✓ Branch 0 taken 243 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 243 times.
 243 av_assert0(d->name && d->name[0]);
46 243 av_log(NULL, AV_LOG_INFO, "Checking: %s\n", d->name);
47
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 243 times.
 243 av_assert0(d->log2_chroma_w <= 3);
48
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 243 times.
 243 av_assert0(d->log2_chroma_h <= 3);
49
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 243 times.
 243 av_assert0(d->nb_components <= 4);
50
3/4
✓ Branch 0 taken 14 times.
✓ Branch 1 taken 229 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 14 times.
 243 av_assert0(d->nb_components || (d->flags & AV_PIX_FMT_FLAG_HWACCEL));
51
1/2
✗ Branch 2 not taken.
✓ Branch 3 taken 243 times.
 243 av_assert0(av_get_pix_fmt(d->name) == av_pix_fmt_desc_get_id(d));
52
53 /* The following two checks as well as the one after the loop
54 * would need to be changed if we changed the way the descriptors
55 * are stored. */
56
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 243 times.
 243 av_assert0(i == av_pix_fmt_desc_get_id(d));
57
3/4
✓ Branch 0 taken 242 times.
✓ Branch 1 taken 1 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 242 times.
 243 av_assert0(!last || last + 1 == d);
58
59
2/2
✓ Branch 0 taken 972 times.
✓ Branch 1 taken 243 times.
 1215 for (int j = 0; j < FF_ARRAY_ELEMS(d->comp); j++) {
60 972 const AVComponentDescriptor *c = &d->comp[j];
61
2/2
✓ Branch 0 taken 248 times.
✓ Branch 1 taken 724 times.
 972 if (!c->depth) {
62 248 continue;
63 }
64
2/2
✓ Branch 0 taken 16 times.
✓ Branch 1 taken 708 times.
 724 if (d->flags & AV_PIX_FMT_FLAG_BITSTREAM) {
65
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 16 times.
 16 av_assert0(c->step >= c->depth);
66 } else {
67
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 708 times.
 708 av_assert0(8*c->step >= c->depth);
68 }
69
2/2
✓ Branch 0 taken 36 times.
✓ Branch 1 taken 688 times.
 724 if (d->flags & AV_PIX_FMT_FLAG_BAYER)
70 36 continue;
71 688 av_read_image_line(tmp, (void*)data, linesize, d, 0, 0, j, 2, 0);
72
2/4
✓ Branch 0 taken 688 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 688 times.
 688 av_assert0(tmp[0] == 0 && tmp[1] == 0);
73 688 tmp[0] = tmp[1] = (1ULL << c->depth) - 1;
74 688 av_write_image_line(tmp, data, linesize, d, 0, 0, j, 2);
75 }
76 243 last = d;
77 }
78
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
 1 av_assert0(i == AV_PIX_FMT_NB);
79 1 }
80
81 60 static int run_single_test(const char *test,
82 const uint8_t *block1, ptrdiff_t stride1,
83 const uint8_t *block2, ptrdiff_t stride2,
84 int align, int n)
85 {
86 int out, ref;
87 60 av_pixelutils_sad_fn f_ref = sad_c[n - 1];
88 60 av_pixelutils_sad_fn f_out = av_pixelutils_get_sad_fn(n, n, align, NULL);
89
90
3/4
✓ Branch 0 taken 20 times.
✓ Branch 1 taken 20 times.
✓ Branch 2 taken 20 times.
✗ Branch 3 not taken.
 60 switch (align) {
91 20 case 0: block1++; block2++; break;
92 20 case 1: block2++; break;
93 20 case 2: break;
94 }
95
96 60 out = f_out(block1, stride1, block2, stride2);
97 60 ref = f_ref(block1, stride1, block2, stride2);
98
5/6
✓ Branch 0 taken 20 times.
✓ Branch 1 taken 40 times.
✓ Branch 2 taken 40 times.
✓ Branch 3 taken 20 times.
✓ Branch 4 taken 60 times.
✗ Branch 5 not taken.
 60 printf("[%s] [%c%c] SAD [%s] %dx%d=%d ref=%d\n",
99 out == ref ? "OK" : "FAIL",
100 align ? 'A' : 'U', align == 2 ? 'A' : 'U',
101 test, 1<<n, 1<<n, out, ref);
102 60 return out != ref;
103 }
104
105 3 static int run_test(const char *test,
106 const uint8_t *b1, const uint8_t *b2)
107 {
108 3 int i, a, ret = 0;
109
110
2/2
✓ Branch 0 taken 9 times.
✓ Branch 1 taken 3 times.
 12 for (a = 0; a < 3; a++) {
111
2/2
✓ Branch 0 taken 45 times.
✓ Branch 1 taken 9 times.
 54 for (i = 1; i <= FF_ARRAY_ELEMS(sad_c); i++) {
112 45 int r = run_single_test(test, b1, W1, b2, W2, a, i);
113
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 45 times.
 45 if (r)
114 ✗ ret = r;
115 }
116 }
117 3 return ret;
118 }
119
120 1 int main(void)
121 {
122 int i, align, ret;
123 1 uint8_t *buf1 = av_malloc(W1*H1);
124 1 uint8_t *buf2 = av_malloc(W2*H2);
125 1 uint32_t state = 0;
126
127
2/4
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 1 times.
 1 if (!buf1 || !buf2) {
128 ✗ fprintf(stderr, "malloc failure\n");
129 ✗ ret = 1;
130 ✗ goto end;
131 }
132
133 1 check_pixfmt_descriptors();
134
135 #define RANDOM_INIT(buf, size) do { \
136 int k; \
137 for (k = 0; k < size; k++) { \
138 state = state * 1664525 + 1013904223; \
139 buf[k] = state>>24; \
140 } \
141 } while (0)
142
143 /* Normal test with different strides */
144
2/2
✓ Branch 0 taken 76800 times.
✓ Branch 1 taken 1 times.
 76801 RANDOM_INIT(buf1, W1*H1);
145
2/2
✓ Branch 0 taken 307200 times.
✓ Branch 1 taken 1 times.
 307201 RANDOM_INIT(buf2, W2*H2);
146 1 ret = run_test("random", buf1, buf2);
147
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
 1 if (ret < 0)
148 ✗ goto end;
149
150 /* Check for maximum SAD */
151 1 memset(buf1, 0xff, W1*H1);
152 1 memset(buf2, 0x00, W2*H2);
153 1 ret = run_test("max", buf1, buf2);
154
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
 1 if (ret < 0)
155 ✗ goto end;
156
157 /* Check for minimum SAD */
158 1 memset(buf1, 0x90, W1*H1);
159 1 memset(buf2, 0x90, W2*H2);
160 1 ret = run_test("min", buf1, buf2);
161
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
 1 if (ret < 0)
162 ✗ goto end;
163
164 /* Exact buffer sizes, to check for overreads */
165
2/2
✓ Branch 0 taken 5 times.
✓ Branch 1 taken 1 times.
 6 for (i = 1; i <= 5; i++) {
166
2/2
✓ Branch 0 taken 15 times.
✓ Branch 1 taken 5 times.
 20 for (align = 0; align < 3; align++) {
167 int size1, size2;
168
169 15 av_freep(&buf1);
170 15 av_freep(&buf2);
171
172 15 size1 = size2 = 1 << (i << 1);
173
174
3/4
✓ Branch 0 taken 5 times.
✓ Branch 1 taken 5 times.
✓ Branch 2 taken 5 times.
✗ Branch 3 not taken.
 15 switch (align) {
175 5 case 0: size1++; size2++; break;
176 5 case 1: size2++; break;
177 5 case 2: break;
178 }
179
180 15 buf1 = av_malloc(size1);
181 15 buf2 = av_malloc(size2);
182
2/4
✓ Branch 0 taken 15 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 15 times.
 15 if (!buf1 || !buf2) {
183 ✗ fprintf(stderr, "malloc failure\n");
184 ✗ ret = 1;
185 ✗ goto end;
186 }
187
2/2
✓ Branch 0 taken 4097 times.
✓ Branch 1 taken 15 times.
 4112 RANDOM_INIT(buf1, size1);
188
2/2
✓ Branch 0 taken 4102 times.
✓ Branch 1 taken 15 times.
 4117 RANDOM_INIT(buf2, size2);
189 15 ret = run_single_test("small", buf1, 1<<i, buf2, 1<<i, align, i);
190
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 15 times.
 15 if (ret < 0)
191 ✗ goto end;
192 }
193 }
194
195 1 end:
196 1 av_free(buf1);
197 1 av_free(buf2);
198 1 return ret;
199 }
200