surfaceflinger: add surface abstraction to RE (7e60ecc2) · Commits · e / os / android_frameworks_native

services/surfaceflinger/Android.mk

+1 −0

Original line number	Diff line number	Diff line
		@@ -41,6 +41,7 @@ LOCAL_SRC_FILES := \
		RenderEngine/ProgramCache.cpp \
		RenderEngine/GLExtensions.cpp \
		RenderEngine/RenderEngine.cpp \
		RenderEngine/Surface.cpp \
		RenderEngine/Texture.cpp \
		RenderEngine/GLES20RenderEngine.cpp \
		LayerProtoHelper.cpp \

services/surfaceflinger/RenderEngine/Surface.cpp

0 → 100644

+106 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright 2017 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		#include "Surface.h"

		#include "RenderEngine.h"

		#include <log/log.h>

		namespace android {
		namespace RE {

		Surface::Surface(const RenderEngine& engine)
		: mEGLDisplay(engine.getEGLDisplay()), mEGLConfig(engine.getEGLConfig()) {
		// RE does not assume any config when EGL_KHR_no_config_context is supported
		if (mEGLConfig == EGL_NO_CONFIG_KHR) {
		mEGLConfig = RenderEngine::chooseEglConfig(mEGLDisplay, PIXEL_FORMAT_RGBA_8888, false);
		}
		}

		Surface::~Surface() {
		setNativeWindow(nullptr);
		}

		void Surface::setNativeWindow(ANativeWindow* window) {
		if (mEGLSurface != EGL_NO_SURFACE) {
		eglDestroySurface(mEGLDisplay, mEGLSurface);
		mEGLSurface = EGL_NO_SURFACE;
		}

		mWindow = window;
		if (mWindow) {
		mEGLSurface = eglCreateWindowSurface(mEGLDisplay, mEGLConfig, mWindow, nullptr);
		}
		}

		void Surface::swapBuffers() const {
		if (!eglSwapBuffers(mEGLDisplay, mEGLSurface)) {
		EGLint error = eglGetError();

		const char format[] = "eglSwapBuffers(%p, %p) failed with 0x%08x";
		if (mCritical \|\| error == EGL_CONTEXT_LOST) {
		LOG_ALWAYS_FATAL(format, mEGLDisplay, mEGLSurface, error);
		} else {
		ALOGE(format, mEGLDisplay, mEGLSurface, error);
		}
		}
		}

		EGLint Surface::queryConfig(EGLint attrib) const {
		EGLint value;
		if (!eglGetConfigAttrib(mEGLConfig, mEGLConfig, attrib, &value)) {
		value = 0;
		}

		return value;
		}

		EGLint Surface::querySurface(EGLint attrib) const {
		EGLint value;
		if (!eglQuerySurface(mEGLDisplay, mEGLSurface, attrib, &value)) {
		value = 0;
		}

		return value;
		}

		int32_t Surface::queryRedSize() const {
		return queryConfig(EGL_RED_SIZE);
		}

		int32_t Surface::queryGreenSize() const {
		return queryConfig(EGL_GREEN_SIZE);
		}

		int32_t Surface::queryBlueSize() const {
		return queryConfig(EGL_BLUE_SIZE);
		}

		int32_t Surface::queryAlphaSize() const {
		return queryConfig(EGL_ALPHA_SIZE);
		}

		int32_t Surface::queryWidth() const {
		return querySurface(EGL_WIDTH);
		}

		int32_t Surface::queryHeight() const {
		return querySurface(EGL_HEIGHT);
		}

		} // namespace RE
		} // namespace android

services/surfaceflinger/RenderEngine/Surface.h

0 → 100644

+73 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright 2017 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		#pragma once

		#include <cstdint>

		#include <EGL/egl.h>

		struct ANativeWindow;

		namespace android {

		class RenderEngine;

		namespace RE {

		class Surface {
		public:
		Surface(const RenderEngine& engine);
		~Surface();

		Surface(const Surface&) = delete;
		Surface& operator=(const Surface&) = delete;

		void setCritical(bool enable) { mCritical = enable; }
		void setAsync(bool enable) { mAsync = enable; }

		void setNativeWindow(ANativeWindow* window);
		void swapBuffers() const;

		int32_t queryRedSize() const;
		int32_t queryGreenSize() const;
		int32_t queryBlueSize() const;
		int32_t queryAlphaSize() const;

		int32_t queryWidth() const;
		int32_t queryHeight() const;

		private:
		EGLint queryConfig(EGLint attrib) const;
		EGLint querySurface(EGLint attrib) const;

		// methods internal to RenderEngine
		friend class android::RenderEngine;
		bool getAsync() const { return mAsync; }
		EGLSurface getEGLSurface() const { return mEGLSurface; }

		EGLDisplay mEGLDisplay;
		EGLConfig mEGLConfig;

		bool mCritical = false;
		bool mAsync = false;

		ANativeWindow* mWindow = nullptr;
		EGLSurface mEGLSurface = EGL_NO_SURFACE;
		};

		} // namespace RE
		} // namespace android