Revert^2 "[SF] Introduce VirtualDisplayId"
This change introduces a new class VirtualDisplayId which is
inherited by HwcVirtualDisplayId and GpuVirtualDisplayId.
HwcVirtualDisplayId replaces the current ids assigned to
virtual displays backed by HWC. GpuVirtualDisplayIds are random
generated IDs assigned to non HWC virtual displays, which currently
don't have IDs. This way all compositionengine/Display and
DisplayDevice objects have a DisplayId.
The logic for ID generation is encapsulated in DisplayIdGenerator.h.
Bug: 162916145
Bug: 160679868
Bug: 137375833
Test: scrcpy on device
Test: atest DisplayIdGeneratorTest
Test: atest libsurfaceflinger_unittest
Test: m WITH_TIDY=1 surfaceflinger
Change-Id: I6e7247d18e3521978dfd8af2dc7b1d36ccaa7313
diff --git a/services/surfaceflinger/DisplayHardware/HWComposer.h b/services/surfaceflinger/DisplayHardware/HWComposer.h
index 488cdc5..028a9a4 100644
--- a/services/surfaceflinger/DisplayHardware/HWComposer.h
+++ b/services/surfaceflinger/DisplayHardware/HWComposer.h
@@ -38,6 +38,7 @@
#include <utils/StrongPointer.h>
#include <utils/Timers.h>
+#include "DisplayIdGenerator.h"
#include "DisplayIdentification.h"
#include "HWC2.h"
#include "Hal.h"
@@ -88,7 +89,7 @@
DisplayIdentificationData* outData) const = 0;
virtual bool hasCapability(hal::Capability) const = 0;
- virtual bool hasDisplayCapability(DisplayId, hal::DisplayCapability) const = 0;
+ virtual bool hasDisplayCapability(HalDisplayId, hal::DisplayCapability) const = 0;
// Attempts to allocate a virtual display and returns its ID if created on the HWC device.
virtual std::optional<DisplayId> allocateVirtualDisplay(uint32_t width, uint32_t height,
@@ -97,9 +98,9 @@
virtual void allocatePhysicalDisplay(hal::HWDisplayId, PhysicalDisplayId) = 0;
// Attempts to create a new layer on this display
- virtual HWC2::Layer* createLayer(DisplayId) = 0;
+ virtual HWC2::Layer* createLayer(HalDisplayId) = 0;
// Destroy a previously created layer
- virtual void destroyLayer(DisplayId, HWC2::Layer*) = 0;
+ virtual void destroyLayer(HalDisplayId, HWC2::Layer*) = 0;
// Gets any required composition change requests from the HWC device.
//
@@ -109,61 +110,60 @@
// with fewer handshakes, but this does not work if client composition is
// expected.
virtual status_t getDeviceCompositionChanges(
- DisplayId, bool frameUsesClientComposition,
+ HalDisplayId, bool frameUsesClientComposition,
std::optional<DeviceRequestedChanges>* outChanges) = 0;
- virtual status_t setClientTarget(DisplayId, uint32_t slot, const sp<Fence>& acquireFence,
+ virtual status_t setClientTarget(HalDisplayId, uint32_t slot, const sp<Fence>& acquireFence,
const sp<GraphicBuffer>& target, ui::Dataspace) = 0;
// Present layers to the display and read releaseFences.
- virtual status_t presentAndGetReleaseFences(DisplayId) = 0;
+ virtual status_t presentAndGetReleaseFences(HalDisplayId) = 0;
// set power mode
- virtual status_t setPowerMode(DisplayId, hal::PowerMode) = 0;
+ virtual status_t setPowerMode(PhysicalDisplayId, hal::PowerMode) = 0;
// Sets a color transform to be applied to the result of composition
- virtual status_t setColorTransform(DisplayId, const mat4& transform) = 0;
+ virtual status_t setColorTransform(HalDisplayId, const mat4& transform) = 0;
- // reset state when an external, non-virtual display is disconnected
- virtual void disconnectDisplay(DisplayId) = 0;
+ // reset state when a display is disconnected
+ virtual void disconnectDisplay(HalDisplayId) = 0;
// get the present fence received from the last call to present.
- virtual sp<Fence> getPresentFence(DisplayId) const = 0;
+ virtual sp<Fence> getPresentFence(HalDisplayId) const = 0;
// Get last release fence for the given layer
- virtual sp<Fence> getLayerReleaseFence(DisplayId, HWC2::Layer*) const = 0;
+ virtual sp<Fence> getLayerReleaseFence(HalDisplayId, HWC2::Layer*) const = 0;
// Set the output buffer and acquire fence for a virtual display.
- // Returns INVALID_OPERATION if displayId is not a virtual display.
- virtual status_t setOutputBuffer(DisplayId, const sp<Fence>& acquireFence,
+ virtual status_t setOutputBuffer(HalVirtualDisplayId, const sp<Fence>& acquireFence,
const sp<GraphicBuffer>& buffer) = 0;
// After SurfaceFlinger has retrieved the release fences for all the frames,
// it can call this to clear the shared pointers in the release fence map
- virtual void clearReleaseFences(DisplayId) = 0;
+ virtual void clearReleaseFences(HalDisplayId) = 0;
// Fetches the HDR capabilities of the given display
- virtual status_t getHdrCapabilities(DisplayId, HdrCapabilities* outCapabilities) = 0;
+ virtual status_t getHdrCapabilities(HalDisplayId, HdrCapabilities* outCapabilities) = 0;
- virtual int32_t getSupportedPerFrameMetadata(DisplayId) const = 0;
+ virtual int32_t getSupportedPerFrameMetadata(HalDisplayId) const = 0;
// Returns the available RenderIntent of the given display.
- virtual std::vector<ui::RenderIntent> getRenderIntents(DisplayId, ui::ColorMode) const = 0;
+ virtual std::vector<ui::RenderIntent> getRenderIntents(HalDisplayId, ui::ColorMode) const = 0;
- virtual mat4 getDataspaceSaturationMatrix(DisplayId, ui::Dataspace) = 0;
+ virtual mat4 getDataspaceSaturationMatrix(HalDisplayId, ui::Dataspace) = 0;
// Returns the attributes of the color sampling engine.
- virtual status_t getDisplayedContentSamplingAttributes(DisplayId, ui::PixelFormat* outFormat,
+ virtual status_t getDisplayedContentSamplingAttributes(HalDisplayId, ui::PixelFormat* outFormat,
ui::Dataspace* outDataspace,
uint8_t* outComponentMask) = 0;
- virtual status_t setDisplayContentSamplingEnabled(DisplayId, bool enabled,
+ virtual status_t setDisplayContentSamplingEnabled(HalDisplayId, bool enabled,
uint8_t componentMask,
uint64_t maxFrames) = 0;
- virtual status_t getDisplayedContentSample(DisplayId, uint64_t maxFrames, uint64_t timestamp,
+ virtual status_t getDisplayedContentSample(HalDisplayId, uint64_t maxFrames, uint64_t timestamp,
DisplayedFrameStats* outStats) = 0;
// Sets the brightness of a display.
- virtual std::future<status_t> setDisplayBrightness(DisplayId, float brightness) = 0;
+ virtual std::future<status_t> setDisplayBrightness(PhysicalDisplayId, float brightness) = 0;
// Events handling ---------------------------------------------------------
@@ -174,33 +174,35 @@
hal::Connection) = 0;
virtual bool onVsync(hal::HWDisplayId, int64_t timestamp) = 0;
- virtual void setVsyncEnabled(DisplayId, hal::Vsync enabled) = 0;
+ virtual void setVsyncEnabled(PhysicalDisplayId, hal::Vsync enabled) = 0;
- virtual nsecs_t getRefreshTimestamp(DisplayId) const = 0;
- virtual bool isConnected(DisplayId) const = 0;
+ virtual nsecs_t getRefreshTimestamp(PhysicalDisplayId) const = 0;
+ virtual bool isConnected(PhysicalDisplayId) const = 0;
// Non-const because it can update configMap inside of mDisplayData
virtual std::vector<std::shared_ptr<const HWC2::Display::Config>> getConfigs(
- DisplayId) const = 0;
+ PhysicalDisplayId) const = 0;
- virtual std::shared_ptr<const HWC2::Display::Config> getActiveConfig(DisplayId) const = 0;
- virtual int getActiveConfigIndex(DisplayId) const = 0;
+ virtual std::shared_ptr<const HWC2::Display::Config> getActiveConfig(
+ PhysicalDisplayId) const = 0;
+ virtual int getActiveConfigIndex(PhysicalDisplayId) const = 0;
- virtual std::vector<ui::ColorMode> getColorModes(DisplayId) const = 0;
+ virtual std::vector<ui::ColorMode> getColorModes(PhysicalDisplayId) const = 0;
- virtual status_t setActiveColorMode(DisplayId, ui::ColorMode mode, ui::RenderIntent) = 0;
+ virtual status_t setActiveColorMode(PhysicalDisplayId, ui::ColorMode mode,
+ ui::RenderIntent) = 0;
// Composer 2.4
- virtual DisplayConnectionType getDisplayConnectionType(DisplayId) const = 0;
- virtual bool isVsyncPeriodSwitchSupported(DisplayId) const = 0;
- virtual nsecs_t getDisplayVsyncPeriod(DisplayId) const = 0;
+ virtual DisplayConnectionType getDisplayConnectionType(PhysicalDisplayId) const = 0;
+ virtual bool isVsyncPeriodSwitchSupported(PhysicalDisplayId) const = 0;
+ virtual nsecs_t getDisplayVsyncPeriod(PhysicalDisplayId) const = 0;
virtual status_t setActiveConfigWithConstraints(
- DisplayId, size_t configId, const hal::VsyncPeriodChangeConstraints&,
+ PhysicalDisplayId, size_t configId, const hal::VsyncPeriodChangeConstraints&,
hal::VsyncPeriodChangeTimeline* outTimeline) = 0;
- virtual status_t setAutoLowLatencyMode(DisplayId, bool on) = 0;
+ virtual status_t setAutoLowLatencyMode(PhysicalDisplayId, bool on) = 0;
virtual status_t getSupportedContentTypes(
- DisplayId, std::vector<hal::ContentType>* outSupportedContentTypes) = 0;
- virtual status_t setContentType(DisplayId, hal::ContentType) = 0;
+ PhysicalDisplayId, std::vector<hal::ContentType>* outSupportedContentTypes) = 0;
+ virtual status_t setContentType(PhysicalDisplayId, hal::ContentType) = 0;
virtual const std::unordered_map<std::string, bool>& getSupportedLayerGenericMetadata()
const = 0;
@@ -232,7 +234,7 @@
DisplayIdentificationData* outData) const override;
bool hasCapability(hal::Capability) const override;
- bool hasDisplayCapability(DisplayId, hal::DisplayCapability) const override;
+ bool hasDisplayCapability(HalDisplayId, hal::DisplayCapability) const override;
// Attempts to allocate a virtual display and returns its ID if created on the HWC device.
std::optional<DisplayId> allocateVirtualDisplay(uint32_t width, uint32_t height,
@@ -242,63 +244,62 @@
void allocatePhysicalDisplay(hal::HWDisplayId, PhysicalDisplayId) override;
// Attempts to create a new layer on this display
- HWC2::Layer* createLayer(DisplayId) override;
+ HWC2::Layer* createLayer(HalDisplayId) override;
// Destroy a previously created layer
- void destroyLayer(DisplayId, HWC2::Layer*) override;
+ void destroyLayer(HalDisplayId, HWC2::Layer*) override;
status_t getDeviceCompositionChanges(
- DisplayId, bool frameUsesClientComposition,
+ HalDisplayId, bool frameUsesClientComposition,
std::optional<DeviceRequestedChanges>* outChanges) override;
- status_t setClientTarget(DisplayId, uint32_t slot, const sp<Fence>& acquireFence,
+ status_t setClientTarget(HalDisplayId, uint32_t slot, const sp<Fence>& acquireFence,
const sp<GraphicBuffer>& target, ui::Dataspace) override;
// Present layers to the display and read releaseFences.
- status_t presentAndGetReleaseFences(DisplayId) override;
+ status_t presentAndGetReleaseFences(HalDisplayId) override;
// set power mode
- status_t setPowerMode(DisplayId, hal::PowerMode mode) override;
+ status_t setPowerMode(PhysicalDisplayId, hal::PowerMode mode) override;
// Sets a color transform to be applied to the result of composition
- status_t setColorTransform(DisplayId, const mat4& transform) override;
+ status_t setColorTransform(HalDisplayId, const mat4& transform) override;
- // reset state when an external, non-virtual display is disconnected
- void disconnectDisplay(DisplayId) override;
+ // reset state when a display is disconnected
+ void disconnectDisplay(HalDisplayId) override;
// get the present fence received from the last call to present.
- sp<Fence> getPresentFence(DisplayId) const override;
+ sp<Fence> getPresentFence(HalDisplayId) const override;
// Get last release fence for the given layer
- sp<Fence> getLayerReleaseFence(DisplayId, HWC2::Layer*) const override;
+ sp<Fence> getLayerReleaseFence(HalDisplayId, HWC2::Layer*) const override;
// Set the output buffer and acquire fence for a virtual display.
- // Returns INVALID_OPERATION if displayId is not a virtual display.
- status_t setOutputBuffer(DisplayId, const sp<Fence>& acquireFence,
+ status_t setOutputBuffer(HalVirtualDisplayId, const sp<Fence>& acquireFence,
const sp<GraphicBuffer>& buffer) override;
// After SurfaceFlinger has retrieved the release fences for all the frames,
// it can call this to clear the shared pointers in the release fence map
- void clearReleaseFences(DisplayId) override;
+ void clearReleaseFences(HalDisplayId) override;
// Fetches the HDR capabilities of the given display
- status_t getHdrCapabilities(DisplayId, HdrCapabilities* outCapabilities) override;
+ status_t getHdrCapabilities(HalDisplayId, HdrCapabilities* outCapabilities) override;
- int32_t getSupportedPerFrameMetadata(DisplayId) const override;
+ int32_t getSupportedPerFrameMetadata(HalDisplayId) const override;
// Returns the available RenderIntent of the given display.
- std::vector<ui::RenderIntent> getRenderIntents(DisplayId, ui::ColorMode) const override;
+ std::vector<ui::RenderIntent> getRenderIntents(HalDisplayId, ui::ColorMode) const override;
- mat4 getDataspaceSaturationMatrix(DisplayId, ui::Dataspace) override;
+ mat4 getDataspaceSaturationMatrix(HalDisplayId, ui::Dataspace) override;
// Returns the attributes of the color sampling engine.
- status_t getDisplayedContentSamplingAttributes(DisplayId, ui::PixelFormat* outFormat,
+ status_t getDisplayedContentSamplingAttributes(HalDisplayId, ui::PixelFormat* outFormat,
ui::Dataspace* outDataspace,
uint8_t* outComponentMask) override;
- status_t setDisplayContentSamplingEnabled(DisplayId, bool enabled, uint8_t componentMask,
+ status_t setDisplayContentSamplingEnabled(HalDisplayId, bool enabled, uint8_t componentMask,
uint64_t maxFrames) override;
- status_t getDisplayedContentSample(DisplayId, uint64_t maxFrames, uint64_t timestamp,
+ status_t getDisplayedContentSample(HalDisplayId, uint64_t maxFrames, uint64_t timestamp,
DisplayedFrameStats* outStats) override;
- std::future<status_t> setDisplayBrightness(DisplayId, float brightness) override;
+ std::future<status_t> setDisplayBrightness(PhysicalDisplayId, float brightness) override;
// Events handling ---------------------------------------------------------
@@ -307,31 +308,32 @@
std::optional<DisplayIdentificationInfo> onHotplug(hal::HWDisplayId, hal::Connection) override;
bool onVsync(hal::HWDisplayId, int64_t timestamp) override;
- void setVsyncEnabled(DisplayId, hal::Vsync enabled) override;
+ void setVsyncEnabled(PhysicalDisplayId, hal::Vsync enabled) override;
- nsecs_t getRefreshTimestamp(DisplayId) const override;
- bool isConnected(DisplayId) const override;
+ nsecs_t getRefreshTimestamp(PhysicalDisplayId) const override;
+ bool isConnected(PhysicalDisplayId) const override;
// Non-const because it can update configMap inside of mDisplayData
- std::vector<std::shared_ptr<const HWC2::Display::Config>> getConfigs(DisplayId) const override;
+ std::vector<std::shared_ptr<const HWC2::Display::Config>> getConfigs(
+ PhysicalDisplayId) const override;
- std::shared_ptr<const HWC2::Display::Config> getActiveConfig(DisplayId) const override;
- int getActiveConfigIndex(DisplayId) const override;
+ std::shared_ptr<const HWC2::Display::Config> getActiveConfig(PhysicalDisplayId) const override;
+ int getActiveConfigIndex(PhysicalDisplayId) const override;
- std::vector<ui::ColorMode> getColorModes(DisplayId) const override;
+ std::vector<ui::ColorMode> getColorModes(PhysicalDisplayId) const override;
- status_t setActiveColorMode(DisplayId, ui::ColorMode, ui::RenderIntent) override;
+ status_t setActiveColorMode(PhysicalDisplayId, ui::ColorMode, ui::RenderIntent) override;
// Composer 2.4
- DisplayConnectionType getDisplayConnectionType(DisplayId) const override;
- bool isVsyncPeriodSwitchSupported(DisplayId) const override;
- nsecs_t getDisplayVsyncPeriod(DisplayId) const override;
- status_t setActiveConfigWithConstraints(DisplayId, size_t configId,
+ DisplayConnectionType getDisplayConnectionType(PhysicalDisplayId) const override;
+ bool isVsyncPeriodSwitchSupported(PhysicalDisplayId) const override;
+ nsecs_t getDisplayVsyncPeriod(PhysicalDisplayId) const override;
+ status_t setActiveConfigWithConstraints(PhysicalDisplayId, size_t configId,
const hal::VsyncPeriodChangeConstraints&,
hal::VsyncPeriodChangeTimeline* outTimeline) override;
- status_t setAutoLowLatencyMode(DisplayId, bool) override;
- status_t getSupportedContentTypes(DisplayId, std::vector<hal::ContentType>*) override;
- status_t setContentType(DisplayId, hal::ContentType) override;
+ status_t setAutoLowLatencyMode(PhysicalDisplayId, bool) override;
+ status_t getSupportedContentTypes(PhysicalDisplayId, std::vector<hal::ContentType>*) override;
+ status_t setContentType(PhysicalDisplayId, hal::ContentType) override;
const std::unordered_map<std::string, bool>& getSupportedLayerGenericMetadata() const override;
@@ -385,7 +387,7 @@
nsecs_t lastHwVsync GUARDED_BY(lastHwVsyncLock) = 0;
};
- std::unordered_map<DisplayId, DisplayData> mDisplayData;
+ std::unordered_map<HalDisplayId, DisplayData> mDisplayData;
std::unique_ptr<android::Hwc2::Composer> mComposer;
std::unordered_set<hal::Capability> mCapabilities;
@@ -397,9 +399,7 @@
std::optional<hal::HWDisplayId> mExternalHwcDisplayId;
bool mHasMultiDisplaySupport = false;
- std::unordered_set<DisplayId> mFreeVirtualDisplayIds;
- uint32_t mNextVirtualDisplayId = 0;
- uint32_t mRemainingHwcVirtualDisplays{getMaxVirtualDisplayCount()};
+ RandomDisplayIdGenerator<HalVirtualDisplayId> mVirtualIdGenerator{getMaxVirtualDisplayCount()};
};
} // namespace impl