Merge "[RenderEngine] Create GLES 3 RenderEngine." (2fe9f86d) · Commits · e / os / android_frameworks_native

libs/renderengine/Android.bp

+1 −1

Original line number	Original line	Diff line number	Diff line
	@@ -46,7 +46,7 @@ filegroup {
	filegroup {		filegroup {
	name: "librenderengine_gl_sources",		name: "librenderengine_gl_sources",
	srcs: [		srcs: [
	"gl/GLES20RenderEngine.cpp",		"gl/GLESRenderEngine.cpp",
	"gl/GLExtensions.cpp",		"gl/GLExtensions.cpp",
	"gl/GLFramebuffer.cpp",		"gl/GLFramebuffer.cpp",
	"gl/GLImage.cpp",		"gl/GLImage.cpp",

libs/renderengine/RenderEngine.cpp

+3 −3

Original line number	Original line	Diff line number	Diff line
	@@ -19,7 +19,7 @@
	#include <cutils/properties.h>		#include <cutils/properties.h>
	#include <log/log.h>		#include <log/log.h>
	#include <private/gui/SyncFeatures.h>		#include <private/gui/SyncFeatures.h>
	#include "gl/GLES20RenderEngine.h"		#include "gl/GLESRenderEngine.h"

	namespace android {		namespace android {
	namespace renderengine {		namespace renderengine {
	@@ -29,10 +29,10 @@ std::unique_ptr<impl::RenderEngine> RenderEngine::create(int hwcFormat, uint32_t
	property_get(PROPERTY_DEBUG_RENDERENGINE_BACKEND, prop, "gles");		property_get(PROPERTY_DEBUG_RENDERENGINE_BACKEND, prop, "gles");
	if (strcmp(prop, "gles") == 0) {		if (strcmp(prop, "gles") == 0) {
	ALOGD("RenderEngine GLES Backend");		ALOGD("RenderEngine GLES Backend");
	return renderengine::gl::GLES20RenderEngine::create(hwcFormat, featureFlags);		return renderengine::gl::GLESRenderEngine::create(hwcFormat, featureFlags);
	}		}
	ALOGE("UNKNOWN BackendType: %s, create GLES RenderEngine.", prop);		ALOGE("UNKNOWN BackendType: %s, create GLES RenderEngine.", prop);
	return renderengine::gl::GLES20RenderEngine::create(hwcFormat, featureFlags);		return renderengine::gl::GLESRenderEngine::create(hwcFormat, featureFlags);
	}		}

	RenderEngine::~RenderEngine() = default;		RenderEngine::~RenderEngine() = default;

libs/renderengine/gl/GLES20RenderEngine.cpp→libs/renderengine/gl/GLESRenderEngine.cpp

+80 −67

Original line number	Original line	Diff line number	Diff line
	@@ -19,7 +19,7 @@
	#define LOG_TAG "RenderEngine"		#define LOG_TAG "RenderEngine"
	#define ATRACE_TAG ATRACE_TAG_GRAPHICS		#define ATRACE_TAG ATRACE_TAG_GRAPHICS

	#include "GLES20RenderEngine.h"		#include "GLESRenderEngine.h"

	#include <math.h>		#include <math.h>
	#include <fstream>		#include <fstream>
	@@ -221,8 +221,7 @@ static status_t selectEGLConfig(EGLDisplay display, EGLint format, EGLint render
	return err;		return err;
	}		}

	std::unique_ptr<GLES20RenderEngine> GLES20RenderEngine::create(int hwcFormat,		std::unique_ptr<GLESRenderEngine> GLESRenderEngine::create(int hwcFormat, uint32_t featureFlags) {
	uint32_t featureFlags) {
	// initialize EGL for the default display		// initialize EGL for the default display
	EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY);		EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
	if (!eglInitialize(display, nullptr, nullptr)) {		if (!eglInitialize(display, nullptr, nullptr)) {
	@@ -263,7 +262,7 @@ std::unique_ptr<GLES20RenderEngine> GLES20RenderEngine::create(int hwcFormat,
	GlesVersion version = parseGlesVersion(extensions.getVersion());		GlesVersion version = parseGlesVersion(extensions.getVersion());

	// initialize the renderer while GL is current		// initialize the renderer while GL is current
	std::unique_ptr<GLES20RenderEngine> engine;		std::unique_ptr<GLESRenderEngine> engine;
	switch (version) {		switch (version) {
	case GLES_VERSION_1_0:		case GLES_VERSION_1_0:
	case GLES_VERSION_1_1:		case GLES_VERSION_1_1:
	@@ -271,8 +270,7 @@ std::unique_ptr<GLES20RenderEngine> GLES20RenderEngine::create(int hwcFormat,
	break;		break;
	case GLES_VERSION_2_0:		case GLES_VERSION_2_0:
	case GLES_VERSION_3_0:		case GLES_VERSION_3_0:
	engine = std::make_unique<GLES20RenderEngine>(featureFlags, display, config, ctxt,		engine = std::make_unique<GLESRenderEngine>(featureFlags, display, config, ctxt, dummy);
	dummy);
	break;		break;
	}		}

	@@ -287,17 +285,17 @@ std::unique_ptr<GLES20RenderEngine> GLES20RenderEngine::create(int hwcFormat,
	return engine;		return engine;
	}		}

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

	// First try to get an ES2 config		// First try to get an ES3 config
	err = selectEGLConfig(display, format, EGL_OPENGL_ES2_BIT, &config);		err = selectEGLConfig(display, format, EGL_OPENGL_ES3_BIT, &config);
	if (err != NO_ERROR) {		if (err != NO_ERROR) {
	// If ES2 fails, try ES1		// If ES3 fails, try to get an ES2 config
	err = selectEGLConfig(display, format, EGL_OPENGL_ES_BIT, &config);		err = selectEGLConfig(display, format, EGL_OPENGL_ES2_BIT, &config);
	if (err != NO_ERROR) {		if (err != NO_ERROR) {
	// still didn't work, probably because we're on the emulator...		// If ES2 still doesn't work, probably because we're on the emulator.
	// try a simplified query		// try a simplified query
	ALOGW("no suitable EGLConfig found, trying a simpler query");		ALOGW("no suitable EGLConfig found, trying a simpler query");
	err = selectEGLConfig(display, format, 0, &config);		err = selectEGLConfig(display, format, 0, &config);
	@@ -326,7 +324,7 @@ EGLConfig GLES20RenderEngine::chooseEglConfig(EGLDisplay display, int format, bo
	return config;		return config;
	}		}

	GLES20RenderEngine::GLES20RenderEngine(uint32_t featureFlags, EGLDisplay display, EGLConfig config,		GLESRenderEngine::GLESRenderEngine(uint32_t featureFlags, EGLDisplay display, EGLConfig config,
	EGLContext ctxt, EGLSurface dummy)		EGLContext ctxt, EGLSurface dummy)
	: renderengine::impl::RenderEngine(featureFlags),		: renderengine::impl::RenderEngine(featureFlags),
	mEGLDisplay(display),		mEGLDisplay(display),
	@@ -382,28 +380,28 @@ GLES20RenderEngine::GLES20RenderEngine(uint32_t featureFlags, EGLDisplay display
	}		}
	}		}

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

	std::unique_ptr<Framebuffer> GLES20RenderEngine::createFramebuffer() {		std::unique_ptr<Framebuffer> GLESRenderEngine::createFramebuffer() {
	return std::make_unique<GLFramebuffer>(*this);		return std::make_unique<GLFramebuffer>(*this);
	}		}

	std::unique_ptr<Image> GLES20RenderEngine::createImage() {		std::unique_ptr<Image> GLESRenderEngine::createImage() {
	return std::make_unique<GLImage>(*this);		return std::make_unique<GLImage>(*this);
	}		}

	void GLES20RenderEngine::primeCache() const {		void GLESRenderEngine::primeCache() const {
	ProgramCache::getInstance().primeCache(mFeatureFlags & USE_COLOR_MANAGEMENT);		ProgramCache::getInstance().primeCache(mFeatureFlags & USE_COLOR_MANAGEMENT);
	}		}

	bool GLES20RenderEngine::isCurrent() const {		bool GLESRenderEngine::isCurrent() const {
	return mEGLDisplay == eglGetCurrentDisplay() && mEGLContext == eglGetCurrentContext();		return mEGLDisplay == eglGetCurrentDisplay() && mEGLContext == eglGetCurrentContext();
	}		}

	base::unique_fd GLES20RenderEngine::flush() {		base::unique_fd GLESRenderEngine::flush() {
	if (!GLExtensions::getInstance().hasNativeFenceSync()) {		if (!GLExtensions::getInstance().hasNativeFenceSync()) {
	return base::unique_fd();		return base::unique_fd();
	}		}
	@@ -427,7 +425,7 @@ base::unique_fd GLES20RenderEngine::flush() {
	return fenceFd;		return fenceFd;
	}		}

	bool GLES20RenderEngine::finish() {		bool GLESRenderEngine::finish() {
	if (!GLExtensions::getInstance().hasFenceSync()) {		if (!GLExtensions::getInstance().hasFenceSync()) {
	ALOGW("no synchronization support");		ALOGW("no synchronization support");
	return false;		return false;
	@@ -455,7 +453,7 @@ bool GLES20RenderEngine::finish() {
	return true;		return true;
	}		}

	bool GLES20RenderEngine::waitFence(base::unique_fd fenceFd) {		bool GLESRenderEngine::waitFence(base::unique_fd fenceFd) {
	if (!GLExtensions::getInstance().hasNativeFenceSync() \|\|		if (!GLExtensions::getInstance().hasNativeFenceSync() \|\|
	!GLExtensions::getInstance().hasWaitSync()) {		!GLExtensions::getInstance().hasWaitSync()) {
	return false;		return false;
	@@ -485,13 +483,13 @@ bool GLES20RenderEngine::waitFence(base::unique_fd fenceFd) {
	return true;		return true;
	}		}

	void GLES20RenderEngine::clearWithColor(float red, float green, float blue, float alpha) {		void GLESRenderEngine::clearWithColor(float red, float green, float blue, float alpha) {
	glClearColor(red, green, blue, alpha);		glClearColor(red, green, blue, alpha);
	glClear(GL_COLOR_BUFFER_BIT);		glClear(GL_COLOR_BUFFER_BIT);
	}		}

	void GLES20RenderEngine::fillRegionWithColor(const Region& region, float red, float green,		void GLESRenderEngine::fillRegionWithColor(const Region& region, float red, float green, float blue,
	float blue, float alpha) {		float alpha) {
	size_t c;		size_t c;
	Rect const* r = region.getArray(&c);		Rect const* r = region.getArray(&c);
	Mesh mesh(Mesh::TRIANGLES, c * 6, 2);		Mesh mesh(Mesh::TRIANGLES, c * 6, 2);
	@@ -514,7 +512,7 @@ void GLES20RenderEngine::fillRegionWithColor(const Region& region, float red, fl
	drawMesh(mesh);		drawMesh(mesh);
	}		}

	void GLES20RenderEngine::setScissor(const Rect& region) {		void GLESRenderEngine::setScissor(const Rect& region) {
	// Invert y-coordinate to map to GL-space.		// Invert y-coordinate to map to GL-space.
	int32_t canvasHeight = mFboHeight;		int32_t canvasHeight = mFboHeight;
	int32_t glBottom = canvasHeight - region.bottom;		int32_t glBottom = canvasHeight - region.bottom;
	@@ -523,19 +521,19 @@ void GLES20RenderEngine::setScissor(const Rect& region) {
	glEnable(GL_SCISSOR_TEST);		glEnable(GL_SCISSOR_TEST);
	}		}

	void GLES20RenderEngine::disableScissor() {		void GLESRenderEngine::disableScissor() {
	glDisable(GL_SCISSOR_TEST);		glDisable(GL_SCISSOR_TEST);
	}		}

	void GLES20RenderEngine::genTextures(size_t count, uint32_t* names) {		void GLESRenderEngine::genTextures(size_t count, uint32_t* names) {
	glGenTextures(count, names);		glGenTextures(count, names);
	}		}

	void GLES20RenderEngine::deleteTextures(size_t count, uint32_t const* names) {		void GLESRenderEngine::deleteTextures(size_t count, uint32_t const* names) {
	glDeleteTextures(count, names);		glDeleteTextures(count, names);
	}		}

	void GLES20RenderEngine::bindExternalTextureImage(uint32_t texName, const Image& image) {		void GLESRenderEngine::bindExternalTextureImage(uint32_t texName, const Image& image) {
	const GLImage& glImage = static_cast<const GLImage&>(image);		const GLImage& glImage = static_cast<const GLImage&>(image);
	const GLenum target = GL_TEXTURE_EXTERNAL_OES;		const GLenum target = GL_TEXTURE_EXTERNAL_OES;

	@@ -545,7 +543,7 @@ void GLES20RenderEngine::bindExternalTextureImage(uint32_t texName, const Image&
	}		}
	}		}

	status_t GLES20RenderEngine::bindFrameBuffer(Framebuffer* framebuffer) {		status_t GLESRenderEngine::bindFrameBuffer(Framebuffer* framebuffer) {
	GLFramebuffer* glFramebuffer = static_cast<GLFramebuffer*>(framebuffer);		GLFramebuffer* glFramebuffer = static_cast<GLFramebuffer*>(framebuffer);
	EGLImageKHR eglImage = glFramebuffer->getEGLImage();		EGLImageKHR eglImage = glFramebuffer->getEGLImage();
	uint32_t textureName = glFramebuffer->getTextureName();		uint32_t textureName = glFramebuffer->getTextureName();
	@@ -569,14 +567,14 @@ status_t GLES20RenderEngine::bindFrameBuffer(Framebuffer* framebuffer) {
	return glStatus == GL_FRAMEBUFFER_COMPLETE_OES ? NO_ERROR : BAD_VALUE;		return glStatus == GL_FRAMEBUFFER_COMPLETE_OES ? NO_ERROR : BAD_VALUE;
	}		}

	void GLES20RenderEngine::unbindFrameBuffer(Framebuffer* /* framebuffer */) {		void GLESRenderEngine::unbindFrameBuffer(Framebuffer* /* framebuffer */) {
	mFboHeight = 0;		mFboHeight = 0;

	// back to main framebuffer		// back to main framebuffer
	glBindFramebuffer(GL_FRAMEBUFFER, 0);		glBindFramebuffer(GL_FRAMEBUFFER, 0);
	}		}

	void GLES20RenderEngine::checkErrors() const {		void GLESRenderEngine::checkErrors() const {
	do {		do {
	// there could be more than one error flag		// there could be more than one error flag
	GLenum error = glGetError();		GLenum error = glGetError();
	@@ -585,14 +583,14 @@ void GLES20RenderEngine::checkErrors() const {
	} while (true);		} while (true);
	}		}

	status_t GLES20RenderEngine::drawLayers(const DisplaySettings& /settings/,		status_t GLESRenderEngine::drawLayers(const DisplaySettings& /settings/,
	const std::vector<LayerSettings>& /layers/,		const std::vector<LayerSettings>& /layers/,
	ANativeWindowBuffer* const /buffer/,		ANativeWindowBuffer* const /buffer/,
	base::unique_fd* /displayFence/) const {		base::unique_fd* /displayFence/) const {
	return NO_ERROR;		return NO_ERROR;
	}		}

	void GLES20RenderEngine::setViewportAndProjection(size_t vpw, size_t vph, Rect sourceCrop,		void GLESRenderEngine::setViewportAndProjection(size_t vpw, size_t vph, Rect sourceCrop,
	ui::Transform::orientation_flags rotation) {		ui::Transform::orientation_flags rotation) {
	int32_t l = sourceCrop.left;		int32_t l = sourceCrop.left;
	int32_t r = sourceCrop.right;		int32_t r = sourceCrop.right;
	@@ -625,9 +623,8 @@ void GLES20RenderEngine::setViewportAndProjection(size_t vpw, size_t vph, Rect s
	mVpHeight = vph;		mVpHeight = vph;
	}		}

	void GLES20RenderEngine::setupLayerBlending(bool premultipliedAlpha, bool opaque,		void GLESRenderEngine::setupLayerBlending(bool premultipliedAlpha, bool opaque, bool disableTexture,
	bool disableTexture, const half4& color,		const half4& color, float cornerRadius) {
	float cornerRadius) {
	mState.isPremultipliedAlpha = premultipliedAlpha;		mState.isPremultipliedAlpha = premultipliedAlpha;
	mState.isOpaque = opaque;		mState.isOpaque = opaque;
	mState.color = color;		mState.color = color;
	@@ -645,23 +642,23 @@ void GLES20RenderEngine::setupLayerBlending(bool premultipliedAlpha, bool opaque
	}		}
	}		}

	void GLES20RenderEngine::setSourceY410BT2020(bool enable) {		void GLESRenderEngine::setSourceY410BT2020(bool enable) {
	mState.isY410BT2020 = enable;		mState.isY410BT2020 = enable;
	}		}

	void GLES20RenderEngine::setSourceDataSpace(Dataspace source) {		void GLESRenderEngine::setSourceDataSpace(Dataspace source) {
	mDataSpace = source;		mDataSpace = source;
	}		}

	void GLES20RenderEngine::setOutputDataSpace(Dataspace dataspace) {		void GLESRenderEngine::setOutputDataSpace(Dataspace dataspace) {
	mOutputDataSpace = dataspace;		mOutputDataSpace = dataspace;
	}		}

	void GLES20RenderEngine::setDisplayMaxLuminance(const float maxLuminance) {		void GLESRenderEngine::setDisplayMaxLuminance(const float maxLuminance) {
	mState.displayMaxLuminance = maxLuminance;		mState.displayMaxLuminance = maxLuminance;
	}		}

	void GLES20RenderEngine::setupLayerTexturing(const Texture& texture) {		void GLESRenderEngine::setupLayerTexturing(const Texture& texture) {
	GLuint target = texture.getTextureTarget();		GLuint target = texture.getTextureTarget();
	glBindTexture(target, texture.getTextureName());		glBindTexture(target, texture.getTextureName());
	GLenum filter = GL_NEAREST;		GLenum filter = GL_NEAREST;
	@@ -677,7 +674,7 @@ void GLES20RenderEngine::setupLayerTexturing(const Texture& texture) {
	mState.textureEnabled = true;		mState.textureEnabled = true;
	}		}

	void GLES20RenderEngine::setupLayerBlackedOut() {		void GLESRenderEngine::setupLayerBlackedOut() {
	glBindTexture(GL_TEXTURE_2D, mProtectedTexName);		glBindTexture(GL_TEXTURE_2D, mProtectedTexName);
	Texture texture(Texture::TEXTURE_2D, mProtectedTexName);		Texture texture(Texture::TEXTURE_2D, mProtectedTexName);
	texture.setDimensions(1, 1); // FIXME: we should get that from somewhere		texture.setDimensions(1, 1); // FIXME: we should get that from somewhere
	@@ -685,19 +682,19 @@ void GLES20RenderEngine::setupLayerBlackedOut() {
	mState.textureEnabled = true;		mState.textureEnabled = true;
	}		}

	void GLES20RenderEngine::setColorTransform(const mat4& colorTransform) {		void GLESRenderEngine::setColorTransform(const mat4& colorTransform) {
	mState.colorMatrix = colorTransform;		mState.colorMatrix = colorTransform;
	}		}

	void GLES20RenderEngine::disableTexturing() {		void GLESRenderEngine::disableTexturing() {
	mState.textureEnabled = false;		mState.textureEnabled = false;
	}		}

	void GLES20RenderEngine::disableBlending() {		void GLESRenderEngine::disableBlending() {
	glDisable(GL_BLEND);		glDisable(GL_BLEND);
	}		}

	void GLES20RenderEngine::setupFillWithColor(float r, float g, float b, float a) {		void GLESRenderEngine::setupFillWithColor(float r, float g, float b, float a) {
	mState.isPremultipliedAlpha = true;		mState.isPremultipliedAlpha = true;
	mState.isOpaque = false;		mState.isOpaque = false;
	mState.color = half4(r, g, b, a);		mState.color = half4(r, g, b, a);
	@@ -705,11 +702,11 @@ void GLES20RenderEngine::setupFillWithColor(float r, float g, float b, float a)
	glDisable(GL_BLEND);		glDisable(GL_BLEND);
	}		}

	void GLES20RenderEngine::setupCornerRadiusCropSize(float width, float height) {		void GLESRenderEngine::setupCornerRadiusCropSize(float width, float height) {
	mState.cropSize = half2(width, height);		mState.cropSize = half2(width, height);
	}		}

	void GLES20RenderEngine::drawMesh(const Mesh& mesh) {		void GLESRenderEngine::drawMesh(const Mesh& mesh) {
	ATRACE_CALL();		ATRACE_CALL();
	if (mesh.getTexCoordsSize()) {		if (mesh.getTexCoordsSize()) {
	glEnableVertexAttribArray(Program::texCoords);		glEnableVertexAttribArray(Program::texCoords);
	@@ -849,15 +846,15 @@ void GLES20RenderEngine::drawMesh(const Mesh& mesh) {
	}		}
	}		}

	size_t GLES20RenderEngine::getMaxTextureSize() const {		size_t GLESRenderEngine::getMaxTextureSize() const {
	return mMaxTextureSize;		return mMaxTextureSize;
	}		}

	size_t GLES20RenderEngine::getMaxViewportDims() const {		size_t GLESRenderEngine::getMaxViewportDims() const {
	return mMaxViewportDims[0] < mMaxViewportDims[1] ? mMaxViewportDims[0] : mMaxViewportDims[1];		return mMaxViewportDims[0] < mMaxViewportDims[1] ? mMaxViewportDims[0] : mMaxViewportDims[1];
	}		}

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

	result.appendFormat("EGL implementation : %s\n", extensions.getEGLVersion());		result.appendFormat("EGL implementation : %s\n", extensions.getEGLVersion());
	@@ -875,7 +872,7 @@ void GLES20RenderEngine::dump(String8& result) {
	dataspaceDetails(static_cast<android_dataspace>(mOutputDataSpace)).c_str());		dataspaceDetails(static_cast<android_dataspace>(mOutputDataSpace)).c_str());
	}		}

	GLES20RenderEngine::GlesVersion GLES20RenderEngine::parseGlesVersion(const char* str) {		GLESRenderEngine::GlesVersion GLESRenderEngine::parseGlesVersion(const char* str) {
	int major, minor;		int major, minor;
	if (sscanf(str, "OpenGL ES-CM %d.%d", &major, &minor) != 2) {		if (sscanf(str, "OpenGL ES-CM %d.%d", &major, &minor) != 2) {
	if (sscanf(str, "OpenGL ES %d.%d", &major, &minor) != 2) {		if (sscanf(str, "OpenGL ES %d.%d", &major, &minor) != 2) {
	@@ -893,16 +890,18 @@ GLES20RenderEngine::GlesVersion GLES20RenderEngine::parseGlesVersion(const char*
	return GLES_VERSION_1_0;		return GLES_VERSION_1_0;
	}		}

	EGLContext GLES20RenderEngine::createEglContext(EGLDisplay display, EGLConfig config,		EGLContext GLESRenderEngine::createEglContext(EGLDisplay display, EGLConfig config,
	EGLContext shareContext, bool useContextPriority) {		EGLContext shareContext, bool useContextPriority) {
	EGLint renderableType = 0;		EGLint renderableType = 0;
	if (config == EGL_NO_CONFIG) {		if (config == EGL_NO_CONFIG) {
	renderableType = EGL_OPENGL_ES2_BIT;		renderableType = EGL_OPENGL_ES3_BIT;
	} else if (!eglGetConfigAttrib(display, config, EGL_RENDERABLE_TYPE, &renderableType)) {		} else if (!eglGetConfigAttrib(display, config, EGL_RENDERABLE_TYPE, &renderableType)) {
	LOG_ALWAYS_FATAL("can't query EGLConfig RENDERABLE_TYPE");		LOG_ALWAYS_FATAL("can't query EGLConfig RENDERABLE_TYPE");
	}		}
	EGLint contextClientVersion = 0;		EGLint contextClientVersion = 0;
	if (renderableType & EGL_OPENGL_ES2_BIT) {		if (renderableType & EGL_OPENGL_ES3_BIT) {
			contextClientVersion = 3;
			} else if (renderableType & EGL_OPENGL_ES2_BIT) {
	contextClientVersion = 2;		contextClientVersion = 2;
	} else if (renderableType & EGL_OPENGL_ES_BIT) {		} else if (renderableType & EGL_OPENGL_ES_BIT) {
	contextClientVersion = 1;		contextClientVersion = 1;
	@@ -920,10 +919,24 @@ EGLContext GLES20RenderEngine::createEglContext(EGLDisplay display, EGLConfig co
	}		}
	contextAttributes.push_back(EGL_NONE);		contextAttributes.push_back(EGL_NONE);

	return eglCreateContext(display, config, shareContext, contextAttributes.data());		EGLContext context = eglCreateContext(display, config, shareContext, contextAttributes.data());

			if (contextClientVersion == 3 && context == EGL_NO_CONTEXT) {
			// eglGetConfigAttrib indicated we can create GLES 3 context, but we failed, thus
			// EGL_NO_CONTEXT so that we can abort.
			if (config != EGL_NO_CONFIG) {
			return context;
			}
			// If \|config\| is EGL_NO_CONFIG, we speculatively try to create GLES 3 context, so we should
			// try to fall back to GLES 2.
			contextAttributes[1] = 2;
			context = eglCreateContext(display, config, shareContext, contextAttributes.data());
			}

			return context;
	}		}

	EGLSurface GLES20RenderEngine::createDummyEglPbufferSurface(EGLDisplay display, EGLConfig config,		EGLSurface GLESRenderEngine::createDummyEglPbufferSurface(EGLDisplay display, EGLConfig config,
	int hwcFormat) {		int hwcFormat) {
	EGLConfig dummyConfig = config;		EGLConfig dummyConfig = config;
	if (dummyConfig == EGL_NO_CONFIG) {		if (dummyConfig == EGL_NO_CONFIG) {
	@@ -940,7 +953,7 @@ EGLSurface GLES20RenderEngine::createDummyEglPbufferSurface(EGLDisplay display,
	return eglCreatePbufferSurface(display, dummyConfig, attributes.data());		return eglCreatePbufferSurface(display, dummyConfig, attributes.data());
	}		}

	bool GLES20RenderEngine::isHdrDataSpace(const Dataspace dataSpace) const {		bool GLESRenderEngine::isHdrDataSpace(const Dataspace dataSpace) const {
	const Dataspace standard = static_cast<Dataspace>(dataSpace & Dataspace::STANDARD_MASK);		const Dataspace standard = static_cast<Dataspace>(dataSpace & Dataspace::STANDARD_MASK);
	const Dataspace transfer = static_cast<Dataspace>(dataSpace & Dataspace::TRANSFER_MASK);		const Dataspace transfer = static_cast<Dataspace>(dataSpace & Dataspace::TRANSFER_MASK);
	return standard == Dataspace::STANDARD_BT2020 &&		return standard == Dataspace::STANDARD_BT2020 &&
	@@ -957,7 +970,7 @@ bool GLES20RenderEngine::isHdrDataSpace(const Dataspace dataSpace) const {
	// input data space or output data space is HDR data space, and the input transfer function		// input data space or output data space is HDR data space, and the input transfer function
	// doesn't match the output transfer function, we would enable an intermediate transfrom to		// doesn't match the output transfer function, we would enable an intermediate transfrom to
	// XYZ color space.		// XYZ color space.
	bool GLES20RenderEngine::needsXYZTransformMatrix() const {		bool GLESRenderEngine::needsXYZTransformMatrix() const {
	const bool isInputHdrDataSpace = isHdrDataSpace(mDataSpace);		const bool isInputHdrDataSpace = isHdrDataSpace(mDataSpace);
	const bool isOutputHdrDataSpace = isHdrDataSpace(mOutputDataSpace);		const bool isOutputHdrDataSpace = isHdrDataSpace(mOutputDataSpace);
	const Dataspace inputTransfer = static_cast<Dataspace>(mDataSpace & Dataspace::TRANSFER_MASK);		const Dataspace inputTransfer = static_cast<Dataspace>(mDataSpace & Dataspace::TRANSFER_MASK);

libs/renderengine/gl/GLES20RenderEngine.h→libs/renderengine/gl/GLESRenderEngine.h

+8 −8

Original line number	Original line	Diff line number	Diff line
	@@ -14,8 +14,8 @@
	* limitations under the License.		* limitations under the License.
	*/		*/

	#ifndef SF_GLES20RENDERENGINE_H_		#ifndef SF_GLESRENDERENGINE_H_
	#define SF_GLES20RENDERENGINE_H_		#define SF_GLESRENDERENGINE_H_

	#include <stdint.h>		#include <stdint.h>
	#include <sys/types.h>		#include <sys/types.h>
	@@ -41,14 +41,14 @@ namespace gl {

	class GLImage;		class GLImage;

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

	GLES20RenderEngine(uint32_t featureFlags, // See RenderEngine::FeatureFlag		GLESRenderEngine(uint32_t featureFlags, // See RenderEngine::FeatureFlag
	EGLDisplay display, EGLConfig config, EGLContext ctxt, EGLSurface dummy);		EGLDisplay display, EGLConfig config, EGLContext ctxt, EGLSurface dummy);
	~GLES20RenderEngine() override;		~GLESRenderEngine() override;

	std::unique_ptr<Framebuffer> createFramebuffer() override;		std::unique_ptr<Framebuffer> createFramebuffer() override;
	std::unique_ptr<Image> createImage() override;		std::unique_ptr<Image> createImage() override;
	@@ -165,4 +165,4 @@ private:
	} // namespace renderengine		} // namespace renderengine
	} // namespace android		} // namespace android

	#endif /* SF_GLES20RENDERENGINE_H_ */		#endif /* SF_GLESRENDERENGINE_H_ */

libs/renderengine/gl/GLFramebuffer.cpp

+2 −2

Original line number	Original line	Diff line number	Diff line
	@@ -21,13 +21,13 @@
	#include <GLES2/gl2.h>		#include <GLES2/gl2.h>
	#include <GLES2/gl2ext.h>		#include <GLES2/gl2ext.h>
	#include <nativebase/nativebase.h>		#include <nativebase/nativebase.h>
	#include "GLES20RenderEngine.h"		#include "GLESRenderEngine.h"

	namespace android {		namespace android {
	namespace renderengine {		namespace renderengine {
	namespace gl {		namespace gl {

	GLFramebuffer::GLFramebuffer(const GLES20RenderEngine& engine)		GLFramebuffer::GLFramebuffer(const GLESRenderEngine& engine)
	: mEGLDisplay(engine.getEGLDisplay()), mEGLImage(EGL_NO_IMAGE_KHR) {		: mEGLDisplay(engine.getEGLDisplay()), mEGLImage(EGL_NO_IMAGE_KHR) {
	glGenTextures(1, &mTextureName);		glGenTextures(1, &mTextureName);
	glGenFramebuffers(1, &mFramebufferName);		glGenFramebuffers(1, &mFramebufferName);