u_format.h revision 1ba3240b281fcbbf03372a6e2db68292cb8a8907
1/************************************************************************** 2 * 3 * Copyright 2009-2010 Vmware, Inc. 4 * All Rights Reserved. 5 * 6 * Permission is hereby granted, free of charge, to any person obtaining a 7 * copy of this software and associated documentation files (the 8 * "Software"), to deal in the Software without restriction, including 9 * without limitation the rights to use, copy, modify, merge, publish, 10 * distribute, sub license, and/or sell copies of the Software, and to 11 * permit persons to whom the Software is furnished to do so, subject to 12 * the following conditions: 13 * 14 * The above copyright notice and this permission notice (including the 15 * next paragraph) shall be included in all copies or substantial portions 16 * of the Software. 17 * 18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 19 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 20 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. 21 * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR 22 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, 23 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE 24 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 25 * 26 **************************************************************************/ 27 28 29#ifndef U_FORMAT_H 30#define U_FORMAT_H 31 32 33#include "pipe/p_format.h" 34#include "util/u_debug.h" 35 36#ifdef __cplusplus 37extern "C" { 38#endif 39 40 41/** 42 * Describe how to pack/unpack pixels into/from the prescribed format. 43 * 44 * XXX: This could be renamed to something like util_format_pack, or broke down 45 * in flags inside util_format_block that said exactly what we want. 46 */ 47enum util_format_layout { 48 /** 49 * Formats with util_format_block::width == util_format_block::height == 1 50 * that can be described as an ordinary data structure. 51 */ 52 UTIL_FORMAT_LAYOUT_PLAIN = 0, 53 54 /** 55 * Formats with sub-sampled channels. 56 * 57 * This is for formats like YV12 where there is less than one sample per 58 * pixel. 59 */ 60 UTIL_FORMAT_LAYOUT_SUBSAMPLED = 3, 61 62 /** 63 * S3 Texture Compression formats. 64 */ 65 UTIL_FORMAT_LAYOUT_S3TC = 4, 66 67 /** 68 * Red-Green Texture Compression formats. 69 */ 70 UTIL_FORMAT_LAYOUT_RGTC = 5, 71 72 /** 73 * Ericsson Texture Compression 74 */ 75 UTIL_FORMAT_LAYOUT_ETC = 6, 76 77 /** 78 * Everything else that doesn't fit in any of the above layouts. 79 */ 80 UTIL_FORMAT_LAYOUT_OTHER = 7 81}; 82 83 84struct util_format_block 85{ 86 /** Block width in pixels */ 87 unsigned width; 88 89 /** Block height in pixels */ 90 unsigned height; 91 92 /** Block size in bits */ 93 unsigned bits; 94}; 95 96 97enum util_format_type { 98 UTIL_FORMAT_TYPE_VOID = 0, 99 UTIL_FORMAT_TYPE_UNSIGNED = 1, 100 UTIL_FORMAT_TYPE_SIGNED = 2, 101 UTIL_FORMAT_TYPE_FIXED = 3, 102 UTIL_FORMAT_TYPE_FLOAT = 4 103}; 104 105 106enum util_format_swizzle { 107 UTIL_FORMAT_SWIZZLE_X = 0, 108 UTIL_FORMAT_SWIZZLE_Y = 1, 109 UTIL_FORMAT_SWIZZLE_Z = 2, 110 UTIL_FORMAT_SWIZZLE_W = 3, 111 UTIL_FORMAT_SWIZZLE_0 = 4, 112 UTIL_FORMAT_SWIZZLE_1 = 5, 113 UTIL_FORMAT_SWIZZLE_NONE = 6, 114 UTIL_FORMAT_SWIZZLE_MAX = 7 /**< Number of enums counter (must be last) */ 115}; 116 117 118enum util_format_colorspace { 119 UTIL_FORMAT_COLORSPACE_RGB = 0, 120 UTIL_FORMAT_COLORSPACE_SRGB = 1, 121 UTIL_FORMAT_COLORSPACE_YUV = 2, 122 UTIL_FORMAT_COLORSPACE_ZS = 3 123}; 124 125 126struct util_format_channel_description 127{ 128 unsigned type:5; /**< UTIL_FORMAT_TYPE_x */ 129 unsigned normalized:1; 130 unsigned pure_integer:1; 131 unsigned size:9; /**< bits per channel */ 132}; 133 134 135struct util_format_description 136{ 137 enum pipe_format format; 138 139 const char *name; 140 141 /** 142 * Short name, striped of the prefix, lower case. 143 */ 144 const char *short_name; 145 146 /** 147 * Pixel block dimensions. 148 */ 149 struct util_format_block block; 150 151 enum util_format_layout layout; 152 153 /** 154 * The number of channels. 155 */ 156 unsigned nr_channels:3; 157 158 /** 159 * Whether all channels have the same number of (whole) bytes. 160 */ 161 unsigned is_array:1; 162 163 /** 164 * Whether the pixel format can be described as a bitfield structure. 165 * 166 * In particular: 167 * - pixel depth must be 8, 16, or 32 bits; 168 * - all channels must be unsigned, signed, or void 169 */ 170 unsigned is_bitmask:1; 171 172 /** 173 * Whether channels have mixed types (ignoring UTIL_FORMAT_TYPE_VOID). 174 */ 175 unsigned is_mixed:1; 176 177 /** 178 * Input channel description. 179 * 180 * Only valid for UTIL_FORMAT_LAYOUT_PLAIN formats. 181 */ 182 struct util_format_channel_description channel[4]; 183 184 /** 185 * Output channel swizzle. 186 * 187 * The order is either: 188 * - RGBA 189 * - YUV(A) 190 * - ZS 191 * depending on the colorspace. 192 */ 193 unsigned char swizzle[4]; 194 195 /** 196 * Colorspace transformation. 197 */ 198 enum util_format_colorspace colorspace; 199 200 /** 201 * Unpack pixel blocks to R8G8B8A8_UNORM. 202 * Note: strides are in bytes. 203 * 204 * Only defined for non-depth-stencil formats. 205 */ 206 void 207 (*unpack_rgba_8unorm)(uint8_t *dst, unsigned dst_stride, 208 const uint8_t *src, unsigned src_stride, 209 unsigned width, unsigned height); 210 211 /** 212 * Pack pixel blocks from R8G8B8A8_UNORM. 213 * Note: strides are in bytes. 214 * 215 * Only defined for non-depth-stencil formats. 216 */ 217 void 218 (*pack_rgba_8unorm)(uint8_t *dst, unsigned dst_stride, 219 const uint8_t *src, unsigned src_stride, 220 unsigned width, unsigned height); 221 222 /** 223 * Fetch a single pixel (i, j) from a block. 224 * 225 * XXX: Only defined for a very few select formats. 226 */ 227 void 228 (*fetch_rgba_8unorm)(uint8_t *dst, 229 const uint8_t *src, 230 unsigned i, unsigned j); 231 232 /** 233 * Unpack pixel blocks to R32G32B32A32_FLOAT. 234 * Note: strides are in bytes. 235 * 236 * Only defined for non-depth-stencil formats. 237 */ 238 void 239 (*unpack_rgba_float)(float *dst, unsigned dst_stride, 240 const uint8_t *src, unsigned src_stride, 241 unsigned width, unsigned height); 242 243 /** 244 * Pack pixel blocks from R32G32B32A32_FLOAT. 245 * Note: strides are in bytes. 246 * 247 * Only defined for non-depth-stencil formats. 248 */ 249 void 250 (*pack_rgba_float)(uint8_t *dst, unsigned dst_stride, 251 const float *src, unsigned src_stride, 252 unsigned width, unsigned height); 253 254 /** 255 * Fetch a single pixel (i, j) from a block. 256 * 257 * Only defined for non-depth-stencil and non-integer formats. 258 */ 259 void 260 (*fetch_rgba_float)(float *dst, 261 const uint8_t *src, 262 unsigned i, unsigned j); 263 264 /** 265 * Unpack pixels to Z32_UNORM. 266 * Note: strides are in bytes. 267 * 268 * Only defined for depth formats. 269 */ 270 void 271 (*unpack_z_32unorm)(uint32_t *dst, unsigned dst_stride, 272 const uint8_t *src, unsigned src_stride, 273 unsigned width, unsigned height); 274 275 /** 276 * Pack pixels from Z32_FLOAT. 277 * Note: strides are in bytes. 278 * 279 * Only defined for depth formats. 280 */ 281 void 282 (*pack_z_32unorm)(uint8_t *dst, unsigned dst_stride, 283 const uint32_t *src, unsigned src_stride, 284 unsigned width, unsigned height); 285 286 /** 287 * Unpack pixels to Z32_FLOAT. 288 * Note: strides are in bytes. 289 * 290 * Only defined for depth formats. 291 */ 292 void 293 (*unpack_z_float)(float *dst, unsigned dst_stride, 294 const uint8_t *src, unsigned src_stride, 295 unsigned width, unsigned height); 296 297 /** 298 * Pack pixels from Z32_FLOAT. 299 * Note: strides are in bytes. 300 * 301 * Only defined for depth formats. 302 */ 303 void 304 (*pack_z_float)(uint8_t *dst, unsigned dst_stride, 305 const float *src, unsigned src_stride, 306 unsigned width, unsigned height); 307 308 /** 309 * Unpack pixels to S8_UINT. 310 * Note: strides are in bytes. 311 * 312 * Only defined for stencil formats. 313 */ 314 void 315 (*unpack_s_8uint)(uint8_t *dst, unsigned dst_stride, 316 const uint8_t *src, unsigned src_stride, 317 unsigned width, unsigned height); 318 319 /** 320 * Pack pixels from S8_UINT. 321 * Note: strides are in bytes. 322 * 323 * Only defined for stencil formats. 324 */ 325 void 326 (*pack_s_8uint)(uint8_t *dst, unsigned dst_stride, 327 const uint8_t *src, unsigned src_stride, 328 unsigned width, unsigned height); 329 330 /** 331 * Unpack pixel blocks to R32G32B32A32_UINT. 332 * Note: strides are in bytes. 333 * 334 * Only defined for INT formats. 335 */ 336 void 337 (*unpack_rgba_uint)(unsigned *dst, unsigned dst_stride, 338 const uint8_t *src, unsigned src_stride, 339 unsigned width, unsigned height); 340 341 void 342 (*pack_rgba_uint)(uint8_t *dst, unsigned dst_stride, 343 const unsigned *src, unsigned src_stride, 344 unsigned width, unsigned height); 345 346 /** 347 * Unpack pixel blocks to R32G32B32A32_SINT. 348 * Note: strides are in bytes. 349 * 350 * Only defined for INT formats. 351 */ 352 void 353 (*unpack_rgba_sint)(signed *dst, unsigned dst_stride, 354 const uint8_t *src, unsigned src_stride, 355 unsigned width, unsigned height); 356 357 void 358 (*pack_rgba_sint)(uint8_t *dst, unsigned dst_stride, 359 const int *src, unsigned src_stride, 360 unsigned width, unsigned height); 361 362 /** 363 * Fetch a single pixel (i, j) from a block. 364 * 365 * Only defined for unsigned (pure) integer formats. 366 */ 367 void 368 (*fetch_rgba_uint)(uint32_t *dst, 369 const uint8_t *src, 370 unsigned i, unsigned j); 371 372 /** 373 * Fetch a single pixel (i, j) from a block. 374 * 375 * Only defined for signed (pure) integer formats. 376 */ 377 void 378 (*fetch_rgba_sint)(int32_t *dst, 379 const uint8_t *src, 380 unsigned i, unsigned j); 381}; 382 383 384extern const struct util_format_description 385util_format_description_table[]; 386 387 388const struct util_format_description * 389util_format_description(enum pipe_format format); 390 391 392/* 393 * Format query functions. 394 */ 395 396static INLINE const char * 397util_format_name(enum pipe_format format) 398{ 399 const struct util_format_description *desc = util_format_description(format); 400 401 assert(desc); 402 if (!desc) { 403 return "PIPE_FORMAT_???"; 404 } 405 406 return desc->name; 407} 408 409static INLINE const char * 410util_format_short_name(enum pipe_format format) 411{ 412 const struct util_format_description *desc = util_format_description(format); 413 414 assert(desc); 415 if (!desc) { 416 return "???"; 417 } 418 419 return desc->short_name; 420} 421 422/** 423 * Whether this format is plain, see UTIL_FORMAT_LAYOUT_PLAIN for more info. 424 */ 425static INLINE boolean 426util_format_is_plain(enum pipe_format format) 427{ 428 const struct util_format_description *desc = util_format_description(format); 429 430 if (!format) { 431 return FALSE; 432 } 433 434 return desc->layout == UTIL_FORMAT_LAYOUT_PLAIN ? TRUE : FALSE; 435} 436 437static INLINE boolean 438util_format_is_compressed(enum pipe_format format) 439{ 440 const struct util_format_description *desc = util_format_description(format); 441 442 assert(desc); 443 if (!desc) { 444 return FALSE; 445 } 446 447 switch (desc->layout) { 448 case UTIL_FORMAT_LAYOUT_S3TC: 449 case UTIL_FORMAT_LAYOUT_RGTC: 450 /* XXX add other formats in the future */ 451 return TRUE; 452 default: 453 return FALSE; 454 } 455} 456 457static INLINE boolean 458util_format_is_s3tc(enum pipe_format format) 459{ 460 const struct util_format_description *desc = util_format_description(format); 461 462 assert(desc); 463 if (!desc) { 464 return FALSE; 465 } 466 467 return desc->layout == UTIL_FORMAT_LAYOUT_S3TC ? TRUE : FALSE; 468} 469 470static INLINE boolean 471util_format_is_srgb(enum pipe_format format) 472{ 473 const struct util_format_description *desc = util_format_description(format); 474 return desc->colorspace == UTIL_FORMAT_COLORSPACE_SRGB; 475} 476 477static INLINE boolean 478util_format_has_depth(const struct util_format_description *desc) 479{ 480 return desc->colorspace == UTIL_FORMAT_COLORSPACE_ZS && 481 desc->swizzle[0] != UTIL_FORMAT_SWIZZLE_NONE; 482} 483 484static INLINE boolean 485util_format_has_stencil(const struct util_format_description *desc) 486{ 487 return desc->colorspace == UTIL_FORMAT_COLORSPACE_ZS && 488 desc->swizzle[1] != UTIL_FORMAT_SWIZZLE_NONE; 489} 490 491static INLINE boolean 492util_format_is_depth_or_stencil(enum pipe_format format) 493{ 494 const struct util_format_description *desc = util_format_description(format); 495 496 assert(desc); 497 if (!desc) { 498 return FALSE; 499 } 500 501 return util_format_has_depth(desc) || 502 util_format_has_stencil(desc); 503} 504 505static INLINE boolean 506util_format_is_depth_and_stencil(enum pipe_format format) 507{ 508 const struct util_format_description *desc = util_format_description(format); 509 510 assert(desc); 511 if (!desc) { 512 return FALSE; 513 } 514 515 return util_format_has_depth(desc) && 516 util_format_has_stencil(desc); 517} 518 519 520/** 521 * Give the RGBA colormask of the channels that can be represented in this 522 * format. 523 * 524 * That is, the channels whose values are preserved. 525 */ 526static INLINE unsigned 527util_format_colormask(const struct util_format_description *desc) 528{ 529 unsigned colormask; 530 unsigned chan; 531 532 switch (desc->colorspace) { 533 case UTIL_FORMAT_COLORSPACE_RGB: 534 case UTIL_FORMAT_COLORSPACE_SRGB: 535 case UTIL_FORMAT_COLORSPACE_YUV: 536 colormask = 0; 537 for (chan = 0; chan < 4; ++chan) { 538 if (desc->swizzle[chan] < 4) { 539 colormask |= (1 << chan); 540 } 541 } 542 return colormask; 543 case UTIL_FORMAT_COLORSPACE_ZS: 544 return 0; 545 default: 546 assert(0); 547 return 0; 548 } 549} 550 551 552boolean 553util_format_is_float(enum pipe_format format); 554 555 556boolean 557util_format_is_rgb_no_alpha(enum pipe_format format); 558 559 560boolean 561util_format_is_luminance(enum pipe_format format); 562 563 564boolean 565util_format_is_luminance_alpha(enum pipe_format format); 566 567 568boolean 569util_format_is_intensity(enum pipe_format format); 570 571boolean 572util_format_is_pure_integer(enum pipe_format format); 573 574boolean 575util_format_is_pure_sint(enum pipe_format format); 576 577boolean 578util_format_is_pure_uint(enum pipe_format format); 579 580/** 581 * Whether the src format can be blitted to destation format with a simple 582 * memcpy. 583 */ 584boolean 585util_is_format_compatible(const struct util_format_description *src_desc, 586 const struct util_format_description *dst_desc); 587 588/** 589 * Whether the format is supported by Gallium for the given bindings. 590 * This covers S3TC textures and floating-point render targets. 591 */ 592boolean 593util_format_is_supported(enum pipe_format format, unsigned bind); 594 595/** 596 * Whether this format is a rgab8 variant. 597 * 598 * That is, any format that matches the 599 * 600 * PIPE_FORMAT_?8?8?8?8_UNORM 601 */ 602static INLINE boolean 603util_format_is_rgba8_variant(const struct util_format_description *desc) 604{ 605 unsigned chan; 606 607 if(desc->block.width != 1 || 608 desc->block.height != 1 || 609 desc->block.bits != 32) 610 return FALSE; 611 612 for(chan = 0; chan < 4; ++chan) { 613 if(desc->channel[chan].type != UTIL_FORMAT_TYPE_UNSIGNED && 614 desc->channel[chan].type != UTIL_FORMAT_TYPE_VOID) 615 return FALSE; 616 if(desc->channel[chan].size != 8) 617 return FALSE; 618 } 619 620 return TRUE; 621} 622 623 624/** 625 * Return total bits needed for the pixel format per block. 626 */ 627static INLINE uint 628util_format_get_blocksizebits(enum pipe_format format) 629{ 630 const struct util_format_description *desc = util_format_description(format); 631 632 assert(desc); 633 if (!desc) { 634 return 0; 635 } 636 637 return desc->block.bits; 638} 639 640/** 641 * Return bytes per block (not pixel) for the given format. 642 */ 643static INLINE uint 644util_format_get_blocksize(enum pipe_format format) 645{ 646 uint bits = util_format_get_blocksizebits(format); 647 648 assert(bits % 8 == 0); 649 650 return bits / 8; 651} 652 653static INLINE uint 654util_format_get_blockwidth(enum pipe_format format) 655{ 656 const struct util_format_description *desc = util_format_description(format); 657 658 assert(desc); 659 if (!desc) { 660 return 1; 661 } 662 663 return desc->block.width; 664} 665 666static INLINE uint 667util_format_get_blockheight(enum pipe_format format) 668{ 669 const struct util_format_description *desc = util_format_description(format); 670 671 assert(desc); 672 if (!desc) { 673 return 1; 674 } 675 676 return desc->block.height; 677} 678 679static INLINE unsigned 680util_format_get_nblocksx(enum pipe_format format, 681 unsigned x) 682{ 683 unsigned blockwidth = util_format_get_blockwidth(format); 684 return (x + blockwidth - 1) / blockwidth; 685} 686 687static INLINE unsigned 688util_format_get_nblocksy(enum pipe_format format, 689 unsigned y) 690{ 691 unsigned blockheight = util_format_get_blockheight(format); 692 return (y + blockheight - 1) / blockheight; 693} 694 695static INLINE unsigned 696util_format_get_nblocks(enum pipe_format format, 697 unsigned width, 698 unsigned height) 699{ 700 return util_format_get_nblocksx(format, width) * util_format_get_nblocksy(format, height); 701} 702 703static INLINE size_t 704util_format_get_stride(enum pipe_format format, 705 unsigned width) 706{ 707 return util_format_get_nblocksx(format, width) * util_format_get_blocksize(format); 708} 709 710static INLINE size_t 711util_format_get_2d_size(enum pipe_format format, 712 size_t stride, 713 unsigned height) 714{ 715 return util_format_get_nblocksy(format, height) * stride; 716} 717 718static INLINE uint 719util_format_get_component_bits(enum pipe_format format, 720 enum util_format_colorspace colorspace, 721 uint component) 722{ 723 const struct util_format_description *desc = util_format_description(format); 724 enum util_format_colorspace desc_colorspace; 725 726 assert(format); 727 if (!format) { 728 return 0; 729 } 730 731 assert(component < 4); 732 733 /* Treat RGB and SRGB as equivalent. */ 734 if (colorspace == UTIL_FORMAT_COLORSPACE_SRGB) { 735 colorspace = UTIL_FORMAT_COLORSPACE_RGB; 736 } 737 if (desc->colorspace == UTIL_FORMAT_COLORSPACE_SRGB) { 738 desc_colorspace = UTIL_FORMAT_COLORSPACE_RGB; 739 } else { 740 desc_colorspace = desc->colorspace; 741 } 742 743 if (desc_colorspace != colorspace) { 744 return 0; 745 } 746 747 switch (desc->swizzle[component]) { 748 case UTIL_FORMAT_SWIZZLE_X: 749 return desc->channel[0].size; 750 case UTIL_FORMAT_SWIZZLE_Y: 751 return desc->channel[1].size; 752 case UTIL_FORMAT_SWIZZLE_Z: 753 return desc->channel[2].size; 754 case UTIL_FORMAT_SWIZZLE_W: 755 return desc->channel[3].size; 756 default: 757 return 0; 758 } 759} 760 761static INLINE boolean 762util_format_has_alpha(enum pipe_format format) 763{ 764 const struct util_format_description *desc = util_format_description(format); 765 766 assert(format); 767 if (!format) { 768 return FALSE; 769 } 770 771 switch (desc->colorspace) { 772 case UTIL_FORMAT_COLORSPACE_RGB: 773 case UTIL_FORMAT_COLORSPACE_SRGB: 774 return desc->swizzle[3] != UTIL_FORMAT_SWIZZLE_1; 775 case UTIL_FORMAT_COLORSPACE_YUV: 776 return FALSE; 777 case UTIL_FORMAT_COLORSPACE_ZS: 778 return FALSE; 779 default: 780 assert(0); 781 return FALSE; 782 } 783} 784 785/** 786 * Given a linear RGB colorspace format, return the corresponding SRGB 787 * format, or PIPE_FORMAT_NONE if none. 788 */ 789static INLINE enum pipe_format 790util_format_srgb(enum pipe_format format) 791{ 792 switch (format) { 793 case PIPE_FORMAT_L8_UNORM: 794 return PIPE_FORMAT_L8_SRGB; 795 case PIPE_FORMAT_L8A8_UNORM: 796 return PIPE_FORMAT_L8A8_SRGB; 797 case PIPE_FORMAT_R8G8B8_UNORM: 798 return PIPE_FORMAT_R8G8B8_SRGB; 799 case PIPE_FORMAT_A8B8G8R8_UNORM: 800 return PIPE_FORMAT_A8B8G8R8_SRGB; 801 case PIPE_FORMAT_X8B8G8R8_UNORM: 802 return PIPE_FORMAT_X8B8G8R8_SRGB; 803 case PIPE_FORMAT_B8G8R8A8_UNORM: 804 return PIPE_FORMAT_B8G8R8A8_SRGB; 805 case PIPE_FORMAT_B8G8R8X8_UNORM: 806 return PIPE_FORMAT_B8G8R8X8_SRGB; 807 case PIPE_FORMAT_A8R8G8B8_UNORM: 808 return PIPE_FORMAT_A8R8G8B8_SRGB; 809 case PIPE_FORMAT_X8R8G8B8_UNORM: 810 return PIPE_FORMAT_X8R8G8B8_SRGB; 811 case PIPE_FORMAT_DXT1_RGB: 812 return PIPE_FORMAT_DXT1_SRGB; 813 case PIPE_FORMAT_DXT1_RGBA: 814 return PIPE_FORMAT_DXT1_SRGBA; 815 case PIPE_FORMAT_DXT3_RGBA: 816 return PIPE_FORMAT_DXT3_SRGBA; 817 case PIPE_FORMAT_DXT5_RGBA: 818 return PIPE_FORMAT_DXT5_SRGBA; 819 default: 820 return PIPE_FORMAT_NONE; 821 } 822} 823 824/** 825 * Given an sRGB format, return the corresponding linear colorspace format. 826 * For non sRGB formats, return the format unchanged. 827 */ 828static INLINE enum pipe_format 829util_format_linear(enum pipe_format format) 830{ 831 switch (format) { 832 case PIPE_FORMAT_L8_SRGB: 833 return PIPE_FORMAT_L8_UNORM; 834 case PIPE_FORMAT_L8A8_SRGB: 835 return PIPE_FORMAT_L8A8_UNORM; 836 case PIPE_FORMAT_R8G8B8_SRGB: 837 return PIPE_FORMAT_R8G8B8_UNORM; 838 case PIPE_FORMAT_A8B8G8R8_SRGB: 839 return PIPE_FORMAT_A8B8G8R8_UNORM; 840 case PIPE_FORMAT_X8B8G8R8_SRGB: 841 return PIPE_FORMAT_X8B8G8R8_UNORM; 842 case PIPE_FORMAT_B8G8R8A8_SRGB: 843 return PIPE_FORMAT_B8G8R8A8_UNORM; 844 case PIPE_FORMAT_B8G8R8X8_SRGB: 845 return PIPE_FORMAT_B8G8R8X8_UNORM; 846 case PIPE_FORMAT_A8R8G8B8_SRGB: 847 return PIPE_FORMAT_A8R8G8B8_UNORM; 848 case PIPE_FORMAT_X8R8G8B8_SRGB: 849 return PIPE_FORMAT_X8R8G8B8_UNORM; 850 case PIPE_FORMAT_DXT1_SRGB: 851 return PIPE_FORMAT_DXT1_RGB; 852 case PIPE_FORMAT_DXT1_SRGBA: 853 return PIPE_FORMAT_DXT1_RGBA; 854 case PIPE_FORMAT_DXT3_SRGBA: 855 return PIPE_FORMAT_DXT3_RGBA; 856 case PIPE_FORMAT_DXT5_SRGBA: 857 return PIPE_FORMAT_DXT5_RGBA; 858 default: 859 return format; 860 } 861} 862 863/** 864 * Return the number of components stored. 865 * Formats with block size != 1x1 will always have 1 component (the block). 866 */ 867static INLINE unsigned 868util_format_get_nr_components(enum pipe_format format) 869{ 870 const struct util_format_description *desc = util_format_description(format); 871 return desc->nr_channels; 872} 873 874/** 875 * Return the index of the first non-void channel 876 * -1 if no non-void channels 877 */ 878static INLINE int 879util_format_get_first_non_void_channel(enum pipe_format format) 880{ 881 const struct util_format_description *desc = util_format_description(format); 882 int i; 883 884 for (i = 0; i < 4; i++) 885 if (desc->channel[i].type != UTIL_FORMAT_TYPE_VOID) 886 break; 887 888 if (i == 4) 889 return -1; 890 891 return i; 892} 893 894/* 895 * Format access functions. 896 */ 897 898void 899util_format_read_4f(enum pipe_format format, 900 float *dst, unsigned dst_stride, 901 const void *src, unsigned src_stride, 902 unsigned x, unsigned y, unsigned w, unsigned h); 903 904void 905util_format_write_4f(enum pipe_format format, 906 const float *src, unsigned src_stride, 907 void *dst, unsigned dst_stride, 908 unsigned x, unsigned y, unsigned w, unsigned h); 909 910void 911util_format_read_4ub(enum pipe_format format, 912 uint8_t *dst, unsigned dst_stride, 913 const void *src, unsigned src_stride, 914 unsigned x, unsigned y, unsigned w, unsigned h); 915 916void 917util_format_write_4ub(enum pipe_format format, 918 const uint8_t *src, unsigned src_stride, 919 void *dst, unsigned dst_stride, 920 unsigned x, unsigned y, unsigned w, unsigned h); 921 922void 923util_format_read_4ui(enum pipe_format format, 924 unsigned *dst, unsigned dst_stride, 925 const void *src, unsigned src_stride, 926 unsigned x, unsigned y, unsigned w, unsigned h); 927 928void 929util_format_write_4ui(enum pipe_format format, 930 const unsigned int *src, unsigned src_stride, 931 void *dst, unsigned dst_stride, 932 unsigned x, unsigned y, unsigned w, unsigned h); 933 934void 935util_format_read_4i(enum pipe_format format, 936 int *dst, unsigned dst_stride, 937 const void *src, unsigned src_stride, 938 unsigned x, unsigned y, unsigned w, unsigned h); 939 940void 941util_format_write_4i(enum pipe_format format, 942 const int *src, unsigned src_stride, 943 void *dst, unsigned dst_stride, 944 unsigned x, unsigned y, unsigned w, unsigned h); 945 946/* 947 * Generic format conversion; 948 */ 949 950boolean 951util_format_fits_8unorm(const struct util_format_description *format_desc); 952 953void 954util_format_translate(enum pipe_format dst_format, 955 void *dst, unsigned dst_stride, 956 unsigned dst_x, unsigned dst_y, 957 enum pipe_format src_format, 958 const void *src, unsigned src_stride, 959 unsigned src_x, unsigned src_y, 960 unsigned width, unsigned height); 961 962/* 963 * Swizzle operations. 964 */ 965 966/* Compose two sets of swizzles. 967 * If V is a 4D vector and the function parameters represent functions that 968 * swizzle vector components, this holds: 969 * swz2(swz1(V)) = dst(V) 970 */ 971void util_format_compose_swizzles(const unsigned char swz1[4], 972 const unsigned char swz2[4], 973 unsigned char dst[4]); 974 975void util_format_swizzle_4f(float *dst, const float *src, 976 const unsigned char swz[4]); 977 978void util_format_unswizzle_4f(float *dst, const float *src, 979 const unsigned char swz[4]); 980 981#ifdef __cplusplus 982} // extern "C" { 983#endif 984 985#endif /* ! U_FORMAT_H */ 986