src/gallium/auxiliary/util/u_format_zs.c

   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);
  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_uscaled_unpack_s_8uscaled(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_uscaled_pack_s_8uscaled(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 = *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
 161 void
 162 util_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
 183 void
 184 util_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
 204 void
 205 util_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
 226 void
 227 util_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
 247 void
 248 util_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
 269 void
 270 util_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
 282 void
 283 util_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
 295 void
 296 util_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
 308 void
 309 util_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
 321 void
 322 util_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
 338 void
 339 util_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
 355 void
 356 util_format_z24_unorm_s8_uscaled_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
 376 void
 377 util_format_z24_unorm_s8_uscaled_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
 402 void
 403 util_format_z24_unorm_s8_uscaled_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
 423 void
 424 util_format_z24_unorm_s8_uscaled_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
 449 void
 450 util_format_z24_unorm_s8_uscaled_unpack_s_8uscaled(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
 470 void
 471 util_format_z24_unorm_s8_uscaled_pack_s_8uscaled(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
 496 void
 497 util_format_s8_uscaled_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
 517 void
 518 util_format_s8_uscaled_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
 543 void
 544 util_format_s8_uscaled_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
 564 void
 565 util_format_s8_uscaled_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
 590 void
 591 util_format_s8_uscaled_z24_unorm_unpack_s_8uscaled(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
 611 void
 612 util_format_s8_uscaled_z24_unorm_pack_s_8uscaled(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
 637 void
 638 util_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
 658 void
 659 util_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
 680 void
 681 util_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
 701 void
 702 util_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
 723 void
 724 util_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
 744 void
 745 util_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
 766 void
 767 util_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
 787 void
 788 util_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
 809 void
 810 util_format_z32_float_s8x24_uscaled_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
 828 void
 829 util_format_z32_float_s8x24_uscaled_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
 847 void
 848 util_format_z32_float_s8x24_uscaled_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
 866 void
 867 util_format_z32_float_s8x24_uscaled_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
 883 void
 884 util_format_z32_float_s8x24_uscaled_unpack_s_8uscaled(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
 902 void
 903 util_format_z32_float_s8x24_uscaled_pack_s_8uscaled(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