src/gallium/auxiliary/util/u_tile.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
   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 TUNGSTEN GRAPHICS 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  * RGBA/float tile get/put functions.
  30  * Usable both by drivers and state trackers.
  31  */
  32
  33
  34 #include "pipe/p_defines.h"
  35 #include "util/u_inlines.h"
  36
  37 #include "util/u_format.h"
  38 #include "util/u_math.h"
  39 #include "util/u_memory.h"
  40 #include "util/u_rect.h"
  41 #include "util/u_tile.h"
  42
  43
  44 /**
  45  * Move raw block of pixels from transfer object to user memory.
  46  */
  47 void
  48 pipe_get_tile_raw(struct pipe_context *pipe,
  49                   struct pipe_transfer *pt,
  50                   uint x, uint y, uint w, uint h,
  51                   void *dst, int dst_stride)
  52 {
  53    const void *src;
  54
  55    if (dst_stride == 0)
  56       dst_stride = util_format_get_stride(pt->texture->format, w);
  57
  58    if (pipe_clip_tile(x, y, &w, &h, pt))
  59       return;
  60
  61    src = pipe->transfer_map(pipe, pt);
  62    assert(src);
  63    if(!src)
  64       return;
  65
  66    util_copy_rect(dst, pt->texture->format, dst_stride, 0, 0, w, h, src, pt->stride, x, y);
  67
  68    pipe->transfer_unmap(pipe, pt);
  69 }
  70
  71
  72 /**
  73  * Move raw block of pixels from user memory to transfer object.
  74  */
  75 void
  76 pipe_put_tile_raw(struct pipe_context *pipe,
  77                   struct pipe_transfer *pt,
  78                   uint x, uint y, uint w, uint h,
  79                   const void *src, int src_stride)
  80 {
  81    void *dst;
  82    enum pipe_format format = pt->texture->format;
  83
  84    if (src_stride == 0)
  85       src_stride = util_format_get_stride(format, w);
  86
  87    if (pipe_clip_tile(x, y, &w, &h, pt))
  88       return;
  89
  90    dst = pipe->transfer_map(pipe, pt);
  91    assert(dst);
  92    if(!dst)
  93       return;
  94
  95    util_copy_rect(dst, format, pt->stride, x, y, w, h, src, src_stride, 0, 0);
  96
  97    pipe->transfer_unmap(pipe, pt);
  98 }
  99
 100
 101
 102
 103 /** Convert short in [-32768,32767] to GLfloat in [-1.0,1.0] */
 104 #define SHORT_TO_FLOAT(S)   ((2.0F * (S) + 1.0F) * (1.0F/65535.0F))
 105
 106 #define UNCLAMPED_FLOAT_TO_SHORT(us, f)  \
 107    us = ( (short) ( CLAMP((f), -1.0, 1.0) * 32767.0F) )
 108
 109
 110
 111 /*** PIPE_FORMAT_Z16_UNORM ***/
 112
 113 /**
 114  * Return each Z value as four floats in [0,1].
 115  */
 116 static void
 117 z16_get_tile_rgba(const ushort *src,
 118                   unsigned w, unsigned h,
 119                   float *p,
 120                   unsigned dst_stride)
 121 {
 122    const float scale = 1.0f / 65535.0f;
 123    unsigned i, j;
 124
 125    for (i = 0; i < h; i++) {
 126       float *pRow = p;
 127       for (j = 0; j < w; j++, pRow += 4) {
 128          pRow[0] =
 129          pRow[1] =
 130          pRow[2] =
 131          pRow[3] = *src++ * scale;
 132       }
 133       p += dst_stride;
 134    }
 135 }
 136
 137
 138
 139
 140 /*** PIPE_FORMAT_A8B8G8R8_SRGB ***/
 141
 142 /**
 143  * Convert an 8-bit sRGB value from non-linear space to a
 144  * linear RGB value in [0, 1].
 145  * Implemented with a 256-entry lookup table.
 146  */
 147 static INLINE float
 148 srgb_to_linear(ubyte cs8)
 149 {
 150    static float table[256];
 151    static boolean tableReady = FALSE;
 152    if (!tableReady) {
 153       /* compute lookup table now */
 154       uint i;
 155       for (i = 0; i < 256; i++) {
 156          const float cs = ubyte_to_float(i);
 157          if (cs <= 0.04045) {
 158             table[i] = cs / 12.92f;
 159          }
 160          else {
 161             table[i] = (float) powf((cs + 0.055) / 1.055, 2.4);
 162          }
 163       }
 164       tableReady = TRUE;
 165    }
 166    return table[cs8];
 167 }
 168
 169
 170 /**
 171  * Convert linear float in [0,1] to an srgb ubyte value in [0,255].
 172  * XXX this hasn't been tested (render to srgb surface).
 173  * XXX this needs optimization.
 174  */
 175 static INLINE ubyte
 176 linear_to_srgb(float cl)
 177 {
 178    if (cl >= 1.0F)
 179       return 255;
 180    else if (cl >= 0.0031308F)
 181       return float_to_ubyte(1.055F * powf(cl, 0.41666F) - 0.055F);
 182    else if (cl > 0.0F)
 183       return float_to_ubyte(12.92F * cl);
 184    else
 185       return 0.0;
 186 }
 187
 188
 189 static void
 190 a8r8g8b8_srgb_get_tile_rgba(const unsigned *src,
 191                             unsigned w, unsigned h,
 192                             float *p,
 193                             unsigned dst_stride)
 194 {
 195    unsigned i, j;
 196
 197    for (i = 0; i < h; i++) {
 198       float *pRow = p;
 199       for (j = 0; j < w; j++, pRow += 4) {
 200          const unsigned pixel = *src++;
 201          pRow[0] = srgb_to_linear((pixel >> 16) & 0xff);
 202          pRow[1] = srgb_to_linear((pixel >>  8) & 0xff);
 203          pRow[2] = srgb_to_linear((pixel >>  0) & 0xff);
 204          pRow[3] = ubyte_to_float((pixel >> 24) & 0xff);
 205       }
 206       p += dst_stride;
 207    }
 208 }
 209
 210 static void
 211 a8r8g8b8_srgb_put_tile_rgba(unsigned *dst,
 212                             unsigned w, unsigned h,
 213                             const float *p,
 214                             unsigned src_stride)
 215 {
 216    unsigned i, j;
 217
 218    for (i = 0; i < h; i++) {
 219       const float *pRow = p;
 220       for (j = 0; j < w; j++, pRow += 4) {
 221          unsigned r, g, b, a;
 222          r = linear_to_srgb(pRow[0]);
 223          g = linear_to_srgb(pRow[1]);
 224          b = linear_to_srgb(pRow[2]);
 225          a = float_to_ubyte(pRow[3]);
 226          *dst++ = (a << 24) | (r << 16) | (g << 8) | b;
 227       }
 228       p += src_stride;
 229    }
 230 }
 231
 232
 233 /*** PIPE_FORMAT_L8A8_SRGB ***/
 234
 235 static void
 236 a8l8_srgb_get_tile_rgba(const ushort *src,
 237                         unsigned w, unsigned h,
 238                         float *p,
 239                         unsigned dst_stride)
 240 {
 241    unsigned i, j;
 242
 243    for (i = 0; i < h; i++) {
 244       float *pRow = p;
 245       for (j = 0; j < w; j++, pRow += 4) {
 246          ushort p = *src++;
 247          pRow[0] =
 248          pRow[1] =
 249          pRow[2] = srgb_to_linear(p & 0xff);
 250          pRow[3] = ubyte_to_float(p >> 8);
 251       }
 252       p += dst_stride;
 253    }
 254 }
 255
 256 static void
 257 a8l8_srgb_put_tile_rgba(ushort *dst,
 258                         unsigned w, unsigned h,
 259                         const float *p,
 260                         unsigned src_stride)
 261 {
 262    unsigned i, j;
 263
 264    for (i = 0; i < h; i++) {
 265       const float *pRow = p;
 266       for (j = 0; j < w; j++, pRow += 4) {
 267          unsigned r, a;
 268          r = linear_to_srgb(pRow[0]);
 269          a = float_to_ubyte(pRow[3]);
 270          *dst++ = (a << 8) | r;
 271       }
 272       p += src_stride;
 273    }
 274 }
 275
 276
 277 /*** PIPE_FORMAT_L8_SRGB ***/
 278
 279 static void
 280 l8_srgb_get_tile_rgba(const ubyte *src,
 281                       unsigned w, unsigned h,
 282                       float *p,
 283                       unsigned dst_stride)
 284 {
 285    unsigned i, j;
 286
 287    for (i = 0; i < h; i++) {
 288       float *pRow = p;
 289       for (j = 0; j < w; j++, src++, pRow += 4) {
 290          pRow[0] =
 291          pRow[1] =
 292          pRow[2] = srgb_to_linear(*src);
 293          pRow[3] = 1.0;
 294       }
 295       p += dst_stride;
 296    }
 297 }
 298
 299 static void
 300 l8_srgb_put_tile_rgba(ubyte *dst,
 301                       unsigned w, unsigned h,
 302                       const float *p,
 303                       unsigned src_stride)
 304 {
 305    unsigned i, j;
 306
 307    for (i = 0; i < h; i++) {
 308       const float *pRow = p;
 309       for (j = 0; j < w; j++, pRow += 4) {
 310          unsigned r;
 311          r = linear_to_srgb(pRow[0]);
 312          *dst++ = (ubyte) r;
 313       }
 314       p += src_stride;
 315    }
 316 }
 317
 318
 319 /*** PIPE_FORMAT_Z32_UNORM ***/
 320
 321 /**
 322  * Return each Z value as four floats in [0,1].
 323  */
 324 static void
 325 z32_get_tile_rgba(const unsigned *src,
 326                   unsigned w, unsigned h,
 327                   float *p,
 328                   unsigned dst_stride)
 329 {
 330    const double scale = 1.0 / (double) 0xffffffff;
 331    unsigned i, j;
 332
 333    for (i = 0; i < h; i++) {
 334       float *pRow = p;
 335       for (j = 0; j < w; j++, pRow += 4) {
 336          pRow[0] =
 337          pRow[1] =
 338          pRow[2] =
 339          pRow[3] = (float) (*src++ * scale);
 340       }
 341       p += dst_stride;
 342    }
 343 }
 344
 345
 346 /*** PIPE_FORMAT_Z24_UNORM_S8_USCALED ***/
 347
 348 /**
 349  * Return Z component as four float in [0,1].  Stencil part ignored.
 350  */
 351 static void
 352 s8z24_get_tile_rgba(const unsigned *src,
 353                     unsigned w, unsigned h,
 354                     float *p,
 355                     unsigned dst_stride)
 356 {
 357    const double scale = 1.0 / ((1 << 24) - 1);
 358    unsigned i, j;
 359
 360    for (i = 0; i < h; i++) {
 361       float *pRow = p;
 362       for (j = 0; j < w; j++, pRow += 4) {
 363          pRow[0] =
 364          pRow[1] =
 365          pRow[2] =
 366          pRow[3] = (float) (scale * (*src++ & 0xffffff));
 367       }
 368       p += dst_stride;
 369    }
 370 }
 371
 372
 373 /*** PIPE_FORMAT_S8_USCALED_Z24_UNORM ***/
 374
 375 /**
 376  * Return Z component as four float in [0,1].  Stencil part ignored.
 377  */
 378 static void
 379 z24s8_get_tile_rgba(const unsigned *src,
 380                     unsigned w, unsigned h,
 381                     float *p,
 382                     unsigned dst_stride)
 383 {
 384    const double scale = 1.0 / ((1 << 24) - 1);
 385    unsigned i, j;
 386
 387    for (i = 0; i < h; i++) {
 388       float *pRow = p;
 389       for (j = 0; j < w; j++, pRow += 4) {
 390          pRow[0] =
 391          pRow[1] =
 392          pRow[2] =
 393          pRow[3] = (float) (scale * (*src++ >> 8));
 394       }
 395       p += dst_stride;
 396    }
 397 }
 398
 399
 400 /*** PIPE_FORMAT_Z32_FLOAT ***/
 401
 402 /**
 403  * Return each Z value as four floats in [0,1].
 404  */
 405 static void
 406 z32f_get_tile_rgba(const float *src,
 407                    unsigned w, unsigned h,
 408                    float *p,
 409                    unsigned dst_stride)
 410 {
 411    unsigned i, j;
 412
 413    for (i = 0; i < h; i++) {
 414       float *pRow = p;
 415       for (j = 0; j < w; j++, pRow += 4) {
 416          pRow[0] =
 417          pRow[1] =
 418          pRow[2] =
 419          pRow[3] = *src++;
 420       }
 421       p += dst_stride;
 422    }
 423 }
 424
 425
 426 /*** PIPE_FORMAT_UYVY / PIPE_FORMAT_YUYV ***/
 427
 428 /**
 429  * Convert YCbCr (or YCrCb) to RGBA.
 430  */
 431 static void
 432 ycbcr_get_tile_rgba(const ushort *src,
 433                     unsigned w, unsigned h,
 434                     float *p,
 435                     unsigned dst_stride,
 436                     boolean rev)
 437 {
 438    const float scale = 1.0f / 255.0f;
 439    unsigned i, j;
 440
 441    for (i = 0; i < h; i++) {
 442       float *pRow = p;
 443       /* do two texels at a time */
 444       for (j = 0; j < (w & ~1); j += 2, src += 2) {
 445          const ushort t0 = src[0];
 446          const ushort t1 = src[1];
 447          const ubyte y0 = (t0 >> 8) & 0xff;  /* luminance */
 448          const ubyte y1 = (t1 >> 8) & 0xff;  /* luminance */
 449          ubyte cb, cr;
 450          float r, g, b;
 451
 452          if (rev) {
 453             cb = t1 & 0xff;         /* chroma U */
 454             cr = t0 & 0xff;         /* chroma V */
 455          }
 456          else {
 457             cb = t0 & 0xff;         /* chroma U */
 458             cr = t1 & 0xff;         /* chroma V */
 459          }
 460
 461          /* even pixel: y0,cr,cb */
 462          r = 1.164f * (y0-16) + 1.596f * (cr-128);
 463          g = 1.164f * (y0-16) - 0.813f * (cr-128) - 0.391f * (cb-128);
 464          b = 1.164f * (y0-16) + 2.018f * (cb-128);
 465          pRow[0] = r * scale;
 466          pRow[1] = g * scale;
 467          pRow[2] = b * scale;
 468          pRow[3] = 1.0f;
 469          pRow += 4;
 470
 471          /* odd pixel: use y1,cr,cb */
 472          r = 1.164f * (y1-16) + 1.596f * (cr-128);
 473          g = 1.164f * (y1-16) - 0.813f * (cr-128) - 0.391f * (cb-128);
 474          b = 1.164f * (y1-16) + 2.018f * (cb-128);
 475          pRow[0] = r * scale;
 476          pRow[1] = g * scale;
 477          pRow[2] = b * scale;
 478          pRow[3] = 1.0f;
 479          pRow += 4;
 480
 481       }
 482       /* do the last texel */
 483       if (w & 1) {
 484          const ushort t0 = src[0];
 485          const ushort t1 = src[1];
 486          const ubyte y0 = (t0 >> 8) & 0xff;  /* luminance */
 487          ubyte cb, cr;
 488          float r, g, b;
 489
 490          if (rev) {
 491             cb = t1 & 0xff;         /* chroma U */
 492             cr = t0 & 0xff;         /* chroma V */
 493          }
 494          else {
 495             cb = t0 & 0xff;         /* chroma U */
 496             cr = t1 & 0xff;         /* chroma V */
 497          }
 498
 499          /* even pixel: y0,cr,cb */
 500          r = 1.164f * (y0-16) + 1.596f * (cr-128);
 501          g = 1.164f * (y0-16) - 0.813f * (cr-128) - 0.391f * (cb-128);
 502          b = 1.164f * (y0-16) + 2.018f * (cb-128);
 503          pRow[0] = r * scale;
 504          pRow[1] = g * scale;
 505          pRow[2] = b * scale;
 506          pRow[3] = 1.0f;
 507          pRow += 4;
 508       }
 509       p += dst_stride;
 510    }
 511 }
 512
 513
 514 void
 515 pipe_tile_raw_to_rgba(enum pipe_format format,
 516                       void *src,
 517                       uint w, uint h,
 518                       float *dst, unsigned dst_stride)
 519 {
 520    switch (format) {
 521    case PIPE_FORMAT_B8G8R8A8_SRGB:
 522       a8r8g8b8_srgb_get_tile_rgba((unsigned *) src, w, h, dst, dst_stride);
 523       break;
 524    case PIPE_FORMAT_L8A8_SRGB:
 525       a8l8_srgb_get_tile_rgba((ushort *) src, w, h, dst, dst_stride);
 526       break;
 527    case PIPE_FORMAT_L8_SRGB:
 528       l8_srgb_get_tile_rgba((ubyte *) src, w, h, dst, dst_stride);
 529       break;
 530    case PIPE_FORMAT_Z16_UNORM:
 531       z16_get_tile_rgba((ushort *) src, w, h, dst, dst_stride);
 532       break;
 533    case PIPE_FORMAT_Z32_UNORM:
 534       z32_get_tile_rgba((unsigned *) src, w, h, dst, dst_stride);
 535       break;
 536    case PIPE_FORMAT_Z24_UNORM_S8_USCALED:
 537    case PIPE_FORMAT_Z24X8_UNORM:
 538       s8z24_get_tile_rgba((unsigned *) src, w, h, dst, dst_stride);
 539       break;
 540    case PIPE_FORMAT_S8_USCALED_Z24_UNORM:
 541    case PIPE_FORMAT_X8Z24_UNORM:
 542       z24s8_get_tile_rgba((unsigned *) src, w, h, dst, dst_stride);
 543       break;
 544    case PIPE_FORMAT_Z32_FLOAT:
 545       z32f_get_tile_rgba((float *) src, w, h, dst, dst_stride);
 546       break;
 547    case PIPE_FORMAT_UYVY:
 548       ycbcr_get_tile_rgba((ushort *) src, w, h, dst, dst_stride, FALSE);
 549       break;
 550    case PIPE_FORMAT_YUYV:
 551       ycbcr_get_tile_rgba((ushort *) src, w, h, dst, dst_stride, TRUE);
 552       break;
 553    default:
 554       util_format_read_4f(format,
 555                           dst, dst_stride * sizeof(float),
 556                           src, util_format_get_stride(format, w),
 557                           0, 0, w, h);
 558    }
 559 }
 560
 561
 562 void
 563 pipe_get_tile_rgba(struct pipe_context *pipe,
 564                    struct pipe_transfer *pt,
 565                    uint x, uint y, uint w, uint h,
 566                    float *p)
 567 {
 568    unsigned dst_stride = w * 4;
 569    void *packed;
 570    enum pipe_format format = pt->texture->format;
 571
 572    if (pipe_clip_tile(x, y, &w, &h, pt))
 573       return;
 574
 575    packed = MALLOC(util_format_get_nblocks(format, w, h) * util_format_get_blocksize(format));
 576
 577    if (!packed)
 578       return;
 579
 580    if(format == PIPE_FORMAT_UYVY || format == PIPE_FORMAT_YUYV)
 581       assert((x & 1) == 0);
 582
 583    pipe_get_tile_raw(pipe, pt, x, y, w, h, packed, 0);
 584
 585    pipe_tile_raw_to_rgba(format, packed, w, h, p, dst_stride);
 586
 587    FREE(packed);
 588 }
 589
 590
 591 void
 592 pipe_get_tile_swizzle(struct pipe_context *pipe,
 593                       struct pipe_transfer *pt,
 594                       uint x,
 595                       uint y,
 596                       uint w,
 597                       uint h,
 598                       uint swizzle_r,
 599                       uint swizzle_g,
 600                       uint swizzle_b,
 601                       uint swizzle_a,
 602                       enum pipe_format format,
 603                       float *p)
 604 {
 605    unsigned dst_stride = w * 4;
 606    void *packed;
 607    uint i;
 608    float rgba01[6];
 609
 610    if (pipe_clip_tile(x, y, &w, &h, pt)) {
 611       return;
 612    }
 613
 614    packed = MALLOC(util_format_get_nblocks(format, w, h) * util_format_get_blocksize(format));
 615    if (!packed) {
 616       return;
 617    }
 618
 619    if (format == PIPE_FORMAT_UYVY || format == PIPE_FORMAT_YUYV) {
 620       assert((x & 1) == 0);
 621    }
 622
 623    pipe_get_tile_raw(pipe, pt, x, y, w, h, packed, 0);
 624
 625    pipe_tile_raw_to_rgba(format, packed, w, h, p, dst_stride);
 626
 627    FREE(packed);
 628
 629    if (swizzle_r == PIPE_SWIZZLE_RED &&
 630        swizzle_g == PIPE_SWIZZLE_GREEN &&
 631        swizzle_b == PIPE_SWIZZLE_BLUE &&
 632        swizzle_a == PIPE_SWIZZLE_ALPHA) {
 633       /* no-op, skip */
 634       return;
 635    }
 636
 637    rgba01[PIPE_SWIZZLE_ZERO] = 0.0f;
 638    rgba01[PIPE_SWIZZLE_ONE] = 1.0f;
 639
 640    for (i = 0; i < w * h; i++) {
 641       rgba01[PIPE_SWIZZLE_RED] = p[0];
 642       rgba01[PIPE_SWIZZLE_GREEN] = p[1];
 643       rgba01[PIPE_SWIZZLE_BLUE] = p[2];
 644       rgba01[PIPE_SWIZZLE_ALPHA] = p[3];
 645
 646       *p++ = rgba01[swizzle_r];
 647       *p++ = rgba01[swizzle_g];
 648       *p++ = rgba01[swizzle_b];
 649       *p++ = rgba01[swizzle_a];
 650    }
 651 }
 652
 653
 654 void
 655 pipe_put_tile_rgba(struct pipe_context *pipe,
 656                    struct pipe_transfer *pt,
 657                    uint x, uint y, uint w, uint h,
 658                    const float *p)
 659 {
 660    unsigned src_stride = w * 4;
 661    void *packed;
 662    enum pipe_format format = pt->texture->format;
 663
 664    if (pipe_clip_tile(x, y, &w, &h, pt))
 665       return;
 666
 667    packed = MALLOC(util_format_get_nblocks(format, w, h) * util_format_get_blocksize(format));
 668
 669    if (!packed)
 670       return;
 671
 672    switch (format) {
 673    case PIPE_FORMAT_B8G8R8A8_SRGB:
 674       a8r8g8b8_srgb_put_tile_rgba((unsigned *) packed, w, h, p, src_stride);
 675       break;
 676    case PIPE_FORMAT_L8A8_SRGB:
 677       a8l8_srgb_put_tile_rgba((ushort *) packed, w, h, p, src_stride);
 678       break;
 679    case PIPE_FORMAT_L8_SRGB:
 680       l8_srgb_put_tile_rgba((ubyte *) packed, w, h, p, src_stride);
 681       break;
 682    case PIPE_FORMAT_Z16_UNORM:
 683       /*z16_put_tile_rgba((ushort *) packed, w, h, p, src_stride);*/
 684       break;
 685    case PIPE_FORMAT_Z32_UNORM:
 686       /*z32_put_tile_rgba((unsigned *) packed, w, h, p, src_stride);*/
 687       break;
 688    case PIPE_FORMAT_Z24_UNORM_S8_USCALED:
 689    case PIPE_FORMAT_Z24X8_UNORM:
 690       /*s8z24_put_tile_rgba((unsigned *) packed, w, h, p, src_stride);*/
 691       break;
 692    case PIPE_FORMAT_S8_USCALED_Z24_UNORM:
 693    case PIPE_FORMAT_X8Z24_UNORM:
 694       /*z24s8_put_tile_rgba((unsigned *) packed, w, h, p, src_stride);*/
 695       break;
 696    default:
 697       util_format_write_4f(format,
 698                            p, src_stride * sizeof(float),
 699                            packed, util_format_get_stride(format, w),
 700                            0, 0, w, h);
 701    }
 702
 703    pipe_put_tile_raw(pipe, pt, x, y, w, h, packed, 0);
 704
 705    FREE(packed);
 706 }
 707
 708
 709 /**
 710  * Get a block of Z values, converted to 32-bit range.
 711  */
 712 void
 713 pipe_get_tile_z(struct pipe_context *pipe,
 714                 struct pipe_transfer *pt,
 715                 uint x, uint y, uint w, uint h,
 716                 uint *z)
 717 {
 718    const uint dstStride = w;
 719    ubyte *map;
 720    uint *pDest = z;
 721    uint i, j;
 722    enum pipe_format format = pt->texture->format;
 723
 724    if (pipe_clip_tile(x, y, &w, &h, pt))
 725       return;
 726
 727    map = (ubyte *)pipe->transfer_map(pipe, pt);
 728    if (!map) {
 729       assert(0);
 730       return;
 731    }
 732
 733    switch (format) {
 734    case PIPE_FORMAT_Z32_UNORM:
 735       {
 736          const uint *ptrc
 737             = (const uint *)(map  + y * pt->stride + x*4);
 738          for (i = 0; i < h; i++) {
 739             memcpy(pDest, ptrc, 4 * w);
 740             pDest += dstStride;
 741             ptrc += pt->stride/4;
 742          }
 743       }
 744       break;
 745    case PIPE_FORMAT_Z24_UNORM_S8_USCALED:
 746    case PIPE_FORMAT_Z24X8_UNORM:
 747       {
 748          const uint *ptrc
 749             = (const uint *)(map + y * pt->stride + x*4);
 750          for (i = 0; i < h; i++) {
 751             for (j = 0; j < w; j++) {
 752                /* convert 24-bit Z to 32-bit Z */
 753                pDest[j] = (ptrc[j] << 8) | ((ptrc[j] >> 16) & 0xff);
 754             }
 755             pDest += dstStride;
 756             ptrc += pt->stride/4;
 757          }
 758       }
 759       break;
 760    case PIPE_FORMAT_S8_USCALED_Z24_UNORM:
 761    case PIPE_FORMAT_X8Z24_UNORM:
 762       {
 763          const uint *ptrc
 764             = (const uint *)(map + y * pt->stride + x*4);
 765          for (i = 0; i < h; i++) {
 766             for (j = 0; j < w; j++) {
 767                /* convert 24-bit Z to 32-bit Z */
 768                pDest[j] = (ptrc[j] & 0xffffff00) | ((ptrc[j] >> 24) & 0xff);
 769             }
 770             pDest += dstStride;
 771             ptrc += pt->stride/4;
 772          }
 773       }
 774       break;
 775    case PIPE_FORMAT_Z16_UNORM:
 776       {
 777          const ushort *ptrc
 778             = (const ushort *)(map + y * pt->stride + x*2);
 779          for (i = 0; i < h; i++) {
 780             for (j = 0; j < w; j++) {
 781                /* convert 16-bit Z to 32-bit Z */
 782                pDest[j] = (ptrc[j] << 16) | ptrc[j];
 783             }
 784             pDest += dstStride;
 785             ptrc += pt->stride/2;
 786          }
 787       }
 788       break;
 789    default:
 790       assert(0);
 791    }
 792
 793    pipe->transfer_unmap(pipe, pt);
 794 }
 795
 796
 797 void
 798 pipe_put_tile_z(struct pipe_context *pipe,
 799                 struct pipe_transfer *pt,
 800                 uint x, uint y, uint w, uint h,
 801                 const uint *zSrc)
 802 {
 803    const uint srcStride = w;
 804    const uint *ptrc = zSrc;
 805    ubyte *map;
 806    uint i, j;
 807    enum pipe_format format = pt->texture->format;
 808
 809    if (pipe_clip_tile(x, y, &w, &h, pt))
 810       return;
 811
 812    map = (ubyte *)pipe->transfer_map(pipe, pt);
 813    if (!map) {
 814       assert(0);
 815       return;
 816    }
 817
 818    switch (format) {
 819    case PIPE_FORMAT_Z32_UNORM:
 820       {
 821          uint *pDest = (uint *) (map + y * pt->stride + x*4);
 822          for (i = 0; i < h; i++) {
 823             memcpy(pDest, ptrc, 4 * w);
 824             pDest += pt->stride/4;
 825             ptrc += srcStride;
 826          }
 827       }
 828       break;
 829    case PIPE_FORMAT_Z24_UNORM_S8_USCALED:
 830       {
 831          uint *pDest = (uint *) (map + y * pt->stride + x*4);
 832          assert((pt->usage & PIPE_TRANSFER_READ_WRITE) == PIPE_TRANSFER_READ_WRITE);
 833          for (i = 0; i < h; i++) {
 834             for (j = 0; j < w; j++) {
 835                /* convert 32-bit Z to 24-bit Z, preserve stencil */
 836                pDest[j] = (pDest[j] & 0xff000000) | ptrc[j] >> 8;
 837             }
 838             pDest += pt->stride/4;
 839             ptrc += srcStride;
 840          }
 841       }
 842       break;
 843    case PIPE_FORMAT_Z24X8_UNORM:
 844       {
 845          uint *pDest = (uint *) (map + y * pt->stride + x*4);
 846          for (i = 0; i < h; i++) {
 847             for (j = 0; j < w; j++) {
 848                /* convert 32-bit Z to 24-bit Z (0 stencil) */
 849                pDest[j] = ptrc[j] >> 8;
 850             }
 851             pDest += pt->stride/4;
 852             ptrc += srcStride;
 853          }
 854       }
 855       break;
 856    case PIPE_FORMAT_S8_USCALED_Z24_UNORM:
 857       {
 858          uint *pDest = (uint *) (map + y * pt->stride + x*4);
 859          assert((pt->usage & PIPE_TRANSFER_READ_WRITE) == PIPE_TRANSFER_READ_WRITE);
 860          for (i = 0; i < h; i++) {
 861             for (j = 0; j < w; j++) {
 862                /* convert 32-bit Z to 24-bit Z, preserve stencil */
 863                pDest[j] = (pDest[j] & 0xff) | (ptrc[j] & 0xffffff00);
 864             }
 865             pDest += pt->stride/4;
 866             ptrc += srcStride;
 867          }
 868       }
 869       break;
 870    case PIPE_FORMAT_X8Z24_UNORM:
 871       {
 872          uint *pDest = (uint *) (map + y * pt->stride + x*4);
 873          for (i = 0; i < h; i++) {
 874             for (j = 0; j < w; j++) {
 875                /* convert 32-bit Z to 24-bit Z (0 stencil) */
 876                pDest[j] = ptrc[j] & 0xffffff00;
 877             }
 878             pDest += pt->stride/4;
 879             ptrc += srcStride;
 880          }
 881       }
 882       break;
 883    case PIPE_FORMAT_Z16_UNORM:
 884       {
 885          ushort *pDest = (ushort *) (map + y * pt->stride + x*2);
 886          for (i = 0; i < h; i++) {
 887             for (j = 0; j < w; j++) {
 888                /* convert 32-bit Z to 16-bit Z */
 889                pDest[j] = ptrc[j] >> 16;
 890             }
 891             pDest += pt->stride/2;
 892             ptrc += srcStride;
 893          }
 894       }
 895       break;
 896    default:
 897       assert(0);
 898    }
 899
 900    pipe->transfer_unmap(pipe, pt);
 901 }
 902
 903