u_format.h revision ce671c7aceca33a2f29dddfaa555a25218524146
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 * Check if the src format can be blitted to the destination format with 582 * a simple memcpy. For example, blitting from RGBA to RGBx is OK, but not 583 * the reverse. 584 */ 585boolean 586util_is_format_compatible(const struct util_format_description *src_desc, 587 const struct util_format_description *dst_desc); 588 589/** 590 * Whether the format is supported by Gallium for the given bindings. 591 * This covers S3TC textures and floating-point render targets. 592 */ 593boolean 594util_format_is_supported(enum pipe_format format, unsigned bind); 595 596/** 597 * Whether this format is a rgab8 variant. 598 * 599 * That is, any format that matches the 600 * 601 * PIPE_FORMAT_?8?8?8?8_UNORM 602 */ 603static INLINE boolean 604util_format_is_rgba8_variant(const struct util_format_description *desc) 605{ 606 unsigned chan; 607 608 if(desc->block.width != 1 || 609 desc->block.height != 1 || 610 desc->block.bits != 32) 611 return FALSE; 612 613 for(chan = 0; chan < 4; ++chan) { 614 if(desc->channel[chan].type != UTIL_FORMAT_TYPE_UNSIGNED && 615 desc->channel[chan].type != UTIL_FORMAT_TYPE_VOID) 616 return FALSE; 617 if(desc->channel[chan].size != 8) 618 return FALSE; 619 } 620 621 return TRUE; 622} 623 624 625/** 626 * Return total bits needed for the pixel format per block. 627 */ 628static INLINE uint 629util_format_get_blocksizebits(enum pipe_format format) 630{ 631 const struct util_format_description *desc = util_format_description(format); 632 633 assert(desc); 634 if (!desc) { 635 return 0; 636 } 637 638 return desc->block.bits; 639} 640 641/** 642 * Return bytes per block (not pixel) for the given format. 643 */ 644static INLINE uint 645util_format_get_blocksize(enum pipe_format format) 646{ 647 uint bits = util_format_get_blocksizebits(format); 648 649 assert(bits % 8 == 0); 650 651 return bits / 8; 652} 653 654static INLINE uint 655util_format_get_blockwidth(enum pipe_format format) 656{ 657 const struct util_format_description *desc = util_format_description(format); 658 659 assert(desc); 660 if (!desc) { 661 return 1; 662 } 663 664 return desc->block.width; 665} 666 667static INLINE uint 668util_format_get_blockheight(enum pipe_format format) 669{ 670 const struct util_format_description *desc = util_format_description(format); 671 672 assert(desc); 673 if (!desc) { 674 return 1; 675 } 676 677 return desc->block.height; 678} 679 680static INLINE unsigned 681util_format_get_nblocksx(enum pipe_format format, 682 unsigned x) 683{ 684 unsigned blockwidth = util_format_get_blockwidth(format); 685 return (x + blockwidth - 1) / blockwidth; 686} 687 688static INLINE unsigned 689util_format_get_nblocksy(enum pipe_format format, 690 unsigned y) 691{ 692 unsigned blockheight = util_format_get_blockheight(format); 693 return (y + blockheight - 1) / blockheight; 694} 695 696static INLINE unsigned 697util_format_get_nblocks(enum pipe_format format, 698 unsigned width, 699 unsigned height) 700{ 701 return util_format_get_nblocksx(format, width) * util_format_get_nblocksy(format, height); 702} 703 704static INLINE size_t 705util_format_get_stride(enum pipe_format format, 706 unsigned width) 707{ 708 return util_format_get_nblocksx(format, width) * util_format_get_blocksize(format); 709} 710 711static INLINE size_t 712util_format_get_2d_size(enum pipe_format format, 713 size_t stride, 714 unsigned height) 715{ 716 return util_format_get_nblocksy(format, height) * stride; 717} 718 719static INLINE uint 720util_format_get_component_bits(enum pipe_format format, 721 enum util_format_colorspace colorspace, 722 uint component) 723{ 724 const struct util_format_description *desc = util_format_description(format); 725 enum util_format_colorspace desc_colorspace; 726 727 assert(format); 728 if (!format) { 729 return 0; 730 } 731 732 assert(component < 4); 733 734 /* Treat RGB and SRGB as equivalent. */ 735 if (colorspace == UTIL_FORMAT_COLORSPACE_SRGB) { 736 colorspace = UTIL_FORMAT_COLORSPACE_RGB; 737 } 738 if (desc->colorspace == UTIL_FORMAT_COLORSPACE_SRGB) { 739 desc_colorspace = UTIL_FORMAT_COLORSPACE_RGB; 740 } else { 741 desc_colorspace = desc->colorspace; 742 } 743 744 if (desc_colorspace != colorspace) { 745 return 0; 746 } 747 748 switch (desc->swizzle[component]) { 749 case UTIL_FORMAT_SWIZZLE_X: 750 return desc->channel[0].size; 751 case UTIL_FORMAT_SWIZZLE_Y: 752 return desc->channel[1].size; 753 case UTIL_FORMAT_SWIZZLE_Z: 754 return desc->channel[2].size; 755 case UTIL_FORMAT_SWIZZLE_W: 756 return desc->channel[3].size; 757 default: 758 return 0; 759 } 760} 761 762static INLINE boolean 763util_format_has_alpha(enum pipe_format format) 764{ 765 const struct util_format_description *desc = util_format_description(format); 766 767 assert(format); 768 if (!format) { 769 return FALSE; 770 } 771 772 switch (desc->colorspace) { 773 case UTIL_FORMAT_COLORSPACE_RGB: 774 case UTIL_FORMAT_COLORSPACE_SRGB: 775 return desc->swizzle[3] != UTIL_FORMAT_SWIZZLE_1; 776 case UTIL_FORMAT_COLORSPACE_YUV: 777 return FALSE; 778 case UTIL_FORMAT_COLORSPACE_ZS: 779 return FALSE; 780 default: 781 assert(0); 782 return FALSE; 783 } 784} 785 786/** 787 * Given a linear RGB colorspace format, return the corresponding SRGB 788 * format, or PIPE_FORMAT_NONE if none. 789 */ 790static INLINE enum pipe_format 791util_format_srgb(enum pipe_format format) 792{ 793 switch (format) { 794 case PIPE_FORMAT_L8_UNORM: 795 return PIPE_FORMAT_L8_SRGB; 796 case PIPE_FORMAT_L8A8_UNORM: 797 return PIPE_FORMAT_L8A8_SRGB; 798 case PIPE_FORMAT_R8G8B8_UNORM: 799 return PIPE_FORMAT_R8G8B8_SRGB; 800 case PIPE_FORMAT_A8B8G8R8_UNORM: 801 return PIPE_FORMAT_A8B8G8R8_SRGB; 802 case PIPE_FORMAT_X8B8G8R8_UNORM: 803 return PIPE_FORMAT_X8B8G8R8_SRGB; 804 case PIPE_FORMAT_B8G8R8A8_UNORM: 805 return PIPE_FORMAT_B8G8R8A8_SRGB; 806 case PIPE_FORMAT_B8G8R8X8_UNORM: 807 return PIPE_FORMAT_B8G8R8X8_SRGB; 808 case PIPE_FORMAT_A8R8G8B8_UNORM: 809 return PIPE_FORMAT_A8R8G8B8_SRGB; 810 case PIPE_FORMAT_X8R8G8B8_UNORM: 811 return PIPE_FORMAT_X8R8G8B8_SRGB; 812 case PIPE_FORMAT_DXT1_RGB: 813 return PIPE_FORMAT_DXT1_SRGB; 814 case PIPE_FORMAT_DXT1_RGBA: 815 return PIPE_FORMAT_DXT1_SRGBA; 816 case PIPE_FORMAT_DXT3_RGBA: 817 return PIPE_FORMAT_DXT3_SRGBA; 818 case PIPE_FORMAT_DXT5_RGBA: 819 return PIPE_FORMAT_DXT5_SRGBA; 820 default: 821 return PIPE_FORMAT_NONE; 822 } 823} 824 825/** 826 * Given an sRGB format, return the corresponding linear colorspace format. 827 * For non sRGB formats, return the format unchanged. 828 */ 829static INLINE enum pipe_format 830util_format_linear(enum pipe_format format) 831{ 832 switch (format) { 833 case PIPE_FORMAT_L8_SRGB: 834 return PIPE_FORMAT_L8_UNORM; 835 case PIPE_FORMAT_L8A8_SRGB: 836 return PIPE_FORMAT_L8A8_UNORM; 837 case PIPE_FORMAT_R8G8B8_SRGB: 838 return PIPE_FORMAT_R8G8B8_UNORM; 839 case PIPE_FORMAT_A8B8G8R8_SRGB: 840 return PIPE_FORMAT_A8B8G8R8_UNORM; 841 case PIPE_FORMAT_X8B8G8R8_SRGB: 842 return PIPE_FORMAT_X8B8G8R8_UNORM; 843 case PIPE_FORMAT_B8G8R8A8_SRGB: 844 return PIPE_FORMAT_B8G8R8A8_UNORM; 845 case PIPE_FORMAT_B8G8R8X8_SRGB: 846 return PIPE_FORMAT_B8G8R8X8_UNORM; 847 case PIPE_FORMAT_A8R8G8B8_SRGB: 848 return PIPE_FORMAT_A8R8G8B8_UNORM; 849 case PIPE_FORMAT_X8R8G8B8_SRGB: 850 return PIPE_FORMAT_X8R8G8B8_UNORM; 851 case PIPE_FORMAT_DXT1_SRGB: 852 return PIPE_FORMAT_DXT1_RGB; 853 case PIPE_FORMAT_DXT1_SRGBA: 854 return PIPE_FORMAT_DXT1_RGBA; 855 case PIPE_FORMAT_DXT3_SRGBA: 856 return PIPE_FORMAT_DXT3_RGBA; 857 case PIPE_FORMAT_DXT5_SRGBA: 858 return PIPE_FORMAT_DXT5_RGBA; 859 default: 860 return format; 861 } 862} 863 864/** 865 * Return the number of components stored. 866 * Formats with block size != 1x1 will always have 1 component (the block). 867 */ 868static INLINE unsigned 869util_format_get_nr_components(enum pipe_format format) 870{ 871 const struct util_format_description *desc = util_format_description(format); 872 return desc->nr_channels; 873} 874 875/** 876 * Return the index of the first non-void channel 877 * -1 if no non-void channels 878 */ 879static INLINE int 880util_format_get_first_non_void_channel(enum pipe_format format) 881{ 882 const struct util_format_description *desc = util_format_description(format); 883 int i; 884 885 for (i = 0; i < 4; i++) 886 if (desc->channel[i].type != UTIL_FORMAT_TYPE_VOID) 887 break; 888 889 if (i == 4) 890 return -1; 891 892 return i; 893} 894 895/* 896 * Format access functions. 897 */ 898 899void 900util_format_read_4f(enum pipe_format format, 901 float *dst, unsigned dst_stride, 902 const void *src, unsigned src_stride, 903 unsigned x, unsigned y, unsigned w, unsigned h); 904 905void 906util_format_write_4f(enum pipe_format format, 907 const float *src, unsigned src_stride, 908 void *dst, unsigned dst_stride, 909 unsigned x, unsigned y, unsigned w, unsigned h); 910 911void 912util_format_read_4ub(enum pipe_format format, 913 uint8_t *dst, unsigned dst_stride, 914 const void *src, unsigned src_stride, 915 unsigned x, unsigned y, unsigned w, unsigned h); 916 917void 918util_format_write_4ub(enum pipe_format format, 919 const uint8_t *src, unsigned src_stride, 920 void *dst, unsigned dst_stride, 921 unsigned x, unsigned y, unsigned w, unsigned h); 922 923void 924util_format_read_4ui(enum pipe_format format, 925 unsigned *dst, unsigned dst_stride, 926 const void *src, unsigned src_stride, 927 unsigned x, unsigned y, unsigned w, unsigned h); 928 929void 930util_format_write_4ui(enum pipe_format format, 931 const unsigned int *src, unsigned src_stride, 932 void *dst, unsigned dst_stride, 933 unsigned x, unsigned y, unsigned w, unsigned h); 934 935void 936util_format_read_4i(enum pipe_format format, 937 int *dst, unsigned dst_stride, 938 const void *src, unsigned src_stride, 939 unsigned x, unsigned y, unsigned w, unsigned h); 940 941void 942util_format_write_4i(enum pipe_format format, 943 const int *src, unsigned src_stride, 944 void *dst, unsigned dst_stride, 945 unsigned x, unsigned y, unsigned w, unsigned h); 946 947/* 948 * Generic format conversion; 949 */ 950 951boolean 952util_format_fits_8unorm(const struct util_format_description *format_desc); 953 954void 955util_format_translate(enum pipe_format dst_format, 956 void *dst, unsigned dst_stride, 957 unsigned dst_x, unsigned dst_y, 958 enum pipe_format src_format, 959 const void *src, unsigned src_stride, 960 unsigned src_x, unsigned src_y, 961 unsigned width, unsigned height); 962 963/* 964 * Swizzle operations. 965 */ 966 967/* Compose two sets of swizzles. 968 * If V is a 4D vector and the function parameters represent functions that 969 * swizzle vector components, this holds: 970 * swz2(swz1(V)) = dst(V) 971 */ 972void util_format_compose_swizzles(const unsigned char swz1[4], 973 const unsigned char swz2[4], 974 unsigned char dst[4]); 975 976void util_format_swizzle_4f(float *dst, const float *src, 977 const unsigned char swz[4]); 978 979void util_format_unswizzle_4f(float *dst, const float *src, 980 const unsigned char swz[4]); 981 982#ifdef __cplusplus 983} // extern "C" { 984#endif 985 986#endif /* ! U_FORMAT_H */ 987