u_format_zs.c revision 866f9b18c68ede63c00917ec9c3dae3524ca8826
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 SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 15 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 16 * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL 17 * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, 18 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR 19 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE 20 * USE OR OTHER DEALINGS IN THE SOFTWARE. 21 * 22 * The above copyright notice and this permission notice (including the 23 * next paragraph) shall be included in all copies or substantial portions 24 * of the Software. 25 * 26 **************************************************************************/ 27 28 29#include "u_debug.h" 30#include "u_math.h" 31#include "u_format_zs.h" 32 33 34/* 35 * z32_unorm conversion functions 36 */ 37 38static INLINE uint16_t 39z32_unorm_to_z16_unorm(uint32_t z) 40{ 41 /* z * 0xffff / 0xffffffff */ 42 return z >> 16; 43} 44 45static INLINE uint32_t 46z16_unorm_to_z32_unorm(uint16_t z) 47{ 48 /* z * 0xffffffff / 0xffff */ 49 return (z << 16) | z; 50} 51 52static INLINE uint32_t 53z32_unorm_to_z24_unorm(uint32_t z) 54{ 55 /* z * 0xffffff / 0xffffffff */ 56 return z >> 8; 57} 58 59static INLINE uint32_t 60z24_unorm_to_z32_unorm(uint32_t z) 61{ 62 /* z * 0xffffffff / 0xffffff */ 63 return (z << 8) | (z >> 16); 64} 65 66 67/* 68 * z32_float conversion functions 69 */ 70 71static INLINE uint16_t 72z32_float_to_z16_unorm(float z) 73{ 74 const float scale = 0xffff; 75 return (uint16_t)(z * scale); 76} 77 78static INLINE float 79z16_unorm_to_z32_float(uint16_t z) 80{ 81 const float scale = 1.0 / 0xffff; 82 return (float)(z * scale); 83} 84 85static INLINE uint32_t 86z32_float_to_z24_unorm(float z) 87{ 88 const double scale = 0xffffff; 89 return (uint32_t)(z * scale) & 0xffffff; 90} 91 92static INLINE float 93z24_unorm_to_z32_float(uint32_t z) 94{ 95 const double scale = 1.0 / 0xffffff; 96 return (float)(z * scale); 97} 98 99static INLINE uint32_t 100z32_float_to_z32_unorm(float z) 101{ 102 const double scale = 0xffffffff; 103 return (uint32_t)(z * scale); 104} 105 106static INLINE float 107z32_unorm_to_z32_float(uint32_t z) 108{ 109 const double scale = 1.0 / 0xffffffff; 110 return (float)(z * scale); 111} 112 113 114void 115util_format_s8_uint_unpack_s_8uint(uint8_t *dst_row, unsigned dst_stride, 116 const uint8_t *src_row, unsigned src_stride, 117 unsigned width, unsigned height) 118{ 119 unsigned y; 120 for(y = 0; y < height; ++y) { 121 memcpy(dst_row, src_row, width); 122 src_row += src_stride/sizeof(*src_row); 123 dst_row += dst_stride/sizeof(*dst_row); 124 } 125} 126 127void 128util_format_s8_uint_pack_s_8uint(uint8_t *dst_row, unsigned dst_stride, 129 const uint8_t *src_row, unsigned src_stride, 130 unsigned width, unsigned height) 131{ 132 unsigned y; 133 for(y = 0; y < height; ++y) { 134 memcpy(dst_row, src_row, width); 135 src_row += src_stride/sizeof(*src_row); 136 dst_row += dst_stride/sizeof(*dst_row); 137 } 138} 139 140void 141util_format_z16_unorm_unpack_z_float(float *dst_row, unsigned dst_stride, 142 const uint8_t *src_row, unsigned src_stride, 143 unsigned width, unsigned height) 144{ 145 unsigned x, y; 146 for(y = 0; y < height; ++y) { 147 float *dst = dst_row; 148 const uint16_t *src = (const uint16_t *)src_row; 149 for(x = 0; x < width; ++x) { 150 uint16_t value = *src++; 151#ifdef PIPE_ARCH_BIG_ENDIAN 152 value = util_bswap16(value); 153#endif 154 *dst++ = z16_unorm_to_z32_float(value); 155 } 156 src_row += src_stride/sizeof(*src_row); 157 dst_row += dst_stride/sizeof(*dst_row); 158 } 159} 160 161void 162util_format_z16_unorm_pack_z_float(uint8_t *dst_row, unsigned dst_stride, 163 const float *src_row, unsigned src_stride, 164 unsigned width, unsigned height) 165{ 166 unsigned x, y; 167 for(y = 0; y < height; ++y) { 168 const float *src = src_row; 169 uint16_t *dst = (uint16_t *)dst_row; 170 for(x = 0; x < width; ++x) { 171 uint16_t value; 172 value = z32_float_to_z16_unorm(*src++); 173#ifdef PIPE_ARCH_BIG_ENDIAN 174 value = util_bswap16(value); 175#endif 176 *dst++ = value; 177 } 178 dst_row += dst_stride/sizeof(*dst_row); 179 src_row += src_stride/sizeof(*src_row); 180 } 181} 182 183void 184util_format_z16_unorm_unpack_z_32unorm(uint32_t *dst_row, unsigned dst_stride, 185 const uint8_t *src_row, unsigned src_stride, 186 unsigned width, unsigned height) 187{ 188 unsigned x, y; 189 for(y = 0; y < height; ++y) { 190 uint32_t *dst = dst_row; 191 const uint16_t *src = (const uint16_t *)src_row; 192 for(x = 0; x < width; ++x) { 193 uint16_t value = *src++; 194#ifdef PIPE_ARCH_BIG_ENDIAN 195 value = util_bswap16(value); 196#endif 197 *dst++ = z16_unorm_to_z32_unorm(value); 198 } 199 src_row += src_stride/sizeof(*src_row); 200 dst_row += dst_stride/sizeof(*dst_row); 201 } 202} 203 204void 205util_format_z16_unorm_pack_z_32unorm(uint8_t *dst_row, unsigned dst_stride, 206 const uint32_t *src_row, unsigned src_stride, 207 unsigned width, unsigned height) 208{ 209 unsigned x, y; 210 for(y = 0; y < height; ++y) { 211 const uint32_t *src = src_row; 212 uint16_t *dst = (uint16_t *)dst_row; 213 for(x = 0; x < width; ++x) { 214 uint16_t value; 215 value = z32_unorm_to_z16_unorm(*src++); 216#ifdef PIPE_ARCH_BIG_ENDIAN 217 value = util_bswap16(value); 218#endif 219 *dst++ = value; 220 } 221 dst_row += dst_stride/sizeof(*dst_row); 222 src_row += src_stride/sizeof(*src_row); 223 } 224} 225 226void 227util_format_z32_unorm_unpack_z_float(float *dst_row, unsigned dst_stride, 228 const uint8_t *src_row, unsigned src_stride, 229 unsigned width, unsigned height) 230{ 231 unsigned x, y; 232 for(y = 0; y < height; ++y) { 233 float *dst = dst_row; 234 const uint32_t *src = (const uint32_t *)src_row; 235 for(x = 0; x < width; ++x) { 236 uint32_t value = *src++; 237#ifdef PIPE_ARCH_BIG_ENDIAN 238 value = util_bswap32(value); 239#endif 240 *dst++ = z32_unorm_to_z32_float(value); 241 } 242 src_row += src_stride/sizeof(*src_row); 243 dst_row += dst_stride/sizeof(*dst_row); 244 } 245} 246 247void 248util_format_z32_unorm_pack_z_float(uint8_t *dst_row, unsigned dst_stride, 249 const float *src_row, unsigned src_stride, 250 unsigned width, unsigned height) 251{ 252 unsigned x, y; 253 for(y = 0; y < height; ++y) { 254 const float *src = src_row; 255 uint32_t *dst = (uint32_t *)dst_row; 256 for(x = 0; x < width; ++x) { 257 uint32_t value; 258 value = z32_float_to_z32_unorm(*src++); 259#ifdef PIPE_ARCH_BIG_ENDIAN 260 value = util_bswap32(value); 261#endif 262 *dst++ = value; 263 } 264 dst_row += dst_stride/sizeof(*dst_row); 265 src_row += src_stride/sizeof(*src_row); 266 } 267} 268 269void 270util_format_z32_unorm_unpack_z_32unorm(uint32_t *dst_row, unsigned dst_stride, 271 const uint8_t *src_row, unsigned src_stride, 272 unsigned width, unsigned height) 273{ 274 unsigned y; 275 for(y = 0; y < height; ++y) { 276 memcpy(dst_row, src_row, width * 4); 277 src_row += src_stride/sizeof(*src_row); 278 dst_row += dst_stride/sizeof(*dst_row); 279 } 280} 281 282void 283util_format_z32_unorm_pack_z_32unorm(uint8_t *dst_row, unsigned dst_stride, 284 const uint32_t *src_row, unsigned src_stride, 285 unsigned width, unsigned height) 286{ 287 unsigned y; 288 for(y = 0; y < height; ++y) { 289 memcpy(dst_row, src_row, width * 4); 290 src_row += src_stride/sizeof(*src_row); 291 dst_row += dst_stride/sizeof(*dst_row); 292 } 293} 294 295void 296util_format_z32_float_unpack_z_float(float *dst_row, unsigned dst_stride, 297 const uint8_t *src_row, unsigned src_stride, 298 unsigned width, unsigned height) 299{ 300 unsigned y; 301 for(y = 0; y < height; ++y) { 302 memcpy(dst_row, src_row, width * 4); 303 src_row += src_stride/sizeof(*src_row); 304 dst_row += dst_stride/sizeof(*dst_row); 305 } 306} 307 308void 309util_format_z32_float_pack_z_float(uint8_t *dst_row, unsigned dst_stride, 310 const float *src_row, unsigned src_stride, 311 unsigned width, unsigned height) 312{ 313 unsigned y; 314 for(y = 0; y < height; ++y) { 315 memcpy(dst_row, src_row, width * 4); 316 src_row += src_stride/sizeof(*src_row); 317 dst_row += dst_stride/sizeof(*dst_row); 318 } 319} 320 321void 322util_format_z32_float_unpack_z_32unorm(uint32_t *dst_row, unsigned dst_stride, 323 const uint8_t *src_row, unsigned src_stride, 324 unsigned width, unsigned height) 325{ 326 unsigned x, y; 327 for(y = 0; y < height; ++y) { 328 uint32_t *dst = dst_row; 329 const float *src = (const float *)src_row; 330 for(x = 0; x < width; ++x) { 331 *dst++ = z32_float_to_z32_unorm(*src++); 332 } 333 src_row += src_stride/sizeof(*src_row); 334 dst_row += dst_stride/sizeof(*dst_row); 335 } 336} 337 338void 339util_format_z32_float_pack_z_32unorm(uint8_t *dst_row, unsigned dst_stride, 340 const uint32_t *src_row, unsigned src_stride, 341 unsigned width, unsigned height) 342{ 343 unsigned x, y; 344 for(y = 0; y < height; ++y) { 345 const uint32_t *src = src_row; 346 float *dst = (float *)dst_row; 347 for(x = 0; x < width; ++x) { 348 *dst++ = z32_unorm_to_z32_float(*src++); 349 } 350 dst_row += dst_stride/sizeof(*dst_row); 351 src_row += src_stride/sizeof(*src_row); 352 } 353} 354 355void 356util_format_z24_unorm_s8_uint_unpack_z_float(float *dst_row, unsigned dst_stride, 357 const uint8_t *src_row, unsigned src_stride, 358 unsigned width, unsigned height) 359{ 360 unsigned x, y; 361 for(y = 0; y < height; ++y) { 362 float *dst = dst_row; 363 const uint32_t *src = (const uint32_t *)src_row; 364 for(x = 0; x < width; ++x) { 365 uint32_t value = *src++; 366#ifdef PIPE_ARCH_BIG_ENDIAN 367 value = util_bswap32(value); 368#endif 369 *dst++ = z24_unorm_to_z32_float(value & 0xffffff); 370 } 371 src_row += src_stride/sizeof(*src_row); 372 dst_row += dst_stride/sizeof(*dst_row); 373 } 374} 375 376void 377util_format_z24_unorm_s8_uint_pack_z_float(uint8_t *dst_row, unsigned dst_stride, 378 const float *src_row, unsigned src_stride, 379 unsigned width, unsigned height) 380{ 381 unsigned x, y; 382 for(y = 0; y < height; ++y) { 383 const float *src = src_row; 384 uint32_t *dst = (uint32_t *)dst_row; 385 for(x = 0; x < width; ++x) { 386 uint32_t value = *dst; 387#ifdef PIPE_ARCH_BIG_ENDIAN 388 value = util_bswap32(value); 389#endif 390 value &= 0xff000000; 391 value |= z32_float_to_z24_unorm(*src++); 392#ifdef PIPE_ARCH_BIG_ENDIAN 393 value = util_bswap32(value); 394#endif 395 *dst++ = value; 396 } 397 dst_row += dst_stride/sizeof(*dst_row); 398 src_row += src_stride/sizeof(*src_row); 399 } 400} 401 402void 403util_format_z24_unorm_s8_uint_unpack_z_32unorm(uint32_t *dst_row, unsigned dst_stride, 404 const uint8_t *src_row, unsigned src_stride, 405 unsigned width, unsigned height) 406{ 407 unsigned x, y; 408 for(y = 0; y < height; ++y) { 409 uint32_t *dst = dst_row; 410 const uint32_t *src = (const uint32_t *)src_row; 411 for(x = 0; x < width; ++x) { 412 uint32_t value = *src++; 413#ifdef PIPE_ARCH_BIG_ENDIAN 414 value = util_bswap32(value); 415#endif 416 *dst++ = z24_unorm_to_z32_unorm(value & 0xffffff); 417 } 418 src_row += src_stride/sizeof(*src_row); 419 dst_row += dst_stride/sizeof(*dst_row); 420 } 421} 422 423void 424util_format_z24_unorm_s8_uint_pack_z_32unorm(uint8_t *dst_row, unsigned dst_stride, 425 const uint32_t *src_row, unsigned src_stride, 426 unsigned width, unsigned height) 427{ 428 unsigned x, y; 429 for(y = 0; y < height; ++y) { 430 const uint32_t *src = src_row; 431 uint32_t *dst = (uint32_t *)dst_row; 432 for(x = 0; x < width; ++x) { 433 uint32_t value= *dst; 434#ifdef PIPE_ARCH_BIG_ENDIAN 435 value = util_bswap32(value); 436#endif 437 value &= 0xff000000; 438 value |= z32_unorm_to_z24_unorm(*src++); 439#ifdef PIPE_ARCH_BIG_ENDIAN 440 value = util_bswap32(value); 441#endif 442 *dst++ = value; 443 } 444 dst_row += dst_stride/sizeof(*dst_row); 445 src_row += src_stride/sizeof(*src_row); 446 } 447} 448 449void 450util_format_z24_unorm_s8_uint_unpack_s_8uint(uint8_t *dst_row, unsigned dst_stride, 451 const uint8_t *src_row, unsigned src_stride, 452 unsigned width, unsigned height) 453{ 454 unsigned x, y; 455 for(y = 0; y < height; ++y) { 456 uint8_t *dst = dst_row; 457 const uint32_t *src = (const uint32_t *)src_row; 458 for(x = 0; x < width; ++x) { 459 uint32_t value = *src++; 460#ifdef PIPE_ARCH_BIG_ENDIAN 461 value = util_bswap32(value); 462#endif 463 *dst++ = value >> 24; 464 } 465 src_row += src_stride/sizeof(*src_row); 466 dst_row += dst_stride/sizeof(*dst_row); 467 } 468} 469 470void 471util_format_z24_unorm_s8_uint_pack_s_8uint(uint8_t *dst_row, unsigned dst_stride, 472 const uint8_t *src_row, unsigned src_stride, 473 unsigned width, unsigned height) 474{ 475 unsigned x, y; 476 for(y = 0; y < height; ++y) { 477 const uint8_t *src = src_row; 478 uint32_t *dst = (uint32_t *)dst_row; 479 for(x = 0; x < width; ++x) { 480 uint32_t value = *dst; 481#ifdef PIPE_ARCH_BIG_ENDIAN 482 value = util_bswap32(value); 483#endif 484 value &= 0x00ffffff; 485 value |= *src++ << 24; 486#ifdef PIPE_ARCH_BIG_ENDIAN 487 value = util_bswap32(value); 488#endif 489 *dst++ = value; 490 } 491 dst_row += dst_stride/sizeof(*dst_row); 492 src_row += src_stride/sizeof(*src_row); 493 } 494} 495 496void 497util_format_s8_uint_z24_unorm_unpack_z_float(float *dst_row, unsigned dst_stride, 498 const uint8_t *src_row, unsigned src_stride, 499 unsigned width, unsigned height) 500{ 501 unsigned x, y; 502 for(y = 0; y < height; ++y) { 503 float *dst = dst_row; 504 const uint32_t *src = (const uint32_t *)src_row; 505 for(x = 0; x < width; ++x) { 506 uint32_t value = *src++; 507#ifdef PIPE_ARCH_BIG_ENDIAN 508 value = util_bswap32(value); 509#endif 510 *dst++ = z24_unorm_to_z32_float(value >> 8); 511 } 512 src_row += src_stride/sizeof(*src_row); 513 dst_row += dst_stride/sizeof(*dst_row); 514 } 515} 516 517void 518util_format_s8_uint_z24_unorm_pack_z_float(uint8_t *dst_row, unsigned dst_stride, 519 const float *src_row, unsigned src_stride, 520 unsigned width, unsigned height) 521{ 522 unsigned x, y; 523 for(y = 0; y < height; ++y) { 524 const float *src = src_row; 525 uint32_t *dst = (uint32_t *)dst_row; 526 for(x = 0; x < width; ++x) { 527 uint32_t value = *dst; 528#ifdef PIPE_ARCH_BIG_ENDIAN 529 value = util_bswap32(value); 530#endif 531 value &= 0x000000ff; 532 value |= z32_float_to_z24_unorm(*src++) << 8; 533#ifdef PIPE_ARCH_BIG_ENDIAN 534 value = util_bswap32(value); 535#endif 536 *dst++ = value; 537 } 538 dst_row += dst_stride/sizeof(*dst_row); 539 src_row += src_stride/sizeof(*src_row); 540 } 541} 542 543void 544util_format_s8_uint_z24_unorm_unpack_z_32unorm(uint32_t *dst_row, unsigned dst_stride, 545 const uint8_t *src_row, unsigned src_stride, 546 unsigned width, unsigned height) 547{ 548 unsigned x, y; 549 for(y = 0; y < height; ++y) { 550 uint32_t *dst = dst_row; 551 const uint32_t *src = (const uint32_t *)src_row; 552 for(x = 0; x < width; ++x) { 553 uint32_t value = *src++; 554#ifdef PIPE_ARCH_BIG_ENDIAN 555 value = util_bswap32(value); 556#endif 557 *dst++ = z24_unorm_to_z32_unorm(value >> 8); 558 } 559 src_row += src_stride/sizeof(*src_row); 560 dst_row += dst_stride/sizeof(*dst_row); 561 } 562} 563 564void 565util_format_s8_uint_z24_unorm_pack_z_32unorm(uint8_t *dst_row, unsigned dst_stride, 566 const uint32_t *src_row, unsigned src_stride, 567 unsigned width, unsigned height) 568{ 569 unsigned x, y; 570 for(y = 0; y < height; ++y) { 571 const uint32_t *src = src_row; 572 uint32_t *dst = (uint32_t *)dst_row; 573 for(x = 0; x < width; ++x) { 574 uint32_t value = *dst; 575#ifdef PIPE_ARCH_BIG_ENDIAN 576 value = util_bswap32(value); 577#endif 578 value &= 0x000000ff; 579 value |= *src++ & 0xffffff00; 580#ifdef PIPE_ARCH_BIG_ENDIAN 581 value = util_bswap32(value); 582#endif 583 *dst++ = value; 584 } 585 dst_row += dst_stride/sizeof(*dst_row); 586 src_row += src_stride/sizeof(*src_row); 587 } 588} 589 590void 591util_format_s8_uint_z24_unorm_unpack_s_8uint(uint8_t *dst_row, unsigned dst_stride, 592 const uint8_t *src_row, unsigned src_stride, 593 unsigned width, unsigned height) 594{ 595 unsigned x, y; 596 for(y = 0; y < height; ++y) { 597 uint8_t *dst = dst_row; 598 const uint32_t *src = (const uint32_t *)src_row; 599 for(x = 0; x < width; ++x) { 600 uint32_t value = *src++; 601#ifdef PIPE_ARCH_BIG_ENDIAN 602 value = util_bswap32(value); 603#endif 604 *dst++ = value & 0xff; 605 } 606 src_row += src_stride/sizeof(*src_row); 607 dst_row += dst_stride/sizeof(*dst_row); 608 } 609} 610 611void 612util_format_s8_uint_z24_unorm_pack_s_8uint(uint8_t *dst_row, unsigned dst_stride, 613 const uint8_t *src_row, unsigned src_stride, 614 unsigned width, unsigned height) 615{ 616 unsigned x, y; 617 for(y = 0; y < height; ++y) { 618 const uint8_t *src = src_row; 619 uint32_t *dst = (uint32_t *)dst_row; 620 for(x = 0; x < width; ++x) { 621 uint32_t value = *dst; 622#ifdef PIPE_ARCH_BIG_ENDIAN 623 value = util_bswap32(value); 624#endif 625 value &= 0xffffff00; 626 value |= *src++; 627#ifdef PIPE_ARCH_BIG_ENDIAN 628 value = util_bswap32(value); 629#endif 630 *dst++ = value; 631 } 632 dst_row += dst_stride/sizeof(*dst_row); 633 src_row += src_stride/sizeof(*src_row); 634 } 635} 636 637void 638util_format_z24x8_unorm_unpack_z_float(float *dst_row, unsigned dst_stride, 639 const uint8_t *src_row, unsigned src_stride, 640 unsigned width, unsigned height) 641{ 642 unsigned x, y; 643 for(y = 0; y < height; ++y) { 644 float *dst = dst_row; 645 const uint32_t *src = (const uint32_t *)src_row; 646 for(x = 0; x < width; ++x) { 647 uint32_t value = *src++; 648#ifdef PIPE_ARCH_BIG_ENDIAN 649 value = util_bswap32(value); 650#endif 651 *dst++ = z24_unorm_to_z32_float(value & 0xffffff); 652 } 653 src_row += src_stride/sizeof(*src_row); 654 dst_row += dst_stride/sizeof(*dst_row); 655 } 656} 657 658void 659util_format_z24x8_unorm_pack_z_float(uint8_t *dst_row, unsigned dst_stride, 660 const float *src_row, unsigned src_stride, 661 unsigned width, unsigned height) 662{ 663 unsigned x, y; 664 for(y = 0; y < height; ++y) { 665 const float *src = src_row; 666 uint32_t *dst = (uint32_t *)dst_row; 667 for(x = 0; x < width; ++x) { 668 uint32_t value; 669 value = z32_float_to_z24_unorm(*src++); 670#ifdef PIPE_ARCH_BIG_ENDIAN 671 value = util_bswap32(value); 672#endif 673 *dst++ = value; 674 } 675 dst_row += dst_stride/sizeof(*dst_row); 676 src_row += src_stride/sizeof(*src_row); 677 } 678} 679 680void 681util_format_z24x8_unorm_unpack_z_32unorm(uint32_t *dst_row, unsigned dst_stride, 682 const uint8_t *src_row, unsigned src_stride, 683 unsigned width, unsigned height) 684{ 685 unsigned x, y; 686 for(y = 0; y < height; ++y) { 687 uint32_t *dst = dst_row; 688 const uint32_t *src = (const uint32_t *)src_row; 689 for(x = 0; x < width; ++x) { 690 uint32_t value = *src++; 691#ifdef PIPE_ARCH_BIG_ENDIAN 692 value = util_bswap32(value); 693#endif 694 *dst++ = z24_unorm_to_z32_unorm(value & 0xffffff); 695 } 696 src_row += src_stride/sizeof(*src_row); 697 dst_row += dst_stride/sizeof(*dst_row); 698 } 699} 700 701void 702util_format_z24x8_unorm_pack_z_32unorm(uint8_t *dst_row, unsigned dst_stride, 703 const uint32_t *src_row, unsigned src_stride, 704 unsigned width, unsigned height) 705{ 706 unsigned x, y; 707 for(y = 0; y < height; ++y) { 708 const uint32_t *src = src_row; 709 uint32_t *dst = (uint32_t *)dst_row; 710 for(x = 0; x < width; ++x) { 711 uint32_t value; 712 value = z32_unorm_to_z24_unorm(*src++); 713#ifdef PIPE_ARCH_BIG_ENDIAN 714 value = util_bswap32(value); 715#endif 716 *dst++ = value; 717 } 718 dst_row += dst_stride/sizeof(*dst_row); 719 src_row += src_stride/sizeof(*src_row); 720 } 721} 722 723void 724util_format_x8z24_unorm_unpack_z_float(float *dst_row, unsigned dst_stride, 725 const uint8_t *src_row, unsigned src_stride, 726 unsigned width, unsigned height) 727{ 728 unsigned x, y; 729 for(y = 0; y < height; ++y) { 730 float *dst = dst_row; 731 const uint32_t *src = (uint32_t *)src_row; 732 for(x = 0; x < width; ++x) { 733 uint32_t value = *src++; 734#ifdef PIPE_ARCH_BIG_ENDIAN 735 value = util_bswap32(value); 736#endif 737 *dst++ = z24_unorm_to_z32_float(value >> 8); 738 } 739 src_row += src_stride/sizeof(*src_row); 740 dst_row += dst_stride/sizeof(*dst_row); 741 } 742} 743 744void 745util_format_x8z24_unorm_pack_z_float(uint8_t *dst_row, unsigned dst_stride, 746 const float *src_row, unsigned src_stride, 747 unsigned width, unsigned height) 748{ 749 unsigned x, y; 750 for(y = 0; y < height; ++y) { 751 const float *src = src_row; 752 uint32_t *dst = (uint32_t *)dst_row; 753 for(x = 0; x < width; ++x) { 754 uint32_t value; 755 value = z32_float_to_z24_unorm(*src++) << 8; 756#ifdef PIPE_ARCH_BIG_ENDIAN 757 value = util_bswap32(value); 758#endif 759 *dst++ = value; 760 } 761 dst_row += dst_stride/sizeof(*dst_row); 762 src_row += src_stride/sizeof(*src_row); 763 } 764} 765 766void 767util_format_x8z24_unorm_unpack_z_32unorm(uint32_t *dst_row, unsigned dst_stride, 768 const uint8_t *src_row, unsigned src_stride, 769 unsigned width, unsigned height) 770{ 771 unsigned x, y; 772 for(y = 0; y < height; ++y) { 773 uint32_t *dst = dst_row; 774 const uint32_t *src = (const uint32_t *)src_row; 775 for(x = 0; x < width; ++x) { 776 uint32_t value = *src++; 777#ifdef PIPE_ARCH_BIG_ENDIAN 778 value = util_bswap32(value); 779#endif 780 *dst++ = z24_unorm_to_z32_unorm(value >> 8); 781 } 782 src_row += src_stride/sizeof(*src_row); 783 dst_row += dst_stride/sizeof(*dst_row); 784 } 785} 786 787void 788util_format_x8z24_unorm_pack_z_32unorm(uint8_t *dst_row, unsigned dst_stride, 789 const uint32_t *src_row, unsigned src_stride, 790 unsigned width, unsigned height) 791{ 792 unsigned x, y; 793 for(y = 0; y < height; ++y) { 794 const uint32_t *src = src_row; 795 uint32_t *dst = (uint32_t *)dst_row; 796 for(x = 0; x < width; ++x) { 797 uint32_t value; 798 value = z32_unorm_to_z24_unorm(*src++) << 8; 799#ifdef PIPE_ARCH_BIG_ENDIAN 800 value = util_bswap32(value); 801#endif 802 *dst++ = value; 803 } 804 dst_row += dst_stride/sizeof(*dst_row); 805 src_row += src_stride/sizeof(*src_row); 806 } 807} 808 809void 810util_format_z32_float_s8x24_uint_unpack_z_float(float *dst_row, unsigned dst_stride, 811 const uint8_t *src_row, unsigned src_stride, 812 unsigned width, unsigned height) 813{ 814 unsigned x, y; 815 for(y = 0; y < height; ++y) { 816 float *dst = dst_row; 817 const float *src = (const float *)src_row; 818 for(x = 0; x < width; ++x) { 819 *dst = *src; 820 src += 2; 821 dst += 1; 822 } 823 src_row += src_stride/sizeof(*src_row); 824 dst_row += dst_stride/sizeof(*dst_row); 825 } 826} 827 828void 829util_format_z32_float_s8x24_uint_pack_z_float(uint8_t *dst_row, unsigned dst_stride, 830 const float *src_row, unsigned src_stride, 831 unsigned width, unsigned height) 832{ 833 unsigned x, y; 834 for(y = 0; y < height; ++y) { 835 const float *src = src_row; 836 float *dst = (float *)dst_row; 837 for(x = 0; x < width; ++x) { 838 *dst = *src; 839 src += 1; 840 dst += 2; 841 } 842 dst_row += dst_stride/sizeof(*dst_row); 843 src_row += src_stride/sizeof(*src_row); 844 } 845} 846 847void 848util_format_z32_float_s8x24_uint_unpack_z_32unorm(uint32_t *dst_row, unsigned dst_stride, 849 const uint8_t *src_row, unsigned src_stride, 850 unsigned width, unsigned height) 851{ 852 unsigned x, y; 853 for(y = 0; y < height; ++y) { 854 uint32_t *dst = dst_row; 855 const float *src = (const float *)src_row; 856 for(x = 0; x < width; ++x) { 857 *dst = z32_float_to_z32_unorm(*src); 858 src += 2; 859 dst += 1; 860 } 861 src_row += src_stride/sizeof(*src_row); 862 dst_row += dst_stride/sizeof(*dst_row); 863 } 864} 865 866void 867util_format_z32_float_s8x24_uint_pack_z_32unorm(uint8_t *dst_row, unsigned dst_stride, 868 const uint32_t *src_row, unsigned src_stride, 869 unsigned width, unsigned height) 870{ 871 unsigned x, y; 872 for(y = 0; y < height; ++y) { 873 const uint32_t *src = src_row; 874 float *dst = (float *)dst_row; 875 for(x = 0; x < width; ++x) { 876 *dst++ = z32_unorm_to_z32_float(*src++); 877 } 878 dst_row += dst_stride/sizeof(*dst_row); 879 src_row += src_stride/sizeof(*src_row); 880 } 881} 882 883void 884util_format_z32_float_s8x24_uint_unpack_s_8uint(uint8_t *dst_row, unsigned dst_stride, 885 const uint8_t *src_row, unsigned src_stride, 886 unsigned width, unsigned height) 887{ 888 unsigned x, y; 889 for(y = 0; y < height; ++y) { 890 uint8_t *dst = dst_row; 891 const uint8_t *src = src_row + 4; 892 for(x = 0; x < width; ++x) { 893 *dst = *src; 894 src += 8; 895 dst += 1; 896 } 897 src_row += src_stride/sizeof(*src_row); 898 dst_row += dst_stride/sizeof(*dst_row); 899 } 900} 901 902void 903util_format_z32_float_s8x24_uint_pack_s_8uint(uint8_t *dst_row, unsigned dst_stride, 904 const uint8_t *src_row, unsigned src_stride, 905 unsigned width, unsigned height) 906{ 907 unsigned x, y; 908 for(y = 0; y < height; ++y) { 909 const uint8_t *src = src_row; 910 uint8_t *dst = dst_row + 4; 911 for(x = 0; x < width; ++x) { 912 *dst = *src; 913 src += 1; 914 dst += 8; 915 } 916 dst_row += dst_stride/sizeof(*dst_row); 917 src_row += src_stride/sizeof(*src_row); 918 } 919} 920 921 922void 923util_format_x24s8_uint_unpack_s_8uint(uint8_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height) 924{ 925 util_format_z24_unorm_s8_uint_unpack_s_8uint(dst_row, dst_stride, 926 src_row, src_stride, 927 width, height); 928} 929 930void 931util_format_x24s8_uint_pack_s_8uint(uint8_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height) 932{ 933 util_format_z24_unorm_s8_uint_pack_s_8uint(dst_row, dst_stride, 934 src_row, src_stride, 935 width, height); 936} 937 938void 939util_format_s8x24_uint_unpack_s_8uint(uint8_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height) 940{ 941 util_format_s8_uint_z24_unorm_unpack_s_8uint(dst_row, dst_stride, 942 src_row, src_stride, 943 width, height); 944} 945 946void 947util_format_s8x24_uint_pack_s_8uint(uint8_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height) 948{ 949 util_format_s8_uint_z24_unorm_pack_s_8uint(dst_row, dst_stride, 950 src_row, src_stride, 951 width, height); 952} 953 954void 955util_format_x32_s8x24_uint_unpack_s_8uint(uint8_t *dst_row, unsigned dst_stride, 956 const uint8_t *src_row, unsigned src_stride, 957 unsigned width, unsigned height) 958{ 959 util_format_z32_float_s8x24_uint_unpack_s_8uint(dst_row, dst_stride, 960 src_row, src_stride, 961 width, height); 962 963} 964 965void 966util_format_x32_s8x24_uint_pack_s_8uint(uint8_t *dst_row, unsigned dst_stride, 967 const uint8_t *src_row, unsigned src_stride, 968 unsigned width, unsigned height) 969{ 970 util_format_z32_float_s8x24_uint_pack_s_8uint(dst_row, dst_stride, 971 src_row, src_stride, 972 width, height); 973} 974