1 #include "tests.h"
2 #include "gpu.h"
3
main()4 int main()
5 {
6 struct pl_bit_encoding bits = {0};
7 struct pl_plane_data data = {0};
8
9 static const struct pl_bit_encoding bits0 = {0};
10 static const struct pl_bit_encoding bits8 = {
11 .sample_depth = 8,
12 .color_depth = 8,
13 };
14
15 static const struct pl_bit_encoding bits16 = {
16 .sample_depth = 16,
17 .color_depth = 16,
18 };
19
20 static const struct pl_bit_encoding bits10_16 = {
21 .sample_depth = 16,
22 .color_depth = 10,
23 };
24
25 static const struct pl_bit_encoding bits10_16_6 = {
26 .sample_depth = 16,
27 .color_depth = 10,
28 .bit_shift = 6,
29 };
30
31 #define TEST_ALIGN(ref, ref_align, ref_bits, ...) \
32 do { \
33 pl_plane_data_from_mask(&data, (uint64_t[4]){ __VA_ARGS__ }); \
34 REQUIRE(memcmp(&data, &ref, sizeof(ref)) == 0); \
35 pl_plane_data_align(&data, &bits); \
36 REQUIRE(memcmp(&data, &ref_align, sizeof(ref_align)) == 0); \
37 REQUIRE(memcmp(&bits, &ref_bits, sizeof(bits)) == 0); \
38 } while (0)
39
40 #define TEST(ref, bits, ...) TEST_ALIGN(ref, ref, bits, __VA_ARGS__)
41
42 static const struct pl_plane_data rgb8 = {
43 .component_size = {8, 8, 8},
44 .component_map = {0, 1, 2},
45 };
46
47 TEST(rgb8, bits8, 0xFF, 0xFF00, 0xFF0000);
48
49 static const struct pl_plane_data bgra8 = {
50 .component_size = {8, 8, 8, 8},
51 .component_map = {2, 1, 0, 3},
52 };
53
54 TEST(bgra8, bits8, 0xFF0000, 0xFF00, 0xFF, 0xFF000000);
55
56 static const struct pl_plane_data gr16 = {
57 .component_size = {16, 16},
58 .component_map = {1, 0},
59 };
60
61 TEST(gr16, bits16, 0xFFFF0000, 0xFFFF);
62
63 static const struct pl_plane_data r10x6g10 = {
64 .component_size = {10, 10},
65 .component_map = {1, 0}, // LSB -> MSB ordering
66 .component_pad = {0, 6},
67 };
68
69 TEST_ALIGN(r10x6g10, gr16, bits10_16, 0x03FF0000, 0x03FF);
70
71 static const struct pl_plane_data rgb565 = {
72 .component_size = {5, 6, 5},
73 .component_map = {2, 1, 0}, // LSB -> MSB ordering
74 };
75
76 TEST(rgb565, bits0, 0xF800, 0x07E0, 0x001F);
77
78 static const struct pl_plane_data rgba16 = {
79 .component_size = {16, 16, 16, 16},
80 .component_map = {0, 1, 2, 3},
81 };
82
83 TEST(rgba16, bits16, 0xFFFFllu, 0xFFFF0000llu, 0xFFFF00000000llu, 0xFFFF000000000000llu);
84
85 static const struct pl_plane_data p010 = {
86 .component_size = {10, 10, 10},
87 .component_map = {0, 1, 2},
88 .component_pad = {6, 6, 6},
89 };
90
91 static const struct pl_plane_data rgb16 = {
92 .component_size = {16, 16, 16},
93 .component_map = {0, 1, 2},
94 };
95
96 TEST_ALIGN(p010, rgb16, bits10_16_6, 0xFFC0llu, 0xFFC00000llu, 0xFFC000000000llu);
97
98 // Test GLSL structure packing
99 struct pl_var vec1 = pl_var_float(""),
100 vec2 = pl_var_vec2(""),
101 vec3 = pl_var_vec3(""),
102 mat2 = pl_var_mat2(""),
103 mat3 = pl_var_mat3("");
104
105 struct pl_var_layout layout;
106 layout = pl_std140_layout(0, &vec2);
107 REQUIRE(layout.offset == 0);
108 REQUIRE(layout.stride == 2 * sizeof(float));
109 REQUIRE(layout.size == 2 * sizeof(float));
110
111 layout = pl_std140_layout(3 * sizeof(float), &vec3);
112 REQUIRE(layout.offset == 4 * sizeof(float));
113 REQUIRE(layout.stride == 3 * sizeof(float));
114 REQUIRE(layout.size == 3 * sizeof(float));
115
116 layout = pl_std140_layout(2 * sizeof(float), &mat3);
117 REQUIRE(layout.offset == 4 * sizeof(float));
118 REQUIRE(layout.stride == 4 * sizeof(float));
119 REQUIRE(layout.size == 3 * 4 * sizeof(float));
120
121 layout = pl_std430_layout(2 * sizeof(float), &mat3);
122 REQUIRE(layout.offset == 4 * sizeof(float));
123 REQUIRE(layout.stride == 4 * sizeof(float));
124 REQUIRE(layout.size == 4 * 3 * sizeof(float));
125
126 layout = pl_std140_layout(3 * sizeof(float), &vec1);
127 REQUIRE(layout.offset == 3 * sizeof(float));
128 REQUIRE(layout.stride == sizeof(float));
129 REQUIRE(layout.size == sizeof(float));
130
131 struct pl_var vec2a = vec2;
132 vec2a.dim_a = 50;
133
134 layout = pl_std140_layout(sizeof(float), &vec2a);
135 REQUIRE(layout.offset == 4 * sizeof(float));
136 REQUIRE(layout.stride == 4 * sizeof(float));
137 REQUIRE(layout.size == 50 * 4 * sizeof(float));
138
139 layout = pl_std430_layout(sizeof(float), &vec2a);
140 REQUIRE(layout.offset == 2 * sizeof(float));
141 REQUIRE(layout.stride == 2 * sizeof(float));
142 REQUIRE(layout.size == 50 * 2 * sizeof(float));
143
144 struct pl_var mat2a = mat2;
145 mat2a.dim_a = 20;
146
147 layout = pl_std140_layout(5 * sizeof(float), &mat2a);
148 REQUIRE(layout.offset == 8 * sizeof(float));
149 REQUIRE(layout.stride == 4 * sizeof(float));
150 REQUIRE(layout.size == 20 * 2 * 4 * sizeof(float));
151
152 layout = pl_std430_layout(5 * sizeof(float), &mat2a);
153 REQUIRE(layout.offset == 6 * sizeof(float));
154 REQUIRE(layout.stride == 2 * sizeof(float));
155 REQUIRE(layout.size == 20 * 2 * 2 * sizeof(float));
156
157 for (const struct pl_named_var *nvar = pl_var_glsl_types; nvar->glsl_name; nvar++) {
158 struct pl_var var = nvar->var;
159 REQUIRE(nvar->glsl_name == pl_var_glsl_type_name(var));
160 var.dim_a = 100;
161 REQUIRE(nvar->glsl_name == pl_var_glsl_type_name(var));
162 }
163 }
164