Merge "Dump OverlayProperties" into main (94140315) · Commits · e / os / android_frameworks_native

libs/ui/DebugUtils.cpp

+62 −51

Original line number	Diff line number	Diff line
		@@ -22,14 +22,12 @@
		#include <android-base/stringprintf.h>
		#include <string>

		using android::base::StringAppendF;
		using android::base::StringPrintf;
		using android::ui::ColorMode;
		using android::ui::RenderIntent;

		std::string decodeStandard(android_dataspace dataspace) {
		const uint32_t dataspaceSelect = (dataspace & HAL_DATASPACE_STANDARD_MASK);
		switch (dataspaceSelect) {
		std::string decodeStandardOnly(uint32_t dataspaceStandard) {
		switch (dataspaceStandard) {
		case HAL_DATASPACE_STANDARD_BT709:
		return std::string("BT709");

		@@ -62,8 +60,14 @@ std::string decodeStandard(android_dataspace dataspace) {

		case HAL_DATASPACE_STANDARD_ADOBE_RGB:
		return std::string("AdobeRGB");
		}

		return StringPrintf("Unknown dataspace code %d", dataspaceStandard);
		}

		case 0:
		std::string decodeStandard(android_dataspace dataspace) {
		const uint32_t dataspaceStandard = (dataspace & HAL_DATASPACE_STANDARD_MASK);
		if (dataspaceStandard == 0) {
		switch (dataspace & 0xffff) {
		case HAL_DATASPACE_JFIF:
		return std::string("(deprecated) JFIF (BT601_625)");
		@@ -90,35 +94,10 @@ std::string decodeStandard(android_dataspace dataspace) {
		return StringPrintf("Unknown deprecated dataspace code %d", dataspace);
		}
		}

		return StringPrintf("Unknown dataspace code %d", dataspaceSelect);
		return decodeStandardOnly(dataspaceStandard);
		}

		std::string decodeTransfer(android_dataspace dataspace) {
		const uint32_t dataspaceSelect = (dataspace & HAL_DATASPACE_STANDARD_MASK);
		if (dataspaceSelect == 0) {
		switch (dataspace & 0xffff) {
		case HAL_DATASPACE_JFIF:
		case HAL_DATASPACE_BT601_625:
		case HAL_DATASPACE_BT601_525:
		case HAL_DATASPACE_BT709:
		return std::string("SMPTE_170M");

		case HAL_DATASPACE_SRGB_LINEAR:
		case HAL_DATASPACE_ARBITRARY:
		return std::string("Linear");

		case HAL_DATASPACE_SRGB:
		return std::string("sRGB");

		case HAL_DATASPACE_UNKNOWN:
		// Fallthrough
		default:
		return std::string("");
		}
		}

		const uint32_t dataspaceTransfer = (dataspace & HAL_DATASPACE_TRANSFER_MASK);
		std::string decodeTransferOnly(uint32_t dataspaceTransfer) {
		switch (dataspaceTransfer) {
		case HAL_DATASPACE_TRANSFER_UNSPECIFIED:
		return std::string("Unspecified");
		@@ -151,29 +130,35 @@ std::string decodeTransfer(android_dataspace dataspace) {
		return StringPrintf("Unknown dataspace transfer %d", dataspaceTransfer);
		}

		std::string decodeRange(android_dataspace dataspace) {
		std::string decodeTransfer(android_dataspace dataspace) {
		const uint32_t dataspaceSelect = (dataspace & HAL_DATASPACE_STANDARD_MASK);
		if (dataspaceSelect == 0) {
		switch (dataspace & 0xffff) {
		case HAL_DATASPACE_JFIF:
		case HAL_DATASPACE_SRGB_LINEAR:
		case HAL_DATASPACE_SRGB:
		return std::string("Full range");

		case HAL_DATASPACE_BT601_625:
		case HAL_DATASPACE_BT601_525:
		case HAL_DATASPACE_BT709:
		return std::string("Limited range");
		return std::string("SMPTE_170M");

		case HAL_DATASPACE_SRGB_LINEAR:
		case HAL_DATASPACE_ARBITRARY:
		return std::string("Linear");

		case HAL_DATASPACE_SRGB:
		return std::string("sRGB");

		case HAL_DATASPACE_UNKNOWN:
		// Fallthrough
		default:
		return std::string("unspecified range");
		return std::string("");
		}
		}

		const uint32_t dataspaceRange = (dataspace & HAL_DATASPACE_RANGE_MASK);
		const uint32_t dataspaceTransfer = (dataspace & HAL_DATASPACE_TRANSFER_MASK);
		return decodeTransferOnly(dataspaceTransfer);
		}

		std::string decodeRangeOnly(uint32_t dataspaceRange) {
		switch (dataspaceRange) {
		case HAL_DATASPACE_RANGE_UNSPECIFIED:
		return std::string("Range Unspecified");
		@@ -191,6 +176,32 @@ std::string decodeRange(android_dataspace dataspace) {
		return StringPrintf("Unknown dataspace range %d", dataspaceRange);
		}

		std::string decodeRange(android_dataspace dataspace) {
		const uint32_t dataspaceSelect = (dataspace & HAL_DATASPACE_STANDARD_MASK);
		if (dataspaceSelect == 0) {
		switch (dataspace & 0xffff) {
		case HAL_DATASPACE_JFIF:
		case HAL_DATASPACE_SRGB_LINEAR:
		case HAL_DATASPACE_SRGB:
		return std::string("Full range");

		case HAL_DATASPACE_BT601_625:
		case HAL_DATASPACE_BT601_525:
		case HAL_DATASPACE_BT709:
		return std::string("Limited range");

		case HAL_DATASPACE_ARBITRARY:
		case HAL_DATASPACE_UNKNOWN:
		// Fallthrough
		default:
		return std::string("unspecified range");
		}
		}

		const uint32_t dataspaceRange = (dataspace & HAL_DATASPACE_RANGE_MASK);
		return decodeRangeOnly(dataspaceRange);
		}

		std::string dataspaceDetails(android_dataspace dataspace) {
		if (dataspace == 0) {
		return "Default";

libs/ui/include/ui/DebugUtils.h

+3 −0

Original line number	Diff line number	Diff line
		@@ -27,8 +27,11 @@ struct DeviceProductInfo;
		}

		std::string decodeStandard(android_dataspace dataspace);
		std::string decodeStandardOnly(uint32_t dataspaceStandard);
		std::string decodeTransfer(android_dataspace dataspace);
		std::string decodeTransferOnly(uint32_t dataspaceTransfer);
		std::string decodeRange(android_dataspace dataspace);
		std::string decodeRangeOnly(uint32_t dataspaceRange);
		std::string dataspaceDetails(android_dataspace dataspace);
		std::string decodeColorMode(android::ui::ColorMode colormode);
		std::string decodeColorTransform(android_color_transform colorTransform);

services/surfaceflinger/CompositionEngine/tests/MockHWComposer.h

+1 −0

Original line number	Diff line number	Diff line
		@@ -126,6 +126,7 @@ public:
		const std::unordered_map<std::string, bool>&());

		MOCK_CONST_METHOD1(dump, void(std::string&));
		MOCK_CONST_METHOD1(dumpOverlayProperties, void(std::string&));
		MOCK_CONST_METHOD0(getComposer, android::Hwc2::Composer*());

		MOCK_METHOD(hal::HWDisplayId, getPrimaryHwcDisplayId, (), (const, override));

services/surfaceflinger/DisplayHardware/HWComposer.cpp

+37 −2

Original line number	Diff line number	Diff line
		@@ -77,9 +77,7 @@ using aidl::android::hardware::graphics::common::HdrConversionCapability;
		using aidl::android::hardware::graphics::common::HdrConversionStrategy;
		using aidl::android::hardware::graphics::composer3::Capability;
		using aidl::android::hardware::graphics::composer3::DisplayCapability;
		using aidl::android::hardware::graphics::composer3::VrrConfig;
		using namespace std::string_literals;
		namespace hal = android::hardware::graphics::composer::hal;

		namespace android {

		@@ -964,8 +962,45 @@ const std::unordered_map<std::string, bool>& HWComposer::getSupportedLayerGeneri
		return mSupportedLayerGenericMetadata;
		}

		void HWComposer::dumpOverlayProperties(std::string& result) const {
		// dump overlay properties
		result.append("OverlayProperties:\n");
		base::StringAppendF(&result, "supportMixedColorSpaces: %d\n",
		mOverlayProperties.supportMixedColorSpaces);
		base::StringAppendF(&result, "SupportedBufferCombinations(%zu entries)\n",
		mOverlayProperties.combinations.size());
		for (const auto& combination : mOverlayProperties.combinations) {
		result.append(" pixelFormats=\n");
		for (const auto& pixelFormat : combination.pixelFormats) {
		base::StringAppendF(&result, " %s (%d)\n",
		decodePixelFormat(static_cast<PixelFormat>(pixelFormat)).c_str(),
		static_cast<uint32_t>(pixelFormat));
		}
		result.append(" standards=\n");
		for (const auto& standard : combination.standards) {
		base::StringAppendF(&result, " %s (%d)\n",
		decodeStandard(static_cast<android_dataspace>(standard)).c_str(),
		static_cast<uint32_t>(standard));
		}
		result.append(" transfers=\n");
		for (const auto& transfer : combination.transfers) {
		base::StringAppendF(&result, " %s (%d)\n",
		decodeTransferOnly(static_cast<uint32_t>(transfer)).c_str(),
		static_cast<uint32_t>(transfer));
		}
		result.append(" ranges=\n");
		for (const auto& range : combination.ranges) {
		base::StringAppendF(&result, " %s (%d)\n",
		decodeRangeOnly(static_cast<uint32_t>(range)).c_str(),
		static_cast<uint32_t>(range));
		}
		result.append("\n");
		}
		}

		void HWComposer::dump(std::string& result) const {
		result.append(mComposer->dumpDebugInfo());
		dumpOverlayProperties(result);
		}

		std::optional<PhysicalDisplayId> HWComposer::toPhysicalDisplayId(

services/surfaceflinger/DisplayHardware/HWComposer.h

+3 −0

Original line number	Diff line number	Diff line
		@@ -269,6 +269,8 @@ public:

		virtual void dump(std::string& out) const = 0;

		virtual void dumpOverlayProperties(std::string& out) const = 0;

		virtual Hwc2::Composer* getComposer() const = 0;

		// Returns the first display connected at boot. Its connection via HWComposer::onHotplug,
		@@ -468,6 +470,7 @@ public:

		// for debugging ----------------------------------------------------------
		void dump(std::string& out) const override;
		void dumpOverlayProperties(std::string& out) const override;

		Hwc2::Composer* getComposer() const override { return mComposer.get(); }