Merge "Fork RenderEngine" (fe0f619c) · Commits · e / os / android_frameworks_av

media/libstagefright/Android.bp

+1 −1

Original line number	Diff line number	Diff line
		@@ -211,7 +211,7 @@ cc_library_shared {
		],

		static_libs: [
		"librenderengine",
		"librenderfright",
		],

		export_include_dirs: [

media/libstagefright/renderfright/Android.bp

0 → 100644

+111 −0

Original line number	Diff line number	Diff line
		cc_defaults {
		name: "renderfright_defaults",
		cflags: [
		"-DLOG_TAG=\"renderfright\"",
		"-Wall",
		"-Werror",
		"-Wthread-safety",
		"-Wunused",
		"-Wunreachable-code",
		],
		}

		cc_defaults {
		name: "librenderfright_defaults",
		defaults: ["renderfright_defaults"],
		cflags: [
		"-DGL_GLEXT_PROTOTYPES",
		"-DEGL_EGLEXT_PROTOTYPES",
		],
		shared_libs: [
		"libbase",
		"libcutils",
		"libEGL",
		"libGLESv1_CM",
		"libGLESv2",
		"libgui",
		"liblog",
		"libnativewindow",
		"libprocessgroup",
		"libsync",
		"libui",
		"libutils",
		],
		local_include_dirs: ["include"],
		export_include_dirs: ["include"],
		}

		filegroup {
		name: "librenderfright_sources",
		srcs: [
		"Description.cpp",
		"Mesh.cpp",
		"RenderEngine.cpp",
		"Texture.cpp",
		],
		}

		filegroup {
		name: "librenderfright_gl_sources",
		srcs: [
		"gl/GLESRenderEngine.cpp",
		"gl/GLExtensions.cpp",
		"gl/GLFramebuffer.cpp",
		"gl/GLImage.cpp",
		"gl/GLShadowTexture.cpp",
		"gl/GLShadowVertexGenerator.cpp",
		"gl/GLSkiaShadowPort.cpp",
		"gl/GLVertexBuffer.cpp",
		"gl/ImageManager.cpp",
		"gl/Program.cpp",
		"gl/ProgramCache.cpp",
		"gl/filters/BlurFilter.cpp",
		"gl/filters/GenericProgram.cpp",
		],
		}

		filegroup {
		name: "librenderfright_threaded_sources",
		srcs: [
		"threaded/RenderEngineThreaded.cpp",
		],
		}

		cc_library_static {
		name: "librenderfright",
		defaults: ["librenderfright_defaults"],
		vendor_available: true,
		vndk: {
		enabled: true,
		},
		double_loadable: true,
		clang: true,
		cflags: [
		"-fvisibility=hidden",
		"-Werror=format",
		],
		srcs: [
		":librenderfright_sources",
		":librenderfright_gl_sources",
		":librenderfright_threaded_sources",
		],
		lto: {
		thin: true,
		},
		}

		cc_library_static {
		name: "librenderfright_mocks",
		defaults: ["librenderfright_defaults"],
		srcs: [
		"mock/Framebuffer.cpp",
		"mock/Image.cpp",
		"mock/RenderEngine.cpp",
		],
		static_libs: [
		"libgtest",
		"libgmock",
		],
		local_include_dirs: ["include"],
		export_include_dirs: ["include"],
		}

media/libstagefright/renderfright/Description.cpp

0 → 100644

+56 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright 2013 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 <renderengine/private/Description.h>

		#include <stdint.h>

		#include <utils/TypeHelpers.h>

		namespace android {
		namespace renderengine {

		Description::TransferFunction Description::dataSpaceToTransferFunction(ui::Dataspace dataSpace) {
		ui::Dataspace transfer = static_cast<ui::Dataspace>(dataSpace & ui::Dataspace::TRANSFER_MASK);
		switch (transfer) {
		case ui::Dataspace::TRANSFER_ST2084:
		return Description::TransferFunction::ST2084;
		case ui::Dataspace::TRANSFER_HLG:
		return Description::TransferFunction::HLG;
		case ui::Dataspace::TRANSFER_LINEAR:
		return Description::TransferFunction::LINEAR;
		default:
		return Description::TransferFunction::SRGB;
		}
		}

		bool Description::hasInputTransformMatrix() const {
		const mat4 identity;
		return inputTransformMatrix != identity;
		}

		bool Description::hasOutputTransformMatrix() const {
		const mat4 identity;
		return outputTransformMatrix != identity;
		}

		bool Description::hasColorMatrix() const {
		const mat4 identity;
		return colorMatrix != identity;
		}

		} // namespace renderengine
		} // namespace android

media/libstagefright/renderfright/Mesh.cpp

0 → 100644

+146 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright 2013 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 <renderengine/Mesh.h>

		#include <utils/Log.h>

		namespace android {
		namespace renderengine {

		Mesh::Mesh(Primitive primitive, size_t vertexCount, size_t vertexSize, size_t texCoordSize,
		size_t cropCoordsSize, size_t shadowColorSize, size_t shadowParamsSize,
		size_t indexCount)
		: mVertexCount(vertexCount),
		mVertexSize(vertexSize),
		mTexCoordsSize(texCoordSize),
		mCropCoordsSize(cropCoordsSize),
		mShadowColorSize(shadowColorSize),
		mShadowParamsSize(shadowParamsSize),
		mPrimitive(primitive),
		mIndexCount(indexCount) {
		if (vertexCount == 0) {
		mVertices.resize(1);
		mVertices[0] = 0.0f;
		mStride = 0;
		return;
		}
		size_t stride = vertexSize + texCoordSize + cropCoordsSize + shadowColorSize + shadowParamsSize;
		size_t remainder = (stride * vertexCount) / vertexCount;
		// Since all of the input parameters are unsigned, if stride is less than
		// either vertexSize or texCoordSize, it must have overflowed. remainder
		// will be equal to stride as long as stride * vertexCount doesn't overflow.
		if ((stride < vertexSize) \|\| (remainder != stride)) {
		ALOGE("Overflow in Mesh(..., %zu, %zu, %zu, %zu, %zu, %zu)", vertexCount, vertexSize,
		texCoordSize, cropCoordsSize, shadowColorSize, shadowParamsSize);
		mVertices.resize(1);
		mVertices[0] = 0.0f;
		mVertexCount = 0;
		mVertexSize = 0;
		mTexCoordsSize = 0;
		mCropCoordsSize = 0;
		mShadowColorSize = 0;
		mShadowParamsSize = 0;
		mStride = 0;
		return;
		}

		mVertices.resize(stride * vertexCount);
		mStride = stride;
		mIndices.resize(indexCount);
		}

		Mesh::Primitive Mesh::getPrimitive() const {
		return mPrimitive;
		}

		float const* Mesh::getPositions() const {
		return mVertices.data();
		}
		float* Mesh::getPositions() {
		return mVertices.data();
		}

		float const* Mesh::getTexCoords() const {
		return mVertices.data() + mVertexSize;
		}
		float* Mesh::getTexCoords() {
		return mVertices.data() + mVertexSize;
		}

		float const* Mesh::getCropCoords() const {
		return mVertices.data() + mVertexSize + mTexCoordsSize;
		}
		float* Mesh::getCropCoords() {
		return mVertices.data() + mVertexSize + mTexCoordsSize;
		}

		float const* Mesh::getShadowColor() const {
		return mVertices.data() + mVertexSize + mTexCoordsSize + mCropCoordsSize;
		}
		float* Mesh::getShadowColor() {
		return mVertices.data() + mVertexSize + mTexCoordsSize + mCropCoordsSize;
		}

		float const* Mesh::getShadowParams() const {
		return mVertices.data() + mVertexSize + mTexCoordsSize + mCropCoordsSize + mShadowColorSize;
		}
		float* Mesh::getShadowParams() {
		return mVertices.data() + mVertexSize + mTexCoordsSize + mCropCoordsSize + mShadowColorSize;
		}

		uint16_t const* Mesh::getIndices() const {
		return mIndices.data();
		}

		uint16_t* Mesh::getIndices() {
		return mIndices.data();
		}

		size_t Mesh::getVertexCount() const {
		return mVertexCount;
		}

		size_t Mesh::getVertexSize() const {
		return mVertexSize;
		}

		size_t Mesh::getTexCoordsSize() const {
		return mTexCoordsSize;
		}

		size_t Mesh::getShadowColorSize() const {
		return mShadowColorSize;
		}

		size_t Mesh::getShadowParamsSize() const {
		return mShadowParamsSize;
		}

		size_t Mesh::getByteStride() const {
		return mStride * sizeof(float);
		}

		size_t Mesh::getStride() const {
		return mStride;
		}

		size_t Mesh::getIndexCount() const {
		return mIndexCount;
		}

		} // namespace renderengine
		} // namespace android

media/libstagefright/renderfright/RenderEngine.cpp

0 → 100644

+71 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright 2013 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 <renderengine/RenderEngine.h>

		#include <cutils/properties.h>
		#include <log/log.h>
		#include <private/gui/SyncFeatures.h>
		#include "gl/GLESRenderEngine.h"
		#include "threaded/RenderEngineThreaded.h"

		namespace android {
		namespace renderengine {

		std::unique_ptr<RenderEngine> RenderEngine::create(const RenderEngineCreationArgs& args) {
		RenderEngineType renderEngineType = args.renderEngineType;

		// Keep the ability to override by PROPERTIES:
		char prop[PROPERTY_VALUE_MAX];
		property_get(PROPERTY_DEBUG_RENDERENGINE_BACKEND, prop, "");
		if (strcmp(prop, "gles") == 0) {
		renderEngineType = RenderEngineType::GLES;
		}
		if (strcmp(prop, "threaded") == 0) {
		renderEngineType = RenderEngineType::THREADED;
		}

		switch (renderEngineType) {
		case RenderEngineType::THREADED:
		ALOGD("Threaded RenderEngine with GLES Backend");
		return renderengine::threaded::RenderEngineThreaded::create(
		[args]() { return android::renderengine::gl::GLESRenderEngine::create(args); });
		case RenderEngineType::GLES:
		default:
		ALOGD("RenderEngine with GLES Backend");
		return renderengine::gl::GLESRenderEngine::create(args);
		}
		}

		RenderEngine::~RenderEngine() = default;

		namespace impl {

		RenderEngine::RenderEngine(const RenderEngineCreationArgs& args) : mArgs(args) {}

		RenderEngine::~RenderEngine() = default;

		bool RenderEngine::useNativeFenceSync() const {
		return SyncFeatures::getInstance().useNativeFenceSync();
		}

		bool RenderEngine::useWaitSync() const {
		return SyncFeatures::getInstance().useWaitSync();
		}

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