From a8e6734a83816df2a39e5c4c49721d762caee86b Mon Sep 17 00:00:00 2001 From: Rob Clark Date: Thu, 11 Aug 2016 11:57:28 -0400 Subject: [PATCH] freedreno: support for using generic clear path Since clears are more or less just normal draws, there isn't that much benefit in having hand-rolled clear path. Add support to use u_blitter instead if gen specific backend doesn't implement ctx->clear(). Signed-off-by: Rob Clark --- src/gallium/drivers/freedreno/freedreno_context.c | 3 + src/gallium/drivers/freedreno/freedreno_context.h | 1 + src/gallium/drivers/freedreno/freedreno_draw.c | 74 ++++++++++++++++++++++ src/gallium/drivers/freedreno/freedreno_resource.c | 20 +++--- src/gallium/drivers/freedreno/freedreno_resource.h | 4 ++ 5 files changed, 92 insertions(+), 10 deletions(-) diff --git a/src/gallium/drivers/freedreno/freedreno_context.c b/src/gallium/drivers/freedreno/freedreno_context.c index 402e88f..ad62fd6 100644 --- a/src/gallium/drivers/freedreno/freedreno_context.c +++ b/src/gallium/drivers/freedreno/freedreno_context.c @@ -115,6 +115,9 @@ fd_context_destroy(struct pipe_context *pctx) if (ctx->blitter) util_blitter_destroy(ctx->blitter); + if (ctx->clear_rs_state) + pctx->delete_rasterizer_state(pctx, ctx->clear_rs_state); + if (ctx->primconvert) util_primconvert_destroy(ctx->primconvert); diff --git a/src/gallium/drivers/freedreno/freedreno_context.h b/src/gallium/drivers/freedreno/freedreno_context.h index ffc4d9e..037c199 100644 --- a/src/gallium/drivers/freedreno/freedreno_context.h +++ b/src/gallium/drivers/freedreno/freedreno_context.h @@ -117,6 +117,7 @@ struct fd_context { struct util_queue flush_queue; struct blitter_context *blitter; + void *clear_rs_state; struct primconvert_context *primconvert; /* slab for pipe_transfer allocations: */ diff --git a/src/gallium/drivers/freedreno/freedreno_draw.c b/src/gallium/drivers/freedreno/freedreno_draw.c index 715ad21..efc1dd2 100644 --- a/src/gallium/drivers/freedreno/freedreno_draw.c +++ b/src/gallium/drivers/freedreno/freedreno_draw.c @@ -203,6 +203,72 @@ fd_draw_vbo(struct pipe_context *pctx, const struct pipe_draw_info *info) fd_batch_check_size(batch); } +/* Generic clear implementation (partially) using u_blitter: */ +static void +fd_blitter_clear(struct pipe_context *pctx, unsigned buffers, + const union pipe_color_union *color, double depth, unsigned stencil) +{ + struct fd_context *ctx = fd_context(pctx); + struct pipe_framebuffer_state *pfb = &ctx->batch->framebuffer; + struct blitter_context *blitter = ctx->blitter; + + fd_blitter_pipe_begin(ctx, false, true, FD_STAGE_CLEAR); + + util_blitter_common_clear_setup(blitter, pfb->width, pfb->height, + buffers, NULL, NULL); + + struct pipe_stencil_ref sr = { + .ref_value = { stencil & 0xff } + }; + pctx->set_stencil_ref(pctx, &sr); + + struct pipe_constant_buffer cb = { + .buffer_size = 16, + .user_buffer = &color->ui, + }; + pctx->set_constant_buffer(pctx, PIPE_SHADER_FRAGMENT, 0, &cb); + + if (!ctx->clear_rs_state) { + const struct pipe_rasterizer_state tmpl = { + .cull_face = PIPE_FACE_NONE, + .half_pixel_center = 1, + .bottom_edge_rule = 1, + .flatshade = 1, + .depth_clip = 1, + }; + ctx->clear_rs_state = pctx->create_rasterizer_state(pctx, &tmpl); + } + pctx->bind_rasterizer_state(pctx, ctx->clear_rs_state); + + struct pipe_viewport_state vp = { + .scale = { 0.5f * pfb->width, -0.5f * pfb->height, depth }, + .translate = { 0.5f * pfb->width, 0.5f * pfb->height, 0.0f }, + }; + pctx->set_viewport_states(pctx, 0, 1, &vp); + + pctx->bind_vertex_elements_state(pctx, ctx->solid_vbuf_state.vtx); + pctx->set_vertex_buffers(pctx, blitter->vb_slot, 1, + &ctx->solid_vbuf_state.vertexbuf.vb[0]); + pctx->set_stream_output_targets(pctx, 0, NULL, NULL); + pctx->bind_vs_state(pctx, ctx->solid_prog.vp); + pctx->bind_fs_state(pctx, ctx->solid_prog.fp); + + struct pipe_draw_info info = { + .mode = PIPE_PRIM_MAX, /* maps to DI_PT_RECTLIST */ + .count = 2, + .instance_count = 1, + }; + ctx->draw_vbo(ctx, &info); + + util_blitter_restore_constant_buffer_state(blitter); + util_blitter_restore_vertex_states(blitter); + util_blitter_restore_fragment_states(blitter); + util_blitter_restore_render_cond(blitter); + util_blitter_unset_running_flag(blitter); + + fd_blitter_pipe_end(ctx); +} + /* TODO figure out how to make better use of existing state mechanism * for clear (and possibly gmem->mem / mem->gmem) so we can (a) keep * track of what state really actually changes, and (b) reduce the code @@ -274,6 +340,14 @@ fd_clear(struct pipe_context *pctx, unsigned buffers, util_format_short_name(pipe_surface_format(pfb->cbufs[0])), util_format_short_name(pipe_surface_format(pfb->zsbuf))); + /* if per-gen backend doesn't implement ctx->clear() generic + * blitter clear: + */ + if (!ctx->clear) { + fd_blitter_clear(pctx, buffers, color, depth, stencil); + return; + } + fd_hw_query_set_stage(batch, batch->draw, FD_STAGE_CLEAR); ctx->clear(ctx, buffers, color, depth, stencil); diff --git a/src/gallium/drivers/freedreno/freedreno_resource.c b/src/gallium/drivers/freedreno/freedreno_resource.c index 9ac9550..2a4fd74 100644 --- a/src/gallium/drivers/freedreno/freedreno_resource.c +++ b/src/gallium/drivers/freedreno/freedreno_resource.c @@ -107,16 +107,13 @@ realloc_bo(struct fd_resource *rsc, uint32_t size) fd_bc_invalidate_resource(rsc, true); } -static void fd_blitter_pipe_begin(struct fd_context *ctx, bool render_cond, bool discard); -static void fd_blitter_pipe_end(struct fd_context *ctx); - static void do_blit(struct fd_context *ctx, const struct pipe_blit_info *blit, bool fallback) { /* TODO size threshold too?? */ if ((blit->src.resource->target != PIPE_BUFFER) && !fallback) { /* do blit on gpu: */ - fd_blitter_pipe_begin(ctx, false, true); + fd_blitter_pipe_begin(ctx, false, true, FD_STAGE_BLIT); util_blitter_blit(ctx->blitter, blit); fd_blitter_pipe_end(ctx); } else { @@ -939,7 +936,7 @@ fd_blitter_pipe_copy_region(struct fd_context *ctx, return false; /* TODO we could discard if dst box covers dst level fully.. */ - fd_blitter_pipe_begin(ctx, false, false); + fd_blitter_pipe_begin(ctx, false, false, FD_STAGE_BLIT); util_blitter_copy_texture(ctx->blitter, dst, dst_level, dstx, dsty, dstz, src, src_level, src_box); @@ -1045,14 +1042,17 @@ fd_blit(struct pipe_context *pctx, const struct pipe_blit_info *blit_info) return; } - fd_blitter_pipe_begin(ctx, info.render_condition_enable, discard); + fd_blitter_pipe_begin(ctx, info.render_condition_enable, discard, FD_STAGE_BLIT); util_blitter_blit(ctx->blitter, &info); fd_blitter_pipe_end(ctx); } -static void -fd_blitter_pipe_begin(struct fd_context *ctx, bool render_cond, bool discard) +void +fd_blitter_pipe_begin(struct fd_context *ctx, bool render_cond, bool discard, + enum fd_render_stage stage) { + util_blitter_save_fragment_constant_buffer_slot(ctx->blitter, + ctx->constbuf[PIPE_SHADER_FRAGMENT].cb); util_blitter_save_vertex_buffer_slot(ctx->blitter, ctx->vtx.vertexbuf.vb); util_blitter_save_vertex_elements(ctx->blitter, ctx->vtx.vtx); util_blitter_save_vertex_shader(ctx->blitter, ctx->prog.vp); @@ -1078,12 +1078,12 @@ fd_blitter_pipe_begin(struct fd_context *ctx, bool render_cond, bool discard) ctx->cond_query, ctx->cond_cond, ctx->cond_mode); if (ctx->batch) - fd_hw_query_set_stage(ctx->batch, ctx->batch->draw, FD_STAGE_BLIT); + fd_hw_query_set_stage(ctx->batch, ctx->batch->draw, stage); ctx->in_blit = discard; } -static void +void fd_blitter_pipe_end(struct fd_context *ctx) { if (ctx->batch) diff --git a/src/gallium/drivers/freedreno/freedreno_resource.h b/src/gallium/drivers/freedreno/freedreno_resource.h index 8caab6b..60ba7e6 100644 --- a/src/gallium/drivers/freedreno/freedreno_resource.h +++ b/src/gallium/drivers/freedreno/freedreno_resource.h @@ -154,6 +154,10 @@ fd_resource_offset(struct fd_resource *rsc, unsigned level, unsigned layer) return offset; } +void fd_blitter_pipe_begin(struct fd_context *ctx, bool render_cond, bool discard, + enum fd_render_stage stage); +void fd_blitter_pipe_end(struct fd_context *ctx); + void fd_resource_screen_init(struct pipe_screen *pscreen); void fd_resource_context_init(struct pipe_context *pctx); -- 2.7.4