| /* |
| * 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; |
| |
| 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 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) 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, uint32_t* outNumTypes, |
| uint32_t* outNumRequests) override; |
| |
| Error presentOrValidateDisplay(Display display, nsecs_t expectedPresentTime, |
| 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; |
| |
| 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 |