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_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 };
 893 static 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 };
 900 static 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 };
 907 static 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
 915 static 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 };
 934 static 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 };
 941 static 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 };
 948 static 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
 956 static 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 };
 991 static 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 };
 998 static 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
1006 static 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 };
1017 static 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 };
1024 static 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 static const deUint8 s_unormShort10In[] =
1033 {
1034         0x80, 0x84, 0x40, 0x3b,
1035         0x40, 0xfd, 0x80, 0x1a,
1036         0x80, 0x0c, 0x80, 0x15,
1037         0x40, 0x11, 0x80, 0xc3,
1038         0x80, 0xc8, 0x80, 0xd5,
1039         0xc0, 0xf9, 0x00, 0x0a,
1040         0xc0, 0x39, 0x40, 0xd5,
1041         0xc0, 0x4d, 0xc0, 0x26
1042 };
1043 static const deUint32 s_unormShort10FloatRef[] =
1044 {
1045         0x3f04a128, 0x3e6d3b4f,
1046         0x3f7d7f60, 0x3dd4350d,
1047         0x3d48320d, 0x3dac2b0b,
1048         0x3d8a2289, 0x3f43b0ec,
1049         0x3f48b22d, 0x3f55b56d,
1050         0x3f79fe80, 0x3d20280a,
1051         0x3e6739ce, 0x3f55755d,
1052         0x3e9ba6ea, 0x3e1b26ca
1053 };
1054 static const deUint32 s_unormShort10UintRef[] =
1055 {
1056         0x212, 0x0ed, 0x3f5, 0x06a,
1057         0x032, 0x056, 0x045, 0x30e,
1058         0x322, 0x356, 0x3e7, 0x028,
1059         0x0e7, 0x355, 0x137, 0x09b,
1060 };
1061 static const deUint32 s_unormShort10IntRef[] =
1062 {
1063         0x212, 0x0ed, 0x3f5, 0x06a,
1064         0x032, 0x056, 0x045, 0x30e,
1065         0x322, 0x356, 0x3e7, 0x028,
1066         0x0e7, 0x355, 0x137, 0x09b,
1067 };
1068
1069 static const deUint8 s_unormShort12In[] =
1070 {
1071         0x30, 0x46, 0xf0, 0x38,
1072         0x90, 0x85, 0xf0, 0x88,
1073         0x90, 0x92, 0x30, 0x5d,
1074         0x30, 0x3a, 0x00, 0xc9,
1075         0x00, 0x64, 0xb0, 0x9b,
1076         0x20, 0x71, 0xd0, 0x5b,
1077         0xa0, 0xc5, 0x70, 0x27,
1078         0x30, 0x0b, 0xa0, 0x53
1079 };
1080 static const deUint32 s_unormShort12FloatRef[] =
1081 {
1082         0x3e8c68c7, 0x3e63ce3d,
1083         0x3f05985a, 0x3f08f890,
1084         0x3f12992a, 0x3eba6ba7,
1085         0x3e68ce8d, 0x3f490c91,
1086         0x3ec80c81, 0x3f1bb9bc,
1087         0x3ee24e25, 0x3eb7ab7b,
1088         0x3f45ac5b, 0x3e1dc9dd,
1089         0x3d330b31, 0x3ea74a75
1090 };
1091 static const deUint32 s_unormShort12UintRef[] =
1092 {
1093         0x463, 0x38f,
1094         0x859, 0x88f,
1095         0x929, 0x5d3,
1096         0x3a3, 0xc90,
1097         0x640, 0x9bb,
1098         0x712, 0x5bd,
1099         0xc5a, 0x277,
1100         0x0b3, 0x53a
1101 };
1102 static const deUint32 s_unormShort12IntRef[] =
1103 {
1104         0x463, 0x38f,
1105         0x859, 0x88f,
1106         0x929, 0x5d3,
1107         0x3a3, 0xc90,
1108         0x640, 0x9bb,
1109         0x712, 0x5bd,
1110         0xc5a, 0x277,
1111         0x0b3, 0x53a
1112 };
1113
1114 // \todo [2015-10-12 pyry] Collapse duplicate ref arrays
1115
1116 static const struct
1117 {
1118         const deUint8*          input;
1119         const int                       inputSize;
1120         const deUint32*         floatRef;
1121         const deUint32*         intRef;
1122         const deUint32*         uintRef;
1123 } s_formatData[] =
1124 {
1125         { s_snormInt8In,                                DE_LENGTH_OF_ARRAY(s_snormInt8In),                                      s_snormInt8FloatRef,                            s_snormInt8IntRef,                              s_snormInt8UintRef                              },
1126         { s_snormInt16In,                               DE_LENGTH_OF_ARRAY(s_snormInt16In),                                     s_snormInt16FloatRef,                           s_snormInt16IntRef,                             s_snormInt16UintRef                             },
1127         { s_snormInt32In,                               DE_LENGTH_OF_ARRAY(s_snormInt32In),                                     s_snormInt32FloatRef,                           s_snormInt32IntRef,                             s_snormInt32UintRef                             },
1128         { s_unormInt8In,                                DE_LENGTH_OF_ARRAY(s_unormInt8In),                                      s_unormInt8FloatRef,                            s_unormInt8IntRef,                              s_unormInt8UintRef                              },
1129         { s_unormInt16In,                               DE_LENGTH_OF_ARRAY(s_unormInt16In),                                     s_unormInt16FloatRef,                           s_unormInt16IntRef,                             s_unormInt16UintRef                             },
1130         { s_unormInt24In,                               DE_LENGTH_OF_ARRAY(s_unormInt24In),                                     s_unormInt24FloatRef,                           s_unormInt24IntRef,                             s_unormInt24UintRef                             },
1131         { s_unormInt32In,                               DE_LENGTH_OF_ARRAY(s_unormInt32In),                                     s_unormInt32FloatRef,                           s_unormInt32IntRef,                             s_unormInt32UintRef                             },
1132         { s_unormByte44In,                              DE_LENGTH_OF_ARRAY(s_unormByte44In),                            s_unormByte44FloatRef,                          s_unormByte44IntRef,                    s_unormByte44IntRef                             },
1133         { s_unormShort565In,                    DE_LENGTH_OF_ARRAY(s_unormShort565In),                          s_unormShort565FloatRef,                        s_unormShort565IntRef,                  s_unormShort565IntRef,                  },
1134         { s_unormShort555In,                    DE_LENGTH_OF_ARRAY(s_unormShort555In),                          s_unormShort555FloatRef,                        s_unormShort555IntRef,                  s_unormShort555IntRef,                  },
1135         { s_unormShort4444In,                   DE_LENGTH_OF_ARRAY(s_unormShort4444In),                         s_unormShort4444FloatRef,                       s_unormShort4444IntRef,                 s_unormShort4444IntRef,                 },
1136         { s_unormShort5551In,                   DE_LENGTH_OF_ARRAY(s_unormShort5551In),                         s_unormShort5551FloatRef,                       s_unormShort5551IntRef,                 s_unormShort5551IntRef,                 },
1137         { s_unormShort1555In,                   DE_LENGTH_OF_ARRAY(s_unormShort1555In),                         s_unormShort1555FloatRef,                       s_unormShort1555IntRef,                 s_unormShort1555IntRef,                 },
1138         { s_unormInt101010In,                   DE_LENGTH_OF_ARRAY(s_unormInt101010In),                         s_unormInt101010FloatRef,                       s_unormInt101010IntRef,                 s_unormInt101010IntRef                  },
1139
1140         // \note Same input data & int reference used for {U,S}NORM_INT_1010102_REV
1141         { s_unormInt1010102RevIn,               DE_LENGTH_OF_ARRAY(s_unormInt1010102RevIn),                     s_snormInt1010102RevFloatRef,           s_snormInt1010102RevIntRef,             s_snormInt1010102RevIntRef              },
1142         { s_unormInt1010102RevIn,               DE_LENGTH_OF_ARRAY(s_unormInt1010102RevIn),                     s_unormInt1010102RevFloatRef,           s_unormInt1010102RevIntRef,             s_unormInt1010102RevIntRef              },
1143
1144         // \note UNSIGNED_BYTE_* and UNSIGNED_SHORT_* re-use input data and integer reference values from UNORM_* cases
1145         { s_unormByte44In,                              DE_LENGTH_OF_ARRAY(s_unormByte44In),                            s_unsignedByte44FloatRef,                       s_unormByte44IntRef,                    s_unormByte44IntRef                             },
1146         { s_unormShort565In,                    DE_LENGTH_OF_ARRAY(s_unormShort565In),                          s_unsignedShort565FloatRef,                     s_unormShort565IntRef,                  s_unormShort565IntRef,                  },
1147         { s_unormShort4444In,                   DE_LENGTH_OF_ARRAY(s_unormShort4444In),                         s_unsignedShort4444FloatRef,            s_unormShort4444IntRef,                 s_unormShort4444IntRef,                 },
1148         { s_unormShort5551In,                   DE_LENGTH_OF_ARRAY(s_unormShort5551In),                         s_unsignedShort5551FloatRef,            s_unormShort5551IntRef,                 s_unormShort5551IntRef,                 },
1149
1150         // \note (UN)SIGNED_INT_1010102_REV formats use same input data
1151         { s_unsignedInt1010102RevIn,    DE_LENGTH_OF_ARRAY(s_unsignedInt1010102RevIn),          s_signedInt1010102RevFloatRef,          s_signedInt1010102RevIntRef,    s_signedInt1010102RevIntRef             },
1152         { s_unsignedInt1010102RevIn,    DE_LENGTH_OF_ARRAY(s_unsignedInt1010102RevIn),          s_unsignedInt1010102RevFloatRef,        s_unsignedInt1010102RevIntRef,  s_unsignedInt1010102RevIntRef   },
1153
1154         { s_unsignedInt11f11f10fRevIn,  DE_LENGTH_OF_ARRAY(s_unsignedInt11f11f10fRevIn),        s_unsignedInt11f11f10fRevFloatRef,      DE_NULL,                                                DE_NULL                                                 },
1155         { s_unsignedInt999E5RevIn,              DE_LENGTH_OF_ARRAY(s_unsignedInt999E5RevIn),            s_unsignedInt999E5RevFloatRef,          DE_NULL,                                                DE_NULL                                                 },
1156         { s_unsignedInt1688In,                  DE_LENGTH_OF_ARRAY(s_unsignedInt1688In),                        s_unsignedInt1688FloatRef,                      DE_NULL,                                                s_unsignedInt1688UintRef                },
1157         { s_unsignedInt248In,                   DE_LENGTH_OF_ARRAY(s_unsignedInt248In),                         s_unsignedInt248FloatRef,                       DE_NULL,                                                s_unsignedInt248UintRef                 },
1158         { s_unsignedInt248RevIn,                DE_LENGTH_OF_ARRAY(s_unsignedInt248RevIn),                      s_unsignedInt248RevFloatRef,            DE_NULL,                                                s_unsignedInt248RevUintRef              },
1159         { s_signedInt8In,                               DE_LENGTH_OF_ARRAY(s_signedInt8In),                                     s_signedInt8FloatRef,                           s_signedInt8IntRef,                             s_signedInt8UintRef                             },
1160         { s_signedInt16In,                              DE_LENGTH_OF_ARRAY(s_signedInt16In),                            s_signedInt16FloatRef,                          s_signedInt16IntRef,                    s_signedInt16UintRef                    },
1161         { s_signedInt32In,                              DE_LENGTH_OF_ARRAY(s_signedInt32In),                            s_signedInt32FloatRef,                          s_signedInt32IntRef,                    s_signedInt32UintRef                    },
1162         { s_unsignedInt8In,                             DE_LENGTH_OF_ARRAY(s_unsignedInt8In),                           s_unsignedInt8FloatRef,                         s_unsignedInt8IntRef,                   s_unsignedInt8UintRef                   },
1163         { s_unsignedInt16In,                    DE_LENGTH_OF_ARRAY(s_unsignedInt16In),                          s_unsignedInt16FloatRef,                        s_unsignedInt16IntRef,                  s_unsignedInt16UintRef                  },
1164         { s_unsignedInt24In,                    DE_LENGTH_OF_ARRAY(s_unsignedInt24In),                          s_unsignedInt24FloatRef,                        s_unsignedInt24IntRef,                  s_unsignedInt24UintRef                  },
1165         { s_unsignedInt32In,                    DE_LENGTH_OF_ARRAY(s_unsignedInt32In),                          s_unsignedInt32FloatRef,                        s_unsignedInt32IntRef,                  s_unsignedInt32UintRef                  },
1166         { s_halfFloatIn,                                DE_LENGTH_OF_ARRAY(s_halfFloatIn),                                      s_halfFloatFloatRef,                            s_halfFloatIntRef,                              s_halfFloatUintRef                              },
1167         { s_floatIn,                                    DE_LENGTH_OF_ARRAY(s_floatIn),                                          s_floatFloatRef,                                        s_floatIntRef,                                  s_floatUintRef                                  },
1168         { s_float64In,                                  DE_LENGTH_OF_ARRAY(s_float64In),                                        s_float64FloatRef,                                      s_float64IntRef,                                s_float64IntRef                                 },
1169         { s_floatUnsignedInt248RevIn,   DE_LENGTH_OF_ARRAY(s_floatUnsignedInt248RevIn),         s_floatUnsignedInt248RevFloatRef,       DE_NULL,                                                s_floatUnsignedInt248RevUintRef },
1170
1171         { s_unormShort10In,                             DE_LENGTH_OF_ARRAY(s_unormShort10In),                           s_unormShort10FloatRef,                         s_unormShort10IntRef,                   s_unormShort10UintRef                   },
1172         { s_unormShort12In,                             DE_LENGTH_OF_ARRAY(s_unormShort12In),                           s_unormShort12FloatRef,                         s_unormShort12IntRef,                   s_unormShort12UintRef                   },
1173 };
1174 DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_formatData) == TextureFormat::CHANNELTYPE_LAST);
1175
1176 TextureFormat getBaseFormat (TextureFormat format)
1177 {
1178         const TextureFormat::ChannelOrder baseOrders[] = { TextureFormat::RGBA, TextureFormat::RGB, TextureFormat::DS };
1179
1180         for (int baseOrderNdx = 0; baseOrderNdx < DE_LENGTH_OF_ARRAY(baseOrders); baseOrderNdx++)
1181         {
1182                 const TextureFormat     curBaseFmt      (baseOrders[baseOrderNdx], format.type);
1183                 if (isValid(curBaseFmt))
1184                         return curBaseFmt;
1185         }
1186
1187         return format;
1188 }
1189
1190 ConstPixelBufferAccess getInputAccess (TextureFormat format)
1191 {
1192         const TextureFormat     inputFormat             = getBaseFormat(format);
1193         const int                       inputPixelSize  = getPixelSize(inputFormat);
1194         const int                       numPixels               = s_formatData[format.type].inputSize / inputPixelSize;
1195
1196         DE_ASSERT(numPixels == 4);
1197         DE_ASSERT(numPixels*inputPixelSize == s_formatData[format.type].inputSize);
1198
1199         return ConstPixelBufferAccess(format, IVec3(numPixels, 1, 1), IVec3(inputPixelSize, 0, 0), s_formatData[format.type].input);
1200 }
1201
1202 template<typename T>
1203 const deUint32* getRawReference (TextureFormat format);
1204
1205 template<>
1206 const deUint32* getRawReference<float> (TextureFormat format)
1207 {
1208         return s_formatData[format.type].floatRef;
1209 }
1210
1211 template<>
1212 const deUint32* getRawReference<deInt32> (TextureFormat format)
1213 {
1214         return s_formatData[format.type].intRef;
1215 }
1216
1217 template<>
1218 const deUint32* getRawReference<deUint32> (TextureFormat format)
1219 {
1220         return s_formatData[format.type].uintRef;
1221 }
1222
1223 template<typename T>
1224 void getReferenceValues (TextureFormat storageFormat, TextureFormat viewFormat, vector<Vector<T, 4> >& dst)
1225 {
1226         const int                                       numPixels       = getInputAccess(storageFormat).getWidth();
1227         const deUint32* const           rawValues       = getRawReference<T>(storageFormat);
1228         const tcu::TextureSwizzle&      swizzle         = tcu::getChannelReadSwizzle(viewFormat.order);
1229
1230         dst.resize(numPixels);
1231
1232         for (int pixelNdx = 0; pixelNdx < numPixels; pixelNdx++)
1233         {
1234                 const deUint32* srcPixPtr       = rawValues + pixelNdx*4;
1235                 T*                              dstPixPtr       = (T*)&dst[pixelNdx];
1236
1237                 for (int c = 0; c < 4; c++)
1238                 {
1239                         switch (swizzle.components[c])
1240                         {
1241                                 case tcu::TextureSwizzle::CHANNEL_0:
1242                                 case tcu::TextureSwizzle::CHANNEL_1:
1243                                 case tcu::TextureSwizzle::CHANNEL_2:
1244                                 case tcu::TextureSwizzle::CHANNEL_3:
1245                                         deMemcpy(dstPixPtr + c, srcPixPtr + (int)swizzle.components[c], sizeof(deUint32));
1246                                         break;
1247
1248                                 case tcu::TextureSwizzle::CHANNEL_ZERO:
1249                                         dstPixPtr[c] = T(0);
1250                                         break;
1251
1252                                 case tcu::TextureSwizzle::CHANNEL_ONE:
1253                                         dstPixPtr[c] = T(1);
1254                                         break;
1255
1256                                 default:
1257                                         DE_FATAL("Unknown swizzle");
1258                         }
1259                 }
1260         }
1261 }
1262
1263 template<typename T>
1264 bool componentEqual (T a, T b)
1265 {
1266         return a == b;
1267 }
1268
1269 template<>
1270 bool componentEqual<float> (float a, float b)
1271 {
1272         return (a == b) || (deFloatIsNaN(a) && deFloatIsNaN(b));
1273 }
1274
1275 template<typename T, int Size>
1276 bool allComponentsEqual (const Vector<T, Size>& a, const Vector<T, Size>& b)
1277 {
1278         for (int ndx = 0; ndx < Size; ndx++)
1279         {
1280                 if (!componentEqual(a[ndx], b[ndx]))
1281                         return false;
1282         }
1283
1284         return true;
1285 }
1286
1287 template<typename T>
1288 void copyPixels (const ConstPixelBufferAccess& src, const PixelBufferAccess& dst)
1289 {
1290         for (int ndx = 0; ndx < src.getWidth(); ndx++)
1291                 dst.setPixel(src.getPixelT<T>(ndx, 0, 0), ndx, 0, 0);
1292 }
1293
1294 void copyGetSetDepth (const ConstPixelBufferAccess& src, const PixelBufferAccess& dst)
1295 {
1296         for (int ndx = 0; ndx < src.getWidth(); ndx++)
1297                 dst.setPixDepth(src.getPixDepth(ndx, 0, 0), ndx, 0, 0);
1298 }
1299
1300 void copyGetSetStencil (const ConstPixelBufferAccess& src, const PixelBufferAccess& dst)
1301 {
1302         for (int ndx = 0; ndx < src.getWidth(); ndx++)
1303                 dst.setPixStencil(src.getPixStencil(ndx, 0, 0), ndx, 0, 0);
1304 }
1305
1306 void copyPixels (const ConstPixelBufferAccess& src, const PixelBufferAccess& dst)
1307 {
1308         switch (getTextureChannelClass(dst.getFormat().type))
1309         {
1310                 case tcu::TEXTURECHANNELCLASS_FLOATING_POINT:
1311                 case tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT:
1312                 case tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT:
1313                         copyPixels<float>(src, dst);
1314                         break;
1315
1316                 case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER:
1317                         copyPixels<deInt32>(src, dst);
1318                         break;
1319
1320                 case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER:
1321                         copyPixels<deUint32>(src, dst);
1322                         break;
1323
1324                 default:
1325                         DE_FATAL("Unknown channel class");
1326         }
1327 }
1328
1329 const char* getTextureAccessTypeDescription (TextureAccessType type)
1330 {
1331         static const char* s_desc[] =
1332         {
1333                 "floating-point",
1334                 "signed integer",
1335                 "unsigned integer"
1336         };
1337         return de::getSizedArrayElement<tcu::TEXTUREACCESSTYPE_LAST>(s_desc, type);
1338 }
1339
1340 template<typename T>
1341 TextureAccessType getTextureAccessType (void);
1342
1343 template<>
1344 TextureAccessType getTextureAccessType<float> (void)
1345 {
1346         return tcu::TEXTUREACCESSTYPE_FLOAT;
1347 }
1348
1349 template<>
1350 TextureAccessType getTextureAccessType<deInt32> (void)
1351 {
1352         return tcu::TEXTUREACCESSTYPE_SIGNED_INT;
1353 }
1354
1355 template<>
1356 TextureAccessType getTextureAccessType<deUint32> (void)
1357 {
1358         return tcu::TEXTUREACCESSTYPE_UNSIGNED_INT;
1359 }
1360
1361 static std::string getCaseName (TextureFormat format)
1362 {
1363         std::ostringstream str;
1364
1365         str << format.type << "_" << format.order;
1366
1367         return de::toLower(str.str());
1368 }
1369
1370 class TextureFormatCase : public tcu::TestCase
1371 {
1372 public:
1373         TextureFormatCase (tcu::TestContext& testCtx, TextureFormat format)
1374                 : tcu::TestCase (testCtx, getCaseName(format).c_str(), "")
1375                 , m_format              (format)
1376         {
1377                 DE_ASSERT(isValid(format));
1378         }
1379
1380 protected:
1381         template<typename T>
1382         void verifyRead (const ConstPixelBufferAccess& src)
1383         {
1384                 const int                               numPixels       = src.getWidth();
1385                 vector<Vector<T, 4> >   res                     (numPixels);
1386                 vector<Vector<T, 4> >   ref;
1387
1388                 m_testCtx.getLog()
1389                         << TestLog::Message << "Verifying " << getTextureAccessTypeDescription(getTextureAccessType<T>()) << " access" << TestLog::EndMessage;
1390
1391                 for (int ndx = 0; ndx < numPixels; ndx++)
1392                         res[ndx] = src.getPixelT<T>(ndx, 0, 0);
1393
1394                 // \note m_format != src.getFormat() for DS formats, and we specifically need to
1395                 //               use the combined format as storage format to get right reference values.
1396                 getReferenceValues<T>(m_format, src.getFormat(), ref);
1397
1398                 for (int pixelNdx = 0; pixelNdx < numPixels; pixelNdx++)
1399                 {
1400                         if (!allComponentsEqual(res[pixelNdx], ref[pixelNdx]))
1401                         {
1402                                 m_testCtx.getLog()
1403                                         << TestLog::Message << "ERROR: at pixel " << pixelNdx << ": expected " << ref[pixelNdx] << ", got " << res[pixelNdx] << TestLog::EndMessage;
1404
1405                                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Comparison failed");
1406                         }
1407                 }
1408         }
1409
1410         void verifyRead (const ConstPixelBufferAccess& src)
1411         {
1412                 // \todo [2016-08-04 pyry] Overflow in float->int conversion is not defined and
1413                 //                                                 produces different results depending on arch.
1414                 const bool      isFloat32Or64   = src.getFormat().type == tcu::TextureFormat::FLOAT ||
1415                                                                           src.getFormat().type == tcu::TextureFormat::FLOAT64;
1416
1417                 if (isAccessValid(src.getFormat(), tcu::TEXTUREACCESSTYPE_FLOAT))
1418                         verifyRead<float>(src);
1419
1420                 if (isAccessValid(src.getFormat(), tcu::TEXTUREACCESSTYPE_UNSIGNED_INT) && !isFloat32Or64)
1421                         verifyRead<deUint32>(src);
1422
1423                 if (isAccessValid(src.getFormat(), tcu::TEXTUREACCESSTYPE_SIGNED_INT) && !isFloat32Or64)
1424                         verifyRead<deInt32>(src);
1425         }
1426
1427         void verifyGetPixDepth (const ConstPixelBufferAccess& refAccess, const ConstPixelBufferAccess& combinedAccess)
1428         {
1429                 m_testCtx.getLog()
1430                         << TestLog::Message << "Verifying getPixDepth()" << TestLog::EndMessage;
1431
1432                 for (int pixelNdx = 0; pixelNdx < refAccess.getWidth(); pixelNdx++)
1433                 {
1434                         const float             ref             = refAccess.getPixel(pixelNdx, 0, 0).x();
1435                         const float             res             = combinedAccess.getPixDepth(pixelNdx, 0, 0);
1436
1437                         if (!componentEqual(res, ref))
1438                         {
1439                                 m_testCtx.getLog()
1440                                         << TestLog::Message << "ERROR: at pixel " << pixelNdx << ": expected " << ref << ", got " << res << TestLog::EndMessage;
1441
1442                                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Comparison failed");
1443                         }
1444                 }
1445         }
1446
1447         void verifyGetPixStencil (const ConstPixelBufferAccess& refAccess, const ConstPixelBufferAccess& combinedAccess)
1448         {
1449                 m_testCtx.getLog()
1450                         << TestLog::Message << "Verifying getPixStencil()" << TestLog::EndMessage;
1451
1452                 for (int pixelNdx = 0; pixelNdx < refAccess.getWidth(); pixelNdx++)
1453                 {
1454                         const int       ref             = refAccess.getPixelInt(pixelNdx, 0, 0).x();
1455                         const int       res             = combinedAccess.getPixStencil(pixelNdx, 0, 0);
1456
1457                         if (!componentEqual(res, ref))
1458                         {
1459                                 m_testCtx.getLog()
1460                                         << TestLog::Message << "ERROR: at pixel " << pixelNdx << ": expected " << ref << ", got " << res << TestLog::EndMessage;
1461
1462                                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Comparison failed");
1463                         }
1464                 }
1465         }
1466
1467         void verifyInfoQueries (void)
1468         {
1469                 const tcu::TextureChannelClass  chnClass        = tcu::getTextureChannelClass(m_format.type);
1470                 const tcu::TextureFormatInfo    fmtInfo         = tcu::getTextureFormatInfo(m_format);
1471
1472                 if (tcu::isCombinedDepthStencilType(m_format.type))
1473                         TCU_CHECK(chnClass == tcu::TEXTURECHANNELCLASS_LAST);
1474                 else
1475                         TCU_CHECK(de::inBounds(chnClass, (tcu::TextureChannelClass)0, tcu::TEXTURECHANNELCLASS_LAST));
1476
1477                 DE_UNREF(fmtInfo);
1478         }
1479
1480         const TextureFormat             m_format;
1481 };
1482
1483 class ColorFormatCase : public TextureFormatCase
1484 {
1485 public:
1486         ColorFormatCase (tcu::TestContext& testCtx, TextureFormat format)
1487                 : TextureFormatCase(testCtx, format)
1488         {
1489                 DE_ASSERT(format.order != TextureFormat::D &&
1490                                   format.order != TextureFormat::S &&
1491                                   format.order != TextureFormat::DS);
1492         }
1493
1494         IterateResult iterate (void)
1495         {
1496                 const ConstPixelBufferAccess    inputAccess             = getInputAccess(m_format);
1497                 vector<deUint8>                                 tmpMem                  (getPixelSize(inputAccess.getFormat())*inputAccess.getWidth());
1498                 const PixelBufferAccess                 tmpAccess               (inputAccess.getFormat(), inputAccess.getWidth(), 1, 1, &tmpMem[0]);
1499
1500                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
1501
1502                 verifyInfoQueries();
1503
1504                 verifyRead(inputAccess);
1505
1506                 // \todo [2015-10-12 pyry] Handle lossy conversion with *NORM_INT32
1507                 if (m_format.type != TextureFormat::UNORM_INT32 && m_format.type != TextureFormat::SNORM_INT32)
1508                 {
1509                         m_testCtx.getLog() << TestLog::Message << "Copying with getPixel() -> setPixel()" << TestLog::EndMessage;
1510                         copyPixels(inputAccess, tmpAccess);
1511                         verifyRead(tmpAccess);
1512                 }
1513
1514                 return STOP;
1515         }
1516 };
1517
1518 class DepthFormatCase : public TextureFormatCase
1519 {
1520 public:
1521         DepthFormatCase (tcu::TestContext& testCtx, TextureFormat format)
1522                 : TextureFormatCase(testCtx, format)
1523         {
1524                 DE_ASSERT(format.order == TextureFormat::D);
1525         }
1526
1527         IterateResult iterate (void)
1528         {
1529                 const ConstPixelBufferAccess    inputAccess                     = getInputAccess(m_format);
1530                 vector<deUint8>                                 tmpMem                          (getPixelSize(inputAccess.getFormat())*inputAccess.getWidth());
1531                 const PixelBufferAccess                 tmpAccess                       (inputAccess.getFormat(), inputAccess.getWidth(), 1, 1, &tmpMem[0]);
1532                 const ConstPixelBufferAccess    inputDepthAccess        = getEffectiveDepthStencilAccess(inputAccess, tcu::Sampler::MODE_DEPTH);
1533                 const PixelBufferAccess                 tmpDepthAccess          = getEffectiveDepthStencilAccess(tmpAccess, tcu::Sampler::MODE_DEPTH);
1534
1535                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
1536
1537                 verifyInfoQueries();
1538
1539                 verifyRead(inputDepthAccess);
1540
1541                 m_testCtx.getLog() << TestLog::Message << "Copying with getPixel() -> setPixel()" << TestLog::EndMessage;
1542                 copyPixels(inputDepthAccess, tmpDepthAccess);
1543                 verifyRead(tmpDepthAccess);
1544
1545                 verifyGetPixDepth(inputDepthAccess, inputAccess);
1546
1547                 m_testCtx.getLog() << TestLog::Message << "Copying both depth getPixDepth() -> setPixDepth()" << TestLog::EndMessage;
1548                 tcu::clear(tmpDepthAccess, tcu::Vec4(0.0f));
1549                 copyGetSetDepth(inputAccess, tmpAccess);
1550                 verifyGetPixDepth(tmpDepthAccess, tmpAccess);
1551
1552                 return STOP;
1553         }
1554 };
1555
1556 class StencilFormatCase : public TextureFormatCase
1557 {
1558 public:
1559         StencilFormatCase (tcu::TestContext& testCtx, TextureFormat format)
1560                 : TextureFormatCase(testCtx, format)
1561         {
1562                 DE_ASSERT(format.order == TextureFormat::S);
1563         }
1564
1565         IterateResult iterate (void)
1566         {
1567                 const ConstPixelBufferAccess    inputAccess                     = getInputAccess(m_format);
1568                 vector<deUint8>                                 tmpMem                          (getPixelSize(inputAccess.getFormat())*inputAccess.getWidth());
1569                 const PixelBufferAccess                 tmpAccess                       (inputAccess.getFormat(), inputAccess.getWidth(), 1, 1, &tmpMem[0]);
1570                 const ConstPixelBufferAccess    inputStencilAccess      = getEffectiveDepthStencilAccess(inputAccess, tcu::Sampler::MODE_STENCIL);
1571                 const PixelBufferAccess                 tmpStencilAccess        = getEffectiveDepthStencilAccess(tmpAccess, tcu::Sampler::MODE_STENCIL);
1572
1573                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
1574
1575                 verifyInfoQueries();
1576
1577                 verifyRead(inputStencilAccess);
1578
1579                 m_testCtx.getLog() << TestLog::Message << "Copying with getPixel() -> setPixel()" << TestLog::EndMessage;
1580                 copyPixels(inputStencilAccess, tmpStencilAccess);
1581                 verifyRead(tmpStencilAccess);
1582
1583                 verifyGetPixStencil(inputStencilAccess, inputAccess);
1584
1585                 m_testCtx.getLog() << TestLog::Message << "Copying both depth getPixStencil() -> setPixStencil()" << TestLog::EndMessage;
1586                 tcu::clear(tmpStencilAccess, tcu::IVec4(0));
1587                 copyGetSetStencil(inputAccess, tmpAccess);
1588                 verifyGetPixStencil(tmpStencilAccess, tmpAccess);
1589
1590                 return STOP;
1591         }
1592 };
1593
1594 class DepthStencilFormatCase : public TextureFormatCase
1595 {
1596 public:
1597         DepthStencilFormatCase (tcu::TestContext& testCtx, TextureFormat format)
1598                 : TextureFormatCase(testCtx, format)
1599         {
1600                 DE_ASSERT(format.order == TextureFormat::DS);
1601         }
1602
1603         IterateResult iterate (void)
1604         {
1605                 const ConstPixelBufferAccess    inputAccess                     = getInputAccess(m_format);
1606                 vector<deUint8>                                 tmpMem                          (getPixelSize(inputAccess.getFormat())*inputAccess.getWidth());
1607                 const PixelBufferAccess                 tmpAccess                       (inputAccess.getFormat(), inputAccess.getWidth(), 1, 1, &tmpMem[0]);
1608                 const ConstPixelBufferAccess    inputDepthAccess        = getEffectiveDepthStencilAccess(inputAccess, tcu::Sampler::MODE_DEPTH);
1609                 const ConstPixelBufferAccess    inputStencilAccess      = getEffectiveDepthStencilAccess(inputAccess, tcu::Sampler::MODE_STENCIL);
1610                 const PixelBufferAccess                 tmpDepthAccess          = getEffectiveDepthStencilAccess(tmpAccess, tcu::Sampler::MODE_DEPTH);
1611                 const PixelBufferAccess                 tmpStencilAccess        = getEffectiveDepthStencilAccess(tmpAccess, tcu::Sampler::MODE_STENCIL);
1612
1613                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
1614
1615                 verifyInfoQueries();
1616
1617                 verifyRead(inputDepthAccess);
1618                 verifyRead(inputStencilAccess);
1619
1620                 verifyGetPixDepth(inputDepthAccess, inputAccess);
1621                 verifyGetPixStencil(inputStencilAccess, inputAccess);
1622
1623                 m_testCtx.getLog() << TestLog::Message << "Copying both depth and stencil with getPixel() -> setPixel()" << TestLog::EndMessage;
1624                 copyPixels(inputDepthAccess, tmpDepthAccess);
1625                 copyPixels(inputStencilAccess, tmpStencilAccess);
1626                 verifyRead(tmpDepthAccess);
1627                 verifyRead(tmpStencilAccess);
1628
1629                 m_testCtx.getLog() << TestLog::Message << "Copying both depth and stencil with getPix{Depth,Stencil}() -> setPix{Depth,Stencil}()" << TestLog::EndMessage;
1630                 copyGetSetDepth(inputDepthAccess, tmpDepthAccess);
1631                 copyGetSetStencil(inputStencilAccess, tmpStencilAccess);
1632                 verifyRead(tmpDepthAccess);
1633                 verifyRead(tmpStencilAccess);
1634
1635                 m_testCtx.getLog() << TestLog::Message << "Verifying that clearing depth component with clearDepth() doesn't affect stencil" << TestLog::EndMessage;
1636                 tcu::copy(tmpAccess, inputAccess);
1637                 tcu::clearDepth(tmpAccess, 0.0f);
1638                 verifyRead(tmpStencilAccess);
1639
1640                 m_testCtx.getLog() << TestLog::Message << "Verifying that clearing stencil component with clearStencil() doesn't affect depth" << TestLog::EndMessage;
1641                 tcu::copy(tmpAccess, inputAccess);
1642                 tcu::clearStencil(tmpAccess, 0);
1643                 verifyRead(tmpDepthAccess);
1644
1645                 m_testCtx.getLog() << TestLog::Message << "Verifying that clearing depth component with setPixDepth() doesn't affect stencil" << TestLog::EndMessage;
1646                 tcu::copy(tmpAccess, inputAccess);
1647
1648                 for (int ndx = 0; ndx < tmpAccess.getWidth(); ndx++)
1649                         tmpAccess.setPixDepth(0.0f, ndx, 0, 0);
1650
1651                 verifyRead(tmpStencilAccess);
1652
1653                 m_testCtx.getLog() << TestLog::Message << "Verifying that clearing stencil component with setPixStencil() doesn't affect depth" << TestLog::EndMessage;
1654                 tcu::copy(tmpAccess, inputAccess);
1655
1656                 for (int ndx = 0; ndx < tmpAccess.getWidth(); ndx++)
1657                         tmpAccess.setPixStencil(0, ndx, 0, 0);
1658
1659                 verifyRead(tmpDepthAccess);
1660
1661                 return STOP;
1662         }
1663 };
1664
1665 } // anonymous
1666
1667 tcu::TestCaseGroup* createTextureFormatTests (tcu::TestContext& testCtx)
1668 {
1669         de::MovePtr<tcu::TestCaseGroup> group   (new tcu::TestCaseGroup(testCtx, "texture_format", "Texture format tests"));
1670
1671         for (int channelType = 0; channelType < TextureFormat::CHANNELTYPE_LAST; channelType++)
1672         {
1673                 for (int channelOrder = 0; channelOrder < TextureFormat::CHANNELORDER_LAST; channelOrder++)
1674                 {
1675                         const TextureFormat             format          ((TextureFormat::ChannelOrder)channelOrder, (TextureFormat::ChannelType)channelType);
1676
1677                         if (!isValid(format))
1678                                 continue;
1679
1680                         if (tcu::isSRGB(format))
1681                                 continue; // \todo [2015-10-12 pyry] Tests for sRGB formats (need thresholds)
1682
1683                         if (format.order == TextureFormat::DS)
1684                                 group->addChild(new DepthStencilFormatCase(testCtx, format));
1685                         else if (format.order == TextureFormat::D)
1686                                 group->addChild(new DepthFormatCase(testCtx, format));
1687                         else if (format.order == TextureFormat::S)
1688                                 group->addChild(new StencilFormatCase(testCtx, format));
1689                         else
1690                                 group->addChild(new ColorFormatCase(testCtx, format));
1691                 }
1692         }
1693
1694         return group.release();
1695 }
1696
1697 } // dit