Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | RSS feed

  1. /**************************************************************************
  2.  *
  3.  * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
  4.  * All Rights Reserved.
  5.  *
  6.  * Permission is hereby granted, free of charge, to any person obtaining a
  7.  * copy of this software and associated documentation files (the
  8.  * "Software"), to deal in the Software without restriction, including
  9.  * without limitation the rights to use, copy, modify, merge, publish,
  10.  * distribute, sub license, and/or sell copies of the Software, and to
  11.  * permit persons to whom the Software is furnished to do so, subject to
  12.  * the following conditions:
  13.  *
  14.  * The above copyright notice and this permission notice (including the
  15.  * next paragraph) shall be included in all copies or substantial portions
  16.  * of the Software.
  17.  *
  18.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  19.  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  20.  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  21.  * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
  22.  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  23.  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  24.  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25.  *
  26.  **************************************************************************/
  27.  
  28. /**
  29.  * RGBA/float tile get/put functions.
  30.  * Usable both by drivers and state trackers.
  31.  */
  32.  
  33.  
  34. #include "pipe/p_defines.h"
  35. #include "util/u_inlines.h"
  36.  
  37. #include "util/u_format.h"
  38. #include "util/u_math.h"
  39. #include "util/u_memory.h"
  40. #include "util/u_rect.h"
  41. #include "util/u_tile.h"
  42.  
  43.  
  44. /**
  45.  * Move raw block of pixels from transfer object to user memory.
  46.  */
  47. void
  48. pipe_get_tile_raw(struct pipe_transfer *pt,
  49.                   const void *src,
  50.                   uint x, uint y, uint w, uint h,
  51.                   void *dst, int dst_stride)
  52. {
  53.    if (dst_stride == 0)
  54.       dst_stride = util_format_get_stride(pt->resource->format, w);
  55.  
  56.    if (u_clip_tile(x, y, &w, &h, &pt->box))
  57.       return;
  58.  
  59.    util_copy_rect(dst, pt->resource->format, dst_stride, 0, 0, w, h, src, pt->stride, x, y);
  60. }
  61.  
  62.  
  63. /**
  64.  * Move raw block of pixels from user memory to transfer object.
  65.  */
  66. void
  67. pipe_put_tile_raw(struct pipe_transfer *pt,
  68.                   void *dst,
  69.                   uint x, uint y, uint w, uint h,
  70.                   const void *src, int src_stride)
  71. {
  72.    enum pipe_format format = pt->resource->format;
  73.  
  74.    if (src_stride == 0)
  75.       src_stride = util_format_get_stride(format, w);
  76.  
  77.    if (u_clip_tile(x, y, &w, &h, &pt->box))
  78.       return;
  79.  
  80.    util_copy_rect(dst, format, pt->stride, x, y, w, h, src, src_stride, 0, 0);
  81. }
  82.  
  83.  
  84.  
  85.  
  86. /** Convert short in [-32768,32767] to GLfloat in [-1.0,1.0] */
  87. #define SHORT_TO_FLOAT(S)   ((2.0F * (S) + 1.0F) * (1.0F/65535.0F))
  88.  
  89. #define UNCLAMPED_FLOAT_TO_SHORT(us, f)  \
  90.    us = ( (short) ( CLAMP((f), -1.0, 1.0) * 32767.0F) )
  91.  
  92.  
  93.  
  94. /*** PIPE_FORMAT_Z16_UNORM ***/
  95.  
  96. /**
  97.  * Return each Z value as four floats in [0,1].
  98.  */
  99. static void
  100. z16_get_tile_rgba(const ushort *src,
  101.                   unsigned w, unsigned h,
  102.                   float *p,
  103.                   unsigned dst_stride)
  104. {
  105.    const float scale = 1.0f / 65535.0f;
  106.    unsigned i, j;
  107.  
  108.    for (i = 0; i < h; i++) {
  109.       float *pRow = p;
  110.       for (j = 0; j < w; j++, pRow += 4) {
  111.          pRow[0] =
  112.          pRow[1] =
  113.          pRow[2] =
  114.          pRow[3] = *src++ * scale;
  115.       }
  116.       p += dst_stride;
  117.    }
  118. }
  119.  
  120.  
  121.  
  122.  
  123. /*** PIPE_FORMAT_Z32_UNORM ***/
  124.  
  125. /**
  126.  * Return each Z value as four floats in [0,1].
  127.  */
  128. static void
  129. z32_get_tile_rgba(const unsigned *src,
  130.                   unsigned w, unsigned h,
  131.                   float *p,
  132.                   unsigned dst_stride)
  133. {
  134.    const double scale = 1.0 / (double) 0xffffffff;
  135.    unsigned i, j;
  136.  
  137.    for (i = 0; i < h; i++) {
  138.       float *pRow = p;
  139.       for (j = 0; j < w; j++, pRow += 4) {
  140.          pRow[0] =
  141.          pRow[1] =
  142.          pRow[2] =
  143.          pRow[3] = (float) (*src++ * scale);
  144.       }
  145.       p += dst_stride;
  146.    }
  147. }
  148.  
  149.  
  150. /*** PIPE_FORMAT_Z24_UNORM_S8_UINT ***/
  151.  
  152. /**
  153.  * Return Z component as four float in [0,1].  Stencil part ignored.
  154.  */
  155. static void
  156. s8z24_get_tile_rgba(const unsigned *src,
  157.                     unsigned w, unsigned h,
  158.                     float *p,
  159.                     unsigned dst_stride)
  160. {
  161.    const double scale = 1.0 / ((1 << 24) - 1);
  162.    unsigned i, j;
  163.  
  164.    for (i = 0; i < h; i++) {
  165.       float *pRow = p;
  166.       for (j = 0; j < w; j++, pRow += 4) {
  167.          pRow[0] =
  168.          pRow[1] =
  169.          pRow[2] =
  170.          pRow[3] = (float) (scale * (*src++ & 0xffffff));
  171.       }
  172.       p += dst_stride;
  173.    }
  174. }
  175.  
  176.  
  177. /*** PIPE_FORMAT_S8_UINT_Z24_UNORM ***/
  178.  
  179. /**
  180.  * Return Z component as four float in [0,1].  Stencil part ignored.
  181.  */
  182. static void
  183. z24s8_get_tile_rgba(const unsigned *src,
  184.                     unsigned w, unsigned h,
  185.                     float *p,
  186.                     unsigned dst_stride)
  187. {
  188.    const double scale = 1.0 / ((1 << 24) - 1);
  189.    unsigned i, j;
  190.  
  191.    for (i = 0; i < h; i++) {
  192.       float *pRow = p;
  193.       for (j = 0; j < w; j++, pRow += 4) {
  194.          pRow[0] =
  195.          pRow[1] =
  196.          pRow[2] =
  197.          pRow[3] = (float) (scale * (*src++ >> 8));
  198.       }
  199.       p += dst_stride;
  200.    }
  201. }
  202.  
  203. /*** PIPE_FORMAT_S8X24_UINT ***/
  204.  
  205. /**
  206.  * Return S component as four uint32_t in [0..255].  Z part ignored.
  207.  */
  208. static void
  209. s8x24_get_tile_rgba(const unsigned *src,
  210.                     unsigned w, unsigned h,
  211.                     float *p,
  212.                     unsigned dst_stride)
  213. {
  214.    unsigned i, j;
  215.  
  216.    for (i = 0; i < h; i++) {
  217.       float *pRow = p;
  218.  
  219.       for (j = 0; j < w; j++, pRow += 4) {
  220.          pRow[0] =
  221.          pRow[1] =
  222.          pRow[2] =
  223.          pRow[3] = (float)((*src++ >> 24) & 0xff);
  224.       }
  225.  
  226.       p += dst_stride;
  227.    }
  228. }
  229.  
  230. /*** PIPE_FORMAT_X24S8_UINT ***/
  231.  
  232. /**
  233.  * Return S component as four uint32_t in [0..255].  Z part ignored.
  234.  */
  235. static void
  236. x24s8_get_tile_rgba(const unsigned *src,
  237.                     unsigned w, unsigned h,
  238.                     float *p,
  239.                     unsigned dst_stride)
  240. {
  241.    unsigned i, j;
  242.  
  243.    for (i = 0; i < h; i++) {
  244.       float *pRow = p;
  245.       for (j = 0; j < w; j++, pRow += 4) {
  246.          pRow[0] =
  247.          pRow[1] =
  248.          pRow[2] =
  249.          pRow[3] = (float)(*src++ & 0xff);
  250.       }
  251.       p += dst_stride;
  252.    }
  253. }
  254.  
  255.  
  256. /**
  257.  * Return S component as four uint32_t in [0..255].  Z part ignored.
  258.  */
  259. static void
  260. s8_get_tile_rgba(const unsigned char *src,
  261.                  unsigned w, unsigned h,
  262.                  float *p,
  263.                  unsigned dst_stride)
  264. {
  265.    unsigned i, j;
  266.  
  267.    for (i = 0; i < h; i++) {
  268.       float *pRow = p;
  269.       for (j = 0; j < w; j++, pRow += 4) {
  270.          pRow[0] =
  271.          pRow[1] =
  272.          pRow[2] =
  273.          pRow[3] = (float)(*src++ & 0xff);
  274.       }
  275.       p += dst_stride;
  276.    }
  277. }
  278.  
  279. /*** PIPE_FORMAT_Z32_FLOAT ***/
  280.  
  281. /**
  282.  * Return each Z value as four floats in [0,1].
  283.  */
  284. static void
  285. z32f_get_tile_rgba(const float *src,
  286.                    unsigned w, unsigned h,
  287.                    float *p,
  288.                    unsigned dst_stride)
  289. {
  290.    unsigned i, j;
  291.  
  292.    for (i = 0; i < h; i++) {
  293.       float *pRow = p;
  294.       for (j = 0; j < w; j++, pRow += 4) {
  295.          pRow[0] =
  296.          pRow[1] =
  297.          pRow[2] =
  298.          pRow[3] = *src++;
  299.       }
  300.       p += dst_stride;
  301.    }
  302. }
  303.  
  304. /*** PIPE_FORMAT_Z32_FLOAT_S8X24_UINT ***/
  305.  
  306. /**
  307.  * Return each Z value as four floats in [0,1].
  308.  */
  309. static void
  310. z32f_x24s8_get_tile_rgba(const float *src,
  311.                          unsigned w, unsigned h,
  312.                          float *p,
  313.                          unsigned dst_stride)
  314. {
  315.    unsigned i, j;
  316.  
  317.    for (i = 0; i < h; i++) {
  318.       float *pRow = p;
  319.       for (j = 0; j < w; j++, pRow += 4) {
  320.          pRow[0] =
  321.          pRow[1] =
  322.          pRow[2] =
  323.          pRow[3] = *src;
  324.          src += 2;
  325.       }
  326.       p += dst_stride;
  327.    }
  328. }
  329.  
  330. /*** PIPE_FORMAT_X32_S8X24_UINT ***/
  331.  
  332. /**
  333.  * Return S component as four uint32_t in [0..255].  Z part ignored.
  334.  */
  335. static void
  336. x32_s8_get_tile_rgba(const unsigned *src,
  337.                      unsigned w, unsigned h,
  338.                      float *p,
  339.                      unsigned dst_stride)
  340. {
  341.    unsigned i, j;
  342.  
  343.    for (i = 0; i < h; i++) {
  344.       float *pRow = p;
  345.       for (j = 0; j < w; j++, pRow += 4) {
  346.          src++;
  347.          pRow[0] =
  348.          pRow[1] =
  349.          pRow[2] =
  350.          pRow[3] = (float)(*src++ & 0xff);
  351.       }
  352.       p += dst_stride;
  353.    }
  354. }
  355.  
  356. void
  357. pipe_tile_raw_to_rgba(enum pipe_format format,
  358.                       const void *src,
  359.                       uint w, uint h,
  360.                       float *dst, unsigned dst_stride)
  361. {
  362.    switch (format) {
  363.    case PIPE_FORMAT_Z16_UNORM:
  364.       z16_get_tile_rgba((ushort *) src, w, h, dst, dst_stride);
  365.       break;
  366.    case PIPE_FORMAT_Z32_UNORM:
  367.       z32_get_tile_rgba((unsigned *) src, w, h, dst, dst_stride);
  368.       break;
  369.    case PIPE_FORMAT_Z24_UNORM_S8_UINT:
  370.    case PIPE_FORMAT_Z24X8_UNORM:
  371.       s8z24_get_tile_rgba((unsigned *) src, w, h, dst, dst_stride);
  372.       break;
  373.    case PIPE_FORMAT_S8_UINT:
  374.       s8_get_tile_rgba((unsigned char *) src, w, h, dst, dst_stride);
  375.       break;
  376.    case PIPE_FORMAT_X24S8_UINT:
  377.       s8x24_get_tile_rgba((unsigned *) src, w, h, dst, dst_stride);
  378.       break;
  379.    case PIPE_FORMAT_S8_UINT_Z24_UNORM:
  380.    case PIPE_FORMAT_X8Z24_UNORM:
  381.       z24s8_get_tile_rgba((unsigned *) src, w, h, dst, dst_stride);
  382.       break;
  383.    case PIPE_FORMAT_S8X24_UINT:
  384.       x24s8_get_tile_rgba((unsigned *) src, w, h, dst, dst_stride);
  385.       break;
  386.    case PIPE_FORMAT_Z32_FLOAT:
  387.       z32f_get_tile_rgba((float *) src, w, h, dst, dst_stride);
  388.       break;
  389.    case PIPE_FORMAT_Z32_FLOAT_S8X24_UINT:
  390.       z32f_x24s8_get_tile_rgba((float *) src, w, h, dst, dst_stride);
  391.       break;
  392.    case PIPE_FORMAT_X32_S8X24_UINT:
  393.       x32_s8_get_tile_rgba((unsigned *) src, w, h, dst, dst_stride);
  394.       break;
  395.    default:
  396.       util_format_read_4f(format,
  397.                           dst, dst_stride * sizeof(float),
  398.                           src, util_format_get_stride(format, w),
  399.                           0, 0, w, h);
  400.    }
  401. }
  402.  
  403. void
  404. pipe_tile_raw_to_unsigned(enum pipe_format format,
  405.                           const void *src,
  406.                           uint w, uint h,
  407.                           unsigned *dst, unsigned dst_stride)
  408. {
  409.   util_format_read_4ui(format,
  410.                        dst, dst_stride * sizeof(float),
  411.                        src, util_format_get_stride(format, w),
  412.                        0, 0, w, h);
  413. }
  414.  
  415. void
  416. pipe_tile_raw_to_signed(enum pipe_format format,
  417.                           void *src,
  418.                           uint w, uint h,
  419.                           int *dst, unsigned dst_stride)
  420. {
  421.   util_format_read_4i(format,
  422.                       dst, dst_stride * sizeof(float),
  423.                       src, util_format_get_stride(format, w),
  424.                       0, 0, w, h);
  425. }
  426.  
  427. void
  428. pipe_get_tile_rgba(struct pipe_transfer *pt,
  429.                    const void *src,
  430.                    uint x, uint y, uint w, uint h,
  431.                    float *p)
  432. {
  433.    pipe_get_tile_rgba_format(pt, src, x, y, w, h, pt->resource->format, p);
  434. }
  435.  
  436.  
  437. void
  438. pipe_get_tile_rgba_format(struct pipe_transfer *pt,
  439.                           const void *src,
  440.                           uint x, uint y, uint w, uint h,
  441.                           enum pipe_format format,
  442.                           float *p)
  443. {
  444.    unsigned dst_stride = w * 4;
  445.    void *packed;
  446.  
  447.    if (u_clip_tile(x, y, &w, &h, &pt->box)) {
  448.       return;
  449.    }
  450.  
  451.    packed = MALLOC(util_format_get_nblocks(format, w, h) * util_format_get_blocksize(format));
  452.    if (!packed) {
  453.       return;
  454.    }
  455.  
  456.    if (format == PIPE_FORMAT_UYVY || format == PIPE_FORMAT_YUYV) {
  457.       assert((x & 1) == 0);
  458.    }
  459.  
  460.    pipe_get_tile_raw(pt, src, x, y, w, h, packed, 0);
  461.  
  462.    pipe_tile_raw_to_rgba(format, packed, w, h, p, dst_stride);
  463.  
  464.    FREE(packed);
  465. }
  466.  
  467.  
  468. void
  469. pipe_put_tile_rgba(struct pipe_transfer *pt,
  470.                    void *dst,
  471.                    uint x, uint y, uint w, uint h,
  472.                    const float *p)
  473. {
  474.    pipe_put_tile_rgba_format(pt, dst, x, y, w, h, pt->resource->format, p);
  475. }
  476.  
  477.  
  478. void
  479. pipe_put_tile_rgba_format(struct pipe_transfer *pt,
  480.                           void *dst,
  481.                           uint x, uint y, uint w, uint h,
  482.                           enum pipe_format format,
  483.                           const float *p)
  484. {
  485.    unsigned src_stride = w * 4;
  486.    void *packed;
  487.  
  488.    if (u_clip_tile(x, y, &w, &h, &pt->box))
  489.       return;
  490.  
  491.    packed = MALLOC(util_format_get_nblocks(format, w, h) * util_format_get_blocksize(format));
  492.  
  493.    if (!packed)
  494.       return;
  495.  
  496.    switch (format) {
  497.    case PIPE_FORMAT_Z16_UNORM:
  498.       /*z16_put_tile_rgba((ushort *) packed, w, h, p, src_stride);*/
  499.       break;
  500.    case PIPE_FORMAT_Z32_UNORM:
  501.       /*z32_put_tile_rgba((unsigned *) packed, w, h, p, src_stride);*/
  502.       break;
  503.    case PIPE_FORMAT_Z24_UNORM_S8_UINT:
  504.    case PIPE_FORMAT_Z24X8_UNORM:
  505.       /*s8z24_put_tile_rgba((unsigned *) packed, w, h, p, src_stride);*/
  506.       break;
  507.    case PIPE_FORMAT_S8_UINT_Z24_UNORM:
  508.    case PIPE_FORMAT_X8Z24_UNORM:
  509.       /*z24s8_put_tile_rgba((unsigned *) packed, w, h, p, src_stride);*/
  510.       break;
  511.    case PIPE_FORMAT_Z32_FLOAT:
  512.       /*z32f_put_tile_rgba((unsigned *) packed, w, h, p, src_stride);*/
  513.       break;
  514.    case PIPE_FORMAT_Z32_FLOAT_S8X24_UINT:
  515.       /*z32f_s8x24_put_tile_rgba((unsigned *) packed, w, h, p, src_stride);*/
  516.       break;
  517.    default:
  518.       util_format_write_4f(format,
  519.                            p, src_stride * sizeof(float),
  520.                            packed, util_format_get_stride(format, w),
  521.                            0, 0, w, h);
  522.    }
  523.  
  524.    pipe_put_tile_raw(pt, dst, x, y, w, h, packed, 0);
  525.  
  526.    FREE(packed);
  527. }
  528.  
  529. void
  530. pipe_put_tile_i_format(struct pipe_transfer *pt,
  531.                        void *dst,
  532.                        uint x, uint y, uint w, uint h,
  533.                        enum pipe_format format,
  534.                        const int *p)
  535. {
  536.    unsigned src_stride = w * 4;
  537.    void *packed;
  538.  
  539.    if (u_clip_tile(x, y, &w, &h, &pt->box))
  540.       return;
  541.  
  542.    packed = MALLOC(util_format_get_nblocks(format, w, h) * util_format_get_blocksize(format));
  543.  
  544.    if (!packed)
  545.       return;
  546.  
  547.    util_format_write_4i(format,
  548.                         p, src_stride * sizeof(float),
  549.                         packed, util_format_get_stride(format, w),
  550.                         0, 0, w, h);
  551.  
  552.    pipe_put_tile_raw(pt, dst, x, y, w, h, packed, 0);
  553.  
  554.    FREE(packed);
  555. }
  556.  
  557. void
  558. pipe_put_tile_ui_format(struct pipe_transfer *pt,
  559.                         void *dst,
  560.                         uint x, uint y, uint w, uint h,
  561.                         enum pipe_format format,
  562.                         const unsigned int *p)
  563. {
  564.    unsigned src_stride = w * 4;
  565.    void *packed;
  566.  
  567.    if (u_clip_tile(x, y, &w, &h, &pt->box))
  568.       return;
  569.  
  570.    packed = MALLOC(util_format_get_nblocks(format, w, h) * util_format_get_blocksize(format));
  571.  
  572.    if (!packed)
  573.       return;
  574.  
  575.    util_format_write_4ui(format,
  576.                          p, src_stride * sizeof(float),
  577.                          packed, util_format_get_stride(format, w),
  578.                          0, 0, w, h);
  579.  
  580.    pipe_put_tile_raw(pt, dst, x, y, w, h, packed, 0);
  581.  
  582.    FREE(packed);
  583. }
  584.  
  585. /**
  586.  * Get a block of Z values, converted to 32-bit range.
  587.  */
  588. void
  589. pipe_get_tile_z(struct pipe_transfer *pt,
  590.                 const void *src,
  591.                 uint x, uint y, uint w, uint h,
  592.                 uint *z)
  593. {
  594.    const uint dstStride = w;
  595.    const ubyte *map = src;
  596.    uint *pDest = z;
  597.    uint i, j;
  598.    enum pipe_format format = pt->resource->format;
  599.  
  600.    if (u_clip_tile(x, y, &w, &h, &pt->box))
  601.       return;
  602.  
  603.    switch (format) {
  604.    case PIPE_FORMAT_Z32_UNORM:
  605.       {
  606.          const uint *ptrc
  607.             = (const uint *)(map  + y * pt->stride + x*4);
  608.          for (i = 0; i < h; i++) {
  609.             memcpy(pDest, ptrc, 4 * w);
  610.             pDest += dstStride;
  611.             ptrc += pt->stride/4;
  612.          }
  613.       }
  614.       break;
  615.    case PIPE_FORMAT_Z24_UNORM_S8_UINT:
  616.    case PIPE_FORMAT_Z24X8_UNORM:
  617.       {
  618.          const uint *ptrc
  619.             = (const uint *)(map + y * pt->stride + x*4);
  620.          for (i = 0; i < h; i++) {
  621.             for (j = 0; j < w; j++) {
  622.                /* convert 24-bit Z to 32-bit Z */
  623.                pDest[j] = (ptrc[j] << 8) | ((ptrc[j] >> 16) & 0xff);
  624.             }
  625.             pDest += dstStride;
  626.             ptrc += pt->stride/4;
  627.          }
  628.       }
  629.       break;
  630.    case PIPE_FORMAT_S8_UINT_Z24_UNORM:
  631.    case PIPE_FORMAT_X8Z24_UNORM:
  632.       {
  633.          const uint *ptrc
  634.             = (const uint *)(map + y * pt->stride + x*4);
  635.          for (i = 0; i < h; i++) {
  636.             for (j = 0; j < w; j++) {
  637.                /* convert 24-bit Z to 32-bit Z */
  638.                pDest[j] = (ptrc[j] & 0xffffff00) | ((ptrc[j] >> 24) & 0xff);
  639.             }
  640.             pDest += dstStride;
  641.             ptrc += pt->stride/4;
  642.          }
  643.       }
  644.       break;
  645.    case PIPE_FORMAT_Z16_UNORM:
  646.       {
  647.          const ushort *ptrc
  648.             = (const ushort *)(map + y * pt->stride + x*2);
  649.          for (i = 0; i < h; i++) {
  650.             for (j = 0; j < w; j++) {
  651.                /* convert 16-bit Z to 32-bit Z */
  652.                pDest[j] = (ptrc[j] << 16) | ptrc[j];
  653.             }
  654.             pDest += dstStride;
  655.             ptrc += pt->stride/2;
  656.          }
  657.       }
  658.       break;
  659.    case PIPE_FORMAT_Z32_FLOAT:
  660.       {
  661.          const float *ptrc = (const float *)(map + y * pt->stride + x*4);
  662.          for (i = 0; i < h; i++) {
  663.             for (j = 0; j < w; j++) {
  664.                /* convert float Z to 32-bit Z */
  665.                if (ptrc[j] <= 0.0) {
  666.                   pDest[j] = 0;
  667.                }
  668.                else if (ptrc[j] >= 1.0) {
  669.                   pDest[j] = 0xffffffff;
  670.                }
  671.                else {
  672.                   double z = ptrc[j] * 0xffffffff;
  673.                   pDest[j] = (uint) z;
  674.                }
  675.             }
  676.             pDest += dstStride;
  677.             ptrc += pt->stride/4;
  678.          }
  679.       }
  680.       break;
  681.    case PIPE_FORMAT_Z32_FLOAT_S8X24_UINT:
  682.       {
  683.          const float *ptrc = (const float *)(map + y * pt->stride + x*8);
  684.          for (i = 0; i < h; i++) {
  685.             for (j = 0; j < w; j++) {
  686.                /* convert float Z to 32-bit Z */
  687.                if (ptrc[j] <= 0.0) {
  688.                   pDest[j*2] = 0;
  689.                }
  690.                else if (ptrc[j] >= 1.0) {
  691.                   pDest[j*2] = 0xffffffff;
  692.                }
  693.                else {
  694.                   double z = ptrc[j] * 0xffffffff;
  695.                   pDest[j*2] = (uint) z;
  696.                }
  697.             }
  698.             pDest += dstStride;
  699.             ptrc += pt->stride/4;
  700.          }
  701.       }
  702.       break;
  703.    default:
  704.       assert(0);
  705.    }
  706. }
  707.  
  708.  
  709. void
  710. pipe_put_tile_z(struct pipe_transfer *pt,
  711.                 void *dst,
  712.                 uint x, uint y, uint w, uint h,
  713.                 const uint *zSrc)
  714. {
  715.    const uint srcStride = w;
  716.    const uint *ptrc = zSrc;
  717.    ubyte *map = dst;
  718.    uint i, j;
  719.    enum pipe_format format = pt->resource->format;
  720.  
  721.    if (u_clip_tile(x, y, &w, &h, &pt->box))
  722.       return;
  723.  
  724.    switch (format) {
  725.    case PIPE_FORMAT_Z32_UNORM:
  726.       {
  727.          uint *pDest = (uint *) (map + y * pt->stride + x*4);
  728.          for (i = 0; i < h; i++) {
  729.             memcpy(pDest, ptrc, 4 * w);
  730.             pDest += pt->stride/4;
  731.             ptrc += srcStride;
  732.          }
  733.       }
  734.       break;
  735.    case PIPE_FORMAT_Z24_UNORM_S8_UINT:
  736.       {
  737.          uint *pDest = (uint *) (map + y * pt->stride + x*4);
  738.          /*assert((pt->usage & PIPE_TRANSFER_READ_WRITE) == PIPE_TRANSFER_READ_WRITE);*/
  739.          for (i = 0; i < h; i++) {
  740.             for (j = 0; j < w; j++) {
  741.                /* convert 32-bit Z to 24-bit Z, preserve stencil */
  742.                pDest[j] = (pDest[j] & 0xff000000) | ptrc[j] >> 8;
  743.             }
  744.             pDest += pt->stride/4;
  745.             ptrc += srcStride;
  746.          }
  747.       }
  748.       break;
  749.    case PIPE_FORMAT_Z24X8_UNORM:
  750.       {
  751.          uint *pDest = (uint *) (map + y * pt->stride + x*4);
  752.          for (i = 0; i < h; i++) {
  753.             for (j = 0; j < w; j++) {
  754.                /* convert 32-bit Z to 24-bit Z (0 stencil) */
  755.                pDest[j] = ptrc[j] >> 8;
  756.             }
  757.             pDest += pt->stride/4;
  758.             ptrc += srcStride;
  759.          }
  760.       }
  761.       break;
  762.    case PIPE_FORMAT_S8_UINT_Z24_UNORM:
  763.       {
  764.          uint *pDest = (uint *) (map + y * pt->stride + x*4);
  765.          /*assert((pt->usage & PIPE_TRANSFER_READ_WRITE) == PIPE_TRANSFER_READ_WRITE);*/
  766.          for (i = 0; i < h; i++) {
  767.             for (j = 0; j < w; j++) {
  768.                /* convert 32-bit Z to 24-bit Z, preserve stencil */
  769.                pDest[j] = (pDest[j] & 0xff) | (ptrc[j] & 0xffffff00);
  770.             }
  771.             pDest += pt->stride/4;
  772.             ptrc += srcStride;
  773.          }
  774.       }
  775.       break;
  776.    case PIPE_FORMAT_X8Z24_UNORM:
  777.       {
  778.          uint *pDest = (uint *) (map + y * pt->stride + x*4);
  779.          for (i = 0; i < h; i++) {
  780.             for (j = 0; j < w; j++) {
  781.                /* convert 32-bit Z to 24-bit Z (0 stencil) */
  782.                pDest[j] = ptrc[j] & 0xffffff00;
  783.             }
  784.             pDest += pt->stride/4;
  785.             ptrc += srcStride;
  786.          }
  787.       }
  788.       break;
  789.    case PIPE_FORMAT_Z16_UNORM:
  790.       {
  791.          ushort *pDest = (ushort *) (map + y * pt->stride + x*2);
  792.          for (i = 0; i < h; i++) {
  793.             for (j = 0; j < w; j++) {
  794.                /* convert 32-bit Z to 16-bit Z */
  795.                pDest[j] = ptrc[j] >> 16;
  796.             }
  797.             pDest += pt->stride/2;
  798.             ptrc += srcStride;
  799.          }
  800.       }
  801.       break;
  802.    case PIPE_FORMAT_Z32_FLOAT:
  803.       {
  804.          float *pDest = (float *) (map + y * pt->stride + x*4);
  805.          for (i = 0; i < h; i++) {
  806.             for (j = 0; j < w; j++) {
  807.                /* convert 32-bit integer Z to float Z */
  808.                const double scale = 1.0 / 0xffffffffU;
  809.                pDest[j] = (float) (ptrc[j] * scale);
  810.             }
  811.             pDest += pt->stride/4;
  812.             ptrc += srcStride;
  813.          }
  814.       }
  815.       break;
  816.    case PIPE_FORMAT_Z32_FLOAT_S8X24_UINT:
  817.       {
  818.          float *pDest = (float *) (map + y * pt->stride + x*8);
  819.          for (i = 0; i < h; i++) {
  820.             for (j = 0; j < w; j++) {
  821.                /* convert 32-bit integer Z to float Z */
  822.                const double scale = 1.0 / 0xffffffffU;
  823.                pDest[j*2] = (float) (ptrc[j] * scale);
  824.             }
  825.             pDest += pt->stride/4;
  826.             ptrc += srcStride;
  827.          }
  828.       }
  829.       break;
  830.    default:
  831.       assert(0);
  832.    }
  833. }
  834.  
  835.  
  836. void
  837. pipe_get_tile_ui_format(struct pipe_transfer *pt,
  838.                         const void *src,
  839.                         uint x, uint y, uint w, uint h,
  840.                         enum pipe_format format,
  841.                         unsigned int *p)
  842. {
  843.    unsigned dst_stride = w * 4;
  844.    void *packed;
  845.  
  846.    if (u_clip_tile(x, y, &w, &h, &pt->box)) {
  847.       return;
  848.    }
  849.  
  850.    packed = MALLOC(util_format_get_nblocks(format, w, h) * util_format_get_blocksize(format));
  851.    if (!packed) {
  852.       return;
  853.    }
  854.  
  855.    if (format == PIPE_FORMAT_UYVY || format == PIPE_FORMAT_YUYV) {
  856.       assert((x & 1) == 0);
  857.    }
  858.  
  859.    pipe_get_tile_raw(pt, src, x, y, w, h, packed, 0);
  860.  
  861.    pipe_tile_raw_to_unsigned(format, packed, w, h, p, dst_stride);
  862.  
  863.    FREE(packed);
  864. }
  865.  
  866.  
  867. void
  868. pipe_get_tile_i_format(struct pipe_transfer *pt,
  869.                        const void *src,
  870.                        uint x, uint y, uint w, uint h,
  871.                        enum pipe_format format,
  872.                        int *p)
  873. {
  874.    unsigned dst_stride = w * 4;
  875.    void *packed;
  876.  
  877.    if (u_clip_tile(x, y, &w, &h, &pt->box)) {
  878.       return;
  879.    }
  880.  
  881.    packed = MALLOC(util_format_get_nblocks(format, w, h) * util_format_get_blocksize(format));
  882.    if (!packed) {
  883.       return;
  884.    }
  885.  
  886.    if (format == PIPE_FORMAT_UYVY || format == PIPE_FORMAT_YUYV) {
  887.       assert((x & 1) == 0);
  888.    }
  889.  
  890.    pipe_get_tile_raw(pt, src, x, y, w, h, packed, 0);
  891.  
  892.    pipe_tile_raw_to_signed(format, packed, w, h, p, dst_stride);
  893.  
  894.    FREE(packed);
  895. }
  896.