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 39namespace dit 40{ 41 42namespace 43{ 44 45using std::string; 46using std::vector; 47 48using tcu::TestLog; 49using tcu::TextureFormat; 50using tcu::TextureChannelClass; 51using tcu::TextureAccessType; 52using tcu::PixelBufferAccess; 53using tcu::ConstPixelBufferAccess; 54using tcu::Vector; 55using tcu::IVec3; 56 57// Test data 58 59static 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}; 66static 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}; 73static 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}; 80static 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 88static 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}; 99static 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}; 106static 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}; 113static 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 121static 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}; 140static 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}; 147static 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}; 154static 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 162static 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}; 169static 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}; 176static 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}; 183static 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 191static 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}; 202static 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}; 209static 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}; 216static 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 224static 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}; 239static 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}; 246static 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}; 253static 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 261static 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}; 280static 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}; 287static 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}; 294static 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 302static const deUint8 s_unormByte44In[] = 303{ 304 0xdb, 0xa8, 0x29, 0x2d, 305}; 306static 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}; 313static 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}; 320static 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 328static const deUint8 s_unormShort565In[] = 329{ 330 0xea, 0x7e, 0xcc, 0x28, 331 0x38, 0xce, 0x8f, 0x16, 332}; 333static 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}; 340static 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}; 347static 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 355static const deUint8 s_unormShort555In[] = 356{ 357 0x02, 0xea, 0x89, 0x13, 358 0x94, 0x5a, 0x5b, 0x60, 359}; 360static 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}; 367static 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 375static const deUint8 s_unormShort4444In[] = 376{ 377 0x19, 0xdb, 0xa8, 0xa8, 378 0x72, 0x29, 0xb4, 0x2d, 379}; 380static 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}; 387static 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}; 394static 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 402static const deUint8 s_unormShort5551In[] = 403{ 404 0x13, 0x89, 0x6f, 0x3c, 405 0xae, 0xe9, 0xf2, 0xd9, 406}; 407static 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}; 414static 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}; 421static 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 429static const deUint8 s_unormShort1555In[] = 430{ 431 0xf8, 0xc5, 0x1f, 0x6c, 432 0xf0, 0x2f, 0xf2, 0x95, 433}; 434static 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}; 441static 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 449static 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}; 456static 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}; 463static 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 471static 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}; 478static 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}; 485static 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}; 492static 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}; 499static 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 507static 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}; 514static 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}; 521static 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}; 528static 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}; 535static 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 543static 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}; 550static 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 558static 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}; 565static 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 573static 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}; 580static 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}; 587static 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 595static 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}; 602static 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}; 609static 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 617static 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}; 624static 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}; 631static 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 639static 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}; 646static 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}; 653static 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}; 660static 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 668static 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}; 679static 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}; 686static 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}; 693static 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 701static 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}; 720static 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}; 727static 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}; 734static 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 742static 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}; 749static 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}; 756static 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}; 763static 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 771static 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}; 782static 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}; 789static 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}; 796static 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 804static 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}; 819static 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}; 826static 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}; 833static 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 841static 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}; 860static 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}; 867static 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}; 874static 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 882static const deUint8 s_halfFloatIn[] = 883{ 884 0x2b, 0x74, 0x6a, 0x5d, 885 0x1c, 0xb2, 0x9a, 0x4d, 886 0xad, 0x55, 0x22, 0x01, 887 0xce, 0x2d, 0x97, 0x0d, 888 0x71, 0x31, 0x42, 0x2b, 889 0xeb, 0x26, 0xc7, 0x16, 890 0x94, 0xd2, 0x22, 0x79, 891 0x89, 0xbd, 0xff, 0xbc, 892}; 893static const deUint32 s_halfFloatFloatRef[] = 894{ 895 0x46856000, 0x43ad4000, 0xbe438000, 0x41b34000, 896 0x42b5a000, 0x37910000, 0x3db9c000, 0x39b2e000, 897 0x3e2e2000, 0x3d684000, 0x3cdd6000, 0x3ad8e000, 898 0xc2528000, 0x47244000, 0xbfb12000, 0xbf9fe000, 899}; 900static const deUint32 s_halfFloatUintRef[] = 901{ 902 0x000042b0, 0x0000015a, 0x00000000, 0x00000016, 903 0x0000005a, 0x00000000, 0x00000000, 0x00000000, 904 0x00000000, 0x00000000, 0x00000000, 0x00000000, 905 0xffffffcc, 0x0000a440, 0xffffffff, 0xffffffff, 906}; 907static const deUint32 s_halfFloatIntRef[] = 908{ 909 0x000042b0, 0x0000015a, 0x00000000, 0x00000016, 910 0x0000005a, 0x00000000, 0x00000000, 0x00000000, 911 0x00000000, 0x00000000, 0x00000000, 0x00000000, 912 0xffffffcc, 0x0000a440, 0xffffffff, 0xffffffff, 913}; 914 915static const deUint8 s_floatIn[] = 916{ 917 0x92, 0xac, 0x68, 0x36, 918 0x9f, 0x42, 0x0b, 0x6e, 919 0x67, 0xcf, 0x0f, 0x20, 920 0x22, 0x6c, 0xe4, 0x0f, 921 0xb3, 0x72, 0xc8, 0x8a, 922 0x4b, 0x99, 0xc3, 0xb0, 923 0xbd, 0x78, 0x5c, 0x16, 924 0x1c, 0xce, 0xb7, 0x4e, 925 0x15, 0xdf, 0x37, 0xfd, 926 0xeb, 0x32, 0xe9, 0x47, 927 0x68, 0x1a, 0xaa, 0xd0, 928 0xb9, 0xba, 0x77, 0xe7, 929 0x81, 0x0a, 0x42, 0x5a, 930 0xb0, 0x5a, 0xee, 0x06, 931 0x77, 0xb4, 0x7b, 0x57, 932 0xf5, 0x35, 0xac, 0x56, 933}; 934static const deUint32 s_floatFloatRef[] = 935{ 936 0x3668ac92, 0x6e0b429f, 0x200fcf67, 0x0fe46c22, 937 0x8ac872b3, 0xb0c3994b, 0x165c78bd, 0x4eb7ce1c, 938 0xfd37df15, 0x47e932eb, 0xd0aa1a68, 0xe777bab9, 939 0x5a420a81, 0x06ee5ab0, 0x577bb477, 0x56ac35f5, 940}; 941static const deUint32 s_floatUintRef[] = 942{ 943 0x00000000, 0x80000000, 0x00000000, 0x00000000, 944 0x00000000, 0x00000000, 0x00000000, 0x5be70e00, 945 0x80000000, 0x0001d265, 0x80000000, 0x80000000, 946 0x80000000, 0x00000000, 0x80000000, 0x80000000, 947}; 948static const deUint32 s_floatIntRef[] = 949{ 950 0x00000000, 0x80000000, 0x00000000, 0x00000000, 951 0x00000000, 0x00000000, 0x00000000, 0x5be70e00, 952 0x80000000, 0x0001d265, 0x80000000, 0x80000000, 953 0x80000000, 0x00000000, 0x80000000, 0x80000000, 954}; 955 956static const deUint8 s_float64In[] = 957{ 958 0xbd, 0xb6, 0xc3, 0xd2, 959 0xf6, 0x62, 0x29, 0xd9, 960 0x2f, 0xc2, 0x46, 0x18, 961 0x6b, 0x0d, 0x0a, 0x53, 962 0x6d, 0x0c, 0xf3, 0x80, 963 0xbd, 0xa9, 0x12, 0x89, 964 0x6b, 0x9f, 0x3d, 0xdd, 965 0xb3, 0x91, 0xee, 0xf5, 966 0x92, 0xac, 0x68, 0x36, 967 0x9f, 0x42, 0x0b, 0x6e, 968 0x67, 0xcf, 0x0f, 0x20, 969 0x22, 0x6c, 0xe4, 0x0f, 970 0xb3, 0x72, 0xc8, 0x8a, 971 0x4b, 0x99, 0xc3, 0xb0, 972 0xbd, 0x78, 0x5c, 0x16, 973 0x1c, 0xce, 0xb7, 0x4e, 974 0x15, 0xdf, 0x37, 0xfd, 975 0xeb, 0x32, 0xe9, 0x47, 976 0x68, 0x1a, 0xaa, 0xd0, 977 0xb9, 0xba, 0x77, 0xe7, 978 0x81, 0x0a, 0x42, 0x5a, 979 0xb0, 0x5a, 0xee, 0x06, 980 0x77, 0xb4, 0x7b, 0x57, 981 0xf5, 0x35, 0xac, 0x56, 982 0x2b, 0x74, 0x6a, 0x5d, 983 0x1c, 0xb2, 0x9a, 0x4d, 984 0xad, 0x55, 0x22, 0x01, 985 0xce, 0x2d, 0x97, 0x0d, 986 0x71, 0x31, 0x42, 0x2b, 987 0xeb, 0x26, 0xc7, 0x16, 988 0x94, 0xd2, 0x22, 0x79, 989 0x89, 0xbd, 0xff, 0xbc, 990}; 991static const deUint32 s_float64FloatRef[] = 992{ 993 0xff800000, 0x7f800000, 0x80000000, 0xff800000, 994 0x7f800000, 0x00000000, 0x80000000, 0x7f800000, 995 0x7f499760, 0xff800000, 0x00000000, 0x7f800000, 996 0x7f800000, 0x00000000, 0x00000000, 0xa7fdec4c, 997}; 998static const deUint32 s_float64IntRef[] = 999{ 1000 0x80000000, 0x80000000, 0x00000000, 0x80000000, 1001 0x80000000, 0x00000000, 0x00000000, 0x80000000, 1002 0x80000000, 0x80000000, 0x00000000, 0x80000000, 1003 0x80000000, 0x00000000, 0x00000000, 0x00000000, 1004}; 1005 1006static const deUint8 s_floatUnsignedInt248RevIn[] = 1007{ 1008 0xbd, 0xb6, 0xc3, 0xd2, 1009 0xf6, 0x62, 0x29, 0xd9, 1010 0x2f, 0xc2, 0x46, 0x18, 1011 0x6b, 0x0d, 0x0a, 0x53, 1012 0x6d, 0x0c, 0xf3, 0x80, 1013 0xbd, 0xa9, 0x12, 0x89, 1014 0x6b, 0x9f, 0x3d, 0xdd, 1015 0xb3, 0x91, 0xee, 0xf5, 1016}; 1017static const deUint32 s_floatUnsignedInt248RevFloatRef[] = 1018{ 1019 0xd2c3b6bd, 0x00000000, 0x00000000, 0x3f800000, 1020 0x1846c22f, 0x00000000, 0x00000000, 0x3f800000, 1021 0x80f30c6d, 0x00000000, 0x00000000, 0x3f800000, 1022 0xdd3d9f6b, 0x00000000, 0x00000000, 0x3f800000, 1023}; 1024static const deUint32 s_floatUnsignedInt248RevUintRef[] = 1025{ 1026 0x000000f6, 0x00000000, 0x00000000, 0x00000001, 1027 0x0000006b, 0x00000000, 0x00000000, 0x00000001, 1028 0x000000bd, 0x00000000, 0x00000000, 0x00000001, 1029 0x000000b3, 0x00000000, 0x00000000, 0x00000001, 1030}; 1031 1032// \todo [2015-10-12 pyry] Collapse duplicate ref arrays 1033 1034static const struct 1035{ 1036 const deUint8* input; 1037 const int inputSize; 1038 const deUint32* floatRef; 1039 const deUint32* intRef; 1040 const deUint32* uintRef; 1041} s_formatData[] = 1042{ 1043 { s_snormInt8In, DE_LENGTH_OF_ARRAY(s_snormInt8In), s_snormInt8FloatRef, s_snormInt8IntRef, s_snormInt8UintRef }, 1044 { s_snormInt16In, DE_LENGTH_OF_ARRAY(s_snormInt16In), s_snormInt16FloatRef, s_snormInt16IntRef, s_snormInt16UintRef }, 1045 { s_snormInt32In, DE_LENGTH_OF_ARRAY(s_snormInt32In), s_snormInt32FloatRef, s_snormInt32IntRef, s_snormInt32UintRef }, 1046 { s_unormInt8In, DE_LENGTH_OF_ARRAY(s_unormInt8In), s_unormInt8FloatRef, s_unormInt8IntRef, s_unormInt8UintRef }, 1047 { s_unormInt16In, DE_LENGTH_OF_ARRAY(s_unormInt16In), s_unormInt16FloatRef, s_unormInt16IntRef, s_unormInt16UintRef }, 1048 { s_unormInt24In, DE_LENGTH_OF_ARRAY(s_unormInt24In), s_unormInt24FloatRef, s_unormInt24IntRef, s_unormInt24UintRef }, 1049 { s_unormInt32In, DE_LENGTH_OF_ARRAY(s_unormInt32In), s_unormInt32FloatRef, s_unormInt32IntRef, s_unormInt32UintRef }, 1050 { s_unormByte44In, DE_LENGTH_OF_ARRAY(s_unormByte44In), s_unormByte44FloatRef, s_unormByte44IntRef, s_unormByte44IntRef }, 1051 { s_unormShort565In, DE_LENGTH_OF_ARRAY(s_unormShort565In), s_unormShort565FloatRef, s_unormShort565IntRef, s_unormShort565IntRef, }, 1052 { s_unormShort555In, DE_LENGTH_OF_ARRAY(s_unormShort555In), s_unormShort555FloatRef, s_unormShort555IntRef, s_unormShort555IntRef, }, 1053 { s_unormShort4444In, DE_LENGTH_OF_ARRAY(s_unormShort4444In), s_unormShort4444FloatRef, s_unormShort4444IntRef, s_unormShort4444IntRef, }, 1054 { s_unormShort5551In, DE_LENGTH_OF_ARRAY(s_unormShort5551In), s_unormShort5551FloatRef, s_unormShort5551IntRef, s_unormShort5551IntRef, }, 1055 { s_unormShort1555In, DE_LENGTH_OF_ARRAY(s_unormShort1555In), s_unormShort1555FloatRef, s_unormShort1555IntRef, s_unormShort1555IntRef, }, 1056 { s_unormInt101010In, DE_LENGTH_OF_ARRAY(s_unormInt101010In), s_unormInt101010FloatRef, s_unormInt101010IntRef, s_unormInt101010IntRef }, 1057 1058 // \note Same input data & int reference used for {U,S}NORM_INT_1010102_REV 1059 { s_unormInt1010102RevIn, DE_LENGTH_OF_ARRAY(s_unormInt1010102RevIn), s_snormInt1010102RevFloatRef, s_snormInt1010102RevIntRef, s_snormInt1010102RevIntRef }, 1060 { s_unormInt1010102RevIn, DE_LENGTH_OF_ARRAY(s_unormInt1010102RevIn), s_unormInt1010102RevFloatRef, s_unormInt1010102RevIntRef, s_unormInt1010102RevIntRef }, 1061 1062 // \note UNSIGNED_BYTE_* and UNSIGNED_SHORT_* re-use input data and integer reference values from UNORM_* cases 1063 { s_unormByte44In, DE_LENGTH_OF_ARRAY(s_unormByte44In), s_unsignedByte44FloatRef, s_unormByte44IntRef, s_unormByte44IntRef }, 1064 { s_unormShort565In, DE_LENGTH_OF_ARRAY(s_unormShort565In), s_unsignedShort565FloatRef, s_unormShort565IntRef, s_unormShort565IntRef, }, 1065 { s_unormShort4444In, DE_LENGTH_OF_ARRAY(s_unormShort4444In), s_unsignedShort4444FloatRef, s_unormShort4444IntRef, s_unormShort4444IntRef, }, 1066 { s_unormShort5551In, DE_LENGTH_OF_ARRAY(s_unormShort5551In), s_unsignedShort5551FloatRef, s_unormShort5551IntRef, s_unormShort5551IntRef, }, 1067 1068 // \note (UN)SIGNED_INT_1010102_REV formats use same input data 1069 { s_unsignedInt1010102RevIn, DE_LENGTH_OF_ARRAY(s_unsignedInt1010102RevIn), s_signedInt1010102RevFloatRef, s_signedInt1010102RevIntRef, s_signedInt1010102RevIntRef }, 1070 { s_unsignedInt1010102RevIn, DE_LENGTH_OF_ARRAY(s_unsignedInt1010102RevIn), s_unsignedInt1010102RevFloatRef, s_unsignedInt1010102RevIntRef, s_unsignedInt1010102RevIntRef }, 1071 1072 { s_unsignedInt11f11f10fRevIn, DE_LENGTH_OF_ARRAY(s_unsignedInt11f11f10fRevIn), s_unsignedInt11f11f10fRevFloatRef, DE_NULL, DE_NULL }, 1073 { s_unsignedInt999E5RevIn, DE_LENGTH_OF_ARRAY(s_unsignedInt999E5RevIn), s_unsignedInt999E5RevFloatRef, DE_NULL, DE_NULL }, 1074 { s_unsignedInt1688In, DE_LENGTH_OF_ARRAY(s_unsignedInt1688In), s_unsignedInt1688FloatRef, DE_NULL, s_unsignedInt1688UintRef }, 1075 { s_unsignedInt248In, DE_LENGTH_OF_ARRAY(s_unsignedInt248In), s_unsignedInt248FloatRef, DE_NULL, s_unsignedInt248UintRef }, 1076 { s_unsignedInt248RevIn, DE_LENGTH_OF_ARRAY(s_unsignedInt248RevIn), s_unsignedInt248RevFloatRef, DE_NULL, s_unsignedInt248RevUintRef }, 1077 { s_signedInt8In, DE_LENGTH_OF_ARRAY(s_signedInt8In), s_signedInt8FloatRef, s_signedInt8IntRef, s_signedInt8UintRef }, 1078 { s_signedInt16In, DE_LENGTH_OF_ARRAY(s_signedInt16In), s_signedInt16FloatRef, s_signedInt16IntRef, s_signedInt16UintRef }, 1079 { s_signedInt32In, DE_LENGTH_OF_ARRAY(s_signedInt32In), s_signedInt32FloatRef, s_signedInt32IntRef, s_signedInt32UintRef }, 1080 { s_unsignedInt8In, DE_LENGTH_OF_ARRAY(s_unsignedInt8In), s_unsignedInt8FloatRef, s_unsignedInt8IntRef, s_unsignedInt8UintRef }, 1081 { s_unsignedInt16In, DE_LENGTH_OF_ARRAY(s_unsignedInt16In), s_unsignedInt16FloatRef, s_unsignedInt16IntRef, s_unsignedInt16UintRef }, 1082 { s_unsignedInt24In, DE_LENGTH_OF_ARRAY(s_unsignedInt24In), s_unsignedInt24FloatRef, s_unsignedInt24IntRef, s_unsignedInt24UintRef }, 1083 { s_unsignedInt32In, DE_LENGTH_OF_ARRAY(s_unsignedInt32In), s_unsignedInt32FloatRef, s_unsignedInt32IntRef, s_unsignedInt32UintRef }, 1084 { s_halfFloatIn, DE_LENGTH_OF_ARRAY(s_halfFloatIn), s_halfFloatFloatRef, s_halfFloatIntRef, s_halfFloatUintRef }, 1085 { s_floatIn, DE_LENGTH_OF_ARRAY(s_floatIn), s_floatFloatRef, s_floatIntRef, s_floatUintRef }, 1086 { s_float64In, DE_LENGTH_OF_ARRAY(s_float64In), s_float64FloatRef, s_float64IntRef, s_float64IntRef }, 1087 { s_floatUnsignedInt248RevIn, DE_LENGTH_OF_ARRAY(s_floatUnsignedInt248RevIn), s_floatUnsignedInt248RevFloatRef, DE_NULL, s_floatUnsignedInt248RevUintRef }, 1088}; 1089DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_formatData) == TextureFormat::CHANNELTYPE_LAST); 1090 1091TextureFormat getBaseFormat (TextureFormat format) 1092{ 1093 const TextureFormat::ChannelOrder baseOrders[] = { TextureFormat::RGBA, TextureFormat::RGB, TextureFormat::DS }; 1094 1095 for (int baseOrderNdx = 0; baseOrderNdx < DE_LENGTH_OF_ARRAY(baseOrders); baseOrderNdx++) 1096 { 1097 const TextureFormat curBaseFmt (baseOrders[baseOrderNdx], format.type); 1098 if (isValid(curBaseFmt)) 1099 return curBaseFmt; 1100 } 1101 1102 return format; 1103} 1104 1105ConstPixelBufferAccess getInputAccess (TextureFormat format) 1106{ 1107 const TextureFormat inputFormat = getBaseFormat(format); 1108 const int inputPixelSize = getPixelSize(inputFormat); 1109 const int numPixels = s_formatData[format.type].inputSize / inputPixelSize; 1110 1111 DE_ASSERT(numPixels == 4); 1112 DE_ASSERT(numPixels*inputPixelSize == s_formatData[format.type].inputSize); 1113 1114 return ConstPixelBufferAccess(format, IVec3(numPixels, 1, 1), IVec3(inputPixelSize, 0, 0), s_formatData[format.type].input); 1115} 1116 1117template<typename T> 1118const deUint32* getRawReference (TextureFormat format); 1119 1120template<> 1121const deUint32* getRawReference<float> (TextureFormat format) 1122{ 1123 return s_formatData[format.type].floatRef; 1124} 1125 1126template<> 1127const deUint32* getRawReference<deInt32> (TextureFormat format) 1128{ 1129 return s_formatData[format.type].intRef; 1130} 1131 1132template<> 1133const deUint32* getRawReference<deUint32> (TextureFormat format) 1134{ 1135 return s_formatData[format.type].uintRef; 1136} 1137 1138template<typename T> 1139void getReferenceValues (TextureFormat storageFormat, TextureFormat viewFormat, vector<Vector<T, 4> >& dst) 1140{ 1141 const int numPixels = getInputAccess(storageFormat).getWidth(); 1142 const deUint32* const rawValues = getRawReference<T>(storageFormat); 1143 const tcu::TextureSwizzle& swizzle = tcu::getChannelReadSwizzle(viewFormat.order); 1144 1145 dst.resize(numPixels); 1146 1147 for (int pixelNdx = 0; pixelNdx < numPixels; pixelNdx++) 1148 { 1149 const deUint32* srcPixPtr = rawValues + pixelNdx*4; 1150 T* dstPixPtr = (T*)&dst[pixelNdx]; 1151 1152 for (int c = 0; c < 4; c++) 1153 { 1154 switch (swizzle.components[c]) 1155 { 1156 case tcu::TextureSwizzle::CHANNEL_0: 1157 case tcu::TextureSwizzle::CHANNEL_1: 1158 case tcu::TextureSwizzle::CHANNEL_2: 1159 case tcu::TextureSwizzle::CHANNEL_3: 1160 deMemcpy(dstPixPtr + c, srcPixPtr + (int)swizzle.components[c], sizeof(deUint32)); 1161 break; 1162 1163 case tcu::TextureSwizzle::CHANNEL_ZERO: 1164 dstPixPtr[c] = T(0); 1165 break; 1166 1167 case tcu::TextureSwizzle::CHANNEL_ONE: 1168 dstPixPtr[c] = T(1); 1169 break; 1170 1171 default: 1172 DE_FATAL("Unknown swizzle"); 1173 } 1174 } 1175 } 1176} 1177 1178template<typename T> 1179bool componentEqual (T a, T b) 1180{ 1181 return a == b; 1182} 1183 1184template<> 1185bool componentEqual<float> (float a, float b) 1186{ 1187 return (a == b) || (deFloatIsNaN(a) && deFloatIsNaN(b)); 1188} 1189 1190template<typename T, int Size> 1191bool allComponentsEqual (const Vector<T, Size>& a, const Vector<T, Size>& b) 1192{ 1193 for (int ndx = 0; ndx < Size; ndx++) 1194 { 1195 if (!componentEqual(a[ndx], b[ndx])) 1196 return false; 1197 } 1198 1199 return true; 1200} 1201 1202template<typename T> 1203void copyPixels (const ConstPixelBufferAccess& src, const PixelBufferAccess& dst) 1204{ 1205 for (int ndx = 0; ndx < src.getWidth(); ndx++) 1206 dst.setPixel(src.getPixelT<T>(ndx, 0, 0), ndx, 0, 0); 1207} 1208 1209void copyGetSetDepth (const ConstPixelBufferAccess& src, const PixelBufferAccess& dst) 1210{ 1211 for (int ndx = 0; ndx < src.getWidth(); ndx++) 1212 dst.setPixDepth(src.getPixDepth(ndx, 0, 0), ndx, 0, 0); 1213} 1214 1215void copyGetSetStencil (const ConstPixelBufferAccess& src, const PixelBufferAccess& dst) 1216{ 1217 for (int ndx = 0; ndx < src.getWidth(); ndx++) 1218 dst.setPixStencil(src.getPixStencil(ndx, 0, 0), ndx, 0, 0); 1219} 1220 1221void copyPixels (const ConstPixelBufferAccess& src, const PixelBufferAccess& dst) 1222{ 1223 switch (getTextureChannelClass(dst.getFormat().type)) 1224 { 1225 case tcu::TEXTURECHANNELCLASS_FLOATING_POINT: 1226 case tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT: 1227 case tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT: 1228 copyPixels<float>(src, dst); 1229 break; 1230 1231 case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER: 1232 copyPixels<deInt32>(src, dst); 1233 break; 1234 1235 case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER: 1236 copyPixels<deUint32>(src, dst); 1237 break; 1238 1239 default: 1240 DE_FATAL("Unknown channel class"); 1241 } 1242} 1243 1244const char* getTextureAccessTypeDescription (TextureAccessType type) 1245{ 1246 static const char* s_desc[] = 1247 { 1248 "floating-point", 1249 "signed integer", 1250 "unsigned integer" 1251 }; 1252 return de::getSizedArrayElement<tcu::TEXTUREACCESSTYPE_LAST>(s_desc, type); 1253} 1254 1255template<typename T> 1256TextureAccessType getTextureAccessType (void); 1257 1258template<> 1259TextureAccessType getTextureAccessType<float> (void) 1260{ 1261 return tcu::TEXTUREACCESSTYPE_FLOAT; 1262} 1263 1264template<> 1265TextureAccessType getTextureAccessType<deInt32> (void) 1266{ 1267 return tcu::TEXTUREACCESSTYPE_SIGNED_INT; 1268} 1269 1270template<> 1271TextureAccessType getTextureAccessType<deUint32> (void) 1272{ 1273 return tcu::TEXTUREACCESSTYPE_UNSIGNED_INT; 1274} 1275 1276static std::string getCaseName (TextureFormat format) 1277{ 1278 std::ostringstream str; 1279 1280 str << format.type << "_" << format.order; 1281 1282 return de::toLower(str.str()); 1283} 1284 1285class TextureFormatCase : public tcu::TestCase 1286{ 1287public: 1288 TextureFormatCase (tcu::TestContext& testCtx, TextureFormat format) 1289 : tcu::TestCase (testCtx, getCaseName(format).c_str(), "") 1290 , m_format (format) 1291 { 1292 DE_ASSERT(isValid(format)); 1293 } 1294 1295protected: 1296 template<typename T> 1297 void verifyRead (const ConstPixelBufferAccess& src) 1298 { 1299 const int numPixels = src.getWidth(); 1300 vector<Vector<T, 4> > res (numPixels); 1301 vector<Vector<T, 4> > ref; 1302 1303 m_testCtx.getLog() 1304 << TestLog::Message << "Verifying " << getTextureAccessTypeDescription(getTextureAccessType<T>()) << " access" << TestLog::EndMessage; 1305 1306 for (int ndx = 0; ndx < numPixels; ndx++) 1307 res[ndx] = src.getPixelT<T>(ndx, 0, 0); 1308 1309 // \note m_format != src.getFormat() for DS formats, and we specifically need to 1310 // use the combined format as storage format to get right reference values. 1311 getReferenceValues<T>(m_format, src.getFormat(), ref); 1312 1313 for (int pixelNdx = 0; pixelNdx < numPixels; pixelNdx++) 1314 { 1315 if (!allComponentsEqual(res[pixelNdx], ref[pixelNdx])) 1316 { 1317 m_testCtx.getLog() 1318 << TestLog::Message << "ERROR: at pixel " << pixelNdx << ": expected " << ref[pixelNdx] << ", got " << res[pixelNdx] << TestLog::EndMessage; 1319 1320 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Comparison failed"); 1321 } 1322 } 1323 } 1324 1325 void verifyRead (const ConstPixelBufferAccess& src) 1326 { 1327 // \todo [2016-08-04 pyry] Overflow in float->int conversion is not defined and 1328 // produces different results depending on arch. 1329 const bool isFloat32Or64 = src.getFormat().type == tcu::TextureFormat::FLOAT || 1330 src.getFormat().type == tcu::TextureFormat::FLOAT64; 1331 1332 if (isAccessValid(src.getFormat(), tcu::TEXTUREACCESSTYPE_FLOAT)) 1333 verifyRead<float>(src); 1334 1335 if (isAccessValid(src.getFormat(), tcu::TEXTUREACCESSTYPE_UNSIGNED_INT) && !isFloat32Or64) 1336 verifyRead<deUint32>(src); 1337 1338 if (isAccessValid(src.getFormat(), tcu::TEXTUREACCESSTYPE_SIGNED_INT) && !isFloat32Or64) 1339 verifyRead<deInt32>(src); 1340 } 1341 1342 void verifyGetPixDepth (const ConstPixelBufferAccess& refAccess, const ConstPixelBufferAccess& combinedAccess) 1343 { 1344 m_testCtx.getLog() 1345 << TestLog::Message << "Verifying getPixDepth()" << TestLog::EndMessage; 1346 1347 for (int pixelNdx = 0; pixelNdx < refAccess.getWidth(); pixelNdx++) 1348 { 1349 const float ref = refAccess.getPixel(pixelNdx, 0, 0).x(); 1350 const float res = combinedAccess.getPixDepth(pixelNdx, 0, 0); 1351 1352 if (!componentEqual(res, ref)) 1353 { 1354 m_testCtx.getLog() 1355 << TestLog::Message << "ERROR: at pixel " << pixelNdx << ": expected " << ref << ", got " << res << TestLog::EndMessage; 1356 1357 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Comparison failed"); 1358 } 1359 } 1360 } 1361 1362 void verifyGetPixStencil (const ConstPixelBufferAccess& refAccess, const ConstPixelBufferAccess& combinedAccess) 1363 { 1364 m_testCtx.getLog() 1365 << TestLog::Message << "Verifying getPixStencil()" << TestLog::EndMessage; 1366 1367 for (int pixelNdx = 0; pixelNdx < refAccess.getWidth(); pixelNdx++) 1368 { 1369 const int ref = refAccess.getPixelInt(pixelNdx, 0, 0).x(); 1370 const int res = combinedAccess.getPixStencil(pixelNdx, 0, 0); 1371 1372 if (!componentEqual(res, ref)) 1373 { 1374 m_testCtx.getLog() 1375 << TestLog::Message << "ERROR: at pixel " << pixelNdx << ": expected " << ref << ", got " << res << TestLog::EndMessage; 1376 1377 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Comparison failed"); 1378 } 1379 } 1380 } 1381 1382 void verifyInfoQueries (void) 1383 { 1384 const tcu::TextureChannelClass chnClass = tcu::getTextureChannelClass(m_format.type); 1385 const tcu::TextureFormatInfo fmtInfo = tcu::getTextureFormatInfo(m_format); 1386 1387 if (tcu::isCombinedDepthStencilType(m_format.type)) 1388 TCU_CHECK(chnClass == tcu::TEXTURECHANNELCLASS_LAST); 1389 else 1390 TCU_CHECK(de::inBounds(chnClass, (tcu::TextureChannelClass)0, tcu::TEXTURECHANNELCLASS_LAST)); 1391 1392 DE_UNREF(fmtInfo); 1393 } 1394 1395 const TextureFormat m_format; 1396}; 1397 1398class ColorFormatCase : public TextureFormatCase 1399{ 1400public: 1401 ColorFormatCase (tcu::TestContext& testCtx, TextureFormat format) 1402 : TextureFormatCase(testCtx, format) 1403 { 1404 DE_ASSERT(format.order != TextureFormat::D && 1405 format.order != TextureFormat::S && 1406 format.order != TextureFormat::DS); 1407 } 1408 1409 IterateResult iterate (void) 1410 { 1411 const ConstPixelBufferAccess inputAccess = getInputAccess(m_format); 1412 vector<deUint8> tmpMem (getPixelSize(inputAccess.getFormat())*inputAccess.getWidth()); 1413 const PixelBufferAccess tmpAccess (inputAccess.getFormat(), inputAccess.getWidth(), 1, 1, &tmpMem[0]); 1414 1415 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 1416 1417 verifyInfoQueries(); 1418 1419 verifyRead(inputAccess); 1420 1421 // \todo [2015-10-12 pyry] Handle lossy conversion with *NORM_INT32 1422 if (m_format.type != TextureFormat::UNORM_INT32 && m_format.type != TextureFormat::SNORM_INT32) 1423 { 1424 m_testCtx.getLog() << TestLog::Message << "Copying with getPixel() -> setPixel()" << TestLog::EndMessage; 1425 copyPixels(inputAccess, tmpAccess); 1426 verifyRead(tmpAccess); 1427 } 1428 1429 return STOP; 1430 } 1431}; 1432 1433class DepthFormatCase : public TextureFormatCase 1434{ 1435public: 1436 DepthFormatCase (tcu::TestContext& testCtx, TextureFormat format) 1437 : TextureFormatCase(testCtx, format) 1438 { 1439 DE_ASSERT(format.order == TextureFormat::D); 1440 } 1441 1442 IterateResult iterate (void) 1443 { 1444 const ConstPixelBufferAccess inputAccess = getInputAccess(m_format); 1445 vector<deUint8> tmpMem (getPixelSize(inputAccess.getFormat())*inputAccess.getWidth()); 1446 const PixelBufferAccess tmpAccess (inputAccess.getFormat(), inputAccess.getWidth(), 1, 1, &tmpMem[0]); 1447 const ConstPixelBufferAccess inputDepthAccess = getEffectiveDepthStencilAccess(inputAccess, tcu::Sampler::MODE_DEPTH); 1448 const PixelBufferAccess tmpDepthAccess = getEffectiveDepthStencilAccess(tmpAccess, tcu::Sampler::MODE_DEPTH); 1449 1450 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 1451 1452 verifyInfoQueries(); 1453 1454 verifyRead(inputDepthAccess); 1455 1456 m_testCtx.getLog() << TestLog::Message << "Copying with getPixel() -> setPixel()" << TestLog::EndMessage; 1457 copyPixels(inputDepthAccess, tmpDepthAccess); 1458 verifyRead(tmpDepthAccess); 1459 1460 verifyGetPixDepth(inputDepthAccess, inputAccess); 1461 1462 m_testCtx.getLog() << TestLog::Message << "Copying both depth getPixDepth() -> setPixDepth()" << TestLog::EndMessage; 1463 tcu::clear(tmpDepthAccess, tcu::Vec4(0.0f)); 1464 copyGetSetDepth(inputAccess, tmpAccess); 1465 verifyGetPixDepth(tmpDepthAccess, tmpAccess); 1466 1467 return STOP; 1468 } 1469}; 1470 1471class StencilFormatCase : public TextureFormatCase 1472{ 1473public: 1474 StencilFormatCase (tcu::TestContext& testCtx, TextureFormat format) 1475 : TextureFormatCase(testCtx, format) 1476 { 1477 DE_ASSERT(format.order == TextureFormat::S); 1478 } 1479 1480 IterateResult iterate (void) 1481 { 1482 const ConstPixelBufferAccess inputAccess = getInputAccess(m_format); 1483 vector<deUint8> tmpMem (getPixelSize(inputAccess.getFormat())*inputAccess.getWidth()); 1484 const PixelBufferAccess tmpAccess (inputAccess.getFormat(), inputAccess.getWidth(), 1, 1, &tmpMem[0]); 1485 const ConstPixelBufferAccess inputStencilAccess = getEffectiveDepthStencilAccess(inputAccess, tcu::Sampler::MODE_STENCIL); 1486 const PixelBufferAccess tmpStencilAccess = getEffectiveDepthStencilAccess(tmpAccess, tcu::Sampler::MODE_STENCIL); 1487 1488 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 1489 1490 verifyInfoQueries(); 1491 1492 verifyRead(inputStencilAccess); 1493 1494 m_testCtx.getLog() << TestLog::Message << "Copying with getPixel() -> setPixel()" << TestLog::EndMessage; 1495 copyPixels(inputStencilAccess, tmpStencilAccess); 1496 verifyRead(tmpStencilAccess); 1497 1498 verifyGetPixStencil(inputStencilAccess, inputAccess); 1499 1500 m_testCtx.getLog() << TestLog::Message << "Copying both depth getPixStencil() -> setPixStencil()" << TestLog::EndMessage; 1501 tcu::clear(tmpStencilAccess, tcu::IVec4(0)); 1502 copyGetSetStencil(inputAccess, tmpAccess); 1503 verifyGetPixStencil(tmpStencilAccess, tmpAccess); 1504 1505 return STOP; 1506 } 1507}; 1508 1509class DepthStencilFormatCase : public TextureFormatCase 1510{ 1511public: 1512 DepthStencilFormatCase (tcu::TestContext& testCtx, TextureFormat format) 1513 : TextureFormatCase(testCtx, format) 1514 { 1515 DE_ASSERT(format.order == TextureFormat::DS); 1516 } 1517 1518 IterateResult iterate (void) 1519 { 1520 const ConstPixelBufferAccess inputAccess = getInputAccess(m_format); 1521 vector<deUint8> tmpMem (getPixelSize(inputAccess.getFormat())*inputAccess.getWidth()); 1522 const PixelBufferAccess tmpAccess (inputAccess.getFormat(), inputAccess.getWidth(), 1, 1, &tmpMem[0]); 1523 const ConstPixelBufferAccess inputDepthAccess = getEffectiveDepthStencilAccess(inputAccess, tcu::Sampler::MODE_DEPTH); 1524 const ConstPixelBufferAccess inputStencilAccess = getEffectiveDepthStencilAccess(inputAccess, tcu::Sampler::MODE_STENCIL); 1525 const PixelBufferAccess tmpDepthAccess = getEffectiveDepthStencilAccess(tmpAccess, tcu::Sampler::MODE_DEPTH); 1526 const PixelBufferAccess tmpStencilAccess = getEffectiveDepthStencilAccess(tmpAccess, tcu::Sampler::MODE_STENCIL); 1527 1528 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 1529 1530 verifyInfoQueries(); 1531 1532 verifyRead(inputDepthAccess); 1533 verifyRead(inputStencilAccess); 1534 1535 verifyGetPixDepth(inputDepthAccess, inputAccess); 1536 verifyGetPixStencil(inputStencilAccess, inputAccess); 1537 1538 m_testCtx.getLog() << TestLog::Message << "Copying both depth and stencil with getPixel() -> setPixel()" << TestLog::EndMessage; 1539 copyPixels(inputDepthAccess, tmpDepthAccess); 1540 copyPixels(inputStencilAccess, tmpStencilAccess); 1541 verifyRead(tmpDepthAccess); 1542 verifyRead(tmpStencilAccess); 1543 1544 m_testCtx.getLog() << TestLog::Message << "Copying both depth and stencil with getPix{Depth,Stencil}() -> setPix{Depth,Stencil}()" << TestLog::EndMessage; 1545 copyGetSetDepth(inputDepthAccess, tmpDepthAccess); 1546 copyGetSetStencil(inputStencilAccess, tmpStencilAccess); 1547 verifyRead(tmpDepthAccess); 1548 verifyRead(tmpStencilAccess); 1549 1550 m_testCtx.getLog() << TestLog::Message << "Verifying that clearing depth component with clearDepth() doesn't affect stencil" << TestLog::EndMessage; 1551 tcu::copy(tmpAccess, inputAccess); 1552 tcu::clearDepth(tmpAccess, 0.0f); 1553 verifyRead(tmpStencilAccess); 1554 1555 m_testCtx.getLog() << TestLog::Message << "Verifying that clearing stencil component with clearStencil() doesn't affect depth" << TestLog::EndMessage; 1556 tcu::copy(tmpAccess, inputAccess); 1557 tcu::clearStencil(tmpAccess, 0); 1558 verifyRead(tmpDepthAccess); 1559 1560 m_testCtx.getLog() << TestLog::Message << "Verifying that clearing depth component with setPixDepth() doesn't affect stencil" << TestLog::EndMessage; 1561 tcu::copy(tmpAccess, inputAccess); 1562 1563 for (int ndx = 0; ndx < tmpAccess.getWidth(); ndx++) 1564 tmpAccess.setPixDepth(0.0f, ndx, 0, 0); 1565 1566 verifyRead(tmpStencilAccess); 1567 1568 m_testCtx.getLog() << TestLog::Message << "Verifying that clearing stencil component with setPixStencil() doesn't affect depth" << TestLog::EndMessage; 1569 tcu::copy(tmpAccess, inputAccess); 1570 1571 for (int ndx = 0; ndx < tmpAccess.getWidth(); ndx++) 1572 tmpAccess.setPixStencil(0, ndx, 0, 0); 1573 1574 verifyRead(tmpDepthAccess); 1575 1576 return STOP; 1577 } 1578}; 1579 1580} // anonymous 1581 1582tcu::TestCaseGroup* createTextureFormatTests (tcu::TestContext& testCtx) 1583{ 1584 de::MovePtr<tcu::TestCaseGroup> group (new tcu::TestCaseGroup(testCtx, "texture_format", "Texture format tests")); 1585 1586 for (int channelType = 0; channelType < TextureFormat::CHANNELTYPE_LAST; channelType++) 1587 { 1588 for (int channelOrder = 0; channelOrder < TextureFormat::CHANNELORDER_LAST; channelOrder++) 1589 { 1590 const TextureFormat format ((TextureFormat::ChannelOrder)channelOrder, (TextureFormat::ChannelType)channelType); 1591 1592 if (!isValid(format)) 1593 continue; 1594 1595 if (tcu::isSRGB(format)) 1596 continue; // \todo [2015-10-12 pyry] Tests for sRGB formats (need thresholds) 1597 1598 if (format.order == TextureFormat::DS) 1599 group->addChild(new DepthStencilFormatCase(testCtx, format)); 1600 else if (format.order == TextureFormat::D) 1601 group->addChild(new DepthFormatCase(testCtx, format)); 1602 else if (format.order == TextureFormat::S) 1603 group->addChild(new StencilFormatCase(testCtx, format)); 1604 else 1605 group->addChild(new ColorFormatCase(testCtx, format)); 1606 } 1607 } 1608 1609 return group.release(); 1610} 1611 1612} // dit 1613