Merge "Allow native driver to be ANGLE" into rvc-dev am: eeff9de91c am: 8e9575bf91 (01273475) · Commits · e / os / platform_frameworks_native

opengl/libs/EGL/Loader.cpp

+25 −64

Original line number	Original line	Diff line number	Diff line
	@@ -271,6 +271,12 @@ void* Loader::open(egl_connection_t* cnx)
	if (!hnd) {		if (!hnd) {
	android::GraphicsEnv::getInstance().setDriverLoaded(android::GpuStatsInfo::Api::API_GL,		android::GraphicsEnv::getInstance().setDriverLoaded(android::GpuStatsInfo::Api::API_GL,
	false, systemTime() - openTime);		false, systemTime() - openTime);
			} else {
			// init_angle_backend will check if loaded driver is ANGLE or not,
			// will set cnx->useAngle appropriately.
			// Do this here so that we use ANGLE path when driver is ANGLE (e.g. loaded as native),
			// not just loading ANGLE as option.
			init_angle_backend(hnd->dso[0], cnx);
	}		}

	LOG_ALWAYS_FATAL_IF(!hnd,		LOG_ALWAYS_FATAL_IF(!hnd,
	@@ -311,11 +317,6 @@ void Loader::close(egl_connection_t* cnx)
	cnx->dso = nullptr;		cnx->dso = nullptr;

	cnx->useAngle = false;		cnx->useAngle = false;

	if (cnx->vendorEGL) {
	dlclose(cnx->vendorEGL);
	cnx->vendorEGL = nullptr;
	}
	}		}

	void Loader::init_api(void* dso,		void Loader::init_api(void* dso,
	@@ -482,7 +483,7 @@ static void* load_system_driver(const char* kind, const char* suffix, const bool
	return dso;		return dso;
	}		}

	static void* load_angle_from_namespace(const char* kind, android_namespace_t* ns) {		static void* load_angle(const char* kind, android_namespace_t* ns) {
	const android_dlextinfo dlextinfo = {		const android_dlextinfo dlextinfo = {
	.flags = ANDROID_DLEXT_USE_NAMESPACE,		.flags = ANDROID_DLEXT_USE_NAMESPACE,
	.library_namespace = ns,		.library_namespace = ns,
	@@ -502,61 +503,6 @@ static void* load_angle_from_namespace(const char* kind, android_namespace_t* ns
	return nullptr;		return nullptr;
	}		}

	static void* load_angle(const char* kind, android_namespace_t* ns, egl_connection_t* cnx) {
	void* so = load_angle_from_namespace(kind, ns);

	if (so) {
	ALOGV("Loaded ANGLE %s library for '%s' (instead of native)", kind,
	android::GraphicsEnv::getInstance().getAngleAppName().c_str());
	cnx->useAngle = true;

	char prop[PROPERTY_VALUE_MAX];

	property_get("debug.hwui.renderer", prop, "UNSET");
	ALOGV("Skia's renderer set to %s", prop);

	EGLint angleBackendDefault = EGL_PLATFORM_ANGLE_TYPE_VULKAN_ANGLE;
	property_get("debug.angle.backend", prop, "0");
	switch (atoi(prop)) {
	case 1:
	ALOGV("%s: Requesting OpenGLES back-end", __FUNCTION__);
	angleBackendDefault = EGL_PLATFORM_ANGLE_TYPE_OPENGLES_ANGLE;
	break;
	case 2:
	ALOGV("%s: Requesting Vulkan back-end", __FUNCTION__);
	angleBackendDefault = EGL_PLATFORM_ANGLE_TYPE_VULKAN_ANGLE;
	break;
	default:
	break;
	}

	cnx->angleBackend = angleBackendDefault;
	if (!cnx->vendorEGL && (cnx->angleBackend == EGL_PLATFORM_ANGLE_TYPE_OPENGLES_ANGLE)) {
	// Find and load vendor libEGL for ANGLE's GL back-end to use.
	char prop[PROPERTY_VALUE_MAX + 1];
	for (auto key : HAL_SUBNAME_KEY_PROPERTIES) {
	if (property_get(key, prop, nullptr) <= 0) {
	continue;
	}
	void* dso = load_system_driver("EGL", prop, true);
	if (dso) {
	cnx->vendorEGL = dso;
	break;
	}
	}
	if (!cnx->vendorEGL) {
	cnx->vendorEGL = load_system_driver("EGL", nullptr, true);
	}
	}
	} else {
	ALOGV("Loaded native %s library for '%s' (instead of ANGLE)", kind,
	android::GraphicsEnv::getInstance().getAngleAppName().c_str());
	cnx->useAngle = false;
	}

	return so;
	}

	static void* load_updated_driver(const char* kind, android_namespace_t* ns) {		static void* load_updated_driver(const char* kind, android_namespace_t* ns) {
	ATRACE_CALL();		ATRACE_CALL();
	const android_dlextinfo dlextinfo = {		const android_dlextinfo dlextinfo = {
	@@ -594,22 +540,37 @@ Loader::driver_t* Loader::attempt_to_load_angle(egl_connection_t* cnx) {
	driver_t* hnd = nullptr;		driver_t* hnd = nullptr;

	// ANGLE doesn't ship with GLES library, and thus we skip GLES driver.		// ANGLE doesn't ship with GLES library, and thus we skip GLES driver.
	void* dso = load_angle("EGL", ns, cnx);		void* dso = load_angle("EGL", ns);
	if (dso) {		if (dso) {
	initialize_api(dso, cnx, EGL);		initialize_api(dso, cnx, EGL);
	hnd = new driver_t(dso);		hnd = new driver_t(dso);

	dso = load_angle("GLESv1_CM", ns, cnx);		dso = load_angle("GLESv1_CM", ns);
	initialize_api(dso, cnx, GLESv1_CM);		initialize_api(dso, cnx, GLESv1_CM);
	hnd->set(dso, GLESv1_CM);		hnd->set(dso, GLESv1_CM);

	dso = load_angle("GLESv2", ns, cnx);		dso = load_angle("GLESv2", ns);
	initialize_api(dso, cnx, GLESv2);		initialize_api(dso, cnx, GLESv2);
	hnd->set(dso, GLESv2);		hnd->set(dso, GLESv2);
	}		}
	return hnd;		return hnd;
	}		}

			void Loader::init_angle_backend(void* dso, egl_connection_t* cnx) {
			void* eglCreateDeviceANGLE = nullptr;

			ALOGV("dso: %p", dso);
			eglCreateDeviceANGLE = dlsym(dso, "eglCreateDeviceANGLE");
			ALOGV("eglCreateDeviceANGLE: %p", eglCreateDeviceANGLE);
			if (eglCreateDeviceANGLE) {
			ALOGV("ANGLE GLES library in use");
			cnx->useAngle = true;
			} else {
			ALOGV("Native GLES library in use");
			cnx->useAngle = false;
			}
			}

	Loader::driver_t* Loader::attempt_to_load_updated_driver(egl_connection_t* cnx) {		Loader::driver_t* Loader::attempt_to_load_updated_driver(egl_connection_t* cnx) {
	ATRACE_CALL();		ATRACE_CALL();
	#ifndef __ANDROID_VNDK__		#ifndef __ANDROID_VNDK__

opengl/libs/EGL/Loader.h

+1 −0

Original line number	Original line	Diff line number	Diff line
	@@ -60,6 +60,7 @@ private:
	driver_t* attempt_to_load_system_driver(egl_connection_t* cnx, const char* suffix, const bool exact);		driver_t* attempt_to_load_system_driver(egl_connection_t* cnx, const char* suffix, const bool exact);
	void unload_system_driver(egl_connection_t* cnx);		void unload_system_driver(egl_connection_t* cnx);
	void initialize_api(void* dso, egl_connection_t* cnx, uint32_t mask);		void initialize_api(void* dso, egl_connection_t* cnx, uint32_t mask);
			void init_angle_backend(void* dso, egl_connection_t* cnx);

	static __attribute__((noinline))		static __attribute__((noinline))
	void init_api(void* dso,		void init_api(void* dso,

opengl/libs/EGL/egl_display.cpp

+8 −44

Original line number	Original line	Diff line number	Diff line
	@@ -134,45 +134,6 @@ EGLDisplay egl_display_t::getFromNativeDisplay(EGLNativeDisplayType disp,
	return sDisplay[uintptr_t(disp)].getPlatformDisplay(disp, attrib_list);		return sDisplay[uintptr_t(disp)].getPlatformDisplay(disp, attrib_list);
	}		}

	static bool addAnglePlatformAttributes(egl_connection_t* const cnx,
	std::vector<EGLAttrib>& attrs) {
	intptr_t vendorEGL = (intptr_t)cnx->vendorEGL;

	attrs.reserve(4 * 2);

	attrs.push_back(EGL_PLATFORM_ANGLE_TYPE_ANGLE);
	attrs.push_back(cnx->angleBackend);

	switch (cnx->angleBackend) {
	case EGL_PLATFORM_ANGLE_TYPE_VULKAN_ANGLE:
	ALOGV("%s: Requesting Vulkan ANGLE back-end", __FUNCTION__);
	char prop[PROPERTY_VALUE_MAX];
	property_get("debug.angle.validation", prop, "0");
	attrs.push_back(EGL_PLATFORM_ANGLE_DEBUG_LAYERS_ENABLED_ANGLE);
	attrs.push_back(atoi(prop));
	break;
	case EGL_PLATFORM_ANGLE_TYPE_DEFAULT_ANGLE:
	ALOGV("%s: Requesting Default ANGLE back-end", __FUNCTION__);
	break;
	case EGL_PLATFORM_ANGLE_TYPE_OPENGLES_ANGLE:
	ALOGV("%s: Requesting OpenGL ES ANGLE back-end", __FUNCTION__);
	// NOTE: This is only valid if the backend is OpenGL
	attrs.push_back(EGL_PLATFORM_ANGLE_EGL_HANDLE_ANGLE);
	attrs.push_back(vendorEGL);

	// Context virtualization is only available on GL back-end.
	// Needed to support threading with GL back-end
	attrs.push_back(EGL_PLATFORM_ANGLE_CONTEXT_VIRTUALIZATION_ANGLE);
	attrs.push_back(EGL_FALSE);
	break;
	default:
	ALOGE("%s: Requesting Unknown (%d) ANGLE back-end", __FUNCTION__, cnx->angleBackend);
	break;
	}

	return true;
	}

	static EGLDisplay getPlatformDisplayAngle(EGLNativeDisplayType display, egl_connection_t* const cnx,		static EGLDisplay getPlatformDisplayAngle(EGLNativeDisplayType display, egl_connection_t* const cnx,
	const EGLAttrib* attrib_list, EGLint* error) {		const EGLAttrib* attrib_list, EGLint* error) {
	EGLDisplay dpy = EGL_NO_DISPLAY;		EGLDisplay dpy = EGL_NO_DISPLAY;
	@@ -187,11 +148,14 @@ static EGLDisplay getPlatformDisplayAngle(EGLNativeDisplayType display, egl_conn
	}		}
	}		}

	if (!addAnglePlatformAttributes(cnx, attrs)) {		attrs.push_back(EGL_PLATFORM_ANGLE_TYPE_ANGLE);
	ALOGE("eglGetDisplay(%p) failed: Mismatch display request", display);		attrs.push_back(EGL_PLATFORM_ANGLE_TYPE_VULKAN_ANGLE);
	*error = EGL_BAD_PARAMETER;
	return EGL_NO_DISPLAY;		char prop[PROPERTY_VALUE_MAX];
	}		property_get("debug.angle.validation", prop, "0");
			attrs.push_back(EGL_PLATFORM_ANGLE_DEBUG_LAYERS_ENABLED_ANGLE);
			attrs.push_back(atoi(prop));

	attrs.push_back(EGL_NONE);		attrs.push_back(EGL_NONE);

	dpy = cnx->egl.eglGetPlatformDisplay(EGL_PLATFORM_ANGLE_ANGLE,		dpy = cnx->egl.eglGetPlatformDisplay(EGL_PLATFORM_ANGLE_ANGLE,

opengl/libs/EGL/egl_platform_entries.cpp

+6 −6

Original line number	Original line	Diff line number	Diff line
	@@ -721,7 +721,7 @@ EGLSurface eglCreateWindowSurfaceTmpl(egl_display_ptr dp, egl_connection_t* cnx,

	// NOTE: When using Vulkan backend, the Vulkan runtime makes all the		// NOTE: When using Vulkan backend, the Vulkan runtime makes all the
	// native_window_* calls, so don't do them here.		// native_window_* calls, so don't do them here.
	if (cnx->angleBackend != EGL_PLATFORM_ANGLE_TYPE_VULKAN_ANGLE) {		if (!cnx->useAngle) {
	int result = native_window_api_connect(window, NATIVE_WINDOW_API_EGL);		int result = native_window_api_connect(window, NATIVE_WINDOW_API_EGL);
	if (result < 0) {		if (result < 0) {
	ALOGE("eglCreateWindowSurface: native_window_api_connect (win=%p) "		ALOGE("eglCreateWindowSurface: native_window_api_connect (win=%p) "
	@@ -740,14 +740,14 @@ EGLSurface eglCreateWindowSurfaceTmpl(egl_display_ptr dp, egl_connection_t* cnx,
	std::vector<AttrType> strippedAttribList;		std::vector<AttrType> strippedAttribList;
	if (!processAttributes<AttrType>(dp, window, attrib_list, &colorSpace, &strippedAttribList)) {		if (!processAttributes<AttrType>(dp, window, attrib_list, &colorSpace, &strippedAttribList)) {
	ALOGE("error invalid colorspace: %d", colorSpace);		ALOGE("error invalid colorspace: %d", colorSpace);
	if (cnx->angleBackend != EGL_PLATFORM_ANGLE_TYPE_VULKAN_ANGLE) {		if (!cnx->useAngle) {
	native_window_api_disconnect(window, NATIVE_WINDOW_API_EGL);		native_window_api_disconnect(window, NATIVE_WINDOW_API_EGL);
	}		}
	return EGL_NO_SURFACE;		return EGL_NO_SURFACE;
	}		}
	attrib_list = strippedAttribList.data();		attrib_list = strippedAttribList.data();

	if (cnx->angleBackend != EGL_PLATFORM_ANGLE_TYPE_VULKAN_ANGLE) {		if (!cnx->useAngle) {
	int err = native_window_set_buffers_format(window, format);		int err = native_window_set_buffers_format(window, format);
	if (err != 0) {		if (err != 0) {
	ALOGE("error setting native window pixel format: %s (%d)", strerror(-err), err);		ALOGE("error setting native window pixel format: %s (%d)", strerror(-err), err);
	@@ -779,7 +779,7 @@ EGLSurface eglCreateWindowSurfaceTmpl(egl_display_ptr dp, egl_connection_t* cnx,
	}		}

	// EGLSurface creation failed		// EGLSurface creation failed
	if (cnx->angleBackend != EGL_PLATFORM_ANGLE_TYPE_VULKAN_ANGLE) {		if (!cnx->useAngle) {
	native_window_set_buffers_format(window, 0);		native_window_set_buffers_format(window, 0);
	native_window_api_disconnect(window, NATIVE_WINDOW_API_EGL);		native_window_api_disconnect(window, NATIVE_WINDOW_API_EGL);
	}		}
	@@ -1419,7 +1419,7 @@ EGLBoolean eglSwapBuffersWithDamageKHRImpl(EGLDisplay dpy, EGLSurface draw,
	}		}
	}		}

	if (s->cnx->angleBackend != EGL_PLATFORM_ANGLE_TYPE_VULKAN_ANGLE) {		if (!s->cnx->useAngle) {
	if (!sendSurfaceMetadata(s)) {		if (!sendSurfaceMetadata(s)) {
	native_window_api_disconnect(s->getNativeWindow(), NATIVE_WINDOW_API_EGL);		native_window_api_disconnect(s->getNativeWindow(), NATIVE_WINDOW_API_EGL);
	return setError(EGL_BAD_NATIVE_WINDOW, (EGLBoolean)EGL_FALSE);		return setError(EGL_BAD_NATIVE_WINDOW, (EGLBoolean)EGL_FALSE);
	@@ -1444,7 +1444,7 @@ EGLBoolean eglSwapBuffersWithDamageKHRImpl(EGLDisplay dpy, EGLSurface draw,
	androidRect.bottom = y;		androidRect.bottom = y;
	androidRects.push_back(androidRect);		androidRects.push_back(androidRect);
	}		}
	if (s->cnx->angleBackend != EGL_PLATFORM_ANGLE_TYPE_VULKAN_ANGLE) {		if (!s->cnx->useAngle) {
	native_window_set_surface_damage(s->getNativeWindow(), androidRects.data(),		native_window_set_surface_damage(s->getNativeWindow(), androidRects.data(),
	androidRects.size());		androidRects.size());
	}		}

opengl/libs/EGL/egldefs.h

+0 −2

Original line number	Original line	Diff line number	Diff line
	@@ -82,8 +82,6 @@ struct egl_connection_t {

	bool systemDriverUnloaded;		bool systemDriverUnloaded;
	bool useAngle; // Was ANGLE successfully loaded		bool useAngle; // Was ANGLE successfully loaded
	EGLint angleBackend;
	void* vendorEGL;
	};		};
	// clang-format on		// clang-format on