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