Merge "SF: Extract virtual display allocation from CE" (1ed97c9f) · Commits · e / os / platform_frameworks_native

services/surfaceflinger/CompositionEngine/include/compositionengine/DisplayCreationArgs.h

+9 −36

Original line number	Original line	Diff line number	Diff line
	@@ -21,13 +21,10 @@
	#include <string>		#include <string>

	#include <ui/DisplayId.h>		#include <ui/DisplayId.h>
	#include <ui/PixelFormat.h>
	#include <ui/Size.h>		#include <ui/Size.h>
	#include <ui/StaticDisplayInfo.h>		#include <ui/StaticDisplayInfo.h>

	#include "DisplayHardware/DisplayIdentification.h"
	#include "DisplayHardware/PowerAdvisor.h"		#include "DisplayHardware/PowerAdvisor.h"
	#include "DisplayIdGenerator.h"

	namespace android::compositionengine {		namespace android::compositionengine {

	@@ -37,24 +34,14 @@ class CompositionEngine;
	* A parameter object for creating Display instances		* A parameter object for creating Display instances
	*/		*/
	struct DisplayCreationArgs {		struct DisplayCreationArgs {
	struct Physical {
	DisplayId id;		DisplayId id;
	ui::DisplayConnectionType type;
	};

	// Required for physical displays. Gives the HWC display id for the existing		// Unset for virtual displays
	// display along with the connection type.		std::optional<ui::DisplayConnectionType> connectionType;
	std::optional<Physical> physical;

	// Size of the display in pixels		// Size of the display in pixels
	ui::Size pixels = ui::kInvalidSize;		ui::Size pixels = ui::kInvalidSize;

	// Pixel format of the display
	ui::PixelFormat pixelFormat = static_cast<ui::PixelFormat>(PIXEL_FORMAT_UNKNOWN);

	// True if virtual displays should be created with the HWC API if possible
	bool useHwcVirtualDisplays = false;

	// True if this display should be considered secure		// True if this display should be considered secure
	bool isSecure = false;		bool isSecure = false;

	@@ -67,9 +54,6 @@ struct DisplayCreationArgs {

	// Debugging. Human readable name for the display.		// Debugging. Human readable name for the display.
	std::string name;		std::string name;

	// Generator for IDs of virtual displays, which are backed by the GPU.
	DisplayIdGenerator<GpuVirtualDisplayId>* gpuVirtualDisplayIdGenerator;
	};		};

	/**		/**
	@@ -80,29 +64,18 @@ class DisplayCreationArgsBuilder {
	public:		public:
	DisplayCreationArgs build() { return std::move(mArgs); }		DisplayCreationArgs build() { return std::move(mArgs); }

	DisplayCreationArgsBuilder& setPhysical(DisplayCreationArgs::Physical physical) {		DisplayCreationArgsBuilder& setId(DisplayId id) {
	mArgs.physical = physical;		mArgs.id = id;
	return *this;
	}

	DisplayCreationArgsBuilder& setPixels(ui::Size pixels) {
	mArgs.pixels = pixels;
	return *this;		return *this;
	}		}

	DisplayCreationArgsBuilder& setPixelFormat(ui::PixelFormat pixelFormat) {		DisplayCreationArgsBuilder& setConnectionType(ui::DisplayConnectionType connectionType) {
	mArgs.pixelFormat = pixelFormat;		mArgs.connectionType = connectionType;
	return *this;		return *this;
	}		}

	DisplayCreationArgsBuilder& setUseHwcVirtualDisplays(bool useHwcVirtualDisplays) {		DisplayCreationArgsBuilder& setPixels(ui::Size pixels) {
	mArgs.useHwcVirtualDisplays = useHwcVirtualDisplays;		mArgs.pixels = pixels;
	return *this;
	}

	DisplayCreationArgsBuilder& setGpuVirtualDisplayIdGenerator(
	DisplayIdGenerator<GpuVirtualDisplayId>& generator) {
	mArgs.gpuVirtualDisplayIdGenerator = &generator;
	return *this;		return *this;
	}		}

services/surfaceflinger/CompositionEngine/include/compositionengine/impl/Display.h

+0 −6

Original line number	Original line	Diff line number	Diff line
	@@ -80,19 +80,13 @@ public:

	// Internal		// Internal
	virtual void setConfiguration(const compositionengine::DisplayCreationArgs&);		virtual void setConfiguration(const compositionengine::DisplayCreationArgs&);
	virtual std::optional<DisplayId> maybeAllocateDisplayIdForVirtualDisplay(ui::Size,
	ui::PixelFormat) const;
	std::unique_ptr<compositionengine::OutputLayer> createOutputLayer(const sp<LayerFE>&) const;		std::unique_ptr<compositionengine::OutputLayer> createOutputLayer(const sp<LayerFE>&) const;

	// Testing
	void setDisplayIdForTesting(DisplayId displayId);

	private:		private:
	bool mIsVirtual = false;		bool mIsVirtual = false;
	bool mIsDisconnected = false;		bool mIsDisconnected = false;
	DisplayId mId;		DisplayId mId;
	Hwc2::PowerAdvisor* mPowerAdvisor = nullptr;		Hwc2::PowerAdvisor* mPowerAdvisor = nullptr;
	DisplayIdGenerator<GpuVirtualDisplayId>* mGpuVirtualDisplayIdGenerator;
	};		};

	// This template factory function standardizes the implementation details of the		// This template factory function standardizes the implementation details of the

services/surfaceflinger/CompositionEngine/src/Display.cpp

+6 −35

Original line number	Original line	Diff line number	Diff line
	@@ -50,36 +50,14 @@ std::shared_ptr<Display> createDisplay(
	Display::~Display() = default;		Display::~Display() = default;

	void Display::setConfiguration(const compositionengine::DisplayCreationArgs& args) {		void Display::setConfiguration(const compositionengine::DisplayCreationArgs& args) {
	mIsVirtual = !args.physical;		mId = args.id;
			mIsVirtual = !args.connectionType;
	mPowerAdvisor = args.powerAdvisor;		mPowerAdvisor = args.powerAdvisor;
	editState().isSecure = args.isSecure;		editState().isSecure = args.isSecure;
	editState().displaySpace.bounds = Rect(args.pixels);		editState().displaySpace.bounds = Rect(args.pixels);
	setLayerStackFilter(args.layerStackId,		setLayerStackFilter(args.layerStackId,
	args.physical &&		args.connectionType == ui::DisplayConnectionType::Internal);
	args.physical->type == ui::DisplayConnectionType::Internal);
	setName(args.name);		setName(args.name);
	mGpuVirtualDisplayIdGenerator = args.gpuVirtualDisplayIdGenerator;

	if (args.physical) {
	mId = args.physical->id;
	} else {
	std::optional<DisplayId> id;
	if (args.useHwcVirtualDisplays) {
	id = maybeAllocateDisplayIdForVirtualDisplay(args.pixels, args.pixelFormat);
	}
	if (!id) {
	id = mGpuVirtualDisplayIdGenerator->nextId();
	}
	LOG_ALWAYS_FATAL_IF(!id, "Failed to generate display ID");
	mId = *id;
	}
	}

	std::optional<DisplayId> Display::maybeAllocateDisplayIdForVirtualDisplay(
	ui::Size pixels, ui::PixelFormat pixelFormat) const {
	auto& hwc = getCompositionEngine().getHwComposer();
	return hwc.allocateVirtualDisplay(static_cast<uint32_t>(pixels.width),
	static_cast<uint32_t>(pixels.height), &pixelFormat);
	}		}

	bool Display::isValid() const {		bool Display::isValid() const {
	@@ -102,23 +80,16 @@ std::optional<DisplayId> Display::getDisplayId() const {
	return mId;		return mId;
	}		}

	void Display::setDisplayIdForTesting(DisplayId displayId) {
	mId = displayId;
	}

	void Display::disconnect() {		void Display::disconnect() {
	if (mIsDisconnected) {		if (mIsDisconnected) {
	return;		return;
	}		}

	mIsDisconnected = true;		mIsDisconnected = true;
	if (const auto id = GpuVirtualDisplayId::tryCast(mId)) {
	mGpuVirtualDisplayIdGenerator->markUnused(*id);		if (const auto id = HalDisplayId::tryCast(mId)) {
	return;		getCompositionEngine().getHwComposer().disconnectDisplay(*id);
	}		}
	const auto halDisplayId = HalDisplayId::tryCast(mId);
	LOG_FATAL_IF(!halDisplayId);
	getCompositionEngine().getHwComposer().disconnectDisplay(*halDisplayId);
	}		}

	void Display::setColorTransform(const compositionengine::CompositionRefreshArgs& args) {		void Display::setColorTransform(const compositionengine::CompositionRefreshArgs& args) {