X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fgallium%2Fdrivers%2Fllvmpipe%2Flp_rast.c;h=40a8591cabe14c8b4738409a070b9d84188fd460;hb=294d8a71efe0d85d7212c9b0f465e8637cc25e77;hp=6a610aaf2980261540107e8259222d56ad51b508;hpb=9f6e8e1d6b8696a3ee96cba01b2466ba7a1a8ef6;p=mesa.git

diff --git a/src/gallium/drivers/llvmpipe/lp_rast.c b/src/gallium/drivers/llvmpipe/lp_rast.c
index 6a610aaf298..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,14 +41,15 @@
 #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"
 
 
 #ifdef DEBUG
 int jit_line = 0;
 const struct lp_rast_state *jit_state = NULL;
+const struct lp_rasterizer_task *jit_task = NULL;
 #endif
 
 
@@ -74,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
 }
 
 
@@ -119,8 +116,8 @@ lp_rast_tile_begin(struct lp_rasterizer_task *task,
           * and update the tile's layout info.
           */
          (void) llvmpipe_get_texture_tile(lpt,
-                                          zsbuf->face + zsbuf->zslice,
-                                          zsbuf->level,
+                                          zsbuf->u.tex.first_layer,
+                                          zsbuf->u.tex.level,
                                           usage,
                                           task->x,
                                           task->y);
@@ -149,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);
@@ -211,8 +194,8 @@ lp_rast_clear_zstencil(struct lp_rasterizer_task *task,
                        const union lp_rast_cmd_arg arg)
 {
    const struct lp_scene *scene = task->scene;
-   unsigned clear_value = arg.clear_zstencil.value;
-   unsigned clear_mask = arg.clear_zstencil.mask;
+   uint32_t clear_value = arg.clear_zstencil.value;
+   uint32_t clear_mask = arg.clear_zstencil.mask;
    const unsigned height = TILE_SIZE / TILE_VECTOR_HEIGHT;
    const unsigned width = TILE_SIZE * TILE_VECTOR_HEIGHT;
    const unsigned block_size = scene->zsbuf.blocksize;
@@ -220,10 +203,11 @@ lp_rast_clear_zstencil(struct lp_rasterizer_task *task,
    uint8_t *dst;
    unsigned i, j;
 
-   LP_DBG(DEBUG_RAST, "%s 0x%x%x\n", __FUNCTION__, clear_value, clear_mask);
+   LP_DBG(DEBUG_RAST, "%s: value=0x%08x, mask=0x%08x\n",
+           __FUNCTION__, clear_value, clear_mask);
 
    /*
-    * Clear the aera of the swizzled depth/depth buffer matching this tile, in
+    * Clear the area of the swizzled depth/depth buffer matching this tile, in
     * stripes of TILE_VECTOR_HEIGHT x TILE_SIZE at a time.
     *
     * The swizzled depth format is such that the depths for
@@ -232,16 +216,31 @@ lp_rast_clear_zstencil(struct lp_rasterizer_task *task,
 
    dst = task->depth_tile;
 
+   clear_value &= clear_mask;
+
    switch (block_size) {
    case 1:
+      assert(clear_mask == 0xff);
       memset(dst, (uint8_t) clear_value, height * width);
       break;
    case 2:
-      for (i = 0; i < height; i++) {
-         uint16_t *row = (uint16_t *)dst;
-         for (j = 0; j < width; j++)
-            *row++ = (uint16_t) clear_value;
-         dst += dst_stride;
+      if (clear_mask == 0xffff) {
+         for (i = 0; i < height; i++) {
+            uint16_t *row = (uint16_t *)dst;
+            for (j = 0; j < width; j++)
+               *row++ = (uint16_t) clear_value;
+            dst += dst_stride;
+         }
+      }
+      else {
+         for (i = 0; i < height; i++) {
+            uint16_t *row = (uint16_t *)dst;
+            for (j = 0; j < width; j++) {
+               uint16_t tmp = ~clear_mask & *row;
+               *row++ = clear_value | tmp;
+            }
+            dst += dst_stride;
+         }
       }
       break;
    case 4:
@@ -258,7 +257,7 @@ lp_rast_clear_zstencil(struct lp_rasterizer_task *task,
             uint32_t *row = (uint32_t *)dst;
             for (j = 0; j < width; j++) {
                uint32_t tmp = ~clear_mask & *row;
-               *row++ = (clear_value & clear_mask) | tmp;
+               *row++ = clear_value | tmp;
             }
             dst += dst_stride;
          }
@@ -272,41 +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 face_slice = cbuf->face + cbuf->zslice;
-      const unsigned level = cbuf->level;
-      struct llvmpipe_resource *lpt = llvmpipe_resource(cbuf->texture);
-
-      if (!task->color_tiles[buf])
-         continue;
-
-      llvmpipe_unswizzle_cbuf_tile(lpt,
-                                   face_slice,
-                                   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.
@@ -318,8 +282,8 @@ lp_rast_shade_tile(struct lp_rasterizer_task *task,
 {
    const struct lp_scene *scene = task->scene;
    const struct lp_rast_shader_inputs *inputs = arg.shade_tile;
-   const struct lp_rast_state *state = inputs->state;
-   struct lp_fragment_shader_variant *variant = state->variant;
+   const struct lp_rast_state *state;
+   struct lp_fragment_shader_variant *variant;
    const unsigned tile_x = task->x, tile_y = task->y;
    unsigned x, y;
 
@@ -330,33 +294,44 @@ lp_rast_shade_tile(struct lp_rasterizer_task *task,
 
    LP_DBG(DEBUG_RAST, "%s\n", __FUNCTION__);
 
+   state = task->state;
+   assert(state);
+   if (!state) {
+      return;
+   }
+   variant = state->variant;
+
    /* render the whole 64x64 tile in 4x4 chunks */
    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);
 
          /* run shader on 4x4 block */
-         BEGIN_JIT_CALL(state);
+         BEGIN_JIT_CALL(state, task);
          variant->jit_function[RAST_WHOLE]( &state->jit_context,
                                             tile_x + x, tile_y + y,
-                                            inputs->facing,
-                                            inputs->a0,
-                                            inputs->dadx,
-                                            inputs->dady,
+                                            inputs->frontfacing,
+                                            GET_A0(inputs),
+                                            GET_DADX(inputs),
+                                            GET_DADY(inputs),
                                             color,
                                             depth,
                                             0xffff,
-                                            &task->vis_counter);
+                                            &task->vis_counter,
+                                            stride);
          END_JIT_CALL();
       }
    }
@@ -372,14 +347,11 @@ 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__);
 
-   /* 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);
+   assert(task->state);
+   if (!task->state) {
+      return;
    }
 
    lp_rast_shade_tile(task, arg);
@@ -398,16 +370,19 @@ lp_rast_shade_quads_mask(struct lp_rasterizer_task *task,
                          unsigned x, unsigned y,
                          unsigned mask)
 {
-   const struct lp_rast_state *state = inputs->state;
+   const struct lp_rast_state *state = task->state;
    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;
 
    assert(state);
 
    /* Sanity checks */
+   assert(x < scene->tiles_x * TILE_SIZE);
+   assert(y < scene->tiles_y * TILE_SIZE);
    assert(x % TILE_VECTOR_WIDTH == 0);
    assert(y % TILE_VECTOR_HEIGHT == 0);
 
@@ -416,28 +391,30 @@ 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);
+   BEGIN_JIT_CALL(state, task);
    variant->jit_function[RAST_EDGE_TEST](&state->jit_context,
                                          x, y,
-                                         inputs->facing,
-                                         inputs->a0,
-                                         inputs->dadx,
-                                         inputs->dady,
+                                         inputs->frontfacing,
+                                         GET_A0(inputs),
+                                         GET_DADX(inputs),
+                                         GET_DADY(inputs),
                                          color,
                                          depth,
                                          mask,
-                                         &task->vis_counter);
+                                         &task->vis_counter,
+                                         stride);
    END_JIT_CALL();
 }
 
@@ -454,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;
 }
 
 
@@ -469,61 +458,35 @@ static void
 lp_rast_end_query(struct lp_rasterizer_task *task,
                   const union lp_rast_cmd_arg arg)
 {
-   task->query->count[task->thread_index] += task->vis_counter;
-   task->query = NULL;
-}
-
-
-
-/**
- * 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;
+   struct llvmpipe_query *pq = arg.query_obj;
+   assert(task->query[pq->type] == pq || pq->type == PIPE_QUERY_TIMESTAMP);
 
-   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;
+   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;
+   }
 
-      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;
+   if (task->query[pq->type] == pq) {
+      task->query[pq->type] = NULL;
    }
 }
 
 
-/**
- * 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)
+void
+lp_rast_set_state(struct lp_rasterizer_task *task,
+                  const union lp_rast_cmd_arg arg)
 {
-   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);
+   task->state = arg.state;
 }
 
 
@@ -534,31 +497,13 @@ outline_subtiles(uint8_t *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));
@@ -579,11 +524,14 @@ static lp_rast_cmd_func dispatch[LP_RAST_OP_MAX] =
    lp_rast_triangle_6,
    lp_rast_triangle_7,
    lp_rast_triangle_8,
+   lp_rast_triangle_3_4,
    lp_rast_triangle_3_16,
+   lp_rast_triangle_4_16,
    lp_rast_shade_tile,
    lp_rast_shade_tile_opaque,
    lp_rast_begin_query,
    lp_rast_end_query,
+   lp_rast_set_state,
 };
 
 
@@ -594,6 +542,9 @@ do_rasterize_bin(struct lp_rasterizer_task *task,
    const struct cmd_block *block;
    unsigned k;
 
+   if (0)
+      lp_debug_bin(bin);
+
    for (block = bin->head; block; block = block->next) {
       for (k = 0; k < block->count; k++) {
          dispatch[block->cmd[k]]( task, block->arg[k] );
@@ -654,28 +605,32 @@ rasterize_scene(struct lp_rasterizer_task *task,
                 struct lp_scene *scene)
 {
    task->scene = scene;
-   /* loop over scene bins, rasterize each */
+
+   if (!task->rast->no_rast) {
+      /* loop over scene bins, rasterize each */
 #if 0
-   {
-      unsigned i, j;
-      for (i = 0; i < scene->tiles_x; i++) {
-         for (j = 0; j < scene->tiles_y; j++) {
-            struct cmd_bin *bin = lp_scene_get_bin(scene, i, j);
-            rasterize_bin(task, bin, i, j);
+      {
+         unsigned i, j;
+         for (i = 0; i < scene->tiles_x; i++) {
+            for (j = 0; j < scene->tiles_y; j++) {
+               struct cmd_bin *bin = lp_scene_get_bin(scene, i, j);
+               rasterize_bin(task, bin, i, j);
+            }
          }
       }
-   }
 #else
-   {
-      struct cmd_bin *bin;
+      {
+         struct cmd_bin *bin;
 
-      assert(scene);
-      while ((bin = lp_scene_bin_iter_next(scene))) {
-         if (!is_empty_bin( bin ))
-            rasterize_bin(task, bin);
+         assert(scene);
+         while ((bin = lp_scene_bin_iter_next(scene))) {
+            if (!is_empty_bin( bin ))
+               rasterize_bin(task, bin);
+         }
       }
-   }
 #endif
+   }
+
 
    if (scene->fence) {
       lp_fence_signal(scene->fence);
@@ -745,7 +700,7 @@ lp_rast_finish( struct lp_rasterizer *rast )
  *   2. do work
  *   3. signal that we're done
  */
-static PIPE_THREAD_ROUTINE( thread_func, init_data )
+static PIPE_THREAD_ROUTINE( thread_function, init_data )
 {
    struct lp_rasterizer_task *task = (struct lp_rasterizer_task *) init_data;
    struct lp_rasterizer *rast = task->rast;
@@ -813,7 +768,7 @@ create_rast_threads(struct lp_rasterizer *rast)
    for (i = 0; i < rast->num_threads; i++) {
       pipe_semaphore_init(&rast->tasks[i].work_ready, 0);
       pipe_semaphore_init(&rast->tasks[i].work_done, 0);
-      rast->threads[i] = pipe_thread_create(thread_func,
+      rast->threads[i] = pipe_thread_create(thread_function,
                                             (void *) &rast->tasks[i]);
    }
 }
@@ -832,10 +787,14 @@ lp_rast_create( unsigned num_threads )
    unsigned i;
 
    rast = CALLOC_STRUCT(lp_rasterizer);
-   if(!rast)
-      return NULL;
+   if (!rast) {
+      goto no_rast;
+   }
 
    rast->full_scenes = lp_scene_queue_create();
+   if (!rast->full_scenes) {
+      goto no_full_scenes;
+   }
 
    for (i = 0; i < Elements(rast->tasks); i++) {
       struct lp_rasterizer_task *task = &rast->tasks[i];
@@ -845,6 +804,8 @@ lp_rast_create( unsigned num_threads )
 
    rast->num_threads = num_threads;
 
+   rast->no_rast = debug_get_bool_option("LP_NO_RAST", FALSE);
+
    create_rast_threads(rast);
 
    /* for synchronizing rasterization threads */
@@ -855,6 +816,11 @@ lp_rast_create( unsigned num_threads )
    memset(lp_dummy_tile, 0, sizeof lp_dummy_tile);
 
    return rast;
+
+no_full_scenes:
+   FREE(rast);
+no_rast:
+   return NULL;
 }