Merge "graphics: Clean up VTS boilerplate for composer" (33e96876) · Commits · e / os / android_hardware_interfaces

graphics/composer/2.1/utils/vts/ComposerVts.cpp

+10 −12

Original line number	Diff line number	Diff line
		@@ -25,21 +25,19 @@ namespace composer {
		namespace V2_1 {
		namespace vts {

		Composer::Composer() {
		mComposer = ::testing::VtsHalHidlTargetTestBase::getService<IComposer>();
		init();
		}
		Composer::Composer() : Composer(::testing::VtsHalHidlTargetTestBase::getService<IComposer>()) {}

		Composer::Composer(const std::string& name) {
		mComposer = ::testing::VtsHalHidlTargetTestBase::getService<IComposer>(name);
		init();
		}
		Composer::Composer(const std::string& name)
		: Composer(::testing::VtsHalHidlTargetTestBase::getService<IComposer>(name)) {}

		void Composer::init() {
		Composer::Composer(const sp<IComposer>& composer) : mComposer(composer) {
		// ASSERT_* can only be used in functions returning void.
		[this] {
		ASSERT_NE(nullptr, mComposer.get()) << "failed to get composer service";

		std::vector<IComposer::Capability> capabilities = getCapabilities();
		mCapabilities.insert(capabilities.begin(), capabilities.end());
		}();
		}

		sp<IComposer> Composer::getRaw() const {

graphics/composer/2.1/utils/vts/include/composer-vts/2.1/ComposerVts.h

+4 −4

Original line number	Diff line number	Diff line
		@@ -57,10 +57,10 @@ class Composer {
		std::unique_ptr<ComposerClient> createClient();

		protected:
		sp<IComposer> mComposer;
		explicit Composer(const sp<IComposer>& composer);

		private:
		void init();
		const sp<IComposer> mComposer;

		std::unordered_set<IComposer::Capability> mCapabilities;
		};
		@@ -68,7 +68,7 @@ class Composer {
		// A wrapper to IComposerClient.
		class ComposerClient {
		public:
		ComposerClient(const sp<IComposerClient>& client);
		explicit ComposerClient(const sp<IComposerClient>& client);
		~ComposerClient();

		sp<IComposerClient> getRaw() const;
		@@ -116,7 +116,7 @@ class ComposerClient {
		std::unordered_map<Display, DisplayResource> mDisplayResources;

		private:
		sp<IComposerClient> mClient;
		const sp<IComposerClient> mClient;
		};

		} // namespace vts

graphics/composer/2.2/utils/vts/ComposerVts.cpp

+55 −60

Original line number	Diff line number	Diff line
		@@ -27,28 +27,27 @@ namespace composer {
		namespace V2_2 {
		namespace vts {

		using android::hardware::details::canCastInterface;
		using android::hardware::details::getDescriptor;
		using android::hardware::graphics::composer::V2_2::IComposerClient;
		using details::canCastInterface;
		using details::getDescriptor;

		std::unique_ptr<ComposerClient_v2_2> Composer_v2_2::createClient_v2_2() {
		std::unique_ptr<ComposerClient_v2_2> client;
		mComposer->createClient([&](const auto& tmpError, const auto& tmpClient) {
		std::unique_ptr<ComposerClient> Composer::createClient() {
		std::unique_ptr<ComposerClient> client;
		getRaw()->createClient([&](const auto& tmpError, const auto& tmpClient) {
		ASSERT_EQ(Error::NONE, tmpError) << "failed to create client";
		ALOGV("tmpClient is a %s", getDescriptor(&(*tmpClient)).c_str());
		ASSERT_TRUE(canCastInterface(
		&(*tmpClient), "android.hardware.graphics.composer@2.2::IComposerClient", false))
		<< "Cannot create 2.2 IComposerClient";
		client = std::make_unique<ComposerClient_v2_2>(IComposerClient::castFrom(tmpClient, true));
		client = std::make_unique<ComposerClient>(IComposerClient::castFrom(tmpClient, true));
		});

		return client;
		}

		std::vector<IComposerClient::PerFrameMetadataKey> ComposerClient_v2_2::getPerFrameMetadataKeys(
		std::vector<IComposerClient::PerFrameMetadataKey> ComposerClient::getPerFrameMetadataKeys(
		Display display) {
		std::vector<IComposerClient::PerFrameMetadataKey> keys;
		mClient_v2_2->getPerFrameMetadataKeys(display, [&](const auto& tmpError, const auto& tmpKeys) {
		mClient->getPerFrameMetadataKeys(display, [&](const auto& tmpError, const auto& tmpKeys) {
		ASSERT_EQ(Error::NONE, tmpError) << "failed to get HDR metadata keys";
		keys = tmpKeys;
		});
		@@ -56,26 +55,25 @@ std::vector<IComposerClient::PerFrameMetadataKey> ComposerClient_v2_2::getPerFra
		return keys;
		}

		void ComposerClient_v2_2::execute_v2_2(V2_1::vts::TestCommandReader* reader,
		V2_2::CommandWriterBase* writer) {
		void ComposerClient::execute(V2_1::vts::TestCommandReader* reader, CommandWriterBase* writer) {
		bool queueChanged = false;
		uint32_t commandLength = 0;
		hidl_vec<hidl_handle> commandHandles;
		ASSERT_TRUE(writer->writeQueue(&queueChanged, &commandLength, &commandHandles));

		if (queueChanged) {
		auto ret = mClient_v2_2->setInputCommandQueue(*writer->getMQDescriptor());
		auto ret = mClient->setInputCommandQueue(*writer->getMQDescriptor());
		ASSERT_EQ(Error::NONE, static_cast<Error>(ret));
		return;
		}

		mClient_v2_2->executeCommands(commandLength, commandHandles,
		mClient->executeCommands(commandLength, commandHandles,
		[&](const auto& tmpError, const auto& tmpOutQueueChanged,
		const auto& tmpOutLength, const auto& tmpOutHandles) {
		ASSERT_EQ(Error::NONE, tmpError);

		if (tmpOutQueueChanged) {
		mClient_v2_2->getOutputCommandQueue(
		mClient->getOutputCommandQueue(
		[&](const auto& tmpError, const auto& tmpDescriptor) {
		ASSERT_EQ(Error::NONE, tmpError);
		reader->setMQDescriptor(tmpDescriptor);
		@@ -87,12 +85,12 @@ void ComposerClient_v2_2::execute_v2_2(V2_1::vts::TestCommandReader* reader,
		});
		}

		Display ComposerClient_v2_2::createVirtualDisplay_2_2(uint32_t width, uint32_t height,
		Display ComposerClient::createVirtualDisplay_2_2(uint32_t width, uint32_t height,
		PixelFormat formatHint,
		uint32_t outputBufferSlotCount,
		PixelFormat* outFormat) {
		Display display = 0;
		mClient_v2_2->createVirtualDisplay_2_2(
		mClient->createVirtualDisplay_2_2(
		width, height, formatHint, outputBufferSlotCount,
		[&](const auto& tmpError, const auto& tmpDisplay, const auto& tmpFormat) {
		ASSERT_EQ(Error::NONE, tmpError) << "failed to create virtual display";
		@@ -106,29 +104,27 @@ Display ComposerClient_v2_2::createVirtualDisplay_2_2(uint32_t width, uint32_t h
		return display;
		}

		bool ComposerClient_v2_2::getClientTargetSupport_2_2(Display display, uint32_t width,
		uint32_t height, PixelFormat format,
		Dataspace dataspace) {
		Error error =
		mClient_v2_2->getClientTargetSupport_2_2(display, width, height, format, dataspace);
		bool ComposerClient::getClientTargetSupport_2_2(Display display, uint32_t width, uint32_t height,
		PixelFormat format, Dataspace dataspace) {
		Error error = mClient->getClientTargetSupport_2_2(display, width, height, format, dataspace);
		return error == Error::NONE;
		}

		void ComposerClient_v2_2::setPowerMode_2_2(Display display, V2_2::IComposerClient::PowerMode mode) {
		Error error = mClient_v2_2->setPowerMode_2_2(display, mode);
		void ComposerClient::setPowerMode_2_2(Display display, IComposerClient::PowerMode mode) {
		Error error = mClient->setPowerMode_2_2(display, mode);
		ASSERT_TRUE(error == Error::NONE \|\| error == Error::UNSUPPORTED) << "failed to set power mode";
		}

		void ComposerClient_v2_2::setReadbackBuffer(Display display, const native_handle_t* buffer,
		void ComposerClient::setReadbackBuffer(Display display, const native_handle_t* buffer,
		int32_t /* releaseFence */) {
		// Ignoring fence, HIDL doesn't care
		Error error = mClient_v2_2->setReadbackBuffer(display, buffer, nullptr);
		Error error = mClient->setReadbackBuffer(display, buffer, nullptr);
		ASSERT_EQ(Error::NONE, error) << "failed to setReadbackBuffer";
		}

		void ComposerClient_v2_2::getReadbackBufferAttributes(Display display, PixelFormat* outPixelFormat,
		void ComposerClient::getReadbackBufferAttributes(Display display, PixelFormat* outPixelFormat,
		Dataspace* outDataspace) {
		mClient_v2_2->getReadbackBufferAttributes(
		mClient->getReadbackBufferAttributes(
		display,
		[&](const auto& tmpError, const auto& tmpOutPixelFormat, const auto& tmpOutDataspace) {
		ASSERT_EQ(Error::NONE, tmpError) << "failed to get readback buffer attributes";
		@@ -137,42 +133,41 @@ void ComposerClient_v2_2::getReadbackBufferAttributes(Display display, PixelForm
		});
		}

		void ComposerClient_v2_2::getReadbackBufferFence(Display display, int32_t* outFence) {
		void ComposerClient::getReadbackBufferFence(Display display, int32_t* outFence) {
		hidl_handle handle;
		mClient_v2_2->getReadbackBufferFence(display, [&](const auto& tmpError, const auto& tmpHandle) {
		mClient->getReadbackBufferFence(display, [&](const auto& tmpError, const auto& tmpHandle) {
		ASSERT_EQ(Error::NONE, tmpError) << "failed to get readback fence";
		handle = tmpHandle;
		});
		*outFence = 0;
		}

		std::vector<ColorMode> ComposerClient_v2_2::getColorModes(Display display) {
		std::vector<ColorMode> ComposerClient::getColorModes(Display display) {
		std::vector<ColorMode> modes;
		mClient_v2_2->getColorModes_2_2(display, [&](const auto& tmpError, const auto& tmpModes) {
		mClient->getColorModes_2_2(display, [&](const auto& tmpError, const auto& tmpModes) {
		ASSERT_EQ(Error::NONE, tmpError) << "failed to get color modes";
		modes = tmpModes;
		});
		return modes;
		}

		std::vector<RenderIntent> ComposerClient_v2_2::getRenderIntents(Display display, ColorMode mode) {
		std::vector<RenderIntent> ComposerClient::getRenderIntents(Display display, ColorMode mode) {
		std::vector<RenderIntent> intents;
		mClient_v2_2->getRenderIntents(
		display, mode, [&](const auto& tmpError, const auto& tmpIntents) {
		mClient->getRenderIntents(display, mode, [&](const auto& tmpError, const auto& tmpIntents) {
		ASSERT_EQ(Error::NONE, tmpError) << "failed to get render intents";
		intents = tmpIntents;
		});
		return intents;
		}

		void ComposerClient_v2_2::setColorMode(Display display, ColorMode mode, RenderIntent intent) {
		Error error = mClient_v2_2->setColorMode_2_2(display, mode, intent);
		void ComposerClient::setColorMode(Display display, ColorMode mode, RenderIntent intent) {
		Error error = mClient->setColorMode_2_2(display, mode, intent);
		ASSERT_TRUE(error == Error::NONE \|\| error == Error::UNSUPPORTED) << "failed to set color mode";
		}

		std::array<float, 16> ComposerClient_v2_2::getDataspaceSaturationMatrix(Dataspace dataspace) {
		std::array<float, 16> ComposerClient::getDataspaceSaturationMatrix(Dataspace dataspace) {
		std::array<float, 16> matrix;
		mClient_v2_2->getDataspaceSaturationMatrix(
		mClient->getDataspaceSaturationMatrix(
		dataspace, [&](const auto& tmpError, const auto& tmpMatrix) {
		ASSERT_EQ(Error::NONE, tmpError) << "failed to get datasapce saturation matrix";
		std::copy_n(tmpMatrix.data(), matrix.size(), matrix.begin());

graphics/composer/2.2/utils/vts/include/composer-vts/2.2/ComposerVts.h

+18 −23

Original line number	Diff line number	Diff line
		@@ -36,34 +36,29 @@ namespace composer {
		namespace V2_2 {
		namespace vts {

		using android::hardware::graphics::common::V1_0::Hdr;
		using android::hardware::graphics::common::V1_1::ColorMode;
		using android::hardware::graphics::common::V1_1::Dataspace;
		using android::hardware::graphics::common::V1_1::PixelFormat;
		using android::hardware::graphics::common::V1_1::RenderIntent;
		using android::hardware::graphics::composer::V2_2::IComposer;
		using android::hardware::graphics::composer::V2_2::IComposerClient;

		class ComposerClient_v2_2;

		// Only thing I need for Composer_v2_2 is to create a v2_2 ComposerClient
		// Everything else is the same
		class Composer_v2_2 : public V2_1::vts::Composer {
		using common::V1_0::Hdr;
		using common::V1_1::ColorMode;
		using common::V1_1::Dataspace;
		using common::V1_1::PixelFormat;
		using common::V1_1::RenderIntent;

		class ComposerClient;

		// A wrapper to IComposer.
		class Composer : public V2_1::vts::Composer {
		public:
		Composer_v2_2() : V2_1::vts::Composer(){};
		explicit Composer_v2_2(const std::string& name) : V2_1::vts::Composer(name){};
		using V2_1::vts::Composer::Composer;

		std::unique_ptr<ComposerClient_v2_2> createClient_v2_2();
		std::unique_ptr<ComposerClient> createClient();
		};

		// A wrapper to IComposerClient.
		class ComposerClient_v2_2
		: public android::hardware::graphics::composer::V2_1::vts::ComposerClient {
		class ComposerClient : public V2_1::vts::ComposerClient {
		public:
		ComposerClient_v2_2(const sp<IComposerClient>& client)
		: V2_1::vts::ComposerClient(client), mClient_v2_2(client){};
		explicit ComposerClient(const sp<IComposerClient>& client)
		: V2_1::vts::ComposerClient(client), mClient(client) {}

		void execute_v2_2(V2_1::vts::TestCommandReader* reader, V2_2::CommandWriterBase* writer);
		void execute(V2_1::vts::TestCommandReader* reader, CommandWriterBase* writer);

		std::vector<IComposerClient::PerFrameMetadataKey> getPerFrameMetadataKeys(Display display);

		@@ -71,7 +66,7 @@ class ComposerClient_v2_2
		uint32_t outputBufferSlotCount, PixelFormat* outFormat);
		bool getClientTargetSupport_2_2(Display display, uint32_t width, uint32_t height,
		PixelFormat format, Dataspace dataspace);
		void setPowerMode_2_2(Display display, V2_2::IComposerClient::PowerMode mode);
		void setPowerMode_2_2(Display display, IComposerClient::PowerMode mode);
		void setReadbackBuffer(Display display, const native_handle_t* buffer, int32_t releaseFence);
		void getReadbackBufferAttributes(Display display, PixelFormat* outPixelFormat,
		Dataspace* outDataspace);
		@@ -84,7 +79,7 @@ class ComposerClient_v2_2
		std::array<float, 16> getDataspaceSaturationMatrix(Dataspace dataspace);

		private:
		sp<V2_2::IComposerClient> mClient_v2_2;
		const sp<IComposerClient> mClient;
		};

		} // namespace vts

graphics/composer/2.2/vts/functional/VtsHalGraphicsComposerV2_2TargetTest.cpp

+16 −18

Original line number	Diff line number	Diff line
		@@ -32,17 +32,15 @@ namespace V2_2 {
		namespace vts {
		namespace {

		using android::hardware::graphics::common::V1_0::BufferUsage;
		using android::hardware::graphics::common::V1_0::ColorTransform;
		using android::hardware::graphics::common::V1_0::Transform;
		using android::hardware::graphics::common::V1_1::ColorMode;
		using android::hardware::graphics::common::V1_1::Dataspace;
		using android::hardware::graphics::common::V1_1::PixelFormat;
		using android::hardware::graphics::common::V1_1::RenderIntent;
		using android::hardware::graphics::composer::V2_2::IComposerClient;
		using android::hardware::graphics::mapper::V2_1::IMapper;
		using android::hardware::graphics::mapper::V2_1::vts::Gralloc;
		using GrallocError = android::hardware::graphics::mapper::V2_0::Error;
		using common::V1_0::BufferUsage;
		using common::V1_0::ColorTransform;
		using common::V1_0::Transform;
		using common::V1_1::ColorMode;
		using common::V1_1::Dataspace;
		using common::V1_1::PixelFormat;
		using common::V1_1::RenderIntent;
		using mapper::V2_1::IMapper;
		using mapper::V2_1::vts::Gralloc;

		// Test environment for graphics.composer
		class GraphicsComposerHidlEnvironment : public ::testing::VtsHalHidlTargetTestEnvBase {
		@@ -65,9 +63,9 @@ class GraphicsComposerHidlTest : public ::testing::VtsHalHidlTargetTestBase {
		protected:
		void SetUp() override {
		ASSERT_NO_FATAL_FAILURE(
		mComposer = std::make_unique<Composer_v2_2>(
		mComposer = std::make_unique<Composer>(
		GraphicsComposerHidlEnvironment::Instance()->getServiceName<IComposer>()));
		ASSERT_NO_FATAL_FAILURE(mComposerClient = mComposer->createClient_v2_2());
		ASSERT_NO_FATAL_FAILURE(mComposerClient = mComposer->createClient());

		mComposerCallback = new V2_1::vts::GraphicsComposerCallback;
		mComposerClient->registerCallback(mComposerCallback);
		@@ -91,8 +89,8 @@ class GraphicsComposerHidlTest : public ::testing::VtsHalHidlTargetTestBase {
		// use the slot count usually set by SF
		static constexpr uint32_t kBufferSlotCount = 64;

		std::unique_ptr<Composer_v2_2> mComposer;
		std::unique_ptr<ComposerClient_v2_2> mComposerClient;
		std::unique_ptr<Composer> mComposer;
		std::unique_ptr<ComposerClient> mComposerClient;
		sp<V2_1::vts::GraphicsComposerCallback> mComposerCallback;
		// the first display and is assumed never to be removed
		Display mPrimaryDisplay;
		@@ -119,7 +117,7 @@ class GraphicsComposerHidlCommandTest : public GraphicsComposerHidlTest {

		ASSERT_NO_FATAL_FAILURE(mGralloc = std::make_unique<Gralloc>());

		mWriter = std::make_unique<V2_2::CommandWriterBase>(1024);
		mWriter = std::make_unique<CommandWriterBase>(1024);
		mReader = std::make_unique<V2_1::vts::TestCommandReader>();
		}

		@@ -137,9 +135,9 @@ class GraphicsComposerHidlCommandTest : public GraphicsComposerHidlTest {
		return mGralloc->allocate(info);
		}

		void execute() { mComposerClient->execute_v2_2(mReader.get(), mWriter.get()); }
		void execute() { mComposerClient->execute(mReader.get(), mWriter.get()); }

		std::unique_ptr<V2_2::CommandWriterBase> mWriter;
		std::unique_ptr<CommandWriterBase> mWriter;
		std::unique_ptr<V2_1::vts::TestCommandReader> mReader;

		private: