Merge "Use IVrComposerClient interface to expose the VR HWC client" (8869aec9) · Commits · e / os / platform_frameworks_native

services/surfaceflinger/DisplayHardware/ComposerHal.cpp

+7 −0

Original line number	Diff line number	Diff line
		@@ -181,6 +181,13 @@ Composer::Composer(bool useVrComposer)
		if (mClient == nullptr) {
		LOG_ALWAYS_FATAL("failed to create composer client");
		}

		if (mIsUsingVrComposer) {
		sp<IVrComposerClient> vrClient = IVrComposerClient::castFrom(mClient);
		if (vrClient == nullptr) {
		LOG_ALWAYS_FATAL("failed to create vr composer client");
		}
		}
		}

		std::vector<IComposer::Capability> Composer::getCapabilities()

services/vr/hardware_composer/impl/vr_composer_client.cpp

+174 −10

Original line number	Diff line number	Diff line
		@@ -24,26 +24,63 @@

		namespace android {
		namespace dvr {
		namespace {

		using android::hardware::graphics::common::V1_0::PixelFormat;
		using android::frameworks::vr::composer::V1_0::IVrComposerClient;

		VrComposerClient::VrComposerClient(dvr::VrHwc& hal)
		class ComposerClientImpl : public ComposerClient {
		public:
		ComposerClientImpl(android::dvr::VrHwc& hal);
		virtual ~ComposerClientImpl();

		private:
		class VrCommandReader : public ComposerClient::CommandReader {
		public:
		VrCommandReader(ComposerClientImpl& client);
		~VrCommandReader() override;

		bool parseCommand(IComposerClient::Command command,
		uint16_t length) override;

		private:
		bool parseSetLayerInfo(uint16_t length);
		bool parseSetClientTargetMetadata(uint16_t length);
		bool parseSetLayerBufferMetadata(uint16_t length);

		IVrComposerClient::BufferMetadata readBufferMetadata();

		ComposerClientImpl& mVrClient;
		android::dvr::VrHwc& mVrHal;

		VrCommandReader(const VrCommandReader&) = delete;
		void operator=(const VrCommandReader&) = delete;
		};

		std::unique_ptr<CommandReader> createCommandReader() override;

		dvr::VrHwc& mVrHal;

		ComposerClientImpl(const ComposerClientImpl&) = delete;
		void operator=(const ComposerClientImpl&) = delete;
		};

		ComposerClientImpl::ComposerClientImpl(android::dvr::VrHwc& hal)
		: ComposerClient(hal), mVrHal(hal) {}

		VrComposerClient::~VrComposerClient() {}
		ComposerClientImpl::~ComposerClientImpl() {}

		std::unique_ptr<ComposerClient::CommandReader>
		VrComposerClient::createCommandReader() {
		ComposerClientImpl::createCommandReader() {
		return std::unique_ptr<CommandReader>(new VrCommandReader(*this));
		}

		VrComposerClient::VrCommandReader::VrCommandReader(VrComposerClient& client)
		ComposerClientImpl::VrCommandReader::VrCommandReader(ComposerClientImpl& client)
		: CommandReader(client), mVrClient(client), mVrHal(client.mVrHal) {}

		VrComposerClient::VrCommandReader::~VrCommandReader() {}
		ComposerClientImpl::VrCommandReader::~VrCommandReader() {}

		bool VrComposerClient::VrCommandReader::parseCommand(
		bool ComposerClientImpl::VrCommandReader::parseCommand(
		IComposerClient::Command command, uint16_t length) {
		IVrComposerClient::VrCommand vrCommand =
		static_cast<IVrComposerClient::VrCommand>(command);
		@@ -59,7 +96,7 @@ bool VrComposerClient::VrCommandReader::parseCommand(
		}
		}

		bool VrComposerClient::VrCommandReader::parseSetLayerInfo(uint16_t length) {
		bool ComposerClientImpl::VrCommandReader::parseSetLayerInfo(uint16_t length) {
		if (length != 2) {
		return false;
		}
		@@ -72,7 +109,7 @@ bool VrComposerClient::VrCommandReader::parseSetLayerInfo(uint16_t length) {
		return true;
		}

		bool VrComposerClient::VrCommandReader::parseSetClientTargetMetadata(
		bool ComposerClientImpl::VrCommandReader::parseSetClientTargetMetadata(
		uint16_t length) {
		if (length != 7)
		return false;
		@@ -84,7 +121,7 @@ bool VrComposerClient::VrCommandReader::parseSetClientTargetMetadata(
		return true;
		}

		bool VrComposerClient::VrCommandReader::parseSetLayerBufferMetadata(
		bool ComposerClientImpl::VrCommandReader::parseSetLayerBufferMetadata(
		uint16_t length) {
		if (length != 7)
		return false;
		@@ -98,7 +135,7 @@ bool VrComposerClient::VrCommandReader::parseSetLayerBufferMetadata(
		}

		IVrComposerClient::BufferMetadata
		VrComposerClient::VrCommandReader::readBufferMetadata() {
		ComposerClientImpl::VrCommandReader::readBufferMetadata() {
		IVrComposerClient::BufferMetadata metadata = {
		.width = read(),
		.height = read(),
		@@ -110,5 +147,132 @@ VrComposerClient::VrCommandReader::readBufferMetadata() {
		return metadata;
		}

		} // namespace

		VrComposerClient::VrComposerClient(dvr::VrHwc& hal)
		: client_(new ComposerClientImpl(hal)) {
		client_->initialize();
		}

		VrComposerClient::~VrComposerClient() {}

		void VrComposerClient::onHotplug(Display display,
		IComposerCallback::Connection connected) {
		client_->onHotplug(display, connected);
		}

		Return<void> VrComposerClient::registerCallback(
		const sp<IComposerCallback>& callback) {
		return client_->registerCallback(callback);
		}

		Return<uint32_t> VrComposerClient::getMaxVirtualDisplayCount() {
		return client_->getMaxVirtualDisplayCount();
		}

		Return<void> VrComposerClient::createVirtualDisplay(uint32_t width,
		uint32_t height, PixelFormat formatHint, uint32_t outputBufferSlotCount,
		createVirtualDisplay_cb hidl_cb) {
		return client_->createVirtualDisplay(
		width, height, formatHint, outputBufferSlotCount, hidl_cb);
		}

		Return<Error> VrComposerClient::destroyVirtualDisplay(Display display) {
		return client_->destroyVirtualDisplay(display);
		}

		Return<void> VrComposerClient::createLayer(Display display,
		uint32_t bufferSlotCount, createLayer_cb hidl_cb) {
		return client_->createLayer(display, bufferSlotCount, hidl_cb);
		}

		Return<Error> VrComposerClient::destroyLayer(Display display, Layer layer) {
		return client_->destroyLayer(display, layer);
		}

		Return<void> VrComposerClient::getActiveConfig(Display display,
		getActiveConfig_cb hidl_cb) {
		return client_->getActiveConfig(display, hidl_cb);
		}

		Return<Error> VrComposerClient::getClientTargetSupport(Display display,
		uint32_t width, uint32_t height, PixelFormat format, Dataspace dataspace) {
		return client_->getClientTargetSupport(display, width, height, format,
		dataspace);
		}

		Return<void> VrComposerClient::getColorModes(Display display,
		getColorModes_cb hidl_cb) {
		return client_->getColorModes(display, hidl_cb);
		}

		Return<void> VrComposerClient::getDisplayAttribute(Display display,
		Config config, Attribute attribute, getDisplayAttribute_cb hidl_cb) {
		return client_->getDisplayAttribute(display, config, attribute, hidl_cb);
		}

		Return<void> VrComposerClient::getDisplayConfigs(Display display,
		getDisplayConfigs_cb hidl_cb) {
		return client_->getDisplayConfigs(display, hidl_cb);
		}

		Return<void> VrComposerClient::getDisplayName(Display display,
		getDisplayName_cb hidl_cb) {
		return client_->getDisplayName(display, hidl_cb);
		}

		Return<void> VrComposerClient::getDisplayType(Display display,
		getDisplayType_cb hidl_cb) {
		return client_->getDisplayType(display, hidl_cb);
		}

		Return<void> VrComposerClient::getDozeSupport(
		Display display, getDozeSupport_cb hidl_cb) {
		return client_->getDozeSupport(display, hidl_cb);
		}

		Return<void> VrComposerClient::getHdrCapabilities(
		Display display, getHdrCapabilities_cb hidl_cb) {
		return client_->getHdrCapabilities(display, hidl_cb);
		}

		Return<Error> VrComposerClient::setActiveConfig(Display display,
		Config config) {
		return client_->setActiveConfig(display, config);
		}

		Return<Error> VrComposerClient::setColorMode(Display display, ColorMode mode) {
		return client_->setColorMode(display, mode);
		}

		Return<Error> VrComposerClient::setPowerMode(Display display, PowerMode mode) {
		return client_->setPowerMode(display, mode);
		}

		Return<Error> VrComposerClient::setVsyncEnabled(Display display,
		Vsync enabled) {
		return client_->setVsyncEnabled(display, enabled);
		}

		Return<Error> VrComposerClient::setClientTargetSlotCount(
		Display display, uint32_t clientTargetSlotCount) {
		return client_->setClientTargetSlotCount(display, clientTargetSlotCount);
		}

		Return<Error> VrComposerClient::setInputCommandQueue(
		const hardware::MQDescriptorSync<uint32_t>& descriptor) {
		return client_->setInputCommandQueue(descriptor);
		}

		Return<void> VrComposerClient::getOutputCommandQueue(
		getOutputCommandQueue_cb hidl_cb) {
		return client_->getOutputCommandQueue(hidl_cb);
		}

		Return<void> VrComposerClient::executeCommands(uint32_t inLength,
		const hidl_vec<hidl_handle>& inHandles, executeCommands_cb hidl_cb) {
		return client_->executeCommands(inLength, inHandles, hidl_cb);
		}

		} // namespace dvr
		} // namespace android

services/vr/hardware_composer/impl/vr_composer_client.h

+48 −26

Original line number	Diff line number	Diff line
		@@ -29,37 +29,59 @@ class VrHwc;
		using hardware::graphics::common::V1_0::PixelFormat;
		using hardware::graphics::composer::V2_1::implementation::ComposerClient;

		class VrComposerClient : public ComposerClient {
		class VrComposerClient : public IVrComposerClient {
		public:
		VrComposerClient(android::dvr::VrHwc& hal);
		virtual ~VrComposerClient();

		private:
		class VrCommandReader : public ComposerClient::CommandReader {
		public:
		VrCommandReader(VrComposerClient& client);
		~VrCommandReader() override;

		bool parseCommand(IComposerClient::Command command,
		uint16_t length) override;
		void onHotplug(Display display, IComposerCallback::Connection connected);

		// IComposerClient
		Return<void> registerCallback(const sp<IComposerCallback>& callback) override;
		Return<uint32_t> getMaxVirtualDisplayCount() override;
		Return<void> createVirtualDisplay(
		uint32_t width, uint32_t height, PixelFormat formatHint,
		uint32_t outputBufferSlotCount, createVirtualDisplay_cb hidl_cb) override;
		Return<Error> destroyVirtualDisplay(Display display) override;
		Return<void> createLayer(Display display, uint32_t bufferSlotCount,
		createLayer_cb hidl_cb) override;
		Return<Error> destroyLayer(Display display, Layer layer) override;
		Return<void> getActiveConfig(Display display,
		getActiveConfig_cb hidl_cb) override;
		Return<Error> getClientTargetSupport(
		Display display, uint32_t width, uint32_t height, PixelFormat format,
		Dataspace dataspace) override;
		Return<void> getColorModes(Display display,
		getColorModes_cb hidl_cb) override;
		Return<void> getDisplayAttribute(
		Display display, Config config, Attribute attribute,
		getDisplayAttribute_cb hidl_cb) override;
		Return<void> getDisplayConfigs(Display display,
		getDisplayConfigs_cb hidl_cb) override;
		Return<void> getDisplayName(Display display,
		getDisplayName_cb hidl_cb) override;
		Return<void> getDisplayType(Display display,
		getDisplayType_cb hidl_cb) override;
		Return<void> getDozeSupport(Display display,
		getDozeSupport_cb hidl_cb) override;
		Return<void> getHdrCapabilities(Display display,
		getHdrCapabilities_cb hidl_cb) override;
		Return<Error> setActiveConfig(Display display, Config config) override;
		Return<Error> setColorMode(Display display, ColorMode mode) override;
		Return<Error> setPowerMode(Display display, PowerMode mode) override;
		Return<Error> setVsyncEnabled(Display display, Vsync enabled) override;
		Return<Error> setClientTargetSlotCount(
		Display display, uint32_t clientTargetSlotCount) override;
		Return<Error> setInputCommandQueue(
		const hardware::MQDescriptorSync<uint32_t>& descriptor) override;
		Return<void> getOutputCommandQueue(
		getOutputCommandQueue_cb hidl_cb) override;
		Return<void> executeCommands(
		uint32_t inLength, const hidl_vec<hidl_handle>& inHandles,
		executeCommands_cb hidl_cb) override;

		private:
		bool parseSetLayerInfo(uint16_t length);
		bool parseSetClientTargetMetadata(uint16_t length);
		bool parseSetLayerBufferMetadata(uint16_t length);

		IVrComposerClient::BufferMetadata readBufferMetadata();

		VrComposerClient& mVrClient;
		android::dvr::VrHwc& mVrHal;

		VrCommandReader(const VrCommandReader&) = delete;
		void operator=(const VrCommandReader&) = delete;
		};

		std::unique_ptr<CommandReader> createCommandReader() override;

		dvr::VrHwc& mVrHal;
		std::unique_ptr<ComposerClient> client_;

		VrComposerClient(const VrComposerClient&) = delete;
		void operator=(const VrComposerClient&) = delete;

services/vr/hardware_composer/impl/vr_hwc.cpp

+0 −8

Original line number	Diff line number	Diff line
		@@ -820,7 +820,6 @@ Return<void> VrHwc::createClient(createClient_cb hidl_cb) {
		sp<VrComposerClient> client;
		if (client_ == nullptr) {
		client = new VrComposerClient(*this);
		client->initialize();
		} else {
		ALOGE("Already have a client");
		status = Error::NO_RESOURCES;
		@@ -852,12 +851,5 @@ HwcDisplay* VrHwc::FindDisplay(Display display) {
		return iter == displays_.end() ? nullptr : iter->second.get();
		}

		ComposerView* GetComposerViewFromIComposer(
		hardware::graphics::composer::V2_1::IComposer* composer) {
		return static_cast<VrHwc*>(composer);
		}

		IComposer* HIDL_FETCH_IComposer(const char*) { return new VrHwc(); }

		} // namespace dvr
		} // namespace android

services/vr/hardware_composer/impl/vr_hwc.h

+0 −7

Original line number	Diff line number	Diff line
		@@ -309,13 +309,6 @@ class VrHwc : public IComposer, public ComposerBase, public ComposerView {
		void operator=(const VrHwc&) = delete;
		};


		ComposerView* GetComposerViewFromIComposer(
		hardware::graphics::composer::V2_1::IComposer* composer);

		hardware::graphics::composer::V2_1::IComposer* HIDL_FETCH_IComposer(
		const char* name);

		} // namespace dvr
		} // namespace android