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 38 static inline uint16_t 39 z32_unorm_to_z16_unorm(uint32_t z) 40 { 41 /* z * 0xffff / 0xffffffff */ 42 return z >> 16; 43 } 44 45 static inline uint32_t 46 z16_unorm_to_z32_unorm(uint16_t z) 47 { 48 /* z * 0xffffffff / 0xffff */ 49 return (z << 16) | z; 50 } 51 52 static inline uint32_t 53 z32_unorm_to_z24_unorm(uint32_t z) 54 { 55 /* z * 0xffffff / 0xffffffff */ 56 return z >> 8; 57 } 58 59 static inline uint32_t 60 z24_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 71 static inline uint16_t 72 z32_float_to_z16_unorm(float z) 73 { 74 const float scale = 0xffff; 75 return (uint16_t)(z * scale + 0.5f); 76 } 77 78 static inline float 79 z16_unorm_to_z32_float(uint16_t z) 80 { 81 const float scale = 1.0 / 0xffff; 82 return (float)(z * scale); 83 } 84 85 static inline uint32_t 86 z32_float_to_z24_unorm(float z) 87 { 88 const double scale = 0xffffff; 89 return (uint32_t)(z * scale) & 0xffffff; 90 } 91 92 static inline float 93 z24_unorm_to_z32_float(uint32_t z) 94 { 95 const double scale = 1.0 / 0xffffff; 96 return (float)(z * scale); 97 } 98 99 static inline uint32_t 100 z32_float_to_z32_unorm(float z) 101 { 102 const double scale = 0xffffffff; 103 return (uint32_t)(z * scale); 104 } 105 106 static inline float 107 z32_unorm_to_z32_float(uint32_t z) 108 { 109 const double scale = 1.0 / 0xffffffff; 110 return (float)(z * scale); 111 } 112 113 114 void 115 util_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 127 void 128 util_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 140 void 141 util_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 = util_cpu_to_le16(*src++); 151 *dst++ = z16_unorm_to_z32_float(value); 152 } 153 src_row += src_stride/sizeof(*src_row); 154 dst_row += dst_stride/sizeof(*dst_row); 155 } 156 } 157 158 void 159 util_format_z16_unorm_pack_z_float(uint8_t *dst_row, unsigned dst_stride, 160 const float *src_row, unsigned src_stride, 161 unsigned width, unsigned height) 162 { 163 unsigned x, y; 164 for(y = 0; y < height; ++y) { 165 const float *src = src_row; 166 uint16_t *dst = (uint16_t *)dst_row; 167 for(x = 0; x < width; ++x) { 168 uint16_t value; 169 value = z32_float_to_z16_unorm(*src++); 170 *dst++ = util_le16_to_cpu(value); 171 } 172 dst_row += dst_stride/sizeof(*dst_row); 173 src_row += src_stride/sizeof(*src_row); 174 } 175 } 176 177 void 178 util_format_z16_unorm_unpack_z_32unorm(uint32_t *dst_row, unsigned dst_stride, 179 const uint8_t *src_row, unsigned src_stride, 180 unsigned width, unsigned height) 181 { 182 unsigned x, y; 183 for(y = 0; y < height; ++y) { 184 uint32_t *dst = dst_row; 185 const uint16_t *src = (const uint16_t *)src_row; 186 for(x = 0; x < width; ++x) { 187 uint16_t value = util_cpu_to_le16(*src++); 188 *dst++ = z16_unorm_to_z32_unorm(value); 189 } 190 src_row += src_stride/sizeof(*src_row); 191 dst_row += dst_stride/sizeof(*dst_row); 192 } 193 } 194 195 void 196 util_format_z16_unorm_pack_z_32unorm(uint8_t *dst_row, unsigned dst_stride, 197 const uint32_t *src_row, unsigned src_stride, 198 unsigned width, unsigned height) 199 { 200 unsigned x, y; 201 for(y = 0; y < height; ++y) { 202 const uint32_t *src = src_row; 203 uint16_t *dst = (uint16_t *)dst_row; 204 for(x = 0; x < width; ++x) { 205 uint16_t value; 206 value = z32_unorm_to_z16_unorm(*src++); 207 *dst++ = util_le16_to_cpu(value); 208 } 209 dst_row += dst_stride/sizeof(*dst_row); 210 src_row += src_stride/sizeof(*src_row); 211 } 212 } 213 214 void 215 util_format_z32_unorm_unpack_z_float(float *dst_row, unsigned dst_stride, 216 const uint8_t *src_row, unsigned src_stride, 217 unsigned width, unsigned height) 218 { 219 unsigned x, y; 220 for(y = 0; y < height; ++y) { 221 float *dst = dst_row; 222 const uint32_t *src = (const uint32_t *)src_row; 223 for(x = 0; x < width; ++x) { 224 uint32_t value = util_cpu_to_le32(*src++); 225 *dst++ = z32_unorm_to_z32_float(value); 226 } 227 src_row += src_stride/sizeof(*src_row); 228 dst_row += dst_stride/sizeof(*dst_row); 229 } 230 } 231 232 void 233 util_format_z32_unorm_pack_z_float(uint8_t *dst_row, unsigned dst_stride, 234 const float *src_row, unsigned src_stride, 235 unsigned width, unsigned height) 236 { 237 unsigned x, y; 238 for(y = 0; y < height; ++y) { 239 const float *src = src_row; 240 uint32_t *dst = (uint32_t *)dst_row; 241 for(x = 0; x < width; ++x) { 242 uint32_t value; 243 value = z32_float_to_z32_unorm(*src++); 244 *dst++ = util_le32_to_cpu(value); 245 } 246 dst_row += dst_stride/sizeof(*dst_row); 247 src_row += src_stride/sizeof(*src_row); 248 } 249 } 250 251 void 252 util_format_z32_unorm_unpack_z_32unorm(uint32_t *dst_row, unsigned dst_stride, 253 const uint8_t *src_row, unsigned src_stride, 254 unsigned width, unsigned height) 255 { 256 unsigned y; 257 for(y = 0; y < height; ++y) { 258 memcpy(dst_row, src_row, width * 4); 259 src_row += src_stride/sizeof(*src_row); 260 dst_row += dst_stride/sizeof(*dst_row); 261 } 262 } 263 264 void 265 util_format_z32_unorm_pack_z_32unorm(uint8_t *dst_row, unsigned dst_stride, 266 const uint32_t *src_row, unsigned src_stride, 267 unsigned width, unsigned height) 268 { 269 unsigned y; 270 for(y = 0; y < height; ++y) { 271 memcpy(dst_row, src_row, width * 4); 272 src_row += src_stride/sizeof(*src_row); 273 dst_row += dst_stride/sizeof(*dst_row); 274 } 275 } 276 277 void 278 util_format_z32_float_unpack_z_float(float *dst_row, unsigned dst_stride, 279 const uint8_t *src_row, unsigned src_stride, 280 unsigned width, unsigned height) 281 { 282 unsigned y; 283 for(y = 0; y < height; ++y) { 284 memcpy(dst_row, src_row, width * 4); 285 src_row += src_stride/sizeof(*src_row); 286 dst_row += dst_stride/sizeof(*dst_row); 287 } 288 } 289 290 void 291 util_format_z32_float_pack_z_float(uint8_t *dst_row, unsigned dst_stride, 292 const float *src_row, unsigned src_stride, 293 unsigned width, unsigned height) 294 { 295 unsigned y; 296 for(y = 0; y < height; ++y) { 297 memcpy(dst_row, src_row, width * 4); 298 src_row += src_stride/sizeof(*src_row); 299 dst_row += dst_stride/sizeof(*dst_row); 300 } 301 } 302 303 void 304 util_format_z32_float_unpack_z_32unorm(uint32_t *dst_row, unsigned dst_stride, 305 const uint8_t *src_row, unsigned src_stride, 306 unsigned width, unsigned height) 307 { 308 unsigned x, y; 309 for(y = 0; y < height; ++y) { 310 uint32_t *dst = dst_row; 311 const float *src = (const float *)src_row; 312 for(x = 0; x < width; ++x) { 313 *dst++ = z32_float_to_z32_unorm(*src++); 314 } 315 src_row += src_stride/sizeof(*src_row); 316 dst_row += dst_stride/sizeof(*dst_row); 317 } 318 } 319 320 void 321 util_format_z32_float_pack_z_32unorm(uint8_t *dst_row, unsigned dst_stride, 322 const uint32_t *src_row, unsigned src_stride, 323 unsigned width, unsigned height) 324 { 325 unsigned x, y; 326 for(y = 0; y < height; ++y) { 327 const uint32_t *src = src_row; 328 float *dst = (float *)dst_row; 329 for(x = 0; x < width; ++x) { 330 *dst++ = z32_unorm_to_z32_float(*src++); 331 } 332 dst_row += dst_stride/sizeof(*dst_row); 333 src_row += src_stride/sizeof(*src_row); 334 } 335 } 336 337 void 338 util_format_z24_unorm_s8_uint_unpack_z_float(float *dst_row, unsigned dst_stride, 339 const uint8_t *src_row, unsigned src_stride, 340 unsigned width, unsigned height) 341 { 342 unsigned x, y; 343 for(y = 0; y < height; ++y) { 344 float *dst = dst_row; 345 const uint32_t *src = (const uint32_t *)src_row; 346 for(x = 0; x < width; ++x) { 347 uint32_t value = util_cpu_to_le32(*src++); 348 *dst++ = z24_unorm_to_z32_float(value & 0xffffff); 349 } 350 src_row += src_stride/sizeof(*src_row); 351 dst_row += dst_stride/sizeof(*dst_row); 352 } 353 } 354 355 void 356 util_format_z24_unorm_s8_uint_pack_z_float(uint8_t *dst_row, unsigned dst_stride, 357 const float *src_row, unsigned src_stride, 358 unsigned width, unsigned height) 359 { 360 unsigned x, y; 361 for(y = 0; y < height; ++y) { 362 const float *src = src_row; 363 uint32_t *dst = (uint32_t *)dst_row; 364 for(x = 0; x < width; ++x) { 365 uint32_t value = util_le32_to_cpu(*dst); 366 value &= 0xff000000; 367 value |= z32_float_to_z24_unorm(*src++); 368 *dst++ = util_cpu_to_le32(value); 369 } 370 dst_row += dst_stride/sizeof(*dst_row); 371 src_row += src_stride/sizeof(*src_row); 372 } 373 } 374 375 void 376 util_format_z24_unorm_s8_uint_unpack_z_32unorm(uint32_t *dst_row, unsigned dst_stride, 377 const uint8_t *src_row, unsigned src_stride, 378 unsigned width, unsigned height) 379 { 380 unsigned x, y; 381 for(y = 0; y < height; ++y) { 382 uint32_t *dst = dst_row; 383 const uint32_t *src = (const uint32_t *)src_row; 384 for(x = 0; x < width; ++x) { 385 uint32_t value = util_cpu_to_le32(*src++); 386 *dst++ = z24_unorm_to_z32_unorm(value & 0xffffff); 387 } 388 src_row += src_stride/sizeof(*src_row); 389 dst_row += dst_stride/sizeof(*dst_row); 390 } 391 } 392 393 void 394 util_format_z24_unorm_s8_uint_pack_z_32unorm(uint8_t *dst_row, unsigned dst_stride, 395 const uint32_t *src_row, unsigned src_stride, 396 unsigned width, unsigned height) 397 { 398 unsigned x, y; 399 for(y = 0; y < height; ++y) { 400 const uint32_t *src = src_row; 401 uint32_t *dst = (uint32_t *)dst_row; 402 for(x = 0; x < width; ++x) { 403 uint32_t value = util_le32_to_cpu(*dst); 404 value &= 0xff000000; 405 value |= z32_unorm_to_z24_unorm(*src++); 406 *dst++ = util_cpu_to_le32(value); 407 } 408 dst_row += dst_stride/sizeof(*dst_row); 409 src_row += src_stride/sizeof(*src_row); 410 } 411 } 412 413 void 414 util_format_z24_unorm_s8_uint_unpack_s_8uint(uint8_t *dst_row, unsigned dst_stride, 415 const uint8_t *src_row, unsigned src_stride, 416 unsigned width, unsigned height) 417 { 418 unsigned x, y; 419 for(y = 0; y < height; ++y) { 420 uint8_t *dst = dst_row; 421 const uint32_t *src = (const uint32_t *)src_row; 422 for(x = 0; x < width; ++x) { 423 uint32_t value = util_cpu_to_le32(*src++); 424 *dst++ = value >> 24; 425 } 426 src_row += src_stride/sizeof(*src_row); 427 dst_row += dst_stride/sizeof(*dst_row); 428 } 429 } 430 431 void 432 util_format_z24_unorm_s8_uint_pack_s_8uint(uint8_t *dst_row, unsigned dst_stride, 433 const uint8_t *src_row, unsigned src_stride, 434 unsigned width, unsigned height) 435 { 436 unsigned x, y; 437 for(y = 0; y < height; ++y) { 438 const uint8_t *src = src_row; 439 uint32_t *dst = (uint32_t *)dst_row; 440 for(x = 0; x < width; ++x) { 441 uint32_t value = util_le32_to_cpu(*dst); 442 value &= 0x00ffffff; 443 value |= *src++ << 24; 444 *dst++ = util_cpu_to_le32(value); 445 } 446 dst_row += dst_stride/sizeof(*dst_row); 447 src_row += src_stride/sizeof(*src_row); 448 } 449 } 450 451 void 452 util_format_s8_uint_z24_unorm_unpack_z_float(float *dst_row, unsigned dst_stride, 453 const uint8_t *src_row, unsigned src_stride, 454 unsigned width, unsigned height) 455 { 456 unsigned x, y; 457 for(y = 0; y < height; ++y) { 458 float *dst = dst_row; 459 const uint32_t *src = (const uint32_t *)src_row; 460 for(x = 0; x < width; ++x) { 461 uint32_t value = util_cpu_to_le32(*src++); 462 *dst++ = z24_unorm_to_z32_float(value >> 8); 463 } 464 src_row += src_stride/sizeof(*src_row); 465 dst_row += dst_stride/sizeof(*dst_row); 466 } 467 } 468 469 void 470 util_format_s8_uint_z24_unorm_pack_z_float(uint8_t *dst_row, unsigned dst_stride, 471 const float *src_row, unsigned src_stride, 472 unsigned width, unsigned height) 473 { 474 unsigned x, y; 475 for(y = 0; y < height; ++y) { 476 const float *src = src_row; 477 uint32_t *dst = (uint32_t *)dst_row; 478 for(x = 0; x < width; ++x) { 479 uint32_t value = util_le32_to_cpu(*dst); 480 value &= 0x000000ff; 481 value |= z32_float_to_z24_unorm(*src++) << 8; 482 *dst++ = util_cpu_to_le32(value); 483 } 484 dst_row += dst_stride/sizeof(*dst_row); 485 src_row += src_stride/sizeof(*src_row); 486 } 487 } 488 489 void 490 util_format_s8_uint_z24_unorm_unpack_z_32unorm(uint32_t *dst_row, unsigned dst_stride, 491 const uint8_t *src_row, unsigned src_stride, 492 unsigned width, unsigned height) 493 { 494 unsigned x, y; 495 for(y = 0; y < height; ++y) { 496 uint32_t *dst = dst_row; 497 const uint32_t *src = (const uint32_t *)src_row; 498 for(x = 0; x < width; ++x) { 499 uint32_t value = util_cpu_to_le32(*src++); 500 *dst++ = z24_unorm_to_z32_unorm(value >> 8); 501 } 502 src_row += src_stride/sizeof(*src_row); 503 dst_row += dst_stride/sizeof(*dst_row); 504 } 505 } 506 507 void 508 util_format_s8_uint_z24_unorm_pack_z_32unorm(uint8_t *dst_row, unsigned dst_stride, 509 const uint32_t *src_row, unsigned src_stride, 510 unsigned width, unsigned height) 511 { 512 unsigned x, y; 513 for(y = 0; y < height; ++y) { 514 const uint32_t *src = src_row; 515 uint32_t *dst = (uint32_t *)dst_row; 516 for(x = 0; x < width; ++x) { 517 uint32_t value = util_le32_to_cpu(*dst); 518 value &= 0x000000ff; 519 value |= *src++ & 0xffffff00; 520 *dst++ = util_cpu_to_le32(value); 521 } 522 dst_row += dst_stride/sizeof(*dst_row); 523 src_row += src_stride/sizeof(*src_row); 524 } 525 } 526 527 void 528 util_format_s8_uint_z24_unorm_unpack_s_8uint(uint8_t *dst_row, unsigned dst_stride, 529 const uint8_t *src_row, unsigned src_stride, 530 unsigned width, unsigned height) 531 { 532 unsigned x, y; 533 for(y = 0; y < height; ++y) { 534 uint8_t *dst = dst_row; 535 const uint32_t *src = (const uint32_t *)src_row; 536 for(x = 0; x < width; ++x) { 537 uint32_t value = util_cpu_to_le32(*src++); 538 *dst++ = value & 0xff; 539 } 540 src_row += src_stride/sizeof(*src_row); 541 dst_row += dst_stride/sizeof(*dst_row); 542 } 543 } 544 545 void 546 util_format_s8_uint_z24_unorm_pack_s_8uint(uint8_t *dst_row, unsigned dst_stride, 547 const uint8_t *src_row, unsigned src_stride, 548 unsigned width, unsigned height) 549 { 550 unsigned x, y; 551 for(y = 0; y < height; ++y) { 552 const uint8_t *src = src_row; 553 uint32_t *dst = (uint32_t *)dst_row; 554 for(x = 0; x < width; ++x) { 555 uint32_t value = util_le32_to_cpu(*dst); 556 value &= 0xffffff00; 557 value |= *src++; 558 *dst++ = util_cpu_to_le32(value); 559 } 560 dst_row += dst_stride/sizeof(*dst_row); 561 src_row += src_stride/sizeof(*src_row); 562 } 563 } 564 565 void 566 util_format_z24x8_unorm_unpack_z_float(float *dst_row, unsigned dst_stride, 567 const uint8_t *src_row, unsigned src_stride, 568 unsigned width, unsigned height) 569 { 570 unsigned x, y; 571 for(y = 0; y < height; ++y) { 572 float *dst = dst_row; 573 const uint32_t *src = (const uint32_t *)src_row; 574 for(x = 0; x < width; ++x) { 575 uint32_t value = util_cpu_to_le32(*src++); 576 *dst++ = z24_unorm_to_z32_float(value & 0xffffff); 577 } 578 src_row += src_stride/sizeof(*src_row); 579 dst_row += dst_stride/sizeof(*dst_row); 580 } 581 } 582 583 void 584 util_format_z24x8_unorm_pack_z_float(uint8_t *dst_row, unsigned dst_stride, 585 const float *src_row, unsigned src_stride, 586 unsigned width, unsigned height) 587 { 588 unsigned x, y; 589 for(y = 0; y < height; ++y) { 590 const float *src = src_row; 591 uint32_t *dst = (uint32_t *)dst_row; 592 for(x = 0; x < width; ++x) { 593 uint32_t value; 594 value = z32_float_to_z24_unorm(*src++); 595 *dst++ = util_le32_to_cpu(value); 596 } 597 dst_row += dst_stride/sizeof(*dst_row); 598 src_row += src_stride/sizeof(*src_row); 599 } 600 } 601 602 void 603 util_format_z24x8_unorm_unpack_z_32unorm(uint32_t *dst_row, unsigned dst_stride, 604 const uint8_t *src_row, unsigned src_stride, 605 unsigned width, unsigned height) 606 { 607 unsigned x, y; 608 for(y = 0; y < height; ++y) { 609 uint32_t *dst = dst_row; 610 const uint32_t *src = (const uint32_t *)src_row; 611 for(x = 0; x < width; ++x) { 612 uint32_t value = util_cpu_to_le32(*src++); 613 *dst++ = z24_unorm_to_z32_unorm(value & 0xffffff); 614 } 615 src_row += src_stride/sizeof(*src_row); 616 dst_row += dst_stride/sizeof(*dst_row); 617 } 618 } 619 620 void 621 util_format_z24x8_unorm_pack_z_32unorm(uint8_t *dst_row, unsigned dst_stride, 622 const uint32_t *src_row, unsigned src_stride, 623 unsigned width, unsigned height) 624 { 625 unsigned x, y; 626 for(y = 0; y < height; ++y) { 627 const uint32_t *src = src_row; 628 uint32_t *dst = (uint32_t *)dst_row; 629 for(x = 0; x < width; ++x) { 630 uint32_t value; 631 value = z32_unorm_to_z24_unorm(*src++); 632 *dst++ = util_cpu_to_le32(value); 633 } 634 dst_row += dst_stride/sizeof(*dst_row); 635 src_row += src_stride/sizeof(*src_row); 636 } 637 } 638 639 void 640 util_format_x8z24_unorm_unpack_z_float(float *dst_row, unsigned dst_stride, 641 const uint8_t *src_row, unsigned src_stride, 642 unsigned width, unsigned height) 643 { 644 unsigned x, y; 645 for(y = 0; y < height; ++y) { 646 float *dst = dst_row; 647 const uint32_t *src = (uint32_t *)src_row; 648 for(x = 0; x < width; ++x) { 649 uint32_t value = util_cpu_to_le32(*src++); 650 *dst++ = z24_unorm_to_z32_float(value >> 8); 651 } 652 src_row += src_stride/sizeof(*src_row); 653 dst_row += dst_stride/sizeof(*dst_row); 654 } 655 } 656 657 void 658 util_format_x8z24_unorm_pack_z_float(uint8_t *dst_row, unsigned dst_stride, 659 const float *src_row, unsigned src_stride, 660 unsigned width, unsigned height) 661 { 662 unsigned x, y; 663 for(y = 0; y < height; ++y) { 664 const float *src = src_row; 665 uint32_t *dst = (uint32_t *)dst_row; 666 for(x = 0; x < width; ++x) { 667 uint32_t value; 668 value = z32_float_to_z24_unorm(*src++) << 8; 669 *dst++ = util_cpu_to_le32(value); 670 } 671 dst_row += dst_stride/sizeof(*dst_row); 672 src_row += src_stride/sizeof(*src_row); 673 } 674 } 675 676 void 677 util_format_x8z24_unorm_unpack_z_32unorm(uint32_t *dst_row, unsigned dst_stride, 678 const uint8_t *src_row, unsigned src_stride, 679 unsigned width, unsigned height) 680 { 681 unsigned x, y; 682 for(y = 0; y < height; ++y) { 683 uint32_t *dst = dst_row; 684 const uint32_t *src = (const uint32_t *)src_row; 685 for(x = 0; x < width; ++x) { 686 uint32_t value = util_cpu_to_le32(*src++); 687 *dst++ = z24_unorm_to_z32_unorm(value >> 8); 688 } 689 src_row += src_stride/sizeof(*src_row); 690 dst_row += dst_stride/sizeof(*dst_row); 691 } 692 } 693 694 void 695 util_format_x8z24_unorm_pack_z_32unorm(uint8_t *dst_row, unsigned dst_stride, 696 const uint32_t *src_row, unsigned src_stride, 697 unsigned width, unsigned height) 698 { 699 unsigned x, y; 700 for(y = 0; y < height; ++y) { 701 const uint32_t *src = src_row; 702 uint32_t *dst = (uint32_t *)dst_row; 703 for(x = 0; x < width; ++x) { 704 uint32_t value; 705 value = z32_unorm_to_z24_unorm(*src++) << 8; 706 *dst++ = util_cpu_to_le32(value); 707 } 708 dst_row += dst_stride/sizeof(*dst_row); 709 src_row += src_stride/sizeof(*src_row); 710 } 711 } 712 713 void 714 util_format_z32_float_s8x24_uint_unpack_z_float(float *dst_row, unsigned dst_stride, 715 const uint8_t *src_row, unsigned src_stride, 716 unsigned width, unsigned height) 717 { 718 unsigned x, y; 719 for(y = 0; y < height; ++y) { 720 float *dst = dst_row; 721 const float *src = (const float *)src_row; 722 for(x = 0; x < width; ++x) { 723 *dst = *src; 724 src += 2; 725 dst += 1; 726 } 727 src_row += src_stride/sizeof(*src_row); 728 dst_row += dst_stride/sizeof(*dst_row); 729 } 730 } 731 732 void 733 util_format_z32_float_s8x24_uint_pack_z_float(uint8_t *dst_row, unsigned dst_stride, 734 const float *src_row, unsigned src_stride, 735 unsigned width, unsigned height) 736 { 737 unsigned x, y; 738 for(y = 0; y < height; ++y) { 739 const float *src = src_row; 740 float *dst = (float *)dst_row; 741 for(x = 0; x < width; ++x) { 742 *dst = *src; 743 src += 1; 744 dst += 2; 745 } 746 dst_row += dst_stride/sizeof(*dst_row); 747 src_row += src_stride/sizeof(*src_row); 748 } 749 } 750 751 void 752 util_format_z32_float_s8x24_uint_unpack_z_32unorm(uint32_t *dst_row, unsigned dst_stride, 753 const uint8_t *src_row, unsigned src_stride, 754 unsigned width, unsigned height) 755 { 756 unsigned x, y; 757 for(y = 0; y < height; ++y) { 758 uint32_t *dst = dst_row; 759 const float *src = (const float *)src_row; 760 for(x = 0; x < width; ++x) { 761 *dst = z32_float_to_z32_unorm(*src); 762 src += 2; 763 dst += 1; 764 } 765 src_row += src_stride/sizeof(*src_row); 766 dst_row += dst_stride/sizeof(*dst_row); 767 } 768 } 769 770 void 771 util_format_z32_float_s8x24_uint_pack_z_32unorm(uint8_t *dst_row, unsigned dst_stride, 772 const uint32_t *src_row, unsigned src_stride, 773 unsigned width, unsigned height) 774 { 775 unsigned x, y; 776 for(y = 0; y < height; ++y) { 777 const uint32_t *src = src_row; 778 float *dst = (float *)dst_row; 779 for(x = 0; x < width; ++x) { 780 *dst++ = z32_unorm_to_z32_float(*src++); 781 } 782 dst_row += dst_stride/sizeof(*dst_row); 783 src_row += src_stride/sizeof(*src_row); 784 } 785 } 786 787 void 788 util_format_z32_float_s8x24_uint_unpack_s_8uint(uint8_t *dst_row, unsigned dst_stride, 789 const uint8_t *src_row, unsigned src_stride, 790 unsigned width, unsigned height) 791 { 792 unsigned x, y; 793 for(y = 0; y < height; ++y) { 794 uint8_t *dst = dst_row; 795 const uint8_t *src = src_row + 4; 796 for(x = 0; x < width; ++x) { 797 *dst = *src; 798 src += 8; 799 dst += 1; 800 } 801 src_row += src_stride/sizeof(*src_row); 802 dst_row += dst_stride/sizeof(*dst_row); 803 } 804 } 805 806 void 807 util_format_z32_float_s8x24_uint_pack_s_8uint(uint8_t *dst_row, unsigned dst_stride, 808 const uint8_t *src_row, unsigned src_stride, 809 unsigned width, unsigned height) 810 { 811 unsigned x, y; 812 for(y = 0; y < height; ++y) { 813 const uint8_t *src = src_row; 814 uint8_t *dst = dst_row + 4; 815 for(x = 0; x < width; ++x) { 816 *dst = *src; 817 src += 1; 818 dst += 8; 819 } 820 dst_row += dst_stride/sizeof(*dst_row); 821 src_row += src_stride/sizeof(*src_row); 822 } 823 } 824 825 826 void 827 util_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) 828 { 829 util_format_z24_unorm_s8_uint_unpack_s_8uint(dst_row, dst_stride, 830 src_row, src_stride, 831 width, height); 832 } 833 834 void 835 util_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) 836 { 837 util_format_z24_unorm_s8_uint_pack_s_8uint(dst_row, dst_stride, 838 src_row, src_stride, 839 width, height); 840 } 841 842 void 843 util_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) 844 { 845 util_format_s8_uint_z24_unorm_unpack_s_8uint(dst_row, dst_stride, 846 src_row, src_stride, 847 width, height); 848 } 849 850 void 851 util_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) 852 { 853 util_format_s8_uint_z24_unorm_pack_s_8uint(dst_row, dst_stride, 854 src_row, src_stride, 855 width, height); 856 } 857 858 void 859 util_format_x32_s8x24_uint_unpack_s_8uint(uint8_t *dst_row, unsigned dst_stride, 860 const uint8_t *src_row, unsigned src_stride, 861 unsigned width, unsigned height) 862 { 863 util_format_z32_float_s8x24_uint_unpack_s_8uint(dst_row, dst_stride, 864 src_row, src_stride, 865 width, height); 866 867 } 868 869 void 870 util_format_x32_s8x24_uint_pack_s_8uint(uint8_t *dst_row, unsigned dst_stride, 871 const uint8_t *src_row, unsigned src_stride, 872 unsigned width, unsigned height) 873 { 874 util_format_z32_float_s8x24_uint_pack_s_8uint(dst_row, dst_stride, 875 src_row, src_stride, 876 width, height); 877 } 878
