shell/platform/android/android_egl_surface.cc - mirrors/engine - Git at Google

 // 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 "flutter/shell/platform/android/android_egl_surface.h"

 #include <EGL/eglext.h>
 #include <sys/system_properties.h>

 #include <array>
 #include <list>

 #include "flutter/fml/trace_event.h"

 namespace flutter {

 void LogLastEGLError() {
   struct EGLNameErrorPair {
     const char* name;
     EGLint code;
   };

 #define _EGL_ERROR_DESC(a) \
   {                        \
 #a, a                  \
   }

   const EGLNameErrorPair pairs[] = {
       _EGL_ERROR_DESC(EGL_SUCCESS),
       _EGL_ERROR_DESC(EGL_NOT_INITIALIZED),
       _EGL_ERROR_DESC(EGL_BAD_ACCESS),
       _EGL_ERROR_DESC(EGL_BAD_ALLOC),
       _EGL_ERROR_DESC(EGL_BAD_ATTRIBUTE),
       _EGL_ERROR_DESC(EGL_BAD_CONTEXT),
       _EGL_ERROR_DESC(EGL_BAD_CONFIG),
       _EGL_ERROR_DESC(EGL_BAD_CURRENT_SURFACE),
       _EGL_ERROR_DESC(EGL_BAD_DISPLAY),
       _EGL_ERROR_DESC(EGL_BAD_SURFACE),
       _EGL_ERROR_DESC(EGL_BAD_MATCH),
       _EGL_ERROR_DESC(EGL_BAD_PARAMETER),
       _EGL_ERROR_DESC(EGL_BAD_NATIVE_PIXMAP),
       _EGL_ERROR_DESC(EGL_BAD_NATIVE_WINDOW),
       _EGL_ERROR_DESC(EGL_CONTEXT_LOST),
   };

 #undef _EGL_ERROR_DESC

   const auto count = sizeof(pairs) / sizeof(EGLNameErrorPair);

   EGLint last_error = eglGetError();

   for (size_t i = 0; i < count; i++) {
     if (last_error == pairs[i].code) {
       FML_LOG(ERROR) << "EGL Error: " << pairs[i].name << " (" << pairs[i].code
                      << ")";
       return;
     }
   }

   FML_LOG(ERROR) << "Unknown EGL Error";
 }

 namespace {

 static 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);
 }

 }  // namespace

 class AndroidEGLSurfaceDamage {
  public:
   void init(EGLDisplay display, EGLContext context) {
     if (GetAPILevel() < 28) {
       // Disable partial repaint for devices older than Android 9. There
       // are old devices that have extensions below available but the
       // implementation causes glitches (i.e. Xperia Z3 with Android 6).
       partial_redraw_supported_ = false;
       return;
     }

     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;
   }

   static int GetAPILevel() {
     char sdk_version_string[PROP_VALUE_MAX];
     if (__system_property_get("ro.build.version.sdk", sdk_version_string)) {
       return atoi(sdk_version_string);
     } else {
       return -1;
     }
   }

   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);
     }
   }

   // Maximum damage history - for triple buffering we need to store damage for
   // last two frames; Some Android devices (Pixel 4) use quad buffering.
   static const int kMaxHistorySize = 10;

   bool SupportsPartialRepaint() const { return partial_redraw_supported_; }

   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 {
       // join up to (age - 1) last rects from damage history
       --age;
       auto res = SkIRect::MakeEmpty();
       for (auto i = damage_history_.rbegin();
            i != damage_history_.rend() && 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() > kMaxHistorySize) {
         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::array<EGLint, 4> static RectToInts(EGLDisplay display,
                                           EGLSurface surface,
                                           const SkIRect& rect) {
     EGLint height;
     eglQuerySurface(display, surface, EGL_HEIGHT, &height);

     std::array<EGLint, 4> res{rect.left(), height - rect.bottom(), rect.width(),
                               rect.height()};
     return res;
   }

   PFNEGLSETDAMAGEREGIONKHRPROC set_damage_region_ = nullptr;
   PFNEGLSWAPBUFFERSWITHDAMAGEEXTPROC swap_buffers_with_damage_ = nullptr;

   bool partial_redraw_supported_;

   std::list<SkIRect> damage_history_;
 };

 AndroidEGLSurface::AndroidEGLSurface(EGLSurface surface,
                                      EGLDisplay display,
                                      EGLContext context)
     : surface_(surface),
       display_(display),
       context_(context),
       damage_(std::make_unique<AndroidEGLSurfaceDamage>()),
       presentation_time_proc_(nullptr) {
   damage_->init(display_, context);

   const char* extensions = eglQueryString(display, EGL_EXTENSIONS);

   if (HasExtension(extensions, "EGL_ANDROID_presentation_time")) {
     presentation_time_proc_ =
         reinterpret_cast<PFNEGLPRESENTATIONTIMEANDROIDPROC>(
             eglGetProcAddress("eglPresentationTimeANDROID"));
   }
 }

 AndroidEGLSurface::~AndroidEGLSurface() {
   [[maybe_unused]] auto result = eglDestroySurface(display_, surface_);
   FML_DCHECK(result == EGL_TRUE);
 }

 bool AndroidEGLSurface::IsValid() const {
   return surface_ != EGL_NO_SURFACE;
 }

 bool AndroidEGLSurface::IsContextCurrent() const {
   EGLContext current_egl_context = eglGetCurrentContext();
   if (context_ != current_egl_context) {
     return false;
   }

   EGLDisplay current_egl_display = eglGetCurrentDisplay();
   if (display_ != current_egl_display) {
     return false;
   }

   EGLSurface draw_surface = eglGetCurrentSurface(EGL_DRAW);
   if (draw_surface != surface_) {
     return false;
   }

   EGLSurface read_surface = eglGetCurrentSurface(EGL_READ);
   if (read_surface != surface_) {
     return false;
   }

   return true;
 }

 AndroidEGLSurfaceMakeCurrentStatus AndroidEGLSurface::MakeCurrent() const {
   if (IsContextCurrent()) {
     return AndroidEGLSurfaceMakeCurrentStatus::kSuccessAlreadyCurrent;
   }
   if (eglMakeCurrent(display_, surface_, surface_, context_) != EGL_TRUE) {
     FML_LOG(ERROR) << "Could not make the context current";
     LogLastEGLError();
     return AndroidEGLSurfaceMakeCurrentStatus::kFailure;
   }
   return AndroidEGLSurfaceMakeCurrentStatus::kSuccessMadeCurrent;
 }

 void AndroidEGLSurface::SetDamageRegion(
     const std::optional<SkIRect>& buffer_damage) {
   damage_->SetDamageRegion(display_, surface_, buffer_damage);
 }

 bool AndroidEGLSurface::SetPresentationTime(
     const fml::TimePoint& presentation_time) {
   if (presentation_time_proc_) {
     const auto time_ns = presentation_time.ToEpochDelta().ToNanoseconds();
     return presentation_time_proc_(display_, surface_, time_ns);
   } else {
     return false;
   }
 }

 bool AndroidEGLSurface::SwapBuffers(
     const std::optional<SkIRect>& surface_damage) {
   TRACE_EVENT0("flutter", "AndroidContextGL::SwapBuffers");
   return damage_->SwapBuffersWithDamage(display_, surface_, surface_damage);
 }

 bool AndroidEGLSurface::SupportsPartialRepaint() const {
   return damage_->SupportsPartialRepaint();
 }

 std::optional<SkIRect> AndroidEGLSurface::InitialDamage() {
   return damage_->InitialDamage(display_, surface_);
 }

 SkISize AndroidEGLSurface::GetSize() const {
   EGLint width = 0;
   EGLint height = 0;

   if (!eglQuerySurface(display_, surface_, EGL_WIDTH, &width) ||
       !eglQuerySurface(display_, surface_, EGL_HEIGHT, &height)) {
     FML_LOG(ERROR) << "Unable to query EGL surface size";
     LogLastEGLError();
     return SkISize::Make(0, 0);
   }
   return SkISize::Make(width, height);
 }

 }  // namespace flutter
	// 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 "flutter/shell/platform/android/android_egl_surface.h"

	#include <EGL/eglext.h>
	#include <sys/system_properties.h>

	#include <array>
	#include <list>

	#include "flutter/fml/trace_event.h"

	namespace flutter {

	void LogLastEGLError() {
	struct EGLNameErrorPair {
	const char* name;
	EGLint code;
	};

	#define _EGL_ERROR_DESC(a) \
	{ \
	#a, a \
	}

	const EGLNameErrorPair pairs[] = {
	_EGL_ERROR_DESC(EGL_SUCCESS),
	_EGL_ERROR_DESC(EGL_NOT_INITIALIZED),
	_EGL_ERROR_DESC(EGL_BAD_ACCESS),
	_EGL_ERROR_DESC(EGL_BAD_ALLOC),
	_EGL_ERROR_DESC(EGL_BAD_ATTRIBUTE),
	_EGL_ERROR_DESC(EGL_BAD_CONTEXT),
	_EGL_ERROR_DESC(EGL_BAD_CONFIG),
	_EGL_ERROR_DESC(EGL_BAD_CURRENT_SURFACE),
	_EGL_ERROR_DESC(EGL_BAD_DISPLAY),
	_EGL_ERROR_DESC(EGL_BAD_SURFACE),
	_EGL_ERROR_DESC(EGL_BAD_MATCH),
	_EGL_ERROR_DESC(EGL_BAD_PARAMETER),
	_EGL_ERROR_DESC(EGL_BAD_NATIVE_PIXMAP),
	_EGL_ERROR_DESC(EGL_BAD_NATIVE_WINDOW),
	_EGL_ERROR_DESC(EGL_CONTEXT_LOST),
	};

	#undef _EGL_ERROR_DESC

	const auto count = sizeof(pairs) / sizeof(EGLNameErrorPair);

	EGLint last_error = eglGetError();

	for (size_t i = 0; i < count; i++) {
	if (last_error == pairs[i].code) {
	FML_LOG(ERROR) << "EGL Error: " << pairs[i].name << " (" << pairs[i].code
	<< ")";
	return;
	}
	}

	FML_LOG(ERROR) << "Unknown EGL Error";
	}

	namespace {

	static 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);
	}

	} // namespace

	class AndroidEGLSurfaceDamage {
	public:
	void init(EGLDisplay display, EGLContext context) {
	if (GetAPILevel() < 28) {
	// Disable partial repaint for devices older than Android 9. There
	// are old devices that have extensions below available but the
	// implementation causes glitches (i.e. Xperia Z3 with Android 6).
	partial_redraw_supported_ = false;
	return;
	}

	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;
	}

	static int GetAPILevel() {
	char sdk_version_string[PROP_VALUE_MAX];
	if (__system_property_get("ro.build.version.sdk", sdk_version_string)) {
	return atoi(sdk_version_string);
	} else {
	return -1;
	}
	}

	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);
	}
	}

	// Maximum damage history - for triple buffering we need to store damage for
	// last two frames; Some Android devices (Pixel 4) use quad buffering.
	static const int kMaxHistorySize = 10;

	bool SupportsPartialRepaint() const { return partial_redraw_supported_; }

	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 {
	// join up to (age - 1) last rects from damage history
	--age;
	auto res = SkIRect::MakeEmpty();
	for (auto i = damage_history_.rbegin();
	i != damage_history_.rend() && 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() > kMaxHistorySize) {
	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::array<EGLint, 4> static RectToInts(EGLDisplay display,
	EGLSurface surface,
	const SkIRect& rect) {
	EGLint height;
	eglQuerySurface(display, surface, EGL_HEIGHT, &height);

	std::array<EGLint, 4> res{rect.left(), height - rect.bottom(), rect.width(),
	rect.height()};
	return res;
	}

	PFNEGLSETDAMAGEREGIONKHRPROC set_damage_region_ = nullptr;
	PFNEGLSWAPBUFFERSWITHDAMAGEEXTPROC swap_buffers_with_damage_ = nullptr;

	bool partial_redraw_supported_;

	std::list<SkIRect> damage_history_;
	};

	AndroidEGLSurface::AndroidEGLSurface(EGLSurface surface,
	EGLDisplay display,
	EGLContext context)
	: surface_(surface),
	display_(display),
	context_(context),
	damage_(std::make_unique<AndroidEGLSurfaceDamage>()),
	presentation_time_proc_(nullptr) {
	damage_->init(display_, context);

	const char* extensions = eglQueryString(display, EGL_EXTENSIONS);

	if (HasExtension(extensions, "EGL_ANDROID_presentation_time")) {
	presentation_time_proc_ =
	reinterpret_cast<PFNEGLPRESENTATIONTIMEANDROIDPROC>(
	eglGetProcAddress("eglPresentationTimeANDROID"));
	}
	}

	AndroidEGLSurface::~AndroidEGLSurface() {
	[[maybe_unused]] auto result = eglDestroySurface(display_, surface_);
	FML_DCHECK(result == EGL_TRUE);
	}

	bool AndroidEGLSurface::IsValid() const {
	return surface_ != EGL_NO_SURFACE;
	}

	bool AndroidEGLSurface::IsContextCurrent() const {
	EGLContext current_egl_context = eglGetCurrentContext();
	if (context_ != current_egl_context) {
	return false;
	}

	EGLDisplay current_egl_display = eglGetCurrentDisplay();
	if (display_ != current_egl_display) {
	return false;
	}

	EGLSurface draw_surface = eglGetCurrentSurface(EGL_DRAW);
	if (draw_surface != surface_) {
	return false;
	}

	EGLSurface read_surface = eglGetCurrentSurface(EGL_READ);
	if (read_surface != surface_) {
	return false;
	}

	return true;
	}

	AndroidEGLSurfaceMakeCurrentStatus AndroidEGLSurface::MakeCurrent() const {
	if (IsContextCurrent()) {
	return AndroidEGLSurfaceMakeCurrentStatus::kSuccessAlreadyCurrent;
	}
	if (eglMakeCurrent(display_, surface_, surface_, context_) != EGL_TRUE) {
	FML_LOG(ERROR) << "Could not make the context current";
	LogLastEGLError();
	return AndroidEGLSurfaceMakeCurrentStatus::kFailure;
	}
	return AndroidEGLSurfaceMakeCurrentStatus::kSuccessMadeCurrent;
	}

	void AndroidEGLSurface::SetDamageRegion(
	const std::optional<SkIRect>& buffer_damage) {
	damage_->SetDamageRegion(display_, surface_, buffer_damage);
	}

	bool AndroidEGLSurface::SetPresentationTime(
	const fml::TimePoint& presentation_time) {
	if (presentation_time_proc_) {
	const auto time_ns = presentation_time.ToEpochDelta().ToNanoseconds();
	return presentation_time_proc_(display_, surface_, time_ns);
	} else {
	return false;
	}
	}

	bool AndroidEGLSurface::SwapBuffers(
	const std::optional<SkIRect>& surface_damage) {
	TRACE_EVENT0("flutter", "AndroidContextGL::SwapBuffers");
	return damage_->SwapBuffersWithDamage(display_, surface_, surface_damage);
	}

	bool AndroidEGLSurface::SupportsPartialRepaint() const {
	return damage_->SupportsPartialRepaint();
	}

	std::optional<SkIRect> AndroidEGLSurface::InitialDamage() {
	return damage_->InitialDamage(display_, surface_);
	}

	SkISize AndroidEGLSurface::GetSize() const {
	EGLint width = 0;
	EGLint height = 0;

	if (!eglQuerySurface(display_, surface_, EGL_WIDTH, &width) \|\|
	!eglQuerySurface(display_, surface_, EGL_HEIGHT, &height)) {
	FML_LOG(ERROR) << "Unable to query EGL surface size";
	LogLastEGLError();
	return SkISize::Make(0, 0);
	}
	return SkISize::Make(width, height);
	}

	} // namespace flutter