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