src/mesa/main/formats.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  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a
   8  * copy of this software and associated documentation files (the "Software"),
   9  * to deal in the Software without restriction, including without limitation
  10  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  11  * and/or sell copies of the Software, and to permit persons to whom the
  12  * Software is furnished to do so, subject to the following conditions:
  13  *
  14  * The above copyright notice and this permission notice shall be included
  15  * in all copies or substantial portions of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  18  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  20  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  21  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  22  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  23  * OTHER DEALINGS IN THE SOFTWARE.
  24  */
  25
  26
  27 #include "imports.h"
  28 #include "formats.h"
  29 #include "macros.h"
  30 #include "glformats.h"
  31
  32
  33 /**
  34  * Information about texture formats.
  35  */
  36 struct gl_format_info
  37 {
  38    mesa_format Name;
  39
  40    /** text name for debugging */
  41    const char *StrName;
  42
  43    enum mesa_format_layout Layout;
  44
  45    /**
  46     * Base format is one of GL_RED, GL_RG, GL_RGB, GL_RGBA, GL_ALPHA,
  47     * GL_LUMINANCE, GL_LUMINANCE_ALPHA, GL_INTENSITY, GL_YCBCR_MESA,
  48     * GL_DEPTH_COMPONENT, GL_STENCIL_INDEX, GL_DEPTH_STENCIL.
  49     */
  50    GLenum BaseFormat;
  51
  52    /**
  53     * Logical data type: one of  GL_UNSIGNED_NORMALIZED, GL_SIGNED_NORMALIZED,
  54     * GL_UNSIGNED_INT, GL_INT, GL_FLOAT.
  55     */
  56    GLenum DataType;
  57
  58    GLubyte RedBits;
  59    GLubyte GreenBits;
  60    GLubyte BlueBits;
  61    GLubyte AlphaBits;
  62    GLubyte LuminanceBits;
  63    GLubyte IntensityBits;
  64    GLubyte DepthBits;
  65    GLubyte StencilBits;
  66
  67    /**
  68     * To describe compressed formats.  If not compressed, Width=Height=1.
  69     */
  70    GLubyte BlockWidth, BlockHeight;
  71    GLubyte BytesPerBlock;
  72
  73    uint8_t Swizzle[4];
  74 };
  75
  76 #include "format_info.c"
  77
  78 static const struct gl_format_info *
  79 _mesa_get_format_info(mesa_format format)
  80 {
  81    const struct gl_format_info *info = &format_info[format];
  82    assert(info->Name == format);
  83    return info;
  84 }
  85
  86
  87 /** Return string name of format (for debugging) */
  88 const char *
  89 _mesa_get_format_name(mesa_format format)
  90 {
  91    const struct gl_format_info *info = _mesa_get_format_info(format);
  92    return info->StrName;
  93 }
  94
  95
  96
  97 /**
  98  * Return bytes needed to store a block of pixels in the given format.
  99  * Normally, a block is 1x1 (a single pixel).  But for compressed formats
 100  * a block may be 4x4 or 8x4, etc.
 101  *
 102  * Note: not GLuint, so as not to coerce math to unsigned. cf. fdo #37351
 103  */
 104 GLint
 105 _mesa_get_format_bytes(mesa_format format)
 106 {
 107    const struct gl_format_info *info = _mesa_get_format_info(format);
 108    ASSERT(info->BytesPerBlock);
 109    ASSERT(info->BytesPerBlock <= MAX_PIXEL_BYTES ||
 110           _mesa_is_format_compressed(format));
 111    return info->BytesPerBlock;
 112 }
 113
 114
 115 /**
 116  * Return bits per component for the given format.
 117  * \param format  one of MESA_FORMAT_x
 118  * \param pname  the component, such as GL_RED_BITS, GL_TEXTURE_BLUE_BITS, etc.
 119  */
 120 GLint
 121 _mesa_get_format_bits(mesa_format format, GLenum pname)
 122 {
 123    const struct gl_format_info *info = _mesa_get_format_info(format);
 124
 125    switch (pname) {
 126    case GL_RED_BITS:
 127    case GL_TEXTURE_RED_SIZE:
 128    case GL_RENDERBUFFER_RED_SIZE_EXT:
 129    case GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE:
 130       return info->RedBits;
 131    case GL_GREEN_BITS:
 132    case GL_TEXTURE_GREEN_SIZE:
 133    case GL_RENDERBUFFER_GREEN_SIZE_EXT:
 134    case GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE:
 135       return info->GreenBits;
 136    case GL_BLUE_BITS:
 137    case GL_TEXTURE_BLUE_SIZE:
 138    case GL_RENDERBUFFER_BLUE_SIZE_EXT:
 139    case GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE:
 140       return info->BlueBits;
 141    case GL_ALPHA_BITS:
 142    case GL_TEXTURE_ALPHA_SIZE:
 143    case GL_RENDERBUFFER_ALPHA_SIZE_EXT:
 144    case GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE:
 145       return info->AlphaBits;
 146    case GL_TEXTURE_INTENSITY_SIZE:
 147       return info->IntensityBits;
 148    case GL_TEXTURE_LUMINANCE_SIZE:
 149       return info->LuminanceBits;
 150    case GL_INDEX_BITS:
 151       return 0;
 152    case GL_DEPTH_BITS:
 153    case GL_TEXTURE_DEPTH_SIZE_ARB:
 154    case GL_RENDERBUFFER_DEPTH_SIZE_EXT:
 155    case GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE:
 156       return info->DepthBits;
 157    case GL_STENCIL_BITS:
 158    case GL_TEXTURE_STENCIL_SIZE_EXT:
 159    case GL_RENDERBUFFER_STENCIL_SIZE_EXT:
 160    case GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE:
 161       return info->StencilBits;
 162    default:
 163       _mesa_problem(NULL, "bad pname in _mesa_get_format_bits()");
 164       return 0;
 165    }
 166 }
 167
 168
 169 GLuint
 170 _mesa_get_format_max_bits(mesa_format format)
 171 {
 172    const struct gl_format_info *info = _mesa_get_format_info(format);
 173    GLuint max = MAX2(info->RedBits, info->GreenBits);
 174    max = MAX2(max, info->BlueBits);
 175    max = MAX2(max, info->AlphaBits);
 176    max = MAX2(max, info->LuminanceBits);
 177    max = MAX2(max, info->IntensityBits);
 178    max = MAX2(max, info->DepthBits);
 179    max = MAX2(max, info->StencilBits);
 180    return max;
 181 }
 182
 183
 184 /**
 185  * Return the layout type of the given format.
 186  * The return value will be one of:
 187  *    MESA_FORMAT_LAYOUT_ARRAY
 188  *    MESA_FORMAT_LAYOUT_PACKED
 189  *    MESA_FORMAT_LAYOUT_OTHER
 190  */
 191 extern enum mesa_format_layout
 192 _mesa_get_format_layout(mesa_format format)
 193 {
 194    const struct gl_format_info *info = _mesa_get_format_info(format);
 195    return info->Layout;
 196 }
 197
 198
 199 /**
 200  * Return the data type (or more specifically, the data representation)
 201  * for the given format.
 202  * The return value will be one of:
 203  *    GL_UNSIGNED_NORMALIZED = unsigned int representing [0,1]
 204  *    GL_SIGNED_NORMALIZED = signed int representing [-1, 1]
 205  *    GL_UNSIGNED_INT = an ordinary unsigned integer
 206  *    GL_INT = an ordinary signed integer
 207  *    GL_FLOAT = an ordinary float
 208  */
 209 GLenum
 210 _mesa_get_format_datatype(mesa_format format)
 211 {
 212    const struct gl_format_info *info = _mesa_get_format_info(format);
 213    return info->DataType;
 214 }
 215
 216
 217 /**
 218  * Return the basic format for the given type.  The result will be one of
 219  * GL_RGB, GL_RGBA, GL_ALPHA, GL_LUMINANCE, GL_LUMINANCE_ALPHA, GL_INTENSITY,
 220  * GL_YCBCR_MESA, GL_DEPTH_COMPONENT, GL_STENCIL_INDEX, GL_DEPTH_STENCIL.
 221  */
 222 GLenum
 223 _mesa_get_format_base_format(mesa_format format)
 224 {
 225    const struct gl_format_info *info = _mesa_get_format_info(format);
 226    return info->BaseFormat;
 227 }
 228
 229
 230 /**
 231  * Return the block size (in pixels) for the given format.  Normally
 232  * the block size is 1x1.  But compressed formats will have block sizes
 233  * of 4x4 or 8x4 pixels, etc.
 234  * \param bw  returns block width in pixels
 235  * \param bh  returns block height in pixels
 236  */
 237 void
 238 _mesa_get_format_block_size(mesa_format format, GLuint *bw, GLuint *bh)
 239 {
 240    const struct gl_format_info *info = _mesa_get_format_info(format);
 241    *bw = info->BlockWidth;
 242    *bh = info->BlockHeight;
 243 }
 244
 245
 246 /**
 247  * Returns the an array of four numbers representing the transformation
 248  * from the RGBA or SZ colorspace to the given format.  For array formats,
 249  * the i'th RGBA component is given by:
 250  *
 251  * if (swizzle[i] <= MESA_FORMAT_SWIZZLE_W)
 252  *    comp = data[swizzle[i]];
 253  * else if (swizzle[i] == MESA_FORMAT_SWIZZLE_ZERO)
 254  *    comp = 0;
 255  * else if (swizzle[i] == MESA_FORMAT_SWIZZLE_ONE)
 256  *    comp = 1;
 257  * else if (swizzle[i] == MESA_FORMAT_SWIZZLE_NONE)
 258  *    // data does not contain a channel of this format
 259  *
 260  * For packed formats, the swizzle gives the number of components left of
 261  * the least significant bit.
 262  *
 263  * Compressed formats have no swizzle.
 264  */
 265 void
 266 _mesa_get_format_swizzle(mesa_format format, uint8_t swizzle_out[4])
 267 {
 268    const struct gl_format_info *info = _mesa_get_format_info(format);
 269    memcpy(swizzle_out, info->Swizzle, sizeof(info->Swizzle));
 270 }
 271
 272
 273 /** Is the given format a compressed format? */
 274 GLboolean
 275 _mesa_is_format_compressed(mesa_format format)
 276 {
 277    const struct gl_format_info *info = _mesa_get_format_info(format);
 278    return info->BlockWidth > 1 || info->BlockHeight > 1;
 279 }
 280
 281
 282 /**
 283  * Determine if the given format represents a packed depth/stencil buffer.
 284  */
 285 GLboolean
 286 _mesa_is_format_packed_depth_stencil(mesa_format format)
 287 {
 288    const struct gl_format_info *info = _mesa_get_format_info(format);
 289
 290    return info->BaseFormat == GL_DEPTH_STENCIL;
 291 }
 292
 293
 294 /**
 295  * Is the given format a signed/unsigned integer color format?
 296  */
 297 GLboolean
 298 _mesa_is_format_integer_color(mesa_format format)
 299 {
 300    const struct gl_format_info *info = _mesa_get_format_info(format);
 301    return (info->DataType == GL_INT || info->DataType == GL_UNSIGNED_INT) &&
 302       info->BaseFormat != GL_DEPTH_COMPONENT &&
 303       info->BaseFormat != GL_DEPTH_STENCIL &&
 304       info->BaseFormat != GL_STENCIL_INDEX;
 305 }
 306
 307
 308 /**
 309  * Is the given format an unsigned integer format?
 310  */
 311 GLboolean
 312 _mesa_is_format_unsigned(mesa_format format)
 313 {
 314    const struct gl_format_info *info = _mesa_get_format_info(format);
 315    return _mesa_is_type_unsigned(info->DataType);
 316 }
 317
 318
 319 /**
 320  * Does the given format store signed values?
 321  */
 322 GLboolean
 323 _mesa_is_format_signed(mesa_format format)
 324 {
 325    if (format == MESA_FORMAT_R11G11B10_FLOAT ||
 326        format == MESA_FORMAT_R9G9B9E5_FLOAT) {
 327       /* these packed float formats only store unsigned values */
 328       return GL_FALSE;
 329    }
 330    else {
 331       const struct gl_format_info *info = _mesa_get_format_info(format);
 332       return (info->DataType == GL_SIGNED_NORMALIZED ||
 333               info->DataType == GL_INT ||
 334               info->DataType == GL_FLOAT);
 335    }
 336 }
 337
 338 /**
 339  * Is the given format an integer format?
 340  */
 341 GLboolean
 342 _mesa_is_format_integer(mesa_format format)
 343 {
 344    const struct gl_format_info *info = _mesa_get_format_info(format);
 345    return (info->DataType == GL_INT || info->DataType == GL_UNSIGNED_INT);
 346 }
 347
 348 /**
 349  * Return color encoding for given format.
 350  * \return GL_LINEAR or GL_SRGB
 351  */
 352 GLenum
 353 _mesa_get_format_color_encoding(mesa_format format)
 354 {
 355    /* XXX this info should be encoded in gl_format_info */
 356    switch (format) {
 357    case MESA_FORMAT_BGR_SRGB8:
 358    case MESA_FORMAT_A8B8G8R8_SRGB:
 359    case MESA_FORMAT_B8G8R8A8_SRGB:
 360    case MESA_FORMAT_R8G8B8A8_SRGB:
 361    case MESA_FORMAT_L_SRGB8:
 362    case MESA_FORMAT_L8A8_SRGB:
 363    case MESA_FORMAT_A8L8_SRGB:
 364    case MESA_FORMAT_SRGB_DXT1:
 365    case MESA_FORMAT_SRGBA_DXT1:
 366    case MESA_FORMAT_SRGBA_DXT3:
 367    case MESA_FORMAT_SRGBA_DXT5:
 368    case MESA_FORMAT_R8G8B8X8_SRGB:
 369    case MESA_FORMAT_ETC2_SRGB8:
 370    case MESA_FORMAT_ETC2_SRGB8_ALPHA8_EAC:
 371    case MESA_FORMAT_ETC2_SRGB8_PUNCHTHROUGH_ALPHA1:
 372    case MESA_FORMAT_B8G8R8X8_SRGB:
 373    case MESA_FORMAT_BPTC_SRGB_ALPHA_UNORM:
 374       return GL_SRGB;
 375    default:
 376       return GL_LINEAR;
 377    }
 378 }
 379
 380
 381 /**
 382  * Return TRUE if format is an ETC2 compressed format specified
 383  * by GL_ARB_ES3_compatibility.
 384  */
 385 bool
 386 _mesa_is_format_etc2(mesa_format format)
 387 {
 388    switch (format) {
 389    case MESA_FORMAT_ETC2_RGB8:
 390    case MESA_FORMAT_ETC2_SRGB8:
 391    case MESA_FORMAT_ETC2_RGBA8_EAC:
 392    case MESA_FORMAT_ETC2_SRGB8_ALPHA8_EAC:
 393    case MESA_FORMAT_ETC2_R11_EAC:
 394    case MESA_FORMAT_ETC2_RG11_EAC:
 395    case MESA_FORMAT_ETC2_SIGNED_R11_EAC:
 396    case MESA_FORMAT_ETC2_SIGNED_RG11_EAC:
 397    case MESA_FORMAT_ETC2_RGB8_PUNCHTHROUGH_ALPHA1:
 398    case MESA_FORMAT_ETC2_SRGB8_PUNCHTHROUGH_ALPHA1:
 399       return GL_TRUE;
 400    default:
 401       return GL_FALSE;
 402    }
 403 }
 404
 405
 406 /**
 407  * For an sRGB format, return the corresponding linear color space format.
 408  * For non-sRGB formats, return the format as-is.
 409  */
 410 mesa_format
 411 _mesa_get_srgb_format_linear(mesa_format format)
 412 {
 413    switch (format) {
 414    case MESA_FORMAT_BGR_SRGB8:
 415       format = MESA_FORMAT_BGR_UNORM8;
 416       break;
 417    case MESA_FORMAT_A8B8G8R8_SRGB:
 418       format = MESA_FORMAT_A8B8G8R8_UNORM;
 419       break;
 420    case MESA_FORMAT_B8G8R8A8_SRGB:
 421       format = MESA_FORMAT_B8G8R8A8_UNORM;
 422       break;
 423    case MESA_FORMAT_R8G8B8A8_SRGB:
 424       format = MESA_FORMAT_R8G8B8A8_UNORM;
 425       break;
 426    case MESA_FORMAT_L_SRGB8:
 427       format = MESA_FORMAT_L_UNORM8;
 428       break;
 429    case MESA_FORMAT_L8A8_SRGB:
 430       format = MESA_FORMAT_L8A8_UNORM;
 431       break;
 432    case MESA_FORMAT_A8L8_SRGB:
 433       format = MESA_FORMAT_A8L8_UNORM;
 434       break;
 435    case MESA_FORMAT_SRGB_DXT1:
 436       format = MESA_FORMAT_RGB_DXT1;
 437       break;
 438    case MESA_FORMAT_SRGBA_DXT1:
 439       format = MESA_FORMAT_RGBA_DXT1;
 440       break;
 441    case MESA_FORMAT_SRGBA_DXT3:
 442       format = MESA_FORMAT_RGBA_DXT3;
 443       break;
 444    case MESA_FORMAT_SRGBA_DXT5:
 445       format = MESA_FORMAT_RGBA_DXT5;
 446       break;
 447    case MESA_FORMAT_R8G8B8X8_SRGB:
 448       format = MESA_FORMAT_R8G8B8X8_UNORM;
 449       break;
 450    case MESA_FORMAT_ETC2_SRGB8:
 451       format = MESA_FORMAT_ETC2_RGB8;
 452       break;
 453    case MESA_FORMAT_ETC2_SRGB8_ALPHA8_EAC:
 454       format = MESA_FORMAT_ETC2_RGBA8_EAC;
 455       break;
 456    case MESA_FORMAT_ETC2_SRGB8_PUNCHTHROUGH_ALPHA1:
 457       format = MESA_FORMAT_ETC2_RGB8_PUNCHTHROUGH_ALPHA1;
 458       break;
 459    case MESA_FORMAT_BPTC_SRGB_ALPHA_UNORM:
 460       format = MESA_FORMAT_BPTC_RGBA_UNORM;
 461       break;
 462    case MESA_FORMAT_B8G8R8X8_SRGB:
 463       format = MESA_FORMAT_B8G8R8X8_UNORM;
 464       break;
 465    default:
 466       break;
 467    }
 468    return format;
 469 }
 470
 471
 472 /**
 473  * If the given format is a compressed format, return a corresponding
 474  * uncompressed format.
 475  */
 476 mesa_format
 477 _mesa_get_uncompressed_format(mesa_format format)
 478 {
 479    switch (format) {
 480    case MESA_FORMAT_RGB_FXT1:
 481       return MESA_FORMAT_BGR_UNORM8;
 482    case MESA_FORMAT_RGBA_FXT1:
 483       return MESA_FORMAT_A8B8G8R8_UNORM;
 484    case MESA_FORMAT_RGB_DXT1:
 485    case MESA_FORMAT_SRGB_DXT1:
 486       return MESA_FORMAT_BGR_UNORM8;
 487    case MESA_FORMAT_RGBA_DXT1:
 488    case MESA_FORMAT_SRGBA_DXT1:
 489       return MESA_FORMAT_A8B8G8R8_UNORM;
 490    case MESA_FORMAT_RGBA_DXT3:
 491    case MESA_FORMAT_SRGBA_DXT3:
 492       return MESA_FORMAT_A8B8G8R8_UNORM;
 493    case MESA_FORMAT_RGBA_DXT5:
 494    case MESA_FORMAT_SRGBA_DXT5:
 495       return MESA_FORMAT_A8B8G8R8_UNORM;
 496    case MESA_FORMAT_R_RGTC1_UNORM:
 497       return MESA_FORMAT_R_UNORM8;
 498    case MESA_FORMAT_R_RGTC1_SNORM:
 499       return MESA_FORMAT_R_SNORM8;
 500    case MESA_FORMAT_RG_RGTC2_UNORM:
 501       return MESA_FORMAT_R8G8_UNORM;
 502    case MESA_FORMAT_RG_RGTC2_SNORM:
 503       return MESA_FORMAT_R8G8_SNORM;
 504    case MESA_FORMAT_L_LATC1_UNORM:
 505       return MESA_FORMAT_L_UNORM8;
 506    case MESA_FORMAT_L_LATC1_SNORM:
 507       return MESA_FORMAT_L_SNORM8;
 508    case MESA_FORMAT_LA_LATC2_UNORM:
 509       return MESA_FORMAT_L8A8_UNORM;
 510    case MESA_FORMAT_LA_LATC2_SNORM:
 511       return MESA_FORMAT_L8A8_SNORM;
 512    case MESA_FORMAT_ETC1_RGB8:
 513    case MESA_FORMAT_ETC2_RGB8:
 514    case MESA_FORMAT_ETC2_SRGB8:
 515       return MESA_FORMAT_BGR_UNORM8;
 516    case MESA_FORMAT_ETC2_RGBA8_EAC:
 517    case MESA_FORMAT_ETC2_SRGB8_ALPHA8_EAC:
 518    case MESA_FORMAT_ETC2_RGB8_PUNCHTHROUGH_ALPHA1:
 519    case MESA_FORMAT_ETC2_SRGB8_PUNCHTHROUGH_ALPHA1:
 520       return MESA_FORMAT_A8B8G8R8_UNORM;
 521    case MESA_FORMAT_ETC2_R11_EAC:
 522    case MESA_FORMAT_ETC2_SIGNED_R11_EAC:
 523       return MESA_FORMAT_R_UNORM16;
 524    case MESA_FORMAT_ETC2_RG11_EAC:
 525    case MESA_FORMAT_ETC2_SIGNED_RG11_EAC:
 526       return MESA_FORMAT_R16G16_UNORM;
 527    case MESA_FORMAT_BPTC_RGBA_UNORM:
 528    case MESA_FORMAT_BPTC_SRGB_ALPHA_UNORM:
 529       return MESA_FORMAT_A8B8G8R8_UNORM;
 530    case MESA_FORMAT_BPTC_RGB_UNSIGNED_FLOAT:
 531    case MESA_FORMAT_BPTC_RGB_SIGNED_FLOAT:
 532       return MESA_FORMAT_RGB_FLOAT32;
 533    default:
 534 #ifdef DEBUG
 535       assert(!_mesa_is_format_compressed(format));
 536 #endif
 537       return format;
 538    }
 539 }
 540
 541
 542 GLuint
 543 _mesa_format_num_components(mesa_format format)
 544 {
 545    const struct gl_format_info *info = _mesa_get_format_info(format);
 546    return ((info->RedBits > 0) +
 547            (info->GreenBits > 0) +
 548            (info->BlueBits > 0) +
 549            (info->AlphaBits > 0) +
 550            (info->LuminanceBits > 0) +
 551            (info->IntensityBits > 0) +
 552            (info->DepthBits > 0) +
 553            (info->StencilBits > 0));
 554 }
 555
 556
 557 /**
 558  * Returns true if a color format has data stored in the R/G/B/A channels,
 559  * given an index from 0 to 3.
 560  */
 561 bool
 562 _mesa_format_has_color_component(mesa_format format, int component)
 563 {
 564    const struct gl_format_info *info = _mesa_get_format_info(format);
 565
 566    assert(info->BaseFormat != GL_DEPTH_COMPONENT &&
 567           info->BaseFormat != GL_DEPTH_STENCIL &&
 568           info->BaseFormat != GL_STENCIL_INDEX);
 569
 570    switch (component) {
 571    case 0:
 572       return (info->RedBits + info->IntensityBits + info->LuminanceBits) > 0;
 573    case 1:
 574       return (info->GreenBits + info->IntensityBits + info->LuminanceBits) > 0;
 575    case 2:
 576       return (info->BlueBits + info->IntensityBits + info->LuminanceBits) > 0;
 577    case 3:
 578       return (info->AlphaBits + info->IntensityBits) > 0;
 579    default:
 580       assert(!"Invalid color component: must be 0..3");
 581       return false;
 582    }
 583 }
 584
 585
 586 /**
 587  * Return number of bytes needed to store an image of the given size
 588  * in the given format.
 589  */
 590 GLuint
 591 _mesa_format_image_size(mesa_format format, GLsizei width,
 592                         GLsizei height, GLsizei depth)
 593 {
 594    const struct gl_format_info *info = _mesa_get_format_info(format);
 595    /* Strictly speaking, a conditional isn't needed here */
 596    if (info->BlockWidth > 1 || info->BlockHeight > 1) {
 597       /* compressed format (2D only for now) */
 598       const GLuint bw = info->BlockWidth, bh = info->BlockHeight;
 599       const GLuint wblocks = (width + bw - 1) / bw;
 600       const GLuint hblocks = (height + bh - 1) / bh;
 601       const GLuint sz = wblocks * hblocks * info->BytesPerBlock;
 602       return sz * depth;
 603    }
 604    else {
 605       /* non-compressed */
 606       const GLuint sz = width * height * depth * info->BytesPerBlock;
 607       return sz;
 608    }
 609 }
 610
 611
 612 /**
 613  * Same as _mesa_format_image_size() but returns a 64-bit value to
 614  * accomodate very large textures.
 615  */
 616 uint64_t
 617 _mesa_format_image_size64(mesa_format format, GLsizei width,
 618                           GLsizei height, GLsizei depth)
 619 {
 620    const struct gl_format_info *info = _mesa_get_format_info(format);
 621    /* Strictly speaking, a conditional isn't needed here */
 622    if (info->BlockWidth > 1 || info->BlockHeight > 1) {
 623       /* compressed format (2D only for now) */
 624       const uint64_t bw = info->BlockWidth, bh = info->BlockHeight;
 625       const uint64_t wblocks = (width + bw - 1) / bw;
 626       const uint64_t hblocks = (height + bh - 1) / bh;
 627       const uint64_t sz = wblocks * hblocks * info->BytesPerBlock;
 628       return sz * depth;
 629    }
 630    else {
 631       /* non-compressed */
 632       const uint64_t sz = ((uint64_t) width *
 633                            (uint64_t) height *
 634                            (uint64_t) depth *
 635                            info->BytesPerBlock);
 636       return sz;
 637    }
 638 }
 639
 640
 641
 642 GLint
 643 _mesa_format_row_stride(mesa_format format, GLsizei width)
 644 {
 645    const struct gl_format_info *info = _mesa_get_format_info(format);
 646    /* Strictly speaking, a conditional isn't needed here */
 647    if (info->BlockWidth > 1 || info->BlockHeight > 1) {
 648       /* compressed format */
 649       const GLuint bw = info->BlockWidth;
 650       const GLuint wblocks = (width + bw - 1) / bw;
 651       const GLint stride = wblocks * info->BytesPerBlock;
 652       return stride;
 653    }
 654    else {
 655       const GLint stride = width * info->BytesPerBlock;
 656       return stride;
 657    }
 658 }
 659
 660
 661 /**
 662  * Debug/test: check that all formats are handled in the
 663  * _mesa_format_to_type_and_comps() function.  When new pixel formats
 664  * are added to Mesa, that function needs to be updated.
 665  * This is a no-op after the first call.
 666  */
 667 static void
 668 check_format_to_type_and_comps(void)
 669 {
 670    mesa_format f;
 671
 672    for (f = MESA_FORMAT_NONE + 1; f < MESA_FORMAT_COUNT; f++) {
 673       GLenum datatype = 0;
 674       GLuint comps = 0;
 675       /* This function will emit a problem/warning if the format is
 676        * not handled.
 677        */
 678       _mesa_format_to_type_and_comps(f, &datatype, &comps);
 679    }
 680 }
 681
 682 /**
 683  * Do sanity checking of the format info table.
 684  */
 685 void
 686 _mesa_test_formats(void)
 687 {
 688    GLuint i;
 689
 690    STATIC_ASSERT(Elements(format_info) == MESA_FORMAT_COUNT);
 691
 692    for (i = 0; i < MESA_FORMAT_COUNT; i++) {
 693       const struct gl_format_info *info = _mesa_get_format_info(i);
 694       assert(info);
 695
 696       assert(info->Name == i);
 697
 698       if (info->Name == MESA_FORMAT_NONE)
 699          continue;
 700
 701       if (info->BlockWidth == 1 && info->BlockHeight == 1) {
 702          if (info->RedBits > 0) {
 703             GLuint t = info->RedBits + info->GreenBits
 704                + info->BlueBits + info->AlphaBits;
 705             assert(t / 8 <= info->BytesPerBlock);
 706             (void) t;
 707          }
 708       }
 709
 710       assert(info->DataType == GL_UNSIGNED_NORMALIZED ||
 711              info->DataType == GL_SIGNED_NORMALIZED ||
 712              info->DataType == GL_UNSIGNED_INT ||
 713              info->DataType == GL_INT ||
 714              info->DataType == GL_FLOAT ||
 715              /* Z32_FLOAT_X24S8 has DataType of GL_NONE */
 716              info->DataType == GL_NONE);
 717
 718       if (info->BaseFormat == GL_RGB) {
 719          assert(info->RedBits > 0);
 720          assert(info->GreenBits > 0);
 721          assert(info->BlueBits > 0);
 722          assert(info->AlphaBits == 0);
 723          assert(info->LuminanceBits == 0);
 724          assert(info->IntensityBits == 0);
 725       }
 726       else if (info->BaseFormat == GL_RGBA) {
 727          assert(info->RedBits > 0);
 728          assert(info->GreenBits > 0);
 729          assert(info->BlueBits > 0);
 730          assert(info->AlphaBits > 0);
 731          assert(info->LuminanceBits == 0);
 732          assert(info->IntensityBits == 0);
 733       }
 734       else if (info->BaseFormat == GL_RG) {
 735          assert(info->RedBits > 0);
 736          assert(info->GreenBits > 0);
 737          assert(info->BlueBits == 0);
 738          assert(info->AlphaBits == 0);
 739          assert(info->LuminanceBits == 0);
 740          assert(info->IntensityBits == 0);
 741       }
 742       else if (info->BaseFormat == GL_RED) {
 743          assert(info->RedBits > 0);
 744          assert(info->GreenBits == 0);
 745          assert(info->BlueBits == 0);
 746          assert(info->AlphaBits == 0);
 747          assert(info->LuminanceBits == 0);
 748          assert(info->IntensityBits == 0);
 749       }
 750       else if (info->BaseFormat == GL_LUMINANCE) {
 751          assert(info->RedBits == 0);
 752          assert(info->GreenBits == 0);
 753          assert(info->BlueBits == 0);
 754          assert(info->AlphaBits == 0);
 755          assert(info->LuminanceBits > 0);
 756          assert(info->IntensityBits == 0);
 757       }
 758       else if (info->BaseFormat == GL_INTENSITY) {
 759          assert(info->RedBits == 0);
 760          assert(info->GreenBits == 0);
 761          assert(info->BlueBits == 0);
 762          assert(info->AlphaBits == 0);
 763          assert(info->LuminanceBits == 0);
 764          assert(info->IntensityBits > 0);
 765       }
 766    }
 767
 768    check_format_to_type_and_comps();
 769 }
 770
 771
 772
 773 /**
 774  * Return datatype and number of components per texel for the given mesa_format.
 775  * Only used for mipmap generation code.
 776  */
 777 void
 778 _mesa_format_to_type_and_comps(mesa_format format,
 779                                GLenum *datatype, GLuint *comps)
 780 {
 781    switch (format) {
 782    case MESA_FORMAT_A8B8G8R8_UNORM:
 783    case MESA_FORMAT_R8G8B8A8_UNORM:
 784    case MESA_FORMAT_B8G8R8A8_UNORM:
 785    case MESA_FORMAT_A8R8G8B8_UNORM:
 786    case MESA_FORMAT_X8B8G8R8_UNORM:
 787    case MESA_FORMAT_R8G8B8X8_UNORM:
 788    case MESA_FORMAT_B8G8R8X8_UNORM:
 789    case MESA_FORMAT_X8R8G8B8_UNORM:
 790       *datatype = GL_UNSIGNED_BYTE;
 791       *comps = 4;
 792       return;
 793    case MESA_FORMAT_BGR_UNORM8:
 794    case MESA_FORMAT_RGB_UNORM8:
 795       *datatype = GL_UNSIGNED_BYTE;
 796       *comps = 3;
 797       return;
 798    case MESA_FORMAT_B5G6R5_UNORM:
 799    case MESA_FORMAT_R5G6B5_UNORM:
 800       *datatype = GL_UNSIGNED_SHORT_5_6_5;
 801       *comps = 3;
 802       return;
 803
 804    case MESA_FORMAT_B4G4R4A4_UNORM:
 805    case MESA_FORMAT_A4R4G4B4_UNORM:
 806    case MESA_FORMAT_B4G4R4X4_UNORM:
 807       *datatype = GL_UNSIGNED_SHORT_4_4_4_4;
 808       *comps = 4;
 809       return;
 810
 811    case MESA_FORMAT_B5G5R5A1_UNORM:
 812    case MESA_FORMAT_A1R5G5B5_UNORM:
 813    case MESA_FORMAT_B5G5R5X1_UNORM:
 814       *datatype = GL_UNSIGNED_SHORT_1_5_5_5_REV;
 815       *comps = 4;
 816       return;
 817
 818    case MESA_FORMAT_B10G10R10A2_UNORM:
 819       *datatype = GL_UNSIGNED_INT_2_10_10_10_REV;
 820       *comps = 4;
 821       return;
 822
 823    case MESA_FORMAT_A1B5G5R5_UNORM:
 824       *datatype = GL_UNSIGNED_SHORT_5_5_5_1;
 825       *comps = 4;
 826       return;
 827
 828    case MESA_FORMAT_L4A4_UNORM:
 829       *datatype = MESA_UNSIGNED_BYTE_4_4;
 830       *comps = 2;
 831       return;
 832
 833    case MESA_FORMAT_L8A8_UNORM:
 834    case MESA_FORMAT_A8L8_UNORM:
 835    case MESA_FORMAT_R8G8_UNORM:
 836    case MESA_FORMAT_G8R8_UNORM:
 837       *datatype = GL_UNSIGNED_BYTE;
 838       *comps = 2;
 839       return;
 840
 841    case MESA_FORMAT_L16A16_UNORM:
 842    case MESA_FORMAT_A16L16_UNORM:
 843    case MESA_FORMAT_R16G16_UNORM:
 844    case MESA_FORMAT_G16R16_UNORM:
 845       *datatype = GL_UNSIGNED_SHORT;
 846       *comps = 2;
 847       return;
 848
 849    case MESA_FORMAT_R_UNORM16:
 850    case MESA_FORMAT_A_UNORM16:
 851    case MESA_FORMAT_L_UNORM16:
 852    case MESA_FORMAT_I_UNORM16:
 853       *datatype = GL_UNSIGNED_SHORT;
 854       *comps = 1;
 855       return;
 856
 857    case MESA_FORMAT_B2G3R3_UNORM:
 858       *datatype = GL_UNSIGNED_BYTE_3_3_2;
 859       *comps = 3;
 860       return;
 861
 862    case MESA_FORMAT_A_UNORM8:
 863    case MESA_FORMAT_L_UNORM8:
 864    case MESA_FORMAT_I_UNORM8:
 865    case MESA_FORMAT_R_UNORM8:
 866    case MESA_FORMAT_S_UINT8:
 867       *datatype = GL_UNSIGNED_BYTE;
 868       *comps = 1;
 869       return;
 870
 871    case MESA_FORMAT_YCBCR:
 872    case MESA_FORMAT_YCBCR_REV:
 873       *datatype = GL_UNSIGNED_SHORT;
 874       *comps = 2;
 875       return;
 876
 877    case MESA_FORMAT_S8_UINT_Z24_UNORM:
 878       *datatype = GL_UNSIGNED_INT_24_8_MESA;
 879       *comps = 2;
 880       return;
 881
 882    case MESA_FORMAT_Z24_UNORM_S8_UINT:
 883       *datatype = GL_UNSIGNED_INT_8_24_REV_MESA;
 884       *comps = 2;
 885       return;
 886
 887    case MESA_FORMAT_Z_UNORM16:
 888       *datatype = GL_UNSIGNED_SHORT;
 889       *comps = 1;
 890       return;
 891
 892    case MESA_FORMAT_Z24_UNORM_X8_UINT:
 893       *datatype = GL_UNSIGNED_INT;
 894       *comps = 1;
 895       return;
 896
 897    case MESA_FORMAT_X8_UINT_Z24_UNORM:
 898       *datatype = GL_UNSIGNED_INT;
 899       *comps = 1;
 900       return;
 901
 902    case MESA_FORMAT_Z_UNORM32:
 903       *datatype = GL_UNSIGNED_INT;
 904       *comps = 1;
 905       return;
 906
 907    case MESA_FORMAT_Z_FLOAT32:
 908       *datatype = GL_FLOAT;
 909       *comps = 1;
 910       return;
 911
 912    case MESA_FORMAT_Z32_FLOAT_S8X24_UINT:
 913       *datatype = GL_FLOAT_32_UNSIGNED_INT_24_8_REV;
 914       *comps = 1;
 915       return;
 916
 917    case MESA_FORMAT_R_SNORM8:
 918    case MESA_FORMAT_A_SNORM8:
 919    case MESA_FORMAT_L_SNORM8:
 920    case MESA_FORMAT_I_SNORM8:
 921       *datatype = GL_BYTE;
 922       *comps = 1;
 923       return;
 924    case MESA_FORMAT_R8G8_SNORM:
 925    case MESA_FORMAT_L8A8_SNORM:
 926    case MESA_FORMAT_A8L8_SNORM:
 927       *datatype = GL_BYTE;
 928       *comps = 2;
 929       return;
 930    case MESA_FORMAT_A8B8G8R8_SNORM:
 931    case MESA_FORMAT_R8G8B8A8_SNORM:
 932    case MESA_FORMAT_X8B8G8R8_SNORM:
 933       *datatype = GL_BYTE;
 934       *comps = 4;
 935       return;
 936
 937    case MESA_FORMAT_RGBA_UNORM16:
 938       *datatype = GL_UNSIGNED_SHORT;
 939       *comps = 4;
 940       return;
 941
 942    case MESA_FORMAT_R_SNORM16:
 943    case MESA_FORMAT_A_SNORM16:
 944    case MESA_FORMAT_L_SNORM16:
 945    case MESA_FORMAT_I_SNORM16:
 946       *datatype = GL_SHORT;
 947       *comps = 1;
 948       return;
 949    case MESA_FORMAT_R16G16_SNORM:
 950    case MESA_FORMAT_LA_SNORM16:
 951       *datatype = GL_SHORT;
 952       *comps = 2;
 953       return;
 954    case MESA_FORMAT_RGB_SNORM16:
 955       *datatype = GL_SHORT;
 956       *comps = 3;
 957       return;
 958    case MESA_FORMAT_RGBA_SNORM16:
 959       *datatype = GL_SHORT;
 960       *comps = 4;
 961       return;
 962
 963    case MESA_FORMAT_BGR_SRGB8:
 964       *datatype = GL_UNSIGNED_BYTE;
 965       *comps = 3;
 966       return;
 967    case MESA_FORMAT_A8B8G8R8_SRGB:
 968    case MESA_FORMAT_B8G8R8A8_SRGB:
 969    case MESA_FORMAT_R8G8B8A8_SRGB:
 970       *datatype = GL_UNSIGNED_BYTE;
 971       *comps = 4;
 972       return;
 973    case MESA_FORMAT_L_SRGB8:
 974       *datatype = GL_UNSIGNED_BYTE;
 975       *comps = 1;
 976       return;
 977    case MESA_FORMAT_L8A8_SRGB:
 978    case MESA_FORMAT_A8L8_SRGB:
 979       *datatype = GL_UNSIGNED_BYTE;
 980       *comps = 2;
 981       return;
 982
 983    case MESA_FORMAT_RGB_FXT1:
 984    case MESA_FORMAT_RGBA_FXT1:
 985    case MESA_FORMAT_RGB_DXT1:
 986    case MESA_FORMAT_RGBA_DXT1:
 987    case MESA_FORMAT_RGBA_DXT3:
 988    case MESA_FORMAT_RGBA_DXT5:
 989    case MESA_FORMAT_SRGB_DXT1:
 990    case MESA_FORMAT_SRGBA_DXT1:
 991    case MESA_FORMAT_SRGBA_DXT3:
 992    case MESA_FORMAT_SRGBA_DXT5:
 993    case MESA_FORMAT_R_RGTC1_UNORM:
 994    case MESA_FORMAT_R_RGTC1_SNORM:
 995    case MESA_FORMAT_RG_RGTC2_UNORM:
 996    case MESA_FORMAT_RG_RGTC2_SNORM:
 997    case MESA_FORMAT_L_LATC1_UNORM:
 998    case MESA_FORMAT_L_LATC1_SNORM:
 999    case MESA_FORMAT_LA_LATC2_UNORM:
1000    case MESA_FORMAT_LA_LATC2_SNORM:
1001    case MESA_FORMAT_ETC1_RGB8:
1002    case MESA_FORMAT_ETC2_RGB8:
1003    case MESA_FORMAT_ETC2_SRGB8:
1004    case MESA_FORMAT_ETC2_RGBA8_EAC:
1005    case MESA_FORMAT_ETC2_SRGB8_ALPHA8_EAC:
1006    case MESA_FORMAT_ETC2_R11_EAC:
1007    case MESA_FORMAT_ETC2_RG11_EAC:
1008    case MESA_FORMAT_ETC2_SIGNED_R11_EAC:
1009    case MESA_FORMAT_ETC2_SIGNED_RG11_EAC:
1010    case MESA_FORMAT_ETC2_RGB8_PUNCHTHROUGH_ALPHA1:
1011    case MESA_FORMAT_ETC2_SRGB8_PUNCHTHROUGH_ALPHA1:
1012    case MESA_FORMAT_BPTC_RGBA_UNORM:
1013    case MESA_FORMAT_BPTC_SRGB_ALPHA_UNORM:
1014    case MESA_FORMAT_BPTC_RGB_SIGNED_FLOAT:
1015    case MESA_FORMAT_BPTC_RGB_UNSIGNED_FLOAT:
1016       /* XXX generate error instead? */
1017       *datatype = GL_UNSIGNED_BYTE;
1018       *comps = 0;
1019       return;
1020
1021    case MESA_FORMAT_RGBA_FLOAT32:
1022       *datatype = GL_FLOAT;
1023       *comps = 4;
1024       return;
1025    case MESA_FORMAT_RGBA_FLOAT16:
1026       *datatype = GL_HALF_FLOAT_ARB;
1027       *comps = 4;
1028       return;
1029    case MESA_FORMAT_RGB_FLOAT32:
1030       *datatype = GL_FLOAT;
1031       *comps = 3;
1032       return;
1033    case MESA_FORMAT_RGB_FLOAT16:
1034       *datatype = GL_HALF_FLOAT_ARB;
1035       *comps = 3;
1036       return;
1037    case MESA_FORMAT_LA_FLOAT32:
1038    case MESA_FORMAT_RG_FLOAT32:
1039       *datatype = GL_FLOAT;
1040       *comps = 2;
1041       return;
1042    case MESA_FORMAT_LA_FLOAT16:
1043    case MESA_FORMAT_RG_FLOAT16:
1044       *datatype = GL_HALF_FLOAT_ARB;
1045       *comps = 2;
1046       return;
1047    case MESA_FORMAT_A_FLOAT32:
1048    case MESA_FORMAT_L_FLOAT32:
1049    case MESA_FORMAT_I_FLOAT32:
1050    case MESA_FORMAT_R_FLOAT32:
1051       *datatype = GL_FLOAT;
1052       *comps = 1;
1053       return;
1054    case MESA_FORMAT_A_FLOAT16:
1055    case MESA_FORMAT_L_FLOAT16:
1056    case MESA_FORMAT_I_FLOAT16:
1057    case MESA_FORMAT_R_FLOAT16:
1058       *datatype = GL_HALF_FLOAT_ARB;
1059       *comps = 1;
1060       return;
1061
1062    case MESA_FORMAT_A_UINT8:
1063    case MESA_FORMAT_L_UINT8:
1064    case MESA_FORMAT_I_UINT8:
1065       *datatype = GL_UNSIGNED_BYTE;
1066       *comps = 1;
1067       return;
1068    case MESA_FORMAT_LA_UINT8:
1069       *datatype = GL_UNSIGNED_BYTE;
1070       *comps = 2;
1071       return;
1072
1073    case MESA_FORMAT_A_UINT16:
1074    case MESA_FORMAT_L_UINT16:
1075    case MESA_FORMAT_I_UINT16:
1076       *datatype = GL_UNSIGNED_SHORT;
1077       *comps = 1;
1078       return;
1079    case MESA_FORMAT_LA_UINT16:
1080       *datatype = GL_UNSIGNED_SHORT;
1081       *comps = 2;
1082       return;
1083    case MESA_FORMAT_A_UINT32:
1084    case MESA_FORMAT_L_UINT32:
1085    case MESA_FORMAT_I_UINT32:
1086       *datatype = GL_UNSIGNED_INT;
1087       *comps = 1;
1088       return;
1089    case MESA_FORMAT_LA_UINT32:
1090       *datatype = GL_UNSIGNED_INT;
1091       *comps = 2;
1092       return;
1093    case MESA_FORMAT_A_SINT8:
1094    case MESA_FORMAT_L_SINT8:
1095    case MESA_FORMAT_I_SINT8:
1096       *datatype = GL_BYTE;
1097       *comps = 1;
1098       return;
1099    case MESA_FORMAT_LA_SINT8:
1100       *datatype = GL_BYTE;
1101       *comps = 2;
1102       return;
1103
1104    case MESA_FORMAT_A_SINT16:
1105    case MESA_FORMAT_L_SINT16:
1106    case MESA_FORMAT_I_SINT16:
1107       *datatype = GL_SHORT;
1108       *comps = 1;
1109       return;
1110    case MESA_FORMAT_LA_SINT16:
1111       *datatype = GL_SHORT;
1112       *comps = 2;
1113       return;
1114
1115    case MESA_FORMAT_A_SINT32:
1116    case MESA_FORMAT_L_SINT32:
1117    case MESA_FORMAT_I_SINT32:
1118       *datatype = GL_INT;
1119       *comps = 1;
1120       return;
1121    case MESA_FORMAT_LA_SINT32:
1122       *datatype = GL_INT;
1123       *comps = 2;
1124       return;
1125
1126    case MESA_FORMAT_R_SINT8:
1127       *datatype = GL_BYTE;
1128       *comps = 1;
1129       return;
1130    case MESA_FORMAT_RG_SINT8:
1131       *datatype = GL_BYTE;
1132       *comps = 2;
1133       return;
1134    case MESA_FORMAT_RGB_SINT8:
1135       *datatype = GL_BYTE;
1136       *comps = 3;
1137       return;
1138    case MESA_FORMAT_RGBA_SINT8:
1139       *datatype = GL_BYTE;
1140       *comps = 4;
1141       return;
1142    case MESA_FORMAT_R_SINT16:
1143       *datatype = GL_SHORT;
1144       *comps = 1;
1145       return;
1146    case MESA_FORMAT_RG_SINT16:
1147       *datatype = GL_SHORT;
1148       *comps = 2;
1149       return;
1150    case MESA_FORMAT_RGB_SINT16:
1151       *datatype = GL_SHORT;
1152       *comps = 3;
1153       return;
1154    case MESA_FORMAT_RGBA_SINT16:
1155       *datatype = GL_SHORT;
1156       *comps = 4;
1157       return;
1158    case MESA_FORMAT_R_SINT32:
1159       *datatype = GL_INT;
1160       *comps = 1;
1161       return;
1162    case MESA_FORMAT_RG_SINT32:
1163       *datatype = GL_INT;
1164       *comps = 2;
1165       return;
1166    case MESA_FORMAT_RGB_SINT32:
1167       *datatype = GL_INT;
1168       *comps = 3;
1169       return;
1170    case MESA_FORMAT_RGBA_SINT32:
1171       *datatype = GL_INT;
1172       *comps = 4;
1173       return;
1174
1175    /**
1176     * \name Non-normalized unsigned integer formats.
1177     */
1178    case MESA_FORMAT_R_UINT8:
1179       *datatype = GL_UNSIGNED_BYTE;
1180       *comps = 1;
1181       return;
1182    case MESA_FORMAT_RG_UINT8:
1183       *datatype = GL_UNSIGNED_BYTE;
1184       *comps = 2;
1185       return;
1186    case MESA_FORMAT_RGB_UINT8:
1187       *datatype = GL_UNSIGNED_BYTE;
1188       *comps = 3;
1189       return;
1190    case MESA_FORMAT_RGBA_UINT8:
1191       *datatype = GL_UNSIGNED_BYTE;
1192       *comps = 4;
1193       return;
1194    case MESA_FORMAT_R_UINT16:
1195       *datatype = GL_UNSIGNED_SHORT;
1196       *comps = 1;
1197       return;
1198    case MESA_FORMAT_RG_UINT16:
1199       *datatype = GL_UNSIGNED_SHORT;
1200       *comps = 2;
1201       return;
1202    case MESA_FORMAT_RGB_UINT16:
1203       *datatype = GL_UNSIGNED_SHORT;
1204       *comps = 3;
1205       return;
1206    case MESA_FORMAT_RGBA_UINT16:
1207       *datatype = GL_UNSIGNED_SHORT;
1208       *comps = 4;
1209       return;
1210    case MESA_FORMAT_R_UINT32:
1211       *datatype = GL_UNSIGNED_INT;
1212       *comps = 1;
1213       return;
1214    case MESA_FORMAT_RG_UINT32:
1215       *datatype = GL_UNSIGNED_INT;
1216       *comps = 2;
1217       return;
1218    case MESA_FORMAT_RGB_UINT32:
1219       *datatype = GL_UNSIGNED_INT;
1220       *comps = 3;
1221       return;
1222    case MESA_FORMAT_RGBA_UINT32:
1223       *datatype = GL_UNSIGNED_INT;
1224       *comps = 4;
1225       return;
1226
1227    case MESA_FORMAT_R9G9B9E5_FLOAT:
1228       *datatype = GL_UNSIGNED_INT_5_9_9_9_REV;
1229       *comps = 3;
1230       return;
1231
1232    case MESA_FORMAT_R11G11B10_FLOAT:
1233       *datatype = GL_UNSIGNED_INT_10F_11F_11F_REV;
1234       *comps = 3;
1235       return;
1236
1237    case MESA_FORMAT_B10G10R10A2_UINT:
1238    case MESA_FORMAT_R10G10B10A2_UINT:
1239       *datatype = GL_UNSIGNED_INT_2_10_10_10_REV;
1240       *comps = 4;
1241       return;
1242
1243    case MESA_FORMAT_R8G8B8X8_SRGB:
1244    case MESA_FORMAT_RGBX_UINT8:
1245       *datatype = GL_UNSIGNED_BYTE;
1246       *comps = 4;
1247       return;
1248
1249    case MESA_FORMAT_R8G8B8X8_SNORM:
1250    case MESA_FORMAT_RGBX_SINT8:
1251       *datatype = GL_BYTE;
1252       *comps = 4;
1253       return;
1254
1255    case MESA_FORMAT_B10G10R10X2_UNORM:
1256       *datatype = GL_UNSIGNED_INT_2_10_10_10_REV;
1257       *comps = 4;
1258       return;
1259
1260    case MESA_FORMAT_RGBX_UNORM16:
1261    case MESA_FORMAT_RGBX_UINT16:
1262       *datatype = GL_UNSIGNED_SHORT;
1263       *comps = 4;
1264       return;
1265
1266    case MESA_FORMAT_RGBX_SNORM16:
1267    case MESA_FORMAT_RGBX_SINT16:
1268       *datatype = GL_SHORT;
1269       *comps = 4;
1270       return;
1271
1272    case MESA_FORMAT_RGBX_FLOAT16:
1273       *datatype = GL_HALF_FLOAT;
1274       *comps = 4;
1275       return;
1276
1277    case MESA_FORMAT_RGBX_FLOAT32:
1278       *datatype = GL_FLOAT;
1279       *comps = 4;
1280       return;
1281
1282    case MESA_FORMAT_RGBX_UINT32:
1283       *datatype = GL_UNSIGNED_INT;
1284       *comps = 4;
1285       return;
1286
1287    case MESA_FORMAT_RGBX_SINT32:
1288       *datatype = GL_INT;
1289       *comps = 4;
1290       return;
1291
1292    case MESA_FORMAT_R10G10B10A2_UNORM:
1293       *datatype = GL_UNSIGNED_INT_2_10_10_10_REV;
1294       *comps = 4;
1295       return;
1296
1297    case MESA_FORMAT_G8R8_SNORM:
1298       *datatype = GL_BYTE;
1299       *comps = 2;
1300       return;
1301
1302    case MESA_FORMAT_G16R16_SNORM:
1303       *datatype = GL_SHORT;
1304       *comps = 2;
1305       return;
1306
1307    case MESA_FORMAT_B8G8R8X8_SRGB:
1308       *datatype = GL_UNSIGNED_BYTE;
1309       *comps = 4;
1310       return;
1311
1312    case MESA_FORMAT_COUNT:
1313       assert(0);
1314       return;
1315
1316    case MESA_FORMAT_NONE:
1317    /* For debug builds, warn if any formats are not handled */
1318 #ifdef DEBUG
1319    default:
1320 #endif
1321       _mesa_problem(NULL, "bad format %s in _mesa_format_to_type_and_comps",
1322                     _mesa_get_format_name(format));
1323       *datatype = 0;
1324       *comps = 1;
1325    }
1326 }
1327
1328 /**
1329  * Check if a mesa_format exactly matches a GL format/type combination
1330  * such that we can use memcpy() from one to the other.
1331  * \param mesa_format  a MESA_FORMAT_x value
1332  * \param format  the user-specified image format
1333  * \param type  the user-specified image datatype
1334  * \param swapBytes  typically the current pixel pack/unpack byteswap state
1335  * \return GL_TRUE if the formats match, GL_FALSE otherwise.
1336  */
1337 GLboolean
1338 _mesa_format_matches_format_and_type(mesa_format mesa_format,
1339                                      GLenum format, GLenum type,
1340                                      GLboolean swapBytes)
1341 {
1342    const GLboolean littleEndian = _mesa_little_endian();
1343
1344    /* Note: When reading a GL format/type combination, the format lists channel
1345     * assignments from most significant channel in the type to least
1346     * significant.  A type with _REV indicates that the assignments are
1347     * swapped, so they are listed from least significant to most significant.
1348     *
1349     * For sanity, please keep this switch statement ordered the same as the
1350     * enums in formats.h.
1351     */
1352
1353    switch (mesa_format) {
1354
1355    case MESA_FORMAT_NONE:
1356    case MESA_FORMAT_COUNT:
1357       return GL_FALSE;
1358
1359    case MESA_FORMAT_A8B8G8R8_UNORM:
1360    case MESA_FORMAT_A8B8G8R8_SRGB:
1361       if (format == GL_RGBA && type == GL_UNSIGNED_INT_8_8_8_8 && !swapBytes)
1362          return GL_TRUE;
1363
1364       if (format == GL_RGBA && type == GL_UNSIGNED_INT_8_8_8_8_REV && swapBytes)
1365          return GL_TRUE;
1366
1367       if (format == GL_RGBA && type == GL_UNSIGNED_BYTE && !littleEndian)
1368          return GL_TRUE;
1369
1370       if (format == GL_ABGR_EXT && type == GL_UNSIGNED_INT_8_8_8_8_REV
1371           && !swapBytes)
1372          return GL_TRUE;
1373
1374       if (format == GL_ABGR_EXT && type == GL_UNSIGNED_INT_8_8_8_8
1375           && swapBytes)
1376          return GL_TRUE;
1377
1378       if (format == GL_ABGR_EXT && type == GL_UNSIGNED_BYTE && littleEndian)
1379          return GL_TRUE;
1380
1381       return GL_FALSE;
1382
1383    case MESA_FORMAT_R8G8B8A8_UNORM:
1384    case MESA_FORMAT_R8G8B8A8_SRGB:
1385       if (format == GL_RGBA && type == GL_UNSIGNED_INT_8_8_8_8_REV &&
1386           !swapBytes)
1387          return GL_TRUE;
1388
1389       if (format == GL_RGBA && type == GL_UNSIGNED_INT_8_8_8_8 && swapBytes)
1390          return GL_TRUE;
1391
1392       if (format == GL_RGBA && type == GL_UNSIGNED_BYTE && littleEndian)
1393          return GL_TRUE;
1394
1395       if (format == GL_ABGR_EXT && type == GL_UNSIGNED_INT_8_8_8_8 &&
1396           !swapBytes)
1397          return GL_TRUE;
1398
1399       if (format == GL_ABGR_EXT && type == GL_UNSIGNED_INT_8_8_8_8_REV &&
1400           swapBytes)
1401          return GL_TRUE;
1402
1403       if (format == GL_ABGR_EXT && type == GL_UNSIGNED_BYTE && !littleEndian)
1404          return GL_TRUE;
1405
1406       return GL_FALSE;
1407
1408    case MESA_FORMAT_B8G8R8A8_UNORM:
1409    case MESA_FORMAT_B8G8R8A8_SRGB:
1410       if (format == GL_BGRA && type == GL_UNSIGNED_INT_8_8_8_8_REV &&
1411           !swapBytes)
1412          return GL_TRUE;
1413
1414       if (format == GL_BGRA && type == GL_UNSIGNED_INT_8_8_8_8 && swapBytes)
1415          return GL_TRUE;
1416
1417       if (format == GL_BGRA && type == GL_UNSIGNED_BYTE && littleEndian)
1418          return GL_TRUE;
1419
1420       return GL_FALSE;
1421
1422    case MESA_FORMAT_A8R8G8B8_UNORM:
1423       if (format == GL_BGRA && type == GL_UNSIGNED_INT_8_8_8_8 && !swapBytes)
1424          return GL_TRUE;
1425
1426       if (format == GL_BGRA && type == GL_UNSIGNED_INT_8_8_8_8_REV &&
1427           swapBytes)
1428          return GL_TRUE;
1429
1430       if (format == GL_BGRA && type == GL_UNSIGNED_BYTE && !littleEndian)
1431          return GL_TRUE;
1432
1433       return GL_FALSE;
1434
1435    case MESA_FORMAT_X8B8G8R8_UNORM:
1436    case MESA_FORMAT_R8G8B8X8_UNORM:
1437       return GL_FALSE;
1438
1439    case MESA_FORMAT_B8G8R8X8_UNORM:
1440    case MESA_FORMAT_X8R8G8B8_UNORM:
1441       return GL_FALSE;
1442
1443    case MESA_FORMAT_BGR_UNORM8:
1444    case MESA_FORMAT_BGR_SRGB8:
1445       return format == GL_BGR && type == GL_UNSIGNED_BYTE && littleEndian;
1446
1447    case MESA_FORMAT_RGB_UNORM8:
1448       return format == GL_RGB && type == GL_UNSIGNED_BYTE && littleEndian;
1449
1450    case MESA_FORMAT_B5G6R5_UNORM:
1451       return format == GL_RGB && type == GL_UNSIGNED_SHORT_5_6_5 && !swapBytes;
1452
1453    case MESA_FORMAT_R5G6B5_UNORM:
1454       /* Some of the 16-bit MESA_FORMATs that would seem to correspond to
1455        * GL_UNSIGNED_SHORT_* are byte-swapped instead of channel-reversed,
1456        * according to formats.h, so they can't be matched.
1457        */
1458       return GL_FALSE;
1459
1460    case MESA_FORMAT_B4G4R4A4_UNORM:
1461       return format == GL_BGRA && type == GL_UNSIGNED_SHORT_4_4_4_4_REV &&
1462          !swapBytes;
1463
1464    case MESA_FORMAT_A4R4G4B4_UNORM:
1465       return GL_FALSE;
1466
1467    case MESA_FORMAT_A1B5G5R5_UNORM:
1468       return format == GL_RGBA && type == GL_UNSIGNED_SHORT_5_5_5_1 &&
1469          !swapBytes;
1470
1471    case MESA_FORMAT_B5G5R5A1_UNORM:
1472       return format == GL_BGRA && type == GL_UNSIGNED_SHORT_1_5_5_5_REV &&
1473          !swapBytes;
1474
1475    case MESA_FORMAT_A1R5G5B5_UNORM:
1476       return GL_FALSE;
1477
1478    case MESA_FORMAT_L4A4_UNORM:
1479       return GL_FALSE;
1480    case MESA_FORMAT_L8A8_UNORM:
1481    case MESA_FORMAT_L8A8_SRGB:
1482       return format == GL_LUMINANCE_ALPHA && type == GL_UNSIGNED_BYTE && littleEndian;
1483    case MESA_FORMAT_A8L8_UNORM:
1484    case MESA_FORMAT_A8L8_SRGB:
1485       return GL_FALSE;
1486
1487    case MESA_FORMAT_L16A16_UNORM:
1488       return format == GL_LUMINANCE_ALPHA && type == GL_UNSIGNED_SHORT && littleEndian && !swapBytes;
1489    case MESA_FORMAT_A16L16_UNORM:
1490       return GL_FALSE;
1491
1492    case MESA_FORMAT_B2G3R3_UNORM:
1493       return format == GL_RGB && type == GL_UNSIGNED_BYTE_3_3_2;
1494
1495    case MESA_FORMAT_A_UNORM8:
1496       return format == GL_ALPHA && type == GL_UNSIGNED_BYTE;
1497    case MESA_FORMAT_A_UNORM16:
1498       return format == GL_ALPHA && type == GL_UNSIGNED_SHORT && !swapBytes;
1499    case MESA_FORMAT_L_UNORM8:
1500    case MESA_FORMAT_L_SRGB8:
1501       return format == GL_LUMINANCE && type == GL_UNSIGNED_BYTE;
1502    case MESA_FORMAT_L_UNORM16:
1503       return format == GL_LUMINANCE && type == GL_UNSIGNED_SHORT && !swapBytes;
1504    case MESA_FORMAT_I_UNORM8:
1505       return format == GL_RED && type == GL_UNSIGNED_BYTE;
1506    case MESA_FORMAT_I_UNORM16:
1507       return format == GL_RED && type == GL_UNSIGNED_SHORT && !swapBytes;
1508
1509    case MESA_FORMAT_YCBCR:
1510       return format == GL_YCBCR_MESA &&
1511              ((type == GL_UNSIGNED_SHORT_8_8_MESA && littleEndian != swapBytes) ||
1512               (type == GL_UNSIGNED_SHORT_8_8_REV_MESA && littleEndian == swapBytes));
1513    case MESA_FORMAT_YCBCR_REV:
1514       return format == GL_YCBCR_MESA &&
1515              ((type == GL_UNSIGNED_SHORT_8_8_MESA && littleEndian == swapBytes) ||
1516               (type == GL_UNSIGNED_SHORT_8_8_REV_MESA && littleEndian != swapBytes));
1517
1518    case MESA_FORMAT_R_UNORM8:
1519       return format == GL_RED && type == GL_UNSIGNED_BYTE;
1520    case MESA_FORMAT_R8G8_UNORM:
1521       return format == GL_RG && type == GL_UNSIGNED_BYTE && littleEndian;
1522    case MESA_FORMAT_G8R8_UNORM:
1523       return GL_FALSE;
1524
1525    case MESA_FORMAT_R_UNORM16:
1526       return format == GL_RED && type == GL_UNSIGNED_SHORT &&
1527          !swapBytes;
1528    case MESA_FORMAT_R16G16_UNORM:
1529       return format == GL_RG && type == GL_UNSIGNED_SHORT && littleEndian &&
1530          !swapBytes;
1531    case MESA_FORMAT_G16R16_UNORM:
1532       return GL_FALSE;
1533
1534    case MESA_FORMAT_B10G10R10A2_UNORM:
1535       return format == GL_BGRA && type == GL_UNSIGNED_INT_2_10_10_10_REV &&
1536          !swapBytes;
1537
1538    case MESA_FORMAT_S8_UINT_Z24_UNORM:
1539       return format == GL_DEPTH_STENCIL && type == GL_UNSIGNED_INT_24_8 &&
1540          !swapBytes;
1541    case MESA_FORMAT_X8_UINT_Z24_UNORM:
1542    case MESA_FORMAT_Z24_UNORM_S8_UINT:
1543       return GL_FALSE;
1544
1545    case MESA_FORMAT_Z_UNORM16:
1546       return format == GL_DEPTH_COMPONENT && type == GL_UNSIGNED_SHORT &&
1547          !swapBytes;
1548
1549    case MESA_FORMAT_Z24_UNORM_X8_UINT:
1550       return GL_FALSE;
1551
1552    case MESA_FORMAT_Z_UNORM32:
1553       return format == GL_DEPTH_COMPONENT && type == GL_UNSIGNED_INT &&
1554          !swapBytes;
1555
1556    case MESA_FORMAT_S_UINT8:
1557       return format == GL_STENCIL_INDEX && type == GL_UNSIGNED_BYTE;
1558
1559    case MESA_FORMAT_SRGB_DXT1:
1560    case MESA_FORMAT_SRGBA_DXT1:
1561    case MESA_FORMAT_SRGBA_DXT3:
1562    case MESA_FORMAT_SRGBA_DXT5:
1563       return GL_FALSE;
1564
1565    case MESA_FORMAT_RGB_FXT1:
1566    case MESA_FORMAT_RGBA_FXT1:
1567    case MESA_FORMAT_RGB_DXT1:
1568    case MESA_FORMAT_RGBA_DXT1:
1569    case MESA_FORMAT_RGBA_DXT3:
1570    case MESA_FORMAT_RGBA_DXT5:
1571       return GL_FALSE;
1572
1573    case MESA_FORMAT_BPTC_RGBA_UNORM:
1574    case MESA_FORMAT_BPTC_SRGB_ALPHA_UNORM:
1575    case MESA_FORMAT_BPTC_RGB_SIGNED_FLOAT:
1576    case MESA_FORMAT_BPTC_RGB_UNSIGNED_FLOAT:
1577       return GL_FALSE;
1578
1579    case MESA_FORMAT_RGBA_FLOAT32:
1580       return format == GL_RGBA && type == GL_FLOAT && !swapBytes;
1581    case MESA_FORMAT_RGBA_FLOAT16:
1582       return format == GL_RGBA && type == GL_HALF_FLOAT && !swapBytes;
1583
1584    case MESA_FORMAT_RGB_FLOAT32:
1585       return format == GL_RGB && type == GL_FLOAT && !swapBytes;
1586    case MESA_FORMAT_RGB_FLOAT16:
1587       return format == GL_RGB && type == GL_HALF_FLOAT && !swapBytes;
1588
1589    case MESA_FORMAT_A_FLOAT32:
1590       return format == GL_ALPHA && type == GL_FLOAT && !swapBytes;
1591    case MESA_FORMAT_A_FLOAT16:
1592       return format == GL_ALPHA && type == GL_HALF_FLOAT && !swapBytes;
1593
1594    case MESA_FORMAT_L_FLOAT32:
1595       return format == GL_LUMINANCE && type == GL_FLOAT && !swapBytes;
1596    case MESA_FORMAT_L_FLOAT16:
1597       return format == GL_LUMINANCE && type == GL_HALF_FLOAT && !swapBytes;
1598
1599    case MESA_FORMAT_LA_FLOAT32:
1600       return format == GL_LUMINANCE_ALPHA && type == GL_FLOAT && !swapBytes;
1601    case MESA_FORMAT_LA_FLOAT16:
1602       return format == GL_LUMINANCE_ALPHA && type == GL_HALF_FLOAT && !swapBytes;
1603
1604    case MESA_FORMAT_I_FLOAT32:
1605       return format == GL_RED && type == GL_FLOAT && !swapBytes;
1606    case MESA_FORMAT_I_FLOAT16:
1607       return format == GL_RED && type == GL_HALF_FLOAT && !swapBytes;
1608
1609    case MESA_FORMAT_R_FLOAT32:
1610       return format == GL_RED && type == GL_FLOAT && !swapBytes;
1611    case MESA_FORMAT_R_FLOAT16:
1612       return format == GL_RED && type == GL_HALF_FLOAT && !swapBytes;
1613
1614    case MESA_FORMAT_RG_FLOAT32:
1615       return format == GL_RG && type == GL_FLOAT && !swapBytes;
1616    case MESA_FORMAT_RG_FLOAT16:
1617       return format == GL_RG && type == GL_HALF_FLOAT && !swapBytes;
1618
1619    case MESA_FORMAT_A_UINT8:
1620       return format == GL_ALPHA_INTEGER && type == GL_UNSIGNED_BYTE;
1621    case MESA_FORMAT_A_UINT16:
1622       return format == GL_ALPHA_INTEGER && type == GL_UNSIGNED_SHORT &&
1623              !swapBytes;
1624    case MESA_FORMAT_A_UINT32:
1625       return format == GL_ALPHA_INTEGER && type == GL_UNSIGNED_INT &&
1626              !swapBytes;
1627    case MESA_FORMAT_A_SINT8:
1628       return format == GL_ALPHA_INTEGER && type == GL_BYTE;
1629    case MESA_FORMAT_A_SINT16:
1630       return format == GL_ALPHA_INTEGER && type == GL_SHORT && !swapBytes;
1631    case MESA_FORMAT_A_SINT32:
1632       return format == GL_ALPHA_INTEGER && type == GL_INT && !swapBytes;
1633
1634    case MESA_FORMAT_I_UINT8:
1635       return format == GL_RED_INTEGER && type == GL_UNSIGNED_BYTE;
1636    case MESA_FORMAT_I_UINT16:
1637       return format == GL_RED_INTEGER && type == GL_UNSIGNED_SHORT && !swapBytes;
1638    case MESA_FORMAT_I_UINT32:
1639       return format == GL_RED_INTEGER && type == GL_UNSIGNED_INT && !swapBytes;
1640    case MESA_FORMAT_I_SINT8:
1641       return format == GL_RED_INTEGER && type == GL_BYTE;
1642    case MESA_FORMAT_I_SINT16:
1643       return format == GL_RED_INTEGER && type == GL_SHORT && !swapBytes;
1644    case MESA_FORMAT_I_SINT32:
1645       return format == GL_RED_INTEGER && type == GL_INT && !swapBytes;
1646
1647    case MESA_FORMAT_L_UINT8:
1648       return format == GL_LUMINANCE_INTEGER_EXT && type == GL_UNSIGNED_BYTE;
1649    case MESA_FORMAT_L_UINT16:
1650       return format == GL_LUMINANCE_INTEGER_EXT && type == GL_UNSIGNED_SHORT &&
1651              !swapBytes;
1652    case MESA_FORMAT_L_UINT32:
1653       return format == GL_LUMINANCE_INTEGER_EXT && type == GL_UNSIGNED_INT &&
1654              !swapBytes;
1655    case MESA_FORMAT_L_SINT8:
1656       return format == GL_LUMINANCE_INTEGER_EXT && type == GL_BYTE;
1657    case MESA_FORMAT_L_SINT16:
1658       return format == GL_LUMINANCE_INTEGER_EXT && type == GL_SHORT &&
1659              !swapBytes;
1660    case MESA_FORMAT_L_SINT32:
1661       return format == GL_LUMINANCE_INTEGER_EXT && type == GL_INT && !swapBytes;
1662
1663    case MESA_FORMAT_LA_UINT8:
1664       return format == GL_LUMINANCE_ALPHA_INTEGER_EXT &&
1665              type == GL_UNSIGNED_BYTE && !swapBytes;
1666    case MESA_FORMAT_LA_UINT16:
1667       return format == GL_LUMINANCE_ALPHA_INTEGER_EXT &&
1668              type == GL_UNSIGNED_SHORT && !swapBytes;
1669    case MESA_FORMAT_LA_UINT32:
1670       return format == GL_LUMINANCE_ALPHA_INTEGER_EXT &&
1671              type == GL_UNSIGNED_INT && !swapBytes;
1672    case MESA_FORMAT_LA_SINT8:
1673       return format == GL_LUMINANCE_ALPHA_INTEGER_EXT && type == GL_BYTE &&
1674              !swapBytes;
1675    case MESA_FORMAT_LA_SINT16:
1676       return format == GL_LUMINANCE_ALPHA_INTEGER_EXT && type == GL_SHORT &&
1677              !swapBytes;
1678    case MESA_FORMAT_LA_SINT32:
1679       return format == GL_LUMINANCE_ALPHA_INTEGER_EXT && type == GL_INT &&
1680              !swapBytes;
1681
1682    case MESA_FORMAT_R_SINT8:
1683       return format == GL_RED_INTEGER && type == GL_BYTE;
1684    case MESA_FORMAT_RG_SINT8:
1685       return format == GL_RG_INTEGER && type == GL_BYTE && !swapBytes;
1686    case MESA_FORMAT_RGB_SINT8:
1687       return format == GL_RGB_INTEGER && type == GL_BYTE && !swapBytes;
1688    case MESA_FORMAT_RGBA_SINT8:
1689       return format == GL_RGBA_INTEGER && type == GL_BYTE && !swapBytes;
1690    case MESA_FORMAT_R_SINT16:
1691       return format == GL_RED_INTEGER && type == GL_SHORT && !swapBytes;
1692    case MESA_FORMAT_RG_SINT16:
1693       return format == GL_RG_INTEGER && type == GL_SHORT && !swapBytes;
1694    case MESA_FORMAT_RGB_SINT16:
1695       return format == GL_RGB_INTEGER && type == GL_SHORT && !swapBytes;
1696    case MESA_FORMAT_RGBA_SINT16:
1697       return format == GL_RGBA_INTEGER && type == GL_SHORT && !swapBytes;
1698    case MESA_FORMAT_R_SINT32:
1699       return format == GL_RED_INTEGER && type == GL_INT && !swapBytes;
1700    case MESA_FORMAT_RG_SINT32:
1701       return format == GL_RG_INTEGER && type == GL_INT && !swapBytes;
1702    case MESA_FORMAT_RGB_SINT32:
1703       return format == GL_RGB_INTEGER && type == GL_INT && !swapBytes;
1704    case MESA_FORMAT_RGBA_SINT32:
1705       return format == GL_RGBA_INTEGER && type == GL_INT && !swapBytes;
1706
1707    case MESA_FORMAT_R_UINT8:
1708       return format == GL_RED_INTEGER && type == GL_UNSIGNED_BYTE;
1709    case MESA_FORMAT_RG_UINT8:
1710       return format == GL_RG_INTEGER && type == GL_UNSIGNED_BYTE && !swapBytes;
1711    case MESA_FORMAT_RGB_UINT8:
1712       return format == GL_RGB_INTEGER && type == GL_UNSIGNED_BYTE && !swapBytes;
1713    case MESA_FORMAT_RGBA_UINT8:
1714       return format == GL_RGBA_INTEGER && type == GL_UNSIGNED_BYTE &&
1715              !swapBytes;
1716    case MESA_FORMAT_R_UINT16:
1717       return format == GL_RED_INTEGER && type == GL_UNSIGNED_SHORT &&
1718              !swapBytes;
1719    case MESA_FORMAT_RG_UINT16:
1720       return format == GL_RG_INTEGER && type == GL_UNSIGNED_SHORT && !swapBytes;
1721    case MESA_FORMAT_RGB_UINT16:
1722       return format == GL_RGB_INTEGER && type == GL_UNSIGNED_SHORT &&
1723              !swapBytes;
1724    case MESA_FORMAT_RGBA_UINT16:
1725       return format == GL_RGBA_INTEGER && type == GL_UNSIGNED_SHORT &&
1726              !swapBytes;
1727    case MESA_FORMAT_R_UINT32:
1728       return format == GL_RED_INTEGER && type == GL_UNSIGNED_INT && !swapBytes;
1729    case MESA_FORMAT_RG_UINT32:
1730       return format == GL_RG_INTEGER && type == GL_UNSIGNED_INT && !swapBytes;
1731    case MESA_FORMAT_RGB_UINT32:
1732       return format == GL_RGB_INTEGER && type == GL_UNSIGNED_INT && !swapBytes;
1733    case MESA_FORMAT_RGBA_UINT32:
1734       return format == GL_RGBA_INTEGER && type == GL_UNSIGNED_INT && !swapBytes;
1735
1736    case MESA_FORMAT_R_SNORM8:
1737       return format == GL_RED && type == GL_BYTE;
1738    case MESA_FORMAT_R8G8_SNORM:
1739       return format == GL_RG && type == GL_BYTE && littleEndian &&
1740              !swapBytes;
1741    case MESA_FORMAT_X8B8G8R8_SNORM:
1742       return GL_FALSE;
1743
1744    case MESA_FORMAT_A8B8G8R8_SNORM:
1745       if (format == GL_RGBA && type == GL_BYTE && !littleEndian)
1746          return GL_TRUE;
1747
1748       if (format == GL_ABGR_EXT && type == GL_BYTE && littleEndian)
1749          return GL_TRUE;
1750
1751       return GL_FALSE;
1752
1753    case MESA_FORMAT_R8G8B8A8_SNORM:
1754       if (format == GL_RGBA && type == GL_BYTE && littleEndian)
1755          return GL_TRUE;
1756
1757       if (format == GL_ABGR_EXT && type == GL_BYTE && !littleEndian)
1758          return GL_TRUE;
1759
1760       return GL_FALSE;
1761
1762    case MESA_FORMAT_R_SNORM16:
1763       return format == GL_RED && type == GL_SHORT &&
1764              !swapBytes;
1765    case MESA_FORMAT_R16G16_SNORM:
1766       return format == GL_RG && type == GL_SHORT && littleEndian && !swapBytes;
1767    case MESA_FORMAT_RGB_SNORM16:
1768       return format == GL_RGB && type == GL_SHORT && !swapBytes;
1769    case MESA_FORMAT_RGBA_SNORM16:
1770       return format == GL_RGBA && type == GL_SHORT && !swapBytes;
1771    case MESA_FORMAT_RGBA_UNORM16:
1772       return format == GL_RGBA && type == GL_UNSIGNED_SHORT &&
1773              !swapBytes;
1774
1775    case MESA_FORMAT_R_RGTC1_UNORM:
1776    case MESA_FORMAT_R_RGTC1_SNORM:
1777    case MESA_FORMAT_RG_RGTC2_UNORM:
1778    case MESA_FORMAT_RG_RGTC2_SNORM:
1779       return GL_FALSE;
1780
1781    case MESA_FORMAT_L_LATC1_UNORM:
1782    case MESA_FORMAT_L_LATC1_SNORM:
1783    case MESA_FORMAT_LA_LATC2_UNORM:
1784    case MESA_FORMAT_LA_LATC2_SNORM:
1785       return GL_FALSE;
1786
1787    case MESA_FORMAT_ETC1_RGB8:
1788    case MESA_FORMAT_ETC2_RGB8:
1789    case MESA_FORMAT_ETC2_SRGB8:
1790    case MESA_FORMAT_ETC2_RGBA8_EAC:
1791    case MESA_FORMAT_ETC2_SRGB8_ALPHA8_EAC:
1792    case MESA_FORMAT_ETC2_R11_EAC:
1793    case MESA_FORMAT_ETC2_RG11_EAC:
1794    case MESA_FORMAT_ETC2_SIGNED_R11_EAC:
1795    case MESA_FORMAT_ETC2_SIGNED_RG11_EAC:
1796    case MESA_FORMAT_ETC2_RGB8_PUNCHTHROUGH_ALPHA1:
1797    case MESA_FORMAT_ETC2_SRGB8_PUNCHTHROUGH_ALPHA1:
1798       return GL_FALSE;
1799
1800    case MESA_FORMAT_A_SNORM8:
1801       return format == GL_ALPHA && type == GL_BYTE;
1802    case MESA_FORMAT_L_SNORM8:
1803       return format == GL_LUMINANCE && type == GL_BYTE;
1804    case MESA_FORMAT_L8A8_SNORM:
1805       return format == GL_LUMINANCE_ALPHA && type == GL_BYTE &&
1806              littleEndian && !swapBytes;
1807    case MESA_FORMAT_A8L8_SNORM:
1808       return format == GL_LUMINANCE_ALPHA && type == GL_BYTE &&
1809              !littleEndian && !swapBytes;
1810    case MESA_FORMAT_I_SNORM8:
1811       return format == GL_RED && type == GL_BYTE;
1812    case MESA_FORMAT_A_SNORM16:
1813       return format == GL_ALPHA && type == GL_SHORT && !swapBytes;
1814    case MESA_FORMAT_L_SNORM16:
1815       return format == GL_LUMINANCE && type == GL_SHORT && !swapBytes;
1816    case MESA_FORMAT_LA_SNORM16:
1817       return format == GL_LUMINANCE_ALPHA && type == GL_SHORT &&
1818              littleEndian && !swapBytes;
1819    case MESA_FORMAT_I_SNORM16:
1820       return format == GL_RED && type == GL_SHORT && littleEndian &&
1821              !swapBytes;
1822
1823    case MESA_FORMAT_B10G10R10A2_UINT:
1824       return (format == GL_BGRA_INTEGER_EXT &&
1825               type == GL_UNSIGNED_INT_2_10_10_10_REV &&
1826               !swapBytes);
1827
1828    case MESA_FORMAT_R10G10B10A2_UINT:
1829       return (format == GL_RGBA_INTEGER_EXT &&
1830               type == GL_UNSIGNED_INT_2_10_10_10_REV &&
1831               !swapBytes);
1832
1833    case MESA_FORMAT_R9G9B9E5_FLOAT:
1834       return format == GL_RGB && type == GL_UNSIGNED_INT_5_9_9_9_REV &&
1835          !swapBytes;
1836
1837    case MESA_FORMAT_R11G11B10_FLOAT:
1838       return format == GL_RGB && type == GL_UNSIGNED_INT_10F_11F_11F_REV &&
1839          !swapBytes;
1840
1841    case MESA_FORMAT_Z_FLOAT32:
1842       return format == GL_DEPTH_COMPONENT && type == GL_FLOAT && !swapBytes;
1843
1844    case MESA_FORMAT_Z32_FLOAT_S8X24_UINT:
1845       return format == GL_DEPTH_STENCIL &&
1846              type == GL_FLOAT_32_UNSIGNED_INT_24_8_REV && !swapBytes;
1847
1848    case MESA_FORMAT_B4G4R4X4_UNORM:
1849    case MESA_FORMAT_B5G5R5X1_UNORM:
1850    case MESA_FORMAT_R8G8B8X8_SNORM:
1851    case MESA_FORMAT_R8G8B8X8_SRGB:
1852    case MESA_FORMAT_RGBX_UINT8:
1853    case MESA_FORMAT_RGBX_SINT8:
1854    case MESA_FORMAT_B10G10R10X2_UNORM:
1855    case MESA_FORMAT_RGBX_UNORM16:
1856    case MESA_FORMAT_RGBX_SNORM16:
1857    case MESA_FORMAT_RGBX_FLOAT16:
1858    case MESA_FORMAT_RGBX_UINT16:
1859    case MESA_FORMAT_RGBX_SINT16:
1860    case MESA_FORMAT_RGBX_FLOAT32:
1861    case MESA_FORMAT_RGBX_UINT32:
1862    case MESA_FORMAT_RGBX_SINT32:
1863       return GL_FALSE;
1864
1865    case MESA_FORMAT_R10G10B10A2_UNORM:
1866       return format == GL_RGBA && type == GL_UNSIGNED_INT_2_10_10_10_REV &&
1867          !swapBytes;
1868
1869    case MESA_FORMAT_G8R8_SNORM:
1870       return format == GL_RG && type == GL_BYTE && !littleEndian &&
1871          !swapBytes;
1872
1873    case MESA_FORMAT_G16R16_SNORM:
1874       return format == GL_RG && type == GL_SHORT && !littleEndian &&
1875          !swapBytes;
1876
1877    case MESA_FORMAT_B8G8R8X8_SRGB:
1878       return GL_FALSE;
1879    }
1880
1881    return GL_FALSE;
1882 }
1883