services/surfaceflinger/DisplayHardware/HidlComposerHal.h - LeafOS-Project/android_frameworks_native - Gitiles

 /*
  * Copyright 2016 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.
  */

 #pragma once

 #include "ComposerHal.h"

 #include <optional>
 #include <string>
 #include <unordered_map>
 #include <utility>
 #include <vector>

 // TODO(b/129481165): remove the #pragma below and fix conversion issues
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wconversion"
 #pragma clang diagnostic ignored "-Wextra"

 #include <composer-command-buffer/2.4/ComposerCommandBuffer.h>
 #include <gui/BufferQueue.h>
 #include <gui/HdrMetadata.h>
 #include <math/mat4.h>
 #include <ui/DisplayedFrameStats.h>
 #include <ui/GraphicBuffer.h>
 #include <utils/StrongPointer.h>

 #include <aidl/android/hardware/graphics/composer3/Composition.h>

 // TODO(b/129481165): remove the #pragma below and fix conversion issues
 #pragma clang diagnostic pop // ignored "-Wconversion -Wextra"

 namespace android::Hwc2 {

 namespace types = hardware::graphics::common;

 namespace V2_1 = hardware::graphics::composer::V2_1;
 namespace V2_2 = hardware::graphics::composer::V2_2;
 namespace V2_3 = hardware::graphics::composer::V2_3;
 namespace V2_4 = hardware::graphics::composer::V2_4;

 using types::V1_0::ColorTransform;
 using types::V1_0::Transform;
 using types::V1_1::RenderIntent;
 using types::V1_2::ColorMode;
 using types::V1_2::Dataspace;
 using types::V1_2::PixelFormat;

 using V2_1::Config;
 using V2_1::Display;
 using V2_1::Error;
 using V2_1::Layer;
 using V2_4::CommandReaderBase;
 using V2_4::CommandWriterBase;
 using V2_4::IComposer;
 using V2_4::IComposerCallback;
 using V2_4::IComposerClient;
 using V2_4::VsyncPeriodChangeTimeline;
 using V2_4::VsyncPeriodNanos;
 using PerFrameMetadata = IComposerClient::PerFrameMetadata;
 using PerFrameMetadataKey = IComposerClient::PerFrameMetadataKey;
 using PerFrameMetadataBlob = IComposerClient::PerFrameMetadataBlob;

 class CommandReader : public CommandReaderBase {
 public:
     ~CommandReader();

     // Parse and execute commands from the command queue.  The commands are
     // actually return values from the server and will be saved in ReturnData.
     Error parse();

     // Get and clear saved errors.
     struct CommandError {
         uint32_t location;
         Error error;
     };
     std::vector<CommandError> takeErrors();

     bool hasChanges(Display display, uint32_t* outNumChangedCompositionTypes,
                     uint32_t* outNumLayerRequestMasks) const;

     // Get and clear saved changed composition types.
     void takeChangedCompositionTypes(
             Display display, std::vector<Layer>* outLayers,
             std::vector<aidl::android::hardware::graphics::composer3::Composition>* outTypes);

     // Get and clear saved display requests.
     void takeDisplayRequests(Display display, uint32_t* outDisplayRequestMask,
                              std::vector<Layer>* outLayers,
                              std::vector<uint32_t>* outLayerRequestMasks);

     // Get and clear saved release fences.
     void takeReleaseFences(Display display, std::vector<Layer>* outLayers,
                            std::vector<int>* outReleaseFences);

     // Get and clear saved present fence.
     void takePresentFence(Display display, int* outPresentFence);

     // Get what stage succeeded during PresentOrValidate: Present or Validate
     void takePresentOrValidateStage(Display display, uint32_t* state);

     // Get the client target properties requested by hardware composer.
     void takeClientTargetProperty(Display display,
                                   IComposerClient::ClientTargetProperty* outClientTargetProperty);

 private:
     void resetData();

     bool parseSelectDisplay(uint16_t length);
     bool parseSetError(uint16_t length);
     bool parseSetChangedCompositionTypes(uint16_t length);
     bool parseSetDisplayRequests(uint16_t length);
     bool parseSetPresentFence(uint16_t length);
     bool parseSetReleaseFences(uint16_t length);
     bool parseSetPresentOrValidateDisplayResult(uint16_t length);
     bool parseSetClientTargetProperty(uint16_t length);

     struct ReturnData {
         uint32_t displayRequests = 0;

         std::vector<Layer> changedLayers;
         std::vector<aidl::android::hardware::graphics::composer3::Composition> compositionTypes;

         std::vector<Layer> requestedLayers;
         std::vector<uint32_t> requestMasks;

         int presentFence = -1;

         std::vector<Layer> releasedLayers;
         std::vector<int> releaseFences;

         uint32_t presentOrValidateState;

         // Composer 2.4 implementation can return a client target property
         // structure to indicate the client target properties that hardware
         // composer requests. The composer client must change the client target
         // properties to match this request.
         IComposerClient::ClientTargetProperty clientTargetProperty{PixelFormat::RGBA_8888,
                                                                    Dataspace::UNKNOWN};
     };

     std::vector<CommandError> mErrors;
     std::unordered_map<Display, ReturnData> mReturnData;

     // When SELECT_DISPLAY is parsed, this is updated to point to the
     // display's return data in mReturnData.  We use it to avoid repeated
     // map lookups.
     ReturnData* mCurrentReturnData;
 };

 // Composer is a wrapper to IComposer, a proxy to server-side composer.
 class HidlComposer final : public Composer {
 public:
     explicit HidlComposer(const std::string& serviceName);
     ~HidlComposer() override;

     bool isSupported(OptionalFeature) const;
     bool isVrrSupported() const;

     std::vector<aidl::android::hardware::graphics::composer3::Capability> getCapabilities()
             override;
     std::string dumpDebugInfo() override;

     void registerCallback(HWC2::ComposerCallback& callback) override;

     // Explicitly flush all pending commands in the command buffer.
     Error executeCommands(Display) override;

     uint32_t getMaxVirtualDisplayCount() override;
     Error createVirtualDisplay(uint32_t width, uint32_t height, PixelFormat* format,
                                Display* outDisplay) override;
     Error destroyVirtualDisplay(Display display) override;

     Error acceptDisplayChanges(Display display) override;

     Error createLayer(Display display, Layer* outLayer) override;
     Error destroyLayer(Display display, Layer layer) override;

     Error getActiveConfig(Display display, Config* outConfig) override;
     Error getChangedCompositionTypes(
             Display display, std::vector<Layer>* outLayers,
             std::vector<aidl::android::hardware::graphics::composer3::Composition>* outTypes)
             override;
     Error getColorModes(Display display, std::vector<ColorMode>* outModes) override;
     Error getDisplayAttribute(Display display, Config config, IComposerClient::Attribute attribute,
                               int32_t* outValue) override;
     Error getDisplayConfigs(Display display, std::vector<Config>* outConfigs);
     Error getDisplayConfigurations(Display, int32_t maxFrameIntervalNs,
                                    std::vector<DisplayConfiguration>*);
     Error getDisplayName(Display display, std::string* outName) override;

     Error getDisplayRequests(Display display, uint32_t* outDisplayRequestMask,
                              std::vector<Layer>* outLayers,
                              std::vector<uint32_t>* outLayerRequestMasks) override;

     Error getDozeSupport(Display display, bool* outSupport) override;
     Error hasDisplayIdleTimerCapability(Display display, bool* outSupport) override;
     Error getHdrCapabilities(Display display, std::vector<Hdr>* outHdrTypes, float* outMaxLuminance,
                              float* outMaxAverageLuminance, float* outMinLuminance) override;
     Error getOverlaySupport(aidl::android::hardware::graphics::composer3::OverlayProperties*
                                     outProperties) override;

     Error getReleaseFences(Display display, std::vector<Layer>* outLayers,
                            std::vector<int>* outReleaseFences) override;

     Error presentDisplay(Display display, int* outPresentFence) override;

     Error setActiveConfig(Display display, Config config) override;

     /*
      * The composer caches client targets internally.  When target is nullptr,
      * the composer uses slot to look up the client target from its cache.
      * When target is not nullptr, the cache is updated with the new target.
      */
     Error setClientTarget(Display display, uint32_t slot, const sp<GraphicBuffer>& target,
                           int acquireFence, Dataspace dataspace,
                           const std::vector<IComposerClient::Rect>& damage,
                           float hdrSdrRatio) override;
     Error setColorMode(Display display, ColorMode mode, RenderIntent renderIntent) override;
     Error setColorTransform(Display display, const float* matrix) override;
     Error setOutputBuffer(Display display, const native_handle_t* buffer,
                           int releaseFence) override;
     Error setPowerMode(Display display, IComposerClient::PowerMode mode) override;
     Error setVsyncEnabled(Display display, IComposerClient::Vsync enabled) override;

     Error setClientTargetSlotCount(Display display) override;

     Error validateDisplay(Display display, nsecs_t expectedPresentTime, int32_t frameIntervalNs,
                           uint32_t* outNumTypes, uint32_t* outNumRequests) override;

     Error presentOrValidateDisplay(Display display, nsecs_t expectedPresentTime,
                                    int32_t frameIntervalNs, uint32_t* outNumTypes,
                                    uint32_t* outNumRequests, int* outPresentFence,
                                    uint32_t* state) override;

     Error setCursorPosition(Display display, Layer layer, int32_t x, int32_t y) override;
     /* see setClientTarget for the purpose of slot */
     Error setLayerBuffer(Display display, Layer layer, uint32_t slot,
                          const sp<GraphicBuffer>& buffer, int acquireFence) override;
     Error setLayerBufferSlotsToClear(Display display, Layer layer,
                                      const std::vector<uint32_t>& slotsToClear,
                                      uint32_t activeBufferSlot) override;
     Error setLayerSurfaceDamage(Display display, Layer layer,
                                 const std::vector<IComposerClient::Rect>& damage) override;
     Error setLayerBlendMode(Display display, Layer layer, IComposerClient::BlendMode mode) override;
     Error setLayerColor(Display display, Layer layer,
                         const aidl::android::hardware::graphics::composer3::Color& color) override;
     Error setLayerCompositionType(
             Display display, Layer layer,
             aidl::android::hardware::graphics::composer3::Composition type) override;
     Error setLayerDataspace(Display display, Layer layer, Dataspace dataspace) override;
     Error setLayerDisplayFrame(Display display, Layer layer,
                                const IComposerClient::Rect& frame) override;
     Error setLayerPlaneAlpha(Display display, Layer layer, float alpha) override;
     Error setLayerSidebandStream(Display display, Layer layer,
                                  const native_handle_t* stream) override;
     Error setLayerSourceCrop(Display display, Layer layer,
                              const IComposerClient::FRect& crop) override;
     Error setLayerTransform(Display display, Layer layer, Transform transform) override;
     Error setLayerVisibleRegion(Display display, Layer layer,
                                 const std::vector<IComposerClient::Rect>& visible) override;
     Error setLayerZOrder(Display display, Layer layer, uint32_t z) override;

     // Composer HAL 2.2
     Error setLayerPerFrameMetadata(
             Display display, Layer layer,
             const std::vector<IComposerClient::PerFrameMetadata>& perFrameMetadatas) override;
     std::vector<IComposerClient::PerFrameMetadataKey> getPerFrameMetadataKeys(
             Display display) override;
     Error getRenderIntents(Display display, ColorMode colorMode,
                            std::vector<RenderIntent>* outRenderIntents) override;
     Error getDataspaceSaturationMatrix(Dataspace dataspace, mat4* outMatrix) override;

     // Composer HAL 2.3
     Error getDisplayIdentificationData(Display display, uint8_t* outPort,
                                        std::vector<uint8_t>* outData) override;
     Error setLayerColorTransform(Display display, Layer layer, const float* matrix) override;
     Error getDisplayedContentSamplingAttributes(Display display, PixelFormat* outFormat,
                                                 Dataspace* outDataspace,
                                                 uint8_t* outComponentMask) override;
     Error setDisplayContentSamplingEnabled(Display display, bool enabled, uint8_t componentMask,
                                            uint64_t maxFrames) override;
     Error getDisplayedContentSample(Display display, uint64_t maxFrames, uint64_t timestamp,
                                     DisplayedFrameStats* outStats) override;
     Error setLayerPerFrameMetadataBlobs(
             Display display, Layer layer,
             const std::vector<IComposerClient::PerFrameMetadataBlob>& metadata) override;
     Error setDisplayBrightness(Display display, float brightness, float brightnessNits,
                                const DisplayBrightnessOptions& options) override;

     // Composer HAL 2.4
     Error getDisplayCapabilities(
             Display display,
             std::vector<aidl::android::hardware::graphics::composer3::DisplayCapability>*
                     outCapabilities) override;
     V2_4::Error getDisplayConnectionType(Display display,
                                          IComposerClient::DisplayConnectionType* outType) override;
     V2_4::Error getDisplayVsyncPeriod(Display display, VsyncPeriodNanos* outVsyncPeriod) override;
     V2_4::Error setActiveConfigWithConstraints(
             Display display, Config config,
             const IComposerClient::VsyncPeriodChangeConstraints& vsyncPeriodChangeConstraints,
             VsyncPeriodChangeTimeline* outTimeline) override;
     V2_4::Error setAutoLowLatencyMode(Display displayId, bool on) override;
     V2_4::Error getSupportedContentTypes(
             Display displayId,
             std::vector<IComposerClient::ContentType>* outSupportedContentTypes) override;
     V2_4::Error setContentType(Display displayId,
                                IComposerClient::ContentType contentType) override;
     V2_4::Error setLayerGenericMetadata(Display display, Layer layer, const std::string& key,
                                         bool mandatory, const std::vector<uint8_t>& value) override;
     V2_4::Error getLayerGenericMetadataKeys(
             std::vector<IComposerClient::LayerGenericMetadataKey>* outKeys) override;
     Error getClientTargetProperty(
             Display display,
             aidl::android::hardware::graphics::composer3::ClientTargetPropertyWithBrightness*
                     outClientTargetProperty) override;

     // AIDL Composer HAL
     Error setLayerBrightness(Display display, Layer layer, float brightness) override;
     Error setLayerBlockingRegion(Display display, Layer layer,
                                  const std::vector<IComposerClient::Rect>& blocking) override;
     Error setBootDisplayConfig(Display displayId, Config) override;
     Error clearBootDisplayConfig(Display displayId) override;
     Error getPreferredBootDisplayConfig(Display displayId, Config*) override;
     Error getDisplayDecorationSupport(
             Display display,
             std::optional<aidl::android::hardware::graphics::common::DisplayDecorationSupport>*
                     support) override;
     Error setIdleTimerEnabled(Display displayId, std::chrono::milliseconds timeout) override;

     Error getPhysicalDisplayOrientation(Display displayId,
                                         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,
                                    Hdr*) override;
     Error setRefreshRateChangedCallbackDebugEnabled(Display, bool) override;
     Error notifyExpectedPresent(Display, nsecs_t, int32_t) override;

 private:
     class CommandWriter : public CommandWriterBase {
     public:
         explicit CommandWriter(uint32_t initialMaxSize) : CommandWriterBase(initialMaxSize) {}
         ~CommandWriter() override {}
     };

     void registerCallback(const sp<IComposerCallback>& callback);

     // Many public functions above simply write a command into the command
     // queue to batch the calls.  validateDisplay and presentDisplay will call
     // this function to execute the command queue.
     Error execute();

     sp<V2_1::IComposer> mComposer;

     sp<V2_1::IComposerClient> mClient;
     sp<V2_2::IComposerClient> mClient_2_2;
     sp<V2_3::IComposerClient> mClient_2_3;
     sp<IComposerClient> mClient_2_4;

     // Buffer slots for layers are cleared by setting the slot buffer to this buffer.
     sp<GraphicBuffer> mClearSlotBuffer;

     // 64KiB minus a small space for metadata such as read/write pointers
     static constexpr size_t kWriterInitialSize = 64 * 1024 / sizeof(uint32_t) - 16;
     // Max number of buffers that may be cached for a given layer
     // We obtain this number by:
     // 1. Tightly coupling this cache to the max size of BufferQueue
     // 2. Adding an additional slot for the layer caching feature in SurfaceFlinger (see: Planner.h)
     static const constexpr uint32_t kMaxLayerBufferCount = BufferQueue::NUM_BUFFER_SLOTS + 1;
     CommandWriter mWriter;
     CommandReader mReader;
 };

 } // namespace android::Hwc2
	/*
	* Copyright 2016 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.
	*/

	#pragma once

	#include "ComposerHal.h"

	#include <optional>
	#include <string>
	#include <unordered_map>
	#include <utility>
	#include <vector>

	// TODO(b/129481165): remove the #pragma below and fix conversion issues
	#pragma clang diagnostic push
	#pragma clang diagnostic ignored "-Wconversion"
	#pragma clang diagnostic ignored "-Wextra"

	#include <composer-command-buffer/2.4/ComposerCommandBuffer.h>
	#include <gui/BufferQueue.h>
	#include <gui/HdrMetadata.h>
	#include <math/mat4.h>
	#include <ui/DisplayedFrameStats.h>
	#include <ui/GraphicBuffer.h>
	#include <utils/StrongPointer.h>

	#include <aidl/android/hardware/graphics/composer3/Composition.h>

	// TODO(b/129481165): remove the #pragma below and fix conversion issues
	#pragma clang diagnostic pop // ignored "-Wconversion -Wextra"

	namespace android::Hwc2 {

	namespace types = hardware::graphics::common;

	namespace V2_1 = hardware::graphics::composer::V2_1;
	namespace V2_2 = hardware::graphics::composer::V2_2;
	namespace V2_3 = hardware::graphics::composer::V2_3;
	namespace V2_4 = hardware::graphics::composer::V2_4;

	using types::V1_0::ColorTransform;
	using types::V1_0::Transform;
	using types::V1_1::RenderIntent;
	using types::V1_2::ColorMode;
	using types::V1_2::Dataspace;
	using types::V1_2::PixelFormat;

	using V2_1::Config;
	using V2_1::Display;
	using V2_1::Error;
	using V2_1::Layer;
	using V2_4::CommandReaderBase;
	using V2_4::CommandWriterBase;
	using V2_4::IComposer;
	using V2_4::IComposerCallback;
	using V2_4::IComposerClient;
	using V2_4::VsyncPeriodChangeTimeline;
	using V2_4::VsyncPeriodNanos;
	using PerFrameMetadata = IComposerClient::PerFrameMetadata;
	using PerFrameMetadataKey = IComposerClient::PerFrameMetadataKey;
	using PerFrameMetadataBlob = IComposerClient::PerFrameMetadataBlob;

	class CommandReader : public CommandReaderBase {
	public:
	~CommandReader();

	// Parse and execute commands from the command queue. The commands are
	// actually return values from the server and will be saved in ReturnData.
	Error parse();

	// Get and clear saved errors.
	struct CommandError {
	uint32_t location;
	Error error;
	};
	std::vector<CommandError> takeErrors();

	bool hasChanges(Display display, uint32_t* outNumChangedCompositionTypes,
	uint32_t* outNumLayerRequestMasks) const;

	// Get and clear saved changed composition types.
	void takeChangedCompositionTypes(
	Display display, std::vector<Layer>* outLayers,
	std::vector<aidl::android::hardware::graphics::composer3::Composition>* outTypes);

	// Get and clear saved display requests.
	void takeDisplayRequests(Display display, uint32_t* outDisplayRequestMask,
	std::vector<Layer>* outLayers,
	std::vector<uint32_t>* outLayerRequestMasks);

	// Get and clear saved release fences.
	void takeReleaseFences(Display display, std::vector<Layer>* outLayers,
	std::vector<int>* outReleaseFences);

	// Get and clear saved present fence.
	void takePresentFence(Display display, int* outPresentFence);

	// Get what stage succeeded during PresentOrValidate: Present or Validate
	void takePresentOrValidateStage(Display display, uint32_t* state);

	// Get the client target properties requested by hardware composer.
	void takeClientTargetProperty(Display display,
	IComposerClient::ClientTargetProperty* outClientTargetProperty);

	private:
	void resetData();

	bool parseSelectDisplay(uint16_t length);
	bool parseSetError(uint16_t length);
	bool parseSetChangedCompositionTypes(uint16_t length);
	bool parseSetDisplayRequests(uint16_t length);
	bool parseSetPresentFence(uint16_t length);
	bool parseSetReleaseFences(uint16_t length);
	bool parseSetPresentOrValidateDisplayResult(uint16_t length);
	bool parseSetClientTargetProperty(uint16_t length);

	struct ReturnData {
	uint32_t displayRequests = 0;

	std::vector<Layer> changedLayers;
	std::vector<aidl::android::hardware::graphics::composer3::Composition> compositionTypes;

	std::vector<Layer> requestedLayers;
	std::vector<uint32_t> requestMasks;

	int presentFence = -1;

	std::vector<Layer> releasedLayers;
	std::vector<int> releaseFences;

	uint32_t presentOrValidateState;

	// Composer 2.4 implementation can return a client target property
	// structure to indicate the client target properties that hardware
	// composer requests. The composer client must change the client target
	// properties to match this request.
	IComposerClient::ClientTargetProperty clientTargetProperty{PixelFormat::RGBA_8888,
	Dataspace::UNKNOWN};
	};

	std::vector<CommandError> mErrors;
	std::unordered_map<Display, ReturnData> mReturnData;

	// When SELECT_DISPLAY is parsed, this is updated to point to the
	// display's return data in mReturnData. We use it to avoid repeated
	// map lookups.
	ReturnData* mCurrentReturnData;
	};

	// Composer is a wrapper to IComposer, a proxy to server-side composer.
	class HidlComposer final : public Composer {
	public:
	explicit HidlComposer(const std::string& serviceName);
	~HidlComposer() override;

	bool isSupported(OptionalFeature) const;
	bool isVrrSupported() const;

	std::vector<aidl::android::hardware::graphics::composer3::Capability> getCapabilities()
	override;
	std::string dumpDebugInfo() override;

	void registerCallback(HWC2::ComposerCallback& callback) override;

	// Explicitly flush all pending commands in the command buffer.
	Error executeCommands(Display) override;

	uint32_t getMaxVirtualDisplayCount() override;
	Error createVirtualDisplay(uint32_t width, uint32_t height, PixelFormat* format,
	Display* outDisplay) override;
	Error destroyVirtualDisplay(Display display) override;

	Error acceptDisplayChanges(Display display) override;

	Error createLayer(Display display, Layer* outLayer) override;
	Error destroyLayer(Display display, Layer layer) override;

	Error getActiveConfig(Display display, Config* outConfig) override;
	Error getChangedCompositionTypes(
	Display display, std::vector<Layer>* outLayers,
	std::vector<aidl::android::hardware::graphics::composer3::Composition>* outTypes)
	override;
	Error getColorModes(Display display, std::vector<ColorMode>* outModes) override;
	Error getDisplayAttribute(Display display, Config config, IComposerClient::Attribute attribute,
	int32_t* outValue) override;
	Error getDisplayConfigs(Display display, std::vector<Config>* outConfigs);
	Error getDisplayConfigurations(Display, int32_t maxFrameIntervalNs,
	std::vector<DisplayConfiguration>*);
	Error getDisplayName(Display display, std::string* outName) override;

	Error getDisplayRequests(Display display, uint32_t* outDisplayRequestMask,
	std::vector<Layer>* outLayers,
	std::vector<uint32_t>* outLayerRequestMasks) override;

	Error getDozeSupport(Display display, bool* outSupport) override;
	Error hasDisplayIdleTimerCapability(Display display, bool* outSupport) override;
	Error getHdrCapabilities(Display display, std::vector<Hdr>* outHdrTypes, float* outMaxLuminance,
	float* outMaxAverageLuminance, float* outMinLuminance) override;
	Error getOverlaySupport(aidl::android::hardware::graphics::composer3::OverlayProperties*
	outProperties) override;

	Error getReleaseFences(Display display, std::vector<Layer>* outLayers,
	std::vector<int>* outReleaseFences) override;

	Error presentDisplay(Display display, int* outPresentFence) override;

	Error setActiveConfig(Display display, Config config) override;

	/*
	* The composer caches client targets internally. When target is nullptr,
	* the composer uses slot to look up the client target from its cache.
	* When target is not nullptr, the cache is updated with the new target.
	*/
	Error setClientTarget(Display display, uint32_t slot, const sp<GraphicBuffer>& target,
	int acquireFence, Dataspace dataspace,
	const std::vector<IComposerClient::Rect>& damage,
	float hdrSdrRatio) override;
	Error setColorMode(Display display, ColorMode mode, RenderIntent renderIntent) override;
	Error setColorTransform(Display display, const float* matrix) override;
	Error setOutputBuffer(Display display, const native_handle_t* buffer,
	int releaseFence) override;
	Error setPowerMode(Display display, IComposerClient::PowerMode mode) override;
	Error setVsyncEnabled(Display display, IComposerClient::Vsync enabled) override;

	Error setClientTargetSlotCount(Display display) override;

	Error validateDisplay(Display display, nsecs_t expectedPresentTime, int32_t frameIntervalNs,
	uint32_t* outNumTypes, uint32_t* outNumRequests) override;

	Error presentOrValidateDisplay(Display display, nsecs_t expectedPresentTime,
	int32_t frameIntervalNs, uint32_t* outNumTypes,
	uint32_t* outNumRequests, int* outPresentFence,
	uint32_t* state) override;

	Error setCursorPosition(Display display, Layer layer, int32_t x, int32_t y) override;
	/* see setClientTarget for the purpose of slot */
	Error setLayerBuffer(Display display, Layer layer, uint32_t slot,
	const sp<GraphicBuffer>& buffer, int acquireFence) override;
	Error setLayerBufferSlotsToClear(Display display, Layer layer,
	const std::vector<uint32_t>& slotsToClear,
	uint32_t activeBufferSlot) override;
	Error setLayerSurfaceDamage(Display display, Layer layer,
	const std::vector<IComposerClient::Rect>& damage) override;
	Error setLayerBlendMode(Display display, Layer layer, IComposerClient::BlendMode mode) override;
	Error setLayerColor(Display display, Layer layer,
	const aidl::android::hardware::graphics::composer3::Color& color) override;
	Error setLayerCompositionType(
	Display display, Layer layer,
	aidl::android::hardware::graphics::composer3::Composition type) override;
	Error setLayerDataspace(Display display, Layer layer, Dataspace dataspace) override;
	Error setLayerDisplayFrame(Display display, Layer layer,
	const IComposerClient::Rect& frame) override;
	Error setLayerPlaneAlpha(Display display, Layer layer, float alpha) override;
	Error setLayerSidebandStream(Display display, Layer layer,
	const native_handle_t* stream) override;
	Error setLayerSourceCrop(Display display, Layer layer,
	const IComposerClient::FRect& crop) override;
	Error setLayerTransform(Display display, Layer layer, Transform transform) override;
	Error setLayerVisibleRegion(Display display, Layer layer,
	const std::vector<IComposerClient::Rect>& visible) override;
	Error setLayerZOrder(Display display, Layer layer, uint32_t z) override;

	// Composer HAL 2.2
	Error setLayerPerFrameMetadata(
	Display display, Layer layer,
	const std::vector<IComposerClient::PerFrameMetadata>& perFrameMetadatas) override;
	std::vector<IComposerClient::PerFrameMetadataKey> getPerFrameMetadataKeys(
	Display display) override;
	Error getRenderIntents(Display display, ColorMode colorMode,
	std::vector<RenderIntent>* outRenderIntents) override;
	Error getDataspaceSaturationMatrix(Dataspace dataspace, mat4* outMatrix) override;

	// Composer HAL 2.3
	Error getDisplayIdentificationData(Display display, uint8_t* outPort,
	std::vector<uint8_t>* outData) override;
	Error setLayerColorTransform(Display display, Layer layer, const float* matrix) override;
	Error getDisplayedContentSamplingAttributes(Display display, PixelFormat* outFormat,
	Dataspace* outDataspace,
	uint8_t* outComponentMask) override;
	Error setDisplayContentSamplingEnabled(Display display, bool enabled, uint8_t componentMask,
	uint64_t maxFrames) override;
	Error getDisplayedContentSample(Display display, uint64_t maxFrames, uint64_t timestamp,
	DisplayedFrameStats* outStats) override;
	Error setLayerPerFrameMetadataBlobs(
	Display display, Layer layer,
	const std::vector<IComposerClient::PerFrameMetadataBlob>& metadata) override;
	Error setDisplayBrightness(Display display, float brightness, float brightnessNits,
	const DisplayBrightnessOptions& options) override;

	// Composer HAL 2.4
	Error getDisplayCapabilities(
	Display display,
	std::vector<aidl::android::hardware::graphics::composer3::DisplayCapability>*
	outCapabilities) override;
	V2_4::Error getDisplayConnectionType(Display display,
	IComposerClient::DisplayConnectionType* outType) override;
	V2_4::Error getDisplayVsyncPeriod(Display display, VsyncPeriodNanos* outVsyncPeriod) override;
	V2_4::Error setActiveConfigWithConstraints(
	Display display, Config config,
	const IComposerClient::VsyncPeriodChangeConstraints& vsyncPeriodChangeConstraints,
	VsyncPeriodChangeTimeline* outTimeline) override;
	V2_4::Error setAutoLowLatencyMode(Display displayId, bool on) override;
	V2_4::Error getSupportedContentTypes(
	Display displayId,
	std::vector<IComposerClient::ContentType>* outSupportedContentTypes) override;
	V2_4::Error setContentType(Display displayId,
	IComposerClient::ContentType contentType) override;
	V2_4::Error setLayerGenericMetadata(Display display, Layer layer, const std::string& key,
	bool mandatory, const std::vector<uint8_t>& value) override;
	V2_4::Error getLayerGenericMetadataKeys(
	std::vector<IComposerClient::LayerGenericMetadataKey>* outKeys) override;
	Error getClientTargetProperty(
	Display display,
	aidl::android::hardware::graphics::composer3::ClientTargetPropertyWithBrightness*
	outClientTargetProperty) override;

	// AIDL Composer HAL
	Error setLayerBrightness(Display display, Layer layer, float brightness) override;
	Error setLayerBlockingRegion(Display display, Layer layer,
	const std::vector<IComposerClient::Rect>& blocking) override;
	Error setBootDisplayConfig(Display displayId, Config) override;
	Error clearBootDisplayConfig(Display displayId) override;
	Error getPreferredBootDisplayConfig(Display displayId, Config*) override;
	Error getDisplayDecorationSupport(
	Display display,
	std::optional<aidl::android::hardware::graphics::common::DisplayDecorationSupport>*
	support) override;
	Error setIdleTimerEnabled(Display displayId, std::chrono::milliseconds timeout) override;

	Error getPhysicalDisplayOrientation(Display displayId,
	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,
	Hdr*) override;
	Error setRefreshRateChangedCallbackDebugEnabled(Display, bool) override;
	Error notifyExpectedPresent(Display, nsecs_t, int32_t) override;

	private:
	class CommandWriter : public CommandWriterBase {
	public:
	explicit CommandWriter(uint32_t initialMaxSize) : CommandWriterBase(initialMaxSize) {}
	~CommandWriter() override {}
	};

	void registerCallback(const sp<IComposerCallback>& callback);

	// Many public functions above simply write a command into the command
	// queue to batch the calls. validateDisplay and presentDisplay will call
	// this function to execute the command queue.
	Error execute();

	sp<V2_1::IComposer> mComposer;

	sp<V2_1::IComposerClient> mClient;
	sp<V2_2::IComposerClient> mClient_2_2;
	sp<V2_3::IComposerClient> mClient_2_3;
	sp<IComposerClient> mClient_2_4;

	// Buffer slots for layers are cleared by setting the slot buffer to this buffer.
	sp<GraphicBuffer> mClearSlotBuffer;

	// 64KiB minus a small space for metadata such as read/write pointers
	static constexpr size_t kWriterInitialSize = 64 * 1024 / sizeof(uint32_t) - 16;
	// Max number of buffers that may be cached for a given layer
	// We obtain this number by:
	// 1. Tightly coupling this cache to the max size of BufferQueue
	// 2. Adding an additional slot for the layer caching feature in SurfaceFlinger (see: Planner.h)
	static const constexpr uint32_t kMaxLayerBufferCount = BufferQueue::NUM_BUFFER_SLOTS + 1;
	CommandWriter mWriter;
	CommandReader mReader;
	};

	} // namespace android::Hwc2