llvmpipe: Eliminate color buffer swizzling.

Now dead code.

Also had to remove the show_tiles/show_subtiles because now the color
buffers are always stored in their native format, so there is no longer
an easy way to paint the tile sizes.

Depth-stencil buffers are still swizzled.

Reviewed-by: Roland Scheidegger <[email protected]>

1 files changed, 16 insertions, 186 deletions

diff --git a/src/gallium/drivers/llvmpipe/lp_rast.c b/src/gallium/drivers/llvmpipe/lp_rast.c
index 3d83077fcbd..5c233c06a15 100644
--- a/src/gallium/drivers/llvmpipe/lp_rast.c
+++ b/src/gallium/drivers/llvmpipe/lp_rast.c
@@ -39,7 +39,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 +75,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
 }
 
 
@@ -154,7 +147,6 @@ lp_rast_clear_color(struct lp_rasterizer_task *task,
    uint8_t clear_color[4];
 
    unsigned i;
-   boolean gray;
 
    for (i = 0; i < 4; ++i) {
       clear_color[i] = float_to_ubyte(arg.clear_color[i]);
@@ -166,57 +158,21 @@ lp_rast_clear_color(struct lp_rasterizer_task *task,
               clear_color[2],
               clear_color[3]);
 
-   gray =
-         clear_color[0] == clear_color[1] &&
-         clear_color[1] == clear_color[2] &&
-         clear_color[2] == clear_color[3];
-
    for (i = 0; i < scene->fb.nr_cbufs; i++) {
-      if (scene->cbufs[i].unswizzled) {
-         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);
-      } else {
-         const unsigned chunk = TILE_SIZE / 4;
-         uint8_t *ptr;
-         unsigned j;
-
-         ptr = lp_rast_get_color_tile_pointer(task, i, LP_TEX_USAGE_WRITE_ALL);
-
-         if (gray) {
-            /* clear to grayscale value {x, x, x, x} */
-
-            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.
-            */
-
-            for (j = 0; j < 4 * TILE_SIZE; j++) {
-               memset(ptr, clear_color[0], chunk);
-               ptr += chunk;
-               memset(ptr, clear_color[1], chunk);
-               ptr += chunk;
-               memset(ptr, clear_color[2], chunk);
-               ptr += chunk;
-               memset(ptr, clear_color[3], chunk);
-               ptr += chunk;
-            }
-         }
-      }
+      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);
@@ -314,40 +270,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 (scene->cbufs[buf].unswizzled || !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.
  * This is a bin command called during bin processing.
@@ -389,11 +311,7 @@ lp_rast_shade_tile(struct lp_rasterizer_task *task,
          for (i = 0; i < scene->fb.nr_cbufs; i++){
             stride[i] = scene->cbufs[i].stride;
 
-            if (scene->cbufs[i].unswizzled) {
-               color[i] = lp_rast_get_unswizzled_color_block_pointer(task, i, tile_x + x, tile_y + y);
-            } else {
-               color[i] = lp_rast_get_color_block_pointer(task, i, tile_x + x, tile_y + y);
-            }
+            color[i] = lp_rast_get_unswizzled_color_block_pointer(task, i, tile_x + x, tile_y + y);
          }
 
          /* depth buffer */
@@ -427,9 +345,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);
@@ -437,13 +352,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++) {
-      if (!scene->cbufs[i].unswizzled) {
-         (void)lp_rast_get_color_tile_pointer(task, i, LP_TEX_USAGE_WRITE_ALL);
-      }
-   }
-
    lp_rast_shade_tile(task, arg);
 }
 
@@ -483,11 +391,7 @@ lp_rast_shade_quads_mask(struct lp_rasterizer_task *task,
    for (i = 0; i < scene->fb.nr_cbufs; i++) {
       stride[i] = scene->cbufs[i].stride;
 
-      if (scene->cbufs[i].unswizzled) {
-         color[i] = lp_rast_get_unswizzled_color_block_pointer(task, i, x, y);
-      } else {
-         color[i] = lp_rast_get_color_block_pointer(task, i, x, y);
-      }
+      color[i] = lp_rast_get_unswizzled_color_block_pointer(task, i, x, y);
    }
 
    /* depth buffer */
@@ -558,85 +462,11 @@ 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);
-
-         if (LP_DEBUG & DEBUG_SHOW_SUBTILES)
-            outline_subtiles(color);
-         else if (LP_DEBUG & DEBUG_SHOW_TILES)
-            outline_tile(color);
-      }
-   }
-#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);