"Fossies" - the Fresh Open Source Software Archive

Member "mesa-20.1.8/src/gallium/drivers/svga/svga_pipe_blit.c" (16 Sep 2020, 30913 Bytes) of package /linux/misc/mesa-20.1.8.tar.xz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file. For more information about "svga_pipe_blit.c" see the Fossies "Dox" file reference documentation and the last Fossies "Diffs" side-by-side code changes report: 20.1.5_vs_20.2.0-rc1.

    1 /**********************************************************
    2  * Copyright 2008-2017 VMware, Inc.  All rights reserved.
    3  *
    4  * Permission is hereby granted, free of charge, to any person
    5  * obtaining a copy of this software and associated documentation
    6  * files (the "Software"), to deal in the Software without
    7  * restriction, including without limitation the rights to use, copy,
    8  * modify, merge, publish, distribute, sublicense, and/or sell copies
    9  * of the Software, and to permit persons to whom the Software is
   10  * furnished to do so, subject to the following conditions:
   11  *
   12  * The above copyright notice and this permission notice shall be
   13  * included in all copies or substantial portions of the Software.
   14  *
   15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
   16  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
   17  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
   18  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
   19  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
   20  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
   21  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
   22  * SOFTWARE.
   23  *
   24  **********************************************************/
   25 
   26 #include "svga_context.h"
   27 #include "svga_debug.h"
   28 #include "svga_cmd.h"
   29 #include "svga_format.h"
   30 #include "svga_resource_buffer.h"
   31 #include "svga_resource_texture.h"
   32 #include "svga_surface.h"
   33 
   34 //#include "util/u_blit_sw.h"
   35 #include "util/format/u_format.h"
   36 #include "util/u_surface.h"
   37 
   38 #define FILE_DEBUG_FLAG DEBUG_BLIT
   39 
   40 
   41 /**
   42  * Build a struct pipe_blit_info object from the arguments used by the
   43  * pipe::resource_copy_region() function.
   44  */
   45 static void
   46 build_blit_info(struct pipe_resource *dst_tex,
   47                 unsigned dst_level,
   48                 unsigned dst_x,
   49                 unsigned dst_y,
   50                 unsigned dst_z,
   51                 struct pipe_resource *src_tex,
   52                 unsigned src_level,
   53                 const struct pipe_box *src_box,
   54                 struct pipe_blit_info *blit)
   55 {
   56    memset(blit, 0, sizeof(*blit));
   57 
   58    blit->src.format = src_tex->format;
   59    blit->dst.format = dst_tex->format;
   60 
   61    blit->mask = util_format_get_mask(blit->dst.format);
   62    blit->filter = PIPE_TEX_FILTER_NEAREST;
   63    blit->src.resource = src_tex;
   64    blit->src.level = src_level;
   65    blit->dst.resource = dst_tex;
   66    blit->dst.level = dst_level;
   67    blit->src.box = *src_box;
   68    u_box_3d(dst_x, dst_y, dst_z, src_box->width, src_box->height,
   69             src_box->depth, &blit->dst.box);
   70 }
   71 
   72 /**
   73  * Copy when src texture and dst texture are same with IntraSurfaceCopy
   74  * command.
   75  */
   76 static void
   77 intra_surface_copy(struct svga_context *svga, struct pipe_resource *tex,
   78                     unsigned src_x, unsigned src_y, unsigned src_z,
   79                     unsigned level, unsigned layer_face,
   80                     unsigned dst_x, unsigned dst_y, unsigned dst_z,
   81                     unsigned width, unsigned height, unsigned depth)
   82 {
   83    enum pipe_error ret;
   84    SVGA3dCopyBox box;
   85    struct svga_texture *stex;
   86 
   87    /*
   88     * Makes sure we have flushed all buffered draw operations and also
   89     * synchronizes all surfaces with any emulated surface views.
   90     */
   91    svga_surfaces_flush(svga);
   92 
   93    stex = svga_texture(tex);
   94 
   95    box.x = dst_x;
   96    box.y = dst_y;
   97    box.z = dst_z;
   98    box.w = width;
   99    box.h = height;
  100    box.d = depth;
  101    box.srcx = src_x;
  102    box.srcy = src_y;
  103    box.srcz = src_z;
  104 
  105    ret = SVGA3D_vgpu10_IntraSurfaceCopy(svga->swc,
  106                                  stex->handle, level, layer_face,  &box);
  107    if (ret != PIPE_OK) {
  108       svga_context_flush(svga, NULL);
  109    ret = SVGA3D_vgpu10_IntraSurfaceCopy(svga->swc,
  110                                  stex->handle, level, layer_face, &box);
  111       assert(ret == PIPE_OK);
  112    }
  113 
  114    /* Mark the texture subresource as rendered-to. */
  115    svga_set_texture_rendered_to(stex, layer_face, level);
  116 }
  117 
  118 /**
  119  * Copy an image between textures with the vgpu10 CopyRegion command.
  120  */
  121 static void
  122 copy_region_vgpu10(struct svga_context *svga, struct pipe_resource *src_tex,
  123                     unsigned src_x, unsigned src_y, unsigned src_z,
  124                     unsigned src_level, unsigned src_layer_face,
  125                     struct pipe_resource *dst_tex,
  126                     unsigned dst_x, unsigned dst_y, unsigned dst_z,
  127                     unsigned dst_level, unsigned dst_layer_face,
  128                     unsigned width, unsigned height, unsigned depth)
  129 {
  130    uint32 srcSubResource, dstSubResource;
  131    struct svga_texture *dtex, *stex;
  132 
  133    stex = svga_texture(src_tex);
  134    dtex = svga_texture(dst_tex);
  135 
  136    svga_surfaces_flush(svga);
  137 
  138    srcSubResource = src_layer_face * (src_tex->last_level + 1) + src_level;
  139    dstSubResource = dst_layer_face * (dst_tex->last_level + 1) + dst_level;
  140 
  141    svga_texture_copy_region(svga, stex->handle, srcSubResource,
  142                             src_x, src_y, src_z,
  143                             dtex->handle, dstSubResource,
  144                             dst_x, dst_y, dst_z,
  145                             width, height, depth);
  146 
  147    /* Mark the texture subresource as defined. */
  148    svga_define_texture_level(dtex, dst_layer_face, dst_level);
  149 
  150    /* Mark the texture subresource as rendered-to. */
  151    svga_set_texture_rendered_to(dtex, dst_layer_face, dst_level);
  152 }
  153 
  154 
  155 /**
  156  * Fallback to the copy region utility which uses map/memcpy for the copy
  157  */
  158 static void
  159 copy_region_fallback(struct svga_context *svga, 
  160                      struct pipe_resource *dst_tex, unsigned dst_level,
  161                      unsigned dstx, unsigned dsty, unsigned dstz,
  162                      struct pipe_resource *src_tex, unsigned src_level,
  163                      const struct pipe_box *src_box)
  164 {
  165    struct svga_winsys_screen *sws = svga_screen(svga->pipe.screen)->sws;
  166 
  167    SVGA_STATS_TIME_PUSH(sws, SVGA_STATS_TIME_COPYREGIONFALLBACK);
  168    util_resource_copy_region(&svga->pipe, dst_tex, dst_level, dstx,
  169                              dsty, dstz, src_tex, src_level, src_box);
  170    SVGA_STATS_TIME_POP(sws);
  171    (void) sws;
  172 }
  173 
  174 
  175 /**
  176  * Whether the layer_face index is given by the Z coordinate.
  177  */
  178 static bool
  179 has_layer_face_index_in_z(enum pipe_texture_target target)
  180 {
  181    if (target == PIPE_TEXTURE_CUBE ||
  182        target == PIPE_TEXTURE_1D_ARRAY ||
  183        target == PIPE_TEXTURE_2D_ARRAY ||
  184        target == PIPE_TEXTURE_CUBE_ARRAY)
  185       return true;
  186    else
  187       return false;
  188 }
  189 
  190 
  191 /**
  192  * For some texture types, we need to move the z (slice) coordinate
  193  * to the layer value.  For example, to select the z=3 slice of a 2D ARRAY
  194  * texture, we need to use layer=3 and set z=0.
  195  */
  196 static void
  197 adjust_z_layer(enum pipe_texture_target target,
  198                int z_in, unsigned *layer_out, unsigned *z_out)
  199 {
  200    if (target == PIPE_TEXTURE_CUBE ||
  201        target == PIPE_TEXTURE_1D_ARRAY ||
  202        target == PIPE_TEXTURE_2D_ARRAY ||
  203        target == PIPE_TEXTURE_CUBE_ARRAY) {
  204       *layer_out = z_in;
  205       *z_out = 0;
  206    }
  207    else {
  208       *layer_out = 0;
  209       *z_out = z_in;
  210    }
  211 }
  212 
  213 
  214 /**
  215  * Are the given SVGA3D formats compatible, in terms of vgpu10's
  216  * PredCopyRegion() command?
  217  */
  218 static bool
  219 formats_compatible(const struct svga_screen *ss,
  220                    SVGA3dSurfaceFormat src_svga_fmt,
  221                    SVGA3dSurfaceFormat dst_svga_fmt)
  222 {
  223    src_svga_fmt = svga_typeless_format(src_svga_fmt);
  224    dst_svga_fmt = svga_typeless_format(dst_svga_fmt);
  225 
  226    return src_svga_fmt == dst_svga_fmt;
  227 }
  228 
  229 
  230 /**
  231  * Check whether the blending is enabled or not
  232  */
  233 static bool
  234 is_blending_enabled(struct svga_context *svga,
  235                     const struct pipe_blit_info *blit)
  236 {
  237    bool blend_enable = false;
  238    int i;
  239    if (svga->curr.blend) {
  240       if (svga->curr.blend->independent_blend_enable) {
  241          for (i = 0; i < PIPE_MAX_COLOR_BUFS; i++) {
  242             struct pipe_surface *cbuf = svga->curr.framebuffer.cbufs[i];
  243             if (cbuf && (cbuf->texture == blit->dst.resource)) {
  244                if (svga->curr.blend->rt[i].blend_enable) {
  245                   blend_enable = true;
  246                }
  247                break;
  248             }
  249          }
  250       }
  251       else {
  252          if (svga->curr.blend->rt[0].blend_enable)
  253             blend_enable = true;
  254       }
  255    }
  256    return blend_enable;
  257 }
  258 
  259 /**
  260  * If GL_FRAMEBUFFER_SRGB is enabled, then output colorspace is
  261  * expected to be sRGB if blending is not enabled.
  262  * If GL_FRAMEBUFFER_SRGB is disabled, then we can use
  263  * copy_region_vgpu10()
  264  * Following table basically tells when copy_region_vgpu10 can be
  265  * used if GL_FRAMEBUFFER_SRGB is enabled.
  266  * ______________________________________________________________
  267  *  | src fmt     | dst_fmt   | blending  |Can use       |
  268  *  |             |           |           |copy_region   |
  269  * ______________________________________________________________
  270  *  | linear      | linear    |   N       |     Y        |
  271  *  | linear      | linear    |   Y       |     Y        |
  272  *  | linear      | sRGB      |   N       |     N        |
  273  *  | linear      | sRGB      |   Y       |     Y        |
  274  *  | sRGB        | linear    |   N       |     N        |
  275  *  | sRGB        | linear    |   Y       |     N        |
  276  *  | sRGB        | sRGB      |   N       |     Y        |
  277  *  | sRGB        | sRGB      |   Y       |     N        |
  278  * ______________________________________________________________
  279  *
  280  */
  281 static bool
  282 check_blending_and_srgb_cond(struct svga_context *svga,
  283                              const struct pipe_blit_info *blit)
  284 {
  285    enum pipe_format sFmt = blit->src.format;
  286    enum pipe_format dFmt = blit->dst.format;
  287 
  288    if (is_blending_enabled(svga, blit)) {
  289       if (!util_format_is_srgb(blit->src.format))
  290          return true;
  291    }
  292    else {
  293       if (util_format_is_srgb(sFmt) && util_format_is_srgb(dFmt))
  294          return true;
  295       else if (!util_format_is_srgb(sFmt)){
  296          if (!util_format_is_srgb(dFmt))
  297             return true;
  298          else {
  299            /**
  300             * State tracker converts all sRGB src blit format
  301             * to linear if GL_FRAMEBUFFER_SRGB is disabled.
  302             * So if src resource format is sRGB and
  303             * blit format is linear then it means,
  304             * GL_FRAMEBUFFER_SRGB is disabled. In this case also
  305             * we can use copy_region_vgpu10().
  306             */
  307 
  308             if (util_format_is_srgb(blit->src.resource->format))
  309                return true;
  310          }
  311       }
  312    }
  313    return false;
  314 }
  315 
  316 /**
  317  * Do common checks for svga surface copy.
  318  */
  319 static bool
  320 can_blit_via_svga_copy_region(struct svga_context *svga,
  321                               const struct pipe_blit_info *blit_info)
  322 {
  323    struct pipe_blit_info local_blit = *blit_info;
  324 
  325    /* First basic checks to catch incompatibilities in new or locally unchecked
  326     * struct pipe_blit_info members but bypass the format check here.
  327     * Also since util_can_blit_via_copy_region() requires a dimension match,
  328     * PIPE_FILTER_LINEAR should be equal to PIPE_FILTER_NEAREST.
  329     */
  330    local_blit.dst.format = local_blit.src.format;
  331    if (local_blit.filter == PIPE_TEX_FILTER_LINEAR)
  332       local_blit.filter = PIPE_TEX_FILTER_NEAREST;
  333    if (!util_can_blit_via_copy_region(&local_blit, TRUE))
  334       return false;
  335 
  336    /* For depth+stencil formats, copy with mask != PIPE_MASK_ZS is not
  337     * supported
  338     */
  339    if (util_format_is_depth_and_stencil(blit_info->src.format) &&
  340       blit_info->mask != (PIPE_MASK_ZS))
  341      return false;
  342 
  343    return check_blending_and_srgb_cond(svga, blit_info);
  344 }
  345 
  346 /**
  347  * Check whether we can blit using the intra_surface_copy command.
  348  */
  349 static bool
  350 can_blit_via_intra_surface_copy(struct svga_context *svga,
  351                                 const struct pipe_blit_info *blit_info)
  352 {
  353    struct svga_winsys_screen *sws = svga_screen(svga->pipe.screen)->sws;
  354    struct svga_texture *dtex, *stex;
  355 
  356    if (!svga_have_vgpu10(svga))
  357       return false;
  358 
  359    /* src surface cannot be multisample */
  360    if (blit_info->src.resource->nr_samples > 1)
  361       return false;
  362 
  363    if (!sws->have_intra_surface_copy)
  364       return false;
  365 
  366    if (svga->render_condition && blit_info->render_condition_enable)
  367       return false;
  368 
  369    if (blit_info->src.level != blit_info->dst.level)
  370       return false;
  371 
  372    if (has_layer_face_index_in_z(blit_info->src.resource->target)){
  373       if (blit_info->src.box.z != blit_info->dst.box.z)
  374          return false;
  375    }
  376 
  377    stex = svga_texture(blit_info->src.resource);
  378    dtex = svga_texture(blit_info->dst.resource);
  379 
  380    return (stex->handle == dtex->handle);
  381 }
  382 
  383 
  384 /**
  385  * The state tracker implements some resource copies with blits (for
  386  * GL_ARB_copy_image).  This function checks if we should really do the blit
  387  * with a VGPU10 CopyRegion command or software fallback (for incompatible
  388  * src/dst formats).
  389  */
  390 static bool
  391 can_blit_via_copy_region_vgpu10(struct svga_context *svga,
  392                                 const struct pipe_blit_info *blit_info)
  393 {
  394    struct svga_texture *dtex, *stex;
  395 
  396    /* can't copy between different resource types */
  397    if (svga_resource_type(blit_info->src.resource->target) !=
  398        svga_resource_type(blit_info->dst.resource->target))
  399       return false;
  400 
  401    stex = svga_texture(blit_info->src.resource);
  402    dtex = svga_texture(blit_info->dst.resource);
  403 
  404    if (!svga_have_vgpu10(svga))
  405       return false;
  406 
  407    if (stex->handle == dtex->handle)
  408       return false;
  409 
  410    return formats_compatible(svga_screen(svga->pipe.screen),
  411                              stex->key.format,
  412                              dtex->key.format);
  413 }
  414 
  415 
  416 /**
  417  * Check whether we can blit using the surface_copy command.
  418  */
  419 static bool
  420 can_blit_via_surface_copy(struct svga_context *svga,
  421                           const struct pipe_blit_info *blit_info)
  422 {
  423    struct svga_texture *dtex, *stex;
  424 
  425    /* Mimic the format tests in util_can_blit_via_copy_region(), but
  426     * skip the other tests that have already been performed.
  427     */
  428    if (blit_info->src.format != blit_info->dst.format) {
  429       const struct util_format_description *src_desc, *dst_desc;
  430 
  431       src_desc = util_format_description(blit_info->src.resource->format);
  432       dst_desc = util_format_description(blit_info->dst.resource->format);
  433 
  434       if (blit_info->src.resource->format != blit_info->src.format ||
  435           blit_info->dst.resource->format != blit_info->dst.format ||
  436           !util_is_format_compatible(src_desc, dst_desc))
  437          return false;
  438    }
  439 
  440    if (svga->render_condition && blit_info->render_condition_enable)
  441       return false;
  442 
  443    /* can't copy between different resource types */
  444    if (svga_resource_type(blit_info->src.resource->target) !=
  445        svga_resource_type(blit_info->dst.resource->target))
  446       return false;
  447 
  448    stex = svga_texture(blit_info->src.resource);
  449    dtex = svga_texture(blit_info->dst.resource);
  450 
  451    if (stex->handle == dtex->handle)
  452       return false;
  453 
  454    /*
  455     * This is what we've been using before, but it can probably be
  456     * relaxed. The device checks are less stringent.
  457     */
  458    return (stex->b.b.format == dtex->b.b.format);
  459 }
  460 
  461 
  462 /**
  463  * Try region copy using one of the region copy commands
  464  */
  465 static bool
  466 try_copy_region(struct svga_context *svga,
  467                 const struct pipe_blit_info *blit)
  468 {
  469    unsigned src_layer_face, src_z, dst_layer_face, dst_z;
  470 
  471    if (!can_blit_via_svga_copy_region(svga, blit))
  472       return false;
  473 
  474    adjust_z_layer(blit->src.resource->target, blit->src.box.z,
  475                   &src_layer_face, &src_z);
  476 
  477    adjust_z_layer(blit->dst.resource->target, blit->dst.box.z,
  478                   &dst_layer_face, &dst_z);
  479 
  480    if (can_blit_via_copy_region_vgpu10(svga, blit)) {
  481       svga_toggle_render_condition(svga, blit->render_condition_enable, FALSE);
  482 
  483       copy_region_vgpu10(svga,
  484                          blit->src.resource,
  485                          blit->src.box.x, blit->src.box.y, src_z,
  486                          blit->src.level, src_layer_face,
  487                          blit->dst.resource,
  488                          blit->dst.box.x, blit->dst.box.y, dst_z,
  489                          blit->dst.level, dst_layer_face,
  490                          blit->src.box.width, blit->src.box.height,
  491                          blit->src.box.depth);
  492 
  493       svga_toggle_render_condition(svga, blit->render_condition_enable, TRUE);
  494 
  495       return true;
  496    }
  497 
  498    if (can_blit_via_surface_copy(svga, blit)) {
  499       struct svga_texture *stex = svga_texture(blit->src.resource);
  500       struct svga_texture *dtex = svga_texture(blit->dst.resource);
  501 
  502       svga_surfaces_flush(svga);
  503 
  504       svga_texture_copy_handle(svga,
  505                                stex->handle,
  506                                blit->src.box.x, blit->src.box.y, src_z,
  507                                blit->src.level, src_layer_face,
  508                                dtex->handle,
  509                                blit->dst.box.x, blit->dst.box.y, dst_z,
  510                                blit->dst.level, dst_layer_face,
  511                                blit->src.box.width, blit->src.box.height,
  512                                blit->src.box.depth);
  513 
  514       svga_define_texture_level(dtex, dst_layer_face, blit->dst.level);
  515       svga_set_texture_rendered_to(dtex, dst_layer_face, blit->dst.level);
  516       return true;
  517    }
  518 
  519    if (can_blit_via_intra_surface_copy(svga, blit)) {
  520       intra_surface_copy(svga,
  521                          blit->src.resource,
  522                          blit->src.box.x, blit->src.box.y, src_z,
  523                          blit->src.level, src_layer_face,
  524                          blit->dst.box.x, blit->dst.box.y, dst_z,
  525                          blit->src.box.width, blit->src.box.height,
  526                          blit->src.box.depth);
  527       return true;
  528    }
  529 
  530    return false;
  531 }
  532 
  533 
  534 /**
  535  * A helper function to determine if the specified view format
  536  * is compatible with the surface format.
  537  * It is compatible if the view format is the same as the surface format,
  538  * or the associated svga format for the surface is a typeless format, or
  539  * the view format is an adjusted format for BGRX/BGRA resource.
  540  */
  541 static bool
  542 is_view_format_compatible(enum pipe_format surf_fmt,
  543                           SVGA3dSurfaceFormat surf_svga_fmt,
  544                           enum pipe_format view_fmt)
  545 {
  546    if (surf_fmt == view_fmt || svga_format_is_typeless(surf_svga_fmt))
  547       return true;
  548 
  549    if ((surf_fmt == PIPE_FORMAT_B8G8R8X8_UNORM &&
  550         view_fmt == PIPE_FORMAT_B8G8R8A8_UNORM) ||
  551        (surf_fmt == PIPE_FORMAT_B8G8R8A8_UNORM &&
  552         view_fmt == PIPE_FORMAT_B8G8R8X8_UNORM))
  553       return true;
  554 
  555    return false;
  556 }
  557 
  558 
  559 /**
  560  * Try issuing a quad blit.
  561  */
  562 static bool
  563 try_blit(struct svga_context *svga, const struct pipe_blit_info *blit_info)
  564 {
  565    struct svga_winsys_screen *sws = svga_screen(svga->pipe.screen)->sws;
  566    struct pipe_resource *src = blit_info->src.resource;
  567    struct pipe_resource *dst = blit_info->dst.resource;
  568    struct pipe_resource *newSrc = NULL;
  569    struct pipe_resource *newDst = NULL;
  570    bool can_create_src_view;
  571    bool can_create_dst_view;
  572    bool ret = true;
  573    struct pipe_blit_info blit = *blit_info;
  574 
  575    SVGA_STATS_TIME_PUSH(sws, SVGA_STATS_TIME_BLITBLITTER);
  576 
  577    /**
  578     * Avoid using util_blitter_blit() for these depth formats on non-vgpu10
  579     * devices because these depth formats only support comparison mode
  580     * and not ordinary sampling.
  581     */
  582    if (!svga_have_vgpu10(svga) && (blit.mask & PIPE_MASK_Z) &&
  583        (svga_texture(dst)->key.format == SVGA3D_Z_D16 ||
  584        svga_texture(dst)->key.format == SVGA3D_Z_D24X8 ||
  585        svga_texture(dst)->key.format == SVGA3D_Z_D24S8)) {
  586       ret = false;
  587       goto done;
  588   }
  589 
  590    /**
  591     * If format is srgb and blend is enabled then color values need
  592     * to be converted into linear format.
  593     */
  594    if (is_blending_enabled(svga, &blit)) {
  595       blit.src.format = util_format_linear(blit.src.format);
  596       blit.dst.format = util_format_linear(blit.dst.format);
  597    }
  598 
  599    /* Check if we can create shader resource view and
  600     * render target view for the quad blitter to work
  601     */
  602    can_create_src_view =
  603       is_view_format_compatible(src->format, svga_texture(src)->key.format,
  604                                 blit.src.format);
  605 
  606    can_create_dst_view =
  607       is_view_format_compatible(dst->format, svga_texture(dst)->key.format,
  608                                 blit.dst.format);
  609 
  610    if ((blit.mask & PIPE_MASK_S) ||
  611        ((!can_create_dst_view || !can_create_src_view)
  612         && !svga_have_vgpu10(svga))) {
  613       /* Can't do stencil blits with textured quad blitter */
  614       debug_warn_once("using software stencil blit");
  615       ret = false;
  616       goto done;
  617    }
  618 
  619    if (!util_blitter_is_blit_supported(svga->blitter, &blit)) {
  620       debug_printf("svga: blit unsupported %s -> %s\n",
  621                    util_format_short_name(blit.src.resource->format),
  622                    util_format_short_name(blit.dst.resource->format));
  623       ret = false;
  624       goto done;
  625    }
  626 
  627    /* XXX turn off occlusion and streamout queries */
  628 
  629    util_blitter_save_vertex_buffer_slot(svga->blitter, svga->curr.vb);
  630    util_blitter_save_vertex_elements(svga->blitter, (void*)svga->curr.velems);
  631    util_blitter_save_vertex_shader(svga->blitter, svga->curr.vs);
  632    util_blitter_save_geometry_shader(svga->blitter, svga->curr.user_gs);
  633    util_blitter_save_so_targets(svga->blitter, svga->num_so_targets,
  634                      (struct pipe_stream_output_target**)svga->so_targets);
  635    util_blitter_save_rasterizer(svga->blitter, (void*)svga->curr.rast);
  636    util_blitter_save_viewport(svga->blitter, &svga->curr.viewport);
  637    util_blitter_save_scissor(svga->blitter, &svga->curr.scissor);
  638    util_blitter_save_fragment_shader(svga->blitter, svga->curr.fs);
  639    util_blitter_save_blend(svga->blitter, (void*)svga->curr.blend);
  640    util_blitter_save_depth_stencil_alpha(svga->blitter,
  641                                          (void*)svga->curr.depth);
  642    util_blitter_save_stencil_ref(svga->blitter, &svga->curr.stencil_ref);
  643    util_blitter_save_sample_mask(svga->blitter, svga->curr.sample_mask);
  644    util_blitter_save_framebuffer(svga->blitter, &svga->curr.framebuffer);
  645    util_blitter_save_fragment_sampler_states(svga->blitter,
  646                      svga->curr.num_samplers[PIPE_SHADER_FRAGMENT],
  647                      (void**)svga->curr.sampler[PIPE_SHADER_FRAGMENT]);
  648    util_blitter_save_fragment_sampler_views(svga->blitter,
  649                      svga->curr.num_sampler_views[PIPE_SHADER_FRAGMENT],
  650                      svga->curr.sampler_views[PIPE_SHADER_FRAGMENT]);
  651 
  652    if (!can_create_src_view) {
  653       struct pipe_resource template;
  654       struct pipe_blit_info copy_region_blit;
  655 
  656       /**
  657        * If the source blit format is not compatible with the source resource
  658        * format, we will not be able to create a shader resource view.
  659        * In order to avoid falling back to software blit, we'll create
  660        * a new resource in the blit format, and use DXCopyResource to
  661        * copy from the original format to the new format. The new
  662        * resource will be used for the blit in util_blitter_blit().
  663        */
  664       template = *src;
  665       template.format = blit.src.format;
  666       newSrc = svga_texture_create(svga->pipe.screen, &template);
  667       if (newSrc == NULL) {
  668          debug_printf("svga_blit: fails to create temporary src\n");
  669          ret = false;
  670          goto done;
  671       }
  672 
  673       /* increment the mksStats for blitter with extra copy */
  674       SVGA_STATS_COUNT_INC(sws, SVGA_STATS_COUNT_BLITBLITTERCOPY);
  675       build_blit_info(newSrc,
  676                       blit.src.level, blit.src.box.x,
  677                       blit.src.box.y, blit.src.box.z,
  678                       blit.src.resource,
  679                       blit.src.level, &blit.src.box,
  680                       &copy_region_blit);
  681       if (!try_copy_region(svga, &copy_region_blit)) {
  682          debug_printf("svga: Source blit format conversion failed.\n");
  683          ret = false;
  684          goto done;
  685       }
  686 
  687       blit.src.resource = newSrc;
  688    }
  689 
  690    if (!can_create_dst_view) {
  691       struct pipe_resource template;
  692 
  693       /*
  694        * If the destination blit format is not compatible with the destination
  695        * resource format, we will not be able to create a render target view.
  696        * In order to avoid falling back to software blit, we'll create
  697        * a new resource in the blit format, and use DXPredCopyRegion
  698        * after the blit to copy from the blit format back to the resource
  699        * format.
  700        */
  701       template = *dst;
  702       template.format = blit.dst.format;
  703       newDst = svga_texture_create(svga->pipe.screen, &template);
  704       if (newDst == NULL) {
  705          debug_printf("svga_blit: fails to create temporary dst\n");
  706          ret = false;
  707          goto done;
  708       }
  709 
  710       blit.dst.resource = newDst;
  711    }
  712 
  713    svga_toggle_render_condition(svga, blit.render_condition_enable, FALSE);
  714 
  715    util_blitter_blit(svga->blitter, &blit);
  716 
  717    svga_toggle_render_condition(svga, blit.render_condition_enable, TRUE);
  718 
  719    if (blit.dst.resource != dst) {
  720       struct pipe_blit_info copy_region_blit;
  721 
  722       /* increment the mksStats for blitter with extra copy */
  723       SVGA_STATS_COUNT_INC(sws, SVGA_STATS_COUNT_BLITBLITTERCOPY);
  724 
  725       /*
  726        * A temporary resource was created for the blit, we need to
  727        * copy from the temporary resource back to the original destination.
  728        */
  729       build_blit_info(dst,
  730                       blit.dst.level, blit.dst.box.x,
  731                       blit.dst.box.y, blit.dst.box.z,
  732                       newDst,
  733                       blit.dst.level, &blit.dst.box,
  734                       &copy_region_blit);
  735       if (!try_copy_region(svga, &copy_region_blit)) {
  736          debug_printf("svga: Destination blit format conversion failed.\n");
  737          ret = false;
  738          goto done;
  739       }
  740    }
  741 
  742 done:
  743    /* unreference the temporary resources if needed */
  744    pipe_resource_reference(&newDst, NULL);
  745    pipe_resource_reference(&newSrc, NULL);
  746 
  747    SVGA_STATS_TIME_POP(sws);  /* SVGA_STATS_TIME_BLITBLITTER */
  748    (void) sws;
  749 
  750    return ret;
  751 }
  752 
  753 
  754 /**
  755  * Try a cpu copy_region fallback.
  756  */
  757 static bool
  758 try_cpu_copy_region(struct svga_context *svga,
  759                     const struct pipe_blit_info *blit)
  760 {
  761    if (util_can_blit_via_copy_region(blit, TRUE) ||
  762        util_can_blit_via_copy_region(blit, FALSE)) {
  763 
  764       if (svga->render_condition && blit->render_condition_enable) {
  765          debug_warning("CPU copy_region doesn't support "
  766                        "conditional rendering.\n");
  767          return false;
  768       }
  769 
  770       copy_region_fallback(svga, blit->dst.resource,
  771                            blit->dst.level,
  772                            blit->dst.box.x, blit->dst.box.y,
  773                            blit->dst.box.z, blit->src.resource,
  774                            blit->src.level, &blit->src.box);
  775       return true;
  776    }
  777 
  778    return false;
  779 }
  780 
  781 
  782 /**
  783  * The pipe::blit member.
  784  */
  785 static void
  786 svga_blit(struct pipe_context *pipe,
  787           const struct pipe_blit_info *blit)
  788 {
  789    struct svga_context *svga = svga_context(pipe);
  790    struct svga_winsys_screen *sws = svga_screen(pipe->screen)->sws;
  791 
  792    if (!svga_have_vgpu10(svga) &&
  793        blit->src.resource->nr_samples > 1 &&
  794        blit->dst.resource->nr_samples <= 1 &&
  795        !util_format_is_depth_or_stencil(blit->src.resource->format) &&
  796        !util_format_is_pure_integer(blit->src.resource->format)) {
  797       debug_printf("svga: color resolve unimplemented\n");
  798       return;
  799    }
  800 
  801    SVGA_STATS_TIME_PUSH(sws, SVGA_STATS_TIME_BLIT);
  802 
  803    if (try_copy_region(svga, blit))
  804       goto done;
  805 
  806    if (try_blit(svga, blit))
  807       goto done;
  808 
  809    if (!try_cpu_copy_region(svga, blit))
  810       debug_printf("svga: Blit failed.\n");
  811    
  812 done:
  813    SVGA_STATS_TIME_POP(sws);  /* SVGA_STATS_TIME_BLIT */
  814    (void) sws;
  815 }
  816 
  817 
  818 /**
  819  * The pipe::resource_copy_region member.
  820  */
  821 static void
  822 svga_resource_copy_region(struct pipe_context *pipe,
  823                           struct pipe_resource *dst_tex,
  824                           unsigned dst_level,
  825                           unsigned dstx, unsigned dsty, unsigned dstz,
  826                           struct pipe_resource *src_tex,
  827                           unsigned src_level,
  828                           const struct pipe_box *src_box)
  829 {
  830    struct svga_context *svga = svga_context(pipe);
  831    struct svga_winsys_screen *sws = svga_screen(svga->pipe.screen)->sws;
  832 
  833    SVGA_STATS_TIME_PUSH(sws, SVGA_STATS_TIME_COPYREGION);
  834 
  835    if (dst_tex->target == PIPE_BUFFER && src_tex->target == PIPE_BUFFER) {
  836       /* can't copy within the same buffer, unfortunately */
  837       if (svga_have_vgpu10(svga) && src_tex != dst_tex) {
  838          enum pipe_error ret;
  839          struct svga_winsys_surface *src_surf;
  840          struct svga_winsys_surface *dst_surf;
  841          struct svga_buffer *dbuffer = svga_buffer(dst_tex);
  842          struct svga_buffer *sbuffer = svga_buffer(src_tex);
  843 
  844          src_surf = svga_buffer_handle(svga, src_tex, sbuffer->bind_flags);
  845          dst_surf = svga_buffer_handle(svga, dst_tex, dbuffer->bind_flags);
  846 
  847          ret = SVGA3D_vgpu10_BufferCopy(svga->swc, src_surf, dst_surf,
  848                                         src_box->x, dstx, src_box->width);
  849          if (ret != PIPE_OK) {
  850             svga_context_flush(svga, NULL);
  851             ret = SVGA3D_vgpu10_BufferCopy(svga->swc, src_surf, dst_surf,
  852                                            src_box->x, dstx, src_box->width);
  853             assert(ret == PIPE_OK);
  854          }
  855 
  856          dbuffer->dirty = TRUE;
  857       }
  858       else {
  859          /* use map/memcpy fallback */
  860          copy_region_fallback(svga, dst_tex, dst_level, dstx,
  861                               dsty, dstz, src_tex, src_level, src_box);
  862       }
  863    } else {
  864       struct pipe_blit_info blit;
  865 
  866       build_blit_info(dst_tex, dst_level, dstx, dsty, dstz,
  867                       src_tex, src_level, src_box, &blit);
  868 
  869       if (try_copy_region(svga, &blit))
  870          goto done;
  871 
  872       /* Blits are format-converting which is not what we want, so perform a
  873        * strict format-check.
  874        * FIXME: Need to figure out why srgb blits (tf2) and
  875        * 3D blits (piglit) are broken here. Perhaps we set up the
  876        * struct pipe_blit_info incorrectly.
  877        */
  878       if (src_tex->format == dst_tex->format &&
  879           !util_format_is_srgb(src_tex->format) &&
  880           svga_resource_type(src_tex->target) != SVGA3D_RESOURCE_TEXTURE3D &&
  881           try_blit(svga, &blit))
  882          goto done;
  883 
  884       copy_region_fallback(svga, dst_tex, dst_level, dstx, dsty, dstz,
  885                            src_tex, src_level, src_box);
  886    }
  887 
  888 done:
  889    SVGA_STATS_TIME_POP(sws);
  890    (void) sws;
  891 }
  892 
  893 
  894 /**
  895  * The pipe::flush_resource member.
  896  */
  897 static void
  898 svga_flush_resource(struct pipe_context *pipe,
  899                     struct pipe_resource *resource)
  900 {
  901 }
  902 
  903 
  904 /**
  905  * Setup the pipe blit, resource_copy_region and flush_resource members.
  906  */
  907 void
  908 svga_init_blit_functions(struct svga_context *svga)
  909 {
  910    svga->pipe.resource_copy_region = svga_resource_copy_region;
  911    svga->pipe.blit = svga_blit;
  912    svga->pipe.flush_resource = svga_flush_resource;
  913 }