X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fgallium%2Fdrivers%2Fsvga%2Fsvga_pipe_blit.c;h=5a7fa3087181180a425d61eb1f7e85a5a1ab97b1;hb=c8ef82d65a2c563c1dbafb2a252aca230ab9d1c7;hp=889da29e28b720a9016457906af86b873162205d;hpb=8f3bdeaad610d7d5a5c6e73e1e9c721219595754;p=mesa.git diff --git a/src/gallium/drivers/svga/svga_pipe_blit.c b/src/gallium/drivers/svga/svga_pipe_blit.c index 889da29e28b..5a7fa308718 100644 --- a/src/gallium/drivers/svga/svga_pipe_blit.c +++ b/src/gallium/drivers/svga/svga_pipe_blit.c @@ -23,71 +23,361 @@ * **********************************************************/ -#include "svga_resource_texture.h" #include "svga_context.h" #include "svga_debug.h" #include "svga_cmd.h" +#include "svga_resource_buffer.h" +#include "svga_resource_texture.h" #include "svga_surface.h" +//#include "util/u_blit_sw.h" +#include "util/u_format.h" +#include "util/u_surface.h" + #define FILE_DEBUG_FLAG DEBUG_BLIT -static void svga_surface_copy(struct pipe_context *pipe, - struct pipe_surface *dest, - unsigned destx, unsigned desty, - struct pipe_surface *src, - unsigned srcx, unsigned srcy, - unsigned width, unsigned height) +/** + * Copy an image between textures with the vgpu10 CopyRegion command. + */ +static void +copy_region_vgpu10(struct svga_context *svga, struct pipe_resource *src_tex, + unsigned src_x, unsigned src_y, unsigned src_z, + unsigned src_level, unsigned src_face, + struct pipe_resource *dst_tex, + unsigned dst_x, unsigned dst_y, unsigned dst_z, + unsigned dst_level, unsigned dst_face, + unsigned width, unsigned height, unsigned depth) { - struct svga_context *svga = svga_context(pipe); - SVGA3dCopyBox *box; enum pipe_error ret; + uint32 srcSubResource, dstSubResource; + struct svga_texture *dtex, *stex; + SVGA3dCopyBox box; - svga_hwtnl_flush_retry( svga ); + stex = svga_texture(src_tex); + dtex = svga_texture(dst_tex); - SVGA_DBG(DEBUG_DMA, "blit to sid %p (%d,%d), from sid %p (%d,%d) sz %dx%d\n", - svga_surface(dest)->handle, - destx, desty, - svga_surface(src)->handle, - srcx, srcy, - width, height); + box.x = dst_x; + box.y = dst_y; + box.z = dst_z; + box.w = width; + box.h = height; + box.d = depth; + box.srcx = src_x; + box.srcy = src_y; + box.srcz = src_z; - ret = SVGA3D_BeginSurfaceCopy(svga->swc, - src, - dest, - &box, - 1); - if(ret != PIPE_OK) { + srcSubResource = src_face * (src_tex->last_level + 1) + src_level; + dstSubResource = dst_face * (dst_tex->last_level + 1) + dst_level; + ret = SVGA3D_vgpu10_PredCopyRegion(svga->swc, + dtex->handle, dstSubResource, + stex->handle, srcSubResource, &box); + if (ret != PIPE_OK) { svga_context_flush(svga, NULL); - - ret = SVGA3D_BeginSurfaceCopy(svga->swc, - src, - dest, - &box, - 1); + ret = SVGA3D_vgpu10_PredCopyRegion(svga->swc, + dtex->handle, dstSubResource, + stex->handle, srcSubResource, &box); assert(ret == PIPE_OK); } - box->x = destx; - box->y = desty; - box->z = 0; - box->w = width; - box->h = height; - box->d = 1; - box->srcx = srcx; - box->srcy = srcy; - box->srcz = 0; + svga_define_texture_level(dtex, dst_face, dst_level); +} + + +static void +svga_resource_copy_region(struct pipe_context *pipe, + struct pipe_resource *dst_tex, + unsigned dst_level, + unsigned dstx, unsigned dsty, unsigned dstz, + struct pipe_resource *src_tex, + unsigned src_level, + const struct pipe_box *src_box) +{ + struct svga_context *svga = svga_context(pipe); + struct svga_texture *stex, *dtex; + unsigned dst_face_layer, dst_z, src_face_layer, src_z; + + /* Emit buffered drawing commands, and any back copies. + */ + svga_surfaces_flush( svga ); + + if (dst_tex->target == PIPE_BUFFER && src_tex->target == PIPE_BUFFER) { + /* can't copy within the same buffer, unfortunately */ + if (svga_have_vgpu10(svga) && src_tex != dst_tex) { + enum pipe_error ret; + struct svga_winsys_surface *src_surf; + struct svga_winsys_surface *dst_surf; + struct svga_buffer *dbuffer = svga_buffer(dst_tex); + + src_surf = svga_buffer_handle(svga, src_tex); + dst_surf = svga_buffer_handle(svga, dst_tex); + + ret = SVGA3D_vgpu10_BufferCopy(svga->swc, src_surf, dst_surf, + src_box->x, dstx, src_box->width); + if (ret != PIPE_OK) { + svga_context_flush(svga, NULL); + ret = SVGA3D_vgpu10_BufferCopy(svga->swc, src_surf, dst_surf, + src_box->x, dstx, src_box->width); + assert(ret == PIPE_OK); + } + + dbuffer->dirty = TRUE; + } + else { + /* use map/memcpy fallback */ + util_resource_copy_region(pipe, dst_tex, dst_level, dstx, + dsty, dstz, src_tex, src_level, src_box); + } + return; + } + + stex = svga_texture(src_tex); + dtex = svga_texture(dst_tex); + + if (src_tex->target == PIPE_TEXTURE_CUBE || + src_tex->target == PIPE_TEXTURE_2D_ARRAY || + src_tex->target == PIPE_TEXTURE_1D_ARRAY) { + src_face_layer = src_box->z; + src_z = 0; + assert(src_box->depth == 1); + } + else { + src_face_layer = 0; + src_z = src_box->z; + } + + if (dst_tex->target == PIPE_TEXTURE_CUBE || + dst_tex->target == PIPE_TEXTURE_2D_ARRAY || + dst_tex->target == PIPE_TEXTURE_1D_ARRAY) { + dst_face_layer = dstz; + dst_z = 0; + assert(src_box->depth == 1); + } + else { + dst_face_layer = 0; + dst_z = dstz; + } + + stex = svga_texture(src_tex); + dtex = svga_texture(dst_tex); + + if (svga_have_vgpu10(svga)) { + /* vgpu10 */ + if (util_format_is_compressed(src_tex->format) == + util_format_is_compressed(dst_tex->format) && + !util_format_is_depth_and_stencil(src_tex->format) && + stex->handle != dtex->handle && + svga_resource_type(src_tex->target) == + svga_resource_type(dst_tex->target)) { + copy_region_vgpu10(svga, + src_tex, + src_box->x, src_box->y, src_z, + src_level, src_face_layer, + dst_tex, + dstx, dsty, dst_z, + dst_level, dst_face_layer, + src_box->width, src_box->height, src_box->depth); + } + else { + util_resource_copy_region(pipe, dst_tex, dst_level, dstx, dsty, dstz, + src_tex, src_level, src_box); + } + } + else { + /* vgpu9 */ + if (src_tex->format == dst_tex->format) { + svga_texture_copy_handle(svga, + stex->handle, + src_box->x, src_box->y, src_z, + src_level, src_face_layer, + dtex->handle, + dstx, dsty, dst_z, + dst_level, dst_face_layer, + src_box->width, src_box->height, + src_box->depth); + } + else { + util_resource_copy_region(pipe, dst_tex, dst_level, dstx, dsty, dstz, + src_tex, src_level, src_box); + } + } + + /* Mark the destination image as being defined */ + svga_define_texture_level(dtex, dst_face_layer, dst_level); +} + + +/** + * The state tracker implements some resource copies with blits (for + * GL_ARB_copy_image). This function checks if we should really do the blit + * with a VGPU10 CopyRegion command or software fallback (for incompatible + * src/dst formats). + */ +static bool +can_blit_via_copy_region_vgpu10(struct svga_context *svga, + const struct pipe_blit_info *blit_info) +{ + struct svga_texture *dtex, *stex; + + if (!svga_have_vgpu10(svga)) + return false; + + stex = svga_texture(blit_info->src.resource); + dtex = svga_texture(blit_info->dst.resource); + + // can't copy within one resource + if (stex->handle == dtex->handle) + return false; + + /* can't copy between different resource types */ + if (svga_resource_type(blit_info->src.resource->target) != + svga_resource_type(blit_info->dst.resource->target)) + return false; + + /* check that the blit src/dst regions are same size, no flipping, etc. */ + if (blit_info->src.box.width != blit_info->dst.box.width || + blit_info->src.box.height != blit_info->dst.box.height) + return false; + + /* depth/stencil copies not supported at this time */ + if (blit_info->mask != PIPE_MASK_RGBA) + return false; + + if (blit_info->alpha_blend || blit_info->render_condition_enable || + blit_info->scissor_enable) + return false; + + /* check that src/dst surface formats are compatible for + the VGPU device.*/ + return util_is_format_compatible( + util_format_description(blit_info->src.resource->format), + util_format_description(blit_info->dst.resource->format)); +} + + +static void +svga_blit(struct pipe_context *pipe, + const struct pipe_blit_info *blit_info) +{ + struct svga_context *svga = svga_context(pipe); + struct pipe_blit_info blit = *blit_info; + + if (!svga_have_vgpu10(svga) && + blit.src.resource->nr_samples > 1 && + blit.dst.resource->nr_samples <= 1 && + !util_format_is_depth_or_stencil(blit.src.resource->format) && + !util_format_is_pure_integer(blit.src.resource->format)) { + debug_printf("svga: color resolve unimplemented\n"); + return; + } + + if (can_blit_via_copy_region_vgpu10(svga, blit_info)) { + unsigned src_face, src_z, dst_face, dst_z; - SVGA_FIFOCommitAll(svga->swc); + if (blit.src.resource->target == PIPE_TEXTURE_CUBE) { + src_face = blit.src.box.z; + src_z = 0; + assert(blit.src.box.depth == 1); + } + else { + src_face = 0; + src_z = blit.src.box.z; + } - svga_surface(dest)->dirty = TRUE; - svga_propagate_surface(pipe, dest); + if (blit.dst.resource->target == PIPE_TEXTURE_CUBE) { + dst_face = blit.dst.box.z; + dst_z = 0; + assert(blit.src.box.depth == 1); + } + else { + dst_face = 0; + dst_z = blit.dst.box.z; + } + + copy_region_vgpu10(svga, + blit.src.resource, + blit.src.box.x, blit.src.box.y, src_z, + blit.src.level, src_face, + blit.dst.resource, + blit.dst.box.x, blit.dst.box.y, dst_z, + blit.dst.level, dst_face, + blit.src.box.width, blit.src.box.height, + blit.src.box.depth); + return; + } + + if (util_can_blit_via_copy_region(blit_info, TRUE) || + util_can_blit_via_copy_region(blit_info, FALSE)) { + util_resource_copy_region(pipe, blit.dst.resource, + blit.dst.level, + blit.dst.box.x, blit.dst.box.y, + blit.dst.box.z, blit.src.resource, + blit.src.level, &blit.src.box); + return; /* done */ + } + + if ((blit.mask & PIPE_MASK_S) || + !util_blitter_is_blit_supported(svga->blitter, blit_info)) { + debug_printf("svga: blit unsupported %s -> %s\n", + util_format_short_name(blit.src.resource->format), + util_format_short_name(blit.dst.resource->format)); + return; + } + + /** + * When there is blit from srgb to linear format or vice versa, we change + * src.format to srgb or linear, respectively + */ + + if (util_format_is_srgb(blit.dst.format)) { + blit.src.format = util_format_srgb(blit.src.format); + } + else { + blit.src.format = util_format_linear(blit.src.format); + } + + /* XXX turn off occlusion and streamout queries */ + + util_blitter_save_vertex_buffer_slot(svga->blitter, svga->curr.vb); + util_blitter_save_vertex_elements(svga->blitter, (void*)svga->curr.velems); + util_blitter_save_vertex_shader(svga->blitter, svga->curr.vs); + util_blitter_save_geometry_shader(svga->blitter, svga->curr.user_gs); + util_blitter_save_so_targets(svga->blitter, svga->num_so_targets, + (struct pipe_stream_output_target**)svga->so_targets); + util_blitter_save_rasterizer(svga->blitter, (void*)svga->curr.rast); + util_blitter_save_viewport(svga->blitter, &svga->curr.viewport); + util_blitter_save_scissor(svga->blitter, &svga->curr.scissor); + util_blitter_save_fragment_shader(svga->blitter, svga->curr.fs); + util_blitter_save_blend(svga->blitter, (void*)svga->curr.blend); + util_blitter_save_depth_stencil_alpha(svga->blitter, + (void*)svga->curr.depth); + util_blitter_save_stencil_ref(svga->blitter, &svga->curr.stencil_ref); + util_blitter_save_sample_mask(svga->blitter, svga->curr.sample_mask); + util_blitter_save_framebuffer(svga->blitter, &svga->curr.framebuffer); + util_blitter_save_fragment_sampler_states(svga->blitter, + svga->curr.num_samplers[PIPE_SHADER_FRAGMENT], + (void**)svga->curr.sampler[PIPE_SHADER_FRAGMENT]); + util_blitter_save_fragment_sampler_views(svga->blitter, + svga->curr.num_sampler_views[PIPE_SHADER_FRAGMENT], + svga->curr.sampler_views[PIPE_SHADER_FRAGMENT]); + /*util_blitter_save_render_condition(svga->blitter, svga->render_cond_query, + svga->render_cond_cond, svga->render_cond_mode);*/ + util_blitter_blit(svga->blitter, &blit); +} + + +static void +svga_flush_resource(struct pipe_context *pipe, + struct pipe_resource *resource) +{ } void svga_init_blit_functions(struct svga_context *svga) { - svga->pipe.surface_copy = svga_surface_copy; + svga->pipe.resource_copy_region = svga_resource_copy_region; + svga->pipe.blit = svga_blit; + svga->pipe.flush_resource = svga_flush_resource; }