diff options
19 files changed, 317 insertions, 0 deletions
diff --git a/libs/gui/SurfaceComposerClient.cpp b/libs/gui/SurfaceComposerClient.cpp index a2ed8aa8ab..4eace52f1c 100644 --- a/libs/gui/SurfaceComposerClient.cpp +++ b/libs/gui/SurfaceComposerClient.cpp @@ -2496,6 +2496,20 @@ status_t SurfaceComposerClient::clearBootDisplayMode(const sp<IBinder>& display) return statusTFromBinderStatus(status); } +status_t SurfaceComposerClient::getHdrConversionCapabilities( + std::vector<gui::HdrConversionCapability>* hdrConversionCapabilities) { + binder::Status status = ComposerServiceAIDL::getComposerService()->getHdrConversionCapabilities( + hdrConversionCapabilities); + return statusTFromBinderStatus(status); +} + +status_t SurfaceComposerClient::setHdrConversionStrategy( + gui::HdrConversionStrategy hdrConversionStrategy) { + binder::Status status = ComposerServiceAIDL::getComposerService()->setHdrConversionStrategy( + hdrConversionStrategy); + return statusTFromBinderStatus(status); +} + status_t SurfaceComposerClient::setOverrideFrameRate(uid_t uid, float frameRate) { binder::Status status = ComposerServiceAIDL::getComposerService()->setOverrideFrameRate(uid, frameRate); diff --git a/libs/gui/aidl/android/gui/HdrConversionCapability.aidl b/libs/gui/aidl/android/gui/HdrConversionCapability.aidl new file mode 100644 index 0000000000..1bcfd38eff --- /dev/null +++ b/libs/gui/aidl/android/gui/HdrConversionCapability.aidl @@ -0,0 +1,25 @@ +/* + * Copyright 2022 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package android.gui; + +// TODO(b/265277221): use android.hardware.graphics.common.HdrConversionCapability.aidl +/** @hide */ +parcelable HdrConversionCapability { + int sourceType; + int outputType; + boolean addsLatency; +}
\ No newline at end of file diff --git a/libs/gui/aidl/android/gui/HdrConversionStrategy.aidl b/libs/gui/aidl/android/gui/HdrConversionStrategy.aidl new file mode 100644 index 0000000000..1be74b46e7 --- /dev/null +++ b/libs/gui/aidl/android/gui/HdrConversionStrategy.aidl @@ -0,0 +1,25 @@ +/* + * Copyright 2022 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package android.gui; + +// TODO(b/265277221): use android.hardware.graphics.common.HdrConversionStrategy.aidl +/** @hide */ +union HdrConversionStrategy { + boolean passthrough = true; + int[] autoAllowedHdrTypes; + int forceHdrConversion; +} diff --git a/libs/gui/aidl/android/gui/ISurfaceComposer.aidl b/libs/gui/aidl/android/gui/ISurfaceComposer.aidl index a0b613c059..c08a7c67ae 100644 --- a/libs/gui/aidl/android/gui/ISurfaceComposer.aidl +++ b/libs/gui/aidl/android/gui/ISurfaceComposer.aidl @@ -30,6 +30,8 @@ import android.gui.DisplayStatInfo; import android.gui.DynamicDisplayInfo; import android.gui.FrameEvent; import android.gui.FrameStats; +import android.gui.HdrConversionCapability; +import android.gui.HdrConversionStrategy; import android.gui.IDisplayEventConnection; import android.gui.IFpsListener; import android.gui.IHdrLayerInfoListener; @@ -162,6 +164,26 @@ interface ISurfaceComposer { boolean getBootDisplayModeSupport(); /** + * Gets the HDR conversion capabilities of the device. The conversion capability defines whether + * conversion from sourceType to outputType is possible (with or without latency). + * + * Requires the ACCESS_SURFACE_FLINGER permission. + */ + List<HdrConversionCapability> getHdrConversionCapabilities(); + + /** + * Sets the HDR conversion strategy of the device. + * + * Requires the ACCESS_SURFACE_FLINGER permission. + */ + void setHdrConversionStrategy(in HdrConversionStrategy hdrConversionStrategy); + + /** + * Gets whether HDR output conversion operations are supported on the device. + */ + boolean getHdrOutputConversionSupport(); + + /** * Switches Auto Low Latency Mode on/off on the connected display, if it is * available. This should only be called if the display supports Auto Low * Latency Mode as reported in #getDynamicDisplayInfo. diff --git a/libs/gui/fuzzer/libgui_fuzzer_utils.h b/libs/gui/fuzzer/libgui_fuzzer_utils.h index 8810e4e83a..685bd9290d 100644 --- a/libs/gui/fuzzer/libgui_fuzzer_utils.h +++ b/libs/gui/fuzzer/libgui_fuzzer_utils.h @@ -91,6 +91,11 @@ public: MOCK_METHOD(binder::Status, setBootDisplayMode, (const sp<IBinder>&, int), (override)); MOCK_METHOD(binder::Status, clearBootDisplayMode, (const sp<IBinder>&), (override)); MOCK_METHOD(binder::Status, getBootDisplayModeSupport, (bool*), (override)); + MOCK_METHOD(binder::Status, getHdrConversionCapabilities, + (std::vector<gui::HdrConversionCapability>*), (override)); + MOCK_METHOD(binder::Status, setHdrConversionStrategy, (const gui::HdrConversionStrategy&), + (override)); + MOCK_METHOD(binder::Status, getHdrOutputConversionSupport, (bool*), (override)); MOCK_METHOD(binder::Status, setAutoLowLatencyMode, (const sp<IBinder>&, bool), (override)); MOCK_METHOD(binder::Status, setGameContentType, (const sp<IBinder>&, bool), (override)); MOCK_METHOD(binder::Status, captureDisplay, diff --git a/libs/gui/include/gui/SurfaceComposerClient.h b/libs/gui/include/gui/SurfaceComposerClient.h index cc459c53b5..c3532d4843 100644 --- a/libs/gui/include/gui/SurfaceComposerClient.h +++ b/libs/gui/include/gui/SurfaceComposerClient.h @@ -200,6 +200,11 @@ public: // Clears the user-preferred display mode static status_t clearBootDisplayMode(const sp<IBinder>& display); + // Gets the HDR conversion capabilities of the device + static status_t getHdrConversionCapabilities(std::vector<gui::HdrConversionCapability>*); + // Sets the HDR conversion strategy for the device + static status_t setHdrConversionStrategy(gui::HdrConversionStrategy hdrConversionStrategy); + // Sets the frame rate of a particular app (uid). This is currently called // by GameManager. static status_t setOverrideFrameRate(uid_t uid, float frameRate); diff --git a/libs/gui/tests/Surface_test.cpp b/libs/gui/tests/Surface_test.cpp index 55242dfd39..30148042fb 100644 --- a/libs/gui/tests/Surface_test.cpp +++ b/libs/gui/tests/Surface_test.cpp @@ -819,6 +819,20 @@ public: return binder::Status::ok(); } + binder::Status getHdrConversionCapabilities( + std::vector<gui::HdrConversionCapability>*) override { + return binder::Status::ok(); + } + + binder::Status setHdrConversionStrategy( + const gui::HdrConversionStrategy& /*hdrConversionStrategy*/) override { + return binder::Status::ok(); + } + + binder::Status getHdrOutputConversionSupport(bool* /*outSupport*/) override { + return binder::Status::ok(); + } + binder::Status setAutoLowLatencyMode(const sp<IBinder>& /*display*/, bool /*on*/) override { return binder::Status::ok(); } diff --git a/services/surfaceflinger/CompositionEngine/tests/MockHWComposer.h b/services/surfaceflinger/CompositionEngine/tests/MockHWComposer.h index 33caa7a9b8..6199a5ae40 100644 --- a/services/surfaceflinger/CompositionEngine/tests/MockHWComposer.h +++ b/services/surfaceflinger/CompositionEngine/tests/MockHWComposer.h @@ -112,6 +112,11 @@ public: MOCK_METHOD1(clearBootDisplayMode, status_t(PhysicalDisplayId)); MOCK_METHOD1(getPreferredBootDisplayMode, std::optional<hal::HWConfigId>(PhysicalDisplayId)); MOCK_METHOD0(getBootDisplayModeSupport, bool()); + MOCK_CONST_METHOD0( + getHdrConversionCapabilities, + std::vector<aidl::android::hardware::graphics::common::HdrConversionCapability>()); + MOCK_METHOD1(setHdrConversionStrategy, + status_t(aidl::android::hardware::graphics::common::HdrConversionStrategy)); MOCK_METHOD2(setAutoLowLatencyMode, status_t(PhysicalDisplayId, bool)); MOCK_METHOD(status_t, getSupportedContentTypes, (PhysicalDisplayId, std::vector<hal::ContentType>*), (const, override)); diff --git a/services/surfaceflinger/DisplayHardware/AidlComposerHal.cpp b/services/surfaceflinger/DisplayHardware/AidlComposerHal.cpp index e372b72b33..9470552e41 100644 --- a/services/surfaceflinger/DisplayHardware/AidlComposerHal.cpp +++ b/services/surfaceflinger/DisplayHardware/AidlComposerHal.cpp @@ -56,6 +56,9 @@ using AidlDisplayContentSample = aidl::android::hardware::graphics::composer3::D using AidlDisplayAttribute = aidl::android::hardware::graphics::composer3::DisplayAttribute; using AidlDisplayCapability = aidl::android::hardware::graphics::composer3::DisplayCapability; using AidlHdrCapabilities = aidl::android::hardware::graphics::composer3::HdrCapabilities; +using AidlHdrConversionCapability = + aidl::android::hardware::graphics::common::HdrConversionCapability; +using AidlHdrConversionStrategy = aidl::android::hardware::graphics::common::HdrConversionStrategy; using AidlOverlayProperties = aidl::android::hardware::graphics::composer3::OverlayProperties; using AidlPerFrameMetadata = aidl::android::hardware::graphics::composer3::PerFrameMetadata; using AidlPerFrameMetadataKey = aidl::android::hardware::graphics::composer3::PerFrameMetadataKey; @@ -1396,6 +1399,27 @@ Error AidlComposer::getPreferredBootDisplayConfig(Display display, Config* confi return Error::NONE; } +Error AidlComposer::getHdrConversionCapabilities( + std::vector<AidlHdrConversionCapability>* hdrConversionCapabilities) { + const auto status = + mAidlComposerClient->getHdrConversionCapabilities(hdrConversionCapabilities); + if (!status.isOk()) { + hdrConversionCapabilities = {}; + ALOGE("getHdrConversionCapabilities failed %s", status.getDescription().c_str()); + return static_cast<Error>(status.getServiceSpecificError()); + } + return Error::NONE; +} + +Error AidlComposer::setHdrConversionStrategy(AidlHdrConversionStrategy hdrConversionStrategy) { + const auto status = mAidlComposerClient->setHdrConversionStrategy(hdrConversionStrategy); + if (!status.isOk()) { + ALOGE("setHdrConversionStrategy failed %s", status.getDescription().c_str()); + return static_cast<Error>(status.getServiceSpecificError()); + } + return Error::NONE; +} + Error AidlComposer::getClientTargetProperty( Display display, ClientTargetPropertyWithBrightness* outClientTargetProperty) { Error error = Error::NONE; diff --git a/services/surfaceflinger/DisplayHardware/AidlComposerHal.h b/services/surfaceflinger/DisplayHardware/AidlComposerHal.h index 9a7ade7437..a5ddf7457f 100644 --- a/services/surfaceflinger/DisplayHardware/AidlComposerHal.h +++ b/services/surfaceflinger/DisplayHardware/AidlComposerHal.h @@ -48,6 +48,8 @@ namespace android::Hwc2 { using aidl::android::hardware::graphics::common::DisplayDecorationSupport; +using aidl::android::hardware::graphics::common::HdrConversionCapability; +using aidl::android::hardware::graphics::common::HdrConversionStrategy; using aidl::android::hardware::graphics::composer3::ComposerClientReader; using aidl::android::hardware::graphics::composer3::ComposerClientWriter; using aidl::android::hardware::graphics::composer3::OverlayProperties; @@ -235,6 +237,8 @@ public: AidlTransform* outDisplayOrientation) override; void onHotplugConnect(Display) override; void onHotplugDisconnect(Display) override; + Error getHdrConversionCapabilities(std::vector<HdrConversionCapability>*) override; + Error setHdrConversionStrategy(HdrConversionStrategy) override; private: // Many public functions above simply write a command into the command diff --git a/services/surfaceflinger/DisplayHardware/ComposerHal.h b/services/surfaceflinger/DisplayHardware/ComposerHal.h index 1c2b8b52d9..82b677e7d4 100644 --- a/services/surfaceflinger/DisplayHardware/ComposerHal.h +++ b/services/surfaceflinger/DisplayHardware/ComposerHal.h @@ -32,6 +32,8 @@ #include <utils/StrongPointer.h> #include <aidl/android/hardware/graphics/common/DisplayDecorationSupport.h> +#include <aidl/android/hardware/graphics/common/HdrConversionCapability.h> +#include <aidl/android/hardware/graphics/common/HdrConversionStrategy.h> #include <aidl/android/hardware/graphics/composer3/Capability.h> #include <aidl/android/hardware/graphics/composer3/ClientTargetPropertyWithBrightness.h> #include <aidl/android/hardware/graphics/composer3/Color.h> @@ -288,6 +290,10 @@ public: virtual Error getOverlaySupport(V3_0::OverlayProperties* outProperties) = 0; virtual void onHotplugConnect(Display) = 0; virtual void onHotplugDisconnect(Display) = 0; + virtual Error getHdrConversionCapabilities( + std::vector<::aidl::android::hardware::graphics::common::HdrConversionCapability>*) = 0; + virtual Error setHdrConversionStrategy( + ::aidl::android::hardware::graphics::common::HdrConversionStrategy) = 0; }; } // namespace Hwc2 diff --git a/services/surfaceflinger/DisplayHardware/HWComposer.cpp b/services/surfaceflinger/DisplayHardware/HWComposer.cpp index 10fde2af8e..7dde6b4e44 100644 --- a/services/surfaceflinger/DisplayHardware/HWComposer.cpp +++ b/services/surfaceflinger/DisplayHardware/HWComposer.cpp @@ -70,6 +70,8 @@ #define RETURN_IF_HWC_ERROR(error, displayId, ...) \ RETURN_IF_HWC_ERROR_FOR(__FUNCTION__, error, displayId, __VA_ARGS__) +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; namespace hal = android::hardware::graphics::composer::hal; @@ -97,6 +99,7 @@ void HWComposer::setCallback(HWC2::ComposerCallback& callback) { loadCapabilities(); loadLayerMetadataSupport(); loadOverlayProperties(); + loadHdrConversionCapabilities(); if (mRegisteredCallback) { ALOGW("Callback already registered. Ignored extra registration attempt."); @@ -787,6 +790,18 @@ std::optional<hal::HWConfigId> HWComposer::getPreferredBootDisplayMode( return displayModeId; } +std::vector<HdrConversionCapability> HWComposer::getHdrConversionCapabilities() const { + return mHdrConversionCapabilities; +} + +status_t HWComposer::setHdrConversionStrategy(HdrConversionStrategy hdrConversionStrategy) { + const auto error = mComposer->setHdrConversionStrategy(hdrConversionStrategy); + if (error != hal::Error::NONE) { + ALOGE("Error in setting HDR conversion strategy %s", to_string(error).c_str()); + } + return NO_ERROR; +} + status_t HWComposer::getDisplayDecorationSupport( PhysicalDisplayId displayId, std::optional<aidl::android::hardware::graphics::common::DisplayDecorationSupport>* @@ -979,6 +994,14 @@ void HWComposer::loadOverlayProperties() { mComposer->getOverlaySupport(&mOverlayProperties); } +void HWComposer::loadHdrConversionCapabilities() { + const auto error = mComposer->getHdrConversionCapabilities(&mHdrConversionCapabilities); + if (error != hal::Error::NONE) { + ALOGE("Error in fetching HDR conversion capabilities %s", to_string(error).c_str()); + mHdrConversionCapabilities = {}; + } +} + status_t HWComposer::setIdleTimerEnabled(PhysicalDisplayId displayId, std::chrono::milliseconds timeout) { ATRACE_CALL(); diff --git a/services/surfaceflinger/DisplayHardware/HWComposer.h b/services/surfaceflinger/DisplayHardware/HWComposer.h index 78d4a68617..f6155d24ad 100644 --- a/services/surfaceflinger/DisplayHardware/HWComposer.h +++ b/services/surfaceflinger/DisplayHardware/HWComposer.h @@ -44,6 +44,8 @@ #include "Hal.h" #include <aidl/android/hardware/graphics/common/DisplayDecorationSupport.h> +#include <aidl/android/hardware/graphics/common/HdrConversionCapability.h> +#include <aidl/android/hardware/graphics/common/HdrConversionStrategy.h> #include <aidl/android/hardware/graphics/composer3/Capability.h> #include <aidl/android/hardware/graphics/composer3/ClientTargetPropertyWithBrightness.h> #include <aidl/android/hardware/graphics/composer3/Composition.h> @@ -286,6 +288,10 @@ public: virtual status_t setIdleTimerEnabled(PhysicalDisplayId, std::chrono::milliseconds timeout) = 0; virtual bool hasDisplayIdleTimerCapability(PhysicalDisplayId) const = 0; virtual Hwc2::AidlTransform getPhysicalDisplayOrientation(PhysicalDisplayId) const = 0; + virtual std::vector<aidl::android::hardware::graphics::common::HdrConversionCapability> + getHdrConversionCapabilities() const = 0; + virtual status_t setHdrConversionStrategy( + aidl::android::hardware::graphics::common::HdrConversionStrategy) = 0; }; static inline bool operator==(const android::HWComposer::DeviceRequestedChanges& lhs, @@ -437,6 +443,10 @@ public: status_t setIdleTimerEnabled(PhysicalDisplayId, std::chrono::milliseconds timeout) override; bool hasDisplayIdleTimerCapability(PhysicalDisplayId) const override; Hwc2::AidlTransform getPhysicalDisplayOrientation(PhysicalDisplayId) const override; + std::vector<aidl::android::hardware::graphics::common::HdrConversionCapability> + getHdrConversionCapabilities() const override; + status_t setHdrConversionStrategy( + aidl::android::hardware::graphics::common::HdrConversionStrategy) override; // for debugging ---------------------------------------------------------- void dump(std::string& out) const override; @@ -490,12 +500,16 @@ private: void loadCapabilities(); void loadLayerMetadataSupport(); void loadOverlayProperties(); + void loadHdrConversionCapabilities(); std::unordered_map<HalDisplayId, DisplayData> mDisplayData; std::unique_ptr<android::Hwc2::Composer> mComposer; std::unordered_set<aidl::android::hardware::graphics::composer3::Capability> mCapabilities; aidl::android::hardware::graphics::composer3::OverlayProperties mOverlayProperties; + std::vector<aidl::android::hardware::graphics::common::HdrConversionCapability> + mHdrConversionCapabilities = {}; + std::unordered_map<std::string, bool> mSupportedLayerGenericMetadata; bool mRegisteredCallback = false; diff --git a/services/surfaceflinger/DisplayHardware/HidlComposerHal.cpp b/services/surfaceflinger/DisplayHardware/HidlComposerHal.cpp index c9e1e794ab..6fdb2d79f3 100644 --- a/services/surfaceflinger/DisplayHardware/HidlComposerHal.cpp +++ b/services/surfaceflinger/DisplayHardware/HidlComposerHal.cpp @@ -36,6 +36,8 @@ #include <algorithm> #include <cinttypes> +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::ClientTargetPropertyWithBrightness; using aidl::android::hardware::graphics::composer3::DimmingStage; @@ -1348,6 +1350,14 @@ Error HidlComposer::getPreferredBootDisplayConfig(Display /*displayId*/, Config* return Error::UNSUPPORTED; } +Error HidlComposer::getHdrConversionCapabilities(std::vector<HdrConversionCapability>*) { + return Error::UNSUPPORTED; +} + +Error HidlComposer::setHdrConversionStrategy(HdrConversionStrategy) { + return Error::UNSUPPORTED; +} + Error HidlComposer::getClientTargetProperty( Display display, ClientTargetPropertyWithBrightness* outClientTargetProperty) { IComposerClient::ClientTargetProperty property; diff --git a/services/surfaceflinger/DisplayHardware/HidlComposerHal.h b/services/surfaceflinger/DisplayHardware/HidlComposerHal.h index 921add530a..8280af271e 100644 --- a/services/surfaceflinger/DisplayHardware/HidlComposerHal.h +++ b/services/surfaceflinger/DisplayHardware/HidlComposerHal.h @@ -343,6 +343,11 @@ public: AidlTransform* outDisplayOrientation) override; void onHotplugConnect(Display) override; void onHotplugDisconnect(Display) override; + Error getHdrConversionCapabilities( + std::vector<aidl::android::hardware::graphics::common::HdrConversionCapability>*) + override; + Error setHdrConversionStrategy( + aidl::android::hardware::graphics::common::HdrConversionStrategy) override; private: class CommandWriter : public CommandWriterBase { diff --git a/services/surfaceflinger/SurfaceFlinger.cpp b/services/surfaceflinger/SurfaceFlinger.cpp index 771c09eac3..8ec07092d9 100644 --- a/services/surfaceflinger/SurfaceFlinger.cpp +++ b/services/surfaceflinger/SurfaceFlinger.cpp @@ -1540,6 +1540,80 @@ status_t SurfaceFlinger::clearBootDisplayMode(const sp<IBinder>& displayToken) { return future.get(); } +status_t SurfaceFlinger::getHdrConversionCapabilities( + std::vector<gui::HdrConversionCapability>* hdrConversionCapabilities) const { + bool hdrOutputConversionSupport; + getHdrOutputConversionSupport(&hdrOutputConversionSupport); + if (hdrOutputConversionSupport == false) { + ALOGE("hdrOutputConversion is not supported by this device."); + return INVALID_OPERATION; + } + const auto aidlConversionCapability = getHwComposer().getHdrConversionCapabilities(); + for (auto capability : aidlConversionCapability) { + gui::HdrConversionCapability tempCapability; + tempCapability.sourceType = static_cast<int>(capability.sourceType.hdr); + tempCapability.outputType = static_cast<int>(capability.outputType->hdr); + tempCapability.addsLatency = capability.addsLatency; + hdrConversionCapabilities->push_back(tempCapability); + } + return NO_ERROR; +} + +status_t SurfaceFlinger::setHdrConversionStrategy( + const gui::HdrConversionStrategy& hdrConversionStrategy) { + bool hdrOutputConversionSupport; + getHdrOutputConversionSupport(&hdrOutputConversionSupport); + if (hdrOutputConversionSupport == false) { + ALOGE("hdrOutputConversion is not supported by this device."); + return INVALID_OPERATION; + } + auto future = mScheduler->schedule([=]() FTL_FAKE_GUARD(mStateLock) mutable -> status_t { + using AidlHdrConversionStrategy = + aidl::android::hardware::graphics::common::HdrConversionStrategy; + using GuiHdrConversionStrategyTag = gui::HdrConversionStrategy::Tag; + AidlHdrConversionStrategy aidlConversionStrategy; + switch (hdrConversionStrategy.getTag()) { + case GuiHdrConversionStrategyTag::passthrough: { + aidlConversionStrategy.set<AidlHdrConversionStrategy::Tag::passthrough>( + hdrConversionStrategy.get<GuiHdrConversionStrategyTag::passthrough>()); + return getHwComposer().setHdrConversionStrategy(aidlConversionStrategy); + } + case GuiHdrConversionStrategyTag::autoAllowedHdrTypes: { + auto autoHdrTypes = + hdrConversionStrategy + .get<GuiHdrConversionStrategyTag::autoAllowedHdrTypes>(); + std::vector<aidl::android::hardware::graphics::common::Hdr> aidlAutoHdrTypes; + for (auto type : autoHdrTypes) { + aidlAutoHdrTypes.push_back( + static_cast<aidl::android::hardware::graphics::common::Hdr>(type)); + } + aidlConversionStrategy.set<AidlHdrConversionStrategy::Tag::autoAllowedHdrTypes>( + aidlAutoHdrTypes); + return getHwComposer().setHdrConversionStrategy(aidlConversionStrategy); + } + case GuiHdrConversionStrategyTag::forceHdrConversion: { + auto forceHdrConversion = + hdrConversionStrategy + .get<GuiHdrConversionStrategyTag::forceHdrConversion>(); + aidlConversionStrategy.set<AidlHdrConversionStrategy::Tag::forceHdrConversion>( + static_cast<aidl::android::hardware::graphics::common::Hdr>( + forceHdrConversion)); + return getHwComposer().setHdrConversionStrategy(aidlConversionStrategy); + } + } + }); + return future.get(); +} + +status_t SurfaceFlinger::getHdrOutputConversionSupport(bool* outSupport) const { + auto future = mScheduler->schedule([this] { + return getHwComposer().hasCapability(Capability::HDR_OUTPUT_CONVERSION_CONFIG); + }); + + *outSupport = future.get(); + return NO_ERROR; +} + void SurfaceFlinger::setAutoLowLatencyMode(const sp<IBinder>& displayToken, bool on) { const char* const whence = __func__; static_cast<void>(mScheduler->schedule([=]() FTL_FAKE_GUARD(mStateLock) { @@ -7584,6 +7658,32 @@ binder::Status SurfaceComposerAIDL::getBootDisplayModeSupport(bool* outMode) { return binderStatusFromStatusT(status); } +binder::Status SurfaceComposerAIDL::getHdrConversionCapabilities( + std::vector<gui::HdrConversionCapability>* hdrConversionCapabilities) { + status_t status = checkAccessPermission(); + if (status == OK) { + status = mFlinger->getHdrConversionCapabilities(hdrConversionCapabilities); + } + return binderStatusFromStatusT(status); +} + +binder::Status SurfaceComposerAIDL::setHdrConversionStrategy( + const gui::HdrConversionStrategy& hdrConversionStrategy) { + status_t status = checkAccessPermission(); + if (status == OK) { + status = mFlinger->setHdrConversionStrategy(hdrConversionStrategy); + } + return binderStatusFromStatusT(status); +} + +binder::Status SurfaceComposerAIDL::getHdrOutputConversionSupport(bool* outMode) { + status_t status = checkAccessPermission(); + if (status == OK) { + status = mFlinger->getHdrOutputConversionSupport(outMode); + } + return binderStatusFromStatusT(status); +} + binder::Status SurfaceComposerAIDL::setAutoLowLatencyMode(const sp<IBinder>& display, bool on) { status_t status = checkAccessPermission(); if (status != OK) { diff --git a/services/surfaceflinger/SurfaceFlinger.h b/services/surfaceflinger/SurfaceFlinger.h index 064a1f1104..554ee8c474 100644 --- a/services/surfaceflinger/SurfaceFlinger.h +++ b/services/surfaceflinger/SurfaceFlinger.h @@ -534,6 +534,10 @@ private: status_t setBootDisplayMode(const sp<display::DisplayToken>&, DisplayModeId); status_t getOverlaySupport(gui::OverlayProperties* outProperties) const; status_t clearBootDisplayMode(const sp<IBinder>& displayToken); + status_t getHdrConversionCapabilities( + std::vector<gui::HdrConversionCapability>* hdrConversionCapaabilities) const; + status_t setHdrConversionStrategy(const gui::HdrConversionStrategy& hdrConversionStrategy); + status_t getHdrOutputConversionSupport(bool* outSupport) const; void setAutoLowLatencyMode(const sp<IBinder>& displayToken, bool on); void setGameContentType(const sp<IBinder>& displayToken, bool on); void setPowerMode(const sp<IBinder>& displayToken, int mode); @@ -1434,6 +1438,11 @@ public: binder::Status clearBootDisplayMode(const sp<IBinder>& display) override; binder::Status getBootDisplayModeSupport(bool* outMode) override; binder::Status getOverlaySupport(gui::OverlayProperties* outProperties) override; + binder::Status getHdrConversionCapabilities( + std::vector<gui::HdrConversionCapability>*) override; + binder::Status setHdrConversionStrategy( + const gui::HdrConversionStrategy& hdrConversionStrategy) override; + binder::Status getHdrOutputConversionSupport(bool* outSupport) override; binder::Status setAutoLowLatencyMode(const sp<IBinder>& display, bool on) override; binder::Status setGameContentType(const sp<IBinder>& display, bool on) override; binder::Status captureDisplay(const DisplayCaptureArgs&, diff --git a/services/surfaceflinger/tests/unittests/HWComposerTest.cpp b/services/surfaceflinger/tests/unittests/HWComposerTest.cpp index 8f89a8ca7a..afbc57add8 100644 --- a/services/surfaceflinger/tests/unittests/HWComposerTest.cpp +++ b/services/surfaceflinger/tests/unittests/HWComposerTest.cpp @@ -147,6 +147,7 @@ TEST_F(HWComposerSetCallbackTest, loadsLayerMetadataSupport) { }), Return(hardware::graphics::composer::V2_4::Error::NONE))); EXPECT_CALL(*mHal, getOverlaySupport(_)).WillOnce(Return(HalError::NONE)); + EXPECT_CALL(*mHal, getHdrConversionCapabilities(_)).WillOnce(Return(HalError::NONE)); EXPECT_CALL(*mHal, registerCallback(_)); @@ -165,6 +166,7 @@ TEST_F(HWComposerSetCallbackTest, handlesUnsupportedCallToGetLayerGenericMetadat EXPECT_CALL(*mHal, getLayerGenericMetadataKeys(_)) .WillOnce(Return(hardware::graphics::composer::V2_4::Error::UNSUPPORTED)); EXPECT_CALL(*mHal, getOverlaySupport(_)).WillOnce(Return(HalError::UNSUPPORTED)); + EXPECT_CALL(*mHal, getHdrConversionCapabilities(_)).WillOnce(Return(HalError::UNSUPPORTED)); EXPECT_CALL(*mHal, registerCallback(_)); mHwc.setCallback(mCallback); diff --git a/services/surfaceflinger/tests/unittests/mock/DisplayHardware/MockComposer.h b/services/surfaceflinger/tests/unittests/mock/DisplayHardware/MockComposer.h index 2f16b7b29f..5e29fe7539 100644 --- a/services/surfaceflinger/tests/unittests/mock/DisplayHardware/MockComposer.h +++ b/services/surfaceflinger/tests/unittests/mock/DisplayHardware/MockComposer.h @@ -145,6 +145,11 @@ public: MOCK_METHOD2(setBootDisplayConfig, Error(Display, Config)); MOCK_METHOD1(clearBootDisplayConfig, Error(Display)); MOCK_METHOD2(getPreferredBootDisplayConfig, Error(Display, Config*)); + MOCK_METHOD1(getHdrConversionCapabilities, + Error(std::vector< + aidl::android::hardware::graphics::common::HdrConversionCapability>*)); + MOCK_METHOD1(setHdrConversionStrategy, + Error(aidl::android::hardware::graphics::common::HdrConversionStrategy)); MOCK_METHOD2(getSupportedContentTypes, V2_4::Error(Display, std::vector<IComposerClient::ContentType>*)); MOCK_METHOD2(setContentType, V2_4::Error(Display, IComposerClient::ContentType)); |