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