Enable partial repaint for Android/OpenGL

Author: knopp

shell/common/shell_test_platform_view_gl.cc

@@ -63,8 +63,10 @@ bool ShellTestPlatformViewGL::GLContextClearCurrent() {
 }
 
 // |GPUSurfaceGLDelegate|
-bool ShellTestPlatformViewGL::GLContextPresent(fml::TimePoint target_time,
-                                               uint32_t fbo_id) {
+bool ShellTestPlatformViewGL::GLContextPresent(
+    fml::TimePoint target_time,
+    uint32_t fbo_id,
+    const std::optional<SkIRect>& damage) {
   return gl_surface_.Present();
 }
 

shell/common/shell_test_platform_view_gl.h

@@ -58,7 +58,9 @@ class ShellTestPlatformViewGL : public ShellTestPlatformView,
   bool GLContextClearCurrent() override;
 
   // |GPUSurfaceGLDelegate|
-  bool GLContextPresent(fml::TimePoint target_time, uint32_t fbo_id) override;
+  bool GLContextPresent(fml::TimePoint target_time,
+                        uint32_t fbo_id,
+                        const std::optional<SkIRect>& damage) override;
 
   // |GPUSurfaceGLDelegate|
   intptr_t GLContextFBO(GLFrameInfo frame_info) const override;

shell/gpu/gpu_surface_gl.cc

@@ -242,9 +242,7 @@ std::unique_ptr<SurfaceFrame> GPUSurfaceGL::AcquireFrame(const SkISize& size) {
   SurfaceFrame::SubmitCallback submit_callback =
       [weak = weak_factory_.GetWeakPtr()](const SurfaceFrame& surface_frame,
                                           SkCanvas* canvas) {
-        return weak ? weak->PresentSurface(
-                          surface_frame.submit_info().target_time, canvas)
-                    : false;
+        return weak ? weak->PresentSurface(surface_frame, canvas) : false;
       };
 
   framebuffer_info = delegate_->GLContextFramebufferInfo();
@@ -253,18 +251,20 @@ std::unique_ptr<SurfaceFrame> GPUSurfaceGL::AcquireFrame(const SkISize& size) {
                                         std::move(context_switch));
 }
 
-bool GPUSurfaceGL::PresentSurface(fml::TimePoint target_time,
-                                  SkCanvas* canvas) {
+bool GPUSurfaceGL::PresentSurface(const SurfaceFrame& frame, SkCanvas* canvas) {
   if (delegate_ == nullptr || canvas == nullptr || context_ == nullptr) {
     return false;
   }
 
+  delegate_->GLContextSetDamageRegion(frame.submit_info().buffer_damage);
+
   {
     TRACE_EVENT0("flutter", "SkCanvas::Flush");
     onscreen_surface_->getCanvas()->flush();
   }
 
-  if (!delegate_->GLContextPresent(target_time, fbo_id_)) {
+  if (!delegate_->GLContextPresent(frame.submit_info().target_time, fbo_id_,
+                                   frame.submit_info().frame_damage)) {
     return false;
   }
 

shell/gpu/gpu_surface_gl.h

@@ -60,7 +60,7 @@ class GPUSurfaceGL : public Surface {
       const SkISize& untransformed_size,
       const SkMatrix& root_surface_transformation);
 
-  bool PresentSurface(fml::TimePoint target_time, SkCanvas* canvas);
+  bool PresentSurface(const SurfaceFrame& frame, SkCanvas* canvas);
 
   GPUSurfaceGLDelegate* delegate_;
   sk_sp<GrDirectContext> context_;

shell/gpu/gpu_surface_gl_delegate.h

@@ -5,6 +5,8 @@
 #ifndef FLUTTER_SHELL_GPU_GPU_SURFACE_GL_DELEGATE_H_
 #define FLUTTER_SHELL_GPU_GPU_SURFACE_GL_DELEGATE_H_
 
+#include <optional>
+
 #include "flutter/common/graphics/gl_context_switch.h"
 #include "flutter/flow/embedded_views.h"
 #include "flutter/fml/macros.h"
@@ -31,10 +33,18 @@ class GPUSurfaceGLDelegate {
   // either the GPU or IO threads.
   virtual bool GLContextClearCurrent() = 0;
 
+  // Inform the GL Context that there's going to be no writing beyond
+  // the specified region
+  virtual void GLContextSetDamageRegion(const std::optional<SkIRect>& region) {}
+
   // Called to present the main GL surface. This is only called for the main GL
   // context and not any of the contexts dedicated for IO.
+  //
+  // Damage is a hint to compositor telling it which parts of front buffer
+  // need to be updated
   virtual bool GLContextPresent(fml::TimePoint target_time,
-                                uint32_t fbo_id) = 0;
+                                uint32_t fbo_id,
+                                const std::optional<SkIRect>& damage) = 0;
 
   // The ID of the main window bound framebuffer. Typically FBO0.
   virtual intptr_t GLContextFBO(GLFrameInfo frame_info) const = 0;

shell/platform/android/android_context_gl.cc

@@ -6,6 +6,7 @@
 
 #include <EGL/eglext.h>
 
+#include <list>
 #include <utility>
 
 #include "android_environment_gl.h"
@@ -106,11 +107,120 @@ static bool TeardownContext(EGLDisplay display, EGLContext context) {
   return true;
 }
 
+class AndroidEGLSurfaceDamage {
+ public:
+  void init(EGLDisplay display, EGLContext context) {
+    const char* extensions = eglQueryString(display, EGL_EXTENSIONS);
+
+    if (HasExtension(extensions, "EGL_KHR_partial_update")) {
+      set_damage_region = reinterpret_cast<PFNEGLSETDAMAGEREGIONKHRPROC>(
+          eglGetProcAddress("eglSetDamageRegionKHR"));
+    }
+
+    if (HasExtension(extensions, "EGL_EXT_swap_buffers_with_damage")) {
+      swap_buffers_with_damage =
+          reinterpret_cast<PFNEGLSWAPBUFFERSWITHDAMAGEEXTPROC>(
+              eglGetProcAddress("eglSwapBuffersWithDamageEXT"));
+    } else if (HasExtension(extensions, "EGL_KHR_swap_buffers_with_damage")) {
+      swap_buffers_with_damage =
+          reinterpret_cast<PFNEGLSWAPBUFFERSWITHDAMAGEEXTPROC>(
+              eglGetProcAddress("eglSwapBuffersWithDamageKHR"));
+    }
+
+    _partial_redraw_supported =
+        set_damage_region != nullptr && swap_buffers_with_damage != nullptr;
+  }
+
+  void SetDamageRegion(EGLDisplay display,
+                       EGLSurface surface,
+                       const std::optional<SkIRect>& region) {
+    if (set_damage_region && region) {
+      auto rects = RectToInts(display, surface, *region);
+      set_damage_region(display, surface, rects.data(), 1);
+    }
+  }
+
+  std::optional<SkIRect> InitialDamage(EGLDisplay display, EGLSurface surface) {
+    if (!_partial_redraw_supported) {
+      return std::nullopt;
+    }
+
+    EGLint age;
+    eglQuerySurface(display, surface, EGL_BUFFER_AGE_EXT, &age);
+
+    if (age == 0) {  // full repaint
+      return std::nullopt;
+    } else if (age == 1) {
+      // no initial damage
+      return SkIRect::MakeEmpty();
+    } else {
+      age -= 2;
+      SkIRect res;
+      for (auto i = damage_history_.begin();
+           i != damage_history_.end() && age >= 0; ++i, --age) {
+        res.join(*i);
+      }
+      return res;
+    }
+  }
+
+  bool SwapBuffersWithDamage(EGLDisplay display,
+                             EGLSurface surface,
+                             const std::optional<SkIRect>& damage) {
+    if (swap_buffers_with_damage && damage) {
+      damage_history_.push_back(*damage);
+      if (damage_history_.size() > 2) {
+        damage_history_.pop_front();
+      }
+      auto rects = RectToInts(display, surface, *damage);
+      return swap_buffers_with_damage(display, surface, rects.data(), 1);
+
+    } else {
+      return eglSwapBuffers(display, surface);
+    }
+  }
+
+ private:
+  std::vector<EGLint> RectToInts(EGLDisplay display,
+                                 EGLSurface surface,
+                                 const SkIRect& rect) {
+    std::vector<EGLint> res;
+    EGLint height;
+    eglQuerySurface(display, surface, EGL_HEIGHT, &height);
+
+    res.push_back(rect.left());
+    res.push_back(height - rect.bottom());
+    res.push_back(rect.width());
+    res.push_back(rect.height());
+
+    return res;
+  }
+
+  PFNEGLSETDAMAGEREGIONKHRPROC set_damage_region = nullptr;
+  PFNEGLSWAPBUFFERSWITHDAMAGEEXTPROC swap_buffers_with_damage = nullptr;
+
+  bool _partial_redraw_supported;
+
+  bool HasExtension(const char* extensions, const char* name) {
+    const char* r = strstr(extensions, name);
+    auto len = strlen(name);
+    // check that the extension name is terminated by space or null terminator
+    return r != nullptr && (r[len] == ' ' || r[len] == 0);
+  }
+
+  std::list<SkIRect> damage_history_;
+};
+
 AndroidEGLSurface::AndroidEGLSurface(
     EGLSurface surface,
     fml::RefPtr<AndroidEnvironmentGL> environment,
     EGLContext context)
-    : surface_(surface), environment_(environment), context_(context) {}
+    : surface_(surface),
+      environment_(environment),
+      context_(context),
+      damage_(std::make_unique<AndroidEGLSurfaceDamage>()) {
+  damage_->init(environment->Display(), context);
+}
 
 AndroidEGLSurface::~AndroidEGLSurface() {
   auto result = eglDestroySurface(environment_->Display(), surface_);
@@ -131,10 +241,22 @@ bool AndroidEGLSurface::MakeCurrent() const {
   return true;
 }
 
-bool AndroidEGLSurface::SwapBuffers(fml::TimePoint target_time) {
+void AndroidEGLSurface::SetDamageRegion(
+    const std::optional<SkIRect>& buffer_damage) {
+  damage_->SetDamageRegion(environment_->Display(), surface_, buffer_damage);
+}
+
+bool AndroidEGLSurface::SwapBuffers(
+    fml::TimePoint target_time,
+    const std::optional<SkIRect>& surface_damage) {
   TRACE_EVENT0("flutter", "AndroidContextGL::SwapBuffers");
   environment_->SetPresentationTime(surface_, target_time);
-  return eglSwapBuffers(environment_->Display(), surface_);
+  return damage_->SwapBuffersWithDamage(environment_->Display(), surface_,
+                                        surface_damage);
+}
+
+std::optional<SkIRect> AndroidEGLSurface::InitialDamage() {
+  return damage_->InitialDamage(environment_->Display(), surface_);
 }
 
 SkISize AndroidEGLSurface::GetSize() const {

shell/platform/android/android_context_gl.h

@@ -27,6 +27,8 @@ namespace flutter {
 /// This can be used in conjunction to unique_ptr to provide better guarantees
 /// about the lifespan of the `EGLSurface` object.
 ///
+class AndroidEGLSurfaceDamage;
+
 class AndroidEGLSurface {
  public:
   AndroidEGLSurface(EGLSurface surface,
@@ -49,6 +51,19 @@ class AndroidEGLSurface {
   ///
   bool MakeCurrent() const;
 
+  //----------------------------------------------------------------------------
+  /// @brief      This is the minimal area that needs to be repainted to get
+  ///             correct result
+  ///
+  /// @return     The area of current surface where it is behind front buffer.
+  ///
+  std::optional<SkIRect> InitialDamage();
+
+  //----------------------------------------------------------------------------
+  /// @brief      Sets the damage region for current surface. Corresponds to
+  //              eglSetDamageRegionKHR
+  void SetDamageRegion(const std::optional<SkIRect>& buffer_damage);
+
   //----------------------------------------------------------------------------
   /// @brief      This only applies to on-screen surfaces such as those created
   ///             by `AndroidContextGL::CreateOnscreenSurface`.
@@ -57,7 +72,8 @@ class AndroidEGLSurface {
   ///
   /// @return     Whether the EGL surface color buffer was swapped.
   ///
-  bool SwapBuffers(fml::TimePoint target_time);
+  bool SwapBuffers(fml::TimePoint target_time,
+                   const std::optional<SkIRect>& surface_damage);
 
   //----------------------------------------------------------------------------
   /// @return     The size of an `EGLSurface`.
@@ -68,6 +84,7 @@ class AndroidEGLSurface {
   const EGLSurface surface_;
   const fml::RefPtr<AndroidEnvironmentGL> environment_;
   const EGLContext context_;
+  std::unique_ptr<AndroidEGLSurfaceDamage> damage_;
 };
 
 //------------------------------------------------------------------------------

shell/platform/android/android_context_gl_unittests.cc

@@ -98,7 +98,7 @@ TEST(AndroidEGLSurface, SwapBuffersNotifiesAboutPresentationTime) {
   EXPECT_TRUE(surface);
   EXPECT_FALSE(environment->presentation_time_.has_value());
   auto now = fml::TimePoint::Now();
-  surface->SwapBuffers(now);
+  surface->SwapBuffers(now, std::nullopt);
   EXPECT_EQ(environment->presentation_time_, now);
 }
 }  // namespace android

shell/platform/android/android_surface_gl.cc

@@ -122,11 +122,27 @@ bool AndroidSurfaceGL::GLContextClearCurrent() {
   return GLContextPtr()->ClearCurrent();
 }
 
+SurfaceFrame::FramebufferInfo AndroidSurfaceGL::GLContextFramebufferInfo()
+    const {
+  FML_DCHECK(IsValid());
+  SurfaceFrame::FramebufferInfo res;
+  res.supports_readback = true;
+  res.existing_damage = onscreen_surface_->InitialDamage();
+  return res;
+}
+
+void AndroidSurfaceGL::GLContextSetDamageRegion(
+    const std::optional<SkIRect>& region) {
+  FML_DCHECK(IsValid());
+  onscreen_surface_->SetDamageRegion(region);
+}
+
 bool AndroidSurfaceGL::GLContextPresent(fml::TimePoint target_time,
-                                        uint32_t fbo_id) {
+                                        uint32_t fbo_id,
+                                        const std::optional<SkIRect>& damage) {
   FML_DCHECK(IsValid());
   FML_DCHECK(onscreen_surface_);
-  return onscreen_surface_->SwapBuffers(target_time);
+  return onscreen_surface_->SwapBuffers(target_time, damage);
 }
 
 intptr_t AndroidSurfaceGL::GLContextFBO(GLFrameInfo frame_info) const {

shell/platform/android/android_surface_gl.h

@@ -58,7 +58,15 @@ class AndroidSurfaceGL final : public GPUSurfaceGLDelegate,
   bool GLContextClearCurrent() override;
 
   // |GPUSurfaceGLDelegate|
-  bool GLContextPresent(fml::TimePoint target_time, uint32_t fbo_id) override;
+  SurfaceFrame::FramebufferInfo GLContextFramebufferInfo() const override;
+
+  // |GPUSurfaceGLDelegate|
+  void GLContextSetDamageRegion(const std::optional<SkIRect>& region) override;
+
+  // |GPUSurfaceGLDelegate|
+  bool GLContextPresent(fml::TimePoint target_time,
+                        uint32_t fbo_id,
+                        const std::optional<SkIRect>& damage) override;
 
   // |GPUSurfaceGLDelegate|
   intptr_t GLContextFBO(GLFrameInfo frame_info) const override;