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 {
  54    memset(surf, 0, sizeof(*surf));
  55
  56    surf->format = texture->format;
  57 }
  58
  59
  60 /**
  61  * Copy 2D rect from one place to another.
  62  * Position and sizes are in pixels.
  63  * src_stride may be negative to do vertical flip of pixels from source.
  64  */
  65 void
  66 util_copy_rect(ubyte * dst,
  67                enum pipe_format format,
  68                unsigned dst_stride,
  69                unsigned dst_x,
  70                unsigned dst_y,
  71                unsigned width,
  72                unsigned height,
  73                const ubyte * src,
  74                int src_stride,
  75                unsigned src_x,
  76                unsigned src_y)
  77 {
  78    unsigned i;
  79    int src_stride_pos = src_stride < 0 ? -src_stride : src_stride;
  80    int blocksize = util_format_get_blocksize(format);
  81    int blockwidth = util_format_get_blockwidth(format);
  82    int blockheight = util_format_get_blockheight(format);
  83
  84    assert(blocksize > 0);
  85    assert(blockwidth > 0);
  86    assert(blockheight > 0);
  87
  88    dst_x /= blockwidth;
  89    dst_y /= blockheight;
  90    width = (width + blockwidth - 1)/blockwidth;
  91    height = (height + blockheight - 1)/blockheight;
  92    src_x /= blockwidth;
  93    src_y /= blockheight;
  94
  95    dst += dst_x * blocksize;
  96    src += src_x * blocksize;
  97    dst += dst_y * dst_stride;
  98    src += src_y * src_stride_pos;
  99    width *= blocksize;
 100
 101    if (width == dst_stride && width == src_stride)
 102       memcpy(dst, src, height * width);
 103    else {
 104       for (i = 0; i < height; i++) {
 105          memcpy(dst, src, width);
 106          dst += dst_stride;
 107          src += src_stride;
 108       }
 109    }
 110 }
 111
 112
 113 /**
 114  * Copy 3D box from one place to another.
 115  * Position and sizes are in pixels.
 116  */
 117 void
 118 util_copy_box(ubyte * dst,
 119               enum pipe_format format,
 120               unsigned dst_stride, unsigned dst_slice_stride,
 121               unsigned dst_x, unsigned dst_y, unsigned dst_z,
 122               unsigned width, unsigned height, unsigned depth,
 123               const ubyte * src,
 124               int src_stride, unsigned src_slice_stride,
 125               unsigned src_x, unsigned src_y, unsigned src_z)
 126 {
 127    unsigned z;
 128    dst += dst_z * dst_slice_stride;
 129    src += src_z * src_slice_stride;
 130    for (z = 0; z < depth; ++z) {
 131       util_copy_rect(dst,
 132                      format,
 133                      dst_stride,
 134                      dst_x, dst_y,
 135                      width, height,
 136                      src,
 137                      src_stride,
 138                      src_x, src_y);
 139
 140       dst += dst_slice_stride;
 141       src += src_slice_stride;
 142    }
 143 }
 144
 145
 146 void
 147 util_fill_rect(ubyte * dst,
 148                enum pipe_format format,
 149                unsigned dst_stride,
 150                unsigned dst_x,
 151                unsigned dst_y,
 152                unsigned width,
 153                unsigned height,
 154                union util_color *uc)
 155 {
 156    const struct util_format_description *desc = util_format_description(format);
 157    unsigned i, j;
 158    unsigned width_size;
 159    int blocksize = desc->block.bits / 8;
 160    int blockwidth = desc->block.width;
 161    int blockheight = desc->block.height;
 162
 163    assert(blocksize > 0);
 164    assert(blockwidth > 0);
 165    assert(blockheight > 0);
 166
 167    dst_x /= blockwidth;
 168    dst_y /= blockheight;
 169    width = (width + blockwidth - 1)/blockwidth;
 170    height = (height + blockheight - 1)/blockheight;
 171
 172    dst += dst_x * blocksize;
 173    dst += dst_y * dst_stride;
 174    width_size = width * blocksize;
 175
 176    switch (blocksize) {
 177    case 1:
 178       if(dst_stride == width_size)
 179          memset(dst, uc->ub, height * width_size);
 180       else {
 181          for (i = 0; i < height; i++) {
 182             memset(dst, uc->ub, width_size);
 183             dst += dst_stride;
 184          }
 185       }
 186       break;
 187    case 2:
 188       for (i = 0; i < height; i++) {
 189          uint16_t *row = (uint16_t *)dst;
 190          for (j = 0; j < width; j++)
 191             *row++ = uc->us;
 192          dst += dst_stride;
 193       }
 194       break;
 195    case 4:
 196       for (i = 0; i < height; i++) {
 197          uint32_t *row = (uint32_t *)dst;
 198          for (j = 0; j < width; j++)
 199             *row++ = uc->ui[0];
 200          dst += dst_stride;
 201       }
 202       break;
 203    default:
 204       for (i = 0; i < height; i++) {
 205          ubyte *row = dst;
 206          for (j = 0; j < width; j++) {
 207             memcpy(row, uc, blocksize);
 208             row += blocksize;
 209          }
 210          dst += dst_stride;
 211       }
 212       break;
 213    }
 214 }
 215
 216
 217 void
 218 util_fill_box(ubyte * dst,
 219               enum pipe_format format,
 220               unsigned stride,
 221               unsigned layer_stride,
 222               unsigned x,
 223               unsigned y,
 224               unsigned z,
 225               unsigned width,
 226               unsigned height,
 227               unsigned depth,
 228               union util_color *uc)
 229 {
 230    unsigned layer;
 231    dst += z * layer_stride;
 232    for (layer = z; layer < depth; layer++) {
 233       util_fill_rect(dst, format,
 234                      stride,
 235                      x, y, width, height, uc);
 236       dst += layer_stride;
 237    }
 238 }
 239
 240
 241 /**
 242  * Fallback function for pipe->resource_copy_region().
 243  * Note: (X,Y)=(0,0) is always the upper-left corner.
 244  */
 245 void
 246 util_resource_copy_region(struct pipe_context *pipe,
 247                           struct pipe_resource *dst,
 248                           unsigned dst_level,
 249                           unsigned dst_x, unsigned dst_y, unsigned dst_z,
 250                           struct pipe_resource *src,
 251                           unsigned src_level,
 252                           const struct pipe_box *src_box)
 253 {
 254    struct pipe_transfer *src_trans, *dst_trans;
 255    uint8_t *dst_map;
 256    const uint8_t *src_map;
 257    MAYBE_UNUSED enum pipe_format src_format;
 258    enum pipe_format dst_format;
 259    struct pipe_box dst_box;
 260
 261    assert(src && dst);
 262    if (!src || !dst)
 263       return;
 264
 265    assert((src->target == PIPE_BUFFER && dst->target == PIPE_BUFFER) ||
 266           (src->target != PIPE_BUFFER && dst->target != PIPE_BUFFER));
 267
 268    src_format = src->format;
 269    dst_format = dst->format;
 270
 271    assert(util_format_get_blocksize(dst_format) == util_format_get_blocksize(src_format));
 272    assert(util_format_get_blockwidth(dst_format) == util_format_get_blockwidth(src_format));
 273    assert(util_format_get_blockheight(dst_format) == util_format_get_blockheight(src_format));
 274
 275    src_map = pipe->transfer_map(pipe,
 276                                 src,
 277                                 src_level,
 278                                 PIPE_TRANSFER_READ,
 279                                 src_box, &src_trans);
 280    assert(src_map);
 281    if (!src_map) {
 282       goto no_src_map;
 283    }
 284
 285    dst_box.x = dst_x;
 286    dst_box.y = dst_y;
 287    dst_box.z = dst_z;
 288    dst_box.width  = src_box->width;
 289    dst_box.height = src_box->height;
 290    dst_box.depth  = src_box->depth;
 291
 292    dst_map = pipe->transfer_map(pipe,
 293                                 dst,
 294                                 dst_level,
 295                                 PIPE_TRANSFER_WRITE | PIPE_TRANSFER_DISCARD_RANGE,
 296                                 &dst_box, &dst_trans);
 297    assert(dst_map);
 298    if (!dst_map) {
 299       goto no_dst_map;
 300    }
 301
 302    if (dst->target == PIPE_BUFFER && src->target == PIPE_BUFFER) {
 303       assert(src_box->height == 1);
 304       assert(src_box->depth == 1);
 305       memcpy(dst_map, src_map, src_box->width);
 306    } else {
 307       util_copy_box(dst_map,
 308                     dst_format,
 309                     dst_trans->stride, dst_trans->layer_stride,
 310                     0, 0, 0,
 311                     src_box->width, src_box->height, src_box->depth,
 312                     src_map,
 313                     src_trans->stride, src_trans->layer_stride,
 314                     0, 0, 0);
 315    }
 316
 317    pipe->transfer_unmap(pipe, dst_trans);
 318 no_dst_map:
 319    pipe->transfer_unmap(pipe, src_trans);
 320 no_src_map:
 321    ;
 322 }
 323
 324
 325
 326 #define UBYTE_TO_USHORT(B) ((B) | ((B) << 8))
 327
 328
 329 /**
 330  * Fallback for pipe->clear_render_target() function.
 331  * XXX this looks too hackish to be really useful.
 332  * cpp > 4 looks like a gross hack at best...
 333  * Plus can't use these transfer fallbacks when clearing
 334  * multisampled surfaces for instance.
 335  * Clears all bound layers.
 336  */
 337 void
 338 util_clear_render_target(struct pipe_context *pipe,
 339                          struct pipe_surface *dst,
 340                          const union pipe_color_union *color,
 341                          unsigned dstx, unsigned dsty,
 342                          unsigned width, unsigned height)
 343 {
 344    struct pipe_transfer *dst_trans;
 345    ubyte *dst_map;
 346    union util_color uc;
 347    unsigned max_layer;
 348
 349    assert(dst->texture);
 350    if (!dst->texture)
 351       return;
 352
 353    if (dst->texture->target == PIPE_BUFFER) {
 354       /*
 355        * The fill naturally works on the surface format, however
 356        * the transfer uses resource format which is just bytes for buffers.
 357        */
 358       unsigned dx, w;
 359       unsigned pixstride = util_format_get_blocksize(dst->format);
 360       dx = (dst->u.buf.first_element + dstx) * pixstride;
 361       w = width * pixstride;
 362       max_layer = 0;
 363       dst_map = pipe_transfer_map(pipe,
 364                                   dst->texture,
 365                                   0, 0,
 366                                   PIPE_TRANSFER_WRITE,
 367                                   dx, 0, w, 1,
 368                                   &dst_trans);
 369    }
 370    else {
 371       max_layer = dst->u.tex.last_layer - dst->u.tex.first_layer;
 372       dst_map = pipe_transfer_map_3d(pipe,
 373                                      dst->texture,
 374                                      dst->u.tex.level,
 375                                      PIPE_TRANSFER_WRITE,
 376                                      dstx, dsty, dst->u.tex.first_layer,
 377                                      width, height, max_layer + 1, &dst_trans);
 378    }
 379
 380    assert(dst_map);
 381
 382    if (dst_map) {
 383       enum pipe_format format = dst->format;
 384       assert(dst_trans->stride > 0);
 385
 386       if (util_format_is_pure_integer(format)) {
 387          /*
 388           * We expect int/uint clear values here, though some APIs
 389           * might disagree (but in any case util_pack_color()
 390           * couldn't handle it)...
 391           */
 392          if (util_format_is_pure_sint(format)) {
 393             util_format_write_4i(format, color->i, 0, &uc, 0, 0, 0, 1, 1);
 394          }
 395          else {
 396             assert(util_format_is_pure_uint(format));
 397             util_format_write_4ui(format, color->ui, 0, &uc, 0, 0, 0, 1, 1);
 398          }
 399       }
 400       else {
 401          util_pack_color(color->f, format, &uc);
 402       }
 403
 404       util_fill_box(dst_map, dst->format,
 405                     dst_trans->stride, dst_trans->layer_stride,
 406                     0, 0, 0, width, height, max_layer + 1, &uc);
 407
 408       pipe->transfer_unmap(pipe, dst_trans);
 409    }
 410 }
 411
 412 /**
 413  * Fallback for pipe->clear_stencil() function.
 414  * sw fallback doesn't look terribly useful here.
 415  * Plus can't use these transfer fallbacks when clearing
 416  * multisampled surfaces for instance.
 417  * Clears all bound layers.
 418  */
 419 void
 420 util_clear_depth_stencil(struct pipe_context *pipe,
 421                          struct pipe_surface *dst,
 422                          unsigned clear_flags,
 423                          double depth,
 424                          unsigned stencil,
 425                          unsigned dstx, unsigned dsty,
 426                          unsigned width, unsigned height)
 427 {
 428    enum pipe_format format = dst->format;
 429    struct pipe_transfer *dst_trans;
 430    ubyte *dst_map;
 431    boolean need_rmw = FALSE;
 432    unsigned max_layer, layer;
 433
 434    if ((clear_flags & PIPE_CLEAR_DEPTHSTENCIL) &&
 435        ((clear_flags & PIPE_CLEAR_DEPTHSTENCIL) != PIPE_CLEAR_DEPTHSTENCIL) &&
 436        util_format_is_depth_and_stencil(format))
 437       need_rmw = TRUE;
 438
 439    assert(dst->texture);
 440    if (!dst->texture)
 441       return;
 442
 443    max_layer = dst->u.tex.last_layer - dst->u.tex.first_layer;
 444    dst_map = pipe_transfer_map_3d(pipe,
 445                                   dst->texture,
 446                                   dst->u.tex.level,
 447                                   (need_rmw ? PIPE_TRANSFER_READ_WRITE :
 448                                               PIPE_TRANSFER_WRITE),
 449                                   dstx, dsty, dst->u.tex.first_layer,
 450                                   width, height, max_layer + 1, &dst_trans);
 451    assert(dst_map);
 452
 453    if (dst_map) {
 454       unsigned dst_stride = dst_trans->stride;
 455       uint64_t zstencil = util_pack64_z_stencil(format, depth, stencil);
 456       ubyte *dst_layer = dst_map;
 457       unsigned i, j;
 458       assert(dst_trans->stride > 0);
 459
 460       for (layer = 0; layer <= max_layer; layer++) {
 461          dst_map = dst_layer;
 462
 463          switch (util_format_get_blocksize(format)) {
 464          case 1:
 465             assert(format == PIPE_FORMAT_S8_UINT);
 466             if(dst_stride == width)
 467                memset(dst_map, (uint8_t) zstencil, height * width);
 468             else {
 469                for (i = 0; i < height; i++) {
 470                   memset(dst_map, (uint8_t) zstencil, width);
 471                   dst_map += dst_stride;
 472                }
 473             }
 474             break;
 475          case 2:
 476             assert(format == PIPE_FORMAT_Z16_UNORM);
 477             for (i = 0; i < height; i++) {
 478                uint16_t *row = (uint16_t *)dst_map;
 479                for (j = 0; j < width; j++)
 480                   *row++ = (uint16_t) zstencil;
 481                dst_map += dst_stride;
 482                }
 483             break;
 484          case 4:
 485             if (!need_rmw) {
 486                for (i = 0; i < height; i++) {
 487                   uint32_t *row = (uint32_t *)dst_map;
 488                   for (j = 0; j < width; j++)
 489                      *row++ = (uint32_t) zstencil;
 490                   dst_map += dst_stride;
 491                }
 492             }
 493             else {
 494                uint32_t dst_mask;
 495                if (format == PIPE_FORMAT_Z24_UNORM_S8_UINT)
 496                   dst_mask = 0x00ffffff;
 497                else {
 498                   assert(format == PIPE_FORMAT_S8_UINT_Z24_UNORM);
 499                   dst_mask = 0xffffff00;
 500                }
 501                if (clear_flags & PIPE_CLEAR_DEPTH)
 502                   dst_mask = ~dst_mask;
 503                for (i = 0; i < height; i++) {
 504                   uint32_t *row = (uint32_t *)dst_map;
 505                   for (j = 0; j < width; j++) {
 506                      uint32_t tmp = *row & dst_mask;
 507                      *row++ = tmp | ((uint32_t) zstencil & ~dst_mask);
 508                   }
 509                   dst_map += dst_stride;
 510                }
 511             }
 512             break;
 513          case 8:
 514             if (!need_rmw) {
 515                for (i = 0; i < height; i++) {
 516                   uint64_t *row = (uint64_t *)dst_map;
 517                   for (j = 0; j < width; j++)
 518                      *row++ = zstencil;
 519                   dst_map += dst_stride;
 520                }
 521             }
 522             else {
 523                uint64_t src_mask;
 524
 525                if (clear_flags & PIPE_CLEAR_DEPTH)
 526                   src_mask = 0x00000000ffffffffull;
 527                else
 528                   src_mask = 0x000000ff00000000ull;
 529
 530                for (i = 0; i < height; i++) {
 531                   uint64_t *row = (uint64_t *)dst_map;
 532                   for (j = 0; j < width; j++) {
 533                      uint64_t tmp = *row & ~src_mask;
 534                      *row++ = tmp | (zstencil & src_mask);
 535                   }
 536                   dst_map += dst_stride;
 537                }
 538             }
 539             break;
 540          default:
 541             assert(0);
 542             break;
 543          }
 544          dst_layer += dst_trans->layer_stride;
 545       }
 546
 547       pipe->transfer_unmap(pipe, dst_trans);
 548    }
 549 }
 550
 551
 552 /* Return if the box is totally inside the resource.
 553  */
 554 static boolean
 555 is_box_inside_resource(const struct pipe_resource *res,
 556                        const struct pipe_box *box,
 557                        unsigned level)
 558 {
 559    unsigned width = 1, height = 1, depth = 1;
 560
 561    switch (res->target) {
 562    case PIPE_BUFFER:
 563       width = res->width0;
 564       height = 1;
 565       depth = 1;
 566       break;
 567    case PIPE_TEXTURE_1D:
 568       width = u_minify(res->width0, level);
 569       height = 1;
 570       depth = 1;
 571       break;
 572    case PIPE_TEXTURE_2D:
 573    case PIPE_TEXTURE_RECT:
 574       width = u_minify(res->width0, level);
 575       height = u_minify(res->height0, level);
 576       depth = 1;
 577       break;
 578    case PIPE_TEXTURE_3D:
 579       width = u_minify(res->width0, level);
 580       height = u_minify(res->height0, level);
 581       depth = u_minify(res->depth0, level);
 582       break;
 583    case PIPE_TEXTURE_CUBE:
 584       width = u_minify(res->width0, level);
 585       height = u_minify(res->height0, level);
 586       depth = 6;
 587       break;
 588    case PIPE_TEXTURE_1D_ARRAY:
 589       width = u_minify(res->width0, level);
 590       height = 1;
 591       depth = res->array_size;
 592       break;
 593    case PIPE_TEXTURE_2D_ARRAY:
 594       width = u_minify(res->width0, level);
 595       height = u_minify(res->height0, level);
 596       depth = res->array_size;
 597       break;
 598    case PIPE_TEXTURE_CUBE_ARRAY:
 599       width = u_minify(res->width0, level);
 600       height = u_minify(res->height0, level);
 601       depth = res->array_size;
 602       assert(res->array_size % 6 == 0);
 603       break;
 604    case PIPE_MAX_TEXTURE_TYPES:
 605       break;
 606    }
 607
 608    return box->x >= 0 &&
 609           box->x + box->width <= (int) width &&
 610           box->y >= 0 &&
 611           box->y + box->height <= (int) height &&
 612           box->z >= 0 &&
 613           box->z + box->depth <= (int) depth;
 614 }
 615
 616 static unsigned
 617 get_sample_count(const struct pipe_resource *res)
 618 {
 619    return res->nr_samples ? res->nr_samples : 1;
 620 }
 621
 622 /**
 623  * Try to do a blit using resource_copy_region. The function calls
 624  * resource_copy_region if the blit description is compatible with it.
 625  *
 626  * It returns TRUE if the blit was done using resource_copy_region.
 627  *
 628  * It returns FALSE otherwise and the caller must fall back to a more generic
 629  * codepath for the blit operation. (e.g. by using u_blitter)
 630  */
 631 boolean
 632 util_try_blit_via_copy_region(struct pipe_context *ctx,
 633                               const struct pipe_blit_info *blit)
 634 {
 635    unsigned mask = util_format_get_mask(blit->dst.format);
 636
 637    /* No format conversions. */
 638    if (blit->src.resource->format != blit->src.format ||
 639        blit->dst.resource->format != blit->dst.format ||
 640        !util_is_format_compatible(
 641           util_format_description(blit->src.resource->format),
 642           util_format_description(blit->dst.resource->format))) {
 643       return FALSE;
 644    }
 645
 646    /* No masks, no filtering, no scissor. */
 647    if ((blit->mask & mask) != mask ||
 648        blit->filter != PIPE_TEX_FILTER_NEAREST ||
 649        blit->scissor_enable) {
 650       return FALSE;
 651    }
 652
 653    /* No flipping. */
 654    if (blit->src.box.width < 0 ||
 655        blit->src.box.height < 0 ||
 656        blit->src.box.depth < 0) {
 657       return FALSE;
 658    }
 659
 660    /* No scaling. */
 661    if (blit->src.box.width != blit->dst.box.width ||
 662        blit->src.box.height != blit->dst.box.height ||
 663        blit->src.box.depth != blit->dst.box.depth) {
 664       return FALSE;
 665    }
 666
 667    /* No out-of-bounds access. */
 668    if (!is_box_inside_resource(blit->src.resource, &blit->src.box,
 669                                blit->src.level) ||
 670        !is_box_inside_resource(blit->dst.resource, &blit->dst.box,
 671                                blit->dst.level)) {
 672       return FALSE;
 673    }
 674
 675    /* Sample counts must match. */
 676    if (get_sample_count(blit->src.resource) !=
 677        get_sample_count(blit->dst.resource)) {
 678       return FALSE;
 679    }
 680
 681    if (blit->alpha_blend)
 682       return FALSE;
 683
 684    ctx->resource_copy_region(ctx, blit->dst.resource, blit->dst.level,
 685                              blit->dst.box.x, blit->dst.box.y, blit->dst.box.z,
 686                              blit->src.resource, blit->src.level,
 687                              &blit->src.box);
 688    return TRUE;
 689 }