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