1/************************************************************************** 2 * 3 * Copyright 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 * @file 30 * Pixel format accessor functions. 31 * 32 * @author Jose Fonseca <jfonseca@vmware.com> 33 */ 34 35#include "u_math.h" 36#include "u_memory.h" 37#include "u_rect.h" 38#include "u_format.h" 39#include "u_format_s3tc.h" 40 41#include "pipe/p_defines.h" 42 43 44boolean 45util_format_is_float(enum pipe_format format) 46{ 47 const struct util_format_description *desc = util_format_description(format); 48 unsigned i; 49 50 assert(desc); 51 if (!desc) { 52 return FALSE; 53 } 54 55 i = util_format_get_first_non_void_channel(format); 56 if (i == -1) { 57 return FALSE; 58 } 59 60 return desc->channel[i].type == UTIL_FORMAT_TYPE_FLOAT ? TRUE : FALSE; 61} 62 63 64/** 65 * Return the number of logical channels in the given format by 66 * examining swizzles. 67 * XXX this could be made into a public function if useful elsewhere. 68 */ 69static unsigned 70nr_logical_channels(const struct util_format_description *desc) 71{ 72 boolean swizzle_used[UTIL_FORMAT_SWIZZLE_MAX]; 73 74 memset(swizzle_used, 0, sizeof(swizzle_used)); 75 76 swizzle_used[desc->swizzle[0]] = TRUE; 77 swizzle_used[desc->swizzle[1]] = TRUE; 78 swizzle_used[desc->swizzle[2]] = TRUE; 79 swizzle_used[desc->swizzle[3]] = TRUE; 80 81 return (swizzle_used[UTIL_FORMAT_SWIZZLE_X] + 82 swizzle_used[UTIL_FORMAT_SWIZZLE_Y] + 83 swizzle_used[UTIL_FORMAT_SWIZZLE_Z] + 84 swizzle_used[UTIL_FORMAT_SWIZZLE_W]); 85} 86 87 88/** Test if the format contains RGB, but not alpha */ 89boolean 90util_format_is_rgb_no_alpha(enum pipe_format format) 91{ 92 const struct util_format_description *desc = 93 util_format_description(format); 94 95 if ((desc->colorspace == UTIL_FORMAT_COLORSPACE_RGB || 96 desc->colorspace == UTIL_FORMAT_COLORSPACE_SRGB) && 97 nr_logical_channels(desc) == 3) { 98 return TRUE; 99 } 100 return FALSE; 101} 102 103 104boolean 105util_format_is_luminance(enum pipe_format format) 106{ 107 const struct util_format_description *desc = 108 util_format_description(format); 109 110 if ((desc->colorspace == UTIL_FORMAT_COLORSPACE_RGB || 111 desc->colorspace == UTIL_FORMAT_COLORSPACE_SRGB) && 112 desc->swizzle[0] == UTIL_FORMAT_SWIZZLE_X && 113 desc->swizzle[1] == UTIL_FORMAT_SWIZZLE_X && 114 desc->swizzle[2] == UTIL_FORMAT_SWIZZLE_X && 115 desc->swizzle[3] == UTIL_FORMAT_SWIZZLE_1) { 116 return TRUE; 117 } 118 return FALSE; 119} 120 121boolean 122util_format_is_pure_integer(enum pipe_format format) 123{ 124 const struct util_format_description *desc = util_format_description(format); 125 int i; 126 127 /* Find the first non-void channel. */ 128 i = util_format_get_first_non_void_channel(format); 129 if (i == -1) 130 return FALSE; 131 132 return desc->channel[i].pure_integer ? TRUE : FALSE; 133} 134 135boolean 136util_format_is_pure_sint(enum pipe_format format) 137{ 138 const struct util_format_description *desc = util_format_description(format); 139 int i; 140 141 i = util_format_get_first_non_void_channel(format); 142 if (i == -1) 143 return FALSE; 144 145 return (desc->channel[i].type == UTIL_FORMAT_TYPE_SIGNED && desc->channel[i].pure_integer) ? TRUE : FALSE; 146} 147 148boolean 149util_format_is_pure_uint(enum pipe_format format) 150{ 151 const struct util_format_description *desc = util_format_description(format); 152 int i; 153 154 i = util_format_get_first_non_void_channel(format); 155 if (i == -1) 156 return FALSE; 157 158 return (desc->channel[i].type == UTIL_FORMAT_TYPE_UNSIGNED && desc->channel[i].pure_integer) ? TRUE : FALSE; 159} 160 161boolean 162util_format_is_array(const struct util_format_description *desc) 163{ 164 unsigned chan; 165 166 if (desc->layout != UTIL_FORMAT_LAYOUT_PLAIN || 167 desc->colorspace != UTIL_FORMAT_COLORSPACE_RGB || 168 desc->block.width != 1 || 169 desc->block.height != 1) { 170 return FALSE; 171 } 172 173 for (chan = 0; chan < desc->nr_channels; ++chan) { 174 if (desc->swizzle[chan] != chan) 175 return FALSE; 176 177 if (desc->channel[chan].type != desc->channel[0].type) 178 return FALSE; 179 180 if (desc->channel[chan].normalized != desc->channel[0].normalized) 181 return FALSE; 182 183 if (desc->channel[chan].pure_integer != desc->channel[0].pure_integer) 184 return FALSE; 185 186 if (desc->channel[chan].size != desc->channel[0].size) 187 return FALSE; 188 } 189 190 return TRUE; 191} 192 193boolean 194util_format_is_luminance_alpha(enum pipe_format format) 195{ 196 const struct util_format_description *desc = 197 util_format_description(format); 198 199 if ((desc->colorspace == UTIL_FORMAT_COLORSPACE_RGB || 200 desc->colorspace == UTIL_FORMAT_COLORSPACE_SRGB) && 201 desc->swizzle[0] == UTIL_FORMAT_SWIZZLE_X && 202 desc->swizzle[1] == UTIL_FORMAT_SWIZZLE_X && 203 desc->swizzle[2] == UTIL_FORMAT_SWIZZLE_X && 204 desc->swizzle[3] == UTIL_FORMAT_SWIZZLE_Y) { 205 return TRUE; 206 } 207 return FALSE; 208} 209 210 211boolean 212util_format_is_intensity(enum pipe_format format) 213{ 214 const struct util_format_description *desc = 215 util_format_description(format); 216 217 if ((desc->colorspace == UTIL_FORMAT_COLORSPACE_RGB || 218 desc->colorspace == UTIL_FORMAT_COLORSPACE_SRGB) && 219 desc->swizzle[0] == UTIL_FORMAT_SWIZZLE_X && 220 desc->swizzle[1] == UTIL_FORMAT_SWIZZLE_X && 221 desc->swizzle[2] == UTIL_FORMAT_SWIZZLE_X && 222 desc->swizzle[3] == UTIL_FORMAT_SWIZZLE_X) { 223 return TRUE; 224 } 225 return FALSE; 226} 227 228 229boolean 230util_format_is_supported(enum pipe_format format, unsigned bind) 231{ 232 if (util_format_is_s3tc(format) && !util_format_s3tc_enabled) { 233 return FALSE; 234 } 235 236#ifndef TEXTURE_FLOAT_ENABLED 237 if ((bind & PIPE_BIND_RENDER_TARGET) && 238 format != PIPE_FORMAT_R9G9B9E5_FLOAT && 239 format != PIPE_FORMAT_R11G11B10_FLOAT && 240 util_format_is_float(format)) { 241 return FALSE; 242 } 243#endif 244 245 return TRUE; 246} 247 248 249void 250util_format_read_4f(enum pipe_format format, 251 float *dst, unsigned dst_stride, 252 const void *src, unsigned src_stride, 253 unsigned x, unsigned y, unsigned w, unsigned h) 254{ 255 const struct util_format_description *format_desc; 256 const uint8_t *src_row; 257 float *dst_row; 258 259 format_desc = util_format_description(format); 260 261 assert(x % format_desc->block.width == 0); 262 assert(y % format_desc->block.height == 0); 263 264 src_row = (const uint8_t *)src + y*src_stride + x*(format_desc->block.bits/8); 265 dst_row = dst; 266 267 format_desc->unpack_rgba_float(dst_row, dst_stride, src_row, src_stride, w, h); 268} 269 270 271void 272util_format_write_4f(enum pipe_format format, 273 const float *src, unsigned src_stride, 274 void *dst, unsigned dst_stride, 275 unsigned x, unsigned y, unsigned w, unsigned h) 276{ 277 const struct util_format_description *format_desc; 278 uint8_t *dst_row; 279 const float *src_row; 280 281 format_desc = util_format_description(format); 282 283 assert(x % format_desc->block.width == 0); 284 assert(y % format_desc->block.height == 0); 285 286 dst_row = (uint8_t *)dst + y*dst_stride + x*(format_desc->block.bits/8); 287 src_row = src; 288 289 format_desc->pack_rgba_float(dst_row, dst_stride, src_row, src_stride, w, h); 290} 291 292 293void 294util_format_read_4ub(enum pipe_format format, uint8_t *dst, unsigned dst_stride, const void *src, unsigned src_stride, unsigned x, unsigned y, unsigned w, unsigned h) 295{ 296 const struct util_format_description *format_desc; 297 const uint8_t *src_row; 298 uint8_t *dst_row; 299 300 format_desc = util_format_description(format); 301 302 assert(x % format_desc->block.width == 0); 303 assert(y % format_desc->block.height == 0); 304 305 src_row = (const uint8_t *)src + y*src_stride + x*(format_desc->block.bits/8); 306 dst_row = dst; 307 308 format_desc->unpack_rgba_8unorm(dst_row, dst_stride, src_row, src_stride, w, h); 309} 310 311 312void 313util_format_write_4ub(enum pipe_format format, const uint8_t *src, unsigned src_stride, void *dst, unsigned dst_stride, unsigned x, unsigned y, unsigned w, unsigned h) 314{ 315 const struct util_format_description *format_desc; 316 uint8_t *dst_row; 317 const uint8_t *src_row; 318 319 format_desc = util_format_description(format); 320 321 assert(x % format_desc->block.width == 0); 322 assert(y % format_desc->block.height == 0); 323 324 dst_row = (uint8_t *)dst + y*dst_stride + x*(format_desc->block.bits/8); 325 src_row = src; 326 327 format_desc->pack_rgba_8unorm(dst_row, dst_stride, src_row, src_stride, w, h); 328} 329 330void 331util_format_read_4ui(enum pipe_format format, 332 unsigned *dst, unsigned dst_stride, 333 const void *src, unsigned src_stride, 334 unsigned x, unsigned y, unsigned w, unsigned h) 335{ 336 const struct util_format_description *format_desc; 337 const uint8_t *src_row; 338 unsigned *dst_row; 339 340 format_desc = util_format_description(format); 341 342 assert(x % format_desc->block.width == 0); 343 assert(y % format_desc->block.height == 0); 344 345 src_row = (const uint8_t *)src + y*src_stride + x*(format_desc->block.bits/8); 346 dst_row = dst; 347 348 format_desc->unpack_rgba_uint(dst_row, dst_stride, src_row, src_stride, w, h); 349} 350 351void 352util_format_write_4ui(enum pipe_format format, 353 const unsigned int *src, unsigned src_stride, 354 void *dst, unsigned dst_stride, 355 unsigned x, unsigned y, unsigned w, unsigned h) 356{ 357 const struct util_format_description *format_desc; 358 uint8_t *dst_row; 359 const unsigned *src_row; 360 361 format_desc = util_format_description(format); 362 363 assert(x % format_desc->block.width == 0); 364 assert(y % format_desc->block.height == 0); 365 366 dst_row = (uint8_t *)dst + y*dst_stride + x*(format_desc->block.bits/8); 367 src_row = src; 368 369 format_desc->pack_rgba_uint(dst_row, dst_stride, src_row, src_stride, w, h); 370} 371 372void 373util_format_read_4i(enum pipe_format format, 374 int *dst, unsigned dst_stride, 375 const void *src, unsigned src_stride, 376 unsigned x, unsigned y, unsigned w, unsigned h) 377{ 378 const struct util_format_description *format_desc; 379 const uint8_t *src_row; 380 int *dst_row; 381 382 format_desc = util_format_description(format); 383 384 assert(x % format_desc->block.width == 0); 385 assert(y % format_desc->block.height == 0); 386 387 src_row = (const uint8_t *)src + y*src_stride + x*(format_desc->block.bits/8); 388 dst_row = dst; 389 390 format_desc->unpack_rgba_sint(dst_row, dst_stride, src_row, src_stride, w, h); 391} 392 393void 394util_format_write_4i(enum pipe_format format, 395 const int *src, unsigned src_stride, 396 void *dst, unsigned dst_stride, 397 unsigned x, unsigned y, unsigned w, unsigned h) 398{ 399 const struct util_format_description *format_desc; 400 uint8_t *dst_row; 401 const int *src_row; 402 403 format_desc = util_format_description(format); 404 405 assert(x % format_desc->block.width == 0); 406 assert(y % format_desc->block.height == 0); 407 408 dst_row = (uint8_t *)dst + y*dst_stride + x*(format_desc->block.bits/8); 409 src_row = src; 410 411 format_desc->pack_rgba_sint(dst_row, dst_stride, src_row, src_stride, w, h); 412} 413 414boolean 415util_is_format_compatible(const struct util_format_description *src_desc, 416 const struct util_format_description *dst_desc) 417{ 418 unsigned chan; 419 420 if (src_desc->format == dst_desc->format) { 421 return TRUE; 422 } 423 424 if (src_desc->layout != UTIL_FORMAT_LAYOUT_PLAIN || 425 dst_desc->layout != UTIL_FORMAT_LAYOUT_PLAIN) { 426 return FALSE; 427 } 428 429 if (src_desc->block.bits != dst_desc->block.bits || 430 src_desc->nr_channels != dst_desc->nr_channels || 431 src_desc->colorspace != dst_desc->colorspace) { 432 return FALSE; 433 } 434 435 for (chan = 0; chan < 4; ++chan) { 436 if (src_desc->channel[chan].size != 437 dst_desc->channel[chan].size) { 438 return FALSE; 439 } 440 } 441 442 for (chan = 0; chan < 4; ++chan) { 443 enum util_format_swizzle swizzle = dst_desc->swizzle[chan]; 444 445 if (swizzle < 4) { 446 if (src_desc->swizzle[chan] != swizzle) { 447 return FALSE; 448 } 449 if ((src_desc->channel[swizzle].type != 450 dst_desc->channel[swizzle].type) || 451 (src_desc->channel[swizzle].normalized != 452 dst_desc->channel[swizzle].normalized)) { 453 return FALSE; 454 } 455 } 456 } 457 458 return TRUE; 459} 460 461 462boolean 463util_format_fits_8unorm(const struct util_format_description *format_desc) 464{ 465 unsigned chan; 466 467 /* 468 * After linearized sRGB values require more than 8bits. 469 */ 470 471 if (format_desc->colorspace == UTIL_FORMAT_COLORSPACE_SRGB) { 472 return FALSE; 473 } 474 475 switch (format_desc->layout) { 476 477 case UTIL_FORMAT_LAYOUT_S3TC: 478 /* 479 * These are straight forward. 480 */ 481 return TRUE; 482 case UTIL_FORMAT_LAYOUT_RGTC: 483 if (format_desc->format == PIPE_FORMAT_RGTC1_SNORM || 484 format_desc->format == PIPE_FORMAT_RGTC2_SNORM || 485 format_desc->format == PIPE_FORMAT_LATC1_SNORM || 486 format_desc->format == PIPE_FORMAT_LATC2_SNORM) 487 return FALSE; 488 return TRUE; 489 490 case UTIL_FORMAT_LAYOUT_PLAIN: 491 /* 492 * For these we can find a generic rule. 493 */ 494 495 for (chan = 0; chan < format_desc->nr_channels; ++chan) { 496 switch (format_desc->channel[chan].type) { 497 case UTIL_FORMAT_TYPE_VOID: 498 break; 499 case UTIL_FORMAT_TYPE_UNSIGNED: 500 if (!format_desc->channel[chan].normalized || 501 format_desc->channel[chan].size > 8) { 502 return FALSE; 503 } 504 break; 505 default: 506 return FALSE; 507 } 508 } 509 return TRUE; 510 511 default: 512 /* 513 * Handle all others on a case by case basis. 514 */ 515 516 switch (format_desc->format) { 517 case PIPE_FORMAT_R1_UNORM: 518 case PIPE_FORMAT_UYVY: 519 case PIPE_FORMAT_YUYV: 520 case PIPE_FORMAT_R8G8_B8G8_UNORM: 521 case PIPE_FORMAT_G8R8_G8B8_UNORM: 522 return TRUE; 523 524 default: 525 return FALSE; 526 } 527 } 528} 529 530 531void 532util_format_translate(enum pipe_format dst_format, 533 void *dst, unsigned dst_stride, 534 unsigned dst_x, unsigned dst_y, 535 enum pipe_format src_format, 536 const void *src, unsigned src_stride, 537 unsigned src_x, unsigned src_y, 538 unsigned width, unsigned height) 539{ 540 const struct util_format_description *dst_format_desc; 541 const struct util_format_description *src_format_desc; 542 uint8_t *dst_row; 543 const uint8_t *src_row; 544 unsigned x_step, y_step; 545 unsigned dst_step; 546 unsigned src_step; 547 548 dst_format_desc = util_format_description(dst_format); 549 src_format_desc = util_format_description(src_format); 550 551 if (util_is_format_compatible(src_format_desc, dst_format_desc)) { 552 /* 553 * Trivial case. 554 */ 555 556 util_copy_rect(dst, dst_format, dst_stride, dst_x, dst_y, 557 width, height, src, (int)src_stride, 558 src_x, src_y); 559 return; 560 } 561 562 assert(dst_x % dst_format_desc->block.width == 0); 563 assert(dst_y % dst_format_desc->block.height == 0); 564 assert(src_x % src_format_desc->block.width == 0); 565 assert(src_y % src_format_desc->block.height == 0); 566 567 dst_row = (uint8_t *)dst + dst_y*dst_stride + dst_x*(dst_format_desc->block.bits/8); 568 src_row = (const uint8_t *)src + src_y*src_stride + src_x*(src_format_desc->block.bits/8); 569 570 /* 571 * This works because all pixel formats have pixel blocks with power of two 572 * sizes. 573 */ 574 575 y_step = MAX2(dst_format_desc->block.height, src_format_desc->block.height); 576 x_step = MAX2(dst_format_desc->block.width, src_format_desc->block.width); 577 assert(y_step % dst_format_desc->block.height == 0); 578 assert(y_step % src_format_desc->block.height == 0); 579 580 dst_step = y_step / dst_format_desc->block.height * dst_stride; 581 src_step = y_step / src_format_desc->block.height * src_stride; 582 583 /* 584 * TODO: double formats will loose precision 585 * TODO: Add a special case for formats that are mere swizzles of each other 586 */ 587 588 if (src_format_desc->colorspace == UTIL_FORMAT_COLORSPACE_ZS || 589 dst_format_desc->colorspace == UTIL_FORMAT_COLORSPACE_ZS) { 590 float *tmp_z = NULL; 591 uint8_t *tmp_s = NULL; 592 593 assert(x_step == 1); 594 assert(y_step == 1); 595 596 if (src_format_desc->unpack_z_float && 597 dst_format_desc->pack_z_float) { 598 tmp_z = MALLOC(width * sizeof *tmp_z); 599 } 600 601 if (src_format_desc->unpack_s_8uint && 602 dst_format_desc->pack_s_8uint) { 603 tmp_s = MALLOC(width * sizeof *tmp_s); 604 } 605 606 while (height--) { 607 if (tmp_z) { 608 src_format_desc->unpack_z_float(tmp_z, 0, src_row, src_stride, width, 1); 609 dst_format_desc->pack_z_float(dst_row, dst_stride, tmp_z, 0, width, 1); 610 } 611 612 if (tmp_s) { 613 src_format_desc->unpack_s_8uint(tmp_s, 0, src_row, src_stride, width, 1); 614 dst_format_desc->pack_s_8uint(dst_row, dst_stride, tmp_s, 0, width, 1); 615 } 616 617 dst_row += dst_step; 618 src_row += src_step; 619 } 620 621 if (tmp_s) { 622 FREE(tmp_s); 623 } 624 625 if (tmp_z) { 626 FREE(tmp_z); 627 } 628 629 return; 630 } 631 632 if (util_format_fits_8unorm(src_format_desc) || 633 util_format_fits_8unorm(dst_format_desc)) { 634 unsigned tmp_stride; 635 uint8_t *tmp_row; 636 637 tmp_stride = MAX2(width, x_step) * 4 * sizeof *tmp_row; 638 tmp_row = MALLOC(y_step * tmp_stride); 639 if (!tmp_row) 640 return; 641 642 while (height >= y_step) { 643 src_format_desc->unpack_rgba_8unorm(tmp_row, tmp_stride, src_row, src_stride, width, y_step); 644 dst_format_desc->pack_rgba_8unorm(dst_row, dst_stride, tmp_row, tmp_stride, width, y_step); 645 646 dst_row += dst_step; 647 src_row += src_step; 648 height -= y_step; 649 } 650 651 if (height) { 652 src_format_desc->unpack_rgba_8unorm(tmp_row, tmp_stride, src_row, src_stride, width, height); 653 dst_format_desc->pack_rgba_8unorm(dst_row, dst_stride, tmp_row, tmp_stride, width, height); 654 } 655 656 FREE(tmp_row); 657 } 658 else { 659 unsigned tmp_stride; 660 float *tmp_row; 661 662 tmp_stride = MAX2(width, x_step) * 4 * sizeof *tmp_row; 663 tmp_row = MALLOC(y_step * tmp_stride); 664 if (!tmp_row) 665 return; 666 667 while (height >= y_step) { 668 src_format_desc->unpack_rgba_float(tmp_row, tmp_stride, src_row, src_stride, width, y_step); 669 dst_format_desc->pack_rgba_float(dst_row, dst_stride, tmp_row, tmp_stride, width, y_step); 670 671 dst_row += dst_step; 672 src_row += src_step; 673 height -= y_step; 674 } 675 676 if (height) { 677 src_format_desc->unpack_rgba_float(tmp_row, tmp_stride, src_row, src_stride, width, height); 678 dst_format_desc->pack_rgba_float(dst_row, dst_stride, tmp_row, tmp_stride, width, height); 679 } 680 681 FREE(tmp_row); 682 } 683} 684 685void util_format_compose_swizzles(const unsigned char swz1[4], 686 const unsigned char swz2[4], 687 unsigned char dst[4]) 688{ 689 unsigned i; 690 691 for (i = 0; i < 4; i++) { 692 dst[i] = swz2[i] <= UTIL_FORMAT_SWIZZLE_W ? 693 swz1[swz2[i]] : swz2[i]; 694 } 695} 696 697void util_format_swizzle_4f(float *dst, const float *src, 698 const unsigned char swz[4]) 699{ 700 unsigned i; 701 702 for (i = 0; i < 4; i++) { 703 if (swz[i] <= UTIL_FORMAT_SWIZZLE_W) 704 dst[i] = src[swz[i]]; 705 else if (swz[i] == UTIL_FORMAT_SWIZZLE_0) 706 dst[i] = 0; 707 else if (swz[i] == UTIL_FORMAT_SWIZZLE_1) 708 dst[i] = 1; 709 } 710} 711 712void util_format_unswizzle_4f(float *dst, const float *src, 713 const unsigned char swz[4]) 714{ 715 unsigned i; 716 717 for (i = 0; i < 4; i++) { 718 switch (swz[i]) { 719 case UTIL_FORMAT_SWIZZLE_X: 720 dst[0] = src[i]; 721 break; 722 case UTIL_FORMAT_SWIZZLE_Y: 723 dst[1] = src[i]; 724 break; 725 case UTIL_FORMAT_SWIZZLE_Z: 726 dst[2] = src[i]; 727 break; 728 case UTIL_FORMAT_SWIZZLE_W: 729 dst[3] = src[i]; 730 break; 731 } 732 } 733} 734