modules/internal/ditTextureFormatTests.cpp

   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
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
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<>
1252 const deUint32* getRawReference<float> (TextureFormat format)
1253 {
1254         return s_formatData[format.type].floatRef;
1255 }
1256
1257 template<>
1258 const deUint32* getRawReference<deInt32> (TextureFormat format)
1259 {
1260         return s_formatData[format.type].intRef;
1261 }
1262
1263 template<>
1264 const deUint32* getRawReference<deUint32> (TextureFormat format)
1265 {
1266         return s_formatData[format.type].uintRef;
1267 }
1268
1269 template<typename T>
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>
1310 bool componentEqual (T a, T b)
1311 {
1312         return a == b;
1313 }
1314
1315 template<>
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>
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>
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
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
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
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
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<>
1390 TextureAccessType getTextureAccessType<float> (void)
1391 {
1392         return tcu::TEXTUREACCESSTYPE_FLOAT;
1393 }
1394
1395 template<>
1396 TextureAccessType getTextureAccessType<deInt32> (void)
1397 {
1398         return tcu::TEXTUREACCESSTYPE_SIGNED_INT;
1399 }
1400
1401 template<>
1402 TextureAccessType getTextureAccessType<deUint32> (void)
1403 {
1404         return tcu::TEXTUREACCESSTYPE_UNSIGNED_INT;
1405 }
1406
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:
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>
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
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
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
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
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:
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
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:
1567         DepthFormatCase (tcu::TestContext& testCtx, TextureFormat format)
1568                 : TextureFormatCase(testCtx, format)
1569         {
1570                 DE_ASSERT(format.order == TextureFormat::D);
1571         }
1572
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:
1605         StencilFormatCase (tcu::TestContext& testCtx, TextureFormat format)
1606                 : TextureFormatCase(testCtx, format)
1607         {
1608                 DE_ASSERT(format.order == TextureFormat::S);
1609         }
1610
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:
1643         DepthStencilFormatCase (tcu::TestContext& testCtx, TextureFormat format)
1644                 : TextureFormatCase(testCtx, format)
1645         {
1646                 DE_ASSERT(format.order == TextureFormat::DS);
1647         }
1648
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
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