llvmpipe: get rid of tiled/linear layout remains

Eliminate the rest of the no longer needed layout logic.
(It is possible some code could be simplified a bit further still.)

Reviewed-by: Jose Fonseca <[email protected]>

1 files changed, 26 insertions, 171 deletions

diff --git a/src/gallium/drivers/llvmpipe/lp_texture.c b/src/gallium/drivers/llvmpipe/lp_texture.c
index d10a4ce106d..0ac3528f7ac 100644
--- a/src/gallium/drivers/llvmpipe/lp_texture.c
+++ b/src/gallium/drivers/llvmpipe/lp_texture.c
@@ -60,32 +60,12 @@ static unsigned id_counter = 0;
 
 
 /**
- * Allocate storage for llvmpipe_texture::layout array.
- * The number of elements is width_in_tiles * height_in_tiles.
- */
-static enum lp_texture_layout *
-alloc_layout_array(unsigned num_slices, unsigned width, unsigned height)
-{
-   const unsigned tx = align(width, TILE_SIZE) / TILE_SIZE;
-   const unsigned ty = align(height, TILE_SIZE) / TILE_SIZE;
-
-   assert(num_slices * tx * ty > 0);
-   assert(LP_TEX_LAYOUT_NONE == 0); /* calloc'ing LP_TEX_LAYOUT_NONE here */
-
-   return (enum lp_texture_layout *)
-      CALLOC(num_slices * tx * ty, sizeof(enum lp_texture_layout));
-}
-
-
-
-/**
  * Conventional allocation path for non-display textures:
  * Just compute row strides here.  Storage is allocated on demand later.
  */
 static boolean
 llvmpipe_texture_layout(struct llvmpipe_screen *screen,
-                        struct llvmpipe_resource *lpr,
-                        boolean allocate)
+                        struct llvmpipe_resource *lpr)
 {
    struct pipe_resource *pt = &lpr->base;
    unsigned level;
@@ -100,7 +80,7 @@ llvmpipe_texture_layout(struct llvmpipe_screen *screen,
 
    for (level = 0; level <= pt->last_level; level++) {
 
-      /* Row stride and image stride (for linear layout) */
+      /* Row stride and image stride */
       {
          unsigned alignment, nblocksx, nblocksy, block_size;
 
@@ -131,14 +111,6 @@ llvmpipe_texture_layout(struct llvmpipe_screen *screen,
          lpr->img_stride[level] = lpr->row_stride[level] * nblocksy;
       }
 
-      /* Size of the image in tiles (for tiled layout) */
-      {
-         const unsigned width_t = align(width, TILE_SIZE) / TILE_SIZE;
-         const unsigned height_t = align(height, TILE_SIZE) / TILE_SIZE;
-         lpr->tiles_per_row[level] = width_t;
-         lpr->tiles_per_image[level] = width_t * height_t;
-      }
-
       /* Number of 3D image slices, cube faces or texture array layers */
       {
          unsigned num_slices;
@@ -154,13 +126,6 @@ llvmpipe_texture_layout(struct llvmpipe_screen *screen,
             num_slices = 1;
 
          lpr->num_slices_faces[level] = num_slices;
-
-         if (allocate) {
-            lpr->layout[level] = alloc_layout_array(num_slices, width, height);
-            if (!lpr->layout[level]) {
-               goto fail;
-            }
-         }
       }
 
       /* if img_stride * num_slices_faces > LP_MAX_TEXTURE_SIZE */
@@ -185,10 +150,6 @@ llvmpipe_texture_layout(struct llvmpipe_screen *screen,
    return TRUE;
 
 fail:
-   for (level = 0; level <= pt->last_level; level++) {
-      FREE(lpr->layout[level]);
-   }
-
    return FALSE;
 }
 
@@ -204,7 +165,7 @@ llvmpipe_can_create_resource(struct pipe_screen *screen,
    struct llvmpipe_resource lpr;
    memset(&lpr, 0, sizeof(lpr));
    lpr.base = *res;
-   return llvmpipe_texture_layout(llvmpipe_screen(screen), &lpr, FALSE);
+   return llvmpipe_texture_layout(llvmpipe_screen(screen), &lpr);
 }
 
 
@@ -219,19 +180,10 @@ llvmpipe_displaytarget_layout(struct llvmpipe_screen *screen,
     */
    const unsigned width = MAX2(1, align(lpr->base.width0, TILE_SIZE));
    const unsigned height = MAX2(1, align(lpr->base.height0, TILE_SIZE));
-   const unsigned width_t = width / TILE_SIZE;
-   const unsigned height_t = height / TILE_SIZE;
 
-   lpr->tiles_per_row[0] = width_t;
-   lpr->tiles_per_image[0] = width_t * height_t;
    lpr->num_slices_faces[0] = 1;
    lpr->img_stride[0] = 0;
 
-   lpr->layout[0] = alloc_layout_array(1, width, height);
-   if (!lpr->layout[0]) {
-      return FALSE;
-   }
-
    lpr->dt = winsys->displaytarget_create(winsys,
                                           lpr->base.bind,
                                           lpr->base.format,
@@ -278,15 +230,12 @@ llvmpipe_resource_create(struct pipe_screen *_screen,
          /* displayable surface */
          if (!llvmpipe_displaytarget_layout(screen, lpr))
             goto fail;
-         assert(lpr->layout[0][0] == LP_TEX_LAYOUT_NONE);
       }
       else {
          /* texture map */
-         if (!llvmpipe_texture_layout(screen, lpr, TRUE))
+         if (!llvmpipe_texture_layout(screen, lpr))
             goto fail;
-         assert(lpr->layout[0][0] == LP_TEX_LAYOUT_NONE);
       }
-      assert(lpr->layout[0]);
    }
    else {
       /* other data (vertex buffer, const buffer, etc) */
@@ -332,24 +281,13 @@ llvmpipe_resource_destroy(struct pipe_screen *pscreen,
       /* display target */
       struct sw_winsys *winsys = screen->winsys;
       winsys->displaytarget_destroy(winsys, lpr->dt);
-
-      FREE(lpr->layout[0]);
    }
    else if (llvmpipe_resource_is_texture(pt)) {
-      /* regular texture */
-      uint level;
-
       /* free linear image data */
       if (lpr->linear_img.data) {
          align_free(lpr->linear_img.data);
          lpr->linear_img.data = NULL;
       }
-
-      /* free layout flag arrays */
-      for (level = 0; level < Elements(lpr->layout); level++) {
-         FREE(lpr->layout[level]);
-         lpr->layout[level] = NULL;
-      }
    }
    else if (!lpr->userBuffer) {
       assert(lpr->data);
@@ -372,8 +310,7 @@ void *
 llvmpipe_resource_map(struct pipe_resource *resource,
                       unsigned level,
                       unsigned layer,
-                      enum lp_texture_usage tex_usage,
-                      enum lp_texture_layout layout)
+                      enum lp_texture_usage tex_usage)
 {
    struct llvmpipe_resource *lpr = llvmpipe_resource(resource);
    uint8_t *map;
@@ -385,9 +322,6 @@ llvmpipe_resource_map(struct pipe_resource *resource,
           tex_usage == LP_TEX_USAGE_READ_WRITE ||
           tex_usage == LP_TEX_USAGE_WRITE_ALL);
 
-   assert(layout == LP_TEX_LAYOUT_NONE ||
-          layout == LP_TEX_LAYOUT_LINEAR);
-
    if (lpr->dt) {
       /* display target */
       struct llvmpipe_screen *screen = llvmpipe_screen(resource->screen);
@@ -412,16 +346,13 @@ llvmpipe_resource_map(struct pipe_resource *resource,
       lpr->linear_img.data = map;
 
       /* make sure tiled data gets converted to linear data */
-      map2 = llvmpipe_get_texture_image(lpr, 0, 0, tex_usage, layout);
-      if (layout == LP_TEX_LAYOUT_LINEAR)
-         assert(map == map2);
-
+      map2 = llvmpipe_get_texture_image(lpr, 0, 0, tex_usage);
       return map2;
    }
    else if (llvmpipe_resource_is_texture(resource)) {
 
       map = llvmpipe_get_texture_image(lpr, layer, level,
-                                       tex_usage, layout);
+                                       tex_usage);
       return map;
    }
    else {
@@ -448,11 +379,6 @@ llvmpipe_resource_unmap(struct pipe_resource *resource,
       assert(level == 0);
       assert(layer == 0);
 
-      /* make sure linear image is up to date */
-      (void) llvmpipe_get_texture_image(lpr, layer, level,
-                                        LP_TEX_USAGE_READ,
-                                        LP_TEX_LAYOUT_LINEAR);
-
       winsys->displaytarget_unmap(winsys, lpr->dt);
    }
 }
@@ -476,7 +402,6 @@ llvmpipe_resource_from_handle(struct pipe_screen *screen,
 {
    struct sw_winsys *winsys = llvmpipe_screen(screen)->winsys;
    struct llvmpipe_resource *lpr;
-   unsigned width, height, width_t, height_t;
 
    /* XXX Seems like from_handled depth textures doesn't work that well */
 
@@ -489,11 +414,6 @@ llvmpipe_resource_from_handle(struct pipe_screen *screen,
    pipe_reference_init(&lpr->base.reference, 1);
    lpr->base.screen = screen;
 
-   width = align(lpr->base.width0, TILE_SIZE);
-   height = align(lpr->base.height0, TILE_SIZE);
-   width_t = width / TILE_SIZE;
-   height_t = height / TILE_SIZE;
-
    /*
     * Looks like unaligned displaytargets work just fine,
     * at least sampler/render ones.
@@ -503,8 +423,6 @@ llvmpipe_resource_from_handle(struct pipe_screen *screen,
    assert(lpr->base.height0 == height);
 #endif
 
-   lpr->tiles_per_row[0] = width_t;
-   lpr->tiles_per_image[0] = width_t * height_t;
    lpr->num_slices_faces[0] = 1;
    lpr->img_stride[0] = 0;
 
@@ -516,13 +434,6 @@ llvmpipe_resource_from_handle(struct pipe_screen *screen,
       goto no_dt;
    }
 
-   lpr->layout[0] = alloc_layout_array(1, lpr->base.width0, lpr->base.height0);
-   if (!lpr->layout[0]) {
-      goto no_layout_0;
-   }
-
-   assert(lpr->layout[0][0] == LP_TEX_LAYOUT_NONE);
-
    lpr->id = id_counter++;
 
 #ifdef DEBUG
@@ -531,8 +442,6 @@ llvmpipe_resource_from_handle(struct pipe_screen *screen,
 
    return &lpr->base;
 
-no_layout_0:
-   winsys->displaytarget_destroy(winsys, lpr->dt);
 no_dt:
    FREE(lpr);
 no_lpr:
@@ -707,7 +616,7 @@ llvmpipe_transfer_map( struct pipe_context *pipe,
    map = llvmpipe_resource_map(resource,
                                level,
                                box->z,
-                               tex_usage, LP_TEX_LAYOUT_LINEAR);
+                               tex_usage);
 
 
    /* May want to do different things here depending on read/write nature
@@ -834,12 +743,8 @@ llvmpipe_user_buffer_create(struct pipe_screen *screen,
  * for just one cube face, one array layer or one 3D texture slice
  */
 static unsigned
-tex_image_face_size(const struct llvmpipe_resource *lpr, unsigned level,
-                    enum lp_texture_layout layout)
+tex_image_face_size(const struct llvmpipe_resource *lpr, unsigned level)
 {
-   assert(layout == LP_TEX_LAYOUT_LINEAR);
-
-   /* we already computed this */
    return lpr->img_stride[level];
 }
 
@@ -849,10 +754,9 @@ tex_image_face_size(const struct llvmpipe_resource *lpr, unsigned level,
  * including all cube faces or 3D image slices
  */
 static unsigned
-tex_image_size(const struct llvmpipe_resource *lpr, unsigned level,
-               enum lp_texture_layout layout)
+tex_image_size(const struct llvmpipe_resource *lpr, unsigned level)
 {
-   const unsigned buf_size = tex_image_face_size(lpr, level, layout);
+   const unsigned buf_size = tex_image_face_size(lpr, level);
    return buf_size * lpr->num_slices_faces[level];
 }
 
@@ -863,57 +767,32 @@ tex_image_size(const struct llvmpipe_resource *lpr, unsigned level,
  */
 ubyte *
 llvmpipe_get_texture_image_address(struct llvmpipe_resource *lpr,
-                                   unsigned face_slice, unsigned level,
-                                   enum lp_texture_layout layout)
+                                   unsigned face_slice, unsigned level)
 {
    struct llvmpipe_texture_image *img;
    unsigned offset;
 
-   assert (layout == LP_TEX_LAYOUT_LINEAR);
-
    img = &lpr->linear_img;
    offset = lpr->linear_mip_offsets[level];
 
    if (face_slice > 0)
-      offset += face_slice * tex_image_face_size(lpr, level, layout);
+      offset += face_slice * tex_image_face_size(lpr, level);
 
    return (ubyte *) img->data + offset;
 }
 
 
 /**
- * Set the layout mode for all tiles in a particular image.
- */
-static INLINE void
-llvmpipe_set_texture_image_layout(struct llvmpipe_resource *lpr,
-                                  unsigned face_slice, unsigned level,
-                                  unsigned width_t, unsigned height_t,
-                                  enum lp_texture_layout layout)
-{
-   const unsigned start = face_slice * lpr->tiles_per_image[level];
-   unsigned i;
-
-   for (i = 0; i < width_t * height_t; i++) {
-      lpr->layout[level][start + i] = layout;
-   }
-}
-
-
-/**
- * Allocate storage for a linear or tile texture image (all cube
- * faces and all 3D slices, all levels).
+ * Allocate storage for a linear image
+ * (all cube faces and all 3D slices, all levels).
  */
 static void
-alloc_image_data(struct llvmpipe_resource *lpr,
-                 enum lp_texture_layout layout)
+alloc_image_data(struct llvmpipe_resource *lpr)
 {
    uint alignment = MAX2(16, util_cpu_caps.cacheline);
    uint level;
    uint offset = 0;
 
-   assert(layout == LP_TEX_LAYOUT_LINEAR);
-
-
    if (lpr->dt) {
       /* we get the linear memory from the winsys, and it has
        * already been zeroed
@@ -934,7 +813,7 @@ alloc_image_data(struct llvmpipe_resource *lpr,
        * offset = lpr->linear_mip_offsets[level] + lpr->img_stride[level] * layer
        */
       for (level = 0; level <= lpr->base.last_level; level++) {
-         uint buffer_size = tex_image_size(lpr, level, LP_TEX_LAYOUT_LINEAR);
+         uint buffer_size = tex_image_size(lpr, level);
          lpr->linear_mip_offsets[level] = offset;
          offset += align(buffer_size, alignment);
       }
@@ -953,36 +832,21 @@ alloc_image_data(struct llvmpipe_resource *lpr,
  *
  * \param face_slice  the cube face or 3D slice of interest
  * \param usage  one of LP_TEX_USAGE_READ/WRITE_ALL/READ_WRITE
- * \param layout  should be LP_TEX_LAYOUT_LINEAR
  */
 void *
 llvmpipe_get_texture_image(struct llvmpipe_resource *lpr,
                            unsigned face_slice, unsigned level,
-                           enum lp_texture_usage usage,
-                           enum lp_texture_layout layout)
+                           enum lp_texture_usage usage)
 {
    struct llvmpipe_texture_image *target_img;
    void *target_data;
-   const unsigned width = u_minify(lpr->base.width0, level);
-   const unsigned height = u_minify(lpr->base.height0, level);
-   const unsigned width_t = align(width, TILE_SIZE) / TILE_SIZE;
-   const unsigned height_t = align(height, TILE_SIZE) / TILE_SIZE;
    unsigned target_offset;
    unsigned *target_off_ptr;
 
-   assert(layout == LP_TEX_LAYOUT_NONE ||
-          layout == LP_TEX_LAYOUT_LINEAR);
-
    assert(usage == LP_TEX_USAGE_READ ||
           usage == LP_TEX_USAGE_READ_WRITE ||
           usage == LP_TEX_USAGE_WRITE_ALL);
 
-   /* check for the special case of layout == LP_TEX_LAYOUT_NONE */
-   if (layout == LP_TEX_LAYOUT_NONE) {
-      /* XXX can still get LAYOUT_NONE ? */
-      layout = LP_TEX_LAYOUT_LINEAR;
-   }
-
    if (lpr->dt) {
       assert(lpr->linear_img.data);
    }
@@ -993,38 +857,32 @@ llvmpipe_get_texture_image(struct llvmpipe_resource *lpr,
 
    if (!target_data) {
       /* allocate memory for the target image now */
-      alloc_image_data(lpr, layout);
+      alloc_image_data(lpr);
       target_data = target_img->data;
    }
 
    target_offset = target_off_ptr[level];
 
    if (face_slice > 0) {
-      target_offset += face_slice * tex_image_face_size(lpr, level, layout);
+      target_offset += face_slice * tex_image_face_size(lpr, level);
    }
 
    if (target_data) {
       target_data = (uint8_t *) target_data + target_offset;
    }
 
-   llvmpipe_set_texture_image_layout(lpr, face_slice, level,
-                                     width_t, height_t, layout);
-
    return target_data;
 }
 
 
 /**
  * Return pointer to start of a texture image (1D, 2D, 3D, CUBE).
- * All cube faces and 3D slices will be converted to the requested
- * layout if needed.
  * This is typically used when we're about to sample from a texture.
  */
 void *
 llvmpipe_get_texture_image_all(struct llvmpipe_resource *lpr,
                                unsigned level,
-                               enum lp_texture_usage usage,
-                               enum lp_texture_layout layout)
+                               enum lp_texture_usage usage)
 {
    const int slices = lpr->num_slices_faces[level];
    int slice;
@@ -1033,7 +891,7 @@ llvmpipe_get_texture_image_all(struct llvmpipe_resource *lpr,
    assert(slices > 0);
 
    for (slice = slices - 1; slice >= 0; slice--) {
-      map = llvmpipe_get_texture_image(lpr, slice, level, usage, layout);
+      map = llvmpipe_get_texture_image(lpr, slice, level, usage);
    }
 
    return map;
@@ -1041,9 +899,7 @@ llvmpipe_get_texture_image_all(struct llvmpipe_resource *lpr,
 
 
 /**
- * Get pointer to a linear image (not the tile!) where the tile at (x,y)
- * is known to be in linear layout.
- * Conversion from tiled to linear will be done if necessary.
+ * Get pointer to a linear image (not the tile!) at tile (x,y).
  * \return pointer to start of image/face (not the tile)
  */
 ubyte *
@@ -1062,13 +918,12 @@ llvmpipe_get_texture_tile_linear(struct llvmpipe_resource *lpr,
    if (!linear_img->data) {
       /* allocate memory for the linear image now */
       /* XXX should probably not do that here? */
-      alloc_image_data(lpr, LP_TEX_LAYOUT_LINEAR);
+      alloc_image_data(lpr);
    }
    assert(linear_img->data);
 
    /* compute address of the slice/face of the image that contains the tile */
-   linear_image = llvmpipe_get_texture_image_address(lpr, face_slice, level,
-                                                     LP_TEX_LAYOUT_LINEAR);
+   linear_image = llvmpipe_get_texture_image_address(lpr, face_slice, level);
 
    return linear_image;
 }
@@ -1086,7 +941,7 @@ llvmpipe_resource_size(const struct pipe_resource *resource)
    if (llvmpipe_resource_is_texture(resource)) {
       for (lvl = 0; lvl <= lpr->base.last_level; lvl++) {
          if (lpr->linear_img.data)
-            size += tex_image_size(lpr, lvl, LP_TEX_LAYOUT_LINEAR);
+            size += tex_image_size(lpr, lvl);
       }
    }
    else {