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_A8R8G8B8_SRGB:
 361    case MESA_FORMAT_R8G8B8A8_SRGB:
 362    case MESA_FORMAT_L_SRGB8:
 363    case MESA_FORMAT_L8A8_SRGB:
 364    case MESA_FORMAT_A8L8_SRGB:
 365    case MESA_FORMAT_SRGB_DXT1:
 366    case MESA_FORMAT_SRGBA_DXT1:
 367    case MESA_FORMAT_SRGBA_DXT3:
 368    case MESA_FORMAT_SRGBA_DXT5:
 369    case MESA_FORMAT_R8G8B8X8_SRGB:
 370    case MESA_FORMAT_ETC2_SRGB8:
 371    case MESA_FORMAT_ETC2_SRGB8_ALPHA8_EAC:
 372    case MESA_FORMAT_ETC2_SRGB8_PUNCHTHROUGH_ALPHA1:
 373    case MESA_FORMAT_B8G8R8X8_SRGB:
 374    case MESA_FORMAT_BPTC_SRGB_ALPHA_UNORM:
 375       return GL_SRGB;
 376    default:
 377       return GL_LINEAR;
 378    }
 379 }
 380
 381
 382 /**
 383  * Return TRUE if format is an ETC2 compressed format specified
 384  * by GL_ARB_ES3_compatibility.
 385  */
 386 bool
 387 _mesa_is_format_etc2(mesa_format format)
 388 {
 389    switch (format) {
 390    case MESA_FORMAT_ETC2_RGB8:
 391    case MESA_FORMAT_ETC2_SRGB8:
 392    case MESA_FORMAT_ETC2_RGBA8_EAC:
 393    case MESA_FORMAT_ETC2_SRGB8_ALPHA8_EAC:
 394    case MESA_FORMAT_ETC2_R11_EAC:
 395    case MESA_FORMAT_ETC2_RG11_EAC:
 396    case MESA_FORMAT_ETC2_SIGNED_R11_EAC:
 397    case MESA_FORMAT_ETC2_SIGNED_RG11_EAC:
 398    case MESA_FORMAT_ETC2_RGB8_PUNCHTHROUGH_ALPHA1:
 399    case MESA_FORMAT_ETC2_SRGB8_PUNCHTHROUGH_ALPHA1:
 400       return GL_TRUE;
 401    default:
 402       return GL_FALSE;
 403    }
 404 }
 405
 406
 407 /**
 408  * For an sRGB format, return the corresponding linear color space format.
 409  * For non-sRGB formats, return the format as-is.
 410  */
 411 mesa_format
 412 _mesa_get_srgb_format_linear(mesa_format format)
 413 {
 414    switch (format) {
 415    case MESA_FORMAT_BGR_SRGB8:
 416       format = MESA_FORMAT_BGR_UNORM8;
 417       break;
 418    case MESA_FORMAT_A8B8G8R8_SRGB:
 419       format = MESA_FORMAT_A8B8G8R8_UNORM;
 420       break;
 421    case MESA_FORMAT_B8G8R8A8_SRGB:
 422       format = MESA_FORMAT_B8G8R8A8_UNORM;
 423       break;
 424    case MESA_FORMAT_A8R8G8B8_SRGB:
 425       format = MESA_FORMAT_A8R8G8B8_UNORM;
 426       break;
 427    case MESA_FORMAT_R8G8B8A8_SRGB:
 428       format = MESA_FORMAT_R8G8B8A8_UNORM;
 429       break;
 430    case MESA_FORMAT_L_SRGB8:
 431       format = MESA_FORMAT_L_UNORM8;
 432       break;
 433    case MESA_FORMAT_L8A8_SRGB:
 434       format = MESA_FORMAT_L8A8_UNORM;
 435       break;
 436    case MESA_FORMAT_A8L8_SRGB:
 437       format = MESA_FORMAT_A8L8_UNORM;
 438       break;
 439    case MESA_FORMAT_SRGB_DXT1:
 440       format = MESA_FORMAT_RGB_DXT1;
 441       break;
 442    case MESA_FORMAT_SRGBA_DXT1:
 443       format = MESA_FORMAT_RGBA_DXT1;
 444       break;
 445    case MESA_FORMAT_SRGBA_DXT3:
 446       format = MESA_FORMAT_RGBA_DXT3;
 447       break;
 448    case MESA_FORMAT_SRGBA_DXT5:
 449       format = MESA_FORMAT_RGBA_DXT5;
 450       break;
 451    case MESA_FORMAT_R8G8B8X8_SRGB:
 452       format = MESA_FORMAT_R8G8B8X8_UNORM;
 453       break;
 454    case MESA_FORMAT_X8B8G8R8_SRGB:
 455       format = MESA_FORMAT_X8B8G8R8_UNORM;
 456       break;
 457    case MESA_FORMAT_ETC2_SRGB8:
 458       format = MESA_FORMAT_ETC2_RGB8;
 459       break;
 460    case MESA_FORMAT_ETC2_SRGB8_ALPHA8_EAC:
 461       format = MESA_FORMAT_ETC2_RGBA8_EAC;
 462       break;
 463    case MESA_FORMAT_ETC2_SRGB8_PUNCHTHROUGH_ALPHA1:
 464       format = MESA_FORMAT_ETC2_RGB8_PUNCHTHROUGH_ALPHA1;
 465       break;
 466    case MESA_FORMAT_BPTC_SRGB_ALPHA_UNORM:
 467       format = MESA_FORMAT_BPTC_RGBA_UNORM;
 468       break;
 469    case MESA_FORMAT_B8G8R8X8_SRGB:
 470       format = MESA_FORMAT_B8G8R8X8_UNORM;
 471       break;
 472    case MESA_FORMAT_X8R8G8B8_SRGB:
 473       format = MESA_FORMAT_X8R8G8B8_UNORM;
 474       break;
 475    default:
 476       break;
 477    }
 478    return format;
 479 }
 480
 481
 482 /**
 483  * If the given format is a compressed format, return a corresponding
 484  * uncompressed format.
 485  */
 486 mesa_format
 487 _mesa_get_uncompressed_format(mesa_format format)
 488 {
 489    switch (format) {
 490    case MESA_FORMAT_RGB_FXT1:
 491       return MESA_FORMAT_BGR_UNORM8;
 492    case MESA_FORMAT_RGBA_FXT1:
 493       return MESA_FORMAT_A8B8G8R8_UNORM;
 494    case MESA_FORMAT_RGB_DXT1:
 495    case MESA_FORMAT_SRGB_DXT1:
 496       return MESA_FORMAT_BGR_UNORM8;
 497    case MESA_FORMAT_RGBA_DXT1:
 498    case MESA_FORMAT_SRGBA_DXT1:
 499       return MESA_FORMAT_A8B8G8R8_UNORM;
 500    case MESA_FORMAT_RGBA_DXT3:
 501    case MESA_FORMAT_SRGBA_DXT3:
 502       return MESA_FORMAT_A8B8G8R8_UNORM;
 503    case MESA_FORMAT_RGBA_DXT5:
 504    case MESA_FORMAT_SRGBA_DXT5:
 505       return MESA_FORMAT_A8B8G8R8_UNORM;
 506    case MESA_FORMAT_R_RGTC1_UNORM:
 507       return MESA_FORMAT_R_UNORM8;
 508    case MESA_FORMAT_R_RGTC1_SNORM:
 509       return MESA_FORMAT_R_SNORM8;
 510    case MESA_FORMAT_RG_RGTC2_UNORM:
 511       return MESA_FORMAT_R8G8_UNORM;
 512    case MESA_FORMAT_RG_RGTC2_SNORM:
 513       return MESA_FORMAT_R8G8_SNORM;
 514    case MESA_FORMAT_L_LATC1_UNORM:
 515       return MESA_FORMAT_L_UNORM8;
 516    case MESA_FORMAT_L_LATC1_SNORM:
 517       return MESA_FORMAT_L_SNORM8;
 518    case MESA_FORMAT_LA_LATC2_UNORM:
 519       return MESA_FORMAT_L8A8_UNORM;
 520    case MESA_FORMAT_LA_LATC2_SNORM:
 521       return MESA_FORMAT_L8A8_SNORM;
 522    case MESA_FORMAT_ETC1_RGB8:
 523    case MESA_FORMAT_ETC2_RGB8:
 524    case MESA_FORMAT_ETC2_SRGB8:
 525       return MESA_FORMAT_BGR_UNORM8;
 526    case MESA_FORMAT_ETC2_RGBA8_EAC:
 527    case MESA_FORMAT_ETC2_SRGB8_ALPHA8_EAC:
 528    case MESA_FORMAT_ETC2_RGB8_PUNCHTHROUGH_ALPHA1:
 529    case MESA_FORMAT_ETC2_SRGB8_PUNCHTHROUGH_ALPHA1:
 530       return MESA_FORMAT_A8B8G8R8_UNORM;
 531    case MESA_FORMAT_ETC2_R11_EAC:
 532    case MESA_FORMAT_ETC2_SIGNED_R11_EAC:
 533       return MESA_FORMAT_R_UNORM16;
 534    case MESA_FORMAT_ETC2_RG11_EAC:
 535    case MESA_FORMAT_ETC2_SIGNED_RG11_EAC:
 536       return MESA_FORMAT_R16G16_UNORM;
 537    case MESA_FORMAT_BPTC_RGBA_UNORM:
 538    case MESA_FORMAT_BPTC_SRGB_ALPHA_UNORM:
 539       return MESA_FORMAT_A8B8G8R8_UNORM;
 540    case MESA_FORMAT_BPTC_RGB_UNSIGNED_FLOAT:
 541    case MESA_FORMAT_BPTC_RGB_SIGNED_FLOAT:
 542       return MESA_FORMAT_RGB_FLOAT32;
 543    default:
 544 #ifdef DEBUG
 545       assert(!_mesa_is_format_compressed(format));
 546 #endif
 547       return format;
 548    }
 549 }
 550
 551
 552 GLuint
 553 _mesa_format_num_components(mesa_format format)
 554 {
 555    const struct gl_format_info *info = _mesa_get_format_info(format);
 556    return ((info->RedBits > 0) +
 557            (info->GreenBits > 0) +
 558            (info->BlueBits > 0) +
 559            (info->AlphaBits > 0) +
 560            (info->LuminanceBits > 0) +
 561            (info->IntensityBits > 0) +
 562            (info->DepthBits > 0) +
 563            (info->StencilBits > 0));
 564 }
 565
 566
 567 /**
 568  * Returns true if a color format has data stored in the R/G/B/A channels,
 569  * given an index from 0 to 3.
 570  */
 571 bool
 572 _mesa_format_has_color_component(mesa_format format, int component)
 573 {
 574    const struct gl_format_info *info = _mesa_get_format_info(format);
 575
 576    assert(info->BaseFormat != GL_DEPTH_COMPONENT &&
 577           info->BaseFormat != GL_DEPTH_STENCIL &&
 578           info->BaseFormat != GL_STENCIL_INDEX);
 579
 580    switch (component) {
 581    case 0:
 582       return (info->RedBits + info->IntensityBits + info->LuminanceBits) > 0;
 583    case 1:
 584       return (info->GreenBits + info->IntensityBits + info->LuminanceBits) > 0;
 585    case 2:
 586       return (info->BlueBits + info->IntensityBits + info->LuminanceBits) > 0;
 587    case 3:
 588       return (info->AlphaBits + info->IntensityBits) > 0;
 589    default:
 590       assert(!"Invalid color component: must be 0..3");
 591       return false;
 592    }
 593 }
 594
 595
 596 /**
 597  * Return number of bytes needed to store an image of the given size
 598  * in the given format.
 599  */
 600 GLuint
 601 _mesa_format_image_size(mesa_format format, GLsizei width,
 602                         GLsizei height, GLsizei depth)
 603 {
 604    const struct gl_format_info *info = _mesa_get_format_info(format);
 605    /* Strictly speaking, a conditional isn't needed here */
 606    if (info->BlockWidth > 1 || info->BlockHeight > 1) {
 607       /* compressed format (2D only for now) */
 608       const GLuint bw = info->BlockWidth, bh = info->BlockHeight;
 609       const GLuint wblocks = (width + bw - 1) / bw;
 610       const GLuint hblocks = (height + bh - 1) / bh;
 611       const GLuint sz = wblocks * hblocks * info->BytesPerBlock;
 612       return sz * depth;
 613    }
 614    else {
 615       /* non-compressed */
 616       const GLuint sz = width * height * depth * info->BytesPerBlock;
 617       return sz;
 618    }
 619 }
 620
 621
 622 /**
 623  * Same as _mesa_format_image_size() but returns a 64-bit value to
 624  * accomodate very large textures.
 625  */
 626 uint64_t
 627 _mesa_format_image_size64(mesa_format format, GLsizei width,
 628                           GLsizei height, GLsizei depth)
 629 {
 630    const struct gl_format_info *info = _mesa_get_format_info(format);
 631    /* Strictly speaking, a conditional isn't needed here */
 632    if (info->BlockWidth > 1 || info->BlockHeight > 1) {
 633       /* compressed format (2D only for now) */
 634       const uint64_t bw = info->BlockWidth, bh = info->BlockHeight;
 635       const uint64_t wblocks = (width + bw - 1) / bw;
 636       const uint64_t hblocks = (height + bh - 1) / bh;
 637       const uint64_t sz = wblocks * hblocks * info->BytesPerBlock;
 638       return sz * depth;
 639    }
 640    else {
 641       /* non-compressed */
 642       const uint64_t sz = ((uint64_t) width *
 643                            (uint64_t) height *
 644                            (uint64_t) depth *
 645                            info->BytesPerBlock);
 646       return sz;
 647    }
 648 }
 649
 650
 651
 652 GLint
 653 _mesa_format_row_stride(mesa_format format, GLsizei width)
 654 {
 655    const struct gl_format_info *info = _mesa_get_format_info(format);
 656    /* Strictly speaking, a conditional isn't needed here */
 657    if (info->BlockWidth > 1 || info->BlockHeight > 1) {
 658       /* compressed format */
 659       const GLuint bw = info->BlockWidth;
 660       const GLuint wblocks = (width + bw - 1) / bw;
 661       const GLint stride = wblocks * info->BytesPerBlock;
 662       return stride;
 663    }
 664    else {
 665       const GLint stride = width * info->BytesPerBlock;
 666       return stride;
 667    }
 668 }
 669
 670
 671 /**
 672  * Debug/test: check that all formats are handled in the
 673  * _mesa_format_to_type_and_comps() function.  When new pixel formats
 674  * are added to Mesa, that function needs to be updated.
 675  * This is a no-op after the first call.
 676  */
 677 static void
 678 check_format_to_type_and_comps(void)
 679 {
 680    mesa_format f;
 681
 682    for (f = MESA_FORMAT_NONE + 1; f < MESA_FORMAT_COUNT; f++) {
 683       GLenum datatype = 0;
 684       GLuint comps = 0;
 685       /* This function will emit a problem/warning if the format is
 686        * not handled.
 687        */
 688       _mesa_format_to_type_and_comps(f, &datatype, &comps);
 689    }
 690 }
 691
 692 /**
 693  * Do sanity checking of the format info table.
 694  */
 695 void
 696 _mesa_test_formats(void)
 697 {
 698    GLuint i;
 699
 700    STATIC_ASSERT(Elements(format_info) == MESA_FORMAT_COUNT);
 701
 702    for (i = 0; i < MESA_FORMAT_COUNT; i++) {
 703       const struct gl_format_info *info = _mesa_get_format_info(i);
 704       assert(info);
 705
 706       assert(info->Name == i);
 707
 708       if (info->Name == MESA_FORMAT_NONE)
 709          continue;
 710
 711       if (info->BlockWidth == 1 && info->BlockHeight == 1) {
 712          if (info->RedBits > 0) {
 713             GLuint t = info->RedBits + info->GreenBits
 714                + info->BlueBits + info->AlphaBits;
 715             assert(t / 8 <= info->BytesPerBlock);
 716             (void) t;
 717          }
 718       }
 719
 720       assert(info->DataType == GL_UNSIGNED_NORMALIZED ||
 721              info->DataType == GL_SIGNED_NORMALIZED ||
 722              info->DataType == GL_UNSIGNED_INT ||
 723              info->DataType == GL_INT ||
 724              info->DataType == GL_FLOAT ||
 725              /* Z32_FLOAT_X24S8 has DataType of GL_NONE */
 726              info->DataType == GL_NONE);
 727
 728       if (info->BaseFormat == GL_RGB) {
 729          assert(info->RedBits > 0);
 730          assert(info->GreenBits > 0);
 731          assert(info->BlueBits > 0);
 732          assert(info->AlphaBits == 0);
 733          assert(info->LuminanceBits == 0);
 734          assert(info->IntensityBits == 0);
 735       }
 736       else if (info->BaseFormat == GL_RGBA) {
 737          assert(info->RedBits > 0);
 738          assert(info->GreenBits > 0);
 739          assert(info->BlueBits > 0);
 740          assert(info->AlphaBits > 0);
 741          assert(info->LuminanceBits == 0);
 742          assert(info->IntensityBits == 0);
 743       }
 744       else if (info->BaseFormat == GL_RG) {
 745          assert(info->RedBits > 0);
 746          assert(info->GreenBits > 0);
 747          assert(info->BlueBits == 0);
 748          assert(info->AlphaBits == 0);
 749          assert(info->LuminanceBits == 0);
 750          assert(info->IntensityBits == 0);
 751       }
 752       else if (info->BaseFormat == GL_RED) {
 753          assert(info->RedBits > 0);
 754          assert(info->GreenBits == 0);
 755          assert(info->BlueBits == 0);
 756          assert(info->AlphaBits == 0);
 757          assert(info->LuminanceBits == 0);
 758          assert(info->IntensityBits == 0);
 759       }
 760       else if (info->BaseFormat == GL_LUMINANCE) {
 761          assert(info->RedBits == 0);
 762          assert(info->GreenBits == 0);
 763          assert(info->BlueBits == 0);
 764          assert(info->AlphaBits == 0);
 765          assert(info->LuminanceBits > 0);
 766          assert(info->IntensityBits == 0);
 767       }
 768       else if (info->BaseFormat == GL_INTENSITY) {
 769          assert(info->RedBits == 0);
 770          assert(info->GreenBits == 0);
 771          assert(info->BlueBits == 0);
 772          assert(info->AlphaBits == 0);
 773          assert(info->LuminanceBits == 0);
 774          assert(info->IntensityBits > 0);
 775       }
 776    }
 777
 778    check_format_to_type_and_comps();
 779 }
 780
 781
 782
 783 /**
 784  * Return datatype and number of components per texel for the given mesa_format.
 785  * Only used for mipmap generation code.
 786  */
 787 void
 788 _mesa_format_to_type_and_comps(mesa_format format,
 789                                GLenum *datatype, GLuint *comps)
 790 {
 791    switch (format) {
 792    case MESA_FORMAT_A8B8G8R8_UNORM:
 793    case MESA_FORMAT_R8G8B8A8_UNORM:
 794    case MESA_FORMAT_B8G8R8A8_UNORM:
 795    case MESA_FORMAT_A8R8G8B8_UNORM:
 796    case MESA_FORMAT_X8B8G8R8_UNORM:
 797    case MESA_FORMAT_R8G8B8X8_UNORM:
 798    case MESA_FORMAT_B8G8R8X8_UNORM:
 799    case MESA_FORMAT_X8R8G8B8_UNORM:
 800       *datatype = GL_UNSIGNED_BYTE;
 801       *comps = 4;
 802       return;
 803    case MESA_FORMAT_BGR_UNORM8:
 804    case MESA_FORMAT_RGB_UNORM8:
 805       *datatype = GL_UNSIGNED_BYTE;
 806       *comps = 3;
 807       return;
 808    case MESA_FORMAT_B5G6R5_UNORM:
 809    case MESA_FORMAT_R5G6B5_UNORM:
 810       *datatype = GL_UNSIGNED_SHORT_5_6_5;
 811       *comps = 3;
 812       return;
 813
 814    case MESA_FORMAT_B4G4R4A4_UNORM:
 815    case MESA_FORMAT_A4R4G4B4_UNORM:
 816    case MESA_FORMAT_B4G4R4X4_UNORM:
 817       *datatype = GL_UNSIGNED_SHORT_4_4_4_4;
 818       *comps = 4;
 819       return;
 820
 821    case MESA_FORMAT_B5G5R5A1_UNORM:
 822    case MESA_FORMAT_A1R5G5B5_UNORM:
 823    case MESA_FORMAT_B5G5R5X1_UNORM:
 824       *datatype = GL_UNSIGNED_SHORT_1_5_5_5_REV;
 825       *comps = 4;
 826       return;
 827
 828    case MESA_FORMAT_B10G10R10A2_UNORM:
 829       *datatype = GL_UNSIGNED_INT_2_10_10_10_REV;
 830       *comps = 4;
 831       return;
 832
 833    case MESA_FORMAT_A1B5G5R5_UNORM:
 834       *datatype = GL_UNSIGNED_SHORT_5_5_5_1;
 835       *comps = 4;
 836       return;
 837
 838    case MESA_FORMAT_L4A4_UNORM:
 839       *datatype = MESA_UNSIGNED_BYTE_4_4;
 840       *comps = 2;
 841       return;
 842
 843    case MESA_FORMAT_L8A8_UNORM:
 844    case MESA_FORMAT_A8L8_UNORM:
 845    case MESA_FORMAT_R8G8_UNORM:
 846    case MESA_FORMAT_G8R8_UNORM:
 847       *datatype = GL_UNSIGNED_BYTE;
 848       *comps = 2;
 849       return;
 850
 851    case MESA_FORMAT_L16A16_UNORM:
 852    case MESA_FORMAT_A16L16_UNORM:
 853    case MESA_FORMAT_R16G16_UNORM:
 854    case MESA_FORMAT_G16R16_UNORM:
 855       *datatype = GL_UNSIGNED_SHORT;
 856       *comps = 2;
 857       return;
 858
 859    case MESA_FORMAT_R_UNORM16:
 860    case MESA_FORMAT_A_UNORM16:
 861    case MESA_FORMAT_L_UNORM16:
 862    case MESA_FORMAT_I_UNORM16:
 863       *datatype = GL_UNSIGNED_SHORT;
 864       *comps = 1;
 865       return;
 866
 867    case MESA_FORMAT_B2G3R3_UNORM:
 868       *datatype = GL_UNSIGNED_BYTE_3_3_2;
 869       *comps = 3;
 870       return;
 871
 872    case MESA_FORMAT_A_UNORM8:
 873    case MESA_FORMAT_L_UNORM8:
 874    case MESA_FORMAT_I_UNORM8:
 875    case MESA_FORMAT_R_UNORM8:
 876    case MESA_FORMAT_S_UINT8:
 877       *datatype = GL_UNSIGNED_BYTE;
 878       *comps = 1;
 879       return;
 880
 881    case MESA_FORMAT_YCBCR:
 882    case MESA_FORMAT_YCBCR_REV:
 883       *datatype = GL_UNSIGNED_SHORT;
 884       *comps = 2;
 885       return;
 886
 887    case MESA_FORMAT_S8_UINT_Z24_UNORM:
 888       *datatype = GL_UNSIGNED_INT_24_8_MESA;
 889       *comps = 2;
 890       return;
 891
 892    case MESA_FORMAT_Z24_UNORM_S8_UINT:
 893       *datatype = GL_UNSIGNED_INT_8_24_REV_MESA;
 894       *comps = 2;
 895       return;
 896
 897    case MESA_FORMAT_Z_UNORM16:
 898       *datatype = GL_UNSIGNED_SHORT;
 899       *comps = 1;
 900       return;
 901
 902    case MESA_FORMAT_Z24_UNORM_X8_UINT:
 903       *datatype = GL_UNSIGNED_INT;
 904       *comps = 1;
 905       return;
 906
 907    case MESA_FORMAT_X8_UINT_Z24_UNORM:
 908       *datatype = GL_UNSIGNED_INT;
 909       *comps = 1;
 910       return;
 911
 912    case MESA_FORMAT_Z_UNORM32:
 913       *datatype = GL_UNSIGNED_INT;
 914       *comps = 1;
 915       return;
 916
 917    case MESA_FORMAT_Z_FLOAT32:
 918       *datatype = GL_FLOAT;
 919       *comps = 1;
 920       return;
 921
 922    case MESA_FORMAT_Z32_FLOAT_S8X24_UINT:
 923       *datatype = GL_FLOAT_32_UNSIGNED_INT_24_8_REV;
 924       *comps = 1;
 925       return;
 926
 927    case MESA_FORMAT_R_SNORM8:
 928    case MESA_FORMAT_A_SNORM8:
 929    case MESA_FORMAT_L_SNORM8:
 930    case MESA_FORMAT_I_SNORM8:
 931       *datatype = GL_BYTE;
 932       *comps = 1;
 933       return;
 934    case MESA_FORMAT_R8G8_SNORM:
 935    case MESA_FORMAT_L8A8_SNORM:
 936    case MESA_FORMAT_A8L8_SNORM:
 937       *datatype = GL_BYTE;
 938       *comps = 2;
 939       return;
 940    case MESA_FORMAT_A8B8G8R8_SNORM:
 941    case MESA_FORMAT_R8G8B8A8_SNORM:
 942    case MESA_FORMAT_X8B8G8R8_SNORM:
 943       *datatype = GL_BYTE;
 944       *comps = 4;
 945       return;
 946
 947    case MESA_FORMAT_RGBA_UNORM16:
 948       *datatype = GL_UNSIGNED_SHORT;
 949       *comps = 4;
 950       return;
 951
 952    case MESA_FORMAT_R_SNORM16:
 953    case MESA_FORMAT_A_SNORM16:
 954    case MESA_FORMAT_L_SNORM16:
 955    case MESA_FORMAT_I_SNORM16:
 956       *datatype = GL_SHORT;
 957       *comps = 1;
 958       return;
 959    case MESA_FORMAT_R16G16_SNORM:
 960    case MESA_FORMAT_LA_SNORM16:
 961       *datatype = GL_SHORT;
 962       *comps = 2;
 963       return;
 964    case MESA_FORMAT_RGB_SNORM16:
 965       *datatype = GL_SHORT;
 966       *comps = 3;
 967       return;
 968    case MESA_FORMAT_RGBA_SNORM16:
 969       *datatype = GL_SHORT;
 970       *comps = 4;
 971       return;
 972
 973    case MESA_FORMAT_BGR_SRGB8:
 974       *datatype = GL_UNSIGNED_BYTE;
 975       *comps = 3;
 976       return;
 977    case MESA_FORMAT_A8B8G8R8_SRGB:
 978    case MESA_FORMAT_B8G8R8A8_SRGB:
 979    case MESA_FORMAT_A8R8G8B8_SRGB:
 980    case MESA_FORMAT_R8G8B8A8_SRGB:
 981       *datatype = GL_UNSIGNED_BYTE;
 982       *comps = 4;
 983       return;
 984    case MESA_FORMAT_L_SRGB8:
 985       *datatype = GL_UNSIGNED_BYTE;
 986       *comps = 1;
 987       return;
 988    case MESA_FORMAT_L8A8_SRGB:
 989    case MESA_FORMAT_A8L8_SRGB:
 990       *datatype = GL_UNSIGNED_BYTE;
 991       *comps = 2;
 992       return;
 993
 994    case MESA_FORMAT_RGB_FXT1:
 995    case MESA_FORMAT_RGBA_FXT1:
 996    case MESA_FORMAT_RGB_DXT1:
 997    case MESA_FORMAT_RGBA_DXT1:
 998    case MESA_FORMAT_RGBA_DXT3:
 999    case MESA_FORMAT_RGBA_DXT5:
1000    case MESA_FORMAT_SRGB_DXT1:
1001    case MESA_FORMAT_SRGBA_DXT1:
1002    case MESA_FORMAT_SRGBA_DXT3:
1003    case MESA_FORMAT_SRGBA_DXT5:
1004    case MESA_FORMAT_R_RGTC1_UNORM:
1005    case MESA_FORMAT_R_RGTC1_SNORM:
1006    case MESA_FORMAT_RG_RGTC2_UNORM:
1007    case MESA_FORMAT_RG_RGTC2_SNORM:
1008    case MESA_FORMAT_L_LATC1_UNORM:
1009    case MESA_FORMAT_L_LATC1_SNORM:
1010    case MESA_FORMAT_LA_LATC2_UNORM:
1011    case MESA_FORMAT_LA_LATC2_SNORM:
1012    case MESA_FORMAT_ETC1_RGB8:
1013    case MESA_FORMAT_ETC2_RGB8:
1014    case MESA_FORMAT_ETC2_SRGB8:
1015    case MESA_FORMAT_ETC2_RGBA8_EAC:
1016    case MESA_FORMAT_ETC2_SRGB8_ALPHA8_EAC:
1017    case MESA_FORMAT_ETC2_R11_EAC:
1018    case MESA_FORMAT_ETC2_RG11_EAC:
1019    case MESA_FORMAT_ETC2_SIGNED_R11_EAC:
1020    case MESA_FORMAT_ETC2_SIGNED_RG11_EAC:
1021    case MESA_FORMAT_ETC2_RGB8_PUNCHTHROUGH_ALPHA1:
1022    case MESA_FORMAT_ETC2_SRGB8_PUNCHTHROUGH_ALPHA1:
1023    case MESA_FORMAT_BPTC_RGBA_UNORM:
1024    case MESA_FORMAT_BPTC_SRGB_ALPHA_UNORM:
1025    case MESA_FORMAT_BPTC_RGB_SIGNED_FLOAT:
1026    case MESA_FORMAT_BPTC_RGB_UNSIGNED_FLOAT:
1027       /* XXX generate error instead? */
1028       *datatype = GL_UNSIGNED_BYTE;
1029       *comps = 0;
1030       return;
1031
1032    case MESA_FORMAT_RGBA_FLOAT32:
1033       *datatype = GL_FLOAT;
1034       *comps = 4;
1035       return;
1036    case MESA_FORMAT_RGBA_FLOAT16:
1037       *datatype = GL_HALF_FLOAT_ARB;
1038       *comps = 4;
1039       return;
1040    case MESA_FORMAT_RGB_FLOAT32:
1041       *datatype = GL_FLOAT;
1042       *comps = 3;
1043       return;
1044    case MESA_FORMAT_RGB_FLOAT16:
1045       *datatype = GL_HALF_FLOAT_ARB;
1046       *comps = 3;
1047       return;
1048    case MESA_FORMAT_LA_FLOAT32:
1049    case MESA_FORMAT_RG_FLOAT32:
1050       *datatype = GL_FLOAT;
1051       *comps = 2;
1052       return;
1053    case MESA_FORMAT_LA_FLOAT16:
1054    case MESA_FORMAT_RG_FLOAT16:
1055       *datatype = GL_HALF_FLOAT_ARB;
1056       *comps = 2;
1057       return;
1058    case MESA_FORMAT_A_FLOAT32:
1059    case MESA_FORMAT_L_FLOAT32:
1060    case MESA_FORMAT_I_FLOAT32:
1061    case MESA_FORMAT_R_FLOAT32:
1062       *datatype = GL_FLOAT;
1063       *comps = 1;
1064       return;
1065    case MESA_FORMAT_A_FLOAT16:
1066    case MESA_FORMAT_L_FLOAT16:
1067    case MESA_FORMAT_I_FLOAT16:
1068    case MESA_FORMAT_R_FLOAT16:
1069       *datatype = GL_HALF_FLOAT_ARB;
1070       *comps = 1;
1071       return;
1072
1073    case MESA_FORMAT_A_UINT8:
1074    case MESA_FORMAT_L_UINT8:
1075    case MESA_FORMAT_I_UINT8:
1076       *datatype = GL_UNSIGNED_BYTE;
1077       *comps = 1;
1078       return;
1079    case MESA_FORMAT_LA_UINT8:
1080       *datatype = GL_UNSIGNED_BYTE;
1081       *comps = 2;
1082       return;
1083
1084    case MESA_FORMAT_A_UINT16:
1085    case MESA_FORMAT_L_UINT16:
1086    case MESA_FORMAT_I_UINT16:
1087       *datatype = GL_UNSIGNED_SHORT;
1088       *comps = 1;
1089       return;
1090    case MESA_FORMAT_LA_UINT16:
1091       *datatype = GL_UNSIGNED_SHORT;
1092       *comps = 2;
1093       return;
1094    case MESA_FORMAT_A_UINT32:
1095    case MESA_FORMAT_L_UINT32:
1096    case MESA_FORMAT_I_UINT32:
1097       *datatype = GL_UNSIGNED_INT;
1098       *comps = 1;
1099       return;
1100    case MESA_FORMAT_LA_UINT32:
1101       *datatype = GL_UNSIGNED_INT;
1102       *comps = 2;
1103       return;
1104    case MESA_FORMAT_A_SINT8:
1105    case MESA_FORMAT_L_SINT8:
1106    case MESA_FORMAT_I_SINT8:
1107       *datatype = GL_BYTE;
1108       *comps = 1;
1109       return;
1110    case MESA_FORMAT_LA_SINT8:
1111       *datatype = GL_BYTE;
1112       *comps = 2;
1113       return;
1114
1115    case MESA_FORMAT_A_SINT16:
1116    case MESA_FORMAT_L_SINT16:
1117    case MESA_FORMAT_I_SINT16:
1118       *datatype = GL_SHORT;
1119       *comps = 1;
1120       return;
1121    case MESA_FORMAT_LA_SINT16:
1122       *datatype = GL_SHORT;
1123       *comps = 2;
1124       return;
1125
1126    case MESA_FORMAT_A_SINT32:
1127    case MESA_FORMAT_L_SINT32:
1128    case MESA_FORMAT_I_SINT32:
1129       *datatype = GL_INT;
1130       *comps = 1;
1131       return;
1132    case MESA_FORMAT_LA_SINT32:
1133       *datatype = GL_INT;
1134       *comps = 2;
1135       return;
1136
1137    case MESA_FORMAT_R_SINT8:
1138       *datatype = GL_BYTE;
1139       *comps = 1;
1140       return;
1141    case MESA_FORMAT_RG_SINT8:
1142       *datatype = GL_BYTE;
1143       *comps = 2;
1144       return;
1145    case MESA_FORMAT_RGB_SINT8:
1146       *datatype = GL_BYTE;
1147       *comps = 3;
1148       return;
1149    case MESA_FORMAT_RGBA_SINT8:
1150       *datatype = GL_BYTE;
1151       *comps = 4;
1152       return;
1153    case MESA_FORMAT_R_SINT16:
1154       *datatype = GL_SHORT;
1155       *comps = 1;
1156       return;
1157    case MESA_FORMAT_RG_SINT16:
1158       *datatype = GL_SHORT;
1159       *comps = 2;
1160       return;
1161    case MESA_FORMAT_RGB_SINT16:
1162       *datatype = GL_SHORT;
1163       *comps = 3;
1164       return;
1165    case MESA_FORMAT_RGBA_SINT16:
1166       *datatype = GL_SHORT;
1167       *comps = 4;
1168       return;
1169    case MESA_FORMAT_R_SINT32:
1170       *datatype = GL_INT;
1171       *comps = 1;
1172       return;
1173    case MESA_FORMAT_RG_SINT32:
1174       *datatype = GL_INT;
1175       *comps = 2;
1176       return;
1177    case MESA_FORMAT_RGB_SINT32:
1178       *datatype = GL_INT;
1179       *comps = 3;
1180       return;
1181    case MESA_FORMAT_RGBA_SINT32:
1182       *datatype = GL_INT;
1183       *comps = 4;
1184       return;
1185
1186    /**
1187     * \name Non-normalized unsigned integer formats.
1188     */
1189    case MESA_FORMAT_R_UINT8:
1190       *datatype = GL_UNSIGNED_BYTE;
1191       *comps = 1;
1192       return;
1193    case MESA_FORMAT_RG_UINT8:
1194       *datatype = GL_UNSIGNED_BYTE;
1195       *comps = 2;
1196       return;
1197    case MESA_FORMAT_RGB_UINT8:
1198       *datatype = GL_UNSIGNED_BYTE;
1199       *comps = 3;
1200       return;
1201    case MESA_FORMAT_RGBA_UINT8:
1202       *datatype = GL_UNSIGNED_BYTE;
1203       *comps = 4;
1204       return;
1205    case MESA_FORMAT_R_UINT16:
1206       *datatype = GL_UNSIGNED_SHORT;
1207       *comps = 1;
1208       return;
1209    case MESA_FORMAT_RG_UINT16:
1210       *datatype = GL_UNSIGNED_SHORT;
1211       *comps = 2;
1212       return;
1213    case MESA_FORMAT_RGB_UINT16:
1214       *datatype = GL_UNSIGNED_SHORT;
1215       *comps = 3;
1216       return;
1217    case MESA_FORMAT_RGBA_UINT16:
1218       *datatype = GL_UNSIGNED_SHORT;
1219       *comps = 4;
1220       return;
1221    case MESA_FORMAT_R_UINT32:
1222       *datatype = GL_UNSIGNED_INT;
1223       *comps = 1;
1224       return;
1225    case MESA_FORMAT_RG_UINT32:
1226       *datatype = GL_UNSIGNED_INT;
1227       *comps = 2;
1228       return;
1229    case MESA_FORMAT_RGB_UINT32:
1230       *datatype = GL_UNSIGNED_INT;
1231       *comps = 3;
1232       return;
1233    case MESA_FORMAT_RGBA_UINT32:
1234       *datatype = GL_UNSIGNED_INT;
1235       *comps = 4;
1236       return;
1237
1238    case MESA_FORMAT_R9G9B9E5_FLOAT:
1239       *datatype = GL_UNSIGNED_INT_5_9_9_9_REV;
1240       *comps = 3;
1241       return;
1242
1243    case MESA_FORMAT_R11G11B10_FLOAT:
1244       *datatype = GL_UNSIGNED_INT_10F_11F_11F_REV;
1245       *comps = 3;
1246       return;
1247
1248    case MESA_FORMAT_B10G10R10A2_UINT:
1249    case MESA_FORMAT_R10G10B10A2_UINT:
1250       *datatype = GL_UNSIGNED_INT_2_10_10_10_REV;
1251       *comps = 4;
1252       return;
1253
1254    case MESA_FORMAT_R8G8B8X8_SRGB:
1255    case MESA_FORMAT_X8B8G8R8_SRGB:
1256    case MESA_FORMAT_RGBX_UINT8:
1257       *datatype = GL_UNSIGNED_BYTE;
1258       *comps = 4;
1259       return;
1260
1261    case MESA_FORMAT_R8G8B8X8_SNORM:
1262    case MESA_FORMAT_RGBX_SINT8:
1263       *datatype = GL_BYTE;
1264       *comps = 4;
1265       return;
1266
1267    case MESA_FORMAT_B10G10R10X2_UNORM:
1268       *datatype = GL_UNSIGNED_INT_2_10_10_10_REV;
1269       *comps = 4;
1270       return;
1271
1272    case MESA_FORMAT_RGBX_UNORM16:
1273    case MESA_FORMAT_RGBX_UINT16:
1274       *datatype = GL_UNSIGNED_SHORT;
1275       *comps = 4;
1276       return;
1277
1278    case MESA_FORMAT_RGBX_SNORM16:
1279    case MESA_FORMAT_RGBX_SINT16:
1280       *datatype = GL_SHORT;
1281       *comps = 4;
1282       return;
1283
1284    case MESA_FORMAT_RGBX_FLOAT16:
1285       *datatype = GL_HALF_FLOAT;
1286       *comps = 4;
1287       return;
1288
1289    case MESA_FORMAT_RGBX_FLOAT32:
1290       *datatype = GL_FLOAT;
1291       *comps = 4;
1292       return;
1293
1294    case MESA_FORMAT_RGBX_UINT32:
1295       *datatype = GL_UNSIGNED_INT;
1296       *comps = 4;
1297       return;
1298
1299    case MESA_FORMAT_RGBX_SINT32:
1300       *datatype = GL_INT;
1301       *comps = 4;
1302       return;
1303
1304    case MESA_FORMAT_R10G10B10A2_UNORM:
1305       *datatype = GL_UNSIGNED_INT_2_10_10_10_REV;
1306       *comps = 4;
1307       return;
1308
1309    case MESA_FORMAT_G8R8_SNORM:
1310       *datatype = GL_BYTE;
1311       *comps = 2;
1312       return;
1313
1314    case MESA_FORMAT_G16R16_SNORM:
1315       *datatype = GL_SHORT;
1316       *comps = 2;
1317       return;
1318
1319    case MESA_FORMAT_B8G8R8X8_SRGB:
1320    case MESA_FORMAT_X8R8G8B8_SRGB:
1321       *datatype = GL_UNSIGNED_BYTE;
1322       *comps = 4;
1323       return;
1324
1325    case MESA_FORMAT_COUNT:
1326       assert(0);
1327       return;
1328
1329    case MESA_FORMAT_NONE:
1330    /* For debug builds, warn if any formats are not handled */
1331 #ifdef DEBUG
1332    default:
1333 #endif
1334       _mesa_problem(NULL, "bad format %s in _mesa_format_to_type_and_comps",
1335                     _mesa_get_format_name(format));
1336       *datatype = 0;
1337       *comps = 1;
1338    }
1339 }
1340
1341 /**
1342  * Check if a mesa_format exactly matches a GL format/type combination
1343  * such that we can use memcpy() from one to the other.
1344  * \param mesa_format  a MESA_FORMAT_x value
1345  * \param format  the user-specified image format
1346  * \param type  the user-specified image datatype
1347  * \param swapBytes  typically the current pixel pack/unpack byteswap state
1348  * \return GL_TRUE if the formats match, GL_FALSE otherwise.
1349  */
1350 GLboolean
1351 _mesa_format_matches_format_and_type(mesa_format mesa_format,
1352                                      GLenum format, GLenum type,
1353                                      GLboolean swapBytes)
1354 {
1355    const GLboolean littleEndian = _mesa_little_endian();
1356
1357    /* Note: When reading a GL format/type combination, the format lists channel
1358     * assignments from most significant channel in the type to least
1359     * significant.  A type with _REV indicates that the assignments are
1360     * swapped, so they are listed from least significant to most significant.
1361     *
1362     * For sanity, please keep this switch statement ordered the same as the
1363     * enums in formats.h.
1364     */
1365
1366    switch (mesa_format) {
1367
1368    case MESA_FORMAT_NONE:
1369    case MESA_FORMAT_COUNT:
1370       return GL_FALSE;
1371
1372    case MESA_FORMAT_A8B8G8R8_UNORM:
1373    case MESA_FORMAT_A8B8G8R8_SRGB:
1374       if (format == GL_RGBA && type == GL_UNSIGNED_INT_8_8_8_8 && !swapBytes)
1375          return GL_TRUE;
1376
1377       if (format == GL_RGBA && type == GL_UNSIGNED_INT_8_8_8_8_REV && swapBytes)
1378          return GL_TRUE;
1379
1380       if (format == GL_RGBA && type == GL_UNSIGNED_BYTE && !littleEndian)
1381          return GL_TRUE;
1382
1383       if (format == GL_ABGR_EXT && type == GL_UNSIGNED_INT_8_8_8_8_REV
1384           && !swapBytes)
1385          return GL_TRUE;
1386
1387       if (format == GL_ABGR_EXT && type == GL_UNSIGNED_INT_8_8_8_8
1388           && swapBytes)
1389          return GL_TRUE;
1390
1391       if (format == GL_ABGR_EXT && type == GL_UNSIGNED_BYTE && littleEndian)
1392          return GL_TRUE;
1393
1394       return GL_FALSE;
1395
1396    case MESA_FORMAT_R8G8B8A8_UNORM:
1397    case MESA_FORMAT_R8G8B8A8_SRGB:
1398       if (format == GL_RGBA && type == GL_UNSIGNED_INT_8_8_8_8_REV &&
1399           !swapBytes)
1400          return GL_TRUE;
1401
1402       if (format == GL_RGBA && type == GL_UNSIGNED_INT_8_8_8_8 && swapBytes)
1403          return GL_TRUE;
1404
1405       if (format == GL_RGBA && type == GL_UNSIGNED_BYTE && littleEndian)
1406          return GL_TRUE;
1407
1408       if (format == GL_ABGR_EXT && type == GL_UNSIGNED_INT_8_8_8_8 &&
1409           !swapBytes)
1410          return GL_TRUE;
1411
1412       if (format == GL_ABGR_EXT && type == GL_UNSIGNED_INT_8_8_8_8_REV &&
1413           swapBytes)
1414          return GL_TRUE;
1415
1416       if (format == GL_ABGR_EXT && type == GL_UNSIGNED_BYTE && !littleEndian)
1417          return GL_TRUE;
1418
1419       return GL_FALSE;
1420
1421    case MESA_FORMAT_B8G8R8A8_UNORM:
1422    case MESA_FORMAT_B8G8R8A8_SRGB:
1423       if (format == GL_BGRA && type == GL_UNSIGNED_INT_8_8_8_8_REV &&
1424           !swapBytes)
1425          return GL_TRUE;
1426
1427       if (format == GL_BGRA && type == GL_UNSIGNED_INT_8_8_8_8 && 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_A8R8G8B8_UNORM:
1436    case MESA_FORMAT_A8R8G8B8_SRGB:
1437       if (format == GL_BGRA && type == GL_UNSIGNED_INT_8_8_8_8 && !swapBytes)
1438          return GL_TRUE;
1439
1440       if (format == GL_BGRA && type == GL_UNSIGNED_INT_8_8_8_8_REV &&
1441           swapBytes)
1442          return GL_TRUE;
1443
1444       if (format == GL_BGRA && type == GL_UNSIGNED_BYTE && !littleEndian)
1445          return GL_TRUE;
1446
1447       return GL_FALSE;
1448
1449    case MESA_FORMAT_X8B8G8R8_UNORM:
1450    case MESA_FORMAT_R8G8B8X8_UNORM:
1451       return GL_FALSE;
1452
1453    case MESA_FORMAT_B8G8R8X8_UNORM:
1454    case MESA_FORMAT_X8R8G8B8_UNORM:
1455       return GL_FALSE;
1456
1457    case MESA_FORMAT_BGR_UNORM8:
1458    case MESA_FORMAT_BGR_SRGB8:
1459       return format == GL_BGR && type == GL_UNSIGNED_BYTE && littleEndian;
1460
1461    case MESA_FORMAT_RGB_UNORM8:
1462       return format == GL_RGB && type == GL_UNSIGNED_BYTE && littleEndian;
1463
1464    case MESA_FORMAT_B5G6R5_UNORM:
1465       return ((format == GL_RGB && type == GL_UNSIGNED_SHORT_5_6_5) ||
1466               (format == GL_BGR && type == GL_UNSIGNED_SHORT_5_6_5_REV)) &&
1467               !swapBytes;
1468
1469    case MESA_FORMAT_R5G6B5_UNORM:
1470       return ((format == GL_BGR && type == GL_UNSIGNED_SHORT_5_6_5) ||
1471               (format == GL_RGB && type == GL_UNSIGNED_SHORT_5_6_5_REV)) &&
1472               !swapBytes;
1473
1474    case MESA_FORMAT_B4G4R4A4_UNORM:
1475       return format == GL_BGRA && type == GL_UNSIGNED_SHORT_4_4_4_4_REV &&
1476          !swapBytes;
1477
1478    case MESA_FORMAT_A4R4G4B4_UNORM:
1479       return GL_FALSE;
1480
1481    case MESA_FORMAT_A1B5G5R5_UNORM:
1482       return format == GL_RGBA && type == GL_UNSIGNED_SHORT_5_5_5_1 &&
1483          !swapBytes;
1484
1485    case MESA_FORMAT_B5G5R5A1_UNORM:
1486       return format == GL_BGRA && type == GL_UNSIGNED_SHORT_1_5_5_5_REV &&
1487          !swapBytes;
1488
1489    case MESA_FORMAT_A1R5G5B5_UNORM:
1490       return GL_FALSE;
1491
1492    case MESA_FORMAT_L4A4_UNORM:
1493       return GL_FALSE;
1494    case MESA_FORMAT_L8A8_UNORM:
1495    case MESA_FORMAT_L8A8_SRGB:
1496       return format == GL_LUMINANCE_ALPHA && type == GL_UNSIGNED_BYTE && littleEndian;
1497    case MESA_FORMAT_A8L8_UNORM:
1498    case MESA_FORMAT_A8L8_SRGB:
1499       return GL_FALSE;
1500
1501    case MESA_FORMAT_L16A16_UNORM:
1502       return format == GL_LUMINANCE_ALPHA && type == GL_UNSIGNED_SHORT && littleEndian && !swapBytes;
1503    case MESA_FORMAT_A16L16_UNORM:
1504       return GL_FALSE;
1505
1506    case MESA_FORMAT_B2G3R3_UNORM:
1507       return format == GL_RGB && type == GL_UNSIGNED_BYTE_3_3_2;
1508
1509    case MESA_FORMAT_A_UNORM8:
1510       return format == GL_ALPHA && type == GL_UNSIGNED_BYTE;
1511    case MESA_FORMAT_A_UNORM16:
1512       return format == GL_ALPHA && type == GL_UNSIGNED_SHORT && !swapBytes;
1513    case MESA_FORMAT_L_UNORM8:
1514    case MESA_FORMAT_L_SRGB8:
1515       return format == GL_LUMINANCE && type == GL_UNSIGNED_BYTE;
1516    case MESA_FORMAT_L_UNORM16:
1517       return format == GL_LUMINANCE && type == GL_UNSIGNED_SHORT && !swapBytes;
1518    case MESA_FORMAT_I_UNORM8:
1519       return format == GL_RED && type == GL_UNSIGNED_BYTE;
1520    case MESA_FORMAT_I_UNORM16:
1521       return format == GL_RED && type == GL_UNSIGNED_SHORT && !swapBytes;
1522
1523    case MESA_FORMAT_YCBCR:
1524       return format == GL_YCBCR_MESA &&
1525              ((type == GL_UNSIGNED_SHORT_8_8_MESA && littleEndian != swapBytes) ||
1526               (type == GL_UNSIGNED_SHORT_8_8_REV_MESA && littleEndian == swapBytes));
1527    case MESA_FORMAT_YCBCR_REV:
1528       return format == GL_YCBCR_MESA &&
1529              ((type == GL_UNSIGNED_SHORT_8_8_MESA && littleEndian == swapBytes) ||
1530               (type == GL_UNSIGNED_SHORT_8_8_REV_MESA && littleEndian != swapBytes));
1531
1532    case MESA_FORMAT_R_UNORM8:
1533       return format == GL_RED && type == GL_UNSIGNED_BYTE;
1534    case MESA_FORMAT_R8G8_UNORM:
1535       return format == GL_RG && type == GL_UNSIGNED_BYTE && littleEndian;
1536    case MESA_FORMAT_G8R8_UNORM:
1537       return GL_FALSE;
1538
1539    case MESA_FORMAT_R_UNORM16:
1540       return format == GL_RED && type == GL_UNSIGNED_SHORT &&
1541          !swapBytes;
1542    case MESA_FORMAT_R16G16_UNORM:
1543       return format == GL_RG && type == GL_UNSIGNED_SHORT && littleEndian &&
1544          !swapBytes;
1545    case MESA_FORMAT_G16R16_UNORM:
1546       return GL_FALSE;
1547
1548    case MESA_FORMAT_B10G10R10A2_UNORM:
1549       return format == GL_BGRA && type == GL_UNSIGNED_INT_2_10_10_10_REV &&
1550          !swapBytes;
1551
1552    case MESA_FORMAT_S8_UINT_Z24_UNORM:
1553       return format == GL_DEPTH_STENCIL && type == GL_UNSIGNED_INT_24_8 &&
1554          !swapBytes;
1555    case MESA_FORMAT_X8_UINT_Z24_UNORM:
1556    case MESA_FORMAT_Z24_UNORM_S8_UINT:
1557       return GL_FALSE;
1558
1559    case MESA_FORMAT_Z_UNORM16:
1560       return format == GL_DEPTH_COMPONENT && type == GL_UNSIGNED_SHORT &&
1561          !swapBytes;
1562
1563    case MESA_FORMAT_Z24_UNORM_X8_UINT:
1564       return GL_FALSE;
1565
1566    case MESA_FORMAT_Z_UNORM32:
1567       return format == GL_DEPTH_COMPONENT && type == GL_UNSIGNED_INT &&
1568          !swapBytes;
1569
1570    case MESA_FORMAT_S_UINT8:
1571       return format == GL_STENCIL_INDEX && type == GL_UNSIGNED_BYTE;
1572
1573    case MESA_FORMAT_SRGB_DXT1:
1574    case MESA_FORMAT_SRGBA_DXT1:
1575    case MESA_FORMAT_SRGBA_DXT3:
1576    case MESA_FORMAT_SRGBA_DXT5:
1577       return GL_FALSE;
1578
1579    case MESA_FORMAT_RGB_FXT1:
1580    case MESA_FORMAT_RGBA_FXT1:
1581    case MESA_FORMAT_RGB_DXT1:
1582    case MESA_FORMAT_RGBA_DXT1:
1583    case MESA_FORMAT_RGBA_DXT3:
1584    case MESA_FORMAT_RGBA_DXT5:
1585       return GL_FALSE;
1586
1587    case MESA_FORMAT_BPTC_RGBA_UNORM:
1588    case MESA_FORMAT_BPTC_SRGB_ALPHA_UNORM:
1589    case MESA_FORMAT_BPTC_RGB_SIGNED_FLOAT:
1590    case MESA_FORMAT_BPTC_RGB_UNSIGNED_FLOAT:
1591       return GL_FALSE;
1592
1593    case MESA_FORMAT_RGBA_FLOAT32:
1594       return format == GL_RGBA && type == GL_FLOAT && !swapBytes;
1595    case MESA_FORMAT_RGBA_FLOAT16:
1596       return format == GL_RGBA && type == GL_HALF_FLOAT && !swapBytes;
1597
1598    case MESA_FORMAT_RGB_FLOAT32:
1599       return format == GL_RGB && type == GL_FLOAT && !swapBytes;
1600    case MESA_FORMAT_RGB_FLOAT16:
1601       return format == GL_RGB && type == GL_HALF_FLOAT && !swapBytes;
1602
1603    case MESA_FORMAT_A_FLOAT32:
1604       return format == GL_ALPHA && type == GL_FLOAT && !swapBytes;
1605    case MESA_FORMAT_A_FLOAT16:
1606       return format == GL_ALPHA && type == GL_HALF_FLOAT && !swapBytes;
1607
1608    case MESA_FORMAT_L_FLOAT32:
1609       return format == GL_LUMINANCE && type == GL_FLOAT && !swapBytes;
1610    case MESA_FORMAT_L_FLOAT16:
1611       return format == GL_LUMINANCE && type == GL_HALF_FLOAT && !swapBytes;
1612
1613    case MESA_FORMAT_LA_FLOAT32:
1614       return format == GL_LUMINANCE_ALPHA && type == GL_FLOAT && !swapBytes;
1615    case MESA_FORMAT_LA_FLOAT16:
1616       return format == GL_LUMINANCE_ALPHA && type == GL_HALF_FLOAT && !swapBytes;
1617
1618    case MESA_FORMAT_I_FLOAT32:
1619       return format == GL_RED && type == GL_FLOAT && !swapBytes;
1620    case MESA_FORMAT_I_FLOAT16:
1621       return format == GL_RED && type == GL_HALF_FLOAT && !swapBytes;
1622
1623    case MESA_FORMAT_R_FLOAT32:
1624       return format == GL_RED && type == GL_FLOAT && !swapBytes;
1625    case MESA_FORMAT_R_FLOAT16:
1626       return format == GL_RED && type == GL_HALF_FLOAT && !swapBytes;
1627
1628    case MESA_FORMAT_RG_FLOAT32:
1629       return format == GL_RG && type == GL_FLOAT && !swapBytes;
1630    case MESA_FORMAT_RG_FLOAT16:
1631       return format == GL_RG && type == GL_HALF_FLOAT && !swapBytes;
1632
1633    case MESA_FORMAT_A_UINT8:
1634       return format == GL_ALPHA_INTEGER && type == GL_UNSIGNED_BYTE;
1635    case MESA_FORMAT_A_UINT16:
1636       return format == GL_ALPHA_INTEGER && type == GL_UNSIGNED_SHORT &&
1637              !swapBytes;
1638    case MESA_FORMAT_A_UINT32:
1639       return format == GL_ALPHA_INTEGER && type == GL_UNSIGNED_INT &&
1640              !swapBytes;
1641    case MESA_FORMAT_A_SINT8:
1642       return format == GL_ALPHA_INTEGER && type == GL_BYTE;
1643    case MESA_FORMAT_A_SINT16:
1644       return format == GL_ALPHA_INTEGER && type == GL_SHORT && !swapBytes;
1645    case MESA_FORMAT_A_SINT32:
1646       return format == GL_ALPHA_INTEGER && type == GL_INT && !swapBytes;
1647
1648    case MESA_FORMAT_I_UINT8:
1649       return format == GL_RED_INTEGER && type == GL_UNSIGNED_BYTE;
1650    case MESA_FORMAT_I_UINT16:
1651       return format == GL_RED_INTEGER && type == GL_UNSIGNED_SHORT && !swapBytes;
1652    case MESA_FORMAT_I_UINT32:
1653       return format == GL_RED_INTEGER && type == GL_UNSIGNED_INT && !swapBytes;
1654    case MESA_FORMAT_I_SINT8:
1655       return format == GL_RED_INTEGER && type == GL_BYTE;
1656    case MESA_FORMAT_I_SINT16:
1657       return format == GL_RED_INTEGER && type == GL_SHORT && !swapBytes;
1658    case MESA_FORMAT_I_SINT32:
1659       return format == GL_RED_INTEGER && type == GL_INT && !swapBytes;
1660
1661    case MESA_FORMAT_L_UINT8:
1662       return format == GL_LUMINANCE_INTEGER_EXT && type == GL_UNSIGNED_BYTE;
1663    case MESA_FORMAT_L_UINT16:
1664       return format == GL_LUMINANCE_INTEGER_EXT && type == GL_UNSIGNED_SHORT &&
1665              !swapBytes;
1666    case MESA_FORMAT_L_UINT32:
1667       return format == GL_LUMINANCE_INTEGER_EXT && type == GL_UNSIGNED_INT &&
1668              !swapBytes;
1669    case MESA_FORMAT_L_SINT8:
1670       return format == GL_LUMINANCE_INTEGER_EXT && type == GL_BYTE;
1671    case MESA_FORMAT_L_SINT16:
1672       return format == GL_LUMINANCE_INTEGER_EXT && type == GL_SHORT &&
1673              !swapBytes;
1674    case MESA_FORMAT_L_SINT32:
1675       return format == GL_LUMINANCE_INTEGER_EXT && type == GL_INT && !swapBytes;
1676
1677    case MESA_FORMAT_LA_UINT8:
1678       return format == GL_LUMINANCE_ALPHA_INTEGER_EXT &&
1679              type == GL_UNSIGNED_BYTE && !swapBytes;
1680    case MESA_FORMAT_LA_UINT16:
1681       return format == GL_LUMINANCE_ALPHA_INTEGER_EXT &&
1682              type == GL_UNSIGNED_SHORT && !swapBytes;
1683    case MESA_FORMAT_LA_UINT32:
1684       return format == GL_LUMINANCE_ALPHA_INTEGER_EXT &&
1685              type == GL_UNSIGNED_INT && !swapBytes;
1686    case MESA_FORMAT_LA_SINT8:
1687       return format == GL_LUMINANCE_ALPHA_INTEGER_EXT && type == GL_BYTE &&
1688              !swapBytes;
1689    case MESA_FORMAT_LA_SINT16:
1690       return format == GL_LUMINANCE_ALPHA_INTEGER_EXT && type == GL_SHORT &&
1691              !swapBytes;
1692    case MESA_FORMAT_LA_SINT32:
1693       return format == GL_LUMINANCE_ALPHA_INTEGER_EXT && type == GL_INT &&
1694              !swapBytes;
1695
1696    case MESA_FORMAT_R_SINT8:
1697       return format == GL_RED_INTEGER && type == GL_BYTE;
1698    case MESA_FORMAT_RG_SINT8:
1699       return format == GL_RG_INTEGER && type == GL_BYTE && !swapBytes;
1700    case MESA_FORMAT_RGB_SINT8:
1701       return format == GL_RGB_INTEGER && type == GL_BYTE && !swapBytes;
1702    case MESA_FORMAT_RGBA_SINT8:
1703       return format == GL_RGBA_INTEGER && type == GL_BYTE && !swapBytes;
1704    case MESA_FORMAT_R_SINT16:
1705       return format == GL_RED_INTEGER && type == GL_SHORT && !swapBytes;
1706    case MESA_FORMAT_RG_SINT16:
1707       return format == GL_RG_INTEGER && type == GL_SHORT && !swapBytes;
1708    case MESA_FORMAT_RGB_SINT16:
1709       return format == GL_RGB_INTEGER && type == GL_SHORT && !swapBytes;
1710    case MESA_FORMAT_RGBA_SINT16:
1711       return format == GL_RGBA_INTEGER && type == GL_SHORT && !swapBytes;
1712    case MESA_FORMAT_R_SINT32:
1713       return format == GL_RED_INTEGER && type == GL_INT && !swapBytes;
1714    case MESA_FORMAT_RG_SINT32:
1715       return format == GL_RG_INTEGER && type == GL_INT && !swapBytes;
1716    case MESA_FORMAT_RGB_SINT32:
1717       return format == GL_RGB_INTEGER && type == GL_INT && !swapBytes;
1718    case MESA_FORMAT_RGBA_SINT32:
1719       return format == GL_RGBA_INTEGER && type == GL_INT && !swapBytes;
1720
1721    case MESA_FORMAT_R_UINT8:
1722       return format == GL_RED_INTEGER && type == GL_UNSIGNED_BYTE;
1723    case MESA_FORMAT_RG_UINT8:
1724       return format == GL_RG_INTEGER && type == GL_UNSIGNED_BYTE && !swapBytes;
1725    case MESA_FORMAT_RGB_UINT8:
1726       return format == GL_RGB_INTEGER && type == GL_UNSIGNED_BYTE && !swapBytes;
1727    case MESA_FORMAT_RGBA_UINT8:
1728       return format == GL_RGBA_INTEGER && type == GL_UNSIGNED_BYTE &&
1729              !swapBytes;
1730    case MESA_FORMAT_R_UINT16:
1731       return format == GL_RED_INTEGER && type == GL_UNSIGNED_SHORT &&
1732              !swapBytes;
1733    case MESA_FORMAT_RG_UINT16:
1734       return format == GL_RG_INTEGER && type == GL_UNSIGNED_SHORT && !swapBytes;
1735    case MESA_FORMAT_RGB_UINT16:
1736       return format == GL_RGB_INTEGER && type == GL_UNSIGNED_SHORT &&
1737              !swapBytes;
1738    case MESA_FORMAT_RGBA_UINT16:
1739       return format == GL_RGBA_INTEGER && type == GL_UNSIGNED_SHORT &&
1740              !swapBytes;
1741    case MESA_FORMAT_R_UINT32:
1742       return format == GL_RED_INTEGER && type == GL_UNSIGNED_INT && !swapBytes;
1743    case MESA_FORMAT_RG_UINT32:
1744       return format == GL_RG_INTEGER && type == GL_UNSIGNED_INT && !swapBytes;
1745    case MESA_FORMAT_RGB_UINT32:
1746       return format == GL_RGB_INTEGER && type == GL_UNSIGNED_INT && !swapBytes;
1747    case MESA_FORMAT_RGBA_UINT32:
1748       return format == GL_RGBA_INTEGER && type == GL_UNSIGNED_INT && !swapBytes;
1749
1750    case MESA_FORMAT_R_SNORM8:
1751       return format == GL_RED && type == GL_BYTE;
1752    case MESA_FORMAT_R8G8_SNORM:
1753       return format == GL_RG && type == GL_BYTE && littleEndian &&
1754              !swapBytes;
1755    case MESA_FORMAT_X8B8G8R8_SNORM:
1756       return GL_FALSE;
1757
1758    case MESA_FORMAT_A8B8G8R8_SNORM:
1759       if (format == GL_RGBA && type == GL_BYTE && !littleEndian)
1760          return GL_TRUE;
1761
1762       if (format == GL_ABGR_EXT && type == GL_BYTE && littleEndian)
1763          return GL_TRUE;
1764
1765       return GL_FALSE;
1766
1767    case MESA_FORMAT_R8G8B8A8_SNORM:
1768       if (format == GL_RGBA && type == GL_BYTE && littleEndian)
1769          return GL_TRUE;
1770
1771       if (format == GL_ABGR_EXT && type == GL_BYTE && !littleEndian)
1772          return GL_TRUE;
1773
1774       return GL_FALSE;
1775
1776    case MESA_FORMAT_R_SNORM16:
1777       return format == GL_RED && type == GL_SHORT &&
1778              !swapBytes;
1779    case MESA_FORMAT_R16G16_SNORM:
1780       return format == GL_RG && type == GL_SHORT && littleEndian && !swapBytes;
1781    case MESA_FORMAT_RGB_SNORM16:
1782       return format == GL_RGB && type == GL_SHORT && !swapBytes;
1783    case MESA_FORMAT_RGBA_SNORM16:
1784       return format == GL_RGBA && type == GL_SHORT && !swapBytes;
1785    case MESA_FORMAT_RGBA_UNORM16:
1786       return format == GL_RGBA && type == GL_UNSIGNED_SHORT &&
1787              !swapBytes;
1788
1789    case MESA_FORMAT_R_RGTC1_UNORM:
1790    case MESA_FORMAT_R_RGTC1_SNORM:
1791    case MESA_FORMAT_RG_RGTC2_UNORM:
1792    case MESA_FORMAT_RG_RGTC2_SNORM:
1793       return GL_FALSE;
1794
1795    case MESA_FORMAT_L_LATC1_UNORM:
1796    case MESA_FORMAT_L_LATC1_SNORM:
1797    case MESA_FORMAT_LA_LATC2_UNORM:
1798    case MESA_FORMAT_LA_LATC2_SNORM:
1799       return GL_FALSE;
1800
1801    case MESA_FORMAT_ETC1_RGB8:
1802    case MESA_FORMAT_ETC2_RGB8:
1803    case MESA_FORMAT_ETC2_SRGB8:
1804    case MESA_FORMAT_ETC2_RGBA8_EAC:
1805    case MESA_FORMAT_ETC2_SRGB8_ALPHA8_EAC:
1806    case MESA_FORMAT_ETC2_R11_EAC:
1807    case MESA_FORMAT_ETC2_RG11_EAC:
1808    case MESA_FORMAT_ETC2_SIGNED_R11_EAC:
1809    case MESA_FORMAT_ETC2_SIGNED_RG11_EAC:
1810    case MESA_FORMAT_ETC2_RGB8_PUNCHTHROUGH_ALPHA1:
1811    case MESA_FORMAT_ETC2_SRGB8_PUNCHTHROUGH_ALPHA1:
1812       return GL_FALSE;
1813
1814    case MESA_FORMAT_A_SNORM8:
1815       return format == GL_ALPHA && type == GL_BYTE;
1816    case MESA_FORMAT_L_SNORM8:
1817       return format == GL_LUMINANCE && type == GL_BYTE;
1818    case MESA_FORMAT_L8A8_SNORM:
1819       return format == GL_LUMINANCE_ALPHA && type == GL_BYTE &&
1820              littleEndian && !swapBytes;
1821    case MESA_FORMAT_A8L8_SNORM:
1822       return format == GL_LUMINANCE_ALPHA && type == GL_BYTE &&
1823              !littleEndian && !swapBytes;
1824    case MESA_FORMAT_I_SNORM8:
1825       return format == GL_RED && type == GL_BYTE;
1826    case MESA_FORMAT_A_SNORM16:
1827       return format == GL_ALPHA && type == GL_SHORT && !swapBytes;
1828    case MESA_FORMAT_L_SNORM16:
1829       return format == GL_LUMINANCE && type == GL_SHORT && !swapBytes;
1830    case MESA_FORMAT_LA_SNORM16:
1831       return format == GL_LUMINANCE_ALPHA && type == GL_SHORT &&
1832              littleEndian && !swapBytes;
1833    case MESA_FORMAT_I_SNORM16:
1834       return format == GL_RED && type == GL_SHORT && littleEndian &&
1835              !swapBytes;
1836
1837    case MESA_FORMAT_B10G10R10A2_UINT:
1838       return (format == GL_BGRA_INTEGER_EXT &&
1839               type == GL_UNSIGNED_INT_2_10_10_10_REV &&
1840               !swapBytes);
1841
1842    case MESA_FORMAT_R10G10B10A2_UINT:
1843       return (format == GL_RGBA_INTEGER_EXT &&
1844               type == GL_UNSIGNED_INT_2_10_10_10_REV &&
1845               !swapBytes);
1846
1847    case MESA_FORMAT_R9G9B9E5_FLOAT:
1848       return format == GL_RGB && type == GL_UNSIGNED_INT_5_9_9_9_REV &&
1849          !swapBytes;
1850
1851    case MESA_FORMAT_R11G11B10_FLOAT:
1852       return format == GL_RGB && type == GL_UNSIGNED_INT_10F_11F_11F_REV &&
1853          !swapBytes;
1854
1855    case MESA_FORMAT_Z_FLOAT32:
1856       return format == GL_DEPTH_COMPONENT && type == GL_FLOAT && !swapBytes;
1857
1858    case MESA_FORMAT_Z32_FLOAT_S8X24_UINT:
1859       return format == GL_DEPTH_STENCIL &&
1860              type == GL_FLOAT_32_UNSIGNED_INT_24_8_REV && !swapBytes;
1861
1862    case MESA_FORMAT_B4G4R4X4_UNORM:
1863    case MESA_FORMAT_B5G5R5X1_UNORM:
1864    case MESA_FORMAT_R8G8B8X8_SNORM:
1865    case MESA_FORMAT_R8G8B8X8_SRGB:
1866    case MESA_FORMAT_X8B8G8R8_SRGB:
1867    case MESA_FORMAT_RGBX_UINT8:
1868    case MESA_FORMAT_RGBX_SINT8:
1869    case MESA_FORMAT_B10G10R10X2_UNORM:
1870    case MESA_FORMAT_RGBX_UNORM16:
1871    case MESA_FORMAT_RGBX_SNORM16:
1872    case MESA_FORMAT_RGBX_FLOAT16:
1873    case MESA_FORMAT_RGBX_UINT16:
1874    case MESA_FORMAT_RGBX_SINT16:
1875    case MESA_FORMAT_RGBX_FLOAT32:
1876    case MESA_FORMAT_RGBX_UINT32:
1877    case MESA_FORMAT_RGBX_SINT32:
1878       return GL_FALSE;
1879
1880    case MESA_FORMAT_R10G10B10A2_UNORM:
1881       return format == GL_RGBA && type == GL_UNSIGNED_INT_2_10_10_10_REV &&
1882          !swapBytes;
1883
1884    case MESA_FORMAT_G8R8_SNORM:
1885       return format == GL_RG && type == GL_BYTE && !littleEndian &&
1886          !swapBytes;
1887
1888    case MESA_FORMAT_G16R16_SNORM:
1889       return format == GL_RG && type == GL_SHORT && !littleEndian &&
1890          !swapBytes;
1891
1892    case MESA_FORMAT_B8G8R8X8_SRGB:
1893    case MESA_FORMAT_X8R8G8B8_SRGB:
1894       return GL_FALSE;
1895    }
1896
1897    return GL_FALSE;
1898 }
1899