Merge "Split RenderEngineType into two enums" into main (e5420449) · Commits · e / os / platform_frameworks_native

libs/renderengine/RenderEngine.cpp

+18 −18

Original line number	Diff line number	Diff line
		@@ -28,28 +28,28 @@ namespace android {
		namespace renderengine {

		std::unique_ptr<RenderEngine> RenderEngine::create(const RenderEngineCreationArgs& args) {
		switch (args.renderEngineType) {
		case RenderEngineType::SKIA_GL:
		ALOGD("RenderEngine with SkiaGL Backend");
		return renderengine::skia::SkiaGLRenderEngine::create(args);
		case RenderEngineType::SKIA_VK:
		ALOGD("RenderEngine with SkiaVK Backend");
		return renderengine::skia::SkiaVkRenderEngine::create(args);
		case RenderEngineType::SKIA_GL_THREADED: {
		if (args.threaded == Threaded::YES) {
		switch (args.graphicsApi) {
		case GraphicsApi::GL:
		ALOGD("Threaded RenderEngine with SkiaGL Backend");
		return renderengine::threaded::RenderEngineThreaded::create(
		[args]() {
		return renderengine::threaded::RenderEngineThreaded::create([args]() {
		return android::renderengine::skia::SkiaGLRenderEngine::create(args);
		},
		args.renderEngineType);
		}
		case RenderEngineType::SKIA_VK_THREADED:
		});
		case GraphicsApi::VK:
		ALOGD("Threaded RenderEngine with SkiaVK Backend");
		return renderengine::threaded::RenderEngineThreaded::create(
		[args]() {
		return renderengine::threaded::RenderEngineThreaded::create([args]() {
		return android::renderengine::skia::SkiaVkRenderEngine::create(args);
		},
		args.renderEngineType);
		});
		}
		}

		switch (args.graphicsApi) {
		case GraphicsApi::GL:
		ALOGD("RenderEngine with SkiaGL Backend");
		return renderengine::skia::SkiaGLRenderEngine::create(args);
		case GraphicsApi::VK:
		ALOGD("RenderEngine with SkiaVK Backend");
		return renderengine::skia::SkiaVkRenderEngine::create(args);
		}
		}

libs/renderengine/benchmark/RenderEngineBench.cpp

+11 −45

Original line number	Diff line number	Diff line
		@@ -29,46 +29,6 @@
		using namespace android;
		using namespace android::renderengine;

		///////////////////////////////////////////////////////////////////////////////
		// Helpers for Benchmark::Apply
		///////////////////////////////////////////////////////////////////////////////

		std::string RenderEngineTypeName(RenderEngine::RenderEngineType type) {
		switch (type) {
		case RenderEngine::RenderEngineType::SKIA_GL_THREADED:
		return "skiaglthreaded";
		case RenderEngine::RenderEngineType::SKIA_GL:
		return "skiagl";
		case RenderEngine::RenderEngineType::SKIA_VK:
		return "skiavk";
		case RenderEngine::RenderEngineType::SKIA_VK_THREADED:
		return "skiavkthreaded";
		}
		}

		/**
		* Passed (indirectly - see RunSkiaGLThreaded) to Benchmark::Apply to create a
		* Benchmark which specifies which RenderEngineType it uses.
		*
		* This simplifies calling ->Arg(type)->Arg(type) and provides strings to make
		* it obvious which version is being run.
		*
		* @param b The benchmark family
		* @param type The type of RenderEngine to use.
		*/
		static void AddRenderEngineType(benchmark::internal::Benchmark* b,
		RenderEngine::RenderEngineType type) {
		b->Arg(static_cast<int64_t>(type));
		b->ArgName(RenderEngineTypeName(type));
		}

		/**
		* Run a benchmark once using SKIA_GL_THREADED.
		*/
		static void RunSkiaGLThreaded(benchmark::internal::Benchmark* b) {
		AddRenderEngineType(b, RenderEngine::RenderEngineType::SKIA_GL_THREADED);
		}

		///////////////////////////////////////////////////////////////////////////////
		// Helpers for calling drawLayers
		///////////////////////////////////////////////////////////////////////////////
		@@ -104,7 +64,8 @@ std::pair<uint32_t, uint32_t> getDisplaySize() {
		return std::pair<uint32_t, uint32_t>(width, height);
		}

		static std::unique_ptr<RenderEngine> createRenderEngine(RenderEngine::RenderEngineType type) {
		static std::unique_ptr<RenderEngine> createRenderEngine(RenderEngine::Threaded threaded,
		RenderEngine::GraphicsApi graphicsApi) {
		auto args = RenderEngineCreationArgs::Builder()
		.setPixelFormat(static_cast<int>(ui::PixelFormat::RGBA_8888))
		.setImageCacheSize(1)
		@@ -112,7 +73,8 @@ static std::unique_ptr<RenderEngine> createRenderEngine(RenderEngine::RenderEngi
		.setPrecacheToneMapperShaderOnly(false)
		.setSupportsBackgroundBlur(true)
		.setContextPriority(RenderEngine::ContextPriority::REALTIME)
		.setRenderEngineType(type)
		.setThreaded(threaded)
		.setGraphicsApi(graphicsApi)
		.build();
		return RenderEngine::create(args);
		}
		@@ -214,8 +176,11 @@ static void benchDrawLayers(RenderEngine& re, const std::vector<LayerSettings>&
		// Benchmarks
		///////////////////////////////////////////////////////////////////////////////

		void BM_blur(benchmark::State& benchState) {
		auto re = createRenderEngine(static_cast<RenderEngine::RenderEngineType>(benchState.range()));
		template <class... Args>
		void BM_blur(benchmark::State& benchState, Args&&... args) {
		auto args_tuple = std::make_tuple(std::move(args)...);
		auto re = createRenderEngine(static_cast<RenderEngine::Threaded>(std::get<0>(args_tuple)),
		static_cast<RenderEngine::GraphicsApi>(std::get<1>(args_tuple)));

		// Initially use cpu access so we can decode into it with AImageDecoder.
		auto [width, height] = getDisplaySize();
		@@ -259,4 +224,5 @@ void BM_blur(benchmark::State& benchState) {
		benchDrawLayers(*re, layers, benchState, "blurred");
		}

		BENCHMARK(BM_blur)->Apply(RunSkiaGLThreaded);
		BENCHMARK_CAPTURE(BM_blur, SkiaGLThreaded, RenderEngine::Threaded::YES,
		RenderEngine::GraphicsApi::GL);

libs/renderengine/include/renderengine/RenderEngine.h

+28 −19

Original line number	Diff line number	Diff line
		@@ -33,7 +33,7 @@
		#include <memory>

		/**
		* Allows to set RenderEngine backend to GLES (default) or SkiaGL (NOT yet supported).
		* Allows to override the RenderEngine backend.
		*/
		#define PROPERTY_DEBUG_RENDERENGINE_BACKEND "debug.renderengine.backend"

		@@ -92,11 +92,14 @@ public:
		REALTIME = 4,
		};

		enum class RenderEngineType {
		SKIA_GL = 3,
		SKIA_GL_THREADED = 4,
		SKIA_VK = 5,
		SKIA_VK_THREADED = 6,
		enum class Threaded {
		NO,
		YES,
		};

		enum class GraphicsApi {
		GL,
		VK,
		};

		static std::unique_ptr<RenderEngine> create(const RenderEngineCreationArgs& args);
		@@ -176,10 +179,9 @@ public:
		// query is required to be thread safe.
		virtual bool supportsBackgroundBlur() = 0;

		// Returns the current type of RenderEngine instance that was created.
		// TODO(b/180767535): This is only implemented to allow for backend-specific behavior, which
		// we should not allow in general, so remove this.
		RenderEngineType getRenderEngineType() const { return mRenderEngineType; }
		bool isThreaded() const { return mThreaded == Threaded::YES; }

		static void validateInputBufferUsage(const sp<GraphicBuffer>&);
		static void validateOutputBufferUsage(const sp<GraphicBuffer>&);
		@@ -191,9 +193,9 @@ public:
		virtual void setEnableTracing(bool /tracingEnabled/) {}

		protected:
		RenderEngine() : RenderEngine(RenderEngineType::SKIA_GL) {}
		RenderEngine() : RenderEngine(Threaded::NO) {}

		RenderEngine(RenderEngineType type) : mRenderEngineType(type) {}
		RenderEngine(Threaded threaded) : mThreaded(threaded) {}

		// Maps GPU resources for this buffer.
		// Note that work may be deferred to an additional thread, i.e. this call
		@@ -228,7 +230,7 @@ protected:
		friend class impl::ExternalTexture;
		friend class threaded::RenderEngineThreaded;
		friend class RenderEngineTest_cleanupPostRender_cleansUpOnce_Test;
		const RenderEngineType mRenderEngineType;
		const Threaded mThreaded;

		// Update protectedContext mode depending on whether or not any layer has a protected buffer.
		void updateProtectedContext(const std::vector<LayerSettings>&,
		@@ -251,7 +253,8 @@ struct RenderEngineCreationArgs {
		bool precacheToneMapperShaderOnly;
		bool supportsBackgroundBlur;
		RenderEngine::ContextPriority contextPriority;
		RenderEngine::RenderEngineType renderEngineType;
		RenderEngine::Threaded threaded;
		RenderEngine::GraphicsApi graphicsApi;

		struct Builder;

		@@ -261,14 +264,16 @@ private:
		bool _enableProtectedContext, bool _precacheToneMapperShaderOnly,
		bool _supportsBackgroundBlur,
		RenderEngine::ContextPriority _contextPriority,
		RenderEngine::RenderEngineType _renderEngineType)
		RenderEngine::Threaded _threaded,
		RenderEngine::GraphicsApi _graphicsApi)
		: pixelFormat(_pixelFormat),
		imageCacheSize(_imageCacheSize),
		enableProtectedContext(_enableProtectedContext),
		precacheToneMapperShaderOnly(_precacheToneMapperShaderOnly),
		supportsBackgroundBlur(_supportsBackgroundBlur),
		contextPriority(_contextPriority),
		renderEngineType(_renderEngineType) {}
		threaded(_threaded),
		graphicsApi(_graphicsApi) {}
		RenderEngineCreationArgs() = delete;
		};

		@@ -299,14 +304,18 @@ struct RenderEngineCreationArgs::Builder {
		this->contextPriority = contextPriority;
		return *this;
		}
		Builder& setRenderEngineType(RenderEngine::RenderEngineType renderEngineType) {
		this->renderEngineType = renderEngineType;
		Builder& setThreaded(RenderEngine::Threaded threaded) {
		this->threaded = threaded;
		return *this;
		}
		Builder& setGraphicsApi(RenderEngine::GraphicsApi graphicsApi) {
		this->graphicsApi = graphicsApi;
		return *this;
		}
		RenderEngineCreationArgs build() const {
		return RenderEngineCreationArgs(pixelFormat, imageCacheSize, enableProtectedContext,
		precacheToneMapperShaderOnly, supportsBackgroundBlur,
		contextPriority, renderEngineType);
		contextPriority, threaded, graphicsApi);
		}

		private:
		@@ -317,8 +326,8 @@ private:
		bool precacheToneMapperShaderOnly = false;
		bool supportsBackgroundBlur = false;
		RenderEngine::ContextPriority contextPriority = RenderEngine::ContextPriority::MEDIUM;
		RenderEngine::RenderEngineType renderEngineType =
		RenderEngine::RenderEngineType::SKIA_GL_THREADED;
		RenderEngine::Threaded threaded = RenderEngine::Threaded::YES;
		RenderEngine::GraphicsApi graphicsApi = RenderEngine::GraphicsApi::GL;
		};

		} // namespace renderengine

libs/renderengine/skia/SkiaGLRenderEngine.cpp

+1 −1

Original line number	Diff line number	Diff line
		@@ -268,7 +268,7 @@ EGLConfig SkiaGLRenderEngine::chooseEglConfig(EGLDisplay display, int format, bo
		SkiaGLRenderEngine::SkiaGLRenderEngine(const RenderEngineCreationArgs& args, EGLDisplay display,
		EGLContext ctxt, EGLSurface placeholder,
		EGLContext protectedContext, EGLSurface protectedPlaceholder)
		: SkiaRenderEngine(args.renderEngineType, static_cast<PixelFormat>(args.pixelFormat),
		: SkiaRenderEngine(args.threaded, static_cast<PixelFormat>(args.pixelFormat),
		args.supportsBackgroundBlur),
		mEGLDisplay(display),
		mEGLContext(ctxt),

libs/renderengine/skia/SkiaRenderEngine.cpp

+4 −5

Original line number	Diff line number	Diff line
		@@ -269,9 +269,9 @@ void SkiaRenderEngine::setEnableTracing(bool tracingEnabled) {
		SkAndroidFrameworkTraceUtil::setEnableTracing(tracingEnabled);
		}

		SkiaRenderEngine::SkiaRenderEngine(RenderEngineType type, PixelFormat pixelFormat,
		SkiaRenderEngine::SkiaRenderEngine(Threaded threaded, PixelFormat pixelFormat,
		bool supportsBackgroundBlur)
		: RenderEngine(type), mDefaultPixelFormat(pixelFormat) {
		: RenderEngine(threaded), mDefaultPixelFormat(pixelFormat) {
		if (supportsBackgroundBlur) {
		ALOGD("Background Blurs Enabled");
		mBlurFilter = new KawaseBlurFilter();
		@@ -389,10 +389,9 @@ void SkiaRenderEngine::ensureGrContextsCreated() {
		void SkiaRenderEngine::mapExternalTextureBuffer(const sp<GraphicBuffer>& buffer,
		bool isRenderable) {
		// Only run this if RE is running on its own thread. This
		// way the access to GL operations is guaranteed to be happening on the
		// way the access to GL/VK operations is guaranteed to be happening on the
		// same thread.
		if (mRenderEngineType != RenderEngineType::SKIA_GL_THREADED &&
		mRenderEngineType != RenderEngineType::SKIA_VK_THREADED) {
		if (!isThreaded()) {
		return;
		}
		// We don't attempt to map a buffer if the buffer contains protected content. In GL this is