Branch data Line data Source code
1 : : #include "utils.h"
2 : : #include "libplacebo/utils/libav.h"
3 : :
4 : 1 : int main()
5 : : {
6 : 1 : struct pl_plane_data data[4] = {0};
7 : : struct pl_bit_encoding bits;
8 : :
9 : : // Make sure we don't crash on any av pixfmt
10 : : const AVPixFmtDescriptor *desc = NULL;
11 [ + + ]: 229 : while ((desc = av_pix_fmt_desc_next(desc)))
12 : 228 : pl_plane_data_from_pixfmt(data, &bits, av_pix_fmt_desc_get_id(desc));
13 : :
14 : : #define TEST(pixfmt, reference) \
15 : : do { \
16 : : int planes = pl_plane_data_from_pixfmt(data, &bits, pixfmt); \
17 : : REQUIRE_CMP(planes, ==, sizeof(reference) / sizeof(*reference), "d"); \
18 : : REQUIRE_MEMEQ(data, reference, sizeof(reference)); \
19 : : } while (0)
20 : :
21 : : // Planar and semiplanar formats
22 : : static const struct pl_plane_data yuvp8[] = {
23 : : {
24 : : .type = PL_FMT_UNORM,
25 : : .component_size = {8},
26 : : .component_map = {0},
27 : : .pixel_stride = 1,
28 : : }, {
29 : : .type = PL_FMT_UNORM,
30 : : .component_size = {8},
31 : : .component_map = {1},
32 : : .pixel_stride = 1,
33 : : }, {
34 : : .type = PL_FMT_UNORM,
35 : : .component_size = {8},
36 : : .component_map = {2},
37 : : .pixel_stride = 1,
38 : : }
39 : : };
40 : :
41 [ - + ]: 1 : TEST(AV_PIX_FMT_YUV420P, yuvp8);
42 [ - + ]: 1 : TEST(AV_PIX_FMT_YUV422P, yuvp8);
43 [ - + ]: 1 : TEST(AV_PIX_FMT_YUV444P, yuvp8);
44 [ - + ]: 1 : TEST(AV_PIX_FMT_YUV410P, yuvp8);
45 [ - + ]: 1 : TEST(AV_PIX_FMT_YUV411P, yuvp8);
46 [ - + ]: 1 : TEST(AV_PIX_FMT_YUV440P, yuvp8);
47 : :
48 : : static const struct pl_plane_data yuvap8[] = {
49 : : {
50 : : .type = PL_FMT_UNORM,
51 : : .component_size = {8},
52 : : .component_map = {0},
53 : : .pixel_stride = 1,
54 : : }, {
55 : : .type = PL_FMT_UNORM,
56 : : .component_size = {8},
57 : : .component_map = {1},
58 : : .pixel_stride = 1,
59 : : }, {
60 : : .type = PL_FMT_UNORM,
61 : : .component_size = {8},
62 : : .component_map = {2},
63 : : .pixel_stride = 1,
64 : : }, {
65 : : .type = PL_FMT_UNORM,
66 : : .component_size = {8},
67 : : .component_map = {3},
68 : : .pixel_stride = 1,
69 : : }
70 : : };
71 : :
72 [ - + ]: 1 : TEST(AV_PIX_FMT_YUVA420P, yuvap8);
73 : :
74 : : static const struct pl_plane_data yuvp16[] = {
75 : : {
76 : : .type = PL_FMT_UNORM,
77 : : .component_size = {16},
78 : : .component_map = {0},
79 : : .pixel_stride = 2,
80 : : }, {
81 : : .type = PL_FMT_UNORM,
82 : : .component_size = {16},
83 : : .component_map = {1},
84 : : .pixel_stride = 2,
85 : : }, {
86 : : .type = PL_FMT_UNORM,
87 : : .component_size = {16},
88 : : .component_map = {2},
89 : : .pixel_stride = 2,
90 : : }
91 : : };
92 : :
93 [ - + ]: 1 : TEST(AV_PIX_FMT_YUV420P10LE, yuvp16);
94 [ - + ]: 1 : TEST(AV_PIX_FMT_YUV420P16LE, yuvp16);
95 : :
96 : : static const struct pl_plane_data nv12[] = {
97 : : {
98 : : .type = PL_FMT_UNORM,
99 : : .component_size = {8},
100 : : .component_map = {0},
101 : : .pixel_stride = 1,
102 : : }, {
103 : : .type = PL_FMT_UNORM,
104 : : .component_size = {8, 8},
105 : : .component_map = {1, 2},
106 : : .pixel_stride = 2,
107 : : }
108 : : };
109 : :
110 [ - + ]: 1 : TEST(AV_PIX_FMT_NV12, nv12);
111 : :
112 : : static const struct pl_plane_data nv21[] = {
113 : : {
114 : : .type = PL_FMT_UNORM,
115 : : .component_size = {8},
116 : : .component_map = {0},
117 : : .pixel_stride = 1,
118 : : }, {
119 : : .type = PL_FMT_UNORM,
120 : : .component_size = {8, 8},
121 : : .component_map = {2, 1},
122 : : .pixel_stride = 2,
123 : : }
124 : : };
125 : :
126 [ - + ]: 1 : TEST(AV_PIX_FMT_NV21, nv21);
127 : :
128 : : static const struct pl_plane_data p016[] = {
129 : : {
130 : : .type = PL_FMT_UNORM,
131 : : .component_size = {16},
132 : : .component_map = {0},
133 : : .pixel_stride = 2,
134 : : }, {
135 : : .type = PL_FMT_UNORM,
136 : : .component_size = {16, 16},
137 : : .component_map = {1, 2},
138 : : .pixel_stride = 4,
139 : : }
140 : : };
141 : :
142 [ - + ]: 1 : TEST(AV_PIX_FMT_P010LE, p016);
143 [ - + ]: 1 : TEST(AV_PIX_FMT_P016LE, p016);
144 : :
145 : : // Packed formats
146 : : static const struct pl_plane_data r8[] = {
147 : : {
148 : : .type = PL_FMT_UNORM,
149 : : .component_size = {8},
150 : : .component_map = {0},
151 : : .pixel_stride = 1,
152 : : }
153 : : };
154 : :
155 [ - + ]: 1 : TEST(AV_PIX_FMT_GRAY8, r8);
156 : :
157 : : static const struct pl_plane_data rg8[] = {
158 : : {
159 : : .type = PL_FMT_UNORM,
160 : : .component_size = {8, 8},
161 : : .component_map = {0, 1},
162 : : .pixel_stride = 2,
163 : : }
164 : : };
165 : :
166 [ - + ]: 1 : TEST(AV_PIX_FMT_GRAY8A, rg8);
167 : :
168 : : static const struct pl_plane_data rgb8[] = {
169 : : {
170 : : .type = PL_FMT_UNORM,
171 : : .component_size = {8, 8, 8},
172 : : .component_map = {0, 1, 2},
173 : : .pixel_stride = 3,
174 : : }
175 : : };
176 : :
177 [ - + ]: 1 : TEST(AV_PIX_FMT_RGB24, rgb8);
178 : :
179 : : static const struct pl_plane_data bgr8[] = {
180 : : {
181 : : .type = PL_FMT_UNORM,
182 : : .component_size = {8, 8, 8},
183 : : .component_map = {2, 1, 0},
184 : : .pixel_stride = 3,
185 : : }
186 : : };
187 : :
188 [ - + ]: 1 : TEST(AV_PIX_FMT_BGR24, bgr8);
189 : :
190 : : static const struct pl_plane_data rgbx8[] = {
191 : : {
192 : : .type = PL_FMT_UNORM,
193 : : .component_size = {8, 8, 8},
194 : : .component_map = {0, 1, 2},
195 : : .pixel_stride = 4,
196 : : }
197 : : };
198 : :
199 [ - + ]: 1 : TEST(AV_PIX_FMT_RGB0, rgbx8);
200 : :
201 : : static const struct pl_plane_data xrgb8[] = {
202 : : {
203 : : .type = PL_FMT_UNORM,
204 : : .component_size = {8, 8, 8},
205 : : .component_map = {0, 1, 2},
206 : : .component_pad = {8, 0, 0},
207 : : .pixel_stride = 4,
208 : : }
209 : : };
210 : :
211 [ - + ]: 1 : TEST(AV_PIX_FMT_0RGB, xrgb8);
212 : :
213 : : static const struct pl_plane_data rgba8[] = {
214 : : {
215 : : .type = PL_FMT_UNORM,
216 : : .component_size = {8, 8, 8, 8},
217 : : .component_map = {0, 1, 2, 3},
218 : : .pixel_stride = 4,
219 : : }
220 : : };
221 : :
222 [ - + ]: 1 : TEST(AV_PIX_FMT_RGBA, rgba8);
223 : :
224 : : static const struct pl_plane_data argb8[] = {
225 : : {
226 : : .type = PL_FMT_UNORM,
227 : : .component_size = {8, 8, 8, 8},
228 : : .component_map = {3, 0, 1, 2},
229 : : .pixel_stride = 4,
230 : : }
231 : : };
232 : :
233 [ - + ]: 1 : TEST(AV_PIX_FMT_ARGB, argb8);
234 : :
235 : : static const struct pl_plane_data bgra8[] = {
236 : : {
237 : : .type = PL_FMT_UNORM,
238 : : .component_size = {8, 8, 8, 8},
239 : : .component_map = {2, 1, 0, 3},
240 : : .pixel_stride = 4,
241 : : }
242 : : };
243 : :
244 [ - + ]: 1 : TEST(AV_PIX_FMT_BGRA, bgra8);
245 : :
246 : : static const struct pl_plane_data abgr8[] = {
247 : : {
248 : : .type = PL_FMT_UNORM,
249 : : .component_size = {8, 8, 8, 8},
250 : : .component_map = {3, 2, 1, 0},
251 : : .pixel_stride = 4,
252 : : }
253 : : };
254 : :
255 [ - + ]: 1 : TEST(AV_PIX_FMT_ABGR, abgr8);
256 : :
257 : : static const struct pl_plane_data r16[] = {
258 : : {
259 : : .type = PL_FMT_UNORM,
260 : : .component_size = {16},
261 : : .component_map = {0},
262 : : .pixel_stride = 2,
263 : : }
264 : : };
265 : :
266 [ - + ]: 1 : TEST(AV_PIX_FMT_GRAY16LE, r16);
267 : :
268 : : static const struct pl_plane_data rgb16[] = {
269 : : {
270 : : .type = PL_FMT_UNORM,
271 : : .component_size = {16, 16, 16},
272 : : .component_map = {0, 1, 2},
273 : : .pixel_stride = 6,
274 : : }
275 : : };
276 : :
277 [ - + ]: 1 : TEST(AV_PIX_FMT_RGB48LE, rgb16);
278 : :
279 : : static const struct pl_plane_data rgb16be[] = {
280 : : {
281 : : .type = PL_FMT_UNORM,
282 : : .component_size = {16, 16, 16},
283 : : .component_map = {0, 1, 2},
284 : : .pixel_stride = 6,
285 : : .swapped = true,
286 : : }
287 : : };
288 : :
289 [ - + ]: 1 : TEST(AV_PIX_FMT_RGB48BE, rgb16be);
290 : :
291 : : static const struct pl_plane_data rgba16[] = {
292 : : {
293 : : .type = PL_FMT_UNORM,
294 : : .component_size = {16, 16, 16, 16},
295 : : .component_map = {0, 1, 2, 3},
296 : : .pixel_stride = 8,
297 : : }
298 : : };
299 : :
300 [ - + ]: 1 : TEST(AV_PIX_FMT_RGBA64LE, rgba16);
301 : :
302 : : static const struct pl_plane_data rgba16be[] = {
303 : : {
304 : : .type = PL_FMT_UNORM,
305 : : .component_size = {16, 16, 16, 16},
306 : : .component_map = {0, 1, 2, 3},
307 : : .pixel_stride = 8,
308 : : .swapped = true,
309 : : }
310 : : };
311 : :
312 [ - + ]: 1 : TEST(AV_PIX_FMT_RGBA64BE, rgba16be);
313 : :
314 : : static const struct pl_plane_data rgb565[] = {
315 : : {
316 : : .type = PL_FMT_UNORM,
317 : : .component_size = {5, 6, 5},
318 : : .component_map = {2, 1, 0}, // LSB to MSB
319 : : .pixel_stride = 2,
320 : : }
321 : : };
322 : :
323 [ - + ]: 1 : TEST(AV_PIX_FMT_RGB565LE, rgb565);
324 : :
325 : : #if LIBAVUTIL_VERSION_INT >= AV_VERSION_INT(57, 37, 100)
326 : :
327 : : static const struct pl_plane_data rgb32f[] = {
328 : : {
329 : : .type = PL_FMT_FLOAT,
330 : : .component_size = {32, 32, 32},
331 : : .component_map = {0, 1, 2},
332 : : .pixel_stride = 12,
333 : : }
334 : : };
335 : :
336 [ - + ]: 1 : TEST(AV_PIX_FMT_RGBF32LE, rgb32f);
337 : :
338 : : #endif
339 : :
340 : : // Test pl_frame <- AVFrame bridge
341 : : struct pl_frame image;
342 : 1 : AVFrame *frame = av_frame_alloc();
343 : 1 : frame->format = AV_PIX_FMT_RGBA;
344 : 1 : pl_frame_from_avframe(&image, frame);
345 [ - + ]: 1 : REQUIRE_CMP(image.num_planes, ==, 1, "d");
346 [ - + ]: 1 : REQUIRE_CMP(image.repr.sys, ==, PL_COLOR_SYSTEM_RGB, "u");
347 : :
348 : : // Test inverse mapping
349 : 1 : struct pl_color_space csp = image.color;
350 : 1 : pl_color_space_infer(&csp);
351 : 1 : pl_avframe_set_color(frame, csp);
352 [ + - ]: 1 : pl_avframe_set_repr(frame, image.repr);
353 : 1 : pl_avframe_set_profile(frame, image.profile);
354 : 1 : pl_frame_from_avframe(&image, frame);
355 : 1 : pl_color_space_infer(&image.color);
356 [ - + ]: 1 : REQUIRE(pl_color_space_equal(&csp, &image.color));
357 : 1 : av_frame_free(&frame);
358 : :
359 : : // Test enum functions
360 [ + + ]: 13 : for (enum pl_color_system sys = 0; sys < PL_COLOR_SYSTEM_COUNT; sys++) {
361 : : enum AVColorSpace spc = pl_system_to_av(sys);
362 : : enum pl_color_system sys2 = pl_system_from_av(spc);
363 : : // Exception to the rule, due to different handling in libav*
364 [ + + ]: 12 : if (sys2 && sys != PL_COLOR_SYSTEM_BT_2100_HLG)
365 [ - + ]: 8 : REQUIRE_CMP(sys, ==, sys2, "u");
366 : : }
367 : :
368 [ + + ]: 4 : for (enum pl_color_levels lev = 0; lev < PL_COLOR_LEVELS_COUNT; lev++) {
369 : : enum AVColorRange range = pl_levels_to_av(lev);
370 : : enum pl_color_levels lev2 = pl_levels_from_av(range);
371 [ - + ]: 3 : REQUIRE_CMP(lev, ==, lev2, "u");
372 : : }
373 : :
374 [ + + ]: 19 : for (enum pl_color_primaries prim = 0; prim < PL_COLOR_PRIM_COUNT; prim++) {
375 : : enum AVColorPrimaries avpri = pl_primaries_to_av(prim);
376 : : enum pl_color_primaries prim2 = pl_primaries_from_av(avpri);
377 [ + + ]: 18 : if (prim2)
378 [ - + ]: 10 : REQUIRE_CMP(prim, ==, prim2, "u");
379 : : }
380 : :
381 [ + + ]: 18 : for (enum pl_color_transfer trc = 0; trc < PL_COLOR_TRC_COUNT; trc++) {
382 : : enum AVColorTransferCharacteristic avtrc = pl_transfer_to_av(trc);
383 : : enum pl_color_transfer trc2 = pl_transfer_from_av(avtrc);
384 [ + + ]: 17 : if (trc2)
385 [ - + ]: 8 : REQUIRE_CMP(trc, ==, trc2, "u");
386 : : }
387 : :
388 [ + + ]: 8 : for (enum pl_chroma_location loc = 0; loc < PL_CHROMA_COUNT; loc++) {
389 : : enum AVChromaLocation avloc = pl_chroma_to_av(loc);
390 : : enum pl_chroma_location loc2 = pl_chroma_from_av(avloc);
391 [ - + ]: 7 : REQUIRE_CMP(loc, ==, loc2, "u");
392 : : }
393 : : }
|