src/mesa/main/glformats.c

   1 /*
   2  * Mesa 3-D graphics library
   3  *
   4  * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.
   5  * Copyright (c) 2008-2009  VMware, Inc.
   6  * Copyright (c) 2012 Intel Corporation
   7  *
   8  * Permission is hereby granted, free of charge, to any person obtaining a
   9  * copy of this software and associated documentation files (the "Software"),
  10  * to deal in the Software without restriction, including without limitation
  11  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  12  * and/or sell copies of the Software, and to permit persons to whom the
  13  * Software is furnished to do so, subject to the following conditions:
  14  *
  15  * The above copyright notice and this permission notice shall be included
  16  * in all copies or substantial portions of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  19  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  20  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  21  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  22  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  23  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  24  * OTHER DEALINGS IN THE SOFTWARE.
  25  */
  26
  27
  28 #include "context.h"
  29 #include "glformats.h"
  30 #include "enums.h"
  31
  32 enum {
  33    ZERO = 4,
  34    ONE = 5
  35 };
  36
  37 enum {
  38    IDX_LUMINANCE = 0,
  39    IDX_ALPHA,
  40    IDX_INTENSITY,
  41    IDX_LUMINANCE_ALPHA,
  42    IDX_RGB,
  43    IDX_RGBA,
  44    IDX_RED,
  45    IDX_GREEN,
  46    IDX_BLUE,
  47    IDX_BGR,
  48    IDX_BGRA,
  49    IDX_ABGR,
  50    IDX_RG,
  51    MAX_IDX
  52 };
  53
  54 #define MAP1(x)       MAP4(x, ZERO, ZERO, ZERO)
  55 #define MAP2(x,y)     MAP4(x, y, ZERO, ZERO)
  56 #define MAP3(x,y,z)   MAP4(x, y, z, ZERO)
  57 #define MAP4(x,y,z,w) { x, y, z, w, ZERO, ONE }
  58
  59 static const struct {
  60    GLubyte format_idx;
  61    GLubyte to_rgba[6];
  62    GLubyte from_rgba[6];
  63 } mappings[MAX_IDX] =
  64 {
  65    {
  66       IDX_LUMINANCE,
  67       MAP4(0,0,0,ONE),
  68       MAP1(0)
  69    },
  70
  71    {
  72       IDX_ALPHA,
  73       MAP4(ZERO, ZERO, ZERO, 0),
  74       MAP1(3)
  75    },
  76
  77    {
  78       IDX_INTENSITY,
  79       MAP4(0, 0, 0, 0),
  80       MAP1(0),
  81    },
  82
  83    {
  84       IDX_LUMINANCE_ALPHA,
  85       MAP4(0,0,0,1),
  86       MAP2(0,3)
  87    },
  88
  89    {
  90       IDX_RGB,
  91       MAP4(0,1,2,ONE),
  92       MAP3(0,1,2)
  93    },
  94
  95    {
  96       IDX_RGBA,
  97       MAP4(0,1,2,3),
  98       MAP4(0,1,2,3),
  99    },
 100
 101    {
 102       IDX_RED,
 103       MAP4(0, ZERO, ZERO, ONE),
 104       MAP1(0),
 105    },
 106
 107    {
 108       IDX_GREEN,
 109       MAP4(ZERO, 0, ZERO, ONE),
 110       MAP1(1),
 111    },
 112
 113    {
 114       IDX_BLUE,
 115       MAP4(ZERO, ZERO, 0, ONE),
 116       MAP1(2),
 117    },
 118
 119    {
 120       IDX_BGR,
 121       MAP4(2,1,0,ONE),
 122       MAP3(2,1,0)
 123    },
 124
 125    {
 126       IDX_BGRA,
 127       MAP4(2,1,0,3),
 128       MAP4(2,1,0,3)
 129    },
 130
 131    {
 132       IDX_ABGR,
 133       MAP4(3,2,1,0),
 134       MAP4(3,2,1,0)
 135    },
 136
 137    {
 138       IDX_RG,
 139       MAP4(0, 1, ZERO, ONE),
 140       MAP2(0, 1)
 141    },
 142 };
 143
 144 /**
 145  * Convert a GL image format enum to an IDX_* value (see above).
 146  */
 147 static int
 148 get_map_idx(GLenum value)
 149 {
 150    switch (value) {
 151    case GL_LUMINANCE:
 152    case GL_LUMINANCE_INTEGER_EXT:
 153       return IDX_LUMINANCE;
 154    case GL_ALPHA:
 155    case GL_ALPHA_INTEGER:
 156       return IDX_ALPHA;
 157    case GL_INTENSITY:
 158       return IDX_INTENSITY;
 159    case GL_LUMINANCE_ALPHA:
 160    case GL_LUMINANCE_ALPHA_INTEGER_EXT:
 161       return IDX_LUMINANCE_ALPHA;
 162    case GL_RGB:
 163    case GL_RGB_INTEGER:
 164       return IDX_RGB;
 165    case GL_RGBA:
 166    case GL_RGBA_INTEGER:
 167       return IDX_RGBA;
 168    case GL_RED:
 169    case GL_RED_INTEGER:
 170       return IDX_RED;
 171    case GL_GREEN:
 172       return IDX_GREEN;
 173    case GL_BLUE:
 174       return IDX_BLUE;
 175    case GL_BGR:
 176    case GL_BGR_INTEGER:
 177       return IDX_BGR;
 178    case GL_BGRA:
 179    case GL_BGRA_INTEGER:
 180       return IDX_BGRA;
 181    case GL_ABGR_EXT:
 182       return IDX_ABGR;
 183    case GL_RG:
 184    case GL_RG_INTEGER:
 185       return IDX_RG;
 186    default:
 187       _mesa_problem(NULL, "Unexpected inFormat %s",
 188                     _mesa_lookup_enum_by_nr(value));
 189       return 0;
 190    }
 191 }
 192
 193 /**
 194  * When promoting texture formats (see below) we need to compute the
 195  * mapping of dest components back to source components.
 196  * This function does that.
 197  * \param inFormat  the incoming format of the texture
 198  * \param outFormat  the final texture format
 199  * \return map[6]  a full 6-component map
 200  */
 201 void
 202 _mesa_compute_component_mapping(GLenum inFormat, GLenum outFormat, GLubyte *map)
 203 {
 204    const int inFmt = get_map_idx(inFormat);
 205    const int outFmt = get_map_idx(outFormat);
 206    const GLubyte *in2rgba = mappings[inFmt].to_rgba;
 207    const GLubyte *rgba2out = mappings[outFmt].from_rgba;
 208    int i;
 209
 210    for (i = 0; i < 4; i++)
 211       map[i] = in2rgba[rgba2out[i]];
 212
 213    map[ZERO] = ZERO;
 214    map[ONE] = ONE;
 215
 216 #if 0
 217    printf("from %x/%s to %x/%s map %d %d %d %d %d %d\n",
 218           inFormat, _mesa_lookup_enum_by_nr(inFormat),
 219           outFormat, _mesa_lookup_enum_by_nr(outFormat),
 220           map[0],
 221           map[1],
 222           map[2],
 223           map[3],
 224           map[4],
 225           map[5]);
 226 #endif
 227 }
 228
 229 /**
 230  * \return GL_TRUE if type is packed pixel type, GL_FALSE otherwise.
 231  */
 232 GLboolean
 233 _mesa_type_is_packed(GLenum type)
 234 {
 235    switch (type) {
 236    case GL_UNSIGNED_BYTE_3_3_2:
 237    case GL_UNSIGNED_BYTE_2_3_3_REV:
 238    case MESA_UNSIGNED_BYTE_4_4:
 239    case GL_UNSIGNED_SHORT_5_6_5:
 240    case GL_UNSIGNED_SHORT_5_6_5_REV:
 241    case GL_UNSIGNED_SHORT_4_4_4_4:
 242    case GL_UNSIGNED_SHORT_4_4_4_4_REV:
 243    case GL_UNSIGNED_SHORT_5_5_5_1:
 244    case GL_UNSIGNED_SHORT_1_5_5_5_REV:
 245    case GL_UNSIGNED_INT_8_8_8_8:
 246    case GL_UNSIGNED_INT_8_8_8_8_REV:
 247    case GL_UNSIGNED_INT_10_10_10_2:
 248    case GL_UNSIGNED_INT_2_10_10_10_REV:
 249    case GL_UNSIGNED_SHORT_8_8_MESA:
 250    case GL_UNSIGNED_SHORT_8_8_REV_MESA:
 251    case GL_UNSIGNED_INT_24_8_EXT:
 252    case GL_UNSIGNED_INT_5_9_9_9_REV:
 253    case GL_UNSIGNED_INT_10F_11F_11F_REV:
 254    case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
 255       return GL_TRUE;
 256    }
 257
 258    return GL_FALSE;
 259 }
 260
 261
 262 /**
 263  * Get the size of a GL data type.
 264  *
 265  * \param type GL data type.
 266  *
 267  * \return the size, in bytes, of the given data type, 0 if a GL_BITMAP, or -1
 268  * if an invalid type enum.
 269  */
 270 GLint
 271 _mesa_sizeof_type(GLenum type)
 272 {
 273    switch (type) {
 274    case GL_BITMAP:
 275       return 0;
 276    case GL_UNSIGNED_BYTE:
 277       return sizeof(GLubyte);
 278    case GL_BYTE:
 279       return sizeof(GLbyte);
 280    case GL_UNSIGNED_SHORT:
 281       return sizeof(GLushort);
 282    case GL_SHORT:
 283       return sizeof(GLshort);
 284    case GL_UNSIGNED_INT:
 285       return sizeof(GLuint);
 286    case GL_INT:
 287       return sizeof(GLint);
 288    case GL_FLOAT:
 289       return sizeof(GLfloat);
 290    case GL_DOUBLE:
 291       return sizeof(GLdouble);
 292    case GL_HALF_FLOAT_ARB:
 293       return sizeof(GLhalfARB);
 294    case GL_FIXED:
 295       return sizeof(GLfixed);
 296    default:
 297       return -1;
 298    }
 299 }
 300
 301
 302 /**
 303  * Same as _mesa_sizeof_type() but also accepting the packed pixel
 304  * format data types.
 305  */
 306 GLint
 307 _mesa_sizeof_packed_type(GLenum type)
 308 {
 309    switch (type) {
 310    case GL_BITMAP:
 311       return 0;
 312    case GL_UNSIGNED_BYTE:
 313       return sizeof(GLubyte);
 314    case GL_BYTE:
 315       return sizeof(GLbyte);
 316    case GL_UNSIGNED_SHORT:
 317       return sizeof(GLushort);
 318    case GL_SHORT:
 319       return sizeof(GLshort);
 320    case GL_UNSIGNED_INT:
 321       return sizeof(GLuint);
 322    case GL_INT:
 323       return sizeof(GLint);
 324    case GL_HALF_FLOAT_ARB:
 325       return sizeof(GLhalfARB);
 326    case GL_FLOAT:
 327       return sizeof(GLfloat);
 328    case GL_UNSIGNED_BYTE_3_3_2:
 329    case GL_UNSIGNED_BYTE_2_3_3_REV:
 330    case MESA_UNSIGNED_BYTE_4_4:
 331       return sizeof(GLubyte);
 332    case GL_UNSIGNED_SHORT_5_6_5:
 333    case GL_UNSIGNED_SHORT_5_6_5_REV:
 334    case GL_UNSIGNED_SHORT_4_4_4_4:
 335    case GL_UNSIGNED_SHORT_4_4_4_4_REV:
 336    case GL_UNSIGNED_SHORT_5_5_5_1:
 337    case GL_UNSIGNED_SHORT_1_5_5_5_REV:
 338    case GL_UNSIGNED_SHORT_8_8_MESA:
 339    case GL_UNSIGNED_SHORT_8_8_REV_MESA:
 340       return sizeof(GLushort);
 341    case GL_UNSIGNED_INT_8_8_8_8:
 342    case GL_UNSIGNED_INT_8_8_8_8_REV:
 343    case GL_UNSIGNED_INT_10_10_10_2:
 344    case GL_UNSIGNED_INT_2_10_10_10_REV:
 345    case GL_UNSIGNED_INT_24_8_EXT:
 346    case GL_UNSIGNED_INT_5_9_9_9_REV:
 347    case GL_UNSIGNED_INT_10F_11F_11F_REV:
 348       return sizeof(GLuint);
 349    case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
 350       return 8;
 351    default:
 352       return -1;
 353    }
 354 }
 355
 356
 357 /**
 358  * Get the number of components in a pixel format.
 359  *
 360  * \param format pixel format.
 361  *
 362  * \return the number of components in the given format, or -1 if a bad format.
 363  */
 364 GLint
 365 _mesa_components_in_format(GLenum format)
 366 {
 367    switch (format) {
 368    case GL_COLOR_INDEX:
 369    case GL_STENCIL_INDEX:
 370    case GL_DEPTH_COMPONENT:
 371    case GL_RED:
 372    case GL_RED_INTEGER_EXT:
 373    case GL_GREEN:
 374    case GL_GREEN_INTEGER_EXT:
 375    case GL_BLUE:
 376    case GL_BLUE_INTEGER_EXT:
 377    case GL_ALPHA:
 378    case GL_ALPHA_INTEGER_EXT:
 379    case GL_LUMINANCE:
 380    case GL_LUMINANCE_INTEGER_EXT:
 381    case GL_INTENSITY:
 382       return 1;
 383
 384    case GL_LUMINANCE_ALPHA:
 385    case GL_LUMINANCE_ALPHA_INTEGER_EXT:
 386    case GL_RG:
 387    case GL_YCBCR_MESA:
 388    case GL_DEPTH_STENCIL_EXT:
 389    case GL_RG_INTEGER:
 390       return 2;
 391
 392    case GL_RGB:
 393    case GL_BGR:
 394    case GL_RGB_INTEGER_EXT:
 395    case GL_BGR_INTEGER_EXT:
 396       return 3;
 397
 398    case GL_RGBA:
 399    case GL_BGRA:
 400    case GL_ABGR_EXT:
 401    case GL_RGBA_INTEGER_EXT:
 402    case GL_BGRA_INTEGER_EXT:
 403       return 4;
 404
 405    default:
 406       return -1;
 407    }
 408 }
 409
 410
 411 /**
 412  * Get the bytes per pixel of pixel format type pair.
 413  *
 414  * \param format pixel format.
 415  * \param type pixel type.
 416  *
 417  * \return bytes per pixel, or -1 if a bad format or type was given.
 418  */
 419 GLint
 420 _mesa_bytes_per_pixel(GLenum format, GLenum type)
 421 {
 422    GLint comps = _mesa_components_in_format(format);
 423    if (comps < 0)
 424       return -1;
 425
 426    switch (type) {
 427    case GL_BITMAP:
 428       return 0;  /* special case */
 429    case GL_BYTE:
 430    case GL_UNSIGNED_BYTE:
 431       return comps * sizeof(GLubyte);
 432    case GL_SHORT:
 433    case GL_UNSIGNED_SHORT:
 434       return comps * sizeof(GLshort);
 435    case GL_INT:
 436    case GL_UNSIGNED_INT:
 437       return comps * sizeof(GLint);
 438    case GL_FLOAT:
 439       return comps * sizeof(GLfloat);
 440    case GL_HALF_FLOAT_ARB:
 441       return comps * sizeof(GLhalfARB);
 442    case GL_UNSIGNED_BYTE_3_3_2:
 443    case GL_UNSIGNED_BYTE_2_3_3_REV:
 444       if (format == GL_RGB || format == GL_BGR ||
 445           format == GL_RGB_INTEGER_EXT || format == GL_BGR_INTEGER_EXT)
 446          return sizeof(GLubyte);
 447       else
 448          return -1;  /* error */
 449    case GL_UNSIGNED_SHORT_5_6_5:
 450    case GL_UNSIGNED_SHORT_5_6_5_REV:
 451       if (format == GL_RGB || format == GL_BGR ||
 452           format == GL_RGB_INTEGER_EXT || format == GL_BGR_INTEGER_EXT)
 453          return sizeof(GLushort);
 454       else
 455          return -1;  /* error */
 456    case GL_UNSIGNED_SHORT_4_4_4_4:
 457    case GL_UNSIGNED_SHORT_4_4_4_4_REV:
 458    case GL_UNSIGNED_SHORT_5_5_5_1:
 459    case GL_UNSIGNED_SHORT_1_5_5_5_REV:
 460       if (format == GL_RGBA || format == GL_BGRA || format == GL_ABGR_EXT ||
 461           format == GL_RGBA_INTEGER_EXT || format == GL_BGRA_INTEGER_EXT)
 462          return sizeof(GLushort);
 463       else
 464          return -1;
 465    case GL_UNSIGNED_INT_8_8_8_8:
 466    case GL_UNSIGNED_INT_8_8_8_8_REV:
 467    case GL_UNSIGNED_INT_10_10_10_2:
 468    case GL_UNSIGNED_INT_2_10_10_10_REV:
 469       if (format == GL_RGBA || format == GL_BGRA || format == GL_ABGR_EXT ||
 470           format == GL_RGBA_INTEGER_EXT || format == GL_BGRA_INTEGER_EXT ||
 471           format == GL_RGB)
 472          return sizeof(GLuint);
 473       else
 474          return -1;
 475    case GL_UNSIGNED_SHORT_8_8_MESA:
 476    case GL_UNSIGNED_SHORT_8_8_REV_MESA:
 477       if (format == GL_YCBCR_MESA)
 478          return sizeof(GLushort);
 479       else
 480          return -1;
 481    case GL_UNSIGNED_INT_24_8_EXT:
 482       if (format == GL_DEPTH_STENCIL_EXT)
 483          return sizeof(GLuint);
 484       else
 485          return -1;
 486    case GL_UNSIGNED_INT_5_9_9_9_REV:
 487       if (format == GL_RGB)
 488          return sizeof(GLuint);
 489       else
 490          return -1;
 491    case GL_UNSIGNED_INT_10F_11F_11F_REV:
 492       if (format == GL_RGB)
 493          return sizeof(GLuint);
 494       else
 495          return -1;
 496    case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
 497       if (format == GL_DEPTH_STENCIL)
 498          return 8;
 499       else
 500          return -1;
 501    default:
 502       return -1;
 503    }
 504 }
 505
 506
 507 /**
 508  * Get the number of bytes for a vertex attrib with the given number of
 509  * components and type.
 510  *
 511  * \param comps number of components.
 512  * \param type data type.
 513  *
 514  * \return bytes per attribute, or -1 if a bad comps/type combination was given.
 515  */
 516 GLint
 517 _mesa_bytes_per_vertex_attrib(GLint comps, GLenum type)
 518 {
 519    switch (type) {
 520    case GL_BYTE:
 521    case GL_UNSIGNED_BYTE:
 522       return comps * sizeof(GLubyte);
 523    case GL_SHORT:
 524    case GL_UNSIGNED_SHORT:
 525       return comps * sizeof(GLshort);
 526    case GL_INT:
 527    case GL_UNSIGNED_INT:
 528       return comps * sizeof(GLint);
 529    case GL_FLOAT:
 530       return comps * sizeof(GLfloat);
 531    case GL_HALF_FLOAT_ARB:
 532       return comps * sizeof(GLhalfARB);
 533    case GL_DOUBLE:
 534       return comps * sizeof(GLdouble);
 535    case GL_FIXED:
 536       return comps * sizeof(GLfixed);
 537    case GL_INT_2_10_10_10_REV:
 538    case GL_UNSIGNED_INT_2_10_10_10_REV:
 539       if (comps == 4)
 540          return sizeof(GLuint);
 541       else
 542          return -1;
 543    case GL_UNSIGNED_INT_10F_11F_11F_REV:
 544       if (comps == 3)
 545          return sizeof(GLuint);
 546       else
 547          return -1;
 548    default:
 549       return -1;
 550    }
 551 }
 552
 553 /**
 554  * Test if the given format is unsized.
 555  */
 556 GLboolean
 557 _mesa_is_enum_format_unsized(GLenum format)
 558 {
 559    switch (format) {
 560    case GL_RGBA:
 561    case GL_BGRA:
 562    case GL_ABGR_EXT:
 563    case GL_RGB:
 564    case GL_BGR:
 565    case GL_RG:
 566    case GL_RED:
 567    case GL_GREEN:
 568    case GL_BLUE:
 569    case GL_ALPHA:
 570    case GL_INTENSITY:
 571    case GL_LUMINANCE:
 572    case GL_LUMINANCE_ALPHA:
 573
 574    case GL_SRGB:
 575    case GL_SRGB_ALPHA:
 576    case GL_SLUMINANCE:
 577    case GL_SLUMINANCE_ALPHA:
 578
 579    case GL_RGBA_SNORM:
 580    case GL_RGB_SNORM:
 581    case GL_RG_SNORM:
 582    case GL_RED_SNORM:
 583    case GL_ALPHA_SNORM:
 584    case GL_INTENSITY_SNORM:
 585    case GL_LUMINANCE_SNORM:
 586    case GL_LUMINANCE_ALPHA_SNORM:
 587
 588    case GL_RED_INTEGER:
 589    case GL_GREEN_INTEGER:
 590    case GL_BLUE_INTEGER:
 591    case GL_ALPHA_INTEGER:
 592    case GL_RGB_INTEGER:
 593    case GL_RGBA_INTEGER:
 594    case GL_BGR_INTEGER:
 595    case GL_BGRA_INTEGER:
 596    case GL_RG_INTEGER:
 597    case GL_LUMINANCE_INTEGER_EXT:
 598    case GL_LUMINANCE_ALPHA_INTEGER_EXT:
 599
 600    case GL_DEPTH_COMPONENT:
 601    case GL_DEPTH_STENCIL:
 602    case GL_STENCIL_INDEX:
 603       return GL_TRUE;
 604    default:
 605       return GL_FALSE;
 606    }
 607 }
 608
 609 /**
 610  * Test if the given format is a UNORM (unsigned-normalized) format.
 611  */
 612 GLboolean
 613 _mesa_is_enum_format_unorm(GLenum format)
 614 {
 615       switch(format) {
 616       case GL_RED:
 617       case GL_GREEN:
 618       case GL_BLUE:
 619       case GL_ALPHA:
 620       case GL_ALPHA4:
 621       case GL_ALPHA8:
 622       case GL_ALPHA12:
 623       case GL_ALPHA16:
 624       case 1:
 625       case GL_LUMINANCE:
 626       case GL_SLUMINANCE:
 627       case GL_LUMINANCE4:
 628       case GL_LUMINANCE8:
 629       case GL_LUMINANCE12:
 630       case GL_LUMINANCE16:
 631       case 2:
 632       case GL_LUMINANCE_ALPHA:
 633       case GL_SLUMINANCE_ALPHA:
 634       case GL_LUMINANCE4_ALPHA4:
 635       case GL_LUMINANCE6_ALPHA2:
 636       case GL_LUMINANCE8_ALPHA8:
 637       case GL_LUMINANCE12_ALPHA4:
 638       case GL_LUMINANCE12_ALPHA12:
 639       case GL_LUMINANCE16_ALPHA16:
 640       case GL_INTENSITY:
 641       case GL_INTENSITY4:
 642       case GL_INTENSITY8:
 643       case GL_INTENSITY12:
 644       case GL_INTENSITY16:
 645       case GL_R8:
 646       case GL_R16:
 647       case GL_RG:
 648       case GL_RG8:
 649       case GL_RG16:
 650       case 3:
 651       case GL_RGB:
 652       case GL_BGR:
 653       case GL_SRGB:
 654       case GL_R3_G3_B2:
 655       case GL_RGB4:
 656       case GL_RGB5:
 657       case GL_RGB565:
 658       case GL_RGB8:
 659       case GL_RGB10:
 660       case GL_RGB12:
 661       case GL_RGB16:
 662       case 4:
 663       case GL_ABGR_EXT:
 664       case GL_RGBA:
 665       case GL_BGRA:
 666       case GL_SRGB_ALPHA:
 667       case GL_RGBA2:
 668       case GL_RGBA4:
 669       case GL_RGB5_A1:
 670       case GL_RGBA8:
 671       case GL_RGB10_A2:
 672       case GL_RGBA12:
 673       case GL_RGBA16:
 674          return GL_TRUE;
 675       default:
 676          return GL_FALSE;
 677    }
 678 }
 679
 680 /**
 681  * Test if the given format is a SNORM (signed-normalized) format.
 682  */
 683 GLboolean
 684 _mesa_is_enum_format_snorm(GLenum format)
 685 {
 686    switch (format) {
 687    /* signed, normalized texture formats */
 688    case GL_RED_SNORM:
 689    case GL_R8_SNORM:
 690    case GL_R16_SNORM:
 691    case GL_RG_SNORM:
 692    case GL_RG8_SNORM:
 693    case GL_RG16_SNORM:
 694    case GL_RGB_SNORM:
 695    case GL_RGB8_SNORM:
 696    case GL_RGB16_SNORM:
 697    case GL_RGBA_SNORM:
 698    case GL_RGBA8_SNORM:
 699    case GL_RGBA16_SNORM:
 700    case GL_ALPHA_SNORM:
 701    case GL_ALPHA8_SNORM:
 702    case GL_ALPHA16_SNORM:
 703    case GL_LUMINANCE_SNORM:
 704    case GL_LUMINANCE8_SNORM:
 705    case GL_LUMINANCE16_SNORM:
 706    case GL_LUMINANCE_ALPHA_SNORM:
 707    case GL_LUMINANCE8_ALPHA8_SNORM:
 708    case GL_LUMINANCE16_ALPHA16_SNORM:
 709    case GL_INTENSITY_SNORM:
 710    case GL_INTENSITY8_SNORM:
 711    case GL_INTENSITY16_SNORM:
 712       return GL_TRUE;
 713    default:
 714       return GL_FALSE;
 715    }
 716 }
 717
 718 /**
 719  * Test if the given format is an integer (non-normalized) format.
 720  */
 721 GLboolean
 722 _mesa_is_enum_format_unsigned_int(GLenum format)
 723 {
 724    switch (format) {
 725    /* specific integer formats */
 726    case GL_RGBA32UI_EXT:
 727    case GL_RGB32UI_EXT:
 728    case GL_RG32UI:
 729    case GL_R32UI:
 730    case GL_ALPHA32UI_EXT:
 731    case GL_INTENSITY32UI_EXT:
 732    case GL_LUMINANCE32UI_EXT:
 733    case GL_LUMINANCE_ALPHA32UI_EXT:
 734    case GL_RGBA16UI_EXT:
 735    case GL_RGB16UI_EXT:
 736    case GL_RG16UI:
 737    case GL_R16UI:
 738    case GL_ALPHA16UI_EXT:
 739    case GL_INTENSITY16UI_EXT:
 740    case GL_LUMINANCE16UI_EXT:
 741    case GL_LUMINANCE_ALPHA16UI_EXT:
 742    case GL_RGBA8UI_EXT:
 743    case GL_RGB8UI_EXT:
 744    case GL_RG8UI:
 745    case GL_R8UI:
 746    case GL_ALPHA8UI_EXT:
 747    case GL_INTENSITY8UI_EXT:
 748    case GL_LUMINANCE8UI_EXT:
 749    case GL_LUMINANCE_ALPHA8UI_EXT:
 750    case GL_RGB10_A2UI:
 751       return GL_TRUE;
 752    default:
 753       return GL_FALSE;
 754    }
 755 }
 756
 757
 758 /**
 759  * Test if the given format is an integer (non-normalized) format.
 760  */
 761 GLboolean
 762 _mesa_is_enum_format_signed_int(GLenum format)
 763 {
 764    switch (format) {
 765    /* generic integer formats */
 766    case GL_RED_INTEGER_EXT:
 767    case GL_GREEN_INTEGER_EXT:
 768    case GL_BLUE_INTEGER_EXT:
 769    case GL_ALPHA_INTEGER_EXT:
 770    case GL_RGB_INTEGER_EXT:
 771    case GL_RGBA_INTEGER_EXT:
 772    case GL_BGR_INTEGER_EXT:
 773    case GL_BGRA_INTEGER_EXT:
 774    case GL_LUMINANCE_INTEGER_EXT:
 775    case GL_LUMINANCE_ALPHA_INTEGER_EXT:
 776    case GL_RG_INTEGER:
 777    /* specific integer formats */
 778    case GL_RGBA32I_EXT:
 779    case GL_RGB32I_EXT:
 780    case GL_RG32I:
 781    case GL_R32I:
 782    case GL_ALPHA32I_EXT:
 783    case GL_INTENSITY32I_EXT:
 784    case GL_LUMINANCE32I_EXT:
 785    case GL_LUMINANCE_ALPHA32I_EXT:
 786    case GL_RGBA16I_EXT:
 787    case GL_RGB16I_EXT:
 788    case GL_RG16I:
 789    case GL_R16I:
 790    case GL_ALPHA16I_EXT:
 791    case GL_INTENSITY16I_EXT:
 792    case GL_LUMINANCE16I_EXT:
 793    case GL_LUMINANCE_ALPHA16I_EXT:
 794    case GL_RGBA8I_EXT:
 795    case GL_RGB8I_EXT:
 796    case GL_RG8I:
 797    case GL_R8I:
 798    case GL_ALPHA8I_EXT:
 799    case GL_INTENSITY8I_EXT:
 800    case GL_LUMINANCE8I_EXT:
 801    case GL_LUMINANCE_ALPHA8I_EXT:
 802       return GL_TRUE;
 803    default:
 804       return GL_FALSE;
 805    }
 806 }
 807
 808
 809 /**
 810  * Test if the given format is an integer (non-normalized) format.
 811  */
 812 GLboolean
 813 _mesa_is_enum_format_integer(GLenum format)
 814 {
 815    return _mesa_is_enum_format_unsigned_int(format) ||
 816           _mesa_is_enum_format_signed_int(format);
 817 }
 818
 819
 820 GLboolean
 821 _mesa_is_type_unsigned(GLenum type)
 822 {
 823    switch (type) {
 824    case GL_UNSIGNED_INT:
 825    case GL_UNSIGNED_INT_8_8_8_8:
 826    case GL_UNSIGNED_INT_8_8_8_8_REV:
 827    case GL_UNSIGNED_INT_10_10_10_2:
 828    case GL_UNSIGNED_INT_2_10_10_10_REV:
 829
 830    case GL_UNSIGNED_SHORT:
 831    case GL_UNSIGNED_SHORT_4_4_4_4:
 832    case GL_UNSIGNED_SHORT_5_5_5_1:
 833    case GL_UNSIGNED_SHORT_5_6_5:
 834    case GL_UNSIGNED_SHORT_5_6_5_REV:
 835    case GL_UNSIGNED_SHORT_4_4_4_4_REV:
 836    case GL_UNSIGNED_SHORT_1_5_5_5_REV:
 837    case GL_UNSIGNED_SHORT_8_8_MESA:
 838    case GL_UNSIGNED_SHORT_8_8_REV_MESA:
 839
 840    case GL_UNSIGNED_BYTE:
 841    case GL_UNSIGNED_BYTE_3_3_2:
 842    case GL_UNSIGNED_BYTE_2_3_3_REV:
 843       return GL_TRUE;
 844
 845    default:
 846       return GL_FALSE;
 847    }
 848 }
 849
 850
 851 /**
 852  * Test if the given image format is a color/RGBA format (i.e., not color
 853  * index, depth, stencil, etc).
 854  * \param format  the image format value (may by an internal texture format)
 855  * \return GL_TRUE if its a color/RGBA format, GL_FALSE otherwise.
 856  */
 857 GLboolean
 858 _mesa_is_color_format(GLenum format)
 859 {
 860    switch (format) {
 861       case GL_RED:
 862       case GL_GREEN:
 863       case GL_BLUE:
 864       case GL_ALPHA:
 865       case GL_ALPHA4:
 866       case GL_ALPHA8:
 867       case GL_ALPHA12:
 868       case GL_ALPHA16:
 869       case 1:
 870       case GL_LUMINANCE:
 871       case GL_LUMINANCE4:
 872       case GL_LUMINANCE8:
 873       case GL_LUMINANCE12:
 874       case GL_LUMINANCE16:
 875       case 2:
 876       case GL_LUMINANCE_ALPHA:
 877       case GL_LUMINANCE4_ALPHA4:
 878       case GL_LUMINANCE6_ALPHA2:
 879       case GL_LUMINANCE8_ALPHA8:
 880       case GL_LUMINANCE12_ALPHA4:
 881       case GL_LUMINANCE12_ALPHA12:
 882       case GL_LUMINANCE16_ALPHA16:
 883       case GL_INTENSITY:
 884       case GL_INTENSITY4:
 885       case GL_INTENSITY8:
 886       case GL_INTENSITY12:
 887       case GL_INTENSITY16:
 888       case GL_R8:
 889       case GL_R16:
 890       case GL_RG:
 891       case GL_RG8:
 892       case GL_RG16:
 893       case 3:
 894       case GL_RGB:
 895       case GL_BGR:
 896       case GL_R3_G3_B2:
 897       case GL_RGB4:
 898       case GL_RGB5:
 899       case GL_RGB565:
 900       case GL_RGB8:
 901       case GL_RGB10:
 902       case GL_RGB12:
 903       case GL_RGB16:
 904       case 4:
 905       case GL_ABGR_EXT:
 906       case GL_RGBA:
 907       case GL_BGRA:
 908       case GL_RGBA2:
 909       case GL_RGBA4:
 910       case GL_RGB5_A1:
 911       case GL_RGBA8:
 912       case GL_RGB10_A2:
 913       case GL_RGBA12:
 914       case GL_RGBA16:
 915       /* float texture formats */
 916       case GL_ALPHA16F_ARB:
 917       case GL_ALPHA32F_ARB:
 918       case GL_LUMINANCE16F_ARB:
 919       case GL_LUMINANCE32F_ARB:
 920       case GL_LUMINANCE_ALPHA16F_ARB:
 921       case GL_LUMINANCE_ALPHA32F_ARB:
 922       case GL_INTENSITY16F_ARB:
 923       case GL_INTENSITY32F_ARB:
 924       case GL_R16F:
 925       case GL_R32F:
 926       case GL_RG16F:
 927       case GL_RG32F:
 928       case GL_RGB16F_ARB:
 929       case GL_RGB32F_ARB:
 930       case GL_RGBA16F_ARB:
 931       case GL_RGBA32F_ARB:
 932       /* compressed formats */
 933       case GL_COMPRESSED_ALPHA:
 934       case GL_COMPRESSED_LUMINANCE:
 935       case GL_COMPRESSED_LUMINANCE_ALPHA:
 936       case GL_COMPRESSED_INTENSITY:
 937       case GL_COMPRESSED_RED:
 938       case GL_COMPRESSED_RG:
 939       case GL_COMPRESSED_RGB:
 940       case GL_COMPRESSED_RGBA:
 941       case GL_RGB_S3TC:
 942       case GL_RGB4_S3TC:
 943       case GL_RGBA_S3TC:
 944       case GL_RGBA4_S3TC:
 945       case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
 946       case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
 947       case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
 948       case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
 949       case GL_COMPRESSED_RGB_FXT1_3DFX:
 950       case GL_COMPRESSED_RGBA_FXT1_3DFX:
 951       case GL_SRGB_EXT:
 952       case GL_SRGB8_EXT:
 953       case GL_SRGB_ALPHA_EXT:
 954       case GL_SRGB8_ALPHA8_EXT:
 955       case GL_SLUMINANCE_ALPHA_EXT:
 956       case GL_SLUMINANCE8_ALPHA8_EXT:
 957       case GL_SLUMINANCE_EXT:
 958       case GL_SLUMINANCE8_EXT:
 959       case GL_COMPRESSED_SRGB_EXT:
 960       case GL_COMPRESSED_SRGB_S3TC_DXT1_EXT:
 961       case GL_COMPRESSED_SRGB_ALPHA_EXT:
 962       case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT:
 963       case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT:
 964       case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT:
 965       case GL_COMPRESSED_SLUMINANCE_EXT:
 966       case GL_COMPRESSED_SLUMINANCE_ALPHA_EXT:
 967       case GL_COMPRESSED_RED_RGTC1:
 968       case GL_COMPRESSED_SIGNED_RED_RGTC1:
 969       case GL_COMPRESSED_RG_RGTC2:
 970       case GL_COMPRESSED_SIGNED_RG_RGTC2:
 971       case GL_COMPRESSED_LUMINANCE_LATC1_EXT:
 972       case GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT:
 973       case GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT:
 974       case GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT:
 975       case GL_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI:
 976       case GL_ETC1_RGB8_OES:
 977       case GL_COMPRESSED_RGB8_ETC2:
 978       case GL_COMPRESSED_SRGB8_ETC2:
 979       case GL_COMPRESSED_RGBA8_ETC2_EAC:
 980       case GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC:
 981       case GL_COMPRESSED_R11_EAC:
 982       case GL_COMPRESSED_RG11_EAC:
 983       case GL_COMPRESSED_SIGNED_R11_EAC:
 984       case GL_COMPRESSED_SIGNED_RG11_EAC:
 985       case GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2:
 986       case GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2:
 987       case GL_COMPRESSED_RGBA_BPTC_UNORM:
 988       case GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM:
 989       case GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT:
 990       case GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT:
 991       /* generic integer formats */
 992       case GL_RED_INTEGER_EXT:
 993       case GL_GREEN_INTEGER_EXT:
 994       case GL_BLUE_INTEGER_EXT:
 995       case GL_ALPHA_INTEGER_EXT:
 996       case GL_RGB_INTEGER_EXT:
 997       case GL_RGBA_INTEGER_EXT:
 998       case GL_BGR_INTEGER_EXT:
 999       case GL_BGRA_INTEGER_EXT:
1000       case GL_RG_INTEGER:
1001       case GL_LUMINANCE_INTEGER_EXT:
1002       case GL_LUMINANCE_ALPHA_INTEGER_EXT:
1003       /* sized integer formats */
1004       case GL_RGBA32UI_EXT:
1005       case GL_RGB32UI_EXT:
1006       case GL_RG32UI:
1007       case GL_R32UI:
1008       case GL_ALPHA32UI_EXT:
1009       case GL_INTENSITY32UI_EXT:
1010       case GL_LUMINANCE32UI_EXT:
1011       case GL_LUMINANCE_ALPHA32UI_EXT:
1012       case GL_RGBA16UI_EXT:
1013       case GL_RGB16UI_EXT:
1014       case GL_RG16UI:
1015       case GL_R16UI:
1016       case GL_ALPHA16UI_EXT:
1017       case GL_INTENSITY16UI_EXT:
1018       case GL_LUMINANCE16UI_EXT:
1019       case GL_LUMINANCE_ALPHA16UI_EXT:
1020       case GL_RGBA8UI_EXT:
1021       case GL_RGB8UI_EXT:
1022       case GL_RG8UI:
1023       case GL_R8UI:
1024       case GL_ALPHA8UI_EXT:
1025       case GL_INTENSITY8UI_EXT:
1026       case GL_LUMINANCE8UI_EXT:
1027       case GL_LUMINANCE_ALPHA8UI_EXT:
1028       case GL_RGBA32I_EXT:
1029       case GL_RGB32I_EXT:
1030       case GL_RG32I:
1031       case GL_R32I:
1032       case GL_ALPHA32I_EXT:
1033       case GL_INTENSITY32I_EXT:
1034       case GL_LUMINANCE32I_EXT:
1035       case GL_LUMINANCE_ALPHA32I_EXT:
1036       case GL_RGBA16I_EXT:
1037       case GL_RGB16I_EXT:
1038       case GL_RG16I:
1039       case GL_R16I:
1040       case GL_ALPHA16I_EXT:
1041       case GL_INTENSITY16I_EXT:
1042       case GL_LUMINANCE16I_EXT:
1043       case GL_LUMINANCE_ALPHA16I_EXT:
1044       case GL_RGBA8I_EXT:
1045       case GL_RGB8I_EXT:
1046       case GL_RG8I:
1047       case GL_R8I:
1048       case GL_ALPHA8I_EXT:
1049       case GL_INTENSITY8I_EXT:
1050       case GL_LUMINANCE8I_EXT:
1051       case GL_LUMINANCE_ALPHA8I_EXT:
1052       /* signed, normalized texture formats */
1053       case GL_RED_SNORM:
1054       case GL_R8_SNORM:
1055       case GL_R16_SNORM:
1056       case GL_RG_SNORM:
1057       case GL_RG8_SNORM:
1058       case GL_RG16_SNORM:
1059       case GL_RGB_SNORM:
1060       case GL_RGB8_SNORM:
1061       case GL_RGB16_SNORM:
1062       case GL_RGBA_SNORM:
1063       case GL_RGBA8_SNORM:
1064       case GL_RGBA16_SNORM:
1065       case GL_ALPHA_SNORM:
1066       case GL_ALPHA8_SNORM:
1067       case GL_ALPHA16_SNORM:
1068       case GL_LUMINANCE_SNORM:
1069       case GL_LUMINANCE8_SNORM:
1070       case GL_LUMINANCE16_SNORM:
1071       case GL_LUMINANCE_ALPHA_SNORM:
1072       case GL_LUMINANCE8_ALPHA8_SNORM:
1073       case GL_LUMINANCE16_ALPHA16_SNORM:
1074       case GL_INTENSITY_SNORM:
1075       case GL_INTENSITY8_SNORM:
1076       case GL_INTENSITY16_SNORM:
1077       case GL_RGB9_E5:
1078       case GL_R11F_G11F_B10F:
1079       case GL_RGB10_A2UI:
1080          return GL_TRUE;
1081       case GL_YCBCR_MESA:  /* not considered to be RGB */
1082          /* fall-through */
1083       default:
1084          return GL_FALSE;
1085    }
1086 }
1087
1088
1089 /**
1090  * Test if the given image format is a depth component format.
1091  */
1092 GLboolean
1093 _mesa_is_depth_format(GLenum format)
1094 {
1095    switch (format) {
1096       case GL_DEPTH_COMPONENT:
1097       case GL_DEPTH_COMPONENT16:
1098       case GL_DEPTH_COMPONENT24:
1099       case GL_DEPTH_COMPONENT32:
1100       case GL_DEPTH_COMPONENT32F:
1101          return GL_TRUE;
1102       default:
1103          return GL_FALSE;
1104    }
1105 }
1106
1107
1108 /**
1109  * Test if the given image format is a stencil format.
1110  */
1111 GLboolean
1112 _mesa_is_stencil_format(GLenum format)
1113 {
1114    switch (format) {
1115       case GL_STENCIL_INDEX:
1116          return GL_TRUE;
1117       default:
1118          return GL_FALSE;
1119    }
1120 }
1121
1122
1123 /**
1124  * Test if the given image format is a YCbCr format.
1125  */
1126 GLboolean
1127 _mesa_is_ycbcr_format(GLenum format)
1128 {
1129    switch (format) {
1130       case GL_YCBCR_MESA:
1131          return GL_TRUE;
1132       default:
1133          return GL_FALSE;
1134    }
1135 }
1136
1137
1138 /**
1139  * Test if the given image format is a depth+stencil format.
1140  */
1141 GLboolean
1142 _mesa_is_depthstencil_format(GLenum format)
1143 {
1144    switch (format) {
1145       case GL_DEPTH24_STENCIL8_EXT:
1146       case GL_DEPTH_STENCIL_EXT:
1147       case GL_DEPTH32F_STENCIL8:
1148          return GL_TRUE;
1149       default:
1150          return GL_FALSE;
1151    }
1152 }
1153
1154
1155 /**
1156  * Test if the given image format is a depth or stencil format.
1157  */
1158 GLboolean
1159 _mesa_is_depth_or_stencil_format(GLenum format)
1160 {
1161    switch (format) {
1162       case GL_DEPTH_COMPONENT:
1163       case GL_DEPTH_COMPONENT16:
1164       case GL_DEPTH_COMPONENT24:
1165       case GL_DEPTH_COMPONENT32:
1166       case GL_STENCIL_INDEX:
1167       case GL_STENCIL_INDEX1_EXT:
1168       case GL_STENCIL_INDEX4_EXT:
1169       case GL_STENCIL_INDEX8_EXT:
1170       case GL_STENCIL_INDEX16_EXT:
1171       case GL_DEPTH_STENCIL_EXT:
1172       case GL_DEPTH24_STENCIL8_EXT:
1173       case GL_DEPTH_COMPONENT32F:
1174       case GL_DEPTH32F_STENCIL8:
1175          return GL_TRUE;
1176       default:
1177          return GL_FALSE;
1178    }
1179 }
1180
1181
1182 /**
1183  * Test if an image format is a supported compressed format.
1184  * \param format the internal format token provided by the user.
1185  * \return GL_TRUE if compressed, GL_FALSE if uncompressed
1186  */
1187 GLboolean
1188 _mesa_is_compressed_format(struct gl_context *ctx, GLenum format)
1189 {
1190    switch (format) {
1191    case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
1192    case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
1193    case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
1194    case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
1195       /* Assume that the ANGLE flag will always be set if the EXT flag is set.
1196        */
1197       return ctx->Extensions.ANGLE_texture_compression_dxt;
1198    case GL_RGB_S3TC:
1199    case GL_RGB4_S3TC:
1200    case GL_RGBA_S3TC:
1201    case GL_RGBA4_S3TC:
1202       return _mesa_is_desktop_gl(ctx) &&
1203          ctx->Extensions.ANGLE_texture_compression_dxt;
1204    case GL_COMPRESSED_SRGB_S3TC_DXT1_EXT:
1205    case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT:
1206    case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT:
1207    case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT:
1208       return _mesa_is_desktop_gl(ctx)
1209          && ctx->Extensions.EXT_texture_sRGB
1210          && ctx->Extensions.EXT_texture_compression_s3tc;
1211    case GL_COMPRESSED_RGB_FXT1_3DFX:
1212    case GL_COMPRESSED_RGBA_FXT1_3DFX:
1213       return _mesa_is_desktop_gl(ctx)
1214          && ctx->Extensions.TDFX_texture_compression_FXT1;
1215    case GL_COMPRESSED_RED_RGTC1:
1216    case GL_COMPRESSED_SIGNED_RED_RGTC1:
1217    case GL_COMPRESSED_RG_RGTC2:
1218    case GL_COMPRESSED_SIGNED_RG_RGTC2:
1219       return _mesa_is_desktop_gl(ctx)
1220          && ctx->Extensions.ARB_texture_compression_rgtc;
1221    case GL_COMPRESSED_LUMINANCE_LATC1_EXT:
1222    case GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT:
1223    case GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT:
1224    case GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT:
1225       return ctx->API == API_OPENGL_COMPAT
1226          && ctx->Extensions.EXT_texture_compression_latc;
1227    case GL_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI:
1228       return ctx->API == API_OPENGL_COMPAT
1229          && ctx->Extensions.ATI_texture_compression_3dc;
1230    case GL_ETC1_RGB8_OES:
1231       return _mesa_is_gles(ctx)
1232          && ctx->Extensions.OES_compressed_ETC1_RGB8_texture;
1233    case GL_COMPRESSED_RGB8_ETC2:
1234    case GL_COMPRESSED_SRGB8_ETC2:
1235    case GL_COMPRESSED_RGBA8_ETC2_EAC:
1236    case GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC:
1237    case GL_COMPRESSED_R11_EAC:
1238    case GL_COMPRESSED_RG11_EAC:
1239    case GL_COMPRESSED_SIGNED_R11_EAC:
1240    case GL_COMPRESSED_SIGNED_RG11_EAC:
1241    case GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2:
1242    case GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2:
1243       return _mesa_is_gles3(ctx) || ctx->Extensions.ARB_ES3_compatibility;
1244    case GL_COMPRESSED_RGBA_BPTC_UNORM:
1245    case GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM:
1246    case GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT:
1247    case GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT:
1248       return _mesa_is_desktop_gl(ctx) &&
1249          ctx->Extensions.ARB_texture_compression_bptc;
1250    case GL_PALETTE4_RGB8_OES:
1251    case GL_PALETTE4_RGBA8_OES:
1252    case GL_PALETTE4_R5_G6_B5_OES:
1253    case GL_PALETTE4_RGBA4_OES:
1254    case GL_PALETTE4_RGB5_A1_OES:
1255    case GL_PALETTE8_RGB8_OES:
1256    case GL_PALETTE8_RGBA8_OES:
1257    case GL_PALETTE8_R5_G6_B5_OES:
1258    case GL_PALETTE8_RGBA4_OES:
1259    case GL_PALETTE8_RGB5_A1_OES:
1260       return ctx->API == API_OPENGLES;
1261    default:
1262       return GL_FALSE;
1263    }
1264 }
1265
1266
1267 /**
1268  * Convert various base formats to the cooresponding integer format.
1269  */
1270 GLenum
1271 _mesa_base_format_to_integer_format(GLenum format)
1272 {
1273    switch(format) {
1274    case GL_RED:
1275       return GL_RED_INTEGER;
1276    case GL_GREEN:
1277       return GL_GREEN_INTEGER;
1278    case GL_BLUE:
1279       return GL_BLUE_INTEGER;
1280    case GL_RG:
1281       return GL_RG_INTEGER;
1282    case GL_RGB:
1283       return GL_RGB_INTEGER;
1284    case GL_RGBA:
1285       return GL_RGBA_INTEGER;
1286    case GL_BGR:
1287       return GL_BGR_INTEGER;
1288    case GL_BGRA:
1289       return GL_BGRA_INTEGER;
1290    case GL_ALPHA:
1291       return GL_ALPHA_INTEGER;
1292    case GL_LUMINANCE:
1293       return GL_LUMINANCE_INTEGER_EXT;
1294    case GL_LUMINANCE_ALPHA:
1295       return GL_LUMINANCE_ALPHA_INTEGER_EXT;
1296    }
1297
1298    return format;
1299 }
1300
1301
1302 /**
1303  * Does the given base texture/renderbuffer format have the channel
1304  * named by 'pname'?
1305  */
1306 GLboolean
1307 _mesa_base_format_has_channel(GLenum base_format, GLenum pname)
1308 {
1309    switch (pname) {
1310    case GL_TEXTURE_RED_SIZE:
1311    case GL_TEXTURE_RED_TYPE:
1312    case GL_RENDERBUFFER_RED_SIZE_EXT:
1313    case GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE:
1314       if (base_format == GL_RED ||
1315           base_format == GL_RG ||
1316           base_format == GL_RGB ||
1317           base_format == GL_RGBA) {
1318          return GL_TRUE;
1319       }
1320       return GL_FALSE;
1321    case GL_TEXTURE_GREEN_SIZE:
1322    case GL_TEXTURE_GREEN_TYPE:
1323    case GL_RENDERBUFFER_GREEN_SIZE_EXT:
1324    case GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE:
1325       if (base_format == GL_RG ||
1326           base_format == GL_RGB ||
1327           base_format == GL_RGBA) {
1328          return GL_TRUE;
1329       }
1330       return GL_FALSE;
1331    case GL_TEXTURE_BLUE_SIZE:
1332    case GL_TEXTURE_BLUE_TYPE:
1333    case GL_RENDERBUFFER_BLUE_SIZE_EXT:
1334    case GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE:
1335       if (base_format == GL_RGB ||
1336           base_format == GL_RGBA) {
1337          return GL_TRUE;
1338       }
1339       return GL_FALSE;
1340    case GL_TEXTURE_ALPHA_SIZE:
1341    case GL_TEXTURE_ALPHA_TYPE:
1342    case GL_RENDERBUFFER_ALPHA_SIZE_EXT:
1343    case GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE:
1344       if (base_format == GL_RGBA ||
1345           base_format == GL_ALPHA ||
1346           base_format == GL_LUMINANCE_ALPHA) {
1347          return GL_TRUE;
1348       }
1349       return GL_FALSE;
1350    case GL_TEXTURE_LUMINANCE_SIZE:
1351    case GL_TEXTURE_LUMINANCE_TYPE:
1352       if (base_format == GL_LUMINANCE ||
1353           base_format == GL_LUMINANCE_ALPHA) {
1354          return GL_TRUE;
1355       }
1356       return GL_FALSE;
1357    case GL_TEXTURE_INTENSITY_SIZE:
1358    case GL_TEXTURE_INTENSITY_TYPE:
1359       if (base_format == GL_INTENSITY) {
1360          return GL_TRUE;
1361       }
1362       return GL_FALSE;
1363    case GL_TEXTURE_DEPTH_SIZE:
1364    case GL_TEXTURE_DEPTH_TYPE:
1365    case GL_RENDERBUFFER_DEPTH_SIZE_EXT:
1366    case GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE:
1367       if (base_format == GL_DEPTH_STENCIL ||
1368           base_format == GL_DEPTH_COMPONENT) {
1369          return GL_TRUE;
1370       }
1371       return GL_FALSE;
1372    case GL_RENDERBUFFER_STENCIL_SIZE_EXT:
1373    case GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE:
1374       if (base_format == GL_DEPTH_STENCIL ||
1375           base_format == GL_STENCIL_INDEX) {
1376          return GL_TRUE;
1377       }
1378       return GL_FALSE;
1379    default:
1380       _mesa_warning(NULL, "%s: Unexpected channel token 0x%x\n",
1381                     __FUNCTION__, pname);
1382       return GL_FALSE;
1383    }
1384
1385    return GL_FALSE;
1386 }
1387
1388
1389 /**
1390  * Returns the number of channels/components for a base format.
1391  */
1392 GLint
1393 _mesa_base_format_component_count(GLenum base_format)
1394 {
1395    switch (base_format) {
1396    case GL_RED:
1397    case GL_ALPHA:
1398    case GL_INTENSITY:
1399    case GL_DEPTH_COMPONENT:
1400       return 1;
1401    case GL_RG:
1402    case GL_LUMINANCE_ALPHA:
1403    case GL_DEPTH_STENCIL:
1404       return 2;
1405    case GL_RGB:
1406       return 3;
1407    case GL_RGBA:
1408       return 4;
1409    default:
1410       return -1;
1411    }
1412 }
1413
1414
1415 /**
1416  * If format is a generic compressed format, return the corresponding
1417  * non-compressed format.  For other formats, return the format as-is.
1418  */
1419 GLenum
1420 _mesa_generic_compressed_format_to_uncompressed_format(GLenum format)
1421 {
1422    switch (format) {
1423    case GL_COMPRESSED_RED:
1424       return GL_RED;
1425    case GL_COMPRESSED_RG:
1426       return GL_RG;
1427    case GL_COMPRESSED_RGB:
1428       return GL_RGB;
1429    case GL_COMPRESSED_RGBA:
1430       return GL_RGBA;
1431    case GL_COMPRESSED_ALPHA:
1432       return GL_ALPHA;
1433    case GL_COMPRESSED_LUMINANCE:
1434       return GL_LUMINANCE;
1435    case GL_COMPRESSED_LUMINANCE_ALPHA:
1436       return GL_LUMINANCE_ALPHA;
1437    case GL_COMPRESSED_INTENSITY:
1438       return GL_INTENSITY;
1439    /* sRGB formats */
1440    case GL_COMPRESSED_SRGB:
1441       return GL_SRGB;
1442    case GL_COMPRESSED_SRGB_ALPHA:
1443       return GL_SRGB_ALPHA;
1444    case GL_COMPRESSED_SLUMINANCE:
1445       return GL_SLUMINANCE;
1446    case GL_COMPRESSED_SLUMINANCE_ALPHA:
1447       return GL_SLUMINANCE_ALPHA;
1448    default:
1449       return format;
1450    }
1451 }
1452
1453
1454 /**
1455  * Return the equivalent non-generic internal format.
1456  * This is useful for comparing whether two internal formats are equivalent.
1457  */
1458 GLenum
1459 _mesa_get_nongeneric_internalformat(GLenum format)
1460 {
1461    switch (format) {
1462    /* GL 1.1 formats. */
1463    case 4:
1464    case GL_RGBA:
1465       return GL_RGBA8;
1466    case 3:
1467    case GL_RGB:
1468       return GL_RGB8;
1469    case 2:
1470    case GL_LUMINANCE_ALPHA:
1471       return GL_LUMINANCE8_ALPHA8;
1472    case 1:
1473    case GL_LUMINANCE:
1474       return GL_LUMINANCE8;
1475    case GL_ALPHA:
1476       return GL_ALPHA8;
1477    case GL_INTENSITY:
1478       return GL_INTENSITY8;
1479
1480    /* GL_ARB_texture_rg */
1481    case GL_RED:
1482       return GL_R8;
1483    case GL_RG:
1484       return GL_RG8;
1485
1486    /* GL_EXT_texture_sRGB */
1487    case GL_SRGB:
1488       return GL_SRGB8;
1489    case GL_SRGB_ALPHA:
1490       return GL_SRGB8_ALPHA8;
1491    case GL_SLUMINANCE:
1492       return GL_SLUMINANCE8;
1493    case GL_SLUMINANCE_ALPHA:
1494       return GL_SLUMINANCE8_ALPHA8;
1495
1496    /* GL_EXT_texture_snorm */
1497    case GL_RGBA_SNORM:
1498       return GL_RGBA8_SNORM;
1499    case GL_RGB_SNORM:
1500       return GL_RGB8_SNORM;
1501    case GL_RG_SNORM:
1502       return GL_RG8_SNORM;
1503    case GL_RED_SNORM:
1504       return GL_R8_SNORM;
1505    case GL_LUMINANCE_ALPHA_SNORM:
1506       return GL_LUMINANCE8_ALPHA8_SNORM;
1507    case GL_LUMINANCE_SNORM:
1508       return GL_LUMINANCE8_SNORM;
1509    case GL_ALPHA_SNORM:
1510       return GL_ALPHA8_SNORM;
1511    case GL_INTENSITY_SNORM:
1512       return GL_INTENSITY8_SNORM;
1513
1514    default:
1515       return format;
1516    }
1517 }
1518
1519
1520 /**
1521  * Convert an sRGB internal format to linear.
1522  */
1523 GLenum
1524 _mesa_get_linear_internalformat(GLenum format)
1525 {
1526    switch (format) {
1527    case GL_SRGB:
1528       return GL_RGB;
1529    case GL_SRGB_ALPHA:
1530       return GL_RGBA;
1531    case GL_SRGB8:
1532       return GL_RGB8;
1533    case GL_SRGB8_ALPHA8:
1534       return GL_RGBA8;
1535    case GL_SLUMINANCE8:
1536       return GL_LUMINANCE8;
1537    case GL_SLUMINANCE:
1538       return GL_LUMINANCE;
1539    case GL_SLUMINANCE_ALPHA:
1540       return GL_LUMINANCE_ALPHA;
1541    case GL_SLUMINANCE8_ALPHA8:
1542       return GL_LUMINANCE8_ALPHA8;
1543    default:
1544       return format;
1545    }
1546 }
1547
1548
1549 /**
1550  * Do error checking of format/type combinations for glReadPixels,
1551  * glDrawPixels and glTex[Sub]Image.  Note that depending on the format
1552  * and type values, we may either generate GL_INVALID_OPERATION or
1553  * GL_INVALID_ENUM.
1554  *
1555  * \param format pixel format.
1556  * \param type pixel type.
1557  *
1558  * \return GL_INVALID_ENUM, GL_INVALID_OPERATION or GL_NO_ERROR
1559  */
1560 GLenum
1561 _mesa_error_check_format_and_type(const struct gl_context *ctx,
1562                                   GLenum format, GLenum type)
1563 {
1564    /* From OpenGL 3.3 spec, page 220:
1565     *    "If the format is DEPTH_STENCIL, then values are taken from
1566     *    both the depth buffer and the stencil buffer. If there is no
1567     *    depth buffer or if there is no stencil buffer, then the error
1568     *    INVALID_OPERATION occurs. If the type parameter is not
1569     *    UNSIGNED_INT_24_8 or FLOAT_32_UNSIGNED_INT_24_8_REV, then the
1570     *    error INVALID_ENUM occurs."
1571     *
1572     * OpenGL ES still generates GL_INVALID_OPERATION because glReadPixels
1573     * cannot be used to read depth or stencil in that API.
1574     */
1575    if (_mesa_is_desktop_gl(ctx) && format == GL_DEPTH_STENCIL
1576        && type != GL_UNSIGNED_INT_24_8
1577        && type != GL_FLOAT_32_UNSIGNED_INT_24_8_REV)
1578       return GL_INVALID_ENUM;
1579
1580    /* special type-based checks (see glReadPixels, glDrawPixels error lists) */
1581    switch (type) {
1582    case GL_BITMAP:
1583       if (format != GL_COLOR_INDEX && format != GL_STENCIL_INDEX) {
1584          return GL_INVALID_ENUM;
1585       }
1586       break;
1587
1588    case GL_UNSIGNED_BYTE_3_3_2:
1589    case GL_UNSIGNED_BYTE_2_3_3_REV:
1590    case GL_UNSIGNED_SHORT_5_6_5:
1591    case GL_UNSIGNED_SHORT_5_6_5_REV:
1592       if (format == GL_RGB) {
1593          break; /* OK */
1594       }
1595       if (format == GL_RGB_INTEGER_EXT &&
1596           ctx->Extensions.ARB_texture_rgb10_a2ui) {
1597          break; /* OK */
1598       }
1599       return GL_INVALID_OPERATION;
1600
1601    case GL_UNSIGNED_SHORT_4_4_4_4:
1602    case GL_UNSIGNED_SHORT_4_4_4_4_REV:
1603    case GL_UNSIGNED_SHORT_5_5_5_1:
1604    case GL_UNSIGNED_SHORT_1_5_5_5_REV:
1605    case GL_UNSIGNED_INT_8_8_8_8:
1606    case GL_UNSIGNED_INT_8_8_8_8_REV:
1607    case GL_UNSIGNED_INT_10_10_10_2:
1608    case GL_UNSIGNED_INT_2_10_10_10_REV:
1609       if (format == GL_RGBA ||
1610           format == GL_BGRA ||
1611           format == GL_ABGR_EXT) {
1612          break; /* OK */
1613       }
1614       if ((format == GL_RGBA_INTEGER_EXT || format == GL_BGRA_INTEGER_EXT) &&
1615           ctx->Extensions.ARB_texture_rgb10_a2ui) {
1616          break; /* OK */
1617       }
1618       if (type == GL_UNSIGNED_INT_2_10_10_10_REV && format == GL_RGB &&
1619           ctx->API == API_OPENGLES2) {
1620          break; /* OK by GL_EXT_texture_type_2_10_10_10_REV */
1621       }
1622       return GL_INVALID_OPERATION;
1623
1624    case GL_UNSIGNED_INT_24_8:
1625       if (format != GL_DEPTH_STENCIL) {
1626          return GL_INVALID_OPERATION;
1627       }
1628       return GL_NO_ERROR;
1629
1630    case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
1631       if (!ctx->Extensions.ARB_depth_buffer_float) {
1632          return GL_INVALID_ENUM;
1633       }
1634       if (format != GL_DEPTH_STENCIL) {
1635          return GL_INVALID_OPERATION;
1636       }
1637       return GL_NO_ERROR;
1638
1639    case GL_UNSIGNED_INT_10F_11F_11F_REV:
1640       if (!ctx->Extensions.EXT_packed_float) {
1641          return GL_INVALID_ENUM;
1642       }
1643       if (format != GL_RGB) {
1644          return GL_INVALID_OPERATION;
1645       }
1646       return GL_NO_ERROR;
1647
1648    default:
1649       ; /* fall-through */
1650    }
1651
1652    /* now, for each format, check the type for compatibility */
1653    switch (format) {
1654       case GL_COLOR_INDEX:
1655       case GL_STENCIL_INDEX:
1656          switch (type) {
1657             case GL_BITMAP:
1658             case GL_BYTE:
1659             case GL_UNSIGNED_BYTE:
1660             case GL_SHORT:
1661             case GL_UNSIGNED_SHORT:
1662             case GL_INT:
1663             case GL_UNSIGNED_INT:
1664             case GL_FLOAT:
1665             case GL_HALF_FLOAT:
1666                return GL_NO_ERROR;
1667             default:
1668                return GL_INVALID_ENUM;
1669          }
1670
1671       case GL_RED:
1672       case GL_GREEN:
1673       case GL_BLUE:
1674       case GL_ALPHA:
1675 #if 0 /* not legal!  see table 3.6 of the 1.5 spec */
1676       case GL_INTENSITY:
1677 #endif
1678       case GL_LUMINANCE:
1679       case GL_LUMINANCE_ALPHA:
1680       case GL_DEPTH_COMPONENT:
1681          switch (type) {
1682             case GL_BYTE:
1683             case GL_UNSIGNED_BYTE:
1684             case GL_SHORT:
1685             case GL_UNSIGNED_SHORT:
1686             case GL_INT:
1687             case GL_UNSIGNED_INT:
1688             case GL_FLOAT:
1689             case GL_HALF_FLOAT:
1690                return GL_NO_ERROR;
1691             default:
1692                return GL_INVALID_ENUM;
1693          }
1694
1695       case GL_RG:
1696          if (!ctx->Extensions.ARB_texture_rg)
1697             return GL_INVALID_ENUM;
1698          switch (type) {
1699             case GL_BYTE:
1700             case GL_UNSIGNED_BYTE:
1701             case GL_SHORT:
1702             case GL_UNSIGNED_SHORT:
1703             case GL_INT:
1704             case GL_UNSIGNED_INT:
1705             case GL_FLOAT:
1706             case GL_HALF_FLOAT:
1707                return GL_NO_ERROR;
1708             default:
1709                return GL_INVALID_ENUM;
1710          }
1711
1712       case GL_RGB:
1713          switch (type) {
1714             case GL_BYTE:
1715             case GL_UNSIGNED_BYTE:
1716             case GL_SHORT:
1717             case GL_UNSIGNED_SHORT:
1718             case GL_INT:
1719             case GL_UNSIGNED_INT:
1720             case GL_FLOAT:
1721             case GL_UNSIGNED_BYTE_3_3_2:
1722             case GL_UNSIGNED_BYTE_2_3_3_REV:
1723             case GL_UNSIGNED_SHORT_5_6_5:
1724             case GL_UNSIGNED_SHORT_5_6_5_REV:
1725             case GL_HALF_FLOAT:
1726                return GL_NO_ERROR;
1727             case GL_UNSIGNED_INT_2_10_10_10_REV:
1728                /* OK by GL_EXT_texture_type_2_10_10_10_REV */
1729                return (ctx->API == API_OPENGLES2)
1730                   ? GL_NO_ERROR : GL_INVALID_ENUM;
1731             case GL_UNSIGNED_INT_5_9_9_9_REV:
1732                return ctx->Extensions.EXT_texture_shared_exponent
1733                   ? GL_NO_ERROR : GL_INVALID_ENUM;
1734             case GL_UNSIGNED_INT_10F_11F_11F_REV:
1735                return ctx->Extensions.EXT_packed_float
1736                   ? GL_NO_ERROR : GL_INVALID_ENUM;
1737             default:
1738                return GL_INVALID_ENUM;
1739          }
1740
1741       case GL_BGR:
1742          switch (type) {
1743             /* NOTE: no packed types are supported with BGR.  That's
1744              * intentional, according to the GL spec.
1745              */
1746             case GL_BYTE:
1747             case GL_UNSIGNED_BYTE:
1748             case GL_SHORT:
1749             case GL_UNSIGNED_SHORT:
1750             case GL_INT:
1751             case GL_UNSIGNED_INT:
1752             case GL_FLOAT:
1753             case GL_HALF_FLOAT:
1754                return GL_NO_ERROR;
1755             default:
1756                return GL_INVALID_ENUM;
1757          }
1758
1759       case GL_RGBA:
1760       case GL_BGRA:
1761       case GL_ABGR_EXT:
1762          switch (type) {
1763             case GL_BYTE:
1764             case GL_UNSIGNED_BYTE:
1765             case GL_SHORT:
1766             case GL_UNSIGNED_SHORT:
1767             case GL_INT:
1768             case GL_UNSIGNED_INT:
1769             case GL_FLOAT:
1770             case GL_UNSIGNED_SHORT_4_4_4_4:
1771             case GL_UNSIGNED_SHORT_4_4_4_4_REV:
1772             case GL_UNSIGNED_SHORT_5_5_5_1:
1773             case GL_UNSIGNED_SHORT_1_5_5_5_REV:
1774             case GL_UNSIGNED_INT_8_8_8_8:
1775             case GL_UNSIGNED_INT_8_8_8_8_REV:
1776             case GL_UNSIGNED_INT_10_10_10_2:
1777             case GL_UNSIGNED_INT_2_10_10_10_REV:
1778             case GL_HALF_FLOAT:
1779                return GL_NO_ERROR;
1780             default:
1781                return GL_INVALID_ENUM;
1782          }
1783
1784       case GL_YCBCR_MESA:
1785          if (!ctx->Extensions.MESA_ycbcr_texture)
1786             return GL_INVALID_ENUM;
1787          if (type == GL_UNSIGNED_SHORT_8_8_MESA ||
1788              type == GL_UNSIGNED_SHORT_8_8_REV_MESA)
1789             return GL_NO_ERROR;
1790          else
1791             return GL_INVALID_OPERATION;
1792
1793       case GL_DEPTH_STENCIL:
1794          if (type == GL_UNSIGNED_INT_24_8)
1795             return GL_NO_ERROR;
1796          else if (ctx->Extensions.ARB_depth_buffer_float &&
1797              type == GL_FLOAT_32_UNSIGNED_INT_24_8_REV)
1798             return GL_NO_ERROR;
1799          else
1800             return GL_INVALID_ENUM;
1801
1802       /* integer-valued formats */
1803       case GL_RED_INTEGER_EXT:
1804       case GL_GREEN_INTEGER_EXT:
1805       case GL_BLUE_INTEGER_EXT:
1806       case GL_ALPHA_INTEGER_EXT:
1807       case GL_RG_INTEGER:
1808          switch (type) {
1809             case GL_BYTE:
1810             case GL_UNSIGNED_BYTE:
1811             case GL_SHORT:
1812             case GL_UNSIGNED_SHORT:
1813             case GL_INT:
1814             case GL_UNSIGNED_INT:
1815                return (ctx->Version >= 30 ||
1816                        ctx->Extensions.EXT_texture_integer)
1817                   ? GL_NO_ERROR : GL_INVALID_ENUM;
1818             default:
1819                return GL_INVALID_ENUM;
1820          }
1821
1822       case GL_RGB_INTEGER_EXT:
1823          switch (type) {
1824             case GL_BYTE:
1825             case GL_UNSIGNED_BYTE:
1826             case GL_SHORT:
1827             case GL_UNSIGNED_SHORT:
1828             case GL_INT:
1829             case GL_UNSIGNED_INT:
1830                return (ctx->Version >= 30 ||
1831                        ctx->Extensions.EXT_texture_integer)
1832                   ? GL_NO_ERROR : GL_INVALID_ENUM;
1833             case GL_UNSIGNED_BYTE_3_3_2:
1834             case GL_UNSIGNED_BYTE_2_3_3_REV:
1835             case GL_UNSIGNED_SHORT_5_6_5:
1836             case GL_UNSIGNED_SHORT_5_6_5_REV:
1837                return ctx->Extensions.ARB_texture_rgb10_a2ui
1838                   ? GL_NO_ERROR : GL_INVALID_ENUM;
1839             default:
1840                return GL_INVALID_ENUM;
1841          }
1842
1843       case GL_BGR_INTEGER_EXT:
1844          switch (type) {
1845             case GL_BYTE:
1846             case GL_UNSIGNED_BYTE:
1847             case GL_SHORT:
1848             case GL_UNSIGNED_SHORT:
1849             case GL_INT:
1850             case GL_UNSIGNED_INT:
1851             /* NOTE: no packed formats w/ BGR format */
1852                return (ctx->Version >= 30 ||
1853                        ctx->Extensions.EXT_texture_integer)
1854                   ? GL_NO_ERROR : GL_INVALID_ENUM;
1855             default:
1856                return GL_INVALID_ENUM;
1857          }
1858
1859       case GL_RGBA_INTEGER_EXT:
1860       case GL_BGRA_INTEGER_EXT:
1861          switch (type) {
1862             case GL_BYTE:
1863             case GL_UNSIGNED_BYTE:
1864             case GL_SHORT:
1865             case GL_UNSIGNED_SHORT:
1866             case GL_INT:
1867             case GL_UNSIGNED_INT:
1868                return (ctx->Version >= 30 ||
1869                        ctx->Extensions.EXT_texture_integer)
1870                   ? GL_NO_ERROR : GL_INVALID_ENUM;
1871             case GL_UNSIGNED_SHORT_4_4_4_4:
1872             case GL_UNSIGNED_SHORT_4_4_4_4_REV:
1873             case GL_UNSIGNED_SHORT_5_5_5_1:
1874             case GL_UNSIGNED_SHORT_1_5_5_5_REV:
1875             case GL_UNSIGNED_INT_8_8_8_8:
1876             case GL_UNSIGNED_INT_8_8_8_8_REV:
1877             case GL_UNSIGNED_INT_10_10_10_2:
1878             case GL_UNSIGNED_INT_2_10_10_10_REV:
1879                return ctx->Extensions.ARB_texture_rgb10_a2ui
1880                   ? GL_NO_ERROR : GL_INVALID_ENUM;
1881             default:
1882                return GL_INVALID_ENUM;
1883          }
1884
1885       case GL_LUMINANCE_INTEGER_EXT:
1886       case GL_LUMINANCE_ALPHA_INTEGER_EXT:
1887          switch (type) {
1888             case GL_BYTE:
1889             case GL_UNSIGNED_BYTE:
1890             case GL_SHORT:
1891             case GL_UNSIGNED_SHORT:
1892             case GL_INT:
1893             case GL_UNSIGNED_INT:
1894                return ctx->Extensions.EXT_texture_integer
1895                   ? GL_NO_ERROR : GL_INVALID_ENUM;
1896             default:
1897                return GL_INVALID_ENUM;
1898          }
1899
1900       default:
1901          return GL_INVALID_ENUM;
1902    }
1903    return GL_NO_ERROR;
1904 }
1905
1906
1907 /**
1908  * Do error checking of format/type combinations for OpenGL ES glReadPixels
1909  * and glTex[Sub]Image.
1910  * \return error code, or GL_NO_ERROR.
1911  */
1912 GLenum
1913 _mesa_es_error_check_format_and_type(GLenum format, GLenum type,
1914                                      unsigned dimensions)
1915 {
1916    GLboolean type_valid = GL_TRUE;
1917
1918    switch (format) {
1919    case GL_ALPHA:
1920    case GL_LUMINANCE:
1921    case GL_LUMINANCE_ALPHA:
1922       type_valid = (type == GL_UNSIGNED_BYTE
1923                     || type == GL_FLOAT
1924                     || type == GL_HALF_FLOAT_OES);
1925       break;
1926
1927    case GL_RGB:
1928       type_valid = (type == GL_UNSIGNED_BYTE
1929                     || type == GL_UNSIGNED_SHORT_5_6_5
1930                     || type == GL_FLOAT
1931                     || type == GL_HALF_FLOAT_OES);
1932       break;
1933
1934    case GL_RGBA:
1935       type_valid = (type == GL_UNSIGNED_BYTE
1936                     || type == GL_UNSIGNED_SHORT_4_4_4_4
1937                     || type == GL_UNSIGNED_SHORT_5_5_5_1
1938                     || type == GL_FLOAT
1939                     || type == GL_HALF_FLOAT_OES
1940                     || type == GL_UNSIGNED_INT_2_10_10_10_REV);
1941       break;
1942
1943    case GL_DEPTH_COMPONENT:
1944       /* This format is filtered against invalid dimensionalities elsewhere.
1945        */
1946       type_valid = (type == GL_UNSIGNED_SHORT
1947                     || type == GL_UNSIGNED_INT);
1948       break;
1949
1950    case GL_DEPTH_STENCIL:
1951       /* This format is filtered against invalid dimensionalities elsewhere.
1952        */
1953       type_valid = (type == GL_UNSIGNED_INT_24_8);
1954       break;
1955
1956    case GL_BGRA_EXT:
1957       type_valid = (type == GL_UNSIGNED_BYTE);
1958
1959       /* This feels like a bug in the EXT_texture_format_BGRA8888 spec, but
1960        * the format does not appear to be allowed for 3D textures in OpenGL
1961        * ES.
1962        */
1963       if (dimensions != 2)
1964          return GL_INVALID_VALUE;
1965
1966       break;
1967
1968    default:
1969       return GL_INVALID_VALUE;
1970    }
1971
1972    return type_valid ? GL_NO_ERROR : GL_INVALID_OPERATION;
1973 }
1974
1975
1976 /**
1977  * Do error checking of format/type combinations for OpenGL ES 3
1978  * glTex[Sub]Image.
1979  * \return error code, or GL_NO_ERROR.
1980  */
1981 GLenum
1982 _mesa_es3_error_check_format_and_type(GLenum format, GLenum type,
1983                                       GLenum internalFormat)
1984 {
1985    switch (format) {
1986    case GL_RGBA:
1987       switch (type) {
1988       case GL_UNSIGNED_BYTE:
1989          switch (internalFormat) {
1990          case GL_RGBA:
1991          case GL_RGBA8:
1992          case GL_RGB5_A1:
1993          case GL_RGBA4:
1994          case GL_SRGB8_ALPHA8_EXT:
1995             break;
1996          default:
1997             return GL_INVALID_OPERATION;
1998          }
1999          break;
2000
2001       case GL_BYTE:
2002          if (internalFormat != GL_RGBA8_SNORM)
2003             return GL_INVALID_OPERATION;
2004          break;
2005
2006       case GL_UNSIGNED_SHORT_4_4_4_4:
2007          switch (internalFormat) {
2008          case GL_RGBA:
2009          case GL_RGBA4:
2010             break;
2011          default:
2012             return GL_INVALID_OPERATION;
2013          }
2014          break;
2015
2016       case GL_UNSIGNED_SHORT_5_5_5_1:
2017          switch (internalFormat) {
2018          case GL_RGBA:
2019          case GL_RGB5_A1:
2020             break;
2021          default:
2022             return GL_INVALID_OPERATION;
2023          }
2024          break;
2025
2026       case GL_UNSIGNED_INT_2_10_10_10_REV:
2027          switch (internalFormat) {
2028          case GL_RGBA: /* GL_EXT_texture_type_2_10_10_10_REV */
2029          case GL_RGB10_A2:
2030          case GL_RGB5_A1:
2031             break;
2032          default:
2033             return GL_INVALID_OPERATION;
2034          }
2035          break;
2036
2037       case GL_HALF_FLOAT:
2038          if (internalFormat != GL_RGBA16F)
2039             return GL_INVALID_OPERATION;
2040          break;
2041
2042       case GL_FLOAT:
2043          switch (internalFormat) {
2044          case GL_RGBA16F:
2045          case GL_RGBA32F:
2046             break;
2047          default:
2048             return GL_INVALID_OPERATION;
2049          }
2050          break;
2051
2052       default:
2053          return GL_INVALID_OPERATION;
2054       }
2055       break;
2056
2057    case GL_RGBA_INTEGER:
2058       switch (type) {
2059       case GL_UNSIGNED_BYTE:
2060          if (internalFormat != GL_RGBA8UI)
2061             return GL_INVALID_OPERATION;
2062          break;
2063
2064       case GL_BYTE:
2065          if (internalFormat != GL_RGBA8I)
2066             return GL_INVALID_OPERATION;
2067          break;
2068
2069       case GL_UNSIGNED_SHORT:
2070          if (internalFormat != GL_RGBA16UI)
2071             return GL_INVALID_OPERATION;
2072          break;
2073
2074       case GL_SHORT:
2075          if (internalFormat != GL_RGBA16I)
2076             return GL_INVALID_OPERATION;
2077          break;
2078
2079       case GL_UNSIGNED_INT:
2080          if (internalFormat != GL_RGBA32UI)
2081             return GL_INVALID_OPERATION;
2082          break;
2083
2084       case GL_INT:
2085          if (internalFormat != GL_RGBA32I)
2086             return GL_INVALID_OPERATION;
2087          break;
2088
2089       case GL_UNSIGNED_INT_2_10_10_10_REV:
2090          if (internalFormat != GL_RGB10_A2UI)
2091             return GL_INVALID_OPERATION;
2092          break;
2093
2094       default:
2095          return GL_INVALID_OPERATION;
2096       }
2097       break;
2098
2099    case GL_RGB:
2100       switch (type) {
2101       case GL_UNSIGNED_BYTE:
2102          switch (internalFormat) {
2103          case GL_RGB:
2104          case GL_RGB8:
2105          case GL_RGB565:
2106          case GL_SRGB8:
2107             break;
2108          default:
2109             return GL_INVALID_OPERATION;
2110          }
2111          break;
2112
2113       case GL_BYTE:
2114          if (internalFormat != GL_RGB8_SNORM)
2115             return GL_INVALID_OPERATION;
2116          break;
2117
2118       case GL_UNSIGNED_SHORT_5_6_5:
2119          switch (internalFormat) {
2120          case GL_RGB:
2121          case GL_RGB565:
2122             break;
2123          default:
2124             return GL_INVALID_OPERATION;
2125          }
2126          break;
2127
2128       case GL_UNSIGNED_INT_10F_11F_11F_REV:
2129          if (internalFormat != GL_R11F_G11F_B10F)
2130             return GL_INVALID_OPERATION;
2131          break;
2132
2133       case GL_UNSIGNED_INT_5_9_9_9_REV:
2134          if (internalFormat != GL_RGB9_E5)
2135             return GL_INVALID_OPERATION;
2136          break;
2137
2138       case GL_HALF_FLOAT:
2139          switch (internalFormat) {
2140          case GL_RGB16F:
2141          case GL_R11F_G11F_B10F:
2142          case GL_RGB9_E5:
2143             break;
2144          default:
2145             return GL_INVALID_OPERATION;
2146          }
2147          break;
2148
2149       case GL_FLOAT:
2150          switch (internalFormat) {
2151          case GL_RGB16F:
2152          case GL_RGB32F:
2153          case GL_R11F_G11F_B10F:
2154          case GL_RGB9_E5:
2155             break;
2156          default:
2157             return GL_INVALID_OPERATION;
2158          }
2159          break;
2160
2161       case GL_UNSIGNED_INT_2_10_10_10_REV:
2162          switch (internalFormat) {
2163          case GL_RGB: /* GL_EXT_texture_type_2_10_10_10_REV */
2164             break;
2165          default:
2166             return GL_INVALID_OPERATION;
2167          }
2168          break;
2169
2170       default:
2171          return GL_INVALID_OPERATION;
2172       }
2173       break;
2174
2175    case GL_RGB_INTEGER:
2176       switch (type) {
2177       case GL_UNSIGNED_BYTE:
2178          if (internalFormat != GL_RGB8UI)
2179             return GL_INVALID_OPERATION;
2180          break;
2181
2182       case GL_BYTE:
2183          if (internalFormat != GL_RGB8I)
2184             return GL_INVALID_OPERATION;
2185          break;
2186
2187       case GL_UNSIGNED_SHORT:
2188          if (internalFormat != GL_RGB16UI)
2189             return GL_INVALID_OPERATION;
2190          break;
2191
2192       case GL_SHORT:
2193          if (internalFormat != GL_RGB16I)
2194             return GL_INVALID_OPERATION;
2195          break;
2196
2197       case GL_UNSIGNED_INT:
2198          if (internalFormat != GL_RGB32UI)
2199             return GL_INVALID_OPERATION;
2200          break;
2201
2202       case GL_INT:
2203          if (internalFormat != GL_RGB32I)
2204             return GL_INVALID_OPERATION;
2205          break;
2206
2207       default:
2208          return GL_INVALID_OPERATION;
2209       }
2210       break;
2211
2212    case GL_RG:
2213       switch (type) {
2214       case GL_UNSIGNED_BYTE:
2215          if (internalFormat != GL_RG8)
2216             return GL_INVALID_OPERATION;
2217          break;
2218
2219       case GL_BYTE:
2220          if (internalFormat != GL_RG8_SNORM)
2221             return GL_INVALID_OPERATION;
2222          break;
2223
2224       case GL_HALF_FLOAT:
2225          if (internalFormat != GL_RG16F)
2226             return GL_INVALID_OPERATION;
2227          break;
2228
2229       case GL_FLOAT:
2230          switch (internalFormat) {
2231          case GL_RG16F:
2232          case GL_RG32F:
2233             break;
2234          default:
2235             return GL_INVALID_OPERATION;
2236          }
2237          break;
2238
2239       default:
2240          return GL_INVALID_OPERATION;
2241       }
2242       break;
2243
2244    case GL_RG_INTEGER:
2245       switch (type) {
2246       case GL_UNSIGNED_BYTE:
2247          if (internalFormat != GL_RG8UI)
2248             return GL_INVALID_OPERATION;
2249          break;
2250
2251       case GL_BYTE:
2252          if (internalFormat != GL_RG8I)
2253             return GL_INVALID_OPERATION;
2254          break;
2255
2256       case GL_UNSIGNED_SHORT:
2257          if (internalFormat != GL_RG16UI)
2258             return GL_INVALID_OPERATION;
2259          break;
2260
2261       case GL_SHORT:
2262          if (internalFormat != GL_RG16I)
2263             return GL_INVALID_OPERATION;
2264          break;
2265
2266       case GL_UNSIGNED_INT:
2267          if (internalFormat != GL_RG32UI)
2268             return GL_INVALID_OPERATION;
2269          break;
2270
2271       case GL_INT:
2272          if (internalFormat != GL_RG32I)
2273             return GL_INVALID_OPERATION;
2274          break;
2275
2276       default:
2277          return GL_INVALID_OPERATION;
2278       }
2279       break;
2280
2281    case GL_RED:
2282       switch (type) {
2283       case GL_UNSIGNED_BYTE:
2284          if (internalFormat != GL_R8)
2285             return GL_INVALID_OPERATION;
2286          break;
2287
2288       case GL_BYTE:
2289          if (internalFormat != GL_R8_SNORM)
2290             return GL_INVALID_OPERATION;
2291          break;
2292
2293       case GL_HALF_FLOAT:
2294          if (internalFormat != GL_R16F)
2295             return GL_INVALID_OPERATION;
2296          break;
2297
2298       case GL_FLOAT:
2299          switch (internalFormat) {
2300          case GL_R16F:
2301          case GL_R32F:
2302             break;
2303          default:
2304             return GL_INVALID_OPERATION;
2305          }
2306          break;
2307
2308       default:
2309          return GL_INVALID_OPERATION;
2310       }
2311       break;
2312
2313    case GL_RED_INTEGER:
2314       switch (type) {
2315       case GL_UNSIGNED_BYTE:
2316          if (internalFormat != GL_R8UI)
2317             return GL_INVALID_OPERATION;
2318          break;
2319
2320       case GL_BYTE:
2321          if (internalFormat != GL_R8I)
2322             return GL_INVALID_OPERATION;
2323          break;
2324
2325       case GL_UNSIGNED_SHORT:
2326          if (internalFormat != GL_R16UI)
2327             return GL_INVALID_OPERATION;
2328          break;
2329
2330       case GL_SHORT:
2331          if (internalFormat != GL_R16I)
2332             return GL_INVALID_OPERATION;
2333          break;
2334
2335       case GL_UNSIGNED_INT:
2336          if (internalFormat != GL_R32UI)
2337             return GL_INVALID_OPERATION;
2338          break;
2339
2340       case GL_INT:
2341          if (internalFormat != GL_R32I)
2342             return GL_INVALID_OPERATION;
2343          break;
2344
2345       default:
2346          return GL_INVALID_OPERATION;
2347       }
2348       break;
2349
2350    case GL_DEPTH_COMPONENT:
2351       switch (type) {
2352       case GL_UNSIGNED_SHORT:
2353          if (internalFormat != GL_DEPTH_COMPONENT
2354              && internalFormat != GL_DEPTH_COMPONENT16)
2355             return GL_INVALID_OPERATION;
2356          break;
2357
2358       case GL_UNSIGNED_INT:
2359          switch (internalFormat) {
2360          case GL_DEPTH_COMPONENT:
2361          case GL_DEPTH_COMPONENT16:
2362          case GL_DEPTH_COMPONENT24:
2363             break;
2364          default:
2365             return GL_INVALID_OPERATION;
2366          }
2367          break;
2368
2369       case GL_FLOAT:
2370          if (internalFormat != GL_DEPTH_COMPONENT32F)
2371             return GL_INVALID_OPERATION;
2372          break;
2373
2374       default:
2375          return GL_INVALID_OPERATION;
2376       }
2377       break;
2378
2379    case GL_DEPTH_STENCIL:
2380       switch (type) {
2381       case GL_UNSIGNED_INT_24_8:
2382          if (internalFormat != GL_DEPTH_STENCIL
2383              && internalFormat != GL_DEPTH24_STENCIL8)
2384             return GL_INVALID_OPERATION;
2385          break;
2386
2387       case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
2388          if (internalFormat != GL_DEPTH32F_STENCIL8)
2389             return GL_INVALID_OPERATION;
2390          break;
2391
2392       default:
2393          return GL_INVALID_OPERATION;
2394       }
2395       break;
2396
2397    case GL_ALPHA:
2398    case GL_LUMINANCE:
2399    case GL_LUMINANCE_ALPHA:
2400       if (type != GL_UNSIGNED_BYTE || format != internalFormat)
2401          return GL_INVALID_OPERATION;
2402       break;
2403    }
2404
2405    return GL_NO_ERROR;
2406 }