X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fgallium%2Fdrivers%2Fllvmpipe%2Flp_rast.c;h=40a8591cabe14c8b4738409a070b9d84188fd460;hb=294d8a71efe0d85d7212c9b0f465e8637cc25e77;hp=d743d7689ae473d55f9c85ca0c7407232dee043e;hpb=3469715a8a171512cf9b528702e70393f01c6041;p=mesa.git diff --git a/src/gallium/drivers/llvmpipe/lp_rast.c b/src/gallium/drivers/llvmpipe/lp_rast.c index d743d7689ae..40a8591cabe 100644 --- a/src/gallium/drivers/llvmpipe/lp_rast.c +++ b/src/gallium/drivers/llvmpipe/lp_rast.c @@ -32,6 +32,8 @@ #include "util/u_surface.h" #include "util/u_pack_color.h" +#include "os/os_time.h" + #include "lp_scene_queue.h" #include "lp_debug.h" #include "lp_fence.h" @@ -39,7 +41,6 @@ #include "lp_query.h" #include "lp_rast.h" #include "lp_rast_priv.h" -#include "lp_tile_soa.h" #include "gallivm/lp_bld_debug.h" #include "lp_scene.h" #include "lp_tex_sample.h" @@ -76,12 +77,6 @@ lp_rast_end( struct lp_rasterizer *rast ) lp_scene_end_rasterization( rast->curr_scene ); rast->curr_scene = NULL; - -#ifdef DEBUG - if (0) - debug_printf("Post render scene: tile unswizzle: %u tile swizzle: %u\n", - lp_tile_unswizzle_count, lp_tile_swizzle_count); -#endif } @@ -151,49 +146,35 @@ lp_rast_clear_color(struct lp_rasterizer_task *task, const union lp_rast_cmd_arg arg) { const struct lp_scene *scene = task->scene; - const uint8_t *clear_color = arg.clear_color; + uint8_t clear_color[4]; unsigned i; - LP_DBG(DEBUG_RAST, "%s 0x%x,0x%x,0x%x,0x%x\n", __FUNCTION__, + for (i = 0; i < 4; ++i) { + clear_color[i] = float_to_ubyte(arg.clear_color[i]); + } + + LP_DBG(DEBUG_RAST, "%s 0x%x,0x%x,0x%x,0x%x\n", __FUNCTION__, clear_color[0], clear_color[1], clear_color[2], clear_color[3]); - if (clear_color[0] == clear_color[1] && - clear_color[1] == clear_color[2] && - clear_color[2] == clear_color[3]) { - /* clear to grayscale value {x, x, x, x} */ - for (i = 0; i < scene->fb.nr_cbufs; i++) { - uint8_t *ptr = - lp_rast_get_color_tile_pointer(task, i, LP_TEX_USAGE_WRITE_ALL); - memset(ptr, clear_color[0], TILE_SIZE * TILE_SIZE * 4); - } - } - else { - /* Non-gray color. - * Note: if the swizzled tile layout changes (see TILE_PIXEL) this code - * will need to change. It'll be pretty obvious when clearing no longer - * works. - */ - const unsigned chunk = TILE_SIZE / 4; - for (i = 0; i < scene->fb.nr_cbufs; i++) { - uint8_t *c = - lp_rast_get_color_tile_pointer(task, i, LP_TEX_USAGE_WRITE_ALL); - unsigned j; - - for (j = 0; j < 4 * TILE_SIZE; j++) { - memset(c, clear_color[0], chunk); - c += chunk; - memset(c, clear_color[1], chunk); - c += chunk; - memset(c, clear_color[2], chunk); - c += chunk; - memset(c, clear_color[3], chunk); - c += chunk; - } - } + for (i = 0; i < scene->fb.nr_cbufs; i++) { + const struct lp_scene *scene = task->scene; + union util_color uc; + + util_pack_color(arg.clear_color, + scene->fb.cbufs[i]->format, &uc); + + util_fill_rect(scene->cbufs[i].map, + scene->fb.cbufs[i]->format, + scene->cbufs[i].stride, + task->x, + task->y, + TILE_SIZE, + TILE_SIZE, + &uc); } LP_COUNT(nr_color_tile_clear); @@ -290,40 +271,6 @@ lp_rast_clear_zstencil(struct lp_rasterizer_task *task, -/** - * Convert the color tile from tiled to linear layout. - * This is generally only done when we're flushing the scene just prior to - * SwapBuffers. If we didn't do this here, we'd have to convert the entire - * tiled color buffer to linear layout in the llvmpipe_texture_unmap() - * function. It's better to do it here to take advantage of - * threading/parallelism. - * This is a bin command which is stored in all bins. - */ -static void -lp_rast_store_linear_color( struct lp_rasterizer_task *task ) -{ - const struct lp_scene *scene = task->scene; - unsigned buf; - - for (buf = 0; buf < scene->fb.nr_cbufs; buf++) { - struct pipe_surface *cbuf = scene->fb.cbufs[buf]; - const unsigned layer = cbuf->u.tex.first_layer; - const unsigned level = cbuf->u.tex.level; - struct llvmpipe_resource *lpt = llvmpipe_resource(cbuf->texture); - - if (!task->color_tiles[buf]) - continue; - - llvmpipe_unswizzle_cbuf_tile(lpt, - layer, - level, - task->x, task->y, - task->color_tiles[buf]); - } -} - - - /** * Run the shader on all blocks in a tile. This is used when a tile is * completely contained inside a triangle. @@ -358,13 +305,16 @@ lp_rast_shade_tile(struct lp_rasterizer_task *task, for (y = 0; y < TILE_SIZE; y += 4){ for (x = 0; x < TILE_SIZE; x += 4) { uint8_t *color[PIPE_MAX_COLOR_BUFS]; + unsigned stride[PIPE_MAX_COLOR_BUFS]; uint32_t *depth; unsigned i; /* color buffer */ - for (i = 0; i < scene->fb.nr_cbufs; i++) - color[i] = lp_rast_get_color_block_pointer(task, i, - tile_x + x, tile_y + y); + for (i = 0; i < scene->fb.nr_cbufs; i++){ + stride[i] = scene->cbufs[i].stride; + + color[i] = lp_rast_get_unswizzled_color_block_pointer(task, i, tile_x + x, tile_y + y); + } /* depth buffer */ depth = lp_rast_get_depth_block_pointer(task, tile_x + x, tile_y + y); @@ -380,7 +330,8 @@ lp_rast_shade_tile(struct lp_rasterizer_task *task, color, depth, 0xffff, - &task->vis_counter); + &task->vis_counter, + stride); END_JIT_CALL(); } } @@ -396,9 +347,6 @@ static void lp_rast_shade_tile_opaque(struct lp_rasterizer_task *task, const union lp_rast_cmd_arg arg) { - const struct lp_scene *scene = task->scene; - unsigned i; - LP_DBG(DEBUG_RAST, "%s\n", __FUNCTION__); assert(task->state); @@ -406,11 +354,6 @@ lp_rast_shade_tile_opaque(struct lp_rasterizer_task *task, return; } - /* this will prevent converting the layout from tiled to linear */ - for (i = 0; i < scene->fb.nr_cbufs; i++) { - (void)lp_rast_get_color_tile_pointer(task, i, LP_TEX_USAGE_WRITE_ALL); - } - lp_rast_shade_tile(task, arg); } @@ -431,6 +374,7 @@ lp_rast_shade_quads_mask(struct lp_rasterizer_task *task, struct lp_fragment_shader_variant *variant = state->variant; const struct lp_scene *scene = task->scene; uint8_t *color[PIPE_MAX_COLOR_BUFS]; + unsigned stride[PIPE_MAX_COLOR_BUFS]; void *depth; unsigned i; @@ -447,15 +391,16 @@ lp_rast_shade_quads_mask(struct lp_rasterizer_task *task, /* color buffer */ for (i = 0; i < scene->fb.nr_cbufs; i++) { - color[i] = lp_rast_get_color_block_pointer(task, i, x, y); - assert(lp_check_alignment(color[i], 16)); + stride[i] = scene->cbufs[i].stride; + + color[i] = lp_rast_get_unswizzled_color_block_pointer(task, i, x, y); } /* depth buffer */ depth = lp_rast_get_depth_block_pointer(task, x, y); - assert(lp_check_alignment(state->jit_context.blend_color, 16)); + assert(lp_check_alignment(state->jit_context.u8_blend_color, 16)); /* run shader on 4x4 block */ BEGIN_JIT_CALL(state, task); @@ -468,7 +413,8 @@ lp_rast_shade_quads_mask(struct lp_rasterizer_task *task, color, depth, mask, - &task->vis_counter); + &task->vis_counter, + stride); END_JIT_CALL(); } @@ -485,9 +431,21 @@ lp_rast_begin_query(struct lp_rasterizer_task *task, { struct llvmpipe_query *pq = arg.query_obj; - assert(task->query == NULL); - task->vis_counter = 0; - task->query = pq; + assert(task->query[pq->type] == NULL); + + switch (pq->type) { + case PIPE_QUERY_OCCLUSION_COUNTER: + task->vis_counter = 0; + break; + case PIPE_QUERY_TIME_ELAPSED: + task->query_start = os_time_get_nano(); + break; + default: + assert(0); + break; + } + + task->query[pq->type] = pq; } @@ -500,10 +458,26 @@ static void lp_rast_end_query(struct lp_rasterizer_task *task, const union lp_rast_cmd_arg arg) { - assert(task->query); - if (task->query) { - task->query->count[task->thread_index] += task->vis_counter; - task->query = NULL; + struct llvmpipe_query *pq = arg.query_obj; + assert(task->query[pq->type] == pq || pq->type == PIPE_QUERY_TIMESTAMP); + + switch (pq->type) { + case PIPE_QUERY_OCCLUSION_COUNTER: + pq->count[task->thread_index] += task->vis_counter; + break; + case PIPE_QUERY_TIME_ELAPSED: + pq->count[task->thread_index] = os_time_get_nano() - task->query_start; + break; + case PIPE_QUERY_TIMESTAMP: + pq->count[task->thread_index] = os_time_get_nano(); + break; + default: + assert(0); + break; + } + + if (task->query[pq->type] == pq) { + task->query[pq->type] = NULL; } } @@ -517,90 +491,19 @@ lp_rast_set_state(struct lp_rasterizer_task *task, -/** - * Set top row and left column of the tile's pixels to white. For debugging. - */ -static void -outline_tile(uint8_t *tile) -{ - const uint8_t val = 0xff; - unsigned i; - - for (i = 0; i < TILE_SIZE; i++) { - TILE_PIXEL(tile, i, 0, 0) = val; - TILE_PIXEL(tile, i, 0, 1) = val; - TILE_PIXEL(tile, i, 0, 2) = val; - TILE_PIXEL(tile, i, 0, 3) = val; - - TILE_PIXEL(tile, 0, i, 0) = val; - TILE_PIXEL(tile, 0, i, 1) = val; - TILE_PIXEL(tile, 0, i, 2) = val; - TILE_PIXEL(tile, 0, i, 3) = val; - } -} - - -/** - * Draw grid of gray lines at 16-pixel intervals across the tile to - * show the sub-tile boundaries. For debugging. - */ -static void -outline_subtiles(uint8_t *tile) -{ - const uint8_t val = 0x80; - const unsigned step = 16; - unsigned i, j; - - for (i = 0; i < TILE_SIZE; i += step) { - for (j = 0; j < TILE_SIZE; j++) { - TILE_PIXEL(tile, i, j, 0) = val; - TILE_PIXEL(tile, i, j, 1) = val; - TILE_PIXEL(tile, i, j, 2) = val; - TILE_PIXEL(tile, i, j, 3) = val; - - TILE_PIXEL(tile, j, i, 0) = val; - TILE_PIXEL(tile, j, i, 1) = val; - TILE_PIXEL(tile, j, i, 2) = val; - TILE_PIXEL(tile, j, i, 3) = val; - } - } - - outline_tile(tile); -} - - - /** * Called when we're done writing to a color tile. */ static void lp_rast_tile_end(struct lp_rasterizer_task *task) { -#ifdef DEBUG - if (LP_DEBUG & (DEBUG_SHOW_SUBTILES | DEBUG_SHOW_TILES)) { - const struct lp_scene *scene = task->scene; - unsigned buf; - - for (buf = 0; buf < scene->fb.nr_cbufs; buf++) { - uint8_t *color = lp_rast_get_color_block_pointer(task, buf, - task->x, task->y); + unsigned i; - if (LP_DEBUG & DEBUG_SHOW_SUBTILES) - outline_subtiles(color); - else if (LP_DEBUG & DEBUG_SHOW_TILES) - outline_tile(color); + for (i = 0; i < PIPE_QUERY_TYPES; ++i) { + if (task->query[i]) { + lp_rast_end_query(task, lp_rast_arg_query(task->query[i])); } } -#else - (void) outline_subtiles; -#endif - - lp_rast_store_linear_color(task); - - if (task->query) { - union lp_rast_cmd_arg dummy = {0}; - lp_rast_end_query(task, dummy); - } /* debug */ memset(task->color_tiles, 0, sizeof(task->color_tiles));