SDL

1
/**
2
 * Pixels test suite
3
 */
4
#include <SDL3/SDL.h>
5
#include <SDL3/SDL_test.h>
6
#include "testautomation_suites.h"
7

8
/* Test case functions */
9

10
/* Definition of all RGB formats used to test pixel conversions */
11
static const SDL_PixelFormat g_AllFormats[] = {
12
    SDL_PIXELFORMAT_INDEX1LSB,
13
    SDL_PIXELFORMAT_INDEX1MSB,
14
    SDL_PIXELFORMAT_INDEX2LSB,
15
    SDL_PIXELFORMAT_INDEX2MSB,
16
    SDL_PIXELFORMAT_INDEX4LSB,
17
    SDL_PIXELFORMAT_INDEX4MSB,
18
    SDL_PIXELFORMAT_INDEX8,
19
    SDL_PIXELFORMAT_RGB332,
20
    SDL_PIXELFORMAT_XRGB4444,
21
    SDL_PIXELFORMAT_XBGR4444,
22
    SDL_PIXELFORMAT_XRGB1555,
23
    SDL_PIXELFORMAT_XBGR1555,
24
    SDL_PIXELFORMAT_ARGB4444,
25
    SDL_PIXELFORMAT_RGBA4444,
26
    SDL_PIXELFORMAT_ABGR4444,
27
    SDL_PIXELFORMAT_BGRA4444,
28
    SDL_PIXELFORMAT_ARGB1555,
29
    SDL_PIXELFORMAT_RGBA5551,
30
    SDL_PIXELFORMAT_ABGR1555,
31
    SDL_PIXELFORMAT_BGRA5551,
32
    SDL_PIXELFORMAT_RGB565,
33
    SDL_PIXELFORMAT_BGR565,
34
    SDL_PIXELFORMAT_RGB24,
35
    SDL_PIXELFORMAT_BGR24,
36
    SDL_PIXELFORMAT_XRGB8888,
37
    SDL_PIXELFORMAT_RGBX8888,
38
    SDL_PIXELFORMAT_XBGR8888,
39
    SDL_PIXELFORMAT_BGRX8888,
40
    SDL_PIXELFORMAT_ARGB8888,
41
    SDL_PIXELFORMAT_RGBA8888,
42
    SDL_PIXELFORMAT_ABGR8888,
43
    SDL_PIXELFORMAT_BGRA8888,
44
    SDL_PIXELFORMAT_XRGB2101010,
45
    SDL_PIXELFORMAT_XBGR2101010,
46
    SDL_PIXELFORMAT_ARGB2101010,
47
    SDL_PIXELFORMAT_ABGR2101010,
48
    SDL_PIXELFORMAT_YV12,
49
    SDL_PIXELFORMAT_IYUV,
50
    SDL_PIXELFORMAT_YUY2,
51
    SDL_PIXELFORMAT_UYVY,
52
    SDL_PIXELFORMAT_YVYU,
53
    SDL_PIXELFORMAT_NV12,
54
    SDL_PIXELFORMAT_NV21
55
};
56
static const int g_numAllFormats = SDL_arraysize(g_AllFormats);
57

58
static const char *g_AllFormatsVerbose[] = {
59
    "SDL_PIXELFORMAT_INDEX1LSB",
60
    "SDL_PIXELFORMAT_INDEX1MSB",
61
    "SDL_PIXELFORMAT_INDEX2LSB",
62
    "SDL_PIXELFORMAT_INDEX2MSB",
63
    "SDL_PIXELFORMAT_INDEX4LSB",
64
    "SDL_PIXELFORMAT_INDEX4MSB",
65
    "SDL_PIXELFORMAT_INDEX8",
66
    "SDL_PIXELFORMAT_RGB332",
67
    "SDL_PIXELFORMAT_XRGB4444",
68
    "SDL_PIXELFORMAT_XBGR4444",
69
    "SDL_PIXELFORMAT_XRGB1555",
70
    "SDL_PIXELFORMAT_XBGR1555",
71
    "SDL_PIXELFORMAT_ARGB4444",
72
    "SDL_PIXELFORMAT_RGBA4444",
73
    "SDL_PIXELFORMAT_ABGR4444",
74
    "SDL_PIXELFORMAT_BGRA4444",
75
    "SDL_PIXELFORMAT_ARGB1555",
76
    "SDL_PIXELFORMAT_RGBA5551",
77
    "SDL_PIXELFORMAT_ABGR1555",
78
    "SDL_PIXELFORMAT_BGRA5551",
79
    "SDL_PIXELFORMAT_RGB565",
80
    "SDL_PIXELFORMAT_BGR565",
81
    "SDL_PIXELFORMAT_RGB24",
82
    "SDL_PIXELFORMAT_BGR24",
83
    "SDL_PIXELFORMAT_XRGB8888",
84
    "SDL_PIXELFORMAT_RGBX8888",
85
    "SDL_PIXELFORMAT_XBGR8888",
86
    "SDL_PIXELFORMAT_BGRX8888",
87
    "SDL_PIXELFORMAT_ARGB8888",
88
    "SDL_PIXELFORMAT_RGBA8888",
89
    "SDL_PIXELFORMAT_ABGR8888",
90
    "SDL_PIXELFORMAT_BGRA8888",
91
    "SDL_PIXELFORMAT_XRGB2101010",
92
    "SDL_PIXELFORMAT_XBGR2101010",
93
    "SDL_PIXELFORMAT_ARGB2101010",
94
    "SDL_PIXELFORMAT_ABGR2101010",
95
    "SDL_PIXELFORMAT_YV12",
96
    "SDL_PIXELFORMAT_IYUV",
97
    "SDL_PIXELFORMAT_YUY2",
98
    "SDL_PIXELFORMAT_UYVY",
99
    "SDL_PIXELFORMAT_YVYU",
100
    "SDL_PIXELFORMAT_NV12",
101
    "SDL_PIXELFORMAT_NV21"
102
};
103

104
/* Definition of some invalid formats for negative tests */
105
static Uint32 g_invalidPixelFormats[] = {
106
    SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED32, SDL_PACKEDORDER_ABGR, SDL_PACKEDLAYOUT_1010102 + 1, 32, 4),
107
    SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED32, SDL_PACKEDORDER_ABGR, SDL_PACKEDLAYOUT_1010102 + 2, 32, 4)
108
};
109
static const int g_numInvalidPixelFormats = SDL_arraysize(g_invalidPixelFormats);
110
static const char *g_invalidPixelFormatsVerbose[] = {
111
    "SDL_PIXELFORMAT_UNKNOWN",
112
    "SDL_PIXELFORMAT_UNKNOWN"
113
};
114

115
/* Verify the pixel formats are laid out as expected */
116
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_INDEX1LSB_FORMAT, SDL_PIXELFORMAT_INDEX1LSB == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_INDEX1, SDL_BITMAPORDER_4321, 0, 1, 0));
117
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_INDEX1MSB_FORMAT, SDL_PIXELFORMAT_INDEX1MSB == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_INDEX1, SDL_BITMAPORDER_1234, 0, 1, 0));
118
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_INDEX2LSB_FORMAT, SDL_PIXELFORMAT_INDEX2LSB == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_INDEX2, SDL_BITMAPORDER_4321, 0, 2, 0));
119
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_INDEX2MSB_FORMAT, SDL_PIXELFORMAT_INDEX2MSB == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_INDEX2, SDL_BITMAPORDER_1234, 0, 2, 0));
120
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_INDEX4LSB_FORMAT, SDL_PIXELFORMAT_INDEX4LSB == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_INDEX4, SDL_BITMAPORDER_4321, 0, 4, 0));
121
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_INDEX4MSB_FORMAT, SDL_PIXELFORMAT_INDEX4MSB == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_INDEX4, SDL_BITMAPORDER_1234, 0, 4, 0));
122
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_INDEX8_FORMAT, SDL_PIXELFORMAT_INDEX8 == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_INDEX8, 0, 0, 8, 1));
123
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGB332_FORMAT, SDL_PIXELFORMAT_RGB332 == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED8, SDL_PACKEDORDER_XRGB, SDL_PACKEDLAYOUT_332, 8, 1));
124
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_XRGB4444_FORMAT, SDL_PIXELFORMAT_XRGB4444 == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED16, SDL_PACKEDORDER_XRGB, SDL_PACKEDLAYOUT_4444, 12, 2));
125
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_XBGR4444_FORMAT, SDL_PIXELFORMAT_XBGR4444 == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED16, SDL_PACKEDORDER_XBGR, SDL_PACKEDLAYOUT_4444, 12, 2));
126
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_XRGB1555_FORMAT, SDL_PIXELFORMAT_XRGB1555 == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED16, SDL_PACKEDORDER_XRGB, SDL_PACKEDLAYOUT_1555, 15, 2));
127
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_XBGR1555_FORMAT, SDL_PIXELFORMAT_XBGR1555 == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED16, SDL_PACKEDORDER_XBGR, SDL_PACKEDLAYOUT_1555, 15, 2));
128
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ARGB4444_FORMAT, SDL_PIXELFORMAT_ARGB4444 == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED16, SDL_PACKEDORDER_ARGB, SDL_PACKEDLAYOUT_4444, 16, 2));
129
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGBA4444_FORMAT, SDL_PIXELFORMAT_RGBA4444 == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED16, SDL_PACKEDORDER_RGBA, SDL_PACKEDLAYOUT_4444, 16, 2));
130
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ABGR4444_FORMAT, SDL_PIXELFORMAT_ABGR4444 == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED16, SDL_PACKEDORDER_ABGR, SDL_PACKEDLAYOUT_4444, 16, 2));
131
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGRA4444_FORMAT, SDL_PIXELFORMAT_BGRA4444 == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED16, SDL_PACKEDORDER_BGRA, SDL_PACKEDLAYOUT_4444, 16, 2));
132
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ARGB1555_FORMAT, SDL_PIXELFORMAT_ARGB1555 == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED16, SDL_PACKEDORDER_ARGB, SDL_PACKEDLAYOUT_1555, 16, 2));
133
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGBA5551_FORMAT, SDL_PIXELFORMAT_RGBA5551 == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED16, SDL_PACKEDORDER_RGBA, SDL_PACKEDLAYOUT_5551, 16, 2));
134
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ABGR1555_FORMAT, SDL_PIXELFORMAT_ABGR1555 == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED16, SDL_PACKEDORDER_ABGR, SDL_PACKEDLAYOUT_1555, 16, 2));
135
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGRA5551_FORMAT, SDL_PIXELFORMAT_BGRA5551 == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED16, SDL_PACKEDORDER_BGRA, SDL_PACKEDLAYOUT_5551, 16, 2));
136
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGB565_FORMAT, SDL_PIXELFORMAT_RGB565 == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED16, SDL_PACKEDORDER_XRGB, SDL_PACKEDLAYOUT_565, 16, 2));
137
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGR565_FORMAT, SDL_PIXELFORMAT_BGR565 == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED16, SDL_PACKEDORDER_XBGR, SDL_PACKEDLAYOUT_565, 16, 2));
138
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGB24_FORMAT, SDL_PIXELFORMAT_RGB24 == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_ARRAYU8, SDL_ARRAYORDER_RGB, 0, 24, 3));
139
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGR24_FORMAT, SDL_PIXELFORMAT_BGR24 == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_ARRAYU8, SDL_ARRAYORDER_BGR, 0, 24, 3));
140
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_XRGB8888_FORMAT, SDL_PIXELFORMAT_XRGB8888 == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED32, SDL_PACKEDORDER_XRGB, SDL_PACKEDLAYOUT_8888, 24, 4));
141
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGBX8888_FORMAT, SDL_PIXELFORMAT_RGBX8888 == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED32, SDL_PACKEDORDER_RGBX, SDL_PACKEDLAYOUT_8888, 24, 4));
142
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_XBGR8888_FORMAT, SDL_PIXELFORMAT_XBGR8888 == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED32, SDL_PACKEDORDER_XBGR, SDL_PACKEDLAYOUT_8888, 24, 4));
143
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGRX8888_FORMAT, SDL_PIXELFORMAT_BGRX8888 == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED32, SDL_PACKEDORDER_BGRX, SDL_PACKEDLAYOUT_8888, 24, 4));
144
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ARGB8888_FORMAT, SDL_PIXELFORMAT_ARGB8888 == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED32, SDL_PACKEDORDER_ARGB, SDL_PACKEDLAYOUT_8888, 32, 4));
145
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGBA8888_FORMAT, SDL_PIXELFORMAT_RGBA8888 == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED32, SDL_PACKEDORDER_RGBA, SDL_PACKEDLAYOUT_8888, 32, 4));
146
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ABGR8888_FORMAT, SDL_PIXELFORMAT_ABGR8888 == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED32, SDL_PACKEDORDER_ABGR, SDL_PACKEDLAYOUT_8888, 32, 4));
147
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGRA8888_FORMAT, SDL_PIXELFORMAT_BGRA8888 == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED32, SDL_PACKEDORDER_BGRA, SDL_PACKEDLAYOUT_8888, 32, 4));
148
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_XRGB2101010_FORMAT, SDL_PIXELFORMAT_XRGB2101010 == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED32, SDL_PACKEDORDER_XRGB, SDL_PACKEDLAYOUT_2101010, 32, 4));
149
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_XBGR2101010_FORMAT, SDL_PIXELFORMAT_XBGR2101010 == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED32, SDL_PACKEDORDER_XBGR, SDL_PACKEDLAYOUT_2101010, 32, 4));
150
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ARGB2101010_FORMAT, SDL_PIXELFORMAT_ARGB2101010 == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED32, SDL_PACKEDORDER_ARGB, SDL_PACKEDLAYOUT_2101010, 32, 4));
151
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ABGR2101010_FORMAT, SDL_PIXELFORMAT_ABGR2101010 == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED32, SDL_PACKEDORDER_ABGR, SDL_PACKEDLAYOUT_2101010, 32, 4));
152
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGB48_FORMAT, SDL_PIXELFORMAT_RGB48 == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_ARRAYU16, SDL_ARRAYORDER_RGB, 0, 48, 6));
153
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGR48_FORMAT, SDL_PIXELFORMAT_BGR48 == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_ARRAYU16, SDL_ARRAYORDER_BGR, 0, 48, 6));
154
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGBA64_FORMAT, SDL_PIXELFORMAT_RGBA64 == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_ARRAYU16, SDL_ARRAYORDER_RGBA, 0, 64, 8));
155
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ARGB64_FORMAT, SDL_PIXELFORMAT_ARGB64 == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_ARRAYU16, SDL_ARRAYORDER_ARGB, 0, 64, 8));
156
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGRA64_FORMAT, SDL_PIXELFORMAT_BGRA64 == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_ARRAYU16, SDL_ARRAYORDER_BGRA, 0, 64, 8));
157
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ABGR64_FORMAT, SDL_PIXELFORMAT_ABGR64 == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_ARRAYU16, SDL_ARRAYORDER_ABGR, 0, 64, 8));
158
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGB48_FLOAT_FORMAT, SDL_PIXELFORMAT_RGB48_FLOAT == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_ARRAYF16, SDL_ARRAYORDER_RGB, 0, 48, 6));
159
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGR48_FLOAT_FORMAT, SDL_PIXELFORMAT_BGR48_FLOAT == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_ARRAYF16, SDL_ARRAYORDER_BGR, 0, 48, 6));
160
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGBA64_FLOAT_FORMAT, SDL_PIXELFORMAT_RGBA64_FLOAT == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_ARRAYF16, SDL_ARRAYORDER_RGBA, 0, 64, 8));
161
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ARGB64_FLOAT_FORMAT, SDL_PIXELFORMAT_ARGB64_FLOAT == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_ARRAYF16, SDL_ARRAYORDER_ARGB, 0, 64, 8));
162
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGRA64_FLOAT_FORMAT, SDL_PIXELFORMAT_BGRA64_FLOAT == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_ARRAYF16, SDL_ARRAYORDER_BGRA, 0, 64, 8));
163
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ABGR64_FLOAT_FORMAT, SDL_PIXELFORMAT_ABGR64_FLOAT == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_ARRAYF16, SDL_ARRAYORDER_ABGR, 0, 64, 8));
164
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGB96_FLOAT_FORMAT, SDL_PIXELFORMAT_RGB96_FLOAT == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_ARRAYF32, SDL_ARRAYORDER_RGB, 0, 96, 12));
165
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGR96_FLOAT_FORMAT, SDL_PIXELFORMAT_BGR96_FLOAT == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_ARRAYF32, SDL_ARRAYORDER_BGR, 0, 96, 12));
166
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGBA128_FLOAT_FORMAT, SDL_PIXELFORMAT_RGBA128_FLOAT == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_ARRAYF32, SDL_ARRAYORDER_RGBA, 0, 128, 16));
167
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ARGB128_FLOAT_FORMAT, SDL_PIXELFORMAT_ARGB128_FLOAT == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_ARRAYF32, SDL_ARRAYORDER_ARGB, 0, 128, 16));
168
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGRA128_FLOAT_FORMAT, SDL_PIXELFORMAT_BGRA128_FLOAT == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_ARRAYF32, SDL_ARRAYORDER_BGRA, 0, 128, 16));
169
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ABGR128_FLOAT_FORMAT, SDL_PIXELFORMAT_ABGR128_FLOAT == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_ARRAYF32, SDL_ARRAYORDER_ABGR, 0, 128, 16));
170
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_YV12_FORMAT, SDL_PIXELFORMAT_YV12 == SDL_DEFINE_PIXELFOURCC('Y', 'V', '1', '2'));
171
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_IYUV_FORMAT, SDL_PIXELFORMAT_IYUV == SDL_DEFINE_PIXELFOURCC('I', 'Y', 'U', 'V'));
172
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_YUY2_FORMAT, SDL_PIXELFORMAT_YUY2 == SDL_DEFINE_PIXELFOURCC('Y', 'U', 'Y', '2'));
173
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_UYVY_FORMAT, SDL_PIXELFORMAT_UYVY == SDL_DEFINE_PIXELFOURCC('U', 'Y', 'V', 'Y'));
174
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_YVYU_FORMAT, SDL_PIXELFORMAT_YVYU == SDL_DEFINE_PIXELFOURCC('Y', 'V', 'Y', 'U'));
175
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_NV12_FORMAT, SDL_PIXELFORMAT_NV12 == SDL_DEFINE_PIXELFOURCC('N', 'V', '1', '2'));
176
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_NV21_FORMAT, SDL_PIXELFORMAT_NV21 == SDL_DEFINE_PIXELFOURCC('N', 'V', '2', '1'));
177
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_P010_FORMAT, SDL_PIXELFORMAT_P010 == SDL_DEFINE_PIXELFOURCC('P', '0', '1', '0'));
178
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_EXTERNAL_OES_FORMAT, SDL_PIXELFORMAT_EXTERNAL_OES == SDL_DEFINE_PIXELFOURCC('O', 'E', 'S', ' '));
179

180
/* Verify the colorspaces are laid out as expected */
181
SDL_COMPILE_TIME_ASSERT(SDL_COLORSPACE_SRGB_FORMAT, SDL_COLORSPACE_SRGB ==
182
        SDL_DEFINE_COLORSPACE(SDL_COLOR_TYPE_RGB,
183
                                 SDL_COLOR_RANGE_FULL,
184
                                 SDL_COLOR_PRIMARIES_BT709,
185
                                 SDL_TRANSFER_CHARACTERISTICS_SRGB,
186
                                 SDL_MATRIX_COEFFICIENTS_IDENTITY,
187
                                 SDL_CHROMA_LOCATION_NONE));
188
SDL_COMPILE_TIME_ASSERT(SDL_COLORSPACE_SRGB_LINEAR_FORMAT, SDL_COLORSPACE_SRGB_LINEAR ==
189
        SDL_DEFINE_COLORSPACE(SDL_COLOR_TYPE_RGB,
190
                                 SDL_COLOR_RANGE_FULL,
191
                                 SDL_COLOR_PRIMARIES_BT709,
192
                                 SDL_TRANSFER_CHARACTERISTICS_LINEAR,
193
                                 SDL_MATRIX_COEFFICIENTS_IDENTITY,
194
                                 SDL_CHROMA_LOCATION_NONE));
195

196
SDL_COMPILE_TIME_ASSERT(SDL_COLORSPACE_HDR10_FORMAT, SDL_COLORSPACE_HDR10 ==
197
        SDL_DEFINE_COLORSPACE(SDL_COLOR_TYPE_RGB,
198
                                 SDL_COLOR_RANGE_FULL,
199
                                 SDL_COLOR_PRIMARIES_BT2020,
200
                                 SDL_TRANSFER_CHARACTERISTICS_PQ,
201
                                 SDL_MATRIX_COEFFICIENTS_IDENTITY,
202
                                 SDL_CHROMA_LOCATION_NONE));
203

204
SDL_COMPILE_TIME_ASSERT(SDL_COLORSPACE_JPEG_FORMAT, SDL_COLORSPACE_JPEG ==
205
        SDL_DEFINE_COLORSPACE(SDL_COLOR_TYPE_YCBCR,
206
                                 SDL_COLOR_RANGE_FULL,
207
                                 SDL_COLOR_PRIMARIES_BT709,
208
                                 SDL_TRANSFER_CHARACTERISTICS_BT601,
209
                                 SDL_MATRIX_COEFFICIENTS_BT601,
210
                                 SDL_CHROMA_LOCATION_NONE));
211

212
SDL_COMPILE_TIME_ASSERT(SDL_COLORSPACE_BT601_LIMITED_FORMAT, SDL_COLORSPACE_BT601_LIMITED ==
213
        SDL_DEFINE_COLORSPACE(SDL_COLOR_TYPE_YCBCR,
214
                                 SDL_COLOR_RANGE_LIMITED,
215
                                 SDL_COLOR_PRIMARIES_BT601,
216
                                 SDL_TRANSFER_CHARACTERISTICS_BT601,
217
                                 SDL_MATRIX_COEFFICIENTS_BT601,
218
                                 SDL_CHROMA_LOCATION_LEFT));
219

220
SDL_COMPILE_TIME_ASSERT(SDL_COLORSPACE_BT601_FULL_FORMAT, SDL_COLORSPACE_BT601_FULL ==
221
        SDL_DEFINE_COLORSPACE(SDL_COLOR_TYPE_YCBCR,
222
                                 SDL_COLOR_RANGE_FULL,
223
                                 SDL_COLOR_PRIMARIES_BT601,
224
                                 SDL_TRANSFER_CHARACTERISTICS_BT601,
225
                                 SDL_MATRIX_COEFFICIENTS_BT601,
226
                                 SDL_CHROMA_LOCATION_LEFT));
227

228
SDL_COMPILE_TIME_ASSERT(SDL_COLORSPACE_BT709_LIMITED_FORMAT, SDL_COLORSPACE_BT709_LIMITED ==
229
        SDL_DEFINE_COLORSPACE(SDL_COLOR_TYPE_YCBCR,
230
                                 SDL_COLOR_RANGE_LIMITED,
231
                                 SDL_COLOR_PRIMARIES_BT709,
232
                                 SDL_TRANSFER_CHARACTERISTICS_BT709,
233
                                 SDL_MATRIX_COEFFICIENTS_BT709,
234
                                 SDL_CHROMA_LOCATION_LEFT));
235

236
SDL_COMPILE_TIME_ASSERT(SDL_COLORSPACE_BT709_FULL_FORMAT, SDL_COLORSPACE_BT709_FULL ==
237
        SDL_DEFINE_COLORSPACE(SDL_COLOR_TYPE_YCBCR,
238
                                 SDL_COLOR_RANGE_FULL,
239
                                 SDL_COLOR_PRIMARIES_BT709,
240
                                 SDL_TRANSFER_CHARACTERISTICS_BT709,
241
                                 SDL_MATRIX_COEFFICIENTS_BT709,
242
                                 SDL_CHROMA_LOCATION_LEFT));
243

244
SDL_COMPILE_TIME_ASSERT(SDL_COLORSPACE_BT2020_LIMITED_FORMAT, SDL_COLORSPACE_BT2020_LIMITED ==
245
        SDL_DEFINE_COLORSPACE(SDL_COLOR_TYPE_YCBCR,
246
                                 SDL_COLOR_RANGE_LIMITED,
247
                                 SDL_COLOR_PRIMARIES_BT2020,
248
                                 SDL_TRANSFER_CHARACTERISTICS_PQ,
249
                                 SDL_MATRIX_COEFFICIENTS_BT2020_NCL,
250
                                 SDL_CHROMA_LOCATION_LEFT));
251

252
SDL_COMPILE_TIME_ASSERT(SDL_COLORSPACE_BT2020_FULL_FORMAT, SDL_COLORSPACE_BT2020_FULL ==
253
        SDL_DEFINE_COLORSPACE(SDL_COLOR_TYPE_YCBCR,
254
                                 SDL_COLOR_RANGE_FULL,
255
                                 SDL_COLOR_PRIMARIES_BT2020,
256
                                 SDL_TRANSFER_CHARACTERISTICS_PQ,
257
                                 SDL_MATRIX_COEFFICIENTS_BT2020_NCL,
258
                                 SDL_CHROMA_LOCATION_LEFT));
259
/* Test case functions */
260

261
/**
262
 * Call to SDL_GetPixelFormatDetails
263
 */
264
static int pixels_getPixelFormatDetails(void *arg)
265
{
266
    const char *unknownFormat = "SDL_PIXELFORMAT_UNKNOWN";
267
    const char *expectedError = "Unknown pixel format";
268
    const char *error;
269
    int i;
270
    SDL_PixelFormat format;
271
    Uint32 masks;
272
    const SDL_PixelFormatDetails *result;
273

274
    /* Blank/unknown format */
275
    format = SDL_PIXELFORMAT_UNKNOWN;
276
    SDLTest_Log("Pixel Format: %s (%d)", unknownFormat, format);
277

278
    /* Allocate format */
279
    result = SDL_GetPixelFormatDetails(format);
280
    SDLTest_AssertPass("Call to SDL_GetPixelFormatDetails()");
281
    SDLTest_AssertCheck(result != NULL, "Verify result is not NULL");
282
    if (result != NULL) {
283
        SDLTest_AssertCheck(result->format == format, "Verify value of result.format; expected: %d, got %d", format, result->format);
284
        SDLTest_AssertCheck(result->bits_per_pixel == 0,
285
                            "Verify value of result.bits_per_pixel; expected: 0, got %u",
286
                            result->bits_per_pixel);
287
        SDLTest_AssertCheck(result->bytes_per_pixel == 0,
288
                            "Verify value of result.bytes_per_pixel; expected: 0, got %u",
289
                            result->bytes_per_pixel);
290
        masks = result->Rmask | result->Gmask | result->Bmask | result->Amask;
291
        SDLTest_AssertCheck(masks == 0, "Verify value of result.[RGBA]mask combined; expected: 0, got %" SDL_PRIu32, masks);
292
    }
293

294
    /* RGB formats */
295
    for (i = 0; i < g_numAllFormats; i++) {
296
        format = g_AllFormats[i];
297
        SDLTest_Log("Pixel Format: %s (%d)", g_AllFormatsVerbose[i], format);
298

299
        /* Allocate format */
300
        result = SDL_GetPixelFormatDetails(format);
301
        SDLTest_AssertPass("Call to SDL_GetPixelFormatDetails()");
302
        SDLTest_AssertCheck(result != NULL, "Verify result is not NULL");
303
        if (result != NULL) {
304
            SDLTest_AssertCheck(result->format == format, "Verify value of result.format; expected: %d, got %d", format, result->format);
305
            if (!SDL_ISPIXELFORMAT_FOURCC(format)) {
306
                SDLTest_AssertCheck(result->bits_per_pixel > 0,
307
                                    "Verify value of result.bits_per_pixel; expected: >0, got %u",
308
                                    result->bits_per_pixel);
309
                SDLTest_AssertCheck(result->bytes_per_pixel > 0,
310
                                    "Verify value of result.bytes_per_pixel; expected: >0, got %u",
311
                                    result->bytes_per_pixel);
312
                if (!SDL_ISPIXELFORMAT_INDEXED(format)) {
313
                    masks = result->Rmask | result->Gmask | result->Bmask | result->Amask;
314
                    SDLTest_AssertCheck(masks > 0, "Verify value of result.[RGBA]mask combined; expected: >0, got %" SDL_PRIu32, masks);
315
                    if (SDL_ISPIXELFORMAT_10BIT(format)) {
316
                        SDLTest_AssertCheck(result->Rbits == 10 && result->Gbits == 10 && result->Bbits == 10, "Verify value of result.[RGB]bits; expected: 10, got %d/%d/%d", result->Rbits, result->Gbits, result->Bbits);
317
                    } else if (SDL_BITSPERPIXEL(format) == 32) {
318
                        SDLTest_AssertCheck(result->Rbits == 8 && result->Gbits == 8 && result->Bbits == 8, "Verify value of result.[RGB]bits; expected: 8, got %d/%d/%d", result->Rbits, result->Gbits, result->Bbits);
319
                    }
320
                }
321
            }
322
        }
323
    }
324

325
    /* Negative cases */
326

327
    /* Invalid Formats */
328
    for (i = 0; i < g_numInvalidPixelFormats; i++) {
329
        SDL_ClearError();
330
        SDLTest_AssertPass("Call to SDL_ClearError()");
331
        format = g_invalidPixelFormats[i];
332
        result = SDL_GetPixelFormatDetails(format);
333
        SDLTest_AssertPass("Call to SDL_GetPixelFormatDetails(%d)", format);
334
        SDLTest_AssertCheck(result == NULL, "Verify result is NULL");
335
        error = SDL_GetError();
336
        SDLTest_AssertPass("Call to SDL_GetError()");
337
        SDLTest_AssertCheck(error != NULL, "Validate that error message was not NULL");
338
        if (error != NULL) {
339
            SDLTest_AssertCheck(SDL_strcmp(error, expectedError) == 0,
340
                                "Validate error message, expected: '%s', got: '%s'", expectedError, error);
341
        }
342
    }
343

344
    return TEST_COMPLETED;
345
}
346

347
/**
348
 * Call to SDL_GetPixelFormatName
349
 *
350
 * \sa SDL_GetPixelFormatName
351
 */
352
static int pixels_getPixelFormatName(void *arg)
353
{
354
    const char *unknownFormat = "SDL_PIXELFORMAT_UNKNOWN";
355
    const char *error;
356
    int i;
357
    SDL_PixelFormat format;
358
    const char *result;
359

360
    /* Blank/undefined format */
361
    format = SDL_PIXELFORMAT_UNKNOWN;
362
    SDLTest_Log("RGB Format: %s (%d)", unknownFormat, format);
363

364
    /* Get name of format */
365
    result = SDL_GetPixelFormatName(format);
366
    SDLTest_AssertPass("Call to SDL_GetPixelFormatName()");
367
    SDLTest_AssertCheck(result != NULL, "Verify result is not NULL");
368
    if (result != NULL) {
369
        SDLTest_AssertCheck(result[0] != '\0', "Verify result is non-empty");
370
        SDLTest_AssertCheck(SDL_strcmp(result, unknownFormat) == 0,
371
                            "Verify result text; expected: %s, got %s", unknownFormat, result);
372
    }
373

374
    /* RGB formats */
375
    for (i = 0; i < g_numAllFormats; i++) {
376
        format = g_AllFormats[i];
377
        SDLTest_Log("RGB Format: %s (%d)", g_AllFormatsVerbose[i], format);
378

379
        /* Get name of format */
380
        result = SDL_GetPixelFormatName(format);
381
        SDLTest_AssertPass("Call to SDL_GetPixelFormatName()");
382
        SDLTest_AssertCheck(result != NULL, "Verify result is not NULL");
383
        if (result != NULL) {
384
            SDLTest_AssertCheck(result[0] != '\0', "Verify result is non-empty");
385
            SDLTest_AssertCheck(SDL_strcmp(result, g_AllFormatsVerbose[i]) == 0,
386
                                "Verify result text; expected: %s, got %s", g_AllFormatsVerbose[i], result);
387
        }
388
    }
389

390
    /* Negative cases */
391

392
    /* Invalid Formats */
393
    SDL_ClearError();
394
    SDLTest_AssertPass("Call to SDL_ClearError()");
395
    for (i = 0; i < g_numInvalidPixelFormats; i++) {
396
        format = g_invalidPixelFormats[i];
397
        result = SDL_GetPixelFormatName(format);
398
        SDLTest_AssertPass("Call to SDL_GetPixelFormatName(%d)", format);
399
        SDLTest_AssertCheck(result != NULL, "Verify result is not NULL");
400
        if (result != NULL) {
401
            SDLTest_AssertCheck(result[0] != '\0',
402
                                "Verify result is non-empty; got: %s", result);
403
            SDLTest_AssertCheck(SDL_strcmp(result, g_invalidPixelFormatsVerbose[i]) == 0,
404
                                "Validate name is UNKNOWN, expected: '%s', got: '%s'", g_invalidPixelFormatsVerbose[i], result);
405
        }
406
        error = SDL_GetError();
407
        SDLTest_AssertPass("Call to SDL_GetError()");
408
        SDLTest_AssertCheck(error == NULL || error[0] == '\0', "Validate that error message is empty");
409
    }
410

411
    return TEST_COMPLETED;
412
}
413

414
/**
415
 * Call to SDL_CreatePalette and SDL_DestroyPalette
416
 *
417
 * \sa SDL_CreatePalette
418
 * \sa SDL_DestroyPalette
419
 */
420
static int pixels_allocFreePalette(void *arg)
421
{
422
    const char *expectedError = "Parameter 'ncolors' is invalid";
423
    const char *error;
424
    int variation;
425
    int i;
426
    int ncolors;
427
    SDL_Palette *result;
428

429
    /* Allocate palette */
430
    for (variation = 1; variation <= 3; variation++) {
431
        switch (variation) {
432
        /* Just one color */
433
        default:
434
        case 1:
435
            ncolors = 1;
436
            break;
437
        /* Two colors */
438
        case 2:
439
            ncolors = 2;
440
            break;
441
        /* More than two colors */
442
        case 3:
443
            ncolors = SDLTest_RandomIntegerInRange(8, 16);
444
            break;
445
        }
446

447
        result = SDL_CreatePalette(ncolors);
448
        SDLTest_AssertPass("Call to SDL_CreatePalette(%d)", ncolors);
449
        SDLTest_AssertCheck(result != NULL, "Verify result is not NULL");
450
        if (result != NULL) {
451
            SDLTest_AssertCheck(result->ncolors == ncolors, "Verify value of result.ncolors; expected: %u, got %u", ncolors, result->ncolors);
452
            if (result->ncolors > 0) {
453
                SDLTest_AssertCheck(result->colors != NULL, "Verify value of result.colors is not NULL");
454
                if (result->colors != NULL) {
455
                    for (i = 0; i < result->ncolors; i++) {
456
                        SDLTest_AssertCheck(result->colors[i].r == 255, "Verify value of result.colors[%d].r; expected: 255, got %u", i, result->colors[i].r);
457
                        SDLTest_AssertCheck(result->colors[i].g == 255, "Verify value of result.colors[%d].g; expected: 255, got %u", i, result->colors[i].g);
458
                        SDLTest_AssertCheck(result->colors[i].b == 255, "Verify value of result.colors[%d].b; expected: 255, got %u", i, result->colors[i].b);
459
                    }
460
                }
461
            }
462

463
            /* Deallocate again */
464
            SDL_DestroyPalette(result);
465
            SDLTest_AssertPass("Call to SDL_DestroyPalette()");
466
        }
467
    }
468

469
    /* Negative cases */
470

471
    /* Invalid number of colors */
472
    for (ncolors = 0; ncolors > -3; ncolors--) {
473
        SDL_ClearError();
474
        SDLTest_AssertPass("Call to SDL_ClearError()");
475
        result = SDL_CreatePalette(ncolors);
476
        SDLTest_AssertPass("Call to SDL_CreatePalette(%d)", ncolors);
477
        SDLTest_AssertCheck(result == NULL, "Verify result is NULL");
478
        error = SDL_GetError();
479
        SDLTest_AssertPass("Call to SDL_GetError()");
480
        SDLTest_AssertCheck(error != NULL, "Validate that error message was not NULL");
481
        if (error != NULL) {
482
            SDLTest_AssertCheck(SDL_strcmp(error, expectedError) == 0,
483
                                "Validate error message, expected: '%s', got: '%s'", expectedError, error);
484
        }
485
    }
486

487
    /* Invalid free pointer */
488
    SDL_ClearError();
489
    SDLTest_AssertPass("Call to SDL_ClearError()");
490
    SDL_DestroyPalette(NULL);
491
    SDLTest_AssertPass("Call to SDL_DestroyPalette(NULL)");
492
    error = SDL_GetError();
493
    SDLTest_AssertPass("Call to SDL_GetError()");
494
    SDLTest_AssertCheck(error == NULL || error[0] == '\0', "Validate that error message is empty");
495

496
    return TEST_COMPLETED;
497
}
498

499
/* ================= Test References ================== */
500

501
/* Pixels test cases */
502
static const SDLTest_TestCaseReference pixelsTest1 = {
503
    (SDLTest_TestCaseFp)pixels_getPixelFormatDetails, "pixels_allocFreeFormat", "Call to SDL_GetPixelFormatDetails", TEST_ENABLED
504
};
505

506
static const SDLTest_TestCaseReference pixelsTest2 = {
507
    (SDLTest_TestCaseFp)pixels_allocFreePalette, "pixels_allocFreePalette", "Call to SDL_CreatePalette and SDL_DestroyPalette", TEST_ENABLED
508
};
509

510
static const SDLTest_TestCaseReference pixelsTest3 = {
511
    (SDLTest_TestCaseFp)pixels_getPixelFormatName, "pixels_getPixelFormatName", "Call to SDL_GetPixelFormatName", TEST_ENABLED
512
};
513

514
/* Sequence of Pixels test cases */
515
static const SDLTest_TestCaseReference *pixelsTests[] = {
516
    &pixelsTest1, &pixelsTest2, &pixelsTest3, NULL
517
};
518

519
/* Pixels test suite (global) */
520
SDLTest_TestSuiteReference pixelsTestSuite = {
521
    "Pixels",
522
    NULL,
523
    pixelsTests,
524
    NULL
525
};
526