Merge "Revert "Revert "[SurfaceFlinger] Add GPU protected content support.""" (2f48c968) · Commits · e / os / platform_frameworks_native

libs/renderengine/gl/GLESRenderEngine.cpp

+96 −18

Original line number	Diff line number	Diff line
		@@ -242,23 +242,43 @@ std::unique_ptr<GLESRenderEngine> GLESRenderEngine::create(int hwcFormat, uint32

		bool useContextPriority = extensions.hasContextPriority() &&
		(featureFlags & RenderEngine::USE_HIGH_PRIORITY_CONTEXT);
		EGLContext ctxt = createEglContext(display, config, EGL_NO_CONTEXT, useContextPriority);
		EGLContext protectedContext = EGL_NO_CONTEXT;
		if (extensions.hasProtectedContent()) {
		protectedContext = createEglContext(display, config, nullptr, useContextPriority,
		Protection::PROTECTED);
		ALOGE_IF(protectedContext == EGL_NO_CONTEXT, "Can't create protected context");
		}

		EGLContext ctxt = createEglContext(display, config, protectedContext, useContextPriority,
		Protection::UNPROTECTED);

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

		EGLSurface dummy = EGL_NO_SURFACE;
		if (!extensions.hasSurfacelessContext()) {
		dummy = createDummyEglPbufferSurface(display, config, hwcFormat);
		dummy = createDummyEglPbufferSurface(display, config, hwcFormat, Protection::UNPROTECTED);
		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));

		// In order to have protected contents in GPU composition, the OpenGL ES extension
		// GL_EXT_protected_textures must be supported. If it's not supported, reset
		// protected context to EGL_NO_CONTEXT to indicate that protected contents is not supported.
		if (!extensions.hasProtectedTexture()) {
		protectedContext = EGL_NO_CONTEXT;
		}

		EGLSurface protectedDummy = EGL_NO_SURFACE;
		if (protectedContext != EGL_NO_CONTEXT && !extensions.hasSurfacelessContext()) {
		protectedDummy =
		createDummyEglPbufferSurface(display, config, hwcFormat, Protection::PROTECTED);
		ALOGE_IF(protectedDummy == EGL_NO_SURFACE, "can't create protected dummy pbuffer");
		}

		// now figure out what version of GL did we actually get
		GlesVersion version = parseGlesVersion(extensions.getVersion());

		@@ -271,7 +291,8 @@ std::unique_ptr<GLESRenderEngine> GLESRenderEngine::create(int hwcFormat, uint32
		break;
		case GLES_VERSION_2_0:
		case GLES_VERSION_3_0:
		engine = std::make_unique<GLESRenderEngine>(featureFlags, display, config, ctxt, dummy);
		engine = std::make_unique<GLESRenderEngine>(featureFlags, display, config, ctxt, dummy,
		protectedContext, protectedDummy);
		break;
		}

		@@ -326,12 +347,15 @@ EGLConfig GLESRenderEngine::chooseEglConfig(EGLDisplay display, int format, bool
		}

		GLESRenderEngine::GLESRenderEngine(uint32_t featureFlags, EGLDisplay display, EGLConfig config,
		EGLContext ctxt, EGLSurface dummy)
		EGLContext ctxt, EGLSurface dummy, EGLContext protectedContext,
		EGLSurface protectedDummy)
		: renderengine::impl::RenderEngine(featureFlags),
		mEGLDisplay(display),
		mEGLConfig(config),
		mEGLContext(ctxt),
		mDummySurface(dummy),
		mProtectedEGLContext(protectedContext),
		mProtectedDummySurface(protectedDummy),
		mVpWidth(0),
		mVpHeight(0),
		mUseColorManagement(featureFlags & USE_COLOR_MANAGEMENT) {
		@@ -341,6 +365,17 @@ GLESRenderEngine::GLESRenderEngine(uint32_t featureFlags, EGLDisplay display, EG
		glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
		glPixelStorei(GL_PACK_ALIGNMENT, 4);

		// Initialize protected EGL Context.
		if (mProtectedEGLContext != EGL_NO_CONTEXT) {
		EGLBoolean success = eglMakeCurrent(display, mProtectedDummySurface, mProtectedDummySurface,
		mProtectedEGLContext);
		ALOGE_IF(!success, "can't make protected context current");
		glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
		glPixelStorei(GL_PACK_ALIGNMENT, 4);
		success = eglMakeCurrent(display, mDummySurface, mDummySurface, mEGLContext);
		LOG_ALWAYS_FATAL_IF(!success, "can't make default context current");
		}

		const uint16_t protTexData[] = {0};
		glGenTextures(1, &mProtectedTexName);
		glBindTexture(GL_TEXTURE_2D, mProtectedTexName);
		@@ -395,7 +430,8 @@ std::unique_ptr<Image> GLESRenderEngine::createImage() {
		}

		void GLESRenderEngine::primeCache() const {
		ProgramCache::getInstance().primeCache(mFeatureFlags & USE_COLOR_MANAGEMENT);
		ProgramCache::getInstance().primeCache(mInProtectedContext ? mProtectedEGLContext : mEGLContext,
		mFeatureFlags & USE_COLOR_MANAGEMENT);
		}

		bool GLESRenderEngine::isCurrent() const {
		@@ -539,6 +575,10 @@ void GLESRenderEngine::bindExternalTextureImage(uint32_t texName, const Image& i
		const GLenum target = GL_TEXTURE_EXTERNAL_OES;

		glBindTexture(target, texName);
		if (supportsProtectedContent()) {
		glTexParameteri(target, GL_TEXTURE_PROTECTED_EXT,
		glImage.isProtected() ? GL_TRUE : GL_FALSE);
		}
		if (glImage.getEGLImage() != EGL_NO_IMAGE_KHR) {
		glEGLImageTargetTexture2DOES(target, static_cast<GLeglImageOES>(glImage.getEGLImage()));
		}
		@@ -552,6 +592,10 @@ status_t GLESRenderEngine::bindFrameBuffer(Framebuffer* framebuffer) {

		// Bind the texture and turn our EGLImage into a texture
		glBindTexture(GL_TEXTURE_2D, textureName);
		if (supportsProtectedContent()) {
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_PROTECTED_EXT,
		mInProtectedContext ? GL_TRUE : GL_FALSE);
		}
		glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, (GLeglImageOES)eglImage);

		// Bind the Framebuffer to render into
		@@ -584,6 +628,26 @@ void GLESRenderEngine::checkErrors() const {
		} while (true);
		}

		bool GLESRenderEngine::supportsProtectedContent() const {
		return mProtectedEGLContext != EGL_NO_CONTEXT;
		}

		bool GLESRenderEngine::useProtectedContext(bool useProtectedContext) {
		if (useProtectedContext == mInProtectedContext) {
		return true;
		}
		if (useProtectedContext && mProtectedEGLContext == EGL_NO_CONTEXT) {
		return false;
		}
		const EGLSurface surface = useProtectedContext ? mProtectedDummySurface : mDummySurface;
		const EGLContext context = useProtectedContext ? mProtectedEGLContext : mEGLContext;
		const bool success = eglMakeCurrent(mEGLDisplay, surface, surface, context) == EGL_TRUE;
		if (success) {
		mInProtectedContext = useProtectedContext;
		}
		return success;
		}

		status_t GLESRenderEngine::drawLayers(const DisplaySettings& /settings/,
		const std::vector<LayerSettings>& /layers/,
		ANativeWindowBuffer* const /buffer/,
		@@ -822,7 +886,9 @@ void GLESRenderEngine::drawMesh(const Mesh& mesh) {
		Description::dataSpaceToTransferFunction(outputTransfer);
		}

		ProgramCache::getInstance().useProgram(managedState);
		ProgramCache::getInstance().useProgram(mInProtectedContext ? mProtectedEGLContext
		: mEGLContext,
		managedState);

		glDrawArrays(mesh.getPrimitive(), 0, mesh.getVertexCount());

		@@ -833,7 +899,9 @@ void GLESRenderEngine::drawMesh(const Mesh& mesh) {
		writePPM(out.str().c_str(), mVpWidth, mVpHeight);
		}
		} else {
		ProgramCache::getInstance().useProgram(mState);
		ProgramCache::getInstance().useProgram(mInProtectedContext ? mProtectedEGLContext
		: mEGLContext,
		mState);

		glDrawArrays(mesh.getPrimitive(), 0, mesh.getVertexCount());
		}
		@@ -857,17 +925,18 @@ size_t GLESRenderEngine::getMaxViewportDims() const {

		void GLESRenderEngine::dump(std::string& result) {
		const GLExtensions& extensions = GLExtensions::getInstance();
		ProgramCache& cache = ProgramCache::getInstance();

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

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

		StringAppendF(&result, "RenderEngine program cache size: %zu\n",
		ProgramCache::getInstance().getSize());

		StringAppendF(&result, "RenderEngine is in protected context : %d\n", mInProtectedContext);
		StringAppendF(&result, "RenderEngine program cache size for unprotected context: %zu\n",
		cache.getSize(mEGLContext));
		StringAppendF(&result, "RenderEngine program cache size for protected context: %zu\n",
		cache.getSize(mProtectedEGLContext));
		StringAppendF(&result, "RenderEngine last dataspace conversion: (%s) to (%s)\n",
		dataspaceDetails(static_cast<android_dataspace>(mDataSpace)).c_str(),
		dataspaceDetails(static_cast<android_dataspace>(mOutputDataSpace)).c_str());
		@@ -892,7 +961,8 @@ GLESRenderEngine::GlesVersion GLESRenderEngine::parseGlesVersion(const char* str
		}

		EGLContext GLESRenderEngine::createEglContext(EGLDisplay display, EGLConfig config,
		EGLContext shareContext, bool useContextPriority) {
		EGLContext shareContext, bool useContextPriority,
		Protection protection) {
		EGLint renderableType = 0;
		if (config == EGL_NO_CONFIG) {
		renderableType = EGL_OPENGL_ES3_BIT;
		@@ -911,13 +981,17 @@ EGLContext GLESRenderEngine::createEglContext(EGLDisplay display, EGLConfig conf
		}

		std::vector<EGLint> contextAttributes;
		contextAttributes.reserve(5);
		contextAttributes.reserve(7);
		contextAttributes.push_back(EGL_CONTEXT_CLIENT_VERSION);
		contextAttributes.push_back(contextClientVersion);
		if (useContextPriority) {
		contextAttributes.push_back(EGL_CONTEXT_PRIORITY_LEVEL_IMG);
		contextAttributes.push_back(EGL_CONTEXT_PRIORITY_HIGH_IMG);
		}
		if (protection == Protection::PROTECTED) {
		contextAttributes.push_back(EGL_PROTECTED_CONTENT_EXT);
		contextAttributes.push_back(EGL_TRUE);
		}
		contextAttributes.push_back(EGL_NONE);

		EGLContext context = eglCreateContext(display, config, shareContext, contextAttributes.data());
		@@ -938,17 +1012,21 @@ EGLContext GLESRenderEngine::createEglContext(EGLDisplay display, EGLConfig conf
		}

		EGLSurface GLESRenderEngine::createDummyEglPbufferSurface(EGLDisplay display, EGLConfig config,
		int hwcFormat) {
		int hwcFormat, Protection protection) {
		EGLConfig dummyConfig = config;
		if (dummyConfig == EGL_NO_CONFIG) {
		dummyConfig = chooseEglConfig(display, hwcFormat, /logConfig/ true);
		}
		std::vector<EGLint> attributes;
		attributes.reserve(5);
		attributes.reserve(7);
		attributes.push_back(EGL_WIDTH);
		attributes.push_back(1);
		attributes.push_back(EGL_HEIGHT);
		attributes.push_back(1);
		if (protection == Protection::PROTECTED) {
		attributes.push_back(EGL_PROTECTED_CONTENT_EXT);
		attributes.push_back(EGL_TRUE);
		}
		attributes.push_back(EGL_NONE);

		return eglCreatePbufferSurface(display, dummyConfig, attributes.data());

libs/renderengine/gl/GLESRenderEngine.h

+11 −4

Original line number	Diff line number	Diff line
		@@ -45,7 +45,8 @@ public:
		static EGLConfig chooseEglConfig(EGLDisplay display, int format, bool logConfig);

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

		std::unique_ptr<Framebuffer> createFramebuffer() override;
		@@ -68,6 +69,9 @@ public:
		void unbindFrameBuffer(Framebuffer* framebuffer) override;
		void checkErrors() const override;

		bool isProtected() const override { return mInProtectedContext; }
		bool supportsProtectedContent() const override;
		bool useProtectedContext(bool useProtectedContext) override;
		status_t drawLayers(const DisplaySettings& settings, const std::vector<LayerSettings>& layers,
		ANativeWindowBuffer* const buffer,
		base::unique_fd* displayFence) const override;
		@@ -112,20 +116,22 @@ private:

		static GlesVersion parseGlesVersion(const char* str);
		static EGLContext createEglContext(EGLDisplay display, EGLConfig config,
		EGLContext shareContext, bool useContextPriority);
		EGLContext shareContext, bool useContextPriority,
		Protection protection);
		static EGLSurface createDummyEglPbufferSurface(EGLDisplay display, EGLConfig config,
		int hwcFormat);
		int hwcFormat, Protection protection);

		// 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, EGLSurface dummy);

		EGLDisplay mEGLDisplay;
		EGLConfig mEGLConfig;
		EGLContext mEGLContext;
		EGLSurface mDummySurface;
		EGLContext mProtectedEGLContext;
		EGLSurface mProtectedDummySurface;
		GLuint mProtectedTexName;
		GLint mMaxViewportDims[2];
		GLint mMaxTextureSize;
		@@ -146,6 +152,7 @@ private:
		mat4 mBt2020ToSrgb;
		mat4 mBt2020ToDisplayP3;

		bool mInProtectedContext = false;
		int32_t mFboHeight = 0;

		// Current dataspace of layer being rendered

libs/renderengine/gl/GLExtensions.cpp

+5 −0

Original line number	Diff line number	Diff line
		@@ -60,6 +60,11 @@ void GLExtensions::initWithGLStrings(GLubyte const* vendor, GLubyte const* rende
		mRenderer = (char const*)renderer;
		mVersion = (char const*)version;
		mExtensions = (char const*)extensions;

		ExtensionSet extensionSet(mExtensions.c_str());
		if (extensionSet.hasExtension("GL_EXT_protected_textures")) {
		mHasProtectedTexture = true;
		}
		}

		char const* GLExtensions::getVendor() const {

libs/renderengine/gl/GLExtensions.h

+2 −1

Original line number	Diff line number	Diff line
		@@ -40,6 +40,7 @@ public:
		bool hasProtectedContent() const { return mHasProtectedContent; }
		bool hasContextPriority() const { return mHasContextPriority; }
		bool hasSurfacelessContext() const { return mHasSurfacelessContext; }
		bool hasProtectedTexture() const { return mHasProtectedTexture; }

		void initWithGLStrings(GLubyte const* vendor, GLubyte const* renderer, GLubyte const* version,
		GLubyte const* extensions);
		@@ -65,12 +66,12 @@ private:
		bool mHasProtectedContent = false;
		bool mHasContextPriority = false;
		bool mHasSurfacelessContext = false;
		bool mHasProtectedTexture = false;

		String8 mVendor;
		String8 mRenderer;
		String8 mVersion;
		String8 mExtensions;

		String8 mEGLVersion;
		String8 mEGLExtensions;

libs/renderengine/gl/GLFramebuffer.cpp

+7 −2

Original line number	Diff line number	Diff line
		@@ -39,7 +39,7 @@ GLFramebuffer::~GLFramebuffer() {
		eglDestroyImageKHR(mEGLDisplay, mEGLImage);
		}

		bool GLFramebuffer::setNativeWindowBuffer(ANativeWindowBuffer* nativeBuffer) {
		bool GLFramebuffer::setNativeWindowBuffer(ANativeWindowBuffer* nativeBuffer, bool isProtected) {
		if (mEGLImage != EGL_NO_IMAGE_KHR) {
		eglDestroyImageKHR(mEGLDisplay, mEGLImage);
		mEGLImage = EGL_NO_IMAGE_KHR;
		@@ -48,8 +48,13 @@ bool GLFramebuffer::setNativeWindowBuffer(ANativeWindowBuffer* nativeBuffer) {
		}

		if (nativeBuffer) {
		EGLint attributes[] = {
		isProtected ? EGL_PROTECTED_CONTENT_EXT : EGL_NONE,
		isProtected ? EGL_TRUE : EGL_NONE,
		EGL_NONE,
		};
		mEGLImage = eglCreateImageKHR(mEGLDisplay, EGL_NO_CONTEXT, EGL_NATIVE_BUFFER_ANDROID,
		nativeBuffer, nullptr);
		nativeBuffer, attributes);
		if (mEGLImage == EGL_NO_IMAGE_KHR) {
		return false;
		}