[Impeller] migrate blur to calculating coefficients on the cpu (#49512)

issue: flutter/flutter#131580

This factors out the gaussian blur fragment shader to be a more generic kernel fragment shader.  We can't use this for the old gaussian blur because it's kernel is unbounded in one dimension.  I implemented this by passing in the coefficients into the UBO so it can't support that.

Profile after change:
```
    "average_vsync_transitions_missed": 2.0,
    "90th_percentile_vsync_transitions_missed": 2.0,
    "99th_percentile_vsync_transitions_missed": 2.0,
    "average_vsync_frame_lag": 0.0,
    "90th_percentile_vsync_frame_lag": 0.0,
    "99th_percentile_vsync_frame_lag": 0.0,
    "average_layer_cache_count": 0.0,
    "90th_percentile_layer_cache_count": 0.0,
    "99th_percentile_layer_cache_count": 0.0,
    "average_frame_request_pending_latency": 16636.624373956594,
    "90th_percentile_frame_request_pending_latency": 16718.0,
    "99th_percentile_frame_request_pending_latency": 16761.0,
    "worst_layer_cache_count": 0.0,
    "average_layer_cache_memory": 0.0,
    "90th_percentile_layer_cache_memory": 0.0,
    "99th_percentile_layer_cache_memory": 0.0,
    "worst_layer_cache_memory": 0.0,
    "average_picture_cache_count": 0.0,
    "90th_percentile_picture_cache_count": 0.0,
    "99th_percentile_picture_cache_count": 0.0,
    "worst_picture_cache_count": 0.0,
    "average_picture_cache_memory": 0.0,
    "90th_percentile_picture_cache_memory": 0.0,
    "99th_percentile_picture_cache_memory": 0.0,
    "worst_picture_cache_memory": 0.0,
    "total_ui_gc_time": 1.65,
    "30hz_frame_percentage": 0.0,
    "60hz_frame_percentage": 100.0,
    "80hz_frame_percentage": 0.0,
    "90hz_frame_percentage": 0.0,
    "120hz_frame_percentage": 0.0,
    "illegal_refresh_rate_frame_count": 0,
    "average_gpu_frame_time": 21.875,
    "90th_percentile_gpu_frame_time": 31.25,
    "99th_percentile_gpu_frame_time": 31.25,
    "worst_gpu_frame_time": 31.25,
    "average_cpu_usage": 162.86326532653064,
    "90th_percentile_cpu_usage": 167.3,
    "99th_percentile_cpu_usage": 168.500003,
    "average_gpu_usage": 93.26530612244898,
    "90th_percentile_gpu_usage": 94.0,
    "99th_percentile_gpu_usage": 95.0,
    "average_memory_usage": 113.56696428571429,
    "90th_percentile_memory_usage": 145.484375,
    "99th_percentile_memory_usage": 152.75
```

This is a 13% (21.25 / 25 ) drop in `average_gpu_frame_time` from the last profile in #49299.

[C++, Objective-C, Java style guides]: https://github.com/flutter/engine/blob/main/CONTRIBUTING.md#style

Author: gaaclarke

ci/licenses_golden/licenses_flutter

@@ -5231,6 +5231,9 @@ ORIGIN: ../../../flutter/impeller/entity/shaders/gaussian_blur/gaussian_blur.gls
 ORIGIN: ../../../flutter/impeller/entity/shaders/gaussian_blur/gaussian_blur.vert + ../../../flutter/LICENSE
 ORIGIN: ../../../flutter/impeller/entity/shaders/gaussian_blur/gaussian_blur_noalpha_decal.frag + ../../../flutter/LICENSE
 ORIGIN: ../../../flutter/impeller/entity/shaders/gaussian_blur/gaussian_blur_noalpha_nodecal.frag + ../../../flutter/LICENSE
+ORIGIN: ../../../flutter/impeller/entity/shaders/gaussian_blur/kernel.glsl + ../../../flutter/LICENSE
+ORIGIN: ../../../flutter/impeller/entity/shaders/gaussian_blur/kernel_decal.frag + ../../../flutter/LICENSE
+ORIGIN: ../../../flutter/impeller/entity/shaders/gaussian_blur/kernel_nodecal.frag + ../../../flutter/LICENSE
 ORIGIN: ../../../flutter/impeller/entity/shaders/geometry/points.comp + ../../../flutter/LICENSE
 ORIGIN: ../../../flutter/impeller/entity/shaders/geometry/uv.comp + ../../../flutter/LICENSE
 ORIGIN: ../../../flutter/impeller/entity/shaders/glyph_atlas.frag + ../../../flutter/LICENSE
@@ -8041,6 +8044,9 @@ FILE: ../../../flutter/impeller/entity/shaders/gaussian_blur/gaussian_blur.glsl
 FILE: ../../../flutter/impeller/entity/shaders/gaussian_blur/gaussian_blur.vert
 FILE: ../../../flutter/impeller/entity/shaders/gaussian_blur/gaussian_blur_noalpha_decal.frag
 FILE: ../../../flutter/impeller/entity/shaders/gaussian_blur/gaussian_blur_noalpha_nodecal.frag
+FILE: ../../../flutter/impeller/entity/shaders/gaussian_blur/kernel.glsl
+FILE: ../../../flutter/impeller/entity/shaders/gaussian_blur/kernel_decal.frag
+FILE: ../../../flutter/impeller/entity/shaders/gaussian_blur/kernel_nodecal.frag
 FILE: ../../../flutter/impeller/entity/shaders/geometry/points.comp
 FILE: ../../../flutter/impeller/entity/shaders/geometry/uv.comp
 FILE: ../../../flutter/impeller/entity/shaders/glyph_atlas.frag

impeller/entity/BUILD.gn

@@ -28,6 +28,8 @@ impeller_shaders("entity_shaders") {
     "shaders/gaussian_blur/gaussian_blur.vert",
     "shaders/gaussian_blur/gaussian_blur_noalpha_decal.frag",
     "shaders/gaussian_blur/gaussian_blur_noalpha_nodecal.frag",
+    "shaders/gaussian_blur/kernel_decal.frag",
+    "shaders/gaussian_blur/kernel_nodecal.frag",
     "shaders/glyph_atlas.frag",
     "shaders/glyph_atlas_color.frag",
     "shaders/glyph_atlas.vert",
@@ -245,6 +247,7 @@ impeller_component("entity") {
   }
 
   deps = [ "//flutter/fml" ]
+  defines = [ "_USE_MATH_DEFINES" ]
 }
 
 impeller_component("entity_test_helpers") {

impeller/entity/contents/content_context.cc

@@ -336,6 +336,8 @@ ContentContext::ContentContext(
                                                        options_trianglestrip);
   gaussian_blur_noalpha_nodecal_pipelines_.CreateDefault(*context_,
                                                          options_trianglestrip);
+  kernel_decal_pipelines_.CreateDefault(*context_, options_trianglestrip);
+  kernel_nodecal_pipelines_.CreateDefault(*context_, options_trianglestrip);
   border_mask_blur_pipelines_.CreateDefault(*context_, options_trianglestrip);
   morphology_filter_pipelines_.CreateDefault(*context_, options_trianglestrip,
                                              {supports_decal});

impeller/entity/contents/content_context.h

@@ -67,6 +67,8 @@
 #include "impeller/entity/gaussian_blur.vert.h"
 #include "impeller/entity/gaussian_blur_noalpha_decal.frag.h"
 #include "impeller/entity/gaussian_blur_noalpha_nodecal.frag.h"
+#include "impeller/entity/kernel_decal.frag.h"
+#include "impeller/entity/kernel_nodecal.frag.h"
 
 #include "impeller/entity/position_color.vert.h"
 
@@ -137,6 +139,10 @@ using GaussianBlurDecalPipeline =
 using GaussianBlurPipeline =
     RenderPipelineT<GaussianBlurVertexShader,
                     GaussianBlurNoalphaNodecalFragmentShader>;
+using KernelDecalPipeline =
+    RenderPipelineT<GaussianBlurVertexShader, KernelDecalFragmentShader>;
+using KernelPipeline =
+    RenderPipelineT<GaussianBlurVertexShader, KernelNodecalFragmentShader>;
 using BorderMaskBlurPipeline =
     RenderPipelineT<BorderMaskBlurVertexShader, BorderMaskBlurFragmentShader>;
 using MorphologyFilterPipeline =
@@ -447,6 +453,16 @@ class ContentContext {
     return GetPipeline(gaussian_blur_noalpha_nodecal_pipelines_, opts);
   }
 
+  std::shared_ptr<Pipeline<PipelineDescriptor>> GetKernelDecalPipeline(
+      ContentContextOptions opts) const {
+    return GetPipeline(kernel_decal_pipelines_, opts);
+  }
+
+  std::shared_ptr<Pipeline<PipelineDescriptor>> GetKernelPipeline(
+      ContentContextOptions opts) const {
+    return GetPipeline(kernel_nodecal_pipelines_, opts);
+  }
+
   std::shared_ptr<Pipeline<PipelineDescriptor>> GetBorderMaskBlurPipeline(
       ContentContextOptions opts) const {
     return GetPipeline(border_mask_blur_pipelines_, opts);
@@ -813,6 +829,8 @@ class ContentContext {
       gaussian_blur_noalpha_decal_pipelines_;
   mutable Variants<GaussianBlurPipeline>
       gaussian_blur_noalpha_nodecal_pipelines_;
+  mutable Variants<KernelDecalPipeline> kernel_decal_pipelines_;
+  mutable Variants<KernelPipeline> kernel_nodecal_pipelines_;
   mutable Variants<BorderMaskBlurPipeline> border_mask_blur_pipelines_;
   mutable Variants<MorphologyFilterPipeline> morphology_filter_pipelines_;
   mutable Variants<ColorMatrixColorFilterPipeline>

impeller/entity/contents/filters/gaussian_blur_filter_contents.cc

@@ -4,6 +4,8 @@
 
 #include "impeller/entity/contents/filters/gaussian_blur_filter_contents.h"
 
+#include <cmath>
+
 #include "impeller/entity/contents/content_context.h"
 #include "impeller/entity/texture_fill.frag.h"
 #include "impeller/entity/texture_fill.vert.h"
@@ -14,8 +16,8 @@
 
 namespace impeller {
 
-using GaussianBlurVertexShader = GaussianBlurPipeline::VertexShader;
-using GaussianBlurFragmentShader = GaussianBlurPipeline::FragmentShader;
+using GaussianBlurVertexShader = KernelPipeline::VertexShader;
+using GaussianBlurFragmentShader = KernelPipeline::FragmentShader;
 
 namespace {
 
@@ -120,7 +122,7 @@ fml::StatusOr<RenderTarget> MakeBlurSubpass(
     const RenderTarget& input_pass,
     const SamplerDescriptor& sampler_descriptor,
     Entity::TileMode tile_mode,
-    const GaussianBlurFragmentShader::BlurInfo& blur_info,
+    const BlurParameters& blur_info,
     std::optional<RenderTarget> destination_target,
     const Quad& blur_uvs) {
   if (blur_info.blur_sigma < kEhCloseEnough) {
@@ -147,9 +149,9 @@ fml::StatusOr<RenderTarget> MakeBlurSubpass(
         if (tile_mode == Entity::TileMode::kDecal &&
             !renderer.GetDeviceCapabilities()
                  .SupportsDecalSamplerAddressMode()) {
-          cmd.pipeline = renderer.GetGaussianBlurDecalPipeline(options);
+          cmd.pipeline = renderer.GetKernelDecalPipeline(options);
         } else {
-          cmd.pipeline = renderer.GetGaussianBlurPipeline(options);
+          cmd.pipeline = renderer.GetKernelPipeline(options);
         }
 
         BindVertices<GaussianBlurVertexShader>(cmd, host_buffer,
@@ -169,8 +171,8 @@ fml::StatusOr<RenderTarget> MakeBlurSubpass(
                 linear_sampler_descriptor));
         GaussianBlurVertexShader::BindFrameInfo(
             cmd, host_buffer.EmplaceUniform(frame_info));
-        GaussianBlurFragmentShader::BindBlurInfo(
-            cmd, host_buffer.EmplaceUniform(blur_info));
+        GaussianBlurFragmentShader::BindKernelSamples(
+            cmd, host_buffer.EmplaceUniform(GenerateBlurInfo(blur_info)));
         pass.AddCommand(std::move(cmd));
 
         return true;
@@ -343,16 +345,17 @@ std::optional<Entity> GaussianBlurFilterContents::RenderFilter(
     }
   }
 
-  fml::StatusOr<RenderTarget> pass2_out =
-      MakeBlurSubpass(renderer, /*input_pass=*/pass1_out.value(),
-                      input_snapshot->sampler_descriptor, tile_mode_,
-                      GaussianBlurFragmentShader::BlurInfo{
-                          .blur_uv_offset = Point(0.0, pass1_pixel_size.y),
-                          .blur_sigma = scaled_sigma.y * effective_scalar.y,
-                          .blur_radius = blur_radius.y * effective_scalar.y,
-                          .step_size = 1.0,
-                      },
-                      /*destination_target=*/std::nullopt, blur_uvs);
+  fml::StatusOr<RenderTarget> pass2_out = MakeBlurSubpass(
+      renderer, /*input_pass=*/pass1_out.value(),
+      input_snapshot->sampler_descriptor, tile_mode_,
+      BlurParameters{
+          .blur_uv_offset = Point(0.0, pass1_pixel_size.y),
+          .blur_sigma = scaled_sigma.y * effective_scalar.y,
+          .blur_radius =
+              static_cast<int>(std::round(blur_radius.y * effective_scalar.y)),
+          .step_size = 1,
+      },
+      /*destination_target=*/std::nullopt, blur_uvs);
 
   if (!pass2_out.ok()) {
     return std::nullopt;
@@ -364,16 +367,17 @@ std::optional<Entity> GaussianBlurFilterContents::RenderFilter(
                                ? std::optional<RenderTarget>(pass1_out.value())
                                : std::optional<RenderTarget>(std::nullopt);
 
-  fml::StatusOr<RenderTarget> pass3_out =
-      MakeBlurSubpass(renderer, /*input_pass=*/pass2_out.value(),
-                      input_snapshot->sampler_descriptor, tile_mode_,
-                      GaussianBlurFragmentShader::BlurInfo{
-                          .blur_uv_offset = Point(pass1_pixel_size.x, 0.0),
-                          .blur_sigma = scaled_sigma.x * effective_scalar.x,
-                          .blur_radius = blur_radius.x * effective_scalar.x,
-                          .step_size = 1.0,
-                      },
-                      pass3_destination, blur_uvs);
+  fml::StatusOr<RenderTarget> pass3_out = MakeBlurSubpass(
+      renderer, /*input_pass=*/pass2_out.value(),
+      input_snapshot->sampler_descriptor, tile_mode_,
+      BlurParameters{
+          .blur_uv_offset = Point(pass1_pixel_size.x, 0.0),
+          .blur_sigma = scaled_sigma.x * effective_scalar.x,
+          .blur_radius =
+              static_cast<int>(std::round(blur_radius.x * effective_scalar.x)),
+          .step_size = 1,
+      },
+      pass3_destination, blur_uvs);
 
   if (!pass3_out.ok()) {
     return std::nullopt;
@@ -429,4 +433,31 @@ Scalar GaussianBlurFilterContents::ScaleSigma(Scalar sigma) {
   return clamped * scalar;
 }
 
+KernelPipeline::FragmentShader::KernelSamples GenerateBlurInfo(
+    BlurParameters parameters) {
+  KernelPipeline::FragmentShader::KernelSamples result;
+  result.sample_count =
+      ((2 * parameters.blur_radius) / parameters.step_size) + 1;
+  FML_CHECK(result.sample_count < 24);
+
+  Scalar tally = 0.0f;
+  for (int i = 0; i < result.sample_count; ++i) {
+    int x = (i * parameters.step_size) - parameters.blur_radius;
+    result.samples[i] = KernelPipeline::FragmentShader::KernelSample{
+        .uv_offset = parameters.blur_uv_offset * x,
+        .coefficient = expf(-0.5f * (x * x) /
+                            (parameters.blur_sigma * parameters.blur_sigma)) /
+                       (sqrtf(2.0f * M_PI) * parameters.blur_sigma),
+    };
+    tally += result.samples[i].coefficient;
+  }
+
+  // Make sure everything adds up to 1.
+  for (auto& sample : result.samples) {
+    sample.coefficient /= tally;
+  }
+
+  return result;
+}
+
 }  // namespace impeller

impeller/entity/contents/filters/gaussian_blur_filter_contents.h

@@ -6,10 +6,21 @@
 #define FLUTTER_IMPELLER_ENTITY_CONTENTS_FILTERS_GAUSSIAN_BLUR_FILTER_CONTENTS_H_
 
 #include <optional>
+#include "impeller/entity/contents/content_context.h"
 #include "impeller/entity/contents/filters/filter_contents.h"
 
 namespace impeller {
 
+struct BlurParameters {
+  Point blur_uv_offset;
+  Scalar blur_sigma;
+  int blur_radius;
+  int step_size;
+};
+
+KernelPipeline::FragmentShader::KernelSamples GenerateBlurInfo(
+    BlurParameters parameters);
+
 /// Performs a bidirectional Gaussian blur.
 ///
 /// This is accomplished by rendering multiple passes in multiple directions.

impeller/entity/contents/filters/gaussian_blur_filter_contents_unittests.cc

@@ -381,5 +381,30 @@ TEST(GaussianBlurFilterContentsTest, CalculateSigmaForBlurRadius) {
   EXPECT_NEAR(sigma, derived_sigma, 0.01f);
 }
 
+TEST(GaussianBlurFilterContentsTest, Coefficients) {
+  BlurParameters parameters = {.blur_uv_offset = Point(1, 0),
+                               .blur_sigma = 1,
+                               .blur_radius = 5,
+                               .step_size = 1};
+  KernelPipeline::FragmentShader::KernelSamples samples =
+      GenerateBlurInfo(parameters);
+  EXPECT_EQ(samples.sample_count, 11);
+
+  // Coefficients should add up to 1.
+  Scalar tally = 0;
+  for (int i = 0; i < samples.sample_count; ++i) {
+    tally += samples.samples[i].coefficient;
+  }
+  EXPECT_FLOAT_EQ(tally, 1.0f);
+
+  // Verify the shape of the curve.
+  for (int i = 0; i < 5; ++i) {
+    EXPECT_FLOAT_EQ(samples.samples[i].coefficient,
+                    samples.samples[10 - i].coefficient);
+    EXPECT_TRUE(samples.samples[i + 1].coefficient >
+                samples.samples[i].coefficient);
+  }
+}
+
 }  // namespace testing
 }  // namespace impeller

impeller/entity/shaders/gaussian_blur/kernel.glsl

@@ -0,0 +1,46 @@
+// Copyright 2013 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include <impeller/constants.glsl>
+#include <impeller/gaussian.glsl>
+#include <impeller/texture.glsl>
+#include <impeller/types.glsl>
+
+uniform f16sampler2D texture_sampler;
+
+struct KernelSample {
+  vec2 uv_offset;
+  float coefficient;
+};
+
+uniform KernelSamples {
+  int sample_count;
+  KernelSample samples[24];
+}
+blur_info;
+
+f16vec4 Sample(f16sampler2D tex, vec2 coords) {
+#if ENABLE_DECAL_SPECIALIZATION
+  return IPHalfSampleDecal(tex, coords);
+#else
+  return texture(tex, coords);
+#endif
+}
+
+in vec2 v_texture_coords;
+
+out f16vec4 frag_color;
+
+void main() {
+  f16vec4 total_color = f16vec4(0.0hf);
+
+  for (int i = 0; i < blur_info.sample_count; ++i) {
+    float16_t coefficient = float16_t(blur_info.samples[i].coefficient);
+    total_color +=
+        coefficient * Sample(texture_sampler,
+                             v_texture_coords + blur_info.samples[i].uv_offset);
+  }
+
+  frag_color = total_color;
+}

impeller/entity/shaders/gaussian_blur/kernel_decal.frag

@@ -0,0 +1,9 @@
+// Copyright 2013 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+precision mediump float;
+
+#define ENABLE_DECAL_SPECIALIZATION 1
+
+#include "kernel.glsl"

impeller/entity/shaders/gaussian_blur/kernel_nodecal.frag

@@ -0,0 +1,9 @@
+// Copyright 2013 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+precision mediump float;
+
+#define ENABLE_DECAL_SPECIALIZATION 0
+
+#include "kernel.glsl"