1 /*-------------------------------------------------------------------------
2 * drawElements Internal Test Module
3 * ---------------------------------
4 *
5 * Copyright 2015 The Android Open Source Project
6 *
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
18 *
19 *//*!
20 * \file
21 * \brief Texture format tests.
22 *//*--------------------------------------------------------------------*/
23
24 #include "ditTextureFormatTests.hpp"
25 #include "tcuTestLog.hpp"
26
27 #include "rrRenderer.hpp"
28 #include "tcuTextureUtil.hpp"
29 #include "tcuVectorUtil.hpp"
30 #include "tcuFormatUtil.hpp"
31
32 #include "deRandom.hpp"
33 #include "deArrayUtil.hpp"
34 #include "deStringUtil.hpp"
35 #include "deUniquePtr.hpp"
36
37 #include <sstream>
38
39 namespace dit
40 {
41
42 namespace
43 {
44
45 using std::string;
46 using std::vector;
47
48 using tcu::TestLog;
49 using tcu::TextureFormat;
50 using tcu::TextureChannelClass;
51 using tcu::TextureAccessType;
52 using tcu::PixelBufferAccess;
53 using tcu::ConstPixelBufferAccess;
54 using tcu::Vector;
55 using tcu::IVec3;
56
57 // Test data
58
59 static const deUint8 s_snormInt8In[] =
60 {
61 0x1b, 0x23, 0xc5, 0x09,
62 0xb4, 0xbf, 0xbf, 0x24,
63 0x1a, 0x8a, 0xdb, 0x96,
64 0xc0, 0xa1, 0xde, 0x78,
65 };
66 static const deUint32 s_snormInt8FloatRef[] =
67 {
68 0x3e59b367, 0x3e8d1a34, 0xbeeddbb7, 0x3d912245,
69 0xbf193265, 0xbf03060c, 0xbf03060c, 0x3e912245,
70 0x3e51a347, 0xbf6ddbb7, 0xbe952a55, 0xbf55ab57,
71 0xbf010204, 0xbf3f7efe, 0xbe891224, 0x3f71e3c8,
72 };
73 static const deUint32 s_snormInt8UintRef[] =
74 {
75 0x0000001b, 0x00000023, 0xffffffc5, 0x00000009,
76 0xffffffb4, 0xffffffbf, 0xffffffbf, 0x00000024,
77 0x0000001a, 0xffffff8a, 0xffffffdb, 0xffffff96,
78 0xffffffc0, 0xffffffa1, 0xffffffde, 0x00000078,
79 };
80 static const deUint32 s_snormInt8IntRef[] =
81 {
82 0x0000001b, 0x00000023, 0xffffffc5, 0x00000009,
83 0xffffffb4, 0xffffffbf, 0xffffffbf, 0x00000024,
84 0x0000001a, 0xffffff8a, 0xffffffdb, 0xffffff96,
85 0xffffffc0, 0xffffffa1, 0xffffffde, 0x00000078,
86 };
87
88 static const deUint8 s_snormInt16In[] =
89 {
90 0xa0, 0xe9, 0xaa, 0x30,
91 0x16, 0x61, 0x37, 0xa2,
92 0x23, 0x4c, 0x46, 0xac,
93 0x8b, 0xf9, 0x36, 0x3e,
94 0x92, 0x7c, 0x96, 0x81,
95 0xc5, 0xb2, 0x95, 0x6e,
96 0x4f, 0x1e, 0xbc, 0x49,
97 0x14, 0x6c, 0x3c, 0x61,
98 };
99 static const deUint32 s_snormInt16FloatRef[] =
100 {
101 0xbe330166, 0x3ec2a985, 0x3f422d84, 0xbf3b9377,
102 0x3f184731, 0xbf27754f, 0xbd4ea19d, 0x3ef8d9f2,
103 0x3f7925f2, 0xbf7cd5fa, 0xbf1a7735, 0x3f5d2bba,
104 0x3e7279e5, 0x3f137927, 0x3f5829b0, 0x3f427985,
105 };
106 static const deUint32 s_snormInt16UintRef[] =
107 {
108 0xffffe9a0, 0x000030aa, 0x00006116, 0xffffa237,
109 0x00004c23, 0xffffac46, 0xfffff98b, 0x00003e36,
110 0x00007c92, 0xffff8196, 0xffffb2c5, 0x00006e95,
111 0x00001e4f, 0x000049bc, 0x00006c14, 0x0000613c,
112 };
113 static const deUint32 s_snormInt16IntRef[] =
114 {
115 0xffffe9a0, 0x000030aa, 0x00006116, 0xffffa237,
116 0x00004c23, 0xffffac46, 0xfffff98b, 0x00003e36,
117 0x00007c92, 0xffff8196, 0xffffb2c5, 0x00006e95,
118 0x00001e4f, 0x000049bc, 0x00006c14, 0x0000613c,
119 };
120
121 static const deUint8 s_snormInt32In[] =
122 {
123 0xba, 0x2c, 0x02, 0xea,
124 0x75, 0x59, 0x74, 0x48,
125 0x32, 0xad, 0xb0, 0xda,
126 0x0b, 0xf7, 0x6f, 0x49,
127 0x98, 0x9b, 0x76, 0x66,
128 0x79, 0x7d, 0x69, 0x33,
129 0xb5, 0x74, 0x61, 0xa4,
130 0x4c, 0xcd, 0x5c, 0x20,
131 0xc3, 0xba, 0x90, 0xfc,
132 0xe3, 0x17, 0xd0, 0x89,
133 0x28, 0x61, 0x5d, 0xb0,
134 0x5d, 0xc9, 0xad, 0xc9,
135 0xfc, 0x8c, 0x48, 0x3c,
136 0x11, 0x13, 0x40, 0x27,
137 0xe4, 0x88, 0x27, 0x4f,
138 0x52, 0xa2, 0x54, 0x50,
139 };
140 static const deUint32 s_snormInt32FloatRef[] =
141 {
142 0xbe2fee9a, 0x3f10e8b3, 0xbe953d4b, 0x3f12dfee,
143 0x3f4ced37, 0x3ecda5f6, 0xbf373d17, 0x3e817335,
144 0xbcdbd14f, 0xbf6c5fd0, 0xbf1f453e, 0xbed948db,
145 0x3ef12234, 0x3e9d004c, 0x3f1e4f12, 0x3f20a945,
146 };
147 static const deUint32 s_snormInt32UintRef[] =
148 {
149 0xea022cba, 0x48745975, 0xdab0ad32, 0x496ff70b,
150 0x66769b98, 0x33697d79, 0xa46174b5, 0x205ccd4c,
151 0xfc90bac3, 0x89d017e3, 0xb05d6128, 0xc9adc95d,
152 0x3c488cfc, 0x27401311, 0x4f2788e4, 0x5054a252,
153 };
154 static const deUint32 s_snormInt32IntRef[] =
155 {
156 0xea022cba, 0x48745975, 0xdab0ad32, 0x496ff70b,
157 0x66769b98, 0x33697d79, 0xa46174b5, 0x205ccd4c,
158 0xfc90bac3, 0x89d017e3, 0xb05d6128, 0xc9adc95d,
159 0x3c488cfc, 0x27401311, 0x4f2788e4, 0x5054a252,
160 };
161
162 static const deUint8 s_unormInt8In[] =
163 {
164 0x90, 0xa0, 0xa9, 0x26,
165 0x24, 0xc4, 0xa1, 0xa5,
166 0xdb, 0x0e, 0x09, 0x7a,
167 0x7f, 0x3d, 0xf2, 0x1f,
168 };
169 static const deUint32 s_unormInt8FloatRef[] =
170 {
171 0x3f109091, 0x3f20a0a1, 0x3f29a9aa, 0x3e189899,
172 0x3e109091, 0x3f44c4c5, 0x3f21a1a2, 0x3f25a5a6,
173 0x3f5bdbdc, 0x3d60e0e1, 0x3d109091, 0x3ef4f4f5,
174 0x3efefeff, 0x3e74f4f5, 0x3f72f2f3, 0x3df8f8f9,
175 };
176 static const deUint32 s_unormInt8UintRef[] =
177 {
178 0x00000090, 0x000000a0, 0x000000a9, 0x00000026,
179 0x00000024, 0x000000c4, 0x000000a1, 0x000000a5,
180 0x000000db, 0x0000000e, 0x00000009, 0x0000007a,
181 0x0000007f, 0x0000003d, 0x000000f2, 0x0000001f,
182 };
183 static const deUint32 s_unormInt8IntRef[] =
184 {
185 0x00000090, 0x000000a0, 0x000000a9, 0x00000026,
186 0x00000024, 0x000000c4, 0x000000a1, 0x000000a5,
187 0x000000db, 0x0000000e, 0x00000009, 0x0000007a,
188 0x0000007f, 0x0000003d, 0x000000f2, 0x0000001f,
189 };
190
191 static const deUint8 s_unormInt16In[] =
192 {
193 0xb6, 0x85, 0xf0, 0x1a,
194 0xbc, 0x76, 0x5b, 0x59,
195 0xf8, 0x74, 0x80, 0x6c,
196 0xb1, 0x80, 0x4a, 0xdc,
197 0xeb, 0x61, 0xa3, 0x12,
198 0xf6, 0x65, 0x6b, 0x25,
199 0x29, 0xe0, 0xe3, 0x0d,
200 0x3a, 0xac, 0xa7, 0x97,
201 };
202 static const deUint32 s_unormInt16FloatRef[] =
203 {
204 0x3f05b686, 0x3dd780d8, 0x3eed78ed, 0x3eb2b6b3,
205 0x3ee9f0ea, 0x3ed900d9, 0x3f00b181, 0x3f5c4adc,
206 0x3ec3d6c4, 0x3d951895, 0x3ecbeccc, 0x3e15ac96,
207 0x3f6029e0, 0x3d5e30de, 0x3f2c3aac, 0x3f17a798,
208 };
209 static const deUint32 s_unormInt16UintRef[] =
210 {
211 0x000085b6, 0x00001af0, 0x000076bc, 0x0000595b,
212 0x000074f8, 0x00006c80, 0x000080b1, 0x0000dc4a,
213 0x000061eb, 0x000012a3, 0x000065f6, 0x0000256b,
214 0x0000e029, 0x00000de3, 0x0000ac3a, 0x000097a7,
215 };
216 static const deUint32 s_unormInt16IntRef[] =
217 {
218 0x000085b6, 0x00001af0, 0x000076bc, 0x0000595b,
219 0x000074f8, 0x00006c80, 0x000080b1, 0x0000dc4a,
220 0x000061eb, 0x000012a3, 0x000065f6, 0x0000256b,
221 0x0000e029, 0x00000de3, 0x0000ac3a, 0x000097a7,
222 };
223
224 static const deUint8 s_unormInt24In[] =
225 {
226 0xea, 0x65, 0x31, 0xb3,
227 0x53, 0x62, 0x02, 0xf1,
228 0xda, 0x3c, 0xaf, 0x31,
229 0x35, 0xd6, 0x1f, 0xe4,
230 0xfa, 0x3b, 0xb9, 0x48,
231 0x73, 0x9a, 0xde, 0x6b,
232 0x3e, 0xa5, 0x15, 0x90,
233 0x95, 0xc2, 0x56, 0x8b,
234 0xd2, 0x14, 0xd5, 0xe5,
235 0xd0, 0x7b, 0x9f, 0x74,
236 0x79, 0x58, 0x86, 0xa9,
237 0xc0, 0xdf, 0xb6, 0xb4,
238 };
239 static const deUint32 s_unormInt24FloatRef[] =
240 {
241 0x3e4597a9, 0x3ec4a767, 0x3f5af103, 0x3e46bcf1,
242 0x3dfeb1a9, 0x3e6feb91, 0x3ee69173, 0x3ed7bd35,
243 0x3dad29f1, 0x3f429591, 0x3f528b57, 0x3f65d515,
244 0x3f1f7bd1, 0x3eb0f2e9, 0x3f40a987, 0x3f34b6e0,
245 };
246 static const deUint32 s_unormInt24UintRef[] =
247 {
248 0x003165ea, 0x006253b3, 0x00daf102, 0x0031af3c,
249 0x001fd635, 0x003bfae4, 0x007348b9, 0x006bde9a,
250 0x0015a53e, 0x00c29590, 0x00d28b56, 0x00e5d514,
251 0x009f7bd0, 0x00587974, 0x00c0a986, 0x00b4b6df,
252 };
253 static const deUint32 s_unormInt24IntRef[] =
254 {
255 0x003165ea, 0x006253b3, 0x00daf102, 0x0031af3c,
256 0x001fd635, 0x003bfae4, 0x007348b9, 0x006bde9a,
257 0x0015a53e, 0x00c29590, 0x00d28b56, 0x00e5d514,
258 0x009f7bd0, 0x00587974, 0x00c0a986, 0x00b4b6df,
259 };
260
261 static const deUint8 s_unormInt32In[] =
262 {
263 0x45, 0x7d, 0xe1, 0x55,
264 0xd2, 0xcb, 0xc5, 0x17,
265 0x64, 0x87, 0x84, 0x50,
266 0x37, 0x60, 0x54, 0xa1,
267 0xa8, 0x7e, 0xea, 0x98,
268 0x1a, 0xd1, 0xb4, 0x70,
269 0x2d, 0xcb, 0xff, 0x13,
270 0x3d, 0xd7, 0x3c, 0xe4,
271 0x94, 0xd6, 0xb4, 0xf7,
272 0x01, 0x58, 0x32, 0x9d,
273 0x91, 0x2b, 0x49, 0x1f,
274 0xd0, 0xca, 0x3d, 0x05,
275 0x14, 0x5a, 0x95, 0xd0,
276 0xfd, 0x64, 0x33, 0xd3,
277 0x73, 0x87, 0xa5, 0xf9,
278 0x6d, 0xc8, 0x39, 0x03,
279 };
280 static const deUint32 s_unormInt32FloatRef[] =
281 {
282 0x3eabc2fb, 0x3dbe2e5f, 0x3ea1090f, 0x3f215460,
283 0x3f18ea7f, 0x3ee169a2, 0x3d9ffe59, 0x3f643cd7,
284 0x3f77b4d7, 0x3f1d3258, 0x3dfa495d, 0x3ca7b95a,
285 0x3f50955a, 0x3f533365, 0x3f79a587, 0x3c4e721b,
286 };
287 static const deUint32 s_unormInt32UintRef[] =
288 {
289 0x55e17d45, 0x17c5cbd2, 0x50848764, 0xa1546037,
290 0x98ea7ea8, 0x70b4d11a, 0x13ffcb2d, 0xe43cd73d,
291 0xf7b4d694, 0x9d325801, 0x1f492b91, 0x053dcad0,
292 0xd0955a14, 0xd33364fd, 0xf9a58773, 0x0339c86d,
293 };
294 static const deUint32 s_unormInt32IntRef[] =
295 {
296 0x55e17d45, 0x17c5cbd2, 0x50848764, 0xa1546037,
297 0x98ea7ea8, 0x70b4d11a, 0x13ffcb2d, 0xe43cd73d,
298 0xf7b4d694, 0x9d325801, 0x1f492b91, 0x053dcad0,
299 0xd0955a14, 0xd33364fd, 0xf9a58773, 0x0339c86d,
300 };
301
302 static const deUint8 s_unormByte44In[] =
303 {
304 0xdb, 0xa8, 0x29, 0x2d,
305 };
306 static const deUint32 s_unormByte44FloatRef[] =
307 {
308 0x3f5dddde, 0x3f3bbbbc, 0x00000000, 0x3f800000,
309 0x3f2aaaab, 0x3f088889, 0x00000000, 0x3f800000,
310 0x3e088889, 0x3f19999a, 0x00000000, 0x3f800000,
311 0x3e088889, 0x3f5dddde, 0x00000000, 0x3f800000,
312 };
313 static const deUint32 s_unormByte44IntRef[] =
314 {
315 0x0000000d, 0x0000000b, 0x00000000, 0x00000001,
316 0x0000000a, 0x00000008, 0x00000000, 0x00000001,
317 0x00000002, 0x00000009, 0x00000000, 0x00000001,
318 0x00000002, 0x0000000d, 0x00000000, 0x00000001,
319 };
320 static const deUint32 s_unsignedByte44FloatRef[] =
321 {
322 0x41500000, 0x41300000, 0x00000000, 0x3f800000,
323 0x41200000, 0x41000000, 0x00000000, 0x3f800000,
324 0x40000000, 0x41100000, 0x00000000, 0x3f800000,
325 0x40000000, 0x41500000, 0x00000000, 0x3f800000,
326 };
327
328 static const deUint8 s_unormShort565In[] =
329 {
330 0xea, 0x7e, 0xcc, 0x28,
331 0x38, 0xce, 0x8f, 0x16,
332 };
333 static const deUint32 s_unormShort565FloatRef[] =
334 {
335 0x3ef7bdef, 0x3f5f7df8, 0x3ea5294a, 0x3f800000,
336 0x3e25294a, 0x3dc30c31, 0x3ec6318c, 0x3f800000,
337 0x3f4e739d, 0x3f471c72, 0x3f46318c, 0x3f800000,
338 0x3d842108, 0x3f534d35, 0x3ef7bdef, 0x3f800000,
339 };
340 static const deUint32 s_unormShort565IntRef[] =
341 {
342 0x0000000f, 0x00000037, 0x0000000a, 0x00000001,
343 0x00000005, 0x00000006, 0x0000000c, 0x00000001,
344 0x00000019, 0x00000031, 0x00000018, 0x00000001,
345 0x00000002, 0x00000034, 0x0000000f, 0x00000001,
346 };
347 static const deUint32 s_unsignedShort565FloatRef[] =
348 {
349 0x41700000, 0x425c0000, 0x41200000, 0x3f800000,
350 0x40a00000, 0x40c00000, 0x41400000, 0x3f800000,
351 0x41c80000, 0x42440000, 0x41c00000, 0x3f800000,
352 0x40000000, 0x42500000, 0x41700000, 0x3f800000,
353 };
354
355 static const deUint8 s_unormShort555In[] =
356 {
357 0x02, 0xea, 0x89, 0x13,
358 0x94, 0x5a, 0x5b, 0x60,
359 };
360 static const deUint32 s_unormShort555FloatRef[] =
361 {
362 0x3f56b5ad, 0x3f042108, 0x3d842108, 0x3f800000,
363 0x3e042108, 0x3f6739ce, 0x3e94a529, 0x3f800000,
364 0x3f35ad6b, 0x3f25294a, 0x3f25294a, 0x3f800000,
365 0x3f46318c, 0x3d842108, 0x3f5ef7be, 0x3f800000,
366 };
367 static const deUint32 s_unormShort555IntRef[] =
368 {
369 0x0000001a, 0x00000010, 0x00000002, 0x00000001,
370 0x00000004, 0x0000001c, 0x00000009, 0x00000001,
371 0x00000016, 0x00000014, 0x00000014, 0x00000001,
372 0x00000018, 0x00000002, 0x0000001b, 0x00000001,
373 };
374
375 static const deUint8 s_unormShort4444In[] =
376 {
377 0x19, 0xdb, 0xa8, 0xa8,
378 0x72, 0x29, 0xb4, 0x2d,
379 };
380 static const deUint32 s_unormShort4444FloatRef[] =
381 {
382 0x3f5dddde, 0x3f3bbbbc, 0x3d888889, 0x3f19999a,
383 0x3f2aaaab, 0x3f088889, 0x3f2aaaab, 0x3f088889,
384 0x3e088889, 0x3f19999a, 0x3eeeeeef, 0x3e088889,
385 0x3e088889, 0x3f5dddde, 0x3f3bbbbc, 0x3e888889,
386 };
387 static const deUint32 s_unormShort4444IntRef[] =
388 {
389 0x0000000d, 0x0000000b, 0x00000001, 0x00000009,
390 0x0000000a, 0x00000008, 0x0000000a, 0x00000008,
391 0x00000002, 0x00000009, 0x00000007, 0x00000002,
392 0x00000002, 0x0000000d, 0x0000000b, 0x00000004,
393 };
394 static const deUint32 s_unsignedShort4444FloatRef[] =
395 {
396 0x41500000, 0x41300000, 0x3f800000, 0x41100000,
397 0x41200000, 0x41000000, 0x41200000, 0x41000000,
398 0x40000000, 0x41100000, 0x40e00000, 0x40000000,
399 0x40000000, 0x41500000, 0x41300000, 0x40800000,
400 };
401
402 static const deUint8 s_unormShort5551In[] =
403 {
404 0x13, 0x89, 0x6f, 0x3c,
405 0xae, 0xe9, 0xf2, 0xd9,
406 };
407 static const deUint32 s_unormShort5551FloatRef[] =
408 {
409 0x3f0c6319, 0x3e042108, 0x3e94a529, 0x3f800000,
410 0x3e6739ce, 0x3f0c6319, 0x3f3def7c, 0x3f800000,
411 0x3f6f7bdf, 0x3e46318c, 0x3f3def7c, 0x00000000,
412 0x3f5ef7be, 0x3e6739ce, 0x3f4e739d, 0x00000000,
413 };
414 static const deUint32 s_unormShort5551IntRef[] =
415 {
416 0x00000011, 0x00000004, 0x00000009, 0x00000001,
417 0x00000007, 0x00000011, 0x00000017, 0x00000001,
418 0x0000001d, 0x00000006, 0x00000017, 0x00000000,
419 0x0000001b, 0x00000007, 0x00000019, 0x00000000,
420 };
421 static const deUint32 s_unsignedShort5551FloatRef[] =
422 {
423 0x41880000, 0x40800000, 0x41100000, 0x3f800000,
424 0x40e00000, 0x41880000, 0x41b80000, 0x3f800000,
425 0x41e80000, 0x40c00000, 0x41b80000, 0x00000000,
426 0x41d80000, 0x40e00000, 0x41c80000, 0x00000000,
427 };
428
429 static const deUint8 s_unormShort1555In[] =
430 {
431 0xf8, 0xc5, 0x1f, 0x6c,
432 0xf0, 0x2f, 0xf2, 0x95,
433 };
434 static const deUint32 s_unormShort1555FloatRef[] =
435 {
436 0x3f800000, 0x3f0c6319, 0x3ef7bdef, 0x3f46318c,
437 0x00000000, 0x3f5ef7be, 0x00000000, 0x3f800000,
438 0x00000000, 0x3eb5ad6b, 0x3f800000, 0x3f042108,
439 0x3f800000, 0x3e25294a, 0x3ef7bdef, 0x3f14a529,
440 };
441 static const deUint32 s_unormShort1555IntRef[] =
442 {
443 0x00000001, 0x00000011, 0x0000000f, 0x00000018,
444 0x00000000, 0x0000001b, 0x00000000, 0x0000001f,
445 0x00000000, 0x0000000b, 0x0000001f, 0x00000010,
446 0x00000001, 0x00000005, 0x0000000f, 0x00000012,
447 };
448
449 static const deUint8 s_unormInt101010In[] =
450 {
451 0x81, 0xb3, 0x67, 0x51,
452 0xa9, 0x00, 0x34, 0xc5,
453 0xf0, 0x2f, 0xf2, 0x95,
454 0xf8, 0xc5, 0x1f, 0x6c,
455 };
456 static const deUint32 s_unormInt101010FloatRef[] =
457 {
458 0x3ea2a8aa, 0x3f1ee7ba, 0x3e60380e, 0x3f800000,
459 0x3f45314c, 0x3f50340d, 0x3d282a0b, 0x3f800000,
460 0x3f15e579, 0x3f48b22d, 0x3f7f3fd0, 0x3f800000,
461 0x3ed8360e, 0x3efe3f90, 0x3ebf2fcc, 0x3f800000,
462 };
463 static const deUint32 s_unormInt101010IntRef[] =
464 {
465 0x00000145, 0x0000027b, 0x000000e0, 0x00000001,
466 0x00000314, 0x00000340, 0x0000002a, 0x00000001,
467 0x00000257, 0x00000322, 0x000003fc, 0x00000001,
468 0x000001b0, 0x000001fc, 0x0000017e, 0x00000001,
469 };
470
471 static const deUint8 s_unormInt1010102RevIn[] =
472 {
473 0xfd, 0xc6, 0xf5, 0xc4,
474 0x32, 0xa8, 0xfd, 0x7d,
475 0xe7, 0x3f, 0x10, 0xd0,
476 0x86, 0x0d, 0x66, 0xd0,
477 };
478 static const deUint32 s_unormInt1010102RevFloatRef[] =
479 {
480 0x3f3f6fdc, 0x3eb8ae2c, 0x3d9e278a, 0x3f800000,
481 0x3d48320d, 0x3f5ab6ae, 0x3f77fdff, 0x3eaaaaab,
482 0x3f79fe80, 0x3c703c0f, 0x3e80a028, 0x3f800000,
483 0x3ec330cc, 0x3ec1b06c, 0x3e8320c8, 0x3f800000,
484 };
485 static const deUint32 s_unormInt1010102RevIntRef[] =
486 {
487 0x000002fd, 0x00000171, 0x0000004f, 0x00000003,
488 0x00000032, 0x0000036a, 0x000003df, 0x00000001,
489 0x000003e7, 0x0000000f, 0x00000101, 0x00000003,
490 0x00000186, 0x00000183, 0x00000106, 0x00000003,
491 };
492 static const deUint32 s_snormInt1010102RevFloatRef[] =
493 {
494 0xbf01c0e0, 0x3f38dc6e, 0x3e1e4f28, 0xbf800000,
495 0x3dc86432, 0xbe964b26, 0xbd844221, 0x3f800000,
496 0xbd486432, 0x3cf0783c, 0x3f00c060, 0xbf800000,
497 0x3f4361b1, 0x3f41e0f0, 0x3f0341a1, 0xbf800000,
498 };
499 static const deUint32 s_snormInt1010102RevIntRef[] =
500 {
501 0xfffffefd, 0x00000171, 0x0000004f, 0xffffffff,
502 0x00000032, 0xffffff6a, 0xffffffdf, 0x00000001,
503 0xffffffe7, 0x0000000f, 0x00000101, 0xffffffff,
504 0x00000186, 0x00000183, 0x00000106, 0xffffffff,
505 };
506
507 static const deUint8 s_unsignedInt1010102RevIn[] =
508 {
509 0xb8, 0x4c, 0xfd, 0x00,
510 0x65, 0x7f, 0xb2, 0x4e,
511 0x11, 0x3e, 0x03, 0x23,
512 0xae, 0xc9, 0xdd, 0xa2,
513 };
514 static const deUint32 s_unsignedInt1010102RevFloatRef[] =
515 {
516 0x43380000, 0x4454c000, 0x41700000, 0x00000000,
517 0x44594000, 0x431f0000, 0x436b0000, 0x3f800000,
518 0x44044000, 0x434f0000, 0x440c0000, 0x00000000,
519 0x43d70000, 0x445c8000, 0x440b4000, 0x40000000,
520 };
521 static const deUint32 s_unsignedInt1010102RevIntRef[] =
522 {
523 0x000000b8, 0x00000353, 0x0000000f, 0x00000000,
524 0x00000365, 0x0000009f, 0x000000eb, 0x00000001,
525 0x00000211, 0x000000cf, 0x00000230, 0x00000000,
526 0x000001ae, 0x00000372, 0x0000022d, 0x00000002,
527 };
528 static const deUint32 s_signedInt1010102RevFloatRef[] =
529 {
530 0x43380000, 0x4f7fffff, 0x41700000, 0x00000000,
531 0x4f7fffff, 0x431f0000, 0x436b0000, 0x3f800000,
532 0x4f7ffffe, 0x434f0000, 0x4f7ffffe, 0x00000000,
533 0x43d70000, 0x4f7fffff, 0x4f7ffffe, 0x4f800000,
534 };
535 static const deUint32 s_signedInt1010102RevIntRef[] =
536 {
537 0x000000b8, 0xffffff53, 0x0000000f, 0x00000000,
538 0xffffff65, 0x0000009f, 0x000000eb, 0x00000001,
539 0xfffffe11, 0x000000cf, 0xfffffe30, 0x00000000,
540 0x000001ae, 0xffffff72, 0xfffffe2d, 0xfffffffe,
541 };
542
543 static const deUint8 s_unsignedInt11f11f10fRevIn[] =
544 {
545 0x8e, 0x1b, 0x81, 0x45,
546 0xcf, 0x47, 0x50, 0x29,
547 0xff, 0x5e, 0x8e, 0x93,
548 0x95, 0x07, 0x45, 0x4a,
549 };
550 static const deUint32 s_unsignedInt11f11f10fRevFloatRef[] =
551 {
552 0x3f1c0000, 0x380c0000, 0x3c580000, 0x3f800000,
553 0x7fffffff, 0x3c100000, 0x3a940000, 0x3f800000,
554 0x45fe0000, 0x3b960000, 0x41380000, 0x3f800000,
555 0x472a0000, 0x39400000, 0x3ca40000, 0x3f800000,
556 };
557
558 static const deUint8 s_unsignedInt999E5RevIn[] =
559 {
560 0x88, 0x8b, 0x50, 0x34,
561 0x2b, 0x2f, 0xe2, 0x92,
562 0x95, 0x7f, 0xeb, 0x18,
563 0x6b, 0xe2, 0x27, 0x30,
564 };
565 static const deUint32 s_unsignedInt999E5RevFloatRef[] =
566 {
567 0x3ac40000, 0x398a0000, 0x3a8a0000, 0x3f800000,
568 0x40958000, 0x408b8000, 0x40380000, 0x3f800000,
569 0x394a8000, 0x395f8000, 0x37e80000, 0x3f800000,
570 0x39d60000, 0x3af88000, 0x38100000, 0x3f800000,
571 };
572
573 static const deUint8 s_unsignedInt1688In[] =
574 {
575 0x02, 0x50, 0x91, 0x85,
576 0xcc, 0xe2, 0xfd, 0xc8,
577 0x62, 0xeb, 0x0f, 0xe6,
578 0x95, 0x27, 0x26, 0x24,
579 };
580 static const deUint32 s_unsignedInt1688FloatRef[] =
581 {
582 0x3f059186, 0x00000000, 0x00000000, 0x3f800000,
583 0x3f48fdc9, 0x00000000, 0x00000000, 0x3f800000,
584 0x3f660fe6, 0x00000000, 0x00000000, 0x3f800000,
585 0x3e109891, 0x00000000, 0x00000000, 0x3f800000,
586 };
587 static const deUint32 s_unsignedInt1688UintRef[] =
588 {
589 0x00000002, 0x00000000, 0x00000000, 0x00000001,
590 0x000000cc, 0x00000000, 0x00000000, 0x00000001,
591 0x00000062, 0x00000000, 0x00000000, 0x00000001,
592 0x00000095, 0x00000000, 0x00000000, 0x00000001,
593 };
594
595 static const deUint8 s_unsignedInt248In[] =
596 {
597 0xea, 0x7e, 0xcc, 0x28,
598 0x38, 0xce, 0x8f, 0x16,
599 0x3e, 0x4f, 0xe2, 0xfd,
600 0x74, 0x5e, 0xf2, 0x30,
601 };
602 static const deUint32 s_unsignedInt248FloatRef[] =
603 {
604 0x3e2331f9, 0x00000000, 0x00000000, 0x3f800000,
605 0x3db47e71, 0x00000000, 0x00000000, 0x3f800000,
606 0x3f7de250, 0x00000000, 0x00000000, 0x3f800000,
607 0x3e43c979, 0x00000000, 0x00000000, 0x3f800000,
608 };
609 static const deUint32 s_unsignedInt248UintRef[] =
610 {
611 0x000000ea, 0x00000000, 0x00000000, 0x00000001,
612 0x00000038, 0x00000000, 0x00000000, 0x00000001,
613 0x0000003e, 0x00000000, 0x00000000, 0x00000001,
614 0x00000074, 0x00000000, 0x00000000, 0x00000001,
615 };
616
617 static const deUint8 s_unsignedInt248RevIn[] =
618 {
619 0x7e, 0xcc, 0x28, 0xea,
620 0xce, 0x8f, 0x16, 0x38,
621 0x4f, 0xe2, 0xfd, 0x3e,
622 0x5e, 0xf2, 0x30, 0x74,
623 };
624 static const deUint32 s_unsignedInt248RevFloatRef[] =
625 {
626 0x3e2331f9, 0x00000000, 0x00000000, 0x3f800000,
627 0x3db47e71, 0x00000000, 0x00000000, 0x3f800000,
628 0x3f7de250, 0x00000000, 0x00000000, 0x3f800000,
629 0x3e43c979, 0x00000000, 0x00000000, 0x3f800000,
630 };
631 static const deUint32 s_unsignedInt248RevUintRef[] =
632 {
633 0x000000ea, 0x00000000, 0x00000000, 0x00000001,
634 0x00000038, 0x00000000, 0x00000000, 0x00000001,
635 0x0000003e, 0x00000000, 0x00000000, 0x00000001,
636 0x00000074, 0x00000000, 0x00000000, 0x00000001,
637 };
638
639 static const deUint8 s_signedInt8In[] =
640 {
641 0x3a, 0x5b, 0x6d, 0x6a,
642 0x44, 0x56, 0x6b, 0x21,
643 0x6a, 0x0b, 0x24, 0xd9,
644 0xd4, 0xb4, 0xda, 0x97,
645 };
646 static const deUint32 s_signedInt8FloatRef[] =
647 {
648 0x42680000, 0x42b60000, 0x42da0000, 0x42d40000,
649 0x42880000, 0x42ac0000, 0x42d60000, 0x42040000,
650 0x42d40000, 0x41300000, 0x42100000, 0xc21c0000,
651 0xc2300000, 0xc2980000, 0xc2180000, 0xc2d20000,
652 };
653 static const deUint32 s_signedInt8UintRef[] =
654 {
655 0x0000003a, 0x0000005b, 0x0000006d, 0x0000006a,
656 0x00000044, 0x00000056, 0x0000006b, 0x00000021,
657 0x0000006a, 0x0000000b, 0x00000024, 0xffffffd9,
658 0xffffffd4, 0xffffffb4, 0xffffffda, 0xffffff97,
659 };
660 static const deUint32 s_signedInt8IntRef[] =
661 {
662 0x0000003a, 0x0000005b, 0x0000006d, 0x0000006a,
663 0x00000044, 0x00000056, 0x0000006b, 0x00000021,
664 0x0000006a, 0x0000000b, 0x00000024, 0xffffffd9,
665 0xffffffd4, 0xffffffb4, 0xffffffda, 0xffffff97,
666 };
667
668 static const deUint8 s_signedInt16In[] =
669 {
670 0xf1, 0xdd, 0xcd, 0xc3,
671 0x1c, 0xb6, 0x6f, 0x74,
672 0x19, 0x13, 0x25, 0xed,
673 0x16, 0xce, 0x0d, 0x0f,
674 0x5c, 0xf4, 0x3c, 0xa3,
675 0x6d, 0x25, 0x65, 0x6d,
676 0xae, 0x5d, 0x88, 0xfa,
677 0x86, 0x3e, 0x6a, 0x91,
678 };
679 static const deUint32 s_signedInt16FloatRef[] =
680 {
681 0xc6083c00, 0xc670cc00, 0xc693c800, 0x46e8de00,
682 0x4598c800, 0xc596d800, 0xc647a800, 0x4570d000,
683 0xc53a4000, 0xc6b98800, 0x4615b400, 0x46daca00,
684 0x46bb5c00, 0xc4af0000, 0x467a1800, 0xc6dd2c00,
685 };
686 static const deUint32 s_signedInt16UintRef[] =
687 {
688 0xffffddf1, 0xffffc3cd, 0xffffb61c, 0x0000746f,
689 0x00001319, 0xffffed25, 0xffffce16, 0x00000f0d,
690 0xfffff45c, 0xffffa33c, 0x0000256d, 0x00006d65,
691 0x00005dae, 0xfffffa88, 0x00003e86, 0xffff916a,
692 };
693 static const deUint32 s_signedInt16IntRef[] =
694 {
695 0xffffddf1, 0xffffc3cd, 0xffffb61c, 0x0000746f,
696 0x00001319, 0xffffed25, 0xffffce16, 0x00000f0d,
697 0xfffff45c, 0xffffa33c, 0x0000256d, 0x00006d65,
698 0x00005dae, 0xfffffa88, 0x00003e86, 0xffff916a,
699 };
700
701 static const deUint8 s_signedInt32In[] =
702 {
703 0xc6, 0x7e, 0x50, 0x2a,
704 0xec, 0x0f, 0x9b, 0x44,
705 0x4d, 0xa9, 0x77, 0x0d,
706 0x69, 0x4c, 0xd3, 0x76,
707 0xf0, 0xb7, 0xde, 0x6b,
708 0x4e, 0xe2, 0xb1, 0x58,
709 0xa8, 0x9c, 0xfc, 0x6d,
710 0x75, 0x8f, 0x3c, 0x7f,
711 0xf3, 0x19, 0x14, 0x97,
712 0xf0, 0x87, 0x5c, 0x11,
713 0x95, 0x32, 0xab, 0x7a,
714 0x03, 0x2b, 0xdf, 0x52,
715 0x68, 0x84, 0xd9, 0x91,
716 0xec, 0x2a, 0xf1, 0xd0,
717 0xf7, 0x73, 0x8f, 0x0a,
718 0x62, 0xd2, 0x76, 0xfd,
719 };
720 static const deUint32 s_signedInt32FloatRef[] =
721 {
722 0x4e2941fb, 0x4e893620, 0x4d577a95, 0x4eeda699,
723 0x4ed7bd70, 0x4eb163c5, 0x4edbf939, 0x4efe791f,
724 0xced1d7cc, 0x4d8ae440, 0x4ef55665, 0x4ea5be56,
725 0xcedc4cf7, 0xce3c3b54, 0x4d28f73f, 0xcc224b68,
726 };
727 static const deUint32 s_signedInt32UintRef[] =
728 {
729 0x2a507ec6, 0x449b0fec, 0x0d77a94d, 0x76d34c69,
730 0x6bdeb7f0, 0x58b1e24e, 0x6dfc9ca8, 0x7f3c8f75,
731 0x971419f3, 0x115c87f0, 0x7aab3295, 0x52df2b03,
732 0x91d98468, 0xd0f12aec, 0x0a8f73f7, 0xfd76d262,
733 };
734 static const deUint32 s_signedInt32IntRef[] =
735 {
736 0x2a507ec6, 0x449b0fec, 0x0d77a94d, 0x76d34c69,
737 0x6bdeb7f0, 0x58b1e24e, 0x6dfc9ca8, 0x7f3c8f75,
738 0x971419f3, 0x115c87f0, 0x7aab3295, 0x52df2b03,
739 0x91d98468, 0xd0f12aec, 0x0a8f73f7, 0xfd76d262,
740 };
741
742 static const deUint8 s_unsignedInt8In[] =
743 {
744 0x68, 0xa6, 0x99, 0x6e,
745 0x13, 0x90, 0x0f, 0x40,
746 0x34, 0x76, 0x05, 0x9a,
747 0x6c, 0x9c, 0x1d, 0x6a,
748 };
749 static const deUint32 s_unsignedInt8FloatRef[] =
750 {
751 0x42d00000, 0x43260000, 0x43190000, 0x42dc0000,
752 0x41980000, 0x43100000, 0x41700000, 0x42800000,
753 0x42500000, 0x42ec0000, 0x40a00000, 0x431a0000,
754 0x42d80000, 0x431c0000, 0x41e80000, 0x42d40000,
755 };
756 static const deUint32 s_unsignedInt8UintRef[] =
757 {
758 0x00000068, 0x000000a6, 0x00000099, 0x0000006e,
759 0x00000013, 0x00000090, 0x0000000f, 0x00000040,
760 0x00000034, 0x00000076, 0x00000005, 0x0000009a,
761 0x0000006c, 0x0000009c, 0x0000001d, 0x0000006a,
762 };
763 static const deUint32 s_unsignedInt8IntRef[] =
764 {
765 0x00000068, 0x000000a6, 0x00000099, 0x0000006e,
766 0x00000013, 0x00000090, 0x0000000f, 0x00000040,
767 0x00000034, 0x00000076, 0x00000005, 0x0000009a,
768 0x0000006c, 0x0000009c, 0x0000001d, 0x0000006a,
769 };
770
771 static const deUint8 s_unsignedInt16In[] =
772 {
773 0xa5, 0x62, 0x98, 0x7c,
774 0x13, 0x21, 0xc8, 0xf4,
775 0x78, 0x0b, 0x9f, 0xc2,
776 0x92, 0x1c, 0xa9, 0x25,
777 0x86, 0xea, 0x1f, 0x1c,
778 0x41, 0xf7, 0xe2, 0x2e,
779 0x38, 0x69, 0xf2, 0x6d,
780 0x01, 0xec, 0x7f, 0xc5,
781 };
782 static const deUint32 s_unsignedInt16FloatRef[] =
783 {
784 0x46c54a00, 0x46f93000, 0x46044c00, 0x4774c800,
785 0x45378000, 0x47429f00, 0x45e49000, 0x4616a400,
786 0x476a8600, 0x45e0f800, 0x47774100, 0x463b8800,
787 0x46d27000, 0x46dbe400, 0x476c0100, 0x47457f00,
788 };
789 static const deUint32 s_unsignedInt16UintRef[] =
790 {
791 0x000062a5, 0x00007c98, 0x00002113, 0x0000f4c8,
792 0x00000b78, 0x0000c29f, 0x00001c92, 0x000025a9,
793 0x0000ea86, 0x00001c1f, 0x0000f741, 0x00002ee2,
794 0x00006938, 0x00006df2, 0x0000ec01, 0x0000c57f,
795 };
796 static const deUint32 s_unsignedInt16IntRef[] =
797 {
798 0x000062a5, 0x00007c98, 0x00002113, 0x0000f4c8,
799 0x00000b78, 0x0000c29f, 0x00001c92, 0x000025a9,
800 0x0000ea86, 0x00001c1f, 0x0000f741, 0x00002ee2,
801 0x00006938, 0x00006df2, 0x0000ec01, 0x0000c57f,
802 };
803
804 static const deUint8 s_unsignedInt24In[] =
805 {
806 0xa8, 0x11, 0x00, 0xc8,
807 0xe5, 0x07, 0xd3, 0x6d,
808 0x0a, 0xc7, 0xe4, 0x42,
809 0x2d, 0xf7, 0x5d, 0x9c,
810 0x2e, 0x18, 0xfd, 0xa4,
811 0x9e, 0x90, 0x0c, 0x31,
812 0x06, 0x04, 0xc4, 0xc2,
813 0xde, 0xfe, 0x7c, 0x1d,
814 0x57, 0x37, 0x4a, 0xf2,
815 0xe2, 0xf3, 0x74, 0x8e,
816 0x8f, 0xd6, 0x73, 0xc4,
817 0x91, 0xa0, 0x49, 0xe3,
818 };
819 static const deUint32 s_unsignedInt24FloatRef[] =
820 {
821 0x458d4000, 0x48fcb900, 0x4926dd30, 0x4a85c98e,
822 0x4abbee5a, 0x49c174e0, 0x4b1ea4fd, 0x4a443240,
823 0x4b440406, 0x4b7edec2, 0x4aae3af8, 0x4b724a37,
824 0x4ae9e7c4, 0x4b568f8e, 0x4b11c473, 0x4b6349a0,
825 };
826 static const deUint32 s_unsignedInt24UintRef[] =
827 {
828 0x000011a8, 0x0007e5c8, 0x000a6dd3, 0x0042e4c7,
829 0x005df72d, 0x00182e9c, 0x009ea4fd, 0x00310c90,
830 0x00c40406, 0x00fedec2, 0x00571d7c, 0x00f24a37,
831 0x0074f3e2, 0x00d68f8e, 0x0091c473, 0x00e349a0,
832 };
833 static const deUint32 s_unsignedInt24IntRef[] =
834 {
835 0x000011a8, 0x0007e5c8, 0x000a6dd3, 0x0042e4c7,
836 0x005df72d, 0x00182e9c, 0x009ea4fd, 0x00310c90,
837 0x00c40406, 0x00fedec2, 0x00571d7c, 0x00f24a37,
838 0x0074f3e2, 0x00d68f8e, 0x0091c473, 0x00e349a0,
839 };
840
841 static const deUint8 s_unsignedInt32In[] =
842 {
843 0x90, 0xb0, 0x00, 0xa8,
844 0xd8, 0x42, 0x5b, 0xae,
845 0x40, 0x70, 0x38, 0x2a,
846 0x92, 0x76, 0xd8, 0x70,
847 0x04, 0x0d, 0x67, 0x87,
848 0x9c, 0xdd, 0xb1, 0xeb,
849 0xfc, 0x37, 0xe6, 0x40,
850 0x24, 0x9c, 0x6a, 0x0f,
851 0x09, 0x0e, 0xb6, 0x2f,
852 0x31, 0x95, 0x43, 0x22,
853 0x24, 0xde, 0x70, 0x2a,
854 0x05, 0xa2, 0x84, 0x38,
855 0x16, 0x9f, 0x65, 0x0e,
856 0xb2, 0x99, 0x84, 0x6d,
857 0xef, 0x86, 0x94, 0xf0,
858 0x25, 0x9d, 0xf9, 0x67,
859 };
860 static const deUint32 s_unsignedInt32FloatRef[] =
861 {
862 0x4f2800b1, 0x4f2e5b43, 0x4e28e1c1, 0x4ee1b0ed,
863 0x4f07670d, 0x4f6bb1de, 0x4e81cc70, 0x4d76a9c2,
864 0x4e3ed838, 0x4e090e55, 0x4e29c379, 0x4e621288,
865 0x4d6659f1, 0x4edb0933, 0x4f709487, 0x4ecff33a,
866 };
867 static const deUint32 s_unsignedInt32UintRef[] =
868 {
869 0xa800b090, 0xae5b42d8, 0x2a387040, 0x70d87692,
870 0x87670d04, 0xebb1dd9c, 0x40e637fc, 0x0f6a9c24,
871 0x2fb60e09, 0x22439531, 0x2a70de24, 0x3884a205,
872 0x0e659f16, 0x6d8499b2, 0xf09486ef, 0x67f99d25,
873 };
874 static const deUint32 s_unsignedInt32IntRef[] =
875 {
876 0xa800b090, 0xae5b42d8, 0x2a387040, 0x70d87692,
877 0x87670d04, 0xebb1dd9c, 0x40e637fc, 0x0f6a9c24,
878 0x2fb60e09, 0x22439531, 0x2a70de24, 0x3884a205,
879 0x0e659f16, 0x6d8499b2, 0xf09486ef, 0x67f99d25,
880 };
881
882 static const deUint8 s_Int64In[] =
883 {
884 0x90, 0xb0, 0x00, 0x78, 0x01, 0x00, 0x00, 0x00,
885 0x40, 0x70, 0x38, 0x2a, 0x01, 0x01, 0x00, 0x00,
886 0x04, 0x0d, 0x67, 0x87, 0x01, 0x01, 0x01, 0x00,
887 0xfc, 0x37, 0xe6, 0x40, 0x01, 0x01, 0x01, 0x01,
888 0x09, 0x0e, 0xb6, 0x2f, 0x02, 0x01, 0x01, 0x01,
889 0x24, 0xde, 0x70, 0x2a, 0x01, 0x02, 0x01, 0x01,
890 0x16, 0x9f, 0x65, 0x0e, 0x01, 0x01, 0x02, 0x01,
891 0xef, 0x86, 0x94, 0x72, 0x01, 0x01, 0x01, 0x02,
892 0xc6, 0x7e, 0x50, 0x2a, 0x01, 0x00, 0x00, 0x00,
893 0x4d, 0xa9, 0x77, 0x0d, 0x01, 0x01, 0x00, 0x00,
894 0xf0, 0xb7, 0xde, 0x6b, 0x01, 0x01, 0x01, 0x00,
895 0xa8, 0x9c, 0xfc, 0x6d, 0x01, 0x01, 0x01, 0x01,
896 0xf3, 0x19, 0x14, 0x97, 0x02, 0x01, 0x01, 0x01,
897 0x95, 0x32, 0xab, 0x7a, 0x01, 0x02, 0x01, 0x01,
898 0x68, 0x84, 0xd9, 0x71, 0x01, 0x01, 0x02, 0x01,
899 0xf7, 0x73, 0x8f, 0x0a, 0x01, 0x01, 0x01, 0x02,
900 };
901
902 static const deUint32 s_Int64FloatRef[] =
903 {
904 0x4fbc0058, 0x5380951c, 0x578080c4, 0x5b808081,
905 0x5b808081, 0x5b808101, 0x5b810081, 0x5c004040,
906 0x4f95283f, 0x538086bc, 0x578080b6, 0x5b808081,
907 0x5b808081, 0x5b808101, 0x5b810081, 0x5c004040,
908 };
909
910 static const deUint32 s_Int64IntRef[] =
911 {
912 0x7800b090, 0x2a387040, 0x87670d04, 0x40e637fc,
913 0x2fb60e09, 0x2a70de24, 0x0e659f16, 0x729486ef,
914 0x2a507ec6, 0x0d77a94d, 0x6bdeb7f0, 0x6dfc9ca8,
915 0x971419f3, 0x7aab3295, 0x71d98468, 0x0a8f73f7,
916 };
917
918 static const deUint8 s_halfFloatIn[] =
919 {
920 0x2b, 0x74, 0x6a, 0x5d,
921 0x1c, 0xb2, 0x9a, 0x4d,
922 0xad, 0x55, 0x22, 0x01,
923 0xce, 0x2d, 0x97, 0x0d,
924 0x71, 0x31, 0x42, 0x2b,
925 0xeb, 0x26, 0xc7, 0x16,
926 0x94, 0xd2, 0x22, 0x79,
927 0x89, 0xbd, 0xff, 0xbc,
928 };
929 static const deUint32 s_halfFloatFloatRef[] =
930 {
931 0x46856000, 0x43ad4000, 0xbe438000, 0x41b34000,
932 0x42b5a000, 0x37910000, 0x3db9c000, 0x39b2e000,
933 0x3e2e2000, 0x3d684000, 0x3cdd6000, 0x3ad8e000,
934 0xc2528000, 0x47244000, 0xbfb12000, 0xbf9fe000,
935 };
936 static const deUint32 s_halfFloatUintRef[] =
937 {
938 0x000042b0, 0x0000015a, 0x00000000, 0x00000016,
939 0x0000005a, 0x00000000, 0x00000000, 0x00000000,
940 0x00000000, 0x00000000, 0x00000000, 0x00000000,
941 0xffffffcc, 0x0000a440, 0xffffffff, 0xffffffff,
942 };
943 static const deUint32 s_halfFloatIntRef[] =
944 {
945 0x000042b0, 0x0000015a, 0x00000000, 0x00000016,
946 0x0000005a, 0x00000000, 0x00000000, 0x00000000,
947 0x00000000, 0x00000000, 0x00000000, 0x00000000,
948 0xffffffcc, 0x0000a440, 0xffffffff, 0xffffffff,
949 };
950
951 static const deUint8 s_floatIn[] =
952 {
953 0x92, 0xac, 0x68, 0x36,
954 0x9f, 0x42, 0x0b, 0x6e,
955 0x67, 0xcf, 0x0f, 0x20,
956 0x22, 0x6c, 0xe4, 0x0f,
957 0xb3, 0x72, 0xc8, 0x8a,
958 0x4b, 0x99, 0xc3, 0xb0,
959 0xbd, 0x78, 0x5c, 0x16,
960 0x1c, 0xce, 0xb7, 0x4e,
961 0x15, 0xdf, 0x37, 0xfd,
962 0xeb, 0x32, 0xe9, 0x47,
963 0x68, 0x1a, 0xaa, 0xd0,
964 0xb9, 0xba, 0x77, 0xe7,
965 0x81, 0x0a, 0x42, 0x5a,
966 0xb0, 0x5a, 0xee, 0x06,
967 0x77, 0xb4, 0x7b, 0x57,
968 0xf5, 0x35, 0xac, 0x56,
969 };
970 static const deUint32 s_floatFloatRef[] =
971 {
972 0x3668ac92, 0x6e0b429f, 0x200fcf67, 0x0fe46c22,
973 0x8ac872b3, 0xb0c3994b, 0x165c78bd, 0x4eb7ce1c,
974 0xfd37df15, 0x47e932eb, 0xd0aa1a68, 0xe777bab9,
975 0x5a420a81, 0x06ee5ab0, 0x577bb477, 0x56ac35f5,
976 };
977 static const deUint32 s_floatUintRef[] =
978 {
979 0x00000000, 0x80000000, 0x00000000, 0x00000000,
980 0x00000000, 0x00000000, 0x00000000, 0x5be70e00,
981 0x80000000, 0x0001d265, 0x80000000, 0x80000000,
982 0x80000000, 0x00000000, 0x80000000, 0x80000000,
983 };
984 static const deUint32 s_floatIntRef[] =
985 {
986 0x00000000, 0x80000000, 0x00000000, 0x00000000,
987 0x00000000, 0x00000000, 0x00000000, 0x5be70e00,
988 0x80000000, 0x0001d265, 0x80000000, 0x80000000,
989 0x80000000, 0x00000000, 0x80000000, 0x80000000,
990 };
991
992 static const deUint8 s_float64In[] =
993 {
994 0xbd, 0xb6, 0xc3, 0xd2,
995 0xf6, 0x62, 0x29, 0xd9,
996 0x2f, 0xc2, 0x46, 0x18,
997 0x6b, 0x0d, 0x0a, 0x53,
998 0x6d, 0x0c, 0xf3, 0x80,
999 0xbd, 0xa9, 0x12, 0x89,
1000 0x6b, 0x9f, 0x3d, 0xdd,
1001 0xb3, 0x91, 0xee, 0xf5,
1002 0x92, 0xac, 0x68, 0x36,
1003 0x9f, 0x42, 0x0b, 0x6e,
1004 0x67, 0xcf, 0x0f, 0x20,
1005 0x22, 0x6c, 0xe4, 0x0f,
1006 0xb3, 0x72, 0xc8, 0x8a,
1007 0x4b, 0x99, 0xc3, 0xb0,
1008 0xbd, 0x78, 0x5c, 0x16,
1009 0x1c, 0xce, 0xb7, 0x4e,
1010 0x15, 0xdf, 0x37, 0xfd,
1011 0xeb, 0x32, 0xe9, 0x47,
1012 0x68, 0x1a, 0xaa, 0xd0,
1013 0xb9, 0xba, 0x77, 0xe7,
1014 0x81, 0x0a, 0x42, 0x5a,
1015 0xb0, 0x5a, 0xee, 0x06,
1016 0x77, 0xb4, 0x7b, 0x57,
1017 0xf5, 0x35, 0xac, 0x56,
1018 0x2b, 0x74, 0x6a, 0x5d,
1019 0x1c, 0xb2, 0x9a, 0x4d,
1020 0xad, 0x55, 0x22, 0x01,
1021 0xce, 0x2d, 0x97, 0x0d,
1022 0x71, 0x31, 0x42, 0x2b,
1023 0xeb, 0x26, 0xc7, 0x16,
1024 0x94, 0xd2, 0x22, 0x79,
1025 0x89, 0xbd, 0xff, 0xbc,
1026 };
1027 static const deUint32 s_float64FloatRef[] =
1028 {
1029 0xff800000, 0x7f800000, 0x80000000, 0xff800000,
1030 0x7f800000, 0x00000000, 0x80000000, 0x7f800000,
1031 0x7f499760, 0xff800000, 0x00000000, 0x7f800000,
1032 0x7f800000, 0x00000000, 0x00000000, 0xa7fdec4c,
1033 };
1034 static const deUint32 s_float64IntRef[] =
1035 {
1036 0x80000000, 0x80000000, 0x00000000, 0x80000000,
1037 0x80000000, 0x00000000, 0x00000000, 0x80000000,
1038 0x80000000, 0x80000000, 0x00000000, 0x80000000,
1039 0x80000000, 0x00000000, 0x00000000, 0x00000000,
1040 };
1041
1042 static const deUint8 s_floatUnsignedInt248RevIn[] =
1043 {
1044 0xbd, 0xb6, 0xc3, 0xd2,
1045 0xf6, 0x62, 0x29, 0xd9,
1046 0x2f, 0xc2, 0x46, 0x18,
1047 0x6b, 0x0d, 0x0a, 0x53,
1048 0x6d, 0x0c, 0xf3, 0x80,
1049 0xbd, 0xa9, 0x12, 0x89,
1050 0x6b, 0x9f, 0x3d, 0xdd,
1051 0xb3, 0x91, 0xee, 0xf5,
1052 };
1053 static const deUint32 s_floatUnsignedInt248RevFloatRef[] =
1054 {
1055 0xd2c3b6bd, 0x00000000, 0x00000000, 0x3f800000,
1056 0x1846c22f, 0x00000000, 0x00000000, 0x3f800000,
1057 0x80f30c6d, 0x00000000, 0x00000000, 0x3f800000,
1058 0xdd3d9f6b, 0x00000000, 0x00000000, 0x3f800000,
1059 };
1060 static const deUint32 s_floatUnsignedInt248RevUintRef[] =
1061 {
1062 0x000000f6, 0x00000000, 0x00000000, 0x00000001,
1063 0x0000006b, 0x00000000, 0x00000000, 0x00000001,
1064 0x000000bd, 0x00000000, 0x00000000, 0x00000001,
1065 0x000000b3, 0x00000000, 0x00000000, 0x00000001,
1066 };
1067
1068 static const deUint8 s_unormShort10In[] =
1069 {
1070 0x80, 0x84, 0x40, 0x3b,
1071 0x40, 0xfd, 0x80, 0x1a,
1072 0x80, 0x0c, 0x80, 0x15,
1073 0x40, 0x11, 0x80, 0xc3,
1074 0x80, 0xc8, 0x80, 0xd5,
1075 0xc0, 0xf9, 0x00, 0x0a,
1076 0xc0, 0x39, 0x40, 0xd5,
1077 0xc0, 0x4d, 0xc0, 0x26
1078 };
1079 static const deUint32 s_unormShort10FloatRef[] =
1080 {
1081 0x3f04a128, 0x3e6d3b4f,
1082 0x3f7d7f60, 0x3dd4350d,
1083 0x3d48320d, 0x3dac2b0b,
1084 0x3d8a2289, 0x3f43b0ec,
1085 0x3f48b22d, 0x3f55b56d,
1086 0x3f79fe80, 0x3d20280a,
1087 0x3e6739ce, 0x3f55755d,
1088 0x3e9ba6ea, 0x3e1b26ca
1089 };
1090 static const deUint32 s_unormShort10UintRef[] =
1091 {
1092 0x212, 0x0ed, 0x3f5, 0x06a,
1093 0x032, 0x056, 0x045, 0x30e,
1094 0x322, 0x356, 0x3e7, 0x028,
1095 0x0e7, 0x355, 0x137, 0x09b,
1096 };
1097 static const deUint32 s_unormShort10IntRef[] =
1098 {
1099 0x212, 0x0ed, 0x3f5, 0x06a,
1100 0x032, 0x056, 0x045, 0x30e,
1101 0x322, 0x356, 0x3e7, 0x028,
1102 0x0e7, 0x355, 0x137, 0x09b,
1103 };
1104
1105 static const deUint8 s_unormShort12In[] =
1106 {
1107 0x30, 0x46, 0xf0, 0x38,
1108 0x90, 0x85, 0xf0, 0x88,
1109 0x90, 0x92, 0x30, 0x5d,
1110 0x30, 0x3a, 0x00, 0xc9,
1111 0x00, 0x64, 0xb0, 0x9b,
1112 0x20, 0x71, 0xd0, 0x5b,
1113 0xa0, 0xc5, 0x70, 0x27,
1114 0x30, 0x0b, 0xa0, 0x53
1115 };
1116 static const deUint32 s_unormShort12FloatRef[] =
1117 {
1118 0x3e8c68c7, 0x3e63ce3d,
1119 0x3f05985a, 0x3f08f890,
1120 0x3f12992a, 0x3eba6ba7,
1121 0x3e68ce8d, 0x3f490c91,
1122 0x3ec80c81, 0x3f1bb9bc,
1123 0x3ee24e25, 0x3eb7ab7b,
1124 0x3f45ac5b, 0x3e1dc9dd,
1125 0x3d330b31, 0x3ea74a75
1126 };
1127 static const deUint32 s_unormShort12UintRef[] =
1128 {
1129 0x463, 0x38f,
1130 0x859, 0x88f,
1131 0x929, 0x5d3,
1132 0x3a3, 0xc90,
1133 0x640, 0x9bb,
1134 0x712, 0x5bd,
1135 0xc5a, 0x277,
1136 0x0b3, 0x53a
1137 };
1138 static const deUint32 s_unormShort12IntRef[] =
1139 {
1140 0x463, 0x38f,
1141 0x859, 0x88f,
1142 0x929, 0x5d3,
1143 0x3a3, 0xc90,
1144 0x640, 0x9bb,
1145 0x712, 0x5bd,
1146 0xc5a, 0x277,
1147 0x0b3, 0x53a
1148 };
1149
1150 // \todo [2015-10-12 pyry] Collapse duplicate ref arrays
1151
1152 static const struct
1153 {
1154 const deUint8* input;
1155 const int inputSize;
1156 const deUint32* floatRef;
1157 const deUint32* intRef;
1158 const deUint32* uintRef;
1159 } s_formatData[] =
1160 {
1161 { s_snormInt8In, DE_LENGTH_OF_ARRAY(s_snormInt8In), s_snormInt8FloatRef, s_snormInt8IntRef, s_snormInt8UintRef },
1162 { s_snormInt16In, DE_LENGTH_OF_ARRAY(s_snormInt16In), s_snormInt16FloatRef, s_snormInt16IntRef, s_snormInt16UintRef },
1163 { s_snormInt32In, DE_LENGTH_OF_ARRAY(s_snormInt32In), s_snormInt32FloatRef, s_snormInt32IntRef, s_snormInt32UintRef },
1164 { s_unormInt8In, DE_LENGTH_OF_ARRAY(s_unormInt8In), s_unormInt8FloatRef, s_unormInt8IntRef, s_unormInt8UintRef },
1165 { s_unormInt16In, DE_LENGTH_OF_ARRAY(s_unormInt16In), s_unormInt16FloatRef, s_unormInt16IntRef, s_unormInt16UintRef },
1166 { s_unormInt24In, DE_LENGTH_OF_ARRAY(s_unormInt24In), s_unormInt24FloatRef, s_unormInt24IntRef, s_unormInt24UintRef },
1167 { s_unormInt32In, DE_LENGTH_OF_ARRAY(s_unormInt32In), s_unormInt32FloatRef, s_unormInt32IntRef, s_unormInt32UintRef },
1168 { s_unormByte44In, DE_LENGTH_OF_ARRAY(s_unormByte44In), s_unormByte44FloatRef, s_unormByte44IntRef, s_unormByte44IntRef },
1169 { s_unormShort565In, DE_LENGTH_OF_ARRAY(s_unormShort565In), s_unormShort565FloatRef, s_unormShort565IntRef, s_unormShort565IntRef, },
1170 { s_unormShort555In, DE_LENGTH_OF_ARRAY(s_unormShort555In), s_unormShort555FloatRef, s_unormShort555IntRef, s_unormShort555IntRef, },
1171 { s_unormShort4444In, DE_LENGTH_OF_ARRAY(s_unormShort4444In), s_unormShort4444FloatRef, s_unormShort4444IntRef, s_unormShort4444IntRef, },
1172 { s_unormShort5551In, DE_LENGTH_OF_ARRAY(s_unormShort5551In), s_unormShort5551FloatRef, s_unormShort5551IntRef, s_unormShort5551IntRef, },
1173 { s_unormShort1555In, DE_LENGTH_OF_ARRAY(s_unormShort1555In), s_unormShort1555FloatRef, s_unormShort1555IntRef, s_unormShort1555IntRef, },
1174 { s_unormInt101010In, DE_LENGTH_OF_ARRAY(s_unormInt101010In), s_unormInt101010FloatRef, s_unormInt101010IntRef, s_unormInt101010IntRef },
1175
1176 // \note Same input data & int reference used for {U,S}NORM_INT_1010102_REV
1177 { s_unormInt1010102RevIn, DE_LENGTH_OF_ARRAY(s_unormInt1010102RevIn), s_snormInt1010102RevFloatRef, s_snormInt1010102RevIntRef, s_snormInt1010102RevIntRef },
1178 { s_unormInt1010102RevIn, DE_LENGTH_OF_ARRAY(s_unormInt1010102RevIn), s_unormInt1010102RevFloatRef, s_unormInt1010102RevIntRef, s_unormInt1010102RevIntRef },
1179
1180 // \note UNSIGNED_BYTE_* and UNSIGNED_SHORT_* re-use input data and integer reference values from UNORM_* cases
1181 { s_unormByte44In, DE_LENGTH_OF_ARRAY(s_unormByte44In), s_unsignedByte44FloatRef, s_unormByte44IntRef, s_unormByte44IntRef },
1182 { s_unormShort565In, DE_LENGTH_OF_ARRAY(s_unormShort565In), s_unsignedShort565FloatRef, s_unormShort565IntRef, s_unormShort565IntRef, },
1183 { s_unormShort4444In, DE_LENGTH_OF_ARRAY(s_unormShort4444In), s_unsignedShort4444FloatRef, s_unormShort4444IntRef, s_unormShort4444IntRef, },
1184 { s_unormShort5551In, DE_LENGTH_OF_ARRAY(s_unormShort5551In), s_unsignedShort5551FloatRef, s_unormShort5551IntRef, s_unormShort5551IntRef, },
1185
1186 // \note (UN)SIGNED_INT_1010102_REV formats use same input data
1187 { s_unsignedInt1010102RevIn, DE_LENGTH_OF_ARRAY(s_unsignedInt1010102RevIn), s_signedInt1010102RevFloatRef, s_signedInt1010102RevIntRef, s_signedInt1010102RevIntRef },
1188 { s_unsignedInt1010102RevIn, DE_LENGTH_OF_ARRAY(s_unsignedInt1010102RevIn), s_unsignedInt1010102RevFloatRef, s_unsignedInt1010102RevIntRef, s_unsignedInt1010102RevIntRef },
1189
1190 { s_unsignedInt11f11f10fRevIn, DE_LENGTH_OF_ARRAY(s_unsignedInt11f11f10fRevIn), s_unsignedInt11f11f10fRevFloatRef, DE_NULL, DE_NULL },
1191 { s_unsignedInt999E5RevIn, DE_LENGTH_OF_ARRAY(s_unsignedInt999E5RevIn), s_unsignedInt999E5RevFloatRef, DE_NULL, DE_NULL },
1192 { s_unsignedInt1688In, DE_LENGTH_OF_ARRAY(s_unsignedInt1688In), s_unsignedInt1688FloatRef, DE_NULL, s_unsignedInt1688UintRef },
1193 { s_unsignedInt248In, DE_LENGTH_OF_ARRAY(s_unsignedInt248In), s_unsignedInt248FloatRef, DE_NULL, s_unsignedInt248UintRef },
1194 { s_unsignedInt248RevIn, DE_LENGTH_OF_ARRAY(s_unsignedInt248RevIn), s_unsignedInt248RevFloatRef, DE_NULL, s_unsignedInt248RevUintRef },
1195 { s_signedInt8In, DE_LENGTH_OF_ARRAY(s_signedInt8In), s_signedInt8FloatRef, s_signedInt8IntRef, s_signedInt8UintRef },
1196 { s_signedInt16In, DE_LENGTH_OF_ARRAY(s_signedInt16In), s_signedInt16FloatRef, s_signedInt16IntRef, s_signedInt16UintRef },
1197 { s_signedInt32In, DE_LENGTH_OF_ARRAY(s_signedInt32In), s_signedInt32FloatRef, s_signedInt32IntRef, s_signedInt32UintRef },
1198 { s_Int64In, DE_LENGTH_OF_ARRAY(s_Int64In), s_Int64FloatRef, s_Int64IntRef, s_Int64IntRef },
1199 { s_unsignedInt8In, DE_LENGTH_OF_ARRAY(s_unsignedInt8In), s_unsignedInt8FloatRef, s_unsignedInt8IntRef, s_unsignedInt8UintRef },
1200 { s_unsignedInt16In, DE_LENGTH_OF_ARRAY(s_unsignedInt16In), s_unsignedInt16FloatRef, s_unsignedInt16IntRef, s_unsignedInt16UintRef },
1201 { s_unsignedInt24In, DE_LENGTH_OF_ARRAY(s_unsignedInt24In), s_unsignedInt24FloatRef, s_unsignedInt24IntRef, s_unsignedInt24UintRef },
1202 { s_unsignedInt32In, DE_LENGTH_OF_ARRAY(s_unsignedInt32In), s_unsignedInt32FloatRef, s_unsignedInt32IntRef, s_unsignedInt32UintRef },
1203 { s_Int64In, DE_LENGTH_OF_ARRAY(s_Int64In), s_Int64FloatRef, s_Int64IntRef, s_Int64IntRef },
1204
1205 { s_halfFloatIn, DE_LENGTH_OF_ARRAY(s_halfFloatIn), s_halfFloatFloatRef, s_halfFloatIntRef, s_halfFloatUintRef },
1206 { s_floatIn, DE_LENGTH_OF_ARRAY(s_floatIn), s_floatFloatRef, s_floatIntRef, s_floatUintRef },
1207 { s_float64In, DE_LENGTH_OF_ARRAY(s_float64In), s_float64FloatRef, s_float64IntRef, s_float64IntRef },
1208 { s_floatUnsignedInt248RevIn, DE_LENGTH_OF_ARRAY(s_floatUnsignedInt248RevIn), s_floatUnsignedInt248RevFloatRef, DE_NULL, s_floatUnsignedInt248RevUintRef },
1209
1210 { s_unormShort10In, DE_LENGTH_OF_ARRAY(s_unormShort10In), s_unormShort10FloatRef, s_unormShort10IntRef, s_unormShort10UintRef },
1211 { s_unormShort12In, DE_LENGTH_OF_ARRAY(s_unormShort12In), s_unormShort12FloatRef, s_unormShort12IntRef, s_unormShort12UintRef },
1212
1213 { s_unsignedInt8In, DE_LENGTH_OF_ARRAY(s_unsignedInt8In), s_unsignedInt8FloatRef, s_unsignedInt8IntRef, s_unsignedInt8UintRef },
1214 { s_unsignedInt16In, DE_LENGTH_OF_ARRAY(s_unsignedInt16In), s_unsignedInt16FloatRef, s_unsignedInt16IntRef, s_unsignedInt16UintRef },
1215 { s_signedInt8In, DE_LENGTH_OF_ARRAY(s_signedInt8In), s_signedInt8FloatRef, s_signedInt8IntRef, s_signedInt8UintRef },
1216 { s_signedInt16In, DE_LENGTH_OF_ARRAY(s_signedInt16In), s_signedInt16FloatRef, s_signedInt16IntRef, s_signedInt16UintRef },
1217 { s_unsignedInt1010102RevIn, DE_LENGTH_OF_ARRAY(s_unsignedInt1010102RevIn), s_unsignedInt1010102RevFloatRef, s_unsignedInt1010102RevIntRef, s_unsignedInt1010102RevIntRef },
1218 { s_unsignedInt1010102RevIn, DE_LENGTH_OF_ARRAY(s_unsignedInt1010102RevIn), s_signedInt1010102RevFloatRef, s_signedInt1010102RevIntRef, s_signedInt1010102RevIntRef }
1219 };
1220 DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_formatData) == TextureFormat::CHANNELTYPE_LAST);
1221
getBaseFormat(TextureFormat format)1222 TextureFormat getBaseFormat (TextureFormat format)
1223 {
1224 const TextureFormat::ChannelOrder baseOrders[] = { TextureFormat::RGBA, TextureFormat::RGB, TextureFormat::DS };
1225
1226 for (int baseOrderNdx = 0; baseOrderNdx < DE_LENGTH_OF_ARRAY(baseOrders); baseOrderNdx++)
1227 {
1228 const TextureFormat curBaseFmt (baseOrders[baseOrderNdx], format.type);
1229 if (isValid(curBaseFmt))
1230 return curBaseFmt;
1231 }
1232
1233 return format;
1234 }
1235
getInputAccess(TextureFormat format)1236 ConstPixelBufferAccess getInputAccess (TextureFormat format)
1237 {
1238 const TextureFormat inputFormat = getBaseFormat(format);
1239 const int inputPixelSize = getPixelSize(inputFormat);
1240 const int numPixels = s_formatData[format.type].inputSize / inputPixelSize;
1241
1242 DE_ASSERT(numPixels == 4);
1243 DE_ASSERT(numPixels*inputPixelSize == s_formatData[format.type].inputSize);
1244
1245 return ConstPixelBufferAccess(format, IVec3(numPixels, 1, 1), IVec3(inputPixelSize, 0, 0), s_formatData[format.type].input);
1246 }
1247
1248 template<typename T>
1249 const deUint32* getRawReference (TextureFormat format);
1250
1251 template<>
getRawReference(TextureFormat format)1252 const deUint32* getRawReference<float> (TextureFormat format)
1253 {
1254 return s_formatData[format.type].floatRef;
1255 }
1256
1257 template<>
getRawReference(TextureFormat format)1258 const deUint32* getRawReference<deInt32> (TextureFormat format)
1259 {
1260 return s_formatData[format.type].intRef;
1261 }
1262
1263 template<>
getRawReference(TextureFormat format)1264 const deUint32* getRawReference<deUint32> (TextureFormat format)
1265 {
1266 return s_formatData[format.type].uintRef;
1267 }
1268
1269 template<typename T>
getReferenceValues(TextureFormat storageFormat,TextureFormat viewFormat,vector<Vector<T,4>> & dst)1270 void getReferenceValues (TextureFormat storageFormat, TextureFormat viewFormat, vector<Vector<T, 4> >& dst)
1271 {
1272 const int numPixels = getInputAccess(storageFormat).getWidth();
1273 const deUint32* const rawValues = getRawReference<T>(storageFormat);
1274 const tcu::TextureSwizzle& swizzle = tcu::getChannelReadSwizzle(viewFormat.order);
1275
1276 dst.resize(numPixels);
1277
1278 for (int pixelNdx = 0; pixelNdx < numPixels; pixelNdx++)
1279 {
1280 const deUint32* srcPixPtr = rawValues + pixelNdx*4;
1281 T* dstPixPtr = (T*)&dst[pixelNdx];
1282
1283 for (int c = 0; c < 4; c++)
1284 {
1285 switch (swizzle.components[c])
1286 {
1287 case tcu::TextureSwizzle::CHANNEL_0:
1288 case tcu::TextureSwizzle::CHANNEL_1:
1289 case tcu::TextureSwizzle::CHANNEL_2:
1290 case tcu::TextureSwizzle::CHANNEL_3:
1291 deMemcpy(dstPixPtr + c, srcPixPtr + (int)swizzle.components[c], sizeof(deUint32));
1292 break;
1293
1294 case tcu::TextureSwizzle::CHANNEL_ZERO:
1295 dstPixPtr[c] = T(0);
1296 break;
1297
1298 case tcu::TextureSwizzle::CHANNEL_ONE:
1299 dstPixPtr[c] = T(1);
1300 break;
1301
1302 default:
1303 DE_FATAL("Unknown swizzle");
1304 }
1305 }
1306 }
1307 }
1308
1309 template<typename T>
componentEqual(T a,T b)1310 bool componentEqual (T a, T b)
1311 {
1312 return a == b;
1313 }
1314
1315 template<>
componentEqual(float a,float b)1316 bool componentEqual<float> (float a, float b)
1317 {
1318 return (a == b) || (deFloatIsNaN(a) && deFloatIsNaN(b));
1319 }
1320
1321 template<typename T, int Size>
allComponentsEqual(const Vector<T,Size> & a,const Vector<T,Size> & b)1322 bool allComponentsEqual (const Vector<T, Size>& a, const Vector<T, Size>& b)
1323 {
1324 for (int ndx = 0; ndx < Size; ndx++)
1325 {
1326 if (!componentEqual(a[ndx], b[ndx]))
1327 return false;
1328 }
1329
1330 return true;
1331 }
1332
1333 template<typename T>
copyPixels(const ConstPixelBufferAccess & src,const PixelBufferAccess & dst)1334 void copyPixels (const ConstPixelBufferAccess& src, const PixelBufferAccess& dst)
1335 {
1336 for (int ndx = 0; ndx < src.getWidth(); ndx++)
1337 dst.setPixel(src.getPixelT<T>(ndx, 0, 0), ndx, 0, 0);
1338 }
1339
copyGetSetDepth(const ConstPixelBufferAccess & src,const PixelBufferAccess & dst)1340 void copyGetSetDepth (const ConstPixelBufferAccess& src, const PixelBufferAccess& dst)
1341 {
1342 for (int ndx = 0; ndx < src.getWidth(); ndx++)
1343 dst.setPixDepth(src.getPixDepth(ndx, 0, 0), ndx, 0, 0);
1344 }
1345
copyGetSetStencil(const ConstPixelBufferAccess & src,const PixelBufferAccess & dst)1346 void copyGetSetStencil (const ConstPixelBufferAccess& src, const PixelBufferAccess& dst)
1347 {
1348 for (int ndx = 0; ndx < src.getWidth(); ndx++)
1349 dst.setPixStencil(src.getPixStencil(ndx, 0, 0), ndx, 0, 0);
1350 }
1351
copyPixels(const ConstPixelBufferAccess & src,const PixelBufferAccess & dst)1352 void copyPixels (const ConstPixelBufferAccess& src, const PixelBufferAccess& dst)
1353 {
1354 switch (getTextureChannelClass(dst.getFormat().type))
1355 {
1356 case tcu::TEXTURECHANNELCLASS_FLOATING_POINT:
1357 case tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT:
1358 case tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT:
1359 copyPixels<float>(src, dst);
1360 break;
1361
1362 case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER:
1363 copyPixels<deInt32>(src, dst);
1364 break;
1365
1366 case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER:
1367 copyPixels<deUint32>(src, dst);
1368 break;
1369
1370 default:
1371 DE_FATAL("Unknown channel class");
1372 }
1373 }
1374
getTextureAccessTypeDescription(TextureAccessType type)1375 const char* getTextureAccessTypeDescription (TextureAccessType type)
1376 {
1377 static const char* s_desc[] =
1378 {
1379 "floating-point",
1380 "signed integer",
1381 "unsigned integer"
1382 };
1383 return de::getSizedArrayElement<tcu::TEXTUREACCESSTYPE_LAST>(s_desc, type);
1384 }
1385
1386 template<typename T>
1387 TextureAccessType getTextureAccessType (void);
1388
1389 template<>
getTextureAccessType(void)1390 TextureAccessType getTextureAccessType<float> (void)
1391 {
1392 return tcu::TEXTUREACCESSTYPE_FLOAT;
1393 }
1394
1395 template<>
getTextureAccessType(void)1396 TextureAccessType getTextureAccessType<deInt32> (void)
1397 {
1398 return tcu::TEXTUREACCESSTYPE_SIGNED_INT;
1399 }
1400
1401 template<>
getTextureAccessType(void)1402 TextureAccessType getTextureAccessType<deUint32> (void)
1403 {
1404 return tcu::TEXTUREACCESSTYPE_UNSIGNED_INT;
1405 }
1406
getCaseName(TextureFormat format)1407 static std::string getCaseName (TextureFormat format)
1408 {
1409 std::ostringstream str;
1410
1411 str << format.type << "_" << format.order;
1412
1413 return de::toLower(str.str());
1414 }
1415
1416 class TextureFormatCase : public tcu::TestCase
1417 {
1418 public:
TextureFormatCase(tcu::TestContext & testCtx,TextureFormat format)1419 TextureFormatCase (tcu::TestContext& testCtx, TextureFormat format)
1420 : tcu::TestCase (testCtx, getCaseName(format).c_str(), "")
1421 , m_format (format)
1422 {
1423 DE_ASSERT(isValid(format));
1424 }
1425
1426 protected:
1427 template<typename T>
verifyRead(const ConstPixelBufferAccess & src)1428 void verifyRead (const ConstPixelBufferAccess& src)
1429 {
1430 const int numPixels = src.getWidth();
1431 vector<Vector<T, 4> > res (numPixels);
1432 vector<Vector<T, 4> > ref;
1433
1434 m_testCtx.getLog()
1435 << TestLog::Message << "Verifying " << getTextureAccessTypeDescription(getTextureAccessType<T>()) << " access" << TestLog::EndMessage;
1436
1437 for (int ndx = 0; ndx < numPixels; ndx++)
1438 res[ndx] = src.getPixelT<T>(ndx, 0, 0);
1439
1440 // \note m_format != src.getFormat() for DS formats, and we specifically need to
1441 // use the combined format as storage format to get right reference values.
1442 getReferenceValues<T>(m_format, src.getFormat(), ref);
1443
1444 for (int pixelNdx = 0; pixelNdx < numPixels; pixelNdx++)
1445 {
1446 if (!allComponentsEqual(res[pixelNdx], ref[pixelNdx]))
1447 {
1448 m_testCtx.getLog()
1449 << TestLog::Message << "ERROR: at pixel " << pixelNdx << ": expected " << ref[pixelNdx] << ", got " << res[pixelNdx] << TestLog::EndMessage;
1450
1451 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Comparison failed");
1452 }
1453 }
1454 }
1455
verifyRead(const ConstPixelBufferAccess & src)1456 void verifyRead (const ConstPixelBufferAccess& src)
1457 {
1458 // \todo [2016-08-04 pyry] Overflow in float->int conversion is not defined and
1459 // produces different results depending on arch.
1460 const bool isFloat32Or64 = src.getFormat().type == tcu::TextureFormat::FLOAT ||
1461 src.getFormat().type == tcu::TextureFormat::FLOAT64;
1462
1463 if (isAccessValid(src.getFormat(), tcu::TEXTUREACCESSTYPE_FLOAT))
1464 verifyRead<float>(src);
1465
1466 if (isAccessValid(src.getFormat(), tcu::TEXTUREACCESSTYPE_UNSIGNED_INT) && !isFloat32Or64)
1467 verifyRead<deUint32>(src);
1468
1469 if (isAccessValid(src.getFormat(), tcu::TEXTUREACCESSTYPE_SIGNED_INT) && !isFloat32Or64)
1470 verifyRead<deInt32>(src);
1471 }
1472
verifyGetPixDepth(const ConstPixelBufferAccess & refAccess,const ConstPixelBufferAccess & combinedAccess)1473 void verifyGetPixDepth (const ConstPixelBufferAccess& refAccess, const ConstPixelBufferAccess& combinedAccess)
1474 {
1475 m_testCtx.getLog()
1476 << TestLog::Message << "Verifying getPixDepth()" << TestLog::EndMessage;
1477
1478 for (int pixelNdx = 0; pixelNdx < refAccess.getWidth(); pixelNdx++)
1479 {
1480 const float ref = refAccess.getPixel(pixelNdx, 0, 0).x();
1481 const float res = combinedAccess.getPixDepth(pixelNdx, 0, 0);
1482
1483 if (!componentEqual(res, ref))
1484 {
1485 m_testCtx.getLog()
1486 << TestLog::Message << "ERROR: at pixel " << pixelNdx << ": expected " << ref << ", got " << res << TestLog::EndMessage;
1487
1488 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Comparison failed");
1489 }
1490 }
1491 }
1492
verifyGetPixStencil(const ConstPixelBufferAccess & refAccess,const ConstPixelBufferAccess & combinedAccess)1493 void verifyGetPixStencil (const ConstPixelBufferAccess& refAccess, const ConstPixelBufferAccess& combinedAccess)
1494 {
1495 m_testCtx.getLog()
1496 << TestLog::Message << "Verifying getPixStencil()" << TestLog::EndMessage;
1497
1498 for (int pixelNdx = 0; pixelNdx < refAccess.getWidth(); pixelNdx++)
1499 {
1500 const int ref = refAccess.getPixelInt(pixelNdx, 0, 0).x();
1501 const int res = combinedAccess.getPixStencil(pixelNdx, 0, 0);
1502
1503 if (!componentEqual(res, ref))
1504 {
1505 m_testCtx.getLog()
1506 << TestLog::Message << "ERROR: at pixel " << pixelNdx << ": expected " << ref << ", got " << res << TestLog::EndMessage;
1507
1508 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Comparison failed");
1509 }
1510 }
1511 }
1512
verifyInfoQueries(void)1513 void verifyInfoQueries (void)
1514 {
1515 const tcu::TextureChannelClass chnClass = tcu::getTextureChannelClass(m_format.type);
1516 const tcu::TextureFormatInfo fmtInfo = tcu::getTextureFormatInfo(m_format);
1517
1518 if (tcu::isCombinedDepthStencilType(m_format.type))
1519 TCU_CHECK(chnClass == tcu::TEXTURECHANNELCLASS_LAST);
1520 else
1521 TCU_CHECK(de::inBounds(chnClass, (tcu::TextureChannelClass)0, tcu::TEXTURECHANNELCLASS_LAST));
1522
1523 DE_UNREF(fmtInfo);
1524 }
1525
1526 const TextureFormat m_format;
1527 };
1528
1529 class ColorFormatCase : public TextureFormatCase
1530 {
1531 public:
ColorFormatCase(tcu::TestContext & testCtx,TextureFormat format)1532 ColorFormatCase (tcu::TestContext& testCtx, TextureFormat format)
1533 : TextureFormatCase(testCtx, format)
1534 {
1535 DE_ASSERT(format.order != TextureFormat::D &&
1536 format.order != TextureFormat::S &&
1537 format.order != TextureFormat::DS);
1538 }
1539
iterate(void)1540 IterateResult iterate (void)
1541 {
1542 const ConstPixelBufferAccess inputAccess = getInputAccess(m_format);
1543 vector<deUint8> tmpMem (getPixelSize(inputAccess.getFormat())*inputAccess.getWidth());
1544 const PixelBufferAccess tmpAccess (inputAccess.getFormat(), inputAccess.getWidth(), 1, 1, &tmpMem[0]);
1545
1546 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
1547
1548 verifyInfoQueries();
1549
1550 verifyRead(inputAccess);
1551
1552 // \todo [2015-10-12 pyry] Handle lossy conversion with *NORM_INT32
1553 if (m_format.type != TextureFormat::UNORM_INT32 && m_format.type != TextureFormat::SNORM_INT32)
1554 {
1555 m_testCtx.getLog() << TestLog::Message << "Copying with getPixel() -> setPixel()" << TestLog::EndMessage;
1556 copyPixels(inputAccess, tmpAccess);
1557 verifyRead(tmpAccess);
1558 }
1559
1560 return STOP;
1561 }
1562 };
1563
1564 class DepthFormatCase : public TextureFormatCase
1565 {
1566 public:
DepthFormatCase(tcu::TestContext & testCtx,TextureFormat format)1567 DepthFormatCase (tcu::TestContext& testCtx, TextureFormat format)
1568 : TextureFormatCase(testCtx, format)
1569 {
1570 DE_ASSERT(format.order == TextureFormat::D);
1571 }
1572
iterate(void)1573 IterateResult iterate (void)
1574 {
1575 const ConstPixelBufferAccess inputAccess = getInputAccess(m_format);
1576 vector<deUint8> tmpMem (getPixelSize(inputAccess.getFormat())*inputAccess.getWidth());
1577 const PixelBufferAccess tmpAccess (inputAccess.getFormat(), inputAccess.getWidth(), 1, 1, &tmpMem[0]);
1578 const ConstPixelBufferAccess inputDepthAccess = getEffectiveDepthStencilAccess(inputAccess, tcu::Sampler::MODE_DEPTH);
1579 const PixelBufferAccess tmpDepthAccess = getEffectiveDepthStencilAccess(tmpAccess, tcu::Sampler::MODE_DEPTH);
1580
1581 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
1582
1583 verifyInfoQueries();
1584
1585 verifyRead(inputDepthAccess);
1586
1587 m_testCtx.getLog() << TestLog::Message << "Copying with getPixel() -> setPixel()" << TestLog::EndMessage;
1588 copyPixels(inputDepthAccess, tmpDepthAccess);
1589 verifyRead(tmpDepthAccess);
1590
1591 verifyGetPixDepth(inputDepthAccess, inputAccess);
1592
1593 m_testCtx.getLog() << TestLog::Message << "Copying both depth getPixDepth() -> setPixDepth()" << TestLog::EndMessage;
1594 tcu::clear(tmpDepthAccess, tcu::Vec4(0.0f));
1595 copyGetSetDepth(inputAccess, tmpAccess);
1596 verifyGetPixDepth(tmpDepthAccess, tmpAccess);
1597
1598 return STOP;
1599 }
1600 };
1601
1602 class StencilFormatCase : public TextureFormatCase
1603 {
1604 public:
StencilFormatCase(tcu::TestContext & testCtx,TextureFormat format)1605 StencilFormatCase (tcu::TestContext& testCtx, TextureFormat format)
1606 : TextureFormatCase(testCtx, format)
1607 {
1608 DE_ASSERT(format.order == TextureFormat::S);
1609 }
1610
iterate(void)1611 IterateResult iterate (void)
1612 {
1613 const ConstPixelBufferAccess inputAccess = getInputAccess(m_format);
1614 vector<deUint8> tmpMem (getPixelSize(inputAccess.getFormat())*inputAccess.getWidth());
1615 const PixelBufferAccess tmpAccess (inputAccess.getFormat(), inputAccess.getWidth(), 1, 1, &tmpMem[0]);
1616 const ConstPixelBufferAccess inputStencilAccess = getEffectiveDepthStencilAccess(inputAccess, tcu::Sampler::MODE_STENCIL);
1617 const PixelBufferAccess tmpStencilAccess = getEffectiveDepthStencilAccess(tmpAccess, tcu::Sampler::MODE_STENCIL);
1618
1619 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
1620
1621 verifyInfoQueries();
1622
1623 verifyRead(inputStencilAccess);
1624
1625 m_testCtx.getLog() << TestLog::Message << "Copying with getPixel() -> setPixel()" << TestLog::EndMessage;
1626 copyPixels(inputStencilAccess, tmpStencilAccess);
1627 verifyRead(tmpStencilAccess);
1628
1629 verifyGetPixStencil(inputStencilAccess, inputAccess);
1630
1631 m_testCtx.getLog() << TestLog::Message << "Copying both depth getPixStencil() -> setPixStencil()" << TestLog::EndMessage;
1632 tcu::clear(tmpStencilAccess, tcu::IVec4(0));
1633 copyGetSetStencil(inputAccess, tmpAccess);
1634 verifyGetPixStencil(tmpStencilAccess, tmpAccess);
1635
1636 return STOP;
1637 }
1638 };
1639
1640 class DepthStencilFormatCase : public TextureFormatCase
1641 {
1642 public:
DepthStencilFormatCase(tcu::TestContext & testCtx,TextureFormat format)1643 DepthStencilFormatCase (tcu::TestContext& testCtx, TextureFormat format)
1644 : TextureFormatCase(testCtx, format)
1645 {
1646 DE_ASSERT(format.order == TextureFormat::DS);
1647 }
1648
iterate(void)1649 IterateResult iterate (void)
1650 {
1651 const ConstPixelBufferAccess inputAccess = getInputAccess(m_format);
1652 vector<deUint8> tmpMem (getPixelSize(inputAccess.getFormat())*inputAccess.getWidth());
1653 const PixelBufferAccess tmpAccess (inputAccess.getFormat(), inputAccess.getWidth(), 1, 1, &tmpMem[0]);
1654 const ConstPixelBufferAccess inputDepthAccess = getEffectiveDepthStencilAccess(inputAccess, tcu::Sampler::MODE_DEPTH);
1655 const ConstPixelBufferAccess inputStencilAccess = getEffectiveDepthStencilAccess(inputAccess, tcu::Sampler::MODE_STENCIL);
1656 const PixelBufferAccess tmpDepthAccess = getEffectiveDepthStencilAccess(tmpAccess, tcu::Sampler::MODE_DEPTH);
1657 const PixelBufferAccess tmpStencilAccess = getEffectiveDepthStencilAccess(tmpAccess, tcu::Sampler::MODE_STENCIL);
1658
1659 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
1660
1661 verifyInfoQueries();
1662
1663 verifyRead(inputDepthAccess);
1664 verifyRead(inputStencilAccess);
1665
1666 verifyGetPixDepth(inputDepthAccess, inputAccess);
1667 verifyGetPixStencil(inputStencilAccess, inputAccess);
1668
1669 m_testCtx.getLog() << TestLog::Message << "Copying both depth and stencil with getPixel() -> setPixel()" << TestLog::EndMessage;
1670 copyPixels(inputDepthAccess, tmpDepthAccess);
1671 copyPixels(inputStencilAccess, tmpStencilAccess);
1672 verifyRead(tmpDepthAccess);
1673 verifyRead(tmpStencilAccess);
1674
1675 m_testCtx.getLog() << TestLog::Message << "Copying both depth and stencil with getPix{Depth,Stencil}() -> setPix{Depth,Stencil}()" << TestLog::EndMessage;
1676 copyGetSetDepth(inputDepthAccess, tmpDepthAccess);
1677 copyGetSetStencil(inputStencilAccess, tmpStencilAccess);
1678 verifyRead(tmpDepthAccess);
1679 verifyRead(tmpStencilAccess);
1680
1681 m_testCtx.getLog() << TestLog::Message << "Verifying that clearing depth component with clearDepth() doesn't affect stencil" << TestLog::EndMessage;
1682 tcu::copy(tmpAccess, inputAccess);
1683 tcu::clearDepth(tmpAccess, 0.0f);
1684 verifyRead(tmpStencilAccess);
1685
1686 m_testCtx.getLog() << TestLog::Message << "Verifying that clearing stencil component with clearStencil() doesn't affect depth" << TestLog::EndMessage;
1687 tcu::copy(tmpAccess, inputAccess);
1688 tcu::clearStencil(tmpAccess, 0);
1689 verifyRead(tmpDepthAccess);
1690
1691 m_testCtx.getLog() << TestLog::Message << "Verifying that clearing depth component with setPixDepth() doesn't affect stencil" << TestLog::EndMessage;
1692 tcu::copy(tmpAccess, inputAccess);
1693
1694 for (int ndx = 0; ndx < tmpAccess.getWidth(); ndx++)
1695 tmpAccess.setPixDepth(0.0f, ndx, 0, 0);
1696
1697 verifyRead(tmpStencilAccess);
1698
1699 m_testCtx.getLog() << TestLog::Message << "Verifying that clearing stencil component with setPixStencil() doesn't affect depth" << TestLog::EndMessage;
1700 tcu::copy(tmpAccess, inputAccess);
1701
1702 for (int ndx = 0; ndx < tmpAccess.getWidth(); ndx++)
1703 tmpAccess.setPixStencil(0, ndx, 0, 0);
1704
1705 verifyRead(tmpDepthAccess);
1706
1707 return STOP;
1708 }
1709 };
1710
1711 } // anonymous
1712
createTextureFormatTests(tcu::TestContext & testCtx)1713 tcu::TestCaseGroup* createTextureFormatTests (tcu::TestContext& testCtx)
1714 {
1715 de::MovePtr<tcu::TestCaseGroup> group (new tcu::TestCaseGroup(testCtx, "texture_format", "Texture format tests"));
1716
1717 for (int channelType = 0; channelType < TextureFormat::CHANNELTYPE_LAST; channelType++)
1718 {
1719 // \todo [2020-04-08] Missing tests for SIGNED_INT64 and UNSIGNED_INT64
1720 if (TextureFormat::SIGNED_INT64 == channelType || channelType == TextureFormat::UNSIGNED_INT64)
1721 continue;
1722
1723 for (int channelOrder = 0; channelOrder < TextureFormat::CHANNELORDER_LAST; channelOrder++)
1724 {
1725 const TextureFormat format ((TextureFormat::ChannelOrder)channelOrder, (TextureFormat::ChannelType)channelType);
1726
1727 if (!isValid(format))
1728 continue;
1729
1730 if (tcu::isSRGB(format))
1731 continue; // \todo [2015-10-12 pyry] Tests for sRGB formats (need thresholds)
1732
1733 if (format.order == TextureFormat::DS)
1734 group->addChild(new DepthStencilFormatCase(testCtx, format));
1735 else if (format.order == TextureFormat::D)
1736 group->addChild(new DepthFormatCase(testCtx, format));
1737 else if (format.order == TextureFormat::S)
1738 group->addChild(new StencilFormatCase(testCtx, format));
1739 else
1740 group->addChild(new ColorFormatCase(testCtx, format));
1741 }
1742 }
1743
1744 return group.release();
1745 }
1746
1747 } // dit
1748