ilo: always use the specified image format

Move silent promotion of PIPE_FORMAT_ETC1_RGB8 or combined depth/stencil out
of core.

4 files changed, 115 insertions, 69 deletions

diff --git a/src/gallium/drivers/ilo/core/ilo_image.c b/src/gallium/drivers/ilo/core/ilo_image.c
index 9ec6792146f..7da5debcb37 100644
--- a/src/gallium/drivers/ilo/core/ilo_image.c
+++ b/src/gallium/drivers/ilo/core/ilo_image.c
@@ -671,56 +671,36 @@ img_init_size_and_format(struct ilo_image *img,
                          struct ilo_image_params *params)
 {
    const struct ilo_image_info *info = params->info;
-   enum pipe_format format = info->format;
-   bool require_separate_stencil = false;
 
    img->type = info->type;
-   img->width0 = info->width;
-   img->height0 = info->height;
-   img->depth0 = info->depth;
-   img->array_size = info->array_size;
-   img->level_count = info->level_count;
-   img->sample_count = info->sample_count;
 
    /*
-    * From the Sandy Bridge PRM, volume 2 part 1, page 317:
-    *
-    *     "This field (Separate Stencil Buffer Enable) must be set to the same
-    *      value (enabled or disabled) as Hierarchical Depth Buffer Enable."
+    * From the Ivy Bridge PRM, volume 2 part 1, page 314:
     *
-    * GEN7+ requires separate stencil buffers.
+    *     "The separate stencil buffer is always enabled, thus the field in
+    *      3DSTATE_DEPTH_BUFFER to explicitly enable the separate stencil
+    *      buffer has been removed Surface formats with interleaved depth and
+    *      stencil are no longer supported"
     */
-   if (info->bind_zs) {
-      if (ilo_dev_gen(params->dev) >= ILO_GEN(7))
-         require_separate_stencil = true;
-      else
-         require_separate_stencil = (img->aux.type == ILO_IMAGE_AUX_HIZ);
-   }
+   if (ilo_dev_gen(params->dev) >= ILO_GEN(7) && info->bind_zs) {
+      const struct util_format_description *desc =
+         util_format_description(info->format);
 
-   switch (format) {
-   case PIPE_FORMAT_ETC1_RGB8:
-      format = PIPE_FORMAT_R8G8B8X8_UNORM;
-      break;
-   case PIPE_FORMAT_Z24_UNORM_S8_UINT:
-      if (require_separate_stencil) {
-         format = PIPE_FORMAT_Z24X8_UNORM;
-         img->separate_stencil = true;
-      }
-      break;
-   case PIPE_FORMAT_Z32_FLOAT_S8X24_UINT:
-      if (require_separate_stencil) {
-         format = PIPE_FORMAT_Z32_FLOAT;
-         img->separate_stencil = true;
-      }
-      break;
-   default:
-      break;
+      assert(info->format == PIPE_FORMAT_S8_UINT ||
+             !util_format_has_stencil(desc));
    }
 
-   img->format = format;
-   img->block_width = util_format_get_blockwidth(format);
-   img->block_height = util_format_get_blockheight(format);
-   img->block_size = util_format_get_blocksize(format);
+   img->format = info->format;
+   img->block_width = util_format_get_blockwidth(info->format);
+   img->block_height = util_format_get_blockheight(info->format);
+   img->block_size = util_format_get_blocksize(info->format);
+
+   img->width0 = info->width;
+   img->height0 = info->height;
+   img->depth0 = info->depth;
+   img->array_size = info->array_size;
+   img->level_count = info->level_count;
+   img->sample_count = info->sample_count;
 
    params->valid_tilings = img_get_valid_tilings(img, params);
    params->compressed = util_format_is_compressed(img->format);
@@ -805,19 +785,7 @@ img_want_hiz(const struct ilo_image *img,
    if (!info->bind_zs)
       return false;
 
-   if (!util_format_has_depth(desc))
-      return false;
-
-   /*
-    * As can be seen in img_calculate_hiz_size(), HiZ may not be enabled
-    * for every level.  This is generally fine except on GEN6, where HiZ and
-    * separate stencil are enabled and disabled at the same time.  When the
-    * format is PIPE_FORMAT_Z32_FLOAT_S8X24_UINT, enabling and disabling HiZ
-    * can result in incompatible formats.
-    */
-   if (ilo_dev_gen(params->dev) == ILO_GEN(6) &&
-       info->format == PIPE_FORMAT_Z32_FLOAT_S8X24_UINT &&
-       info->level_count > 1)
+   if (!util_format_has_depth(desc) || util_format_has_stencil(desc))
       return false;
 
    return true;
@@ -1303,8 +1271,8 @@ img_init(struct ilo_image *img,
 {
    /* there are hard dependencies between every function here */
 
-   img_init_aux(img, params);
    img_init_size_and_format(img, params);
+   img_init_aux(img, params);
    img_init_walk(img, params);
    img_init_tiling(img, params);
    img_init_alignments(img, params);
diff --git a/src/gallium/drivers/ilo/core/ilo_image.h b/src/gallium/drivers/ilo/core/ilo_image.h
index 1c4f86c78da..8a2e1438158 100644
--- a/src/gallium/drivers/ilo/core/ilo_image.h
+++ b/src/gallium/drivers/ilo/core/ilo_image.h
@@ -119,6 +119,8 @@ struct ilo_image_lod {
 struct ilo_image {
    enum gen_surface_type type;
 
+   enum pipe_format format;
+
    /* size, format, etc for programming hardware states */
    unsigned width0;
    unsigned height0;
@@ -126,8 +128,6 @@ struct ilo_image {
    unsigned array_size;
    unsigned level_count;
    unsigned sample_count;
-   enum pipe_format format;
-   bool separate_stencil;
 
    /*
     * width, height, and size of pixel blocks for conversion between pixel
diff --git a/src/gallium/drivers/ilo/ilo_resource.c b/src/gallium/drivers/ilo/ilo_resource.c
index 9ef53213b17..11833e0c599 100644
--- a/src/gallium/drivers/ilo/ilo_resource.c
+++ b/src/gallium/drivers/ilo/ilo_resource.c
@@ -109,6 +109,45 @@ get_surface_type(enum pipe_texture_target target)
    }
 }
 
+static enum pipe_format
+resource_get_image_format(const struct pipe_resource *templ,
+                          const struct ilo_dev *dev,
+                          bool *separate_stencil_ret)
+{
+   enum pipe_format format = templ->format;
+   bool separate_stencil;
+
+   /* silently promote ETC1 */
+   if (templ->format == PIPE_FORMAT_ETC1_RGB8)
+      format = PIPE_FORMAT_R8G8B8X8_UNORM;
+
+   /* separate stencil buffers */
+   separate_stencil = false;
+   if ((templ->bind & PIPE_BIND_DEPTH_STENCIL) &&
+       util_format_is_depth_and_stencil(templ->format)) {
+      switch (templ->format) {
+      case PIPE_FORMAT_Z32_FLOAT_S8X24_UINT:
+         /* Gen6 requires HiZ to be available for all levels */
+         if (ilo_dev_gen(dev) >= ILO_GEN(7) || templ->last_level == 0) {
+            format = PIPE_FORMAT_Z32_FLOAT;
+            separate_stencil = true;
+         }
+         break;
+      case PIPE_FORMAT_Z24_UNORM_S8_UINT:
+         format = PIPE_FORMAT_Z24X8_UNORM;
+         separate_stencil = true;
+         break;
+      default:
+         break;
+      }
+   }
+
+   if (separate_stencil_ret)
+      *separate_stencil_ret = separate_stencil;
+
+   return format;
+}
+
 static void
 resource_get_image_info(const struct pipe_resource *templ,
                         const struct ilo_dev *dev,
@@ -340,10 +379,6 @@ tex_alloc_bos(struct ilo_texture *tex)
    if (!tex->imported && !tex_create_bo(tex))
       return false;
 
-   /* allocate separate stencil resource */
-   if (tex->image.separate_stencil && !tex_create_separate_stencil(tex))
-      return false;
-
    switch (tex->image.aux.type) {
    case ILO_IMAGE_AUX_HIZ:
       if (!tex_create_hiz(tex))
@@ -396,15 +431,19 @@ tex_import_handle(struct ilo_texture *tex,
 
 static bool
 tex_init_image(struct ilo_texture *tex,
-               const struct winsys_handle *handle)
+               const struct winsys_handle *handle,
+               bool *separate_stencil)
 {
    struct ilo_screen *is = ilo_screen(tex->base.screen);
    const struct pipe_resource *templ = &tex->base;
    struct ilo_image *img = &tex->image;
    struct intel_bo *imported_bo = NULL;;
+   enum pipe_format image_format;
    struct ilo_image_info info;
 
-   resource_get_image_info(templ, &is->dev, templ->format, &info);
+   image_format = resource_get_image_format(templ,
+         &is->dev, separate_stencil);
+   resource_get_image_info(templ, &is->dev, image_format, &info);
 
    if (handle) {
       imported_bo = tex_import_handle(tex, handle, &info);
@@ -417,6 +456,31 @@ tex_init_image(struct ilo_texture *tex,
       return false;
    }
 
+   /*
+    * HiZ requires 8x4 alignment and some levels might need HiZ disabled.  It
+    * is generally fine except on Gen6, where HiZ and separate stencil must be
+    * enabled together.  For PIPE_FORMAT_Z24X8_UNORM with separate stencil, we
+    * can live with stencil values being interleaved for levels where HiZ is
+    * disabled.  But it is not the case for PIPE_FORMAT_Z32_FLOAT with
+    * separate stencil.  If HiZ was disabled for a level, we had to change the
+    * format to PIPE_FORMAT_Z32_FLOAT_S8X24_UINT for the level and that format
+    * had a different bpp.  In other words, HiZ has to be available for all
+    * levels.
+    */
+   if (ilo_dev_gen(&is->dev) == ILO_GEN(6) &&
+       templ->format == PIPE_FORMAT_Z32_FLOAT_S8X24_UINT &&
+       image_format == PIPE_FORMAT_Z32_FLOAT &&
+       img->aux.enables != (1 << templ->last_level)) {
+      image_format = templ->format;
+      info.format = image_format;
+
+      memset(img, 0, sizeof(*img));
+      if (!ilo_image_init(img, &is->dev, &info)) {
+         intel_bo_unref(imported_bo);
+         return false;
+      }
+   }
+
    if (img->bo_height > ilo_max_resource_size / img->bo_stride ||
        !ilo_vma_init(&tex->vma, &is->dev, img->bo_stride * img->bo_height,
           4096)) {
@@ -431,8 +495,8 @@ tex_init_image(struct ilo_texture *tex,
 
    if (templ->flags & PIPE_RESOURCE_FLAG_MAP_PERSISTENT) {
       /* require on-the-fly tiling/untiling or format conversion */
-      if (img->tiling == GEN8_TILING_W || img->separate_stencil ||
-          img->format != templ->format)
+      if (img->tiling == GEN8_TILING_W || *separate_stencil ||
+          image_format != templ->format)
          return false;
    }
 
@@ -448,6 +512,7 @@ tex_create(struct pipe_screen *screen,
            const struct winsys_handle *handle)
 {
    struct ilo_texture *tex;
+   bool separate_stencil;
 
    tex = CALLOC_STRUCT(ilo_texture);
    if (!tex)
@@ -457,12 +522,13 @@ tex_create(struct pipe_screen *screen,
    tex->base.screen = screen;
    pipe_reference_init(&tex->base.reference, 1);
 
-   if (!tex_init_image(tex, handle)) {
+   if (!tex_init_image(tex, handle, &separate_stencil)) {
       FREE(tex);
       return NULL;
    }
 
-   if (!tex_alloc_bos(tex)) {
+   if (!tex_alloc_bos(tex) ||
+       (separate_stencil && !tex_create_separate_stencil(tex))) {
       tex_destroy(tex);
       return NULL;
    }
@@ -572,17 +638,29 @@ ilo_can_create_resource(struct pipe_screen *screen,
                         const struct pipe_resource *templ)
 {
    struct ilo_screen *is = ilo_screen(screen);
+   enum pipe_format image_format;
    struct ilo_image_info info;
    struct ilo_image img;
 
    if (templ->target == PIPE_BUFFER)
       return (templ->width0 <= ilo_max_resource_size);
 
-   resource_get_image_info(templ, &is->dev, templ->format, &info);
+   image_format = resource_get_image_format(templ, &is->dev, NULL);
+   resource_get_image_info(templ, &is->dev, image_format, &info);
 
    memset(&img, 0, sizeof(img));
    ilo_image_init(&img, &ilo_screen(screen)->dev, &info);
 
+   /* as in tex_init_image() */
+   if (ilo_dev_gen(&is->dev) == ILO_GEN(6) &&
+       templ->format == PIPE_FORMAT_Z32_FLOAT_S8X24_UINT &&
+       image_format == PIPE_FORMAT_Z32_FLOAT &&
+       img.aux.enables != (1 << templ->last_level)) {
+      info.format = templ->format;
+      memset(&img, 0, sizeof(img));
+      ilo_image_init(&img, &ilo_screen(screen)->dev, &info);
+   }
+
    return (img.bo_height <= ilo_max_resource_size / img.bo_stride);
 }
 
diff --git a/src/gallium/drivers/ilo/ilo_state.c b/src/gallium/drivers/ilo/ilo_state.c
index 445df1966f9..20d3c001188 100644
--- a/src/gallium/drivers/ilo/ilo_state.c
+++ b/src/gallium/drivers/ilo/ilo_state.c
@@ -2048,7 +2048,7 @@ ilo_create_sampler_view(struct pipe_context *pipe,
       info.type = tex->image.type;
 
       if (templ->format == PIPE_FORMAT_Z32_FLOAT_S8X24_UINT &&
-          tex->image.separate_stencil) {
+          tex->separate_s8) {
          info.format = ilo_format_translate_texture(dev,
                PIPE_FORMAT_Z32_FLOAT);
       } else {