tests/general/draw-pixels.c

   1 /*
   2  * Copyright 2012 Intel Corporation
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice (including the next
  12  * paragraph) shall be included in all copies or substantial portions of the
  13  * Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  21  * IN THE SOFTWARE.
  22  */
  23
  24 /*
  25  * file draw-pixels.c
  26  *
  27  * Test to verify functionality of glDrawPixels() with various pixel formats
  28  * and data types
  29  *
  30  * author: Anuj Phogat
  31  */
  32
  33 #include "piglit-util-gl.h"
  34
  35 /* Data conversions as used in mesa */
  36 /** Convert GLubyte in [0,255] to GLfloat in [0.0,1.0] */
  37 #define UBYTE_TO_FLOAT(u) ((float) u / 255.0F)
  38
  39 /** Convert GLbyte in [-128,127] to GLfloat in [-1.0,1.0] */
  40 #define BYTE_TO_FLOAT(B)    ((B) == -128 ? -1.0F : (B) * (1.0F/127.0F))
  41
  42 /** Convert GLushort in [0,65535] to GLfloat in [0.0,1.0] */
  43 #define USHORT_TO_FLOAT(S)  ((GLfloat) (S) * (1.0F / 65535.0F))
  44
  45 /** Convert GLshort in [-32768,32767] to GLfloat in [-1.0,1.0] */
  46 #define SHORT_TO_FLOAT(S)   ((2.0F * (S) + 1.0F) * (1.0F/65535.0F))
  47
  48 /** Convert GLuint in [0,4294967295] to GLfloat in [0.0,1.0] */
  49 #define UINT_TO_FLOAT(U)    ((GLfloat) ((U) * (1.0F / 4294967295.0)))
  50
  51 /** Convert GLint in [-2147483648,2147483647] to GLfloat in [-1.0,1.0] */
  52 #define INT_TO_FLOAT(I)     ((GLfloat) ((2.0F * (I) + 1.0F) * (1.0F/4294967294.0)))
  53
  54 PIGLIT_GL_TEST_CONFIG_BEGIN
  55
  56         config.supports_gl_compat_version = 10;
  57
  58         config.window_visual = PIGLIT_GL_VISUAL_DOUBLE | PIGLIT_GL_VISUAL_RGBA | PIGLIT_GL_VISUAL_DEPTH | PIGLIT_GL_VISUAL_STENCIL;
  59
  60         config.khr_no_error_support = PIGLIT_NO_ERRORS;
  61
  62 PIGLIT_GL_TEST_CONFIG_END
  63
  64 const GLuint idx0 = 0, idx1 = 1, idx2 = 2, idx3 = 3;
  65 static GLfloat expected[100][4];
  66
  67 /*As per OpenGL 3.0 specification integer formats are not allowed in
  68  * glDrawPixels
  69  */
  70 static GLenum pixel_formats[] = {
  71         GL_RED,
  72         GL_GREEN,
  73         GL_BLUE,
  74         GL_ALPHA,
  75         GL_RG,
  76         GL_RGB,
  77         GL_BGR,
  78         GL_RGBA,
  79         GL_BGRA,
  80         GL_LUMINANCE,
  81         GL_LUMINANCE_ALPHA,
  82         GL_DEPTH_COMPONENT,
  83         GL_STENCIL_INDEX };
  84
  85 static GLenum data_types[] = {
  86         GL_BYTE,
  87         GL_UNSIGNED_BYTE,
  88         GL_SHORT,
  89         GL_UNSIGNED_SHORT,
  90         GL_INT,
  91         GL_UNSIGNED_INT,
  92         GL_FLOAT,
  93         GL_UNSIGNED_BYTE_3_3_2,
  94         GL_UNSIGNED_BYTE_2_3_3_REV,
  95         GL_UNSIGNED_SHORT_5_6_5,
  96         GL_UNSIGNED_SHORT_5_6_5_REV,
  97         GL_UNSIGNED_SHORT_4_4_4_4,
  98         GL_UNSIGNED_SHORT_4_4_4_4_REV,
  99         GL_UNSIGNED_SHORT_5_5_5_1,
 100         GL_UNSIGNED_SHORT_1_5_5_5_REV,
 101         GL_UNSIGNED_INT_8_8_8_8,
 102         GL_UNSIGNED_INT_8_8_8_8_REV,
 103         GL_UNSIGNED_INT_10_10_10_2,
 104         GL_UNSIGNED_INT_2_10_10_10_REV };
 105
 106 typedef struct p_ops {
 107         GLenum pname;
 108         GLint param;
 109 } p_ops;
 110
 111 static const p_ops pixel_ops[] = {
 112         { GL_UNPACK_SWAP_BYTES,         0 },
 113         { GL_UNPACK_SWAP_BYTES,         1 } };
 114
 115
 116 void Swap2Byte(void *value)
 117 {
 118         GLubyte *bytes = (GLubyte *) value;
 119         GLubyte tmp = bytes[0];
 120         bytes[0] = bytes[1];
 121         bytes[1] = tmp;
 122 }
 123
 124 void Swap4Byte(void *value)
 125 {
 126         GLubyte *bytes = (GLubyte *) value;
 127         GLubyte tmp = bytes[0];
 128         bytes[0] = bytes[3];
 129         bytes[3] = tmp;
 130         tmp = bytes[1];
 131         bytes[1] = bytes[2];
 132         bytes[2] = tmp;
 133 }
 134
 135 bool is_format_type_mismatch(GLenum format, GLenum type)
 136 {
 137         if (((type == GL_UNSIGNED_BYTE_3_3_2 ||
 138               type == GL_UNSIGNED_BYTE_2_3_3_REV ||
 139               type == GL_UNSIGNED_SHORT_5_6_5 ||
 140               type == GL_UNSIGNED_SHORT_5_6_5_REV) &&
 141              (format != GL_RGB)) ||
 142
 143             ((type == GL_UNSIGNED_SHORT_4_4_4_4 ||
 144               type == GL_UNSIGNED_SHORT_4_4_4_4_REV ||
 145               type == GL_UNSIGNED_SHORT_5_5_5_1 ||
 146               type == GL_UNSIGNED_SHORT_1_5_5_5_REV ||
 147               type == GL_UNSIGNED_INT_8_8_8_8 ||
 148               type == GL_UNSIGNED_INT_8_8_8_8_REV ||
 149               type == GL_UNSIGNED_INT_10_10_10_2 ||
 150               type == GL_UNSIGNED_INT_2_10_10_10_REV) &&
 151              (format != GL_RGBA &&
 152               format != GL_BGRA)))
 153                 return true;
 154
 155         return false;
 156 }
 157
 158 static void *
 159 allocPixels(GLenum format, GLenum type, GLuint components)
 160 {
 161         GLint i, j;
 162         GLvoid *pixels;
 163         GLuint npixels = piglit_width * piglit_height;
 164
 165         switch(type) {
 166         case GL_BYTE:
 167                 pixels = calloc(npixels * components, sizeof(GLbyte));
 168                 for (i = 0; i < npixels; i++) {
 169                         for (j = 0; j < components; j++)
 170                                 ((GLbyte *)pixels)[i * components + j] = 50 + j * 4;
 171                 }
 172                 break;
 173
 174         case GL_UNSIGNED_BYTE:
 175                 pixels = calloc(npixels * components, sizeof(GLubyte));
 176                 for (i = 0; i < npixels; i++) {
 177                         for (j = 0; j < components; j++)
 178                                 ((GLubyte *)pixels)[i * components + j] = 100 + j * 4;
 179                 }
 180                 break;
 181
 182         case GL_UNSIGNED_BYTE_3_3_2:
 183         case GL_UNSIGNED_BYTE_2_3_3_REV:
 184                 pixels = calloc(npixels, sizeof(GLubyte));
 185                 for (i = 0; i < npixels; i++) {
 186                         ((GLubyte *)pixels)[i] = 0x99;
 187                 }
 188                 break;
 189
 190         case GL_SHORT:
 191                 pixels = calloc(npixels * components, sizeof(GLshort));
 192                 for (i = 0; i < npixels; i++) {
 193                         for (j = 0; j < components; j++) {
 194                                 ((GLshort *)pixels)[i * components + j] = 0x1234;
 195                         }
 196                 }
 197                 break;
 198
 199         case GL_UNSIGNED_SHORT:
 200                 pixels = calloc(npixels * components, sizeof(GLushort));
 201                 for (i = 0; i < npixels; i++) {
 202                         for (j = 0; j < components; j++) {
 203                                 ((GLushort *)pixels)[i * components + j] = 0x4321;
 204                         }
 205                 }
 206                 break;
 207
 208         case GL_UNSIGNED_SHORT_5_6_5:
 209         case GL_UNSIGNED_SHORT_5_6_5_REV:
 210         case GL_UNSIGNED_SHORT_4_4_4_4:
 211         case GL_UNSIGNED_SHORT_4_4_4_4_REV:
 212         case GL_UNSIGNED_SHORT_5_5_5_1:
 213         case GL_UNSIGNED_SHORT_1_5_5_5_REV:
 214                 pixels = calloc(npixels, sizeof(GLushort));
 215                 for (i = 0; i < npixels; i++)
 216                         ((GLushort *)pixels)[i] = 0x9b59;
 217                 break;
 218
 219         case GL_INT:
 220                 pixels = calloc(npixels * components, sizeof(GLint));
 221                 for (i = 0; i < npixels; i++) {
 222                         for (j = 0; j < components; j++) {
 223                                 ((GLint *)pixels)[i * components + j] = 0x12345678;
 224                         }
 225                 }
 226                 break;
 227
 228         case GL_UNSIGNED_INT:
 229                 pixels = calloc(npixels * components, sizeof(GLuint));
 230                 for (i = 0; i < npixels; i++) {
 231                         for (j = 0; j < components; j++) {
 232                                 ((GLuint *)pixels)[i * components + j] = 0x87654321;
 233                         }
 234                 }
 235                 break;
 236
 237         case GL_UNSIGNED_INT_8_8_8_8:
 238         case GL_UNSIGNED_INT_8_8_8_8_REV:
 239         case GL_UNSIGNED_INT_10_10_10_2:
 240         case GL_UNSIGNED_INT_2_10_10_10_REV:
 241                 pixels = calloc(npixels, sizeof(GLuint));
 242                 for (i = 0; i < npixels; i++)
 243                         ((GLuint *)pixels)[i] = 0x1a4b5a4b;
 244                 break;
 245
 246         case GL_FLOAT:
 247                 pixels = calloc(npixels * components, sizeof(GLfloat));
 248                 for (i = 0; i < npixels; i++) {
 249                         for (j = 0; j < components; j++) {
 250                                 if (format == GL_STENCIL_INDEX)
 251                                         ((GLfloat *)pixels)[i * components + j] =
 252                                         0x1020;
 253                                 else
 254                                         ((GLfloat *)pixels)[i * components + j] =
 255                                         0.5 - j * 0.1;
 256                         }
 257                 }
 258                 break;
 259
 260         default:
 261                 assert(!"Unexpected data type");
 262                 pixels = NULL;
 263                 break;
 264         }
 265         return pixels;
 266 }
 267
 268 static void *
 269 pixelsInit(GLenum format, GLenum type)
 270 {
 271         switch(format) {
 272         case GL_RED:
 273         case GL_GREEN:
 274         case GL_BLUE:
 275         case GL_ALPHA:
 276         case GL_LUMINANCE:
 277         case GL_DEPTH_COMPONENT:
 278         case GL_STENCIL_INDEX:
 279                 return (allocPixels(format, type, 1));
 280         case GL_LUMINANCE_ALPHA:
 281         case GL_RG:
 282                 return (allocPixels(format, type, 2));
 283         case GL_RGB:
 284         case GL_BGR:
 285                 return (allocPixels(format, type, 3));
 286         case GL_RGBA:
 287         case GL_BGRA:
 288                 return (allocPixels(format, type, 4));
 289         default:
 290                 printf("format = %s not allowed in glDrawPixels()\n",
 291                        piglit_get_gl_enum_name(format));
 292                 piglit_report_result(PIGLIT_FAIL);
 293         }
 294         return NULL;
 295 }
 296
 297 static float
 298 typeToFloat(GLenum format, GLenum type, GLvoid *src,
 299             GLuint index, p_ops pixelops)
 300 {
 301         /* Scale factors */
 302         GLuint pi, pui, mask; GLushort pus; GLshort ps;
 303         GLfloat pf; GLint stencil_bits; GLbyte pb; GLubyte pub;
 304         const GLuint *uisrc; const GLushort *ussrc; const GLubyte *ubsrc;
 305         GLfloat rs = 1.0f, gs = 1.0f, bs = 1.0f, as = 1.0f;
 306
 307         GLboolean swap = (pixelops.pname == GL_UNPACK_SWAP_BYTES) ?
 308                          pixelops.param : false;
 309
 310         if (format == GL_STENCIL_INDEX) {
 311
 312                 glGetIntegerv(GL_STENCIL_BITS, &stencil_bits);
 313                 /* Clamp the return value to the size of stencil buffer */
 314                 mask = 0xffffffff >> (sizeof(GLuint) *  8 - stencil_bits);
 315
 316                 switch(type) {
 317                 case GL_BYTE:
 318                         pb = ((GLbyte *)src)[index];
 319                         return pb & mask;
 320                 case GL_UNSIGNED_BYTE:
 321                         pub = ((GLubyte *)src)[index];
 322                         return pub & mask;
 323                 case GL_SHORT:
 324                         ps = ((GLshort *)src)[index];
 325                         if (swap)
 326                                 Swap2Byte(&ps);
 327                         return ps & mask;
 328                 case GL_UNSIGNED_SHORT:
 329                         pus = ((GLushort *)src)[index];
 330                         if (swap)
 331                                 Swap2Byte(&pus);
 332                         return pus & mask;
 333                 case GL_INT:
 334                         pi = ((GLint *)src)[index];
 335                         if (swap)
 336                                 Swap4Byte(&pi);
 337                         return pi & mask;
 338                 case GL_UNSIGNED_INT:
 339                         pui = ((GLuint *)src)[index];
 340                         if (swap)
 341                                 Swap4Byte(&pui);
 342                         return pui & mask;
 343                 case GL_FLOAT:
 344                         pf = ((GLfloat *)src)[index];
 345                         if (swap)
 346                                 Swap4Byte(&pf);
 347                         return (GLfloat)((GLuint)pf & mask);
 348                 default:
 349                         printf("type = %s not allowed in glDrawPixels()\n",
 350                                piglit_get_gl_enum_name(type));
 351                         piglit_report_result(PIGLIT_FAIL);
 352                 }
 353         }
 354         else {
 355                 switch(type) {
 356                 case GL_BYTE:
 357                         return BYTE_TO_FLOAT(((GLbyte *)src)[index]);
 358
 359                 case GL_UNSIGNED_BYTE:
 360                         return UBYTE_TO_FLOAT(((GLubyte *)src)[index]);
 361
 362                 case GL_UNSIGNED_BYTE_3_3_2:
 363                         ubsrc = (const GLubyte *) src;
 364                         rs = 1.0F / 7.0F;
 365                         gs = 1.0F / 7.0F;
 366                         bs = 1.0F / 3.0F;
 367                         pub = ubsrc[index];
 368                         if (index == idx0)
 369                                 return (((pub >> 5)      ) * rs);
 370                         else if (index == idx1)
 371                                 return (((pub >> 2) & 0x7) * gs);
 372                         else if (index == idx2)
 373                                 return (((pub     ) & 0x3) * bs);
 374                         else
 375                                 return 1.0F;
 376
 377                 case GL_UNSIGNED_BYTE_2_3_3_REV:
 378                         ubsrc = (const GLubyte *) src;
 379                         rs = 1.0F / 7.0F;
 380                         gs = 1.0F / 7.0F;
 381                         bs = 1.0F / 3.0F;
 382                         pub = ubsrc[index];
 383                         if (index == idx0)
 384                                 return (((pub     ) & 0x7) * rs);
 385                         else if (index == idx1)
 386                                 return (((pub >> 3) & 0x7) * gs);
 387                         else if (index == idx2)
 388                                 return (((pub >> 6)      ) * bs);
 389                         else
 390                                 return 1.0F;
 391
 392                 case GL_SHORT:
 393                         ps = ((GLshort *)src)[index];
 394                         if (swap)
 395                                 Swap2Byte(&ps);
 396                         return (SHORT_TO_FLOAT(ps));
 397
 398                 case GL_UNSIGNED_SHORT:
 399                         pus = ((GLushort *)src)[index];
 400                         if (swap)
 401                                 Swap2Byte(&pus);
 402                         return (USHORT_TO_FLOAT(pus));
 403
 404                 case GL_UNSIGNED_SHORT_5_6_5:
 405                         ussrc = (const GLushort *) src;
 406                         rs = 1.0F / 31.0F;
 407                         gs = 1.0F / 63.0F;
 408                         bs = 1.0F / 31.0F;
 409                         pus = ussrc[index];
 410                         if (swap)
 411                                 Swap2Byte(&pus);
 412                         if (index == idx0)
 413                                 return (((pus >> 11)       ) * rs);
 414                         else if (index == idx1)
 415                                 return (((pus >>  5) & 0x3f) * gs);
 416                         else if (index == idx2)
 417                                 return (((pus      ) & 0x1f) * bs);
 418                         else
 419                                 return 1.0F;
 420
 421                 case GL_UNSIGNED_SHORT_5_6_5_REV:
 422                         ussrc = (const GLushort *) src;
 423                         rs = 1.0F / 31.0F;
 424                         gs = 1.0F / 63.0F;
 425                         bs = 1.0F / 31.0F;
 426                         pus = ussrc[index];
 427                         if (swap)
 428                                 Swap2Byte(&pus);
 429                         if (index == idx0)
 430                                 return (((pus      ) & 0x1f) * rs);
 431                         else if (index == idx1)
 432                                 return (((pus >>  5) & 0x3f) * gs);
 433                         else if (index == idx2)
 434                                 return (((pus >> 11)       ) * bs);
 435                         else
 436                                 return 1.0F;
 437
 438                 case GL_UNSIGNED_SHORT_4_4_4_4:
 439                         ussrc = (const GLushort *) src;
 440                         rs = gs = bs = as = 1.0F / 15.0F;
 441                         pus = ussrc[index];
 442                         if (swap)
 443                                 Swap2Byte(&pus);
 444                         if (index == idx0)
 445                                 return (((pus >> 12)      ) * rs);
 446                         else if (index == idx1)
 447                                 return (((pus >> 8) & 0xf ) * gs);
 448                         else if (index == idx2)
 449                                 return (((pus >> 4) & 0xf ) * bs);
 450                         else
 451                                 return (((pus     ) & 0xf ) * as);
 452
 453                 case GL_UNSIGNED_SHORT_4_4_4_4_REV:
 454                         ussrc = (const GLushort *) src;
 455                         rs = gs = bs = as = 1.0F / 15.0F;
 456                         pus = ussrc[index];
 457                         if (swap)
 458                                 Swap2Byte(&pus);
 459                         if (index == idx0)
 460                                 return (((pus     ) & 0xf ) * rs);
 461                         else if (index == idx1)
 462                                 return (((pus >> 4) & 0xf ) * gs);
 463                         else if (index == idx2)
 464                                 return (((pus >> 8) & 0xf ) * bs);
 465                         else
 466                                 return (((pus >> 12)      ) * as);
 467
 468                 case GL_UNSIGNED_SHORT_5_5_5_1:
 469                         ussrc = (const GLushort *) src;
 470                         rs = gs = bs = 1.0F / 31.0F;
 471                         pus = ussrc[index];
 472                         if (swap)
 473                                 Swap2Byte(&pus);
 474                         if (index == idx0)
 475                                 return (((pus >> 11)       ) * rs);
 476                         else if (index == idx1)
 477                                 return (((pus >>  6) & 0x1f) * gs);
 478                         else if (index == idx2)
 479                                 return (((pus >>  1) & 0x1f) * bs);
 480                         else
 481                                 return (((pus      ) & 0x1)  * as);
 482
 483                 case GL_UNSIGNED_SHORT_1_5_5_5_REV:
 484                         ussrc = (const GLushort *) src;
 485                         rs = gs = bs = 1.0F / 31.0F;
 486                         pus = ussrc[index];
 487                         if (swap)
 488                                 Swap2Byte(&pus);
 489                         if (index == idx0)
 490                                 return (((pus      ) & 0x1f) * rs);
 491                         else if (index == idx1)
 492                                 return (((pus >>  5) & 0x1f) * gs);
 493                         else if (index == idx2)
 494                                 return (((pus >> 10) & 0x1f) * bs);
 495                         else
 496                                 return (((pus >> 15)       ) * as);
 497
 498                 case GL_INT:
 499                         pi = ((GLint *)src)[index];
 500                         if (swap)
 501                                 Swap4Byte(&pi);
 502                         return INT_TO_FLOAT(pi);
 503
 504                 case GL_UNSIGNED_INT:
 505                         pui = ((GLuint *)src)[index];
 506                         if (swap)
 507                                 Swap4Byte(&pui);
 508                         return UINT_TO_FLOAT(pui);
 509
 510                 case GL_UNSIGNED_INT_8_8_8_8:
 511                         uisrc = (const GLuint *) src;
 512                         pui = uisrc[index];
 513                         if (swap)
 514                                 Swap4Byte(&pui);
 515                         if (index == idx0)
 516                                 return UBYTE_TO_FLOAT(((pui >> 24)       ));
 517                         else if (index == idx1)
 518                                 return UBYTE_TO_FLOAT(((pui >> 16) & 0xff));
 519                         else if (index == idx2)
 520                                 return UBYTE_TO_FLOAT(((pui >>  8) & 0xff));
 521                         else
 522                                 return UBYTE_TO_FLOAT(((pui      ) & 0xff));
 523
 524                 case GL_UNSIGNED_INT_8_8_8_8_REV:
 525                         uisrc = (const GLuint *) src;
 526                         pui = uisrc[index];
 527                         if (swap)
 528                                 Swap4Byte(&pui);
 529                         if (index == idx0)
 530                                 return UBYTE_TO_FLOAT(((pui      ) & 0xff));
 531                         else if (index == idx1)
 532                                 return UBYTE_TO_FLOAT(((pui >>  8) & 0xff));
 533                         else if (index == idx2)
 534                                 return UBYTE_TO_FLOAT(((pui >> 16) & 0xff));
 535                         else
 536                                 return UBYTE_TO_FLOAT(((pui >> 24)       ));
 537
 538                 case GL_UNSIGNED_INT_10_10_10_2:
 539                         uisrc = (const GLuint *) src;
 540                         pui = uisrc[index];
 541                         rs = 1.0F / 1023.0F;
 542                         gs = 1.0F / 1023.0F;
 543                         bs = 1.0F / 1023.0F;
 544                         as = 1.0F / 3.0F;
 545                         if (swap)
 546                                 Swap4Byte(&pui);
 547                         if (index == idx0)
 548                                 return (((pui >> 22)        ) * rs);
 549                         else if (index == idx1)
 550                                 return (((pui >> 12) & 0x3ff) * gs);
 551                         else if (index == idx2)
 552                                 return (((pui >>  2) & 0x3ff) * bs);
 553                         else
 554                                 return (((pui      ) & 0x3  ) * as);
 555
 556                 case GL_UNSIGNED_INT_2_10_10_10_REV:
 557                         uisrc = (const GLuint *) src;
 558                         pui = uisrc[index];
 559                         rs = 1.0F / 1023.0F;
 560                         gs = 1.0F / 1023.0F;
 561                         bs = 1.0F / 1023.0F;
 562                         as = 1.0F / 3.0F;
 563                         if (swap)
 564                                 Swap4Byte(&pui);
 565                         if (index == idx0)
 566                                 return (((pui      ) & 0x3ff) * rs);
 567                         else if (index == idx1)
 568                                 return (((pui >> 10) & 0x3ff) * gs);
 569                         else if (index == idx2)
 570                                 return (((pui >> 20) & 0x3ff) * bs);
 571                         else
 572                                 return (((pui >> 30)        ) * as);
 573
 574                 case GL_FLOAT:
 575                         pf = ((GLfloat *)src)[index];
 576                         if (swap)
 577                                 Swap4Byte(&pf);
 578                         return pf;
 579                 default:
 580                         printf("type = %s not supported in glDrawPixels()\n",
 581                                piglit_get_gl_enum_name(format));
 582                         piglit_report_result(PIGLIT_FAIL);
 583                 }
 584         }
 585         return 0.0F;
 586 }
 587
 588 static float
 589 clampColor(float f)
 590 {
 591         return ((f > 1.0f) ? 1.0f : ((f < 0.0f ? 0.0f : f)));
 592 }
 593
 594 static void
 595 computeExpected(GLenum format, GLenum type, GLuint index,
 596                 p_ops pixelops, GLvoid *pixels)
 597 {
 598         int j = index;
 599         GLvoid * src = pixels;
 600         GLfloat fval;
 601
 602         switch(format) {
 603         case GL_RED:
 604                 fval = typeToFloat(format, type, src, idx0, pixelops);
 605                 expected[j][0] = clampColor(fval);
 606                 expected[j][1] = 0.0;
 607                 expected[j][2] = 0.0;
 608                 expected[j][3] = 1.0;
 609                 break;
 610         case GL_GREEN:
 611                 fval = typeToFloat(format, type, src, idx0, pixelops);
 612                 expected[j][0] = 0.0;
 613                 expected[j][1] = clampColor(fval);
 614                 expected[j][2] = 0.0;
 615                 expected[j][3] = 1.0;
 616                 break;
 617         case GL_BLUE:
 618                 fval = typeToFloat(format, type, src, idx0, pixelops);
 619                 expected[j][0] = 0.0;
 620                 expected[j][1] = 0.0;
 621                 expected[j][2] = clampColor(fval);
 622                 expected[j][3] = 1.0;
 623                 break;
 624
 625         case GL_ALPHA:
 626                 fval = typeToFloat(format, type, src, idx0, pixelops);
 627                 expected[j][0] = 0.0;
 628                 expected[j][1] = 0.0;
 629                 expected[j][2] = 0.0;
 630                 expected[j][3] = clampColor(fval);
 631                 break;
 632
 633         case GL_LUMINANCE:
 634                 fval = typeToFloat(format, type, src, idx0, pixelops);
 635                 expected[j][0] = clampColor(fval);
 636                 expected[j][1] = clampColor(fval);
 637                 expected[j][2] = clampColor(fval);
 638                 expected[j][3] = 1.0;
 639                 break;
 640
 641         case GL_LUMINANCE_ALPHA:
 642                 fval = typeToFloat(format, type, src, idx0, pixelops);
 643                 expected[j][0] = clampColor(fval);
 644                 expected[j][1] = clampColor(fval);
 645                 expected[j][2] = clampColor(fval);
 646                 fval = typeToFloat(format, type, src, idx1, pixelops);
 647                 expected[j][3] = clampColor(fval);
 648                 break;
 649
 650         case GL_RG:
 651                 fval = typeToFloat(format, type, src, idx0, pixelops);
 652                 expected[j][0] = clampColor(fval);
 653                 fval = typeToFloat(format, type, src, idx1, pixelops);
 654                 expected[j][1] = clampColor(fval);
 655                 expected[j][2] = 0.0;
 656                 expected[j][3] = 1.0;
 657                 break;
 658
 659         case GL_RGB:
 660                 fval = typeToFloat(format, type, src, idx0, pixelops);
 661                 expected[j][0] = clampColor(fval);
 662                 fval = typeToFloat(format, type, src, idx1, pixelops);
 663                 expected[j][1] = clampColor(fval);
 664                 fval = typeToFloat(format, type, src, idx2, pixelops);
 665                 expected[j][2] = clampColor(fval);
 666                 expected[j][3] = 1.0;
 667                 break;
 668
 669         case GL_BGR:
 670                 fval = typeToFloat(format, type, src, idx2, pixelops);
 671                 expected[j][0] = clampColor(fval);
 672                 fval = typeToFloat(format, type, src, idx1, pixelops);
 673                 expected[j][1] = clampColor(fval);
 674                 fval = typeToFloat(format, type, src, idx0, pixelops);
 675                 expected[j][2] = clampColor(fval);
 676                 expected[j][3] = 1.0;
 677                 break;
 678
 679         case GL_RGBA:
 680                 fval = typeToFloat(format, type, src, idx0, pixelops);
 681                 expected[j][0] = clampColor(fval);
 682                 fval = typeToFloat(format, type, src, idx1, pixelops);
 683                 expected[j][1] = clampColor(fval);
 684                 fval = typeToFloat(format, type, src, idx2, pixelops);
 685                 expected[j][2] = clampColor(fval);
 686                 fval = typeToFloat(format, type, src, idx3, pixelops);
 687                 expected[j][3] = clampColor(fval);
 688                 break;
 689
 690         case GL_BGRA:
 691                 fval = typeToFloat(format, type, src, idx2, pixelops);
 692                 expected[j][0] = clampColor(fval);
 693                 fval = typeToFloat(format, type, src, idx1, pixelops);
 694                 expected[j][1] = clampColor(fval);
 695                 fval = typeToFloat(format, type, src, idx0, pixelops);
 696                 expected[j][2] = clampColor(fval);
 697                 fval = typeToFloat(format, type, src, idx3, pixelops);
 698                 expected[j][3] = clampColor(fval);
 699                 break;
 700
 701         case GL_DEPTH_COMPONENT:
 702                 fval = typeToFloat(format, type, src, idx0, pixelops);
 703                 expected[j][0] = clampColor(fval);
 704                 break;
 705
 706         case GL_STENCIL_INDEX:
 707                 fval = typeToFloat(format, type, src, idx0, pixelops);
 708                 expected[j][0] = fval;
 709                 break;
 710         }
 711 }
 712
 713 static void
 714 report_failure(GLenum format, GLenum type)
 715 {
 716         printf("  Failed with format %s, type %s\n",
 717                piglit_get_gl_enum_name(format),
 718                piglit_get_gl_enum_name(type));
 719 }
 720
 721 enum piglit_result
 722 piglit_display(void)
 723 {
 724         int i, j, k;
 725         GLenum format, type;
 726         GLvoid *pixels = NULL;
 727         bool pass = true, p;
 728         GLfloat black[4] = {0.0, 0.0, 0.0, 1.0};
 729         GLfloat red[4] = {1.0, 0.0, 0.0, 1.0};
 730
 731         glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
 732
 733         for (i = 0; i < ARRAY_SIZE(data_types); i++) {
 734                 for (k = 0; k < ARRAY_SIZE(pixel_ops); k++) {
 735                         for (j = 0; j < ARRAY_SIZE(pixel_formats); j++) {
 736
 737                                 format = pixel_formats[j];
 738                                 type = data_types[i];
 739
 740                                 if (is_format_type_mismatch(format, type)) {
 741                                         if (piglit_khr_no_error)
 742                                                 continue;
 743
 744                                         glDrawPixels(piglit_width, piglit_height,
 745                                                      format, type, pixels);
 746                                         /* Here GL_INVALID_OPERATION is an
 747                                          * expected GL error
 748                                          */
 749                                         pass = piglit_check_gl_error(
 750                                                GL_INVALID_OPERATION)
 751                                                && pass;
 752                                         continue;
 753                                 }
 754
 755                                 if (type == GL_UNSIGNED_BYTE_3_3_2 ||
 756                                     type == GL_UNSIGNED_BYTE_2_3_3_REV)
 757                                         piglit_set_tolerance_for_bits(7, 7, 7, 7);
 758                                 else
 759                                         piglit_set_tolerance_for_bits(8, 8, 8, 8);
 760
 761                                 if (!piglit_automatic)
 762                                         printf("Format = %s, Type = %s,"
 763                                                " Swap Bytes = %d\n",
 764                                                piglit_get_gl_enum_name(format),
 765                                                piglit_get_gl_enum_name(type),
 766                                                pixel_ops[k].param);
 767
 768                                 pixels = pixelsInit(format, type);
 769                                 computeExpected(format, type, j, pixel_ops[k], pixels);
 770
 771                                 glClear(GL_COLOR_BUFFER_BIT);
 772                                 /* Enable/Disable byte swap while unpacking pixels */
 773                                 glPixelStorei(pixel_ops[k].pname, pixel_ops[k].param);
 774
 775                                 switch(format) {
 776
 777                                 case GL_RG:
 778                                         if (!piglit_is_extension_supported(
 779                                            "GL_ARB_texture_rg")) {
 780                                                    if (!piglit_automatic)
 781                                                         printf("GL_RG skipped\n");
 782                                                 continue;
 783                                         }
 784
 785                                 case GL_RED:
 786                                 case GL_GREEN:
 787                                 case GL_BLUE:
 788                                 case GL_ALPHA:
 789                                 case GL_LUMINANCE:
 790                                 case GL_LUMINANCE_ALPHA:
 791                                 case GL_RGB:
 792                                 case GL_BGR:
 793                                 case GL_RGBA:
 794                                 case GL_BGRA:
 795                                         glDrawPixels(piglit_width, piglit_height,
 796                                                      format, type, pixels);
 797
 798                                         pass = piglit_check_gl_error(GL_NO_ERROR)
 799                                                && pass;
 800                                         p = piglit_probe_rect_rgba(0, 0,
 801                                                piglit_width, piglit_height,
 802                                                expected[j]);
 803                                         if (!p) {
 804                                                 report_failure(format, type);
 805                                                 pass = GL_FALSE;
 806                                         }
 807                                         break;
 808
 809                                 case GL_DEPTH_COMPONENT:
 810                                         glEnable(GL_DEPTH_TEST);
 811                                         glClearDepth(0.0);
 812                                         glDepthFunc(GL_ALWAYS);
 813                                         glClear(GL_DEPTH_BUFFER_BIT);
 814                                         glDrawPixels(piglit_width, piglit_height,
 815                                                      format, type, pixels);
 816
 817                                         pass = piglit_check_gl_error(GL_NO_ERROR)
 818                                                && pass;
 819                                         p = piglit_probe_rect_depth(0, 0,
 820                                                piglit_width, piglit_height,
 821                                                expected[j][0]);
 822                                         if (!p) {
 823                                                 report_failure(format, type);
 824                                                 pass = GL_FALSE;
 825                                         }
 826                                         glDisable(GL_DEPTH_TEST);
 827                                         break;
 828
 829                                 case GL_STENCIL_INDEX:
 830                                         glClearStencil(0.0);
 831                                         glClear(GL_STENCIL_BUFFER_BIT);
 832                                         glDrawPixels(piglit_width, piglit_height,
 833                                                      format, type, pixels);
 834
 835                                         pass = piglit_check_gl_error(GL_NO_ERROR)
 836                                                && pass;
 837                                         /* Probe stencil buffer */
 838                                         p = piglit_probe_rect_stencil(0, 0,
 839                                                                 piglit_width,
 840                                                                 piglit_height,
 841                                                                 expected[j][0]);
 842                                         if (!p) {
 843                                                 report_failure(format, type);
 844                                                 pass = GL_FALSE;
 845                                         }
 846
 847                                         glEnable(GL_STENCIL_TEST);
 848                                         glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
 849                                         glStencilFunc(GL_EQUAL, 1, ~0);
 850                                         glColor4f(1.0, 0.0, 0.0, 1.0);
 851                                         piglit_draw_rect(0, 0, piglit_width,
 852                                                          piglit_height);
 853
 854                                         /* Probe color buffer. Color buffer will
 855                                          * stay unaffected by piglit_draw_rect()
 856                                          */
 857                                         p = piglit_probe_rect_rgba(0, 0,
 858                                                piglit_width, piglit_height,
 859                                                black);
 860                                         if (!p) {
 861                                                 report_failure(format, type);
 862                                                 pass = GL_FALSE;
 863                                         }
 864
 865                                         glStencilFunc(GL_EQUAL, expected[j][0], ~0);
 866                                         piglit_draw_rect(0, 0, piglit_width,
 867                                                          piglit_height);
 868                                         p = piglit_probe_rect_rgba(0, 0,
 869                                                piglit_width, piglit_height,
 870                                                red);
 871                                         if (!p) {
 872                                                 report_failure(format, type);
 873                                                 pass = GL_FALSE;
 874                                         }
 875
 876                                         glDisable(GL_STENCIL_TEST);
 877                                         break;
 878                                 }
 879                                 free(pixels);
 880                                 pixels = NULL;
 881
 882                                 if (!pass) {
 883                                         piglit_present_results();
 884                                 }
 885                         }
 886                 }
 887         }
 888         return (pass ? PIGLIT_PASS : PIGLIT_FAIL);
 889 }
 890
 891 void
 892 piglit_init(int argc, char **argv)
 893 {
 894         glClearColor(0.0, 0.0, 0.0, 1.0);
 895         piglit_ortho_projection(piglit_width, piglit_height, GL_TRUE);
 896 }