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 "pipe/p_inlines.h"
  36
  37 #include "util/u_math.h"
  38 #include "util/u_memory.h"
  39 #include "util/u_rect.h"
  40 #include "util/u_tile.h"
  41
  42
  43 /**
  44  * Move raw block of pixels from transfer object to user memory.
  45  */
  46 void
  47 pipe_get_tile_raw(struct pipe_transfer *pt,
  48                   uint x, uint y, uint w, uint h,
  49                   void *dst, int dst_stride)
  50 {
  51    struct pipe_screen *screen = pt->texture->screen;
  52    const void *src;
  53
  54    if (dst_stride == 0)
  55       dst_stride = pf_get_nblocksx(&pt->block, w) * pt->block.size;
  56
  57    if (pipe_clip_tile(x, y, &w, &h, pt))
  58       return;
  59
  60    src = screen->transfer_map(screen, pt);
  61    assert(src);
  62    if(!src)
  63       return;
  64
  65    util_copy_rect(dst, &pt->block, dst_stride, 0, 0, w, h, src, pt->stride, x, y);
  66
  67    screen->transfer_unmap(screen, pt);
  68 }
  69
  70
  71 /**
  72  * Move raw block of pixels from user memory to transfer object.
  73  */
  74 void
  75 pipe_put_tile_raw(struct pipe_transfer *pt,
  76                   uint x, uint y, uint w, uint h,
  77                   const void *src, int src_stride)
  78 {
  79    struct pipe_screen *screen = pt->texture->screen;
  80    void *dst;
  81
  82    if (src_stride == 0)
  83       src_stride = pf_get_nblocksx(&pt->block, w) * pt->block.size;
  84
  85    if (pipe_clip_tile(x, y, &w, &h, pt))
  86       return;
  87
  88    dst = screen->transfer_map(screen, pt);
  89    assert(dst);
  90    if(!dst)
  91       return;
  92
  93    util_copy_rect(dst, &pt->block, pt->stride, x, y, w, h, src, src_stride, 0, 0);
  94
  95    screen->transfer_unmap(screen, pt);
  96 }
  97
  98
  99
 100
 101 /** Convert short in [-32768,32767] to GLfloat in [-1.0,1.0] */
 102 #define SHORT_TO_FLOAT(S)   ((2.0F * (S) + 1.0F) * (1.0F/65535.0F))
 103
 104 #define UNCLAMPED_FLOAT_TO_SHORT(us, f)  \
 105    us = ( (short) ( CLAMP((f), -1.0, 1.0) * 32767.0F) )
 106
 107
 108
 109 /*** PIPE_FORMAT_A8R8G8B8_UNORM ***/
 110
 111 static void
 112 a8r8g8b8_get_tile_rgba(const unsigned *src,
 113                        unsigned w, unsigned h,
 114                        float *p,
 115                        unsigned dst_stride)
 116 {
 117    unsigned i, j;
 118
 119    for (i = 0; i < h; i++) {
 120       float *pRow = p;
 121       for (j = 0; j < w; j++, pRow += 4) {
 122          const unsigned pixel = *src++;
 123          pRow[0] = ubyte_to_float((pixel >> 16) & 0xff);
 124          pRow[1] = ubyte_to_float((pixel >>  8) & 0xff);
 125          pRow[2] = ubyte_to_float((pixel >>  0) & 0xff);
 126          pRow[3] = ubyte_to_float((pixel >> 24) & 0xff);
 127       }
 128       p += dst_stride;
 129    }
 130 }
 131
 132
 133 static void
 134 a8r8g8b8_put_tile_rgba(unsigned *dst,
 135                        unsigned w, unsigned h,
 136                        const float *p,
 137                        unsigned src_stride)
 138 {
 139    unsigned i, j;
 140
 141    for (i = 0; i < h; i++) {
 142       const float *pRow = p;
 143       for (j = 0; j < w; j++, pRow += 4) {
 144          unsigned r, g, b, a;
 145          r = float_to_ubyte(pRow[0]);
 146          g = float_to_ubyte(pRow[1]);
 147          b = float_to_ubyte(pRow[2]);
 148          a = float_to_ubyte(pRow[3]);
 149          *dst++ = (a << 24) | (r << 16) | (g << 8) | b;
 150       }
 151       p += src_stride;
 152    }
 153 }
 154
 155
 156 /*** PIPE_FORMAT_X8R8G8B8_UNORM ***/
 157
 158 static void
 159 x8r8g8b8_get_tile_rgba(const unsigned *src,
 160                        unsigned w, unsigned h,
 161                        float *p,
 162                        unsigned dst_stride)
 163 {
 164    unsigned i, j;
 165
 166    for (i = 0; i < h; i++) {
 167       float *pRow = p;
 168       for (j = 0; j < w; j++, pRow += 4) {
 169          const unsigned pixel = *src++;
 170          pRow[0] = ubyte_to_float((pixel >> 16) & 0xff);
 171          pRow[1] = ubyte_to_float((pixel >>  8) & 0xff);
 172          pRow[2] = ubyte_to_float((pixel >>  0) & 0xff);
 173          pRow[3] = ubyte_to_float(0xff);
 174       }
 175       p += dst_stride;
 176    }
 177 }
 178
 179
 180 static void
 181 x8r8g8b8_put_tile_rgba(unsigned *dst,
 182                        unsigned w, unsigned h,
 183                        const float *p,
 184                        unsigned src_stride)
 185 {
 186    unsigned i, j;
 187
 188    for (i = 0; i < h; i++) {
 189       const float *pRow = p;
 190       for (j = 0; j < w; j++, pRow += 4) {
 191          unsigned r, g, b;
 192          r = float_to_ubyte(pRow[0]);
 193          g = float_to_ubyte(pRow[1]);
 194          b = float_to_ubyte(pRow[2]);
 195          *dst++ = (0xff << 24) | (r << 16) | (g << 8) | b;
 196       }
 197       p += src_stride;
 198    }
 199 }
 200
 201
 202 /*** PIPE_FORMAT_B8G8R8A8_UNORM ***/
 203
 204 static void
 205 b8g8r8a8_get_tile_rgba(const unsigned *src,
 206                        unsigned w, unsigned h,
 207                        float *p,
 208                        unsigned dst_stride)
 209 {
 210    unsigned i, j;
 211
 212    for (i = 0; i < h; i++) {
 213       float *pRow = p;
 214       for (j = 0; j < w; j++, pRow += 4) {
 215          const unsigned pixel = *src++;
 216          pRow[0] = ubyte_to_float((pixel >>  8) & 0xff);
 217          pRow[1] = ubyte_to_float((pixel >> 16) & 0xff);
 218          pRow[2] = ubyte_to_float((pixel >> 24) & 0xff);
 219          pRow[3] = ubyte_to_float((pixel >>  0) & 0xff);
 220       }
 221       p += dst_stride;
 222    }
 223 }
 224
 225
 226 static void
 227 b8g8r8a8_put_tile_rgba(unsigned *dst,
 228                        unsigned w, unsigned h,
 229                        const float *p,
 230                        unsigned src_stride)
 231 {
 232    unsigned i, j;
 233
 234    for (i = 0; i < h; i++) {
 235       const float *pRow = p;
 236       for (j = 0; j < w; j++, pRow += 4) {
 237          unsigned r, g, b, a;
 238          r = float_to_ubyte(pRow[0]);
 239          g = float_to_ubyte(pRow[1]);
 240          b = float_to_ubyte(pRow[2]);
 241          a = float_to_ubyte(pRow[3]);
 242          *dst++ = (b << 24) | (g << 16) | (r << 8) | a;
 243       }
 244       p += src_stride;
 245    }
 246 }
 247
 248
 249 /*** PIPE_FORMAT_A1R5G5B5_UNORM ***/
 250
 251 static void
 252 a1r5g5b5_get_tile_rgba(const ushort *src,
 253                        unsigned w, unsigned h,
 254                        float *p,
 255                        unsigned dst_stride)
 256 {
 257    unsigned i, j;
 258
 259    for (i = 0; i < h; i++) {
 260       float *pRow = p;
 261       for (j = 0; j < w; j++, pRow += 4) {
 262          const ushort pixel = *src++;
 263          pRow[0] = ((pixel >> 10) & 0x1f) * (1.0f / 31.0f);
 264          pRow[1] = ((pixel >>  5) & 0x1f) * (1.0f / 31.0f);
 265          pRow[2] = ((pixel      ) & 0x1f) * (1.0f / 31.0f);
 266          pRow[3] = ((pixel >> 15)       ) * 1.0f;
 267       }
 268       p += dst_stride;
 269    }
 270 }
 271
 272
 273 static void
 274 a1r5g5b5_put_tile_rgba(ushort *dst,
 275                        unsigned w, unsigned h,
 276                        const float *p,
 277                        unsigned src_stride)
 278 {
 279    unsigned i, j;
 280
 281    for (i = 0; i < h; i++) {
 282       const float *pRow = p;
 283       for (j = 0; j < w; j++, pRow += 4) {
 284          unsigned r, g, b, a;
 285          r = float_to_ubyte(pRow[0]);
 286          g = float_to_ubyte(pRow[1]);
 287          b = float_to_ubyte(pRow[2]);
 288          a = float_to_ubyte(pRow[3]);
 289          r = r >> 3;  /* 5 bits */
 290          g = g >> 3;  /* 5 bits */
 291          b = b >> 3;  /* 5 bits */
 292          a = a >> 7;  /* 1 bit */
 293          *dst++ = (a << 15) | (r << 10) | (g << 5) | b;
 294       }
 295       p += src_stride;
 296    }
 297 }
 298
 299
 300 /*** PIPE_FORMAT_A4R4G4B4_UNORM ***/
 301
 302 static void
 303 a4r4g4b4_get_tile_rgba(const ushort *src,
 304                        unsigned w, unsigned h,
 305                        float *p,
 306                        unsigned dst_stride)
 307 {
 308    unsigned i, j;
 309
 310    for (i = 0; i < h; i++) {
 311       float *pRow = p;
 312       for (j = 0; j < w; j++, pRow += 4) {
 313          const ushort pixel = *src++;
 314          pRow[0] = ((pixel >>  8) & 0xf) * (1.0f / 15.0f);
 315          pRow[1] = ((pixel >>  4) & 0xf) * (1.0f / 15.0f);
 316          pRow[2] = ((pixel      ) & 0xf) * (1.0f / 15.0f);
 317          pRow[3] = ((pixel >> 12)      ) * (1.0f / 15.0f);
 318       }
 319       p += dst_stride;
 320    }
 321 }
 322
 323
 324 static void
 325 a4r4g4b4_put_tile_rgba(ushort *dst,
 326                        unsigned w, unsigned h,
 327                        const float *p,
 328                        unsigned src_stride)
 329 {
 330    unsigned i, j;
 331
 332    for (i = 0; i < h; i++) {
 333       const float *pRow = p;
 334       for (j = 0; j < w; j++, pRow += 4) {
 335          unsigned r, g, b, a;
 336          r = float_to_ubyte(pRow[0]);
 337          g = float_to_ubyte(pRow[1]);
 338          b = float_to_ubyte(pRow[2]);
 339          a = float_to_ubyte(pRow[3]);
 340          r >>= 4;
 341          g >>= 4;
 342          b >>= 4;
 343          a >>= 4;
 344          *dst++ = (a << 12) | (r << 16) | (g << 4) | b;
 345       }
 346       p += src_stride;
 347    }
 348 }
 349
 350
 351 /*** PIPE_FORMAT_R5G6B5_UNORM ***/
 352
 353 static void
 354 r5g6b5_get_tile_rgba(const ushort *src,
 355                      unsigned w, unsigned h,
 356                      float *p,
 357                      unsigned dst_stride)
 358 {
 359    unsigned i, j;
 360
 361    for (i = 0; i < h; i++) {
 362       float *pRow = p;
 363       for (j = 0; j < w; j++, pRow += 4) {
 364          const ushort pixel = *src++;
 365          pRow[0] = ((pixel >> 11) & 0x1f) * (1.0f / 31.0f);
 366          pRow[1] = ((pixel >>  5) & 0x3f) * (1.0f / 63.0f);
 367          pRow[2] = ((pixel      ) & 0x1f) * (1.0f / 31.0f);
 368          pRow[3] = 1.0f;
 369       }
 370       p += dst_stride;
 371    }
 372 }
 373
 374
 375 static void
 376 r5g6b5_put_tile_rgba(ushort *dst,
 377                      unsigned w, unsigned h,
 378                      const float *p,
 379                      unsigned src_stride)
 380 {
 381    unsigned i, j;
 382
 383    for (i = 0; i < h; i++) {
 384       const float *pRow = p;
 385       for (j = 0; j < w; j++, pRow += 4) {
 386          uint r = (uint) (CLAMP(pRow[0], 0.0, 1.0) * 31.0);
 387          uint g = (uint) (CLAMP(pRow[1], 0.0, 1.0) * 63.0);
 388          uint b = (uint) (CLAMP(pRow[2], 0.0, 1.0) * 31.0);
 389          *dst++ = (r << 11) | (g << 5) | (b);
 390       }
 391       p += src_stride;
 392    }
 393 }
 394
 395
 396
 397 /*** PIPE_FORMAT_Z16_UNORM ***/
 398
 399 /**
 400  * Return each Z value as four floats in [0,1].
 401  */
 402 static void
 403 z16_get_tile_rgba(const ushort *src,
 404                   unsigned w, unsigned h,
 405                   float *p,
 406                   unsigned dst_stride)
 407 {
 408    const float scale = 1.0f / 65535.0f;
 409    unsigned i, j;
 410
 411    for (i = 0; i < h; i++) {
 412       float *pRow = p;
 413       for (j = 0; j < w; j++, pRow += 4) {
 414          pRow[0] =
 415          pRow[1] =
 416          pRow[2] =
 417          pRow[3] = *src++ * scale;
 418       }
 419       p += dst_stride;
 420    }
 421 }
 422
 423
 424
 425
 426 /*** PIPE_FORMAT_L8_UNORM ***/
 427
 428 static void
 429 l8_get_tile_rgba(const ubyte *src,
 430                  unsigned w, unsigned h,
 431                  float *p,
 432                  unsigned dst_stride)
 433 {
 434    unsigned i, j;
 435
 436    for (i = 0; i < h; i++) {
 437       float *pRow = p;
 438       for (j = 0; j < w; j++, src++, pRow += 4) {
 439          pRow[0] =
 440          pRow[1] =
 441          pRow[2] = ubyte_to_float(*src);
 442          pRow[3] = 1.0;
 443       }
 444       p += dst_stride;
 445    }
 446 }
 447
 448
 449 static void
 450 l8_put_tile_rgba(ubyte *dst,
 451                  unsigned w, unsigned h,
 452                  const float *p,
 453                  unsigned src_stride)
 454 {
 455    unsigned i, j;
 456
 457    for (i = 0; i < h; i++) {
 458       const float *pRow = p;
 459       for (j = 0; j < w; j++, pRow += 4) {
 460          unsigned r;
 461          r = float_to_ubyte(pRow[0]);
 462          *dst++ = (ubyte) r;
 463       }
 464       p += src_stride;
 465    }
 466 }
 467
 468
 469
 470 /*** PIPE_FORMAT_A8_UNORM ***/
 471
 472 static void
 473 a8_get_tile_rgba(const ubyte *src,
 474                  unsigned w, unsigned h,
 475                  float *p,
 476                  unsigned dst_stride)
 477 {
 478    unsigned i, j;
 479
 480    for (i = 0; i < h; i++) {
 481       float *pRow = p;
 482       for (j = 0; j < w; j++, src++, pRow += 4) {
 483          pRow[0] =
 484          pRow[1] =
 485          pRow[2] = 0.0;
 486          pRow[3] = ubyte_to_float(*src);
 487       }
 488       p += dst_stride;
 489    }
 490 }
 491
 492
 493 static void
 494 a8_put_tile_rgba(ubyte *dst,
 495                  unsigned w, unsigned h,
 496                  const float *p,
 497                  unsigned src_stride)
 498 {
 499    unsigned i, j;
 500
 501    for (i = 0; i < h; i++) {
 502       const float *pRow = p;
 503       for (j = 0; j < w; j++, pRow += 4) {
 504          unsigned a;
 505          a = float_to_ubyte(pRow[3]);
 506          *dst++ = (ubyte) a;
 507       }
 508       p += src_stride;
 509    }
 510 }
 511
 512
 513
 514 /*** PIPE_FORMAT_R16_SNORM ***/
 515
 516 static void
 517 r16_get_tile_rgba(const short *src,
 518                   unsigned w, unsigned h,
 519                   float *p,
 520                   unsigned dst_stride)
 521 {
 522    unsigned i, j;
 523
 524    for (i = 0; i < h; i++) {
 525       float *pRow = p;
 526       for (j = 0; j < w; j++, src++, pRow += 4) {
 527          pRow[0] = SHORT_TO_FLOAT(src[0]);
 528          pRow[1] =
 529          pRow[2] = 0.0;
 530          pRow[3] = 1.0;
 531       }
 532       p += dst_stride;
 533    }
 534 }
 535
 536
 537 static void
 538 r16_put_tile_rgba(short *dst,
 539                   unsigned w, unsigned h,
 540                   const float *p,
 541                   unsigned src_stride)
 542 {
 543    unsigned i, j;
 544
 545    for (i = 0; i < h; i++) {
 546       const float *pRow = p;
 547       for (j = 0; j < w; j++, dst++, pRow += 4) {
 548          UNCLAMPED_FLOAT_TO_SHORT(dst[0], pRow[0]);
 549       }
 550       p += src_stride;
 551    }
 552 }
 553
 554
 555 /*** PIPE_FORMAT_R16G16B16A16_SNORM ***/
 556
 557 static void
 558 r16g16b16a16_get_tile_rgba(const short *src,
 559                            unsigned w, unsigned h,
 560                            float *p,
 561                            unsigned dst_stride)
 562 {
 563    unsigned i, j;
 564
 565    for (i = 0; i < h; i++) {
 566       float *pRow = p;
 567       for (j = 0; j < w; j++, src += 4, pRow += 4) {
 568          pRow[0] = SHORT_TO_FLOAT(src[0]);
 569          pRow[1] = SHORT_TO_FLOAT(src[1]);
 570          pRow[2] = SHORT_TO_FLOAT(src[2]);
 571          pRow[3] = SHORT_TO_FLOAT(src[3]);
 572       }
 573       p += dst_stride;
 574    }
 575 }
 576
 577
 578 static void
 579 r16g16b16a16_put_tile_rgba(short *dst,
 580                            unsigned w, unsigned h,
 581                            const float *p,
 582                            unsigned src_stride)
 583 {
 584    unsigned i, j;
 585
 586    for (i = 0; i < h; i++) {
 587       const float *pRow = p;
 588       for (j = 0; j < w; j++, dst += 4, pRow += 4) {
 589          UNCLAMPED_FLOAT_TO_SHORT(dst[0], pRow[0]);
 590          UNCLAMPED_FLOAT_TO_SHORT(dst[1], pRow[1]);
 591          UNCLAMPED_FLOAT_TO_SHORT(dst[2], pRow[2]);
 592          UNCLAMPED_FLOAT_TO_SHORT(dst[3], pRow[3]);
 593       }
 594       p += src_stride;
 595    }
 596 }
 597
 598
 599 /*** PIPE_FORMAT_R8G8B8A8_SRGB ***/
 600
 601 /**
 602  * Convert an 8-bit sRGB value from non-linear space to a
 603  * linear RGB value in [0, 1].
 604  * Implemented with a 256-entry lookup table.
 605  */
 606 static INLINE float
 607 srgb_to_linear(ubyte cs8)
 608 {
 609    static float table[256];
 610    static boolean tableReady = FALSE;
 611    if (!tableReady) {
 612       /* compute lookup table now */
 613       uint i;
 614       for (i = 0; i < 256; i++) {
 615          const float cs = ubyte_to_float(i);
 616          if (cs <= 0.04045) {
 617             table[i] = cs / 12.92f;
 618          }
 619          else {
 620             table[i] = (float) powf((cs + 0.055) / 1.055, 2.4);
 621          }
 622       }
 623       tableReady = TRUE;
 624    }
 625    return table[cs8];
 626 }
 627
 628
 629 /**
 630  * Convert linear float in [0,1] to an srgb ubyte value in [0,255].
 631  * XXX this hasn't been tested (render to srgb surface).
 632  * XXX this needs optimization.
 633  */
 634 static INLINE ubyte
 635 linear_to_srgb(float cl)
 636 {
 637    if (cl >= 1.0F)
 638       return 255;
 639    else if (cl >= 0.0031308F)
 640       return float_to_ubyte(1.055F * powf(cl, 0.41666F) - 0.055F);
 641    else if (cl > 0.0F)
 642       return float_to_ubyte(12.92F * cl);
 643    else
 644       return 0.0;
 645 }
 646
 647
 648 static void
 649 a8r8g8b8_srgb_get_tile_rgba(const unsigned *src,
 650                             unsigned w, unsigned h,
 651                             float *p,
 652                             unsigned dst_stride)
 653 {
 654    unsigned i, j;
 655
 656    for (i = 0; i < h; i++) {
 657       float *pRow = p;
 658       for (j = 0; j < w; j++, pRow += 4) {
 659          const unsigned pixel = *src++;
 660          pRow[0] = srgb_to_linear((pixel >> 16) & 0xff);
 661          pRow[1] = srgb_to_linear((pixel >>  8) & 0xff);
 662          pRow[2] = srgb_to_linear((pixel >>  0) & 0xff);
 663          pRow[3] = ubyte_to_float((pixel >> 24) & 0xff);
 664       }
 665       p += dst_stride;
 666    }
 667 }
 668
 669 static void
 670 a8r8g8b8_srgb_put_tile_rgba(unsigned *dst,
 671                             unsigned w, unsigned h,
 672                             const float *p,
 673                             unsigned src_stride)
 674 {
 675    unsigned i, j;
 676
 677    for (i = 0; i < h; i++) {
 678       const float *pRow = p;
 679       for (j = 0; j < w; j++, pRow += 4) {
 680          unsigned r, g, b, a;
 681          r = linear_to_srgb(pRow[0]);
 682          g = linear_to_srgb(pRow[1]);
 683          b = linear_to_srgb(pRow[2]);
 684          a = float_to_ubyte(pRow[3]);
 685          *dst++ = (a << 24) | (r << 16) | (g << 8) | b;
 686       }
 687       p += src_stride;
 688    }
 689 }
 690
 691
 692 /*** PIPE_FORMAT_A8L8_SRGB ***/
 693
 694 static void
 695 a8l8_srgb_get_tile_rgba(const ushort *src,
 696                         unsigned w, unsigned h,
 697                         float *p,
 698                         unsigned dst_stride)
 699 {
 700    unsigned i, j;
 701
 702    for (i = 0; i < h; i++) {
 703       float *pRow = p;
 704       for (j = 0; j < w; j++, pRow += 4) {
 705          ushort p = *src++;
 706          pRow[0] =
 707          pRow[1] =
 708          pRow[2] = srgb_to_linear(p & 0xff);
 709          pRow[3] = ubyte_to_float(p >> 8);
 710       }
 711       p += dst_stride;
 712    }
 713 }
 714
 715 static void
 716 a8l8_srgb_put_tile_rgba(ushort *dst,
 717                         unsigned w, unsigned h,
 718                         const float *p,
 719                         unsigned src_stride)
 720 {
 721    unsigned i, j;
 722
 723    for (i = 0; i < h; i++) {
 724       const float *pRow = p;
 725       for (j = 0; j < w; j++, pRow += 4) {
 726          unsigned r, a;
 727          r = linear_to_srgb(pRow[0]);
 728          a = float_to_ubyte(pRow[3]);
 729          *dst++ = (a << 8) | r;
 730       }
 731       p += src_stride;
 732    }
 733 }
 734
 735
 736 /*** PIPE_FORMAT_L8_SRGB ***/
 737
 738 static void
 739 l8_srgb_get_tile_rgba(const ubyte *src,
 740                       unsigned w, unsigned h,
 741                       float *p,
 742                       unsigned dst_stride)
 743 {
 744    unsigned i, j;
 745
 746    for (i = 0; i < h; i++) {
 747       float *pRow = p;
 748       for (j = 0; j < w; j++, src++, pRow += 4) {
 749          pRow[0] =
 750          pRow[1] =
 751          pRow[2] = srgb_to_linear(*src);
 752          pRow[3] = 1.0;
 753       }
 754       p += dst_stride;
 755    }
 756 }
 757
 758 static void
 759 l8_srgb_put_tile_rgba(ubyte *dst,
 760                       unsigned w, unsigned h,
 761                       const float *p,
 762                       unsigned src_stride)
 763 {
 764    unsigned i, j;
 765
 766    for (i = 0; i < h; i++) {
 767       const float *pRow = p;
 768       for (j = 0; j < w; j++, pRow += 4) {
 769          unsigned r;
 770          r = linear_to_srgb(pRow[0]);
 771          *dst++ = (ubyte) r;
 772       }
 773       p += src_stride;
 774    }
 775 }
 776
 777
 778 /*** PIPE_FORMAT_I8_UNORM ***/
 779
 780 static void
 781 i8_get_tile_rgba(const ubyte *src,
 782                  unsigned w, unsigned h,
 783                  float *p,
 784                  unsigned dst_stride)
 785 {
 786    unsigned i, j;
 787
 788    for (i = 0; i < h; i++) {
 789       float *pRow = p;
 790       for (j = 0; j < w; j++, src++, pRow += 4) {
 791          pRow[0] =
 792          pRow[1] =
 793          pRow[2] =
 794          pRow[3] = ubyte_to_float(*src);
 795       }
 796       p += dst_stride;
 797    }
 798 }
 799
 800
 801 static void
 802 i8_put_tile_rgba(ubyte *dst,
 803                  unsigned w, unsigned h,
 804                  const float *p,
 805                  unsigned src_stride)
 806 {
 807    unsigned i, j;
 808
 809    for (i = 0; i < h; i++) {
 810       const float *pRow = p;
 811       for (j = 0; j < w; j++, pRow += 4) {
 812          unsigned r;
 813          r = float_to_ubyte(pRow[0]);
 814          *dst++ = (ubyte) r;
 815       }
 816       p += src_stride;
 817    }
 818 }
 819
 820
 821 /*** PIPE_FORMAT_A8L8_UNORM ***/
 822
 823 static void
 824 a8l8_get_tile_rgba(const ushort *src,
 825                    unsigned w, unsigned h,
 826                    float *p,
 827                    unsigned dst_stride)
 828 {
 829    unsigned i, j;
 830
 831    for (i = 0; i < h; i++) {
 832       float *pRow = p;
 833       for (j = 0; j < w; j++, pRow += 4) {
 834          ushort p = *src++;
 835          pRow[0] =
 836          pRow[1] =
 837          pRow[2] = ubyte_to_float(p & 0xff);
 838          pRow[3] = ubyte_to_float(p >> 8);
 839       }
 840       p += dst_stride;
 841    }
 842 }
 843
 844
 845 static void
 846 a8l8_put_tile_rgba(ushort *dst,
 847                    unsigned w, unsigned h,
 848                    const float *p,
 849                    unsigned src_stride)
 850 {
 851    unsigned i, j;
 852
 853    for (i = 0; i < h; i++) {
 854       const float *pRow = p;
 855       for (j = 0; j < w; j++, pRow += 4) {
 856          unsigned r, a;
 857          r = float_to_ubyte(pRow[0]);
 858          a = float_to_ubyte(pRow[3]);
 859          *dst++ = (a << 8) | r;
 860       }
 861       p += src_stride;
 862    }
 863 }
 864
 865
 866
 867
 868 /*** PIPE_FORMAT_Z32_UNORM ***/
 869
 870 /**
 871  * Return each Z value as four floats in [0,1].
 872  */
 873 static void
 874 z32_get_tile_rgba(const unsigned *src,
 875                   unsigned w, unsigned h,
 876                   float *p,
 877                   unsigned dst_stride)
 878 {
 879    const double scale = 1.0 / (double) 0xffffffff;
 880    unsigned i, j;
 881
 882    for (i = 0; i < h; i++) {
 883       float *pRow = p;
 884       for (j = 0; j < w; j++, pRow += 4) {
 885          pRow[0] =
 886          pRow[1] =
 887          pRow[2] =
 888          pRow[3] = (float) (*src++ * scale);
 889       }
 890       p += dst_stride;
 891    }
 892 }
 893
 894
 895 /*** PIPE_FORMAT_S8Z24_UNORM ***/
 896
 897 /**
 898  * Return Z component as four float in [0,1].  Stencil part ignored.
 899  */
 900 static void
 901 s8z24_get_tile_rgba(const unsigned *src,
 902                     unsigned w, unsigned h,
 903                     float *p,
 904                     unsigned dst_stride)
 905 {
 906    const double scale = 1.0 / ((1 << 24) - 1);
 907    unsigned i, j;
 908
 909    for (i = 0; i < h; i++) {
 910       float *pRow = p;
 911       for (j = 0; j < w; j++, pRow += 4) {
 912          pRow[0] =
 913          pRow[1] =
 914          pRow[2] =
 915          pRow[3] = (float) (scale * (*src++ & 0xffffff));
 916       }
 917       p += dst_stride;
 918    }
 919 }
 920
 921
 922 /*** PIPE_FORMAT_Z24S8_UNORM ***/
 923
 924 /**
 925  * Return Z component as four float in [0,1].  Stencil part ignored.
 926  */
 927 static void
 928 z24s8_get_tile_rgba(const unsigned *src,
 929                     unsigned w, unsigned h,
 930                     float *p,
 931                     unsigned dst_stride)
 932 {
 933    const double scale = 1.0 / ((1 << 24) - 1);
 934    unsigned i, j;
 935
 936    for (i = 0; i < h; i++) {
 937       float *pRow = p;
 938       for (j = 0; j < w; j++, pRow += 4) {
 939          pRow[0] =
 940          pRow[1] =
 941          pRow[2] =
 942          pRow[3] = (float) (scale * (*src++ >> 8));
 943       }
 944       p += dst_stride;
 945    }
 946 }
 947
 948
 949 /*** PIPE_FORMAT_Z32_FLOAT ***/
 950
 951 /**
 952  * Return each Z value as four floats in [0,1].
 953  */
 954 static void
 955 z32f_get_tile_rgba(const float *src,
 956                    unsigned w, unsigned h,
 957                    float *p,
 958                    unsigned dst_stride)
 959 {
 960    unsigned i, j;
 961
 962    for (i = 0; i < h; i++) {
 963       float *pRow = p;
 964       for (j = 0; j < w; j++, pRow += 4) {
 965          pRow[0] =
 966          pRow[1] =
 967          pRow[2] =
 968          pRow[3] = *src++;
 969       }
 970       p += dst_stride;
 971    }
 972 }
 973
 974
 975 /*** PIPE_FORMAT_YCBCR / PIPE_FORMAT_YCBCR_REV ***/
 976
 977 /**
 978  * Convert YCbCr (or YCrCb) to RGBA.
 979  */
 980 static void
 981 ycbcr_get_tile_rgba(const ushort *src,
 982                     unsigned w, unsigned h,
 983                     float *p,
 984                     unsigned dst_stride,
 985                     boolean rev)
 986 {
 987    const float scale = 1.0f / 255.0f;
 988    unsigned i, j;
 989
 990    for (i = 0; i < h; i++) {
 991       float *pRow = p;
 992       /* do two texels at a time */
 993       for (j = 0; j < (w & ~1); j += 2, src += 2) {
 994          const ushort t0 = src[0];
 995          const ushort t1 = src[1];
 996          const ubyte y0 = (t0 >> 8) & 0xff;  /* luminance */
 997          const ubyte y1 = (t1 >> 8) & 0xff;  /* luminance */
 998          ubyte cb, cr;
 999          float r, g, b;
1000
1001          if (rev) {
1002             cb = t1 & 0xff;         /* chroma U */
1003             cr = t0 & 0xff;         /* chroma V */
1004          }
1005          else {
1006             cb = t0 & 0xff;         /* chroma U */
1007             cr = t1 & 0xff;         /* chroma V */
1008          }
1009
1010          /* even pixel: y0,cr,cb */
1011          r = 1.164f * (y0-16) + 1.596f * (cr-128);
1012          g = 1.164f * (y0-16) - 0.813f * (cr-128) - 0.391f * (cb-128);
1013          b = 1.164f * (y0-16) + 2.018f * (cb-128);
1014          pRow[0] = r * scale;
1015          pRow[1] = g * scale;
1016          pRow[2] = b * scale;
1017          pRow[3] = 1.0f;
1018          pRow += 4;
1019
1020          /* odd pixel: use y1,cr,cb */
1021          r = 1.164f * (y1-16) + 1.596f * (cr-128);
1022          g = 1.164f * (y1-16) - 0.813f * (cr-128) - 0.391f * (cb-128);
1023          b = 1.164f * (y1-16) + 2.018f * (cb-128);
1024          pRow[0] = r * scale;
1025          pRow[1] = g * scale;
1026          pRow[2] = b * scale;
1027          pRow[3] = 1.0f;
1028          pRow += 4;
1029
1030       }
1031       /* do the last texel */
1032       if (w & 1) {
1033          const ushort t0 = src[0];
1034          const ushort t1 = src[1];
1035          const ubyte y0 = (t0 >> 8) & 0xff;  /* luminance */
1036          ubyte cb, cr;
1037          float r, g, b;
1038
1039          if (rev) {
1040             cb = t1 & 0xff;         /* chroma U */
1041             cr = t0 & 0xff;         /* chroma V */
1042          }
1043          else {
1044             cb = t0 & 0xff;         /* chroma U */
1045             cr = t1 & 0xff;         /* chroma V */
1046          }
1047
1048          /* even pixel: y0,cr,cb */
1049          r = 1.164f * (y0-16) + 1.596f * (cr-128);
1050          g = 1.164f * (y0-16) - 0.813f * (cr-128) - 0.391f * (cb-128);
1051          b = 1.164f * (y0-16) + 2.018f * (cb-128);
1052          pRow[0] = r * scale;
1053          pRow[1] = g * scale;
1054          pRow[2] = b * scale;
1055          pRow[3] = 1.0f;
1056          pRow += 4;
1057       }
1058       p += dst_stride;
1059    }
1060 }
1061
1062
1063 static void
1064 fake_get_tile_rgba(const ushort *src,
1065                    unsigned w, unsigned h,
1066                    float *p,
1067                    unsigned dst_stride)
1068 {
1069    unsigned i, j;
1070
1071    for (i = 0; i < h; i++) {
1072       float *pRow = p;
1073       for (j = 0; j < w; j++, pRow += 4) {
1074          pRow[0] =
1075          pRow[1] =
1076          pRow[2] =
1077          pRow[3] = (i ^ j) & 1 ? 1.0f : 0.0f;
1078       }
1079       p += dst_stride;
1080    }
1081 }
1082
1083
1084 void
1085 pipe_tile_raw_to_rgba(enum pipe_format format,
1086                       void *src,
1087                       uint w, uint h,
1088                       float *dst, unsigned dst_stride)
1089 {
1090    switch (format) {
1091    case PIPE_FORMAT_A8R8G8B8_UNORM:
1092       a8r8g8b8_get_tile_rgba((unsigned *) src, w, h, dst, dst_stride);
1093       break;
1094    case PIPE_FORMAT_X8R8G8B8_UNORM:
1095       x8r8g8b8_get_tile_rgba((unsigned *) src, w, h, dst, dst_stride);
1096       break;
1097    case PIPE_FORMAT_B8G8R8A8_UNORM:
1098       b8g8r8a8_get_tile_rgba((unsigned *) src, w, h, dst, dst_stride);
1099       break;
1100    case PIPE_FORMAT_A1R5G5B5_UNORM:
1101       a1r5g5b5_get_tile_rgba((ushort *) src, w, h, dst, dst_stride);
1102       break;
1103    case PIPE_FORMAT_A4R4G4B4_UNORM:
1104       a4r4g4b4_get_tile_rgba((ushort *) src, w, h, dst, dst_stride);
1105       break;
1106    case PIPE_FORMAT_R5G6B5_UNORM:
1107       r5g6b5_get_tile_rgba((ushort *) src, w, h, dst, dst_stride);
1108       break;
1109    case PIPE_FORMAT_L8_UNORM:
1110       l8_get_tile_rgba((ubyte *) src, w, h, dst, dst_stride);
1111       break;
1112    case PIPE_FORMAT_A8_UNORM:
1113       a8_get_tile_rgba((ubyte *) src, w, h, dst, dst_stride);
1114       break;
1115    case PIPE_FORMAT_I8_UNORM:
1116       i8_get_tile_rgba((ubyte *) src, w, h, dst, dst_stride);
1117       break;
1118    case PIPE_FORMAT_A8L8_UNORM:
1119       a8l8_get_tile_rgba((ushort *) src, w, h, dst, dst_stride);
1120       break;
1121    case PIPE_FORMAT_R16_SNORM:
1122       r16_get_tile_rgba((short *) src, w, h, dst, dst_stride);
1123       break;
1124    case PIPE_FORMAT_R16G16B16A16_SNORM:
1125       r16g16b16a16_get_tile_rgba((short *) src, w, h, dst, dst_stride);
1126       break;
1127    case PIPE_FORMAT_A8R8G8B8_SRGB:
1128       a8r8g8b8_srgb_get_tile_rgba((unsigned *) src, w, h, dst, dst_stride);
1129       break;
1130    case PIPE_FORMAT_A8L8_SRGB:
1131       a8l8_srgb_get_tile_rgba((ushort *) src, w, h, dst, dst_stride);
1132       break;
1133    case PIPE_FORMAT_L8_SRGB:
1134       l8_srgb_get_tile_rgba((ubyte *) src, w, h, dst, dst_stride);
1135       break;
1136    case PIPE_FORMAT_Z16_UNORM:
1137       z16_get_tile_rgba((ushort *) src, w, h, dst, dst_stride);
1138       break;
1139    case PIPE_FORMAT_Z32_UNORM:
1140       z32_get_tile_rgba((unsigned *) src, w, h, dst, dst_stride);
1141       break;
1142    case PIPE_FORMAT_S8Z24_UNORM:
1143    case PIPE_FORMAT_X8Z24_UNORM:
1144       s8z24_get_tile_rgba((unsigned *) src, w, h, dst, dst_stride);
1145       break;
1146    case PIPE_FORMAT_Z24S8_UNORM:
1147    case PIPE_FORMAT_Z24X8_UNORM:
1148       z24s8_get_tile_rgba((unsigned *) src, w, h, dst, dst_stride);
1149       break;
1150    case PIPE_FORMAT_Z32_FLOAT:
1151       z32f_get_tile_rgba((float *) src, w, h, dst, dst_stride);
1152       break;
1153    case PIPE_FORMAT_YCBCR:
1154       ycbcr_get_tile_rgba((ushort *) src, w, h, dst, dst_stride, FALSE);
1155       break;
1156    case PIPE_FORMAT_YCBCR_REV:
1157       ycbcr_get_tile_rgba((ushort *) src, w, h, dst, dst_stride, TRUE);
1158       break;
1159    default:
1160       debug_printf("%s: unsupported format %s\n", __FUNCTION__, pf_name(format));
1161       fake_get_tile_rgba(src, w, h, dst, dst_stride);
1162    }
1163 }
1164
1165
1166 void
1167 pipe_get_tile_rgba(struct pipe_transfer *pt,
1168                    uint x, uint y, uint w, uint h,
1169                    float *p)
1170 {
1171    unsigned dst_stride = w * 4;
1172    void *packed;
1173
1174    if (pipe_clip_tile(x, y, &w, &h, pt))
1175       return;
1176
1177    packed = MALLOC(pf_get_nblocks(&pt->block, w, h) * pt->block.size);
1178
1179    if (!packed)
1180       return;
1181
1182    if(pt->format == PIPE_FORMAT_YCBCR || pt->format == PIPE_FORMAT_YCBCR_REV)
1183       assert((x & 1) == 0);
1184
1185    pipe_get_tile_raw(pt, x, y, w, h, packed, 0);
1186
1187    pipe_tile_raw_to_rgba(pt->format, packed, w, h, p, dst_stride);
1188
1189    FREE(packed);
1190 }
1191
1192
1193 void
1194 pipe_put_tile_rgba(struct pipe_transfer *pt,
1195                    uint x, uint y, uint w, uint h,
1196                    const float *p)
1197 {
1198    unsigned src_stride = w * 4;
1199    void *packed;
1200
1201    if (pipe_clip_tile(x, y, &w, &h, pt))
1202       return;
1203
1204    packed = MALLOC(pf_get_nblocks(&pt->block, w, h) * pt->block.size);
1205
1206    if (!packed)
1207       return;
1208
1209    switch (pt->format) {
1210    case PIPE_FORMAT_A8R8G8B8_UNORM:
1211       a8r8g8b8_put_tile_rgba((unsigned *) packed, w, h, p, src_stride);
1212       break;
1213    case PIPE_FORMAT_X8R8G8B8_UNORM:
1214       x8r8g8b8_put_tile_rgba((unsigned *) packed, w, h, p, src_stride);
1215       break;
1216    case PIPE_FORMAT_B8G8R8A8_UNORM:
1217       b8g8r8a8_put_tile_rgba((unsigned *) packed, w, h, p, src_stride);
1218       break;
1219    case PIPE_FORMAT_A1R5G5B5_UNORM:
1220       a1r5g5b5_put_tile_rgba((ushort *) packed, w, h, p, src_stride);
1221       break;
1222    case PIPE_FORMAT_R5G6B5_UNORM:
1223       r5g6b5_put_tile_rgba((ushort *) packed, w, h, p, src_stride);
1224       break;
1225    case PIPE_FORMAT_R8G8B8A8_UNORM:
1226       assert(0);
1227       break;
1228    case PIPE_FORMAT_A4R4G4B4_UNORM:
1229       a4r4g4b4_put_tile_rgba((ushort *) packed, w, h, p, src_stride);
1230       break;
1231    case PIPE_FORMAT_L8_UNORM:
1232       l8_put_tile_rgba((ubyte *) packed, w, h, p, src_stride);
1233       break;
1234    case PIPE_FORMAT_A8_UNORM:
1235       a8_put_tile_rgba((ubyte *) packed, w, h, p, src_stride);
1236       break;
1237    case PIPE_FORMAT_I8_UNORM:
1238       i8_put_tile_rgba((ubyte *) packed, w, h, p, src_stride);
1239       break;
1240    case PIPE_FORMAT_A8L8_UNORM:
1241       a8l8_put_tile_rgba((ushort *) packed, w, h, p, src_stride);
1242       break;
1243    case PIPE_FORMAT_R16_SNORM:
1244       r16_put_tile_rgba((short *) packed, w, h, p, src_stride);
1245       break;
1246    case PIPE_FORMAT_R16G16B16A16_SNORM:
1247       r16g16b16a16_put_tile_rgba((short *) packed, w, h, p, src_stride);
1248       break;
1249    case PIPE_FORMAT_A8R8G8B8_SRGB:
1250       a8r8g8b8_srgb_put_tile_rgba((unsigned *) packed, w, h, p, src_stride);
1251       break;
1252    case PIPE_FORMAT_A8L8_SRGB:
1253       a8l8_srgb_put_tile_rgba((ushort *) packed, w, h, p, src_stride);
1254       break;
1255    case PIPE_FORMAT_L8_SRGB:
1256       l8_srgb_put_tile_rgba((ubyte *) packed, w, h, p, src_stride);
1257       break;
1258    case PIPE_FORMAT_Z16_UNORM:
1259       /*z16_put_tile_rgba((ushort *) packed, w, h, p, src_stride);*/
1260       break;
1261    case PIPE_FORMAT_Z32_UNORM:
1262       /*z32_put_tile_rgba((unsigned *) packed, w, h, p, src_stride);*/
1263       break;
1264    case PIPE_FORMAT_S8Z24_UNORM:
1265    case PIPE_FORMAT_X8Z24_UNORM:
1266       /*s8z24_put_tile_rgba((unsigned *) packed, w, h, p, src_stride);*/
1267       break;
1268    case PIPE_FORMAT_Z24S8_UNORM:
1269    case PIPE_FORMAT_Z24X8_UNORM:
1270       /*z24s8_put_tile_rgba((unsigned *) packed, w, h, p, src_stride);*/
1271       break;
1272    default:
1273       debug_printf("%s: unsupported format %s\n", __FUNCTION__, pf_name(pt->format));
1274    }
1275
1276    pipe_put_tile_raw(pt, x, y, w, h, packed, 0);
1277
1278    FREE(packed);
1279 }
1280
1281
1282 /**
1283  * Get a block of Z values, converted to 32-bit range.
1284  */
1285 void
1286 pipe_get_tile_z(struct pipe_transfer *pt,
1287                 uint x, uint y, uint w, uint h,
1288                 uint *z)
1289 {
1290    struct pipe_screen *screen = pt->texture->screen;
1291    const uint dstStride = w;
1292    ubyte *map;
1293    uint *pDest = z;
1294    uint i, j;
1295
1296    if (pipe_clip_tile(x, y, &w, &h, pt))
1297       return;
1298
1299    map = (ubyte *)screen->transfer_map(screen, pt);
1300    if (!map) {
1301       assert(0);
1302       return;
1303    }
1304
1305    switch (pt->format) {
1306    case PIPE_FORMAT_Z32_UNORM:
1307       {
1308          const uint *ptrc
1309             = (const uint *)(map  + y * pt->stride + x*4);
1310          for (i = 0; i < h; i++) {
1311             memcpy(pDest, ptrc, 4 * w);
1312             pDest += dstStride;
1313             ptrc += pt->stride/4;
1314          }
1315       }
1316       break;
1317    case PIPE_FORMAT_S8Z24_UNORM:
1318    case PIPE_FORMAT_X8Z24_UNORM:
1319       {
1320          const uint *ptrc
1321             = (const uint *)(map + y * pt->stride + x*4);
1322          for (i = 0; i < h; i++) {
1323             for (j = 0; j < w; j++) {
1324                /* convert 24-bit Z to 32-bit Z */
1325                pDest[j] = (ptrc[j] << 8) | ((ptrc[j] >> 16) & 0xff);
1326             }
1327             pDest += dstStride;
1328             ptrc += pt->stride/4;
1329          }
1330       }
1331       break;
1332    case PIPE_FORMAT_Z24S8_UNORM:
1333    case PIPE_FORMAT_Z24X8_UNORM:
1334       {
1335          const uint *ptrc
1336             = (const uint *)(map + y * pt->stride + x*4);
1337          for (i = 0; i < h; i++) {
1338             for (j = 0; j < w; j++) {
1339                /* convert 24-bit Z to 32-bit Z */
1340                pDest[j] = (ptrc[j] & 0xffffff00) | ((ptrc[j] >> 24) & 0xff);
1341             }
1342             pDest += dstStride;
1343             ptrc += pt->stride/4;
1344          }
1345       }
1346       break;
1347    case PIPE_FORMAT_Z16_UNORM:
1348       {
1349          const ushort *ptrc
1350             = (const ushort *)(map + y * pt->stride + x*2);
1351          for (i = 0; i < h; i++) {
1352             for (j = 0; j < w; j++) {
1353                /* convert 16-bit Z to 32-bit Z */
1354                pDest[j] = (ptrc[j] << 16) | ptrc[j];
1355             }
1356             pDest += dstStride;
1357             ptrc += pt->stride/2;
1358          }
1359       }
1360       break;
1361    default:
1362       assert(0);
1363    }
1364
1365    screen->transfer_unmap(screen, pt);
1366 }
1367
1368
1369 void
1370 pipe_put_tile_z(struct pipe_transfer *pt,
1371                 uint x, uint y, uint w, uint h,
1372                 const uint *zSrc)
1373 {
1374    struct pipe_screen *screen = pt->texture->screen;
1375    const uint srcStride = w;
1376    const uint *ptrc = zSrc;
1377    ubyte *map;
1378    uint i, j;
1379
1380    if (pipe_clip_tile(x, y, &w, &h, pt))
1381       return;
1382
1383    map = (ubyte *)screen->transfer_map(screen, pt);
1384    if (!map) {
1385       assert(0);
1386       return;
1387    }
1388
1389    switch (pt->format) {
1390    case PIPE_FORMAT_Z32_UNORM:
1391       {
1392          uint *pDest = (uint *) (map + y * pt->stride + x*4);
1393          for (i = 0; i < h; i++) {
1394             memcpy(pDest, ptrc, 4 * w);
1395             pDest += pt->stride/4;
1396             ptrc += srcStride;
1397          }
1398       }
1399       break;
1400    case PIPE_FORMAT_S8Z24_UNORM:
1401       {
1402          uint *pDest = (uint *) (map + y * pt->stride + x*4);
1403          assert(pt->usage == PIPE_TRANSFER_READ_WRITE);
1404          for (i = 0; i < h; i++) {
1405             for (j = 0; j < w; j++) {
1406                /* convert 32-bit Z to 24-bit Z, preserve stencil */
1407                pDest[j] = (pDest[j] & 0xff000000) | ptrc[j] >> 8;
1408             }
1409             pDest += pt->stride/4;
1410             ptrc += srcStride;
1411          }
1412       }
1413       break;
1414    case PIPE_FORMAT_X8Z24_UNORM:
1415       {
1416          uint *pDest = (uint *) (map + y * pt->stride + x*4);
1417          for (i = 0; i < h; i++) {
1418             for (j = 0; j < w; j++) {
1419                /* convert 32-bit Z to 24-bit Z (0 stencil) */
1420                pDest[j] = ptrc[j] >> 8;
1421             }
1422             pDest += pt->stride/4;
1423             ptrc += srcStride;
1424          }
1425       }
1426       break;
1427    case PIPE_FORMAT_Z24S8_UNORM:
1428       {
1429          uint *pDest = (uint *) (map + y * pt->stride + x*4);
1430          assert(pt->usage == PIPE_TRANSFER_READ_WRITE);
1431          for (i = 0; i < h; i++) {
1432             for (j = 0; j < w; j++) {
1433                /* convert 32-bit Z to 24-bit Z, preserve stencil */
1434                pDest[j] = (pDest[j] & 0xff) | (ptrc[j] & 0xffffff00);
1435             }
1436             pDest += pt->stride/4;
1437             ptrc += srcStride;
1438          }
1439       }
1440       break;
1441    case PIPE_FORMAT_Z24X8_UNORM:
1442       {
1443          uint *pDest = (uint *) (map + y * pt->stride + x*4);
1444          for (i = 0; i < h; i++) {
1445             for (j = 0; j < w; j++) {
1446                /* convert 32-bit Z to 24-bit Z (0 stencil) */
1447                pDest[j] = ptrc[j] & 0xffffff00;
1448             }
1449             pDest += pt->stride/4;
1450             ptrc += srcStride;
1451          }
1452       }
1453       break;
1454    case PIPE_FORMAT_Z16_UNORM:
1455       {
1456          ushort *pDest = (ushort *) (map + y * pt->stride + x*2);
1457          for (i = 0; i < h; i++) {
1458             for (j = 0; j < w; j++) {
1459                /* convert 32-bit Z to 16-bit Z */
1460                pDest[j] = ptrc[j] >> 16;
1461             }
1462             pDest += pt->stride/2;
1463             ptrc += srcStride;
1464          }
1465       }
1466       break;
1467    default:
1468       assert(0);
1469    }
1470
1471    screen->transfer_unmap(screen, pt);
1472 }
1473
1474