Merge "[RenderEngine] Move GLES20RenderEngine creation code to GLES20RenderEngine." (277482c5) · Commits · e / os / android_frameworks_native-old

services/surfaceflinger/RenderEngine/RenderEngine.cpp

+6 −298

Original line number	Diff line number	Diff line
		@@ -37,131 +37,18 @@ extern "C" EGLAPI const char* eglQueryStringImplementationANDROID(EGLDisplay dpy
		namespace android {
		namespace renderengine {

		RenderEngine::~RenderEngine() = default;

		namespace impl {

		std::unique_ptr<RenderEngine> RenderEngine::create(int hwcFormat, uint32_t featureFlags) {
		// initialize EGL for the default display
		EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
		if (!eglInitialize(display, nullptr, nullptr)) {
		LOG_ALWAYS_FATAL("failed to initialize EGL");
		}

		GLExtensions& extensions = GLExtensions::getInstance();
		extensions.initWithEGLStrings(eglQueryStringImplementationANDROID(display, EGL_VERSION),
		eglQueryStringImplementationANDROID(display, EGL_EXTENSIONS));

		// The code assumes that ES2 or later is available if this extension is
		// supported.
		EGLConfig config = EGL_NO_CONFIG;
		if (!extensions.hasNoConfigContext()) {
		config = chooseEglConfig(display, hwcFormat, /logConfig/ true);
		}

		EGLint renderableType = 0;
		if (config == EGL_NO_CONFIG) {
		renderableType = EGL_OPENGL_ES2_BIT;
		} else if (!eglGetConfigAttrib(display, config, EGL_RENDERABLE_TYPE, &renderableType)) {
		LOG_ALWAYS_FATAL("can't query EGLConfig RENDERABLE_TYPE");
		}
		EGLint contextClientVersion = 0;
		if (renderableType & EGL_OPENGL_ES2_BIT) {
		contextClientVersion = 2;
		} else if (renderableType & EGL_OPENGL_ES_BIT) {
		contextClientVersion = 1;
		} else {
		LOG_ALWAYS_FATAL("no supported EGL_RENDERABLE_TYPEs");
		}

		std::vector<EGLint> contextAttributes;
		contextAttributes.reserve(6);
		contextAttributes.push_back(EGL_CONTEXT_CLIENT_VERSION);
		contextAttributes.push_back(contextClientVersion);
		bool useContextPriority = extensions.hasContextPriority() &&
		(featureFlags & RenderEngine::USE_HIGH_PRIORITY_CONTEXT);
		if (useContextPriority) {
		contextAttributes.push_back(EGL_CONTEXT_PRIORITY_LEVEL_IMG);
		contextAttributes.push_back(EGL_CONTEXT_PRIORITY_HIGH_IMG);
		}
		contextAttributes.push_back(EGL_NONE);

		EGLContext ctxt = eglCreateContext(display, config, nullptr, contextAttributes.data());

		// if can't create a GL context, we can only abort.
		LOG_ALWAYS_FATAL_IF(ctxt == EGL_NO_CONTEXT, "EGLContext creation failed");

		// now figure out what version of GL did we actually get
		// NOTE: a dummy surface is not needed if KHR_create_context is supported

		EGLConfig dummyConfig = config;
		if (dummyConfig == EGL_NO_CONFIG) {
		dummyConfig = chooseEglConfig(display, hwcFormat, /logConfig/ true);
		}
		EGLint attribs[] = {EGL_WIDTH, 1, EGL_HEIGHT, 1, EGL_NONE, EGL_NONE};
		EGLSurface dummy = eglCreatePbufferSurface(display, dummyConfig, attribs);
		LOG_ALWAYS_FATAL_IF(dummy == EGL_NO_SURFACE, "can't create dummy pbuffer");
		EGLBoolean success = eglMakeCurrent(display, dummy, dummy, ctxt);
		LOG_ALWAYS_FATAL_IF(!success, "can't make dummy pbuffer current");

		extensions.initWithGLStrings(glGetString(GL_VENDOR), glGetString(GL_RENDERER),
		glGetString(GL_VERSION), glGetString(GL_EXTENSIONS));

		GlesVersion version = parseGlesVersion(extensions.getVersion());

		// initialize the renderer while GL is current

		std::unique_ptr<RenderEngine> engine;
		switch (version) {
		case GLES_VERSION_1_0:
		case GLES_VERSION_1_1:
		LOG_ALWAYS_FATAL("SurfaceFlinger requires OpenGL ES 2.0 minimum to run.");
		break;
		case GLES_VERSION_2_0:
		case GLES_VERSION_3_0:
		engine = std::make_unique<GLES20RenderEngine>(featureFlags);
		break;
		std::unique_ptr<impl::RenderEngine> RenderEngine::create(int hwcFormat, uint32_t featureFlags) {
		return renderengine::gl::GLES20RenderEngine::create(hwcFormat, featureFlags);
		}
		engine->setEGLHandles(display, config, ctxt);

		ALOGI("OpenGL ES informations:");
		ALOGI("vendor : %s", extensions.getVendor());
		ALOGI("renderer : %s", extensions.getRenderer());
		ALOGI("version : %s", extensions.getVersion());
		ALOGI("extensions: %s", extensions.getExtensions());
		ALOGI("GL_MAX_TEXTURE_SIZE = %zu", engine->getMaxTextureSize());
		ALOGI("GL_MAX_VIEWPORT_DIMS = %zu", engine->getMaxViewportDims());

		eglMakeCurrent(display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
		eglDestroySurface(display, dummy);
		RenderEngine::~RenderEngine() = default;

		return engine;
		}
		namespace impl {

		RenderEngine::RenderEngine(uint32_t featureFlags)
		: mEGLDisplay(EGL_NO_DISPLAY),
		mEGLConfig(nullptr),
		mEGLContext(EGL_NO_CONTEXT),
		mFeatureFlags(featureFlags) {}
		: mFeatureFlags(featureFlags) {}

		RenderEngine::~RenderEngine() {
		eglMakeCurrent(mEGLDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
		eglTerminate(mEGLDisplay);
		}

		void RenderEngine::setEGLHandles(EGLDisplay display, EGLConfig config, EGLContext ctxt) {
		mEGLDisplay = display;
		mEGLConfig = config;
		mEGLContext = ctxt;
		}

		EGLDisplay RenderEngine::getEGLDisplay() const {
		return mEGLDisplay;
		}

		EGLConfig RenderEngine::getEGLConfig() const {
		return mEGLConfig;
		}
		RenderEngine::~RenderEngine() = default;

		bool RenderEngine::useNativeFenceSync() const {
		return SyncFeatures::getInstance().useNativeFenceSync();
		@@ -171,185 +58,6 @@ bool RenderEngine::useWaitSync() const {
		return SyncFeatures::getInstance().useWaitSync();
		}

		RenderEngine::GlesVersion RenderEngine::parseGlesVersion(const char* str) {
		int major, minor;
		if (sscanf(str, "OpenGL ES-CM %d.%d", &major, &minor) != 2) {
		if (sscanf(str, "OpenGL ES %d.%d", &major, &minor) != 2) {
		ALOGW("Unable to parse GL_VERSION string: \"%s\"", str);
		return GLES_VERSION_1_0;
		}
		}

		if (major == 1 && minor == 0) return GLES_VERSION_1_0;
		if (major == 1 && minor >= 1) return GLES_VERSION_1_1;
		if (major == 2 && minor >= 0) return GLES_VERSION_2_0;
		if (major == 3 && minor >= 0) return GLES_VERSION_3_0;

		ALOGW("Unrecognized OpenGL ES version: %d.%d", major, minor);
		return GLES_VERSION_1_0;
		}

		void RenderEngine::dump(String8& result) {
		const GLExtensions& extensions = GLExtensions::getInstance();

		result.appendFormat("EGL implementation : %s\n", extensions.getEGLVersion());
		result.appendFormat("%s\n", extensions.getEGLExtensions());

		result.appendFormat("GLES: %s, %s, %s\n", extensions.getVendor(), extensions.getRenderer(),
		extensions.getVersion());
		result.appendFormat("%s\n", extensions.getExtensions());
		}

		static status_t selectConfigForAttribute(EGLDisplay dpy, EGLint const* attrs, EGLint attribute,
		EGLint wanted, EGLConfig* outConfig) {
		EGLint numConfigs = -1, n = 0;
		eglGetConfigs(dpy, nullptr, 0, &numConfigs);
		EGLConfig* const configs = new EGLConfig[numConfigs];
		eglChooseConfig(dpy, attrs, configs, numConfigs, &n);

		if (n) {
		if (attribute != EGL_NONE) {
		for (int i = 0; i < n; i++) {
		EGLint value = 0;
		eglGetConfigAttrib(dpy, configs[i], attribute, &value);
		if (wanted == value) {
		*outConfig = configs[i];
		delete[] configs;
		return NO_ERROR;
		}
		}
		} else {
		// just pick the first one
		*outConfig = configs[0];
		delete[] configs;
		return NO_ERROR;
		}
		}
		delete[] configs;
		return NAME_NOT_FOUND;
		}

		class EGLAttributeVector {
		struct Attribute;
		class Adder;
		friend class Adder;
		KeyedVector<Attribute, EGLint> mList;
		struct Attribute {
		Attribute() : v(0){};
		explicit Attribute(EGLint v) : v(v) {}
		EGLint v;
		bool operator<(const Attribute& other) const {
		// this places EGL_NONE at the end
		EGLint lhs(v);
		EGLint rhs(other.v);
		if (lhs == EGL_NONE) lhs = 0x7FFFFFFF;
		if (rhs == EGL_NONE) rhs = 0x7FFFFFFF;
		return lhs < rhs;
		}
		};
		class Adder {
		friend class EGLAttributeVector;
		EGLAttributeVector& v;
		EGLint attribute;
		Adder(EGLAttributeVector& v, EGLint attribute) : v(v), attribute(attribute) {}

		public:
		void operator=(EGLint value) {
		if (attribute != EGL_NONE) {
		v.mList.add(Attribute(attribute), value);
		}
		}
		operator EGLint() const { return v.mList[attribute]; }
		};

		public:
		EGLAttributeVector() { mList.add(Attribute(EGL_NONE), EGL_NONE); }
		void remove(EGLint attribute) {
		if (attribute != EGL_NONE) {
		mList.removeItem(Attribute(attribute));
		}
		}
		Adder operator[](EGLint attribute) { return Adder(*this, attribute); }
		EGLint operator[](EGLint attribute) const { return mList[attribute]; }
		// cast-operator to (EGLint const*)
		operator EGLint const*() const { return &mList.keyAt(0).v; }
		};

		static status_t selectEGLConfig(EGLDisplay display, EGLint format, EGLint renderableType,
		EGLConfig* config) {
		// select our EGLConfig. It must support EGL_RECORDABLE_ANDROID if
		// it is to be used with WIFI displays
		status_t err;
		EGLint wantedAttribute;
		EGLint wantedAttributeValue;

		EGLAttributeVector attribs;
		if (renderableType) {
		attribs[EGL_RENDERABLE_TYPE] = renderableType;
		attribs[EGL_RECORDABLE_ANDROID] = EGL_TRUE;
		attribs[EGL_SURFACE_TYPE] = EGL_WINDOW_BIT \| EGL_PBUFFER_BIT;
		attribs[EGL_FRAMEBUFFER_TARGET_ANDROID] = EGL_TRUE;
		attribs[EGL_RED_SIZE] = 8;
		attribs[EGL_GREEN_SIZE] = 8;
		attribs[EGL_BLUE_SIZE] = 8;
		attribs[EGL_ALPHA_SIZE] = 8;
		wantedAttribute = EGL_NONE;
		wantedAttributeValue = EGL_NONE;
		} else {
		// if no renderable type specified, fallback to a simplified query
		wantedAttribute = EGL_NATIVE_VISUAL_ID;
		wantedAttributeValue = format;
		}

		err = selectConfigForAttribute(display, attribs, wantedAttribute, wantedAttributeValue, config);
		if (err == NO_ERROR) {
		EGLint caveat;
		if (eglGetConfigAttrib(display, *config, EGL_CONFIG_CAVEAT, &caveat))
		ALOGW_IF(caveat == EGL_SLOW_CONFIG, "EGL_SLOW_CONFIG selected!");
		}

		return err;
		}

		EGLConfig RenderEngine::chooseEglConfig(EGLDisplay display, int format, bool logConfig) {
		status_t err;
		EGLConfig config;

		// First try to get an ES2 config
		err = selectEGLConfig(display, format, EGL_OPENGL_ES2_BIT, &config);
		if (err != NO_ERROR) {
		// If ES2 fails, try ES1
		err = selectEGLConfig(display, format, EGL_OPENGL_ES_BIT, &config);
		if (err != NO_ERROR) {
		// still didn't work, probably because we're on the emulator...
		// try a simplified query
		ALOGW("no suitable EGLConfig found, trying a simpler query");
		err = selectEGLConfig(display, format, 0, &config);
		if (err != NO_ERROR) {
		// this EGL is too lame for android
		LOG_ALWAYS_FATAL("no suitable EGLConfig found, giving up");
		}
		}
		}

		if (logConfig) {
		// print some debugging info
		EGLint r, g, b, a;
		eglGetConfigAttrib(display, config, EGL_RED_SIZE, &r);
		eglGetConfigAttrib(display, config, EGL_GREEN_SIZE, &g);
		eglGetConfigAttrib(display, config, EGL_BLUE_SIZE, &b);
		eglGetConfigAttrib(display, config, EGL_ALPHA_SIZE, &a);
		ALOGI("EGL information:");
		ALOGI("vendor : %s", eglQueryString(display, EGL_VENDOR));
		ALOGI("version : %s", eglQueryString(display, EGL_VERSION));
		ALOGI("extensions: %s", eglQueryString(display, EGL_EXTENSIONS));
		ALOGI("Client API: %s", eglQueryString(display, EGL_CLIENT_APIS) ?: "Not Supported");
		ALOGI("EGLSurface: %d-%d-%d-%d, config=%p", r, g, b, a, config);
		}

		return config;
		}

		} // namespace impl
		} // namespace renderengine
		} // namespace android

services/surfaceflinger/RenderEngine/gl/GLES20RenderEngine.cpp

+295 −8

File changed.

Preview size limit exceeded, changes collapsed.

services/surfaceflinger/RenderEngine/gl/GLES20RenderEngine.h

+31 −7

Original line number	Diff line number	Diff line
		@@ -20,10 +20,14 @@
		#include <stdint.h>
		#include <sys/types.h>

		#include <EGL/egl.h>
		#include <EGL/eglext.h>
		#include <GLES2/gl2.h>
		#include <renderengine/RenderEngine.h>
		#include <renderengine/private/Description.h>

		#define EGL_NO_CONFIG ((EGLConfig)0)

		namespace android {

		class String8;
		@@ -40,6 +44,9 @@ class GLSurface;

		class GLES20RenderEngine : public impl::RenderEngine {
		public:
		static std::unique_ptr<GLES20RenderEngine> create(int hwcFormat, uint32_t featureFlags);
		static EGLConfig chooseEglConfig(EGLDisplay display, int format, bool logConfig);

		GLES20RenderEngine(uint32_t featureFlags); // See RenderEngine::FeatureFlag
		~GLES20RenderEngine() override;

		@@ -67,19 +74,16 @@ public:
		void unbindFrameBuffer(Framebuffer* framebuffer) override;
		void checkErrors() const override;

		// internal to RenderEngine
		EGLDisplay getEGLDisplay() const { return mEGLDisplay; }
		EGLConfig getEGLConfig() const { return mEGLConfig; }

		protected:
		void dump(String8& result) override;
		void setViewportAndProjection(size_t vpw, size_t vph, Rect sourceCrop,
		ui::Transform::orientation_flags rotation) override;
		void setupLayerBlending(bool premultipliedAlpha, bool opaque, bool disableTexture,
		const half4& color) override;

		// Color management related functions and state
		void setSourceY410BT2020(bool enable) override;
		void setSourceDataSpace(ui::Dataspace source) override;
		void setOutputDataSpace(ui::Dataspace dataspace) override;
		void setDisplayMaxLuminance(const float maxLuminance) override;

		void setupLayerTexturing(const Texture& texture) override;
		void setupLayerBlackedOut() override;
		void setupFillWithColor(float r, float g, float b, float a) override;
		@@ -87,17 +91,37 @@ protected:
		void disableTexturing() override;
		void disableBlending() override;

		// HDR and color management related functions and state
		void setSourceY410BT2020(bool enable) override;
		void setSourceDataSpace(ui::Dataspace source) override;
		void setOutputDataSpace(ui::Dataspace dataspace) override;
		void setDisplayMaxLuminance(const float maxLuminance) override;

		// drawing
		void drawMesh(const Mesh& mesh) override;

		size_t getMaxTextureSize() const override;
		size_t getMaxViewportDims() const override;

		private:
		enum GlesVersion {
		GLES_VERSION_1_0 = 0x10000,
		GLES_VERSION_1_1 = 0x10001,
		GLES_VERSION_2_0 = 0x20000,
		GLES_VERSION_3_0 = 0x30000,
		};

		static GlesVersion parseGlesVersion(const char* str);

		// A data space is considered HDR data space if it has BT2020 color space
		// with PQ or HLG transfer function.
		bool isHdrDataSpace(const ui::Dataspace dataSpace) const;
		bool needsXYZTransformMatrix() const;
		void setEGLHandles(EGLDisplay display, EGLConfig config, EGLContext ctxt);

		EGLDisplay mEGLDisplay;
		EGLConfig mEGLConfig;
		EGLContext mEGLContext;
		GLuint mProtectedTexName;
		GLint mMaxViewportDims[2];
		GLint mMaxTextureSize;

services/surfaceflinger/RenderEngine/include/renderengine/RenderEngine.h

+6 −29

Original line number	Diff line number	Diff line
		@@ -59,6 +59,8 @@ public:
		USE_HIGH_PRIORITY_CONTEXT = 1 << 1, // Use high priority context
		};

		static std::unique_ptr<impl::RenderEngine> create(int hwcFormat, uint32_t featureFlags);

		virtual ~RenderEngine() = 0;

		virtual std::unique_ptr<Framebuffer> createFramebuffer() = 0;
		@@ -155,43 +157,18 @@ private:

		namespace impl {

		// impl::RenderEngine contains common implementation that is graphics back-end agnostic.
		class RenderEngine : public renderengine::RenderEngine {
		protected:
		enum GlesVersion {
		GLES_VERSION_1_0 = 0x10000,
		GLES_VERSION_1_1 = 0x10001,
		GLES_VERSION_2_0 = 0x20000,
		GLES_VERSION_3_0 = 0x30000,
		};
		static GlesVersion parseGlesVersion(const char* str);

		EGLDisplay mEGLDisplay;
		EGLConfig mEGLConfig;
		EGLContext mEGLContext;
		void setEGLHandles(EGLDisplay display, EGLConfig config, EGLContext ctxt);

		RenderEngine(uint32_t featureFlags);

		const uint32_t mFeatureFlags;

		public:
		virtual ~RenderEngine() = 0;

		static std::unique_ptr<RenderEngine> create(int hwcFormat, uint32_t featureFlags);

		static EGLConfig chooseEglConfig(EGLDisplay display, int format, bool logConfig);

		// dump the extension strings. always call the base class.
		void dump(String8& result) override;

		bool useNativeFenceSync() const override;
		bool useWaitSync() const override;

		void setupColorTransform(const mat4& /* colorTransform */) override {}

		// internal to RenderEngine
		EGLDisplay getEGLDisplay() const;
		EGLConfig getEGLConfig() const;
		protected:
		RenderEngine(uint32_t featureFlags);
		const uint32_t mFeatureFlags;
		};

		} // namespace impl

services/surfaceflinger/SurfaceFlinger.cpp

+2 −2

Original line number	Diff line number	Diff line
		@@ -667,7 +667,7 @@ void SurfaceFlinger::init() {

		// TODO(b/77156734): We need to stop casting and use HAL types when possible.
		getBE().mRenderEngine =
		renderengine::impl::RenderEngine::create(static_cast<int32_t>(compositionPixelFormat),
		renderengine::RenderEngine::create(static_cast<int32_t>(compositionPixelFormat),
		renderEngineFeature);
		LOG_ALWAYS_FATAL_IF(getBE().mRenderEngine == nullptr, "couldn't create RenderEngine");