reactos/dll/opengl/mesa/src/gallium/auxiliary/util/u_surface.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2009 VMware, Inc.  All Rights Reserved.
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a
   6  * copy of this software and associated documentation files (the
   7  * "Software"), to deal in the Software without restriction, including
   8  * without limitation the rights to use, copy, modify, merge, publish,
   9  * distribute, sub license, and/or sell copies of the Software, and to
  10  * permit persons to whom the Software is furnished to do so, subject to
  11  * the following conditions:
  12  *
  13  * The above copyright notice and this permission notice (including the
  14  * next paragraph) shall be included in all copies or substantial portions
  15  * of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  18  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  19  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  20  * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
  21  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  22  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  23  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  24  *
  25  **************************************************************************/
  26
  27 /**
  28  * @file
  29  * Surface utility functions.
  30  *
  31  * @author Brian Paul
  32  */
  33
  34
  35 #include "pipe/p_defines.h"
  36 #include "pipe/p_screen.h"
  37 #include "pipe/p_state.h"
  38
  39 #include "util/u_format.h"
  40 #include "util/u_inlines.h"
  41 #include "util/u_rect.h"
  42 #include "util/u_surface.h"
  43 #include "util/u_pack_color.h"
  44
  45
  46 /**
  47  * Initialize a pipe_surface object.  'view' is considered to have
  48  * uninitialized contents.
  49  */
  50 void
  51 u_surface_default_template(struct pipe_surface *surf,
  52                            const struct pipe_resource *texture,
  53                            unsigned bind)
  54 {
  55    memset(surf, 0, sizeof(*surf));
  56
  57    surf->format = texture->format;
  58    /* XXX should filter out all non-rt/ds bind flags ? */
  59    surf->usage = bind;
  60 }
  61
  62 /**
  63  * Helper to quickly create an RGBA rendering surface of a certain size.
  64  * \param textureOut  returns the new texture
  65  * \param surfaceOut  returns the new surface
  66  * \return TRUE for success, FALSE if failure
  67  */
  68 boolean
  69 util_create_rgba_surface(struct pipe_context *pipe,
  70                          uint width, uint height,
  71                          uint bind,
  72                          struct pipe_resource **textureOut,
  73                          struct pipe_surface **surfaceOut)
  74 {
  75    static const enum pipe_format rgbaFormats[] = {
  76       PIPE_FORMAT_B8G8R8A8_UNORM,
  77       PIPE_FORMAT_A8R8G8B8_UNORM,
  78       PIPE_FORMAT_A8B8G8R8_UNORM,
  79       PIPE_FORMAT_NONE
  80    };
  81    const uint target = PIPE_TEXTURE_2D;
  82    enum pipe_format format = PIPE_FORMAT_NONE;
  83    struct pipe_resource templ;
  84    struct pipe_surface surf_templ;
  85    struct pipe_screen *screen = pipe->screen;
  86    uint i;
  87
  88    /* Choose surface format */
  89    for (i = 0; rgbaFormats[i]; i++) {
  90       if (screen->is_format_supported(screen, rgbaFormats[i],
  91                                       target, 0, bind)) {
  92          format = rgbaFormats[i];
  93          break;
  94       }
  95    }
  96    if (format == PIPE_FORMAT_NONE)
  97       return FALSE;  /* unable to get an rgba format!?! */
  98
  99    /* create texture */
 100    memset(&templ, 0, sizeof(templ));
 101    templ.target = target;
 102    templ.format = format;
 103    templ.last_level = 0;
 104    templ.width0 = width;
 105    templ.height0 = height;
 106    templ.depth0 = 1;
 107    templ.array_size = 1;
 108    templ.bind = bind;
 109
 110    *textureOut = screen->resource_create(screen, &templ);
 111    if (!*textureOut)
 112       return FALSE;
 113
 114    /* create surface */
 115    u_surface_default_template(&surf_templ, *textureOut, bind);
 116    /* create surface / view into texture */
 117    *surfaceOut = pipe->create_surface(pipe,
 118                                       *textureOut,
 119                                       &surf_templ);
 120    if (!*surfaceOut) {
 121       pipe_resource_reference(textureOut, NULL);
 122       return FALSE;
 123    }
 124
 125    return TRUE;
 126 }
 127
 128
 129 /**
 130  * Release the surface and texture from util_create_rgba_surface().
 131  */
 132 void
 133 util_destroy_rgba_surface(struct pipe_resource *texture,
 134                           struct pipe_surface *surface)
 135 {
 136    pipe_surface_reference(&surface, NULL);
 137    pipe_resource_reference(&texture, NULL);
 138 }
 139
 140
 141
 142 /**
 143  * Fallback function for pipe->resource_copy_region().
 144  * Note: (X,Y)=(0,0) is always the upper-left corner.
 145  */
 146 void
 147 util_resource_copy_region(struct pipe_context *pipe,
 148                           struct pipe_resource *dst,
 149                           unsigned dst_level,
 150                           unsigned dst_x, unsigned dst_y, unsigned dst_z,
 151                           struct pipe_resource *src,
 152                           unsigned src_level,
 153                           const struct pipe_box *src_box)
 154 {
 155    struct pipe_transfer *src_trans, *dst_trans;
 156    void *dst_map;
 157    const void *src_map;
 158    enum pipe_format src_format, dst_format;
 159    unsigned w = src_box->width;
 160    unsigned h = src_box->height;
 161
 162    assert(src && dst);
 163    assert((src->target == PIPE_BUFFER && dst->target == PIPE_BUFFER) ||
 164           (src->target != PIPE_BUFFER && dst->target != PIPE_BUFFER));
 165
 166    if (!src || !dst)
 167       return;
 168
 169    src_format = src->format;
 170    dst_format = dst->format;
 171
 172    src_trans = pipe_get_transfer(pipe,
 173                                  src,
 174                                  src_level,
 175                                  src_box->z,
 176                                  PIPE_TRANSFER_READ,
 177                                  src_box->x, src_box->y, w, h);
 178
 179    dst_trans = pipe_get_transfer(pipe,
 180                                  dst,
 181                                  dst_level,
 182                                  dst_z,
 183                                  PIPE_TRANSFER_WRITE,
 184                                  dst_x, dst_y, w, h);
 185
 186    assert(util_format_get_blocksize(dst_format) == util_format_get_blocksize(src_format));
 187    assert(util_format_get_blockwidth(dst_format) == util_format_get_blockwidth(src_format));
 188    assert(util_format_get_blockheight(dst_format) == util_format_get_blockheight(src_format));
 189
 190    src_map = pipe->transfer_map(pipe, src_trans);
 191    dst_map = pipe->transfer_map(pipe, dst_trans);
 192
 193    assert(src_map);
 194    assert(dst_map);
 195
 196    if (src_map && dst_map) {
 197       if (dst->target == PIPE_BUFFER && src->target == PIPE_BUFFER) {
 198          memcpy(dst_map, src_map, w);
 199       } else {
 200          util_copy_rect(dst_map,
 201                         dst_format,
 202                         dst_trans->stride,
 203                         0, 0,
 204                         w, h,
 205                         src_map,
 206                         src_trans->stride,
 207                         0,
 208                         0);
 209       }
 210    }
 211
 212    pipe->transfer_unmap(pipe, src_trans);
 213    pipe->transfer_unmap(pipe, dst_trans);
 214
 215    pipe->transfer_destroy(pipe, src_trans);
 216    pipe->transfer_destroy(pipe, dst_trans);
 217 }
 218
 219
 220
 221 #define UBYTE_TO_USHORT(B) ((B) | ((B) << 8))
 222
 223
 224 /**
 225  * Fallback for pipe->clear_render_target() function.
 226  * XXX this looks too hackish to be really useful.
 227  * cpp > 4 looks like a gross hack at best...
 228  * Plus can't use these transfer fallbacks when clearing
 229  * multisampled surfaces for instance.
 230  */
 231 void
 232 util_clear_render_target(struct pipe_context *pipe,
 233                          struct pipe_surface *dst,
 234                          const union pipe_color_union *color,
 235                          unsigned dstx, unsigned dsty,
 236                          unsigned width, unsigned height)
 237 {
 238    struct pipe_transfer *dst_trans;
 239    void *dst_map;
 240    union util_color uc;
 241
 242    assert(dst->texture);
 243    if (!dst->texture)
 244       return;
 245    /* XXX: should handle multiple layers */
 246    dst_trans = pipe_get_transfer(pipe,
 247                                  dst->texture,
 248                                  dst->u.tex.level,
 249                                  dst->u.tex.first_layer,
 250                                  PIPE_TRANSFER_WRITE,
 251                                  dstx, dsty, width, height);
 252
 253    dst_map = pipe->transfer_map(pipe, dst_trans);
 254
 255    assert(dst_map);
 256
 257    if (dst_map) {
 258       assert(dst_trans->stride > 0);
 259
 260       util_pack_color(color->f, dst->texture->format, &uc);
 261       util_fill_rect(dst_map, dst->texture->format,
 262                      dst_trans->stride,
 263                      0, 0, width, height, &uc);
 264    }
 265
 266    pipe->transfer_unmap(pipe, dst_trans);
 267    pipe->transfer_destroy(pipe, dst_trans);
 268 }
 269
 270 /**
 271  * Fallback for pipe->clear_stencil() function.
 272  * sw fallback doesn't look terribly useful here.
 273  * Plus can't use these transfer fallbacks when clearing
 274  * multisampled surfaces for instance.
 275  */
 276 void
 277 util_clear_depth_stencil(struct pipe_context *pipe,
 278                          struct pipe_surface *dst,
 279                          unsigned clear_flags,
 280                          double depth,
 281                          unsigned stencil,
 282                          unsigned dstx, unsigned dsty,
 283                          unsigned width, unsigned height)
 284 {
 285    struct pipe_transfer *dst_trans;
 286    ubyte *dst_map;
 287    boolean need_rmw = FALSE;
 288
 289    if ((clear_flags & PIPE_CLEAR_DEPTHSTENCIL) &&
 290        ((clear_flags & PIPE_CLEAR_DEPTHSTENCIL) != PIPE_CLEAR_DEPTHSTENCIL) &&
 291        util_format_is_depth_and_stencil(dst->format))
 292       need_rmw = TRUE;
 293
 294    assert(dst->texture);
 295    if (!dst->texture)
 296       return;
 297    dst_trans = pipe_get_transfer(pipe,
 298                                  dst->texture,
 299                                  dst->u.tex.level,
 300                                  dst->u.tex.first_layer,
 301                                  (need_rmw ? PIPE_TRANSFER_READ_WRITE :
 302                                      PIPE_TRANSFER_WRITE),
 303                                  dstx, dsty, width, height);
 304
 305    dst_map = pipe->transfer_map(pipe, dst_trans);
 306
 307    assert(dst_map);
 308
 309    if (dst_map) {
 310       unsigned dst_stride = dst_trans->stride;
 311       unsigned zstencil = util_pack_z_stencil(dst->texture->format, depth, stencil);
 312       unsigned i, j;
 313       assert(dst_trans->stride > 0);
 314
 315       switch (util_format_get_blocksize(dst->format)) {
 316       case 1:
 317          assert(dst->format == PIPE_FORMAT_S8_UINT);
 318          if(dst_stride == width)
 319             memset(dst_map, (ubyte) zstencil, height * width);
 320          else {
 321             for (i = 0; i < height; i++) {
 322                memset(dst_map, (ubyte) zstencil, width);
 323                dst_map += dst_stride;
 324             }
 325          }
 326          break;
 327       case 2:
 328          assert(dst->format == PIPE_FORMAT_Z16_UNORM);
 329          for (i = 0; i < height; i++) {
 330             uint16_t *row = (uint16_t *)dst_map;
 331             for (j = 0; j < width; j++)
 332                *row++ = (uint16_t) zstencil;
 333             dst_map += dst_stride;
 334             }
 335          break;
 336       case 4:
 337          if (!need_rmw) {
 338             for (i = 0; i < height; i++) {
 339                uint32_t *row = (uint32_t *)dst_map;
 340                for (j = 0; j < width; j++)
 341                   *row++ = zstencil;
 342                dst_map += dst_stride;
 343             }
 344          }
 345          else {
 346             uint32_t dst_mask;
 347             if (dst->format == PIPE_FORMAT_Z24_UNORM_S8_UINT)
 348                dst_mask = 0xffffff00;
 349             else {
 350                assert(dst->format == PIPE_FORMAT_S8_UINT_Z24_UNORM);
 351                dst_mask = 0xffffff;
 352             }
 353             if (clear_flags & PIPE_CLEAR_DEPTH)
 354                dst_mask = ~dst_mask;
 355             for (i = 0; i < height; i++) {
 356                uint32_t *row = (uint32_t *)dst_map;
 357                for (j = 0; j < width; j++) {
 358                   uint32_t tmp = *row & dst_mask;
 359                   *row++ = tmp | (zstencil & ~dst_mask);
 360                }
 361                dst_map += dst_stride;
 362             }
 363          }
 364          break;
 365       case 8:
 366       {
 367          uint64_t zstencil = util_pack64_z_stencil(dst->texture->format,
 368                                                    depth, stencil);
 369
 370          assert(dst->format == PIPE_FORMAT_Z32_FLOAT_S8X24_UINT);
 371
 372          if (!need_rmw) {
 373             for (i = 0; i < height; i++) {
 374                uint64_t *row = (uint64_t *)dst_map;
 375                for (j = 0; j < width; j++)
 376                   *row++ = zstencil;
 377                dst_map += dst_stride;
 378             }
 379          }
 380          else {
 381             uint64_t src_mask;
 382
 383             if (clear_flags & PIPE_CLEAR_DEPTH)
 384                src_mask = 0x00000000ffffffffull;
 385             else
 386                src_mask = 0x000000ff00000000ull;
 387
 388             for (i = 0; i < height; i++) {
 389                uint64_t *row = (uint64_t *)dst_map;
 390                for (j = 0; j < width; j++) {
 391                   uint64_t tmp = *row & ~src_mask;
 392                   *row++ = tmp | (zstencil & src_mask);
 393                }
 394                dst_map += dst_stride;
 395             }
 396          }
 397          break;
 398       }
 399       default:
 400          assert(0);
 401          break;
 402       }
 403    }
 404
 405    pipe->transfer_unmap(pipe, dst_trans);
 406    pipe->transfer_destroy(pipe, dst_trans);
 407 }