Move all format selection to translate_tex_format and cleanup parameter

usage. Add missing MESA_FORMAT to mesa choose tex format.

7 files changed, 89 insertions, 115 deletions

diff --git a/src/mesa/drivers/dri/i965/brw_blorp.cpp b/src/mesa/drivers/dri/i965/brw_blorp.cpp
index 1abeddc361..107a782080 100644
--- a/src/mesa/drivers/dri/i965/brw_blorp.cpp
+++ b/src/mesa/drivers/dri/i965/brw_blorp.cpp
@@ -86,10 +86,10 @@ brw_blorp_surface_info::set(struct brw_context *brw,
    this->array_spacing_lod0 = mt->array_spacing_lod0;
    this->msaa_layout = mt->msaa_layout;
 
-   const GLenum sRGB_sel = !sRGB_en ? GL_SKIP_DECODE_EXT : 0;
-   BRW_SURFACE render_surfaceformat;
-   BRW_SURFACE sample_surfaceformat;
-   translate_tex_format(brw, mt->format, sRGB_sel, &this->process_format_flags, &render_surfaceformat, &sample_surfaceformat);
+   const GLenum sRGB_sel = sRGB_en ? GL_SKIP_DECODE_EXT : 0;
+   const struct format_translator *format_info =
+         translate_tex_format(brw, mt->format, sRGB_sel);
+   this->process_format_flags = format_info->process_flags;
 
    if (is_render_target || depth_format & this->process_format_flags) {
       /* The miptree is a W-tiled stencil buffer.  Surface states can't be set
@@ -99,10 +99,10 @@ brw_blorp_surface_info::set(struct brw_context *brw,
       this->map_stencil_as_y_tiled = mt->format == MESA_FORMAT_S8;
 
       /* set up for a render target */
-      this->brw_surfaceformat = render_surfaceformat;
+      this->brw_surfaceformat = format_info->brw_render_shadow_format;
    } else {
       /* set up for a sample target */
-      this->brw_surfaceformat = sample_surfaceformat;
+      this->brw_surfaceformat = format_info->brw_sample_shadow_format;
    }
 
 #if 0
diff --git a/src/mesa/drivers/dri/i965/brw_blorp_blit.cpp b/src/mesa/drivers/dri/i965/brw_blorp_blit.cpp
index 0cc9e4130f..eeff8e8969 100644
--- a/src/mesa/drivers/dri/i965/brw_blorp_blit.cpp
+++ b/src/mesa/drivers/dri/i965/brw_blorp_blit.cpp
@@ -2432,29 +2432,27 @@ brw_blorp_blit_params::test_formats(struct brw_context *brw,
    }
 
    /* blorp lies about some formats to placate the GPU. */
-   blorp_process_format src_format_process_flags;
-   BRW_SURFACE sample_format;
-   const GLenum sRGB_en = !brw->ctx.Color.sRGBEnabled ? GL_SKIP_DECODE_EXT : 0;
-   translate_tex_format(brw, src_format, sRGB_en, &src_format_process_flags, 0, &sample_format);
-   if (src_format_process_flags & sample_not_supported_mask) {
+   const GLenum sRGB_en = brw->ctx.Color.sRGBEnabled ? GL_SKIP_DECODE_EXT : 0;
+   const struct format_translator *src_format_info =
+         translate_tex_format(brw, src_format, sRGB_en);
+   if (src_format_info->process_flags & sample_not_supported_mask) {
       _mesa_debug(ctx, "%s: compatible brw_surface format not found for source "
                  "texture mip tree. Source: %s\n",
                  __FUNCTION__, _mesa_get_format_name(src_format));
       return false;
    }
-   if (!brw_format_for_sampling(brw, sample_format)) {
+   if (!brw_format_for_sampling(brw, src_format_info->brw_sample_shadow_format)) {
       _mesa_debug(ctx, "%s: The translated source miptree format is not supported for sampling: %s: 0x%x.\n",
-                 __FUNCTION__, _mesa_get_format_name(src_format), sample_format);
+                 __FUNCTION__, _mesa_get_format_name(src_format), src_format_info->brw_sample_shadow_format);
       return false;
    }
 
-   blorp_process_format dst_format_process_flags;
-   BRW_SURFACE render_format;
-   translate_tex_format(brw, dst_format, sRGB_en, &dst_format_process_flags, &render_format, 0);
-   if (!brw_format_for_render(brw, render_format) ||
-       (dst_format_process_flags & render_not_supported_mask)) {
+   const struct format_translator *dst_format_info =
+         translate_tex_format(brw, dst_format, sRGB_en);
+   if (!brw_format_for_render(brw, dst_format_info->brw_render_shadow_format) ||
+       (dst_format_info->process_flags & render_not_supported_mask)) {
       _mesa_debug(ctx, "%s: The translated target miptree format is not supported as a render target: %s: 0x%x.\n",
-                 __FUNCTION__, _mesa_get_format_name(dst_format), render_format);
+                 __FUNCTION__, _mesa_get_format_name(dst_format), dst_format_info->brw_render_shadow_format);
       return false;
    }
 
@@ -2470,8 +2468,8 @@ brw_blorp_blit_params::test_formats(struct brw_context *brw,
       return false;
    }
 
-   const bool raw_dst = raw_sample & dst_format_process_flags;
-   const bool raw_src = raw_sample & src_format_process_flags;
+   const bool raw_dst = raw_sample & dst_format_info->process_flags;
+   const bool raw_src = raw_sample & src_format_info->process_flags;
    if (raw_dst || raw_src && dst_format != src_format) {
       _mesa_debug(ctx, "%s: Blorp doesn't yet convert from or to raw formats"
                   " dst: %s: src: %s.\n",
@@ -2480,8 +2478,8 @@ brw_blorp_blit_params::test_formats(struct brw_context *brw,
       return false;
    }
 
-   if ((alpha_blend_render & src_format_process_flags) ||
-       (alpha_blend_render & dst_format_process_flags)) {
+   if ((alpha_blend_render & src_format_info->process_flags) ||
+       (alpha_blend_render & dst_format_info->process_flags)) {
       gl_format linear_src_format = _mesa_get_srgb_format_linear(src_format);
       gl_format linear_dst_format = _mesa_get_srgb_format_linear(dst_format);
 
@@ -2561,9 +2559,11 @@ brw_blorp_blit_params::brw_blorp_blit_params(struct brw_context *brw,
        _mesa_get_format_color_encoding(dst_mt->format) == GL_SRGB &&
        _mesa_get_srgb_format_linear(src_mt->format) ==
        _mesa_get_srgb_format_linear(dst_mt->format)) {
-      blorp_process_format process_flags;
-      brw_format_for_mesa_format(dst_mt->format, &process_flags,
-                                 &dst.brw_surfaceformat, &src.brw_surfaceformat);
+      const struct format_translator *format_info =
+            brw_format_for_mesa_format(dst_mt->format);
+
+      dst.brw_surfaceformat = format_info->brw_render_shadow_format;
+      src.brw_surfaceformat = format_info->brw_sample_shadow_format;
       _mesa_debug(&brw->ctx, "%s doing blt in sRGB format", __FUNCTION__);
    }
 
diff --git a/src/mesa/drivers/dri/i965/brw_state.h b/src/mesa/drivers/dri/i965/brw_state.h
index c7234360e3..92f1b33bbe 100644
--- a/src/mesa/drivers/dri/i965/brw_state.h
+++ b/src/mesa/drivers/dri/i965/brw_state.h
@@ -186,9 +186,13 @@ void gen4_init_vtable_surface_functions(struct brw_context *brw);
 uint32_t brw_get_surface_tiling_bits(uint32_t tiling);
 uint32_t brw_get_surface_num_multisamples(unsigned num_samples);
 
-void brw_format_for_mesa_format(gl_format mesa_format, blorp_process_format *process_flags,
-                                BRW_SURFACE *render_target,
-                                BRW_SURFACE *sample_format);
+struct format_translator {
+   BRW_SURFACE brw_render_shadow_format;
+   BRW_SURFACE brw_sample_shadow_format;
+   blorp_process_format process_flags;
+};
+
+const struct format_translator *brw_format_for_mesa_format(gl_format mesa_format);
 bool brw_format_for_blend(struct brw_context *brw, const BRW_SURFACE brw_surface_sel);
 bool brw_format_for_filter(struct brw_context *brw, const BRW_SURFACE brw_surface_sel);
 bool brw_format_for_render(struct brw_context *brw, const BRW_SURFACE brw_surface_sel);
@@ -196,12 +200,9 @@ bool brw_format_for_sampling(struct brw_context *brw, const BRW_SURFACE brw_surf
 
 GLuint translate_tex_target(GLenum target);
 
-void translate_tex_format(struct brw_context *brw,
-                          gl_format mesa_format,
-                          GLenum srgb_decode,
-                          blorp_process_format *process_flags,
-                          BRW_SURFACE *render_surface,
-                          BRW_SURFACE *sample_surface);
+const struct format_translator *translate_tex_format(struct brw_context *brw,
+                                                     gl_format mesa_format,
+                                                     GLenum srgb_decode);
 
 int brw_get_texture_swizzle(const struct gl_context *ctx,
                             const struct gl_texture_object *t);
diff --git a/src/mesa/drivers/dri/i965/brw_surface_formats.c b/src/mesa/drivers/dri/i965/brw_surface_formats.c
index 8b17f236ef..e39c86bbf7 100644
--- a/src/mesa/drivers/dri/i965/brw_surface_formats.c
+++ b/src/mesa/drivers/dri/i965/brw_surface_formats.c
@@ -334,15 +334,8 @@ brw_format_for_sampling(struct brw_context *brw, const BRW_SURFACE brw_surface_s
 #undef x
 #undef Y
 
-struct format_translator {
-   BRW_SURFACE brw_render_shadow_format;
-   BRW_SURFACE brw_sample_shadow_format;
-   blorp_process_format process_flags;
-};
-
-void
-brw_format_for_mesa_format(gl_format mesa_format, blorp_process_format *process_flags,
-                           BRW_SURFACE *render_target, BRW_SURFACE *sample_format)
+const struct format_translator *
+brw_format_for_mesa_format(gl_format mesa_format)
 {
    /* This table is ordered according to the enum ordering in formats.h. gl_formats
     * are used to tag both source sampling and destination render targets, but
@@ -934,15 +927,8 @@ brw_format_for_mesa_format(gl_format mesa_format, blorp_process_format *process_
 
   };
    assert(mesa_format < MESA_PRIVATE_FORMAT_COUNT);
-   if (process_flags) {
-      *process_flags = table[mesa_format].process_flags;
-   }
-   if (render_target) {
-      *render_target = table[mesa_format].brw_render_shadow_format;
-   }
-   if (sample_format) {
-      *sample_format = table[mesa_format].brw_sample_shadow_format;
-   }
+
+   return &table[mesa_format];
 }
 
 void
@@ -955,16 +941,15 @@ brw_init_surface_formats(struct brw_context *brw)
    const unsigned sample_not_supported_test =
          sample_not_supported_mask | (_mesa_is_desktop_gl(ctx) ? 0 : desktop_gl_sel);
    for (gl_format format = MESA_FORMAT_NONE + 1; format < MESA_FORMAT_COUNT; format++) {
-      BRW_SURFACE sample_surface, render_surface;
-      blorp_process_format process_flags;
-      brw_format_for_mesa_format(format, &process_flags, &render_surface, &sample_surface);
+      const struct format_translator *format_info =
+            brw_format_for_mesa_format(format);
 
       const bool is_integer = _mesa_is_format_integer_color(format);
-      const bool no_filtering =  is_integer || (depth_format & process_flags);
+      const bool no_filtering =  is_integer || (depth_format & format_info->process_flags);
       ctx->TextureFormatSupported[format] =
-            brw_format_for_sampling(brw, sample_surface) &&
-            (brw_format_for_filter(brw, sample_surface) || no_filtering) &&
-            (0 == (process_flags & sample_not_supported_test));
+            brw_format_for_sampling(brw, format_info->brw_sample_shadow_format) &&
+            (brw_format_for_filter(brw, format_info->brw_sample_shadow_format) || no_filtering) &&
+            (0 == (format_info->process_flags & sample_not_supported_test));
 
          /* Note that GL_EXT_texture_integer says that blending doesn't occur for
        * integer, so we don't need hardware support for blending on it.  Other
@@ -972,10 +957,10 @@ brw_init_surface_formats(struct brw_context *brw)
        * even though we don't support it for some formats.
        */
       brw->format_supported_as_render_target[format] =
-            brw_format_for_render(brw, render_surface) &&
+            brw_format_for_render(brw, format_info->brw_render_shadow_format) &&
             /* SINTs, UINTs, and YCRCB don't alpha blend. */
-            (brw_format_for_blend(brw, render_surface) || is_integer) &&
-            0 == (process_flags & render_not_supported_mask);
+            (brw_format_for_blend(brw, format_info->brw_render_shadow_format) || is_integer) &&
+            0 == (format_info->process_flags & render_not_supported_mask);
    }
 
    /* On hardware that lacks support for ETC1, we map ETC1 to RGBX
@@ -1032,13 +1017,10 @@ brw_render_target_supported(struct brw_context *brw,
    return brw->format_supported_as_render_target[format];
 }
 
-void
+const struct format_translator *
 translate_tex_format(struct brw_context *brw,
                      gl_format mesa_format,
-                     GLenum srgb_decode,
-                     blorp_process_format *process_flags,
-                     BRW_SURFACE *render_surface,
-                     BRW_SURFACE *sample_surface)
+                     GLenum srgb_decode)
 {
    if (srgb_decode == GL_SKIP_DECODE_EXT)
       mesa_format = _mesa_get_srgb_format_linear(mesa_format);
@@ -1054,17 +1036,7 @@ translate_tex_format(struct brw_context *brw,
          mesa_format = MESA_FORMAT_RGB_DXT1;
       }
 
-   brw_format_for_mesa_format(mesa_format, process_flags,
-                              render_surface, sample_surface);
-
-   if (render_surface) {
-      _mesa_debug(&brw->ctx, "%s: using render format: 0x%x for %s\n",
-                  __FUNCTION__, *render_surface, _mesa_get_format_name(mesa_format));
-   }
-   if (sample_surface) {
-      _mesa_debug(&brw->ctx, "%s: using sample format: 0x%x for %s\n",
-                  __FUNCTION__, *sample_surface, _mesa_get_format_name(mesa_format));
-   }
+   return brw_format_for_mesa_format(mesa_format);
 }
 
 /** Can HiZ be enabled on a depthbuffer of the given format? */
diff --git a/src/mesa/drivers/dri/i965/brw_wm_surface_state.c b/src/mesa/drivers/dri/i965/brw_wm_surface_state.c
index 0f64176d80..cd5b0a8084 100644
--- a/src/mesa/drivers/dri/i965/brw_wm_surface_state.c
+++ b/src/mesa/drivers/dri/i965/brw_wm_surface_state.c
@@ -238,9 +238,8 @@ brw_update_buffer_texture_surface(struct gl_context *ctx,
    uint32_t size = tObj->BufferSize;
    drm_intel_bo *bo = NULL;
    gl_format format = tObj->_BufferObjectFormat;
-   blorp_process_format process_flags;
-   BRW_SURFACE brw_format;
-   brw_format_for_mesa_format(format, &process_flags, 0, &brw_format);
+   const struct format_translator *format_info =
+      brw_format_for_mesa_format(format);
    int texel_size = _mesa_get_format_bytes(format);
 
    if (intel_obj) {
@@ -248,14 +247,14 @@ brw_update_buffer_texture_surface(struct gl_context *ctx,
       bo = intel_bufferobj_buffer(brw, intel_obj, tObj->BufferOffset, size);
    }
 
-   if (brw_format == 0 && format != MESA_FORMAT_RGBA_FLOAT32) {
+   if (BRW_SURFACEFORMAT_NONE == format_info->brw_sample_shadow_format) {
       _mesa_problem(NULL, "bad format %s for texture buffer\n",
 		    _mesa_get_format_name(format));
    }
 
    brw->vtbl.emit_buffer_surface_state(brw, surf_offset, bo,
                                        tObj->BufferOffset,
-                                       brw_format,
+                                       format_info->brw_sample_shadow_format,
                                        size / texel_size,
                                        texel_size,
                                        0, /* mocs */
@@ -286,21 +285,19 @@ brw_update_texture_surface(struct gl_context *ctx,
 
    (void) for_gather;   /* no w/a to apply for this gen */
 
-   blorp_process_format process_flags;
-   BRW_SURFACE brw_surface;
-
-   translate_tex_format(brw,
-                        mt->format,
-                        sampler->sRGBDecode,
-                        &process_flags, 0, &brw_surface);
+   const struct format_translator *format_info =
+         translate_tex_format(brw,
+                              mt->format,
+                              sampler->sRGBDecode);
 
    _mesa_debug(&brw->ctx, "%s: using render format: 0x%x for %s\n",
-               __FUNCTION__, brw_surface, _mesa_get_format_name(mt->format));
+               __FUNCTION__, format_info->brw_sample_shadow_format,
+               _mesa_get_format_name(mt->format));
 
    surf[0] = (translate_tex_target(tObj->Target) << BRW_SURFACE_TYPE_SHIFT |
               BRW_SURFACE_MIPMAPLAYOUT_BELOW << BRW_SURFACE_MIPLAYOUT_SHIFT |
               BRW_SURFACE_CUBEFACE_ENABLES |
-              (brw_surface << BRW_SURFACE_FORMAT_SHIFT));
+              (format_info->brw_sample_shadow_format << BRW_SURFACE_FORMAT_SHIFT));
 
    surf[1] = intelObj->mt->region->bo->offset + intelObj->mt->offset; /* reloc */
 
@@ -606,7 +603,6 @@ brw_update_renderbuffer_surface(struct brw_context *brw,
    uint32_t tile_x, tile_y;
 
    /* _NEW_BUFFERS */
-   gl_format rb_format = _mesa_get_render_format(ctx, intel_rb_format(irb));
    uint32_t surf_index =
       brw->wm.prog_data->binding_table.render_target_start + unit;
 
@@ -634,17 +630,17 @@ brw_update_renderbuffer_surface(struct brw_context *brw,
    surf = brw_state_batch(brw, AUB_TRACE_SURFACE_STATE, 6 * 4, 32,
                           &brw->wm.base.surf_offset[surf_index]);
 
-   blorp_process_format process_format_flags;
-   BRW_SURFACE format;
-   brw_format_for_mesa_format(format, &process_format_flags, &format, 0);
+   const GLenum sRGB_sel = ctx->Color.sRGBEnabled ? GL_SKIP_DECODE_EXT : 0;
+   const struct format_translator *format_info =
+         translate_tex_format(brw, intel_rb_format(irb), sRGB_sel);
 
-   if (unlikely(!brw_format_for_render(brw, rb_format))) {
+   if (unlikely(!brw_format_for_render(brw, format_info->brw_render_shadow_format))) {
       _mesa_problem(ctx, "%s: renderbuffer format %s unsupported\n",
-                    __FUNCTION__, _mesa_get_format_name(rb_format));
+                    __FUNCTION__, _mesa_get_format_name(format_info->brw_render_shadow_format));
    }
 
    surf[0] = (BRW_SURFACE_2D << BRW_SURFACE_TYPE_SHIFT |
-	      format << BRW_SURFACE_FORMAT_SHIFT);
+         format_info->brw_render_shadow_format << BRW_SURFACE_FORMAT_SHIFT);
 
    /* reloc */
    surf[1] = (intel_renderbuffer_get_tile_offsets(irb, &tile_x, &tile_y) +
diff --git a/src/mesa/drivers/dri/i965/gen7_wm_surface_state.c b/src/mesa/drivers/dri/i965/gen7_wm_surface_state.c
index eef243dd8a..46adc9ad0b 100644
--- a/src/mesa/drivers/dri/i965/gen7_wm_surface_state.c
+++ b/src/mesa/drivers/dri/i965/gen7_wm_surface_state.c
@@ -289,20 +289,20 @@ gen7_update_texture_surface(struct gl_context *ctx,
                                     8 * 4, 32, surf_offset);
    memset(surf, 0, 8 * 4);
 
-   blorp_process_format process_flags;
-   BRW_SURFACE tex_format;
-
-   translate_tex_format(brw,
-                        mt->format,
-                        sampler->sRGBDecode,
-                        &process_flags, 0, &tex_format);
-
-   if (for_gather && tex_format == BRW_SURFACEFORMAT_R32G32_FLOAT) {
-      tex_format = BRW_SURFACEFORMAT_R32G32_FLOAT_LD;
+   const struct format_translator *format_info =
+         translate_tex_format(brw,
+                              mt->format,
+                              sampler->sRGBDecode);
+
+   BRW_SURFACE sample_surface_format;
+   if (for_gather && format_info->brw_sample_shadow_format == BRW_SURFACEFORMAT_R32G32_FLOAT) {
+      sample_surface_format = BRW_SURFACEFORMAT_R32G32_FLOAT_LD;
+   } else {
+      sample_surface_format = format_info->brw_sample_shadow_format;
    }
 
    surf[0] = translate_tex_target(tObj->Target) << BRW_SURFACE_TYPE_SHIFT |
-             tex_format << BRW_SURFACE_FORMAT_SHIFT |
+             sample_surface_format << BRW_SURFACE_FORMAT_SHIFT |
              gen7_surface_tiling_mode(mt->region->tiling) |
              BRW_SURFACE_CUBEFACE_ENABLES;
 
@@ -344,7 +344,7 @@ gen7_update_texture_surface(struct gl_context *ctx,
       const int swizzle = unlikely(alpha_depth)
          ? SWIZZLE_XYZW : brw_get_texture_swizzle(ctx, tObj);
 
-      const bool need_scs_green_to_blue = for_gather && tex_format == BRW_SURFACEFORMAT_R32G32_FLOAT_LD;
+      const bool need_scs_green_to_blue = for_gather && sample_surface_format == BRW_SURFACEFORMAT_R32G32_FLOAT_LD;
 
       surf[7] =
          SET_FIELD(brw_swizzle_to_scs(GET_SWZ(swizzle, 0), need_scs_green_to_blue), GEN7_SURFACE_SCS_R) |
@@ -467,8 +467,7 @@ gen7_update_renderbuffer_surface(struct brw_context *brw,
    assert(irb->mt->msaa_layout != INTEL_MSAA_LAYOUT_IMS);
 
    assert(brw_render_target_supported(brw, rb));
-   BRW_SURFACE format;
-   brw_format_for_mesa_format(rb_format, 0, &format, 0);
+   const struct format_translator *format_info = brw_format_for_mesa_format(rb_format);
    if (unlikely(!brw->format_supported_as_render_target[rb_format])) {
       _mesa_problem(ctx, "%s: renderbuffer format %s unsupported\n",
                     __FUNCTION__, _mesa_get_format_name(rb_format));
@@ -496,7 +495,7 @@ gen7_update_renderbuffer_surface(struct brw_context *brw,
    }
 
    surf[0] = surftype << BRW_SURFACE_TYPE_SHIFT |
-             format << BRW_SURFACE_FORMAT_SHIFT |
+             format_info->brw_render_shadow_format << BRW_SURFACE_FORMAT_SHIFT |
              (irb->mt->array_spacing_lod0 ? GEN7_SURFACE_ARYSPC_LOD0
                                           : GEN7_SURFACE_ARYSPC_FULL) |
              gen7_surface_tiling_mode(region->tiling);
diff --git a/src/mesa/main/texformat.c b/src/mesa/main/texformat.c
index 12dd65fee7..7f7189b039 100644
--- a/src/mesa/main/texformat.c
+++ b/src/mesa/main/texformat.c
@@ -1013,6 +1013,12 @@ _mesa_choose_cached_tex_format(struct gl_context *ctx, GLenum format, GLenum typ
       }
       break;
 
+   case GL_RGB9_E5: {
+      if (GL_UNSIGNED_INT_5_9_9_9_REV == type) {
+         return MESA_FORMAT_RGB9_E5_FLOAT;
+      }
+   }
+
    case GL_LUMINANCE:
       switch (type) {
       case GL_BYTE: