Snap for 11361184 from 05e3113ca64afb9f624b75fe68193ae07ea3f167 to 24Q2-release (bfd455af) · Commits · e / os / android_frameworks_native

libs/gui/include/gui/LayerState.h

+21 −4

Original line number	Diff line number	Diff line
		@@ -416,26 +416,36 @@ public:
		};

		struct DisplayState {
		enum {
		enum : uint32_t {
		eSurfaceChanged = 0x01,
		eLayerStackChanged = 0x02,
		eDisplayProjectionChanged = 0x04,
		eDisplaySizeChanged = 0x08,
		eFlagsChanged = 0x10
		eFlagsChanged = 0x10,

		eAllChanged = ~0u
		};

		// Not for direct use. Prefer constructor below for new displays.
		DisplayState();

		DisplayState(sp<IBinder> token, ui::LayerStack layerStack)
		: what(eAllChanged),
		token(std::move(token)),
		layerStack(layerStack),
		layerStackSpaceRect(Rect::INVALID_RECT),
		orientedDisplaySpaceRect(Rect::INVALID_RECT) {}

		void merge(const DisplayState& other);
		void sanitize(int32_t permissions);

		uint32_t what = 0;
		uint32_t flags = 0;
		sp<IBinder> token;
		sp<IGraphicBufferProducer> surface;

		ui::LayerStack layerStack = ui::DEFAULT_LAYER_STACK;

		// These states define how layers are projected onto the physical display.
		// These states define how layers are projected onto the physical or virtual display.
		//
		// Layers are first clipped to `layerStackSpaceRect'. They are then translated and
		// scaled from `layerStackSpaceRect' to `orientedDisplaySpaceRect'. Finally, they are rotated
		@@ -446,10 +456,17 @@ struct DisplayState {
		// will be scaled by a factor of 2 and translated by (20, 10). When orientation is 1, layers
		// will be additionally rotated by 90 degrees around the origin clockwise and translated by (W,
		// 0).
		//
		// Rect::INVALID_RECT sizes the space to the active resolution of the physical display, or the
		// default dimensions of the virtual display surface.
		//
		ui::Rotation orientation = ui::ROTATION_0;
		Rect layerStackSpaceRect = Rect::EMPTY_RECT;
		Rect orientedDisplaySpaceRect = Rect::EMPTY_RECT;

		// Exclusive to virtual displays: The sink surface into which the virtual display is rendered,
		// and an optional resolution that overrides its default dimensions.
		sp<IGraphicBufferProducer> surface;
		uint32_t width = 0;
		uint32_t height = 0;

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),