diff options
18 files changed, 269 insertions, 296 deletions
diff --git a/services/surfaceflinger/BufferStateLayer.cpp b/services/surfaceflinger/BufferStateLayer.cpp index 51a54455d1..cce6ad7fe0 100644 --- a/services/surfaceflinger/BufferStateLayer.cpp +++ b/services/surfaceflinger/BufferStateLayer.cpp @@ -1109,7 +1109,29 @@ bool BufferStateLayer::isVisible() const { } std::optional<compositionengine::LayerFE::LayerSettings> BufferStateLayer::prepareClientComposition( - compositionengine::LayerFE::ClientCompositionTargetSettings& targetSettings) { + compositionengine::LayerFE::ClientCompositionTargetSettings& targetSettings) const { + std::optional<compositionengine::LayerFE::LayerSettings> layerSettings = + prepareClientCompositionInternal(targetSettings); + // Nothing to render. + if (!layerSettings) { + return {}; + } + + // HWC requests to clear this layer. + if (targetSettings.clearContent) { + prepareClearClientComposition(*layerSettings, false /* blackout */); + return *layerSettings; + } + + // set the shadow for the layer if needed + prepareShadowClientComposition(*layerSettings, targetSettings.viewport); + + return *layerSettings; +} + +std::optional<compositionengine::LayerFE::LayerSettings> +BufferStateLayer::prepareClientCompositionInternal( + compositionengine::LayerFE::ClientCompositionTargetSettings& targetSettings) const { ATRACE_CALL(); std::optional<compositionengine::LayerFE::LayerSettings> result = @@ -1559,7 +1581,7 @@ sp<GraphicBuffer> BufferStateLayer::getBuffer() const { return mBufferInfo.mBuffer ? mBufferInfo.mBuffer->getBuffer() : nullptr; } -void BufferStateLayer::getDrawingTransformMatrix(bool filteringEnabled, float outMatrix[16]) { +void BufferStateLayer::getDrawingTransformMatrix(bool filteringEnabled, float outMatrix[16]) const { sp<GraphicBuffer> buffer = getBuffer(); if (!buffer) { ALOGE("Buffer should not be null!"); diff --git a/services/surfaceflinger/BufferStateLayer.h b/services/surfaceflinger/BufferStateLayer.h index 8bad3d230c..a0f13e21d4 100644 --- a/services/surfaceflinger/BufferStateLayer.h +++ b/services/surfaceflinger/BufferStateLayer.h @@ -159,6 +159,9 @@ public: std::atomic<int32_t>* getPendingBufferCounter() override { return &mPendingBufferTransactions; } std::string getPendingBufferCounterName() override { return mBlastTransactionName; } + std::optional<compositionengine::LayerFE::LayerSettings> prepareClientComposition( + compositionengine::LayerFE::ClientCompositionTargetSettings&) const override; + protected: void gatherBufferInfo(); void onSurfaceFrameCreated(const std::shared_ptr<frametimeline::SurfaceFrame>& surfaceFrame); @@ -188,9 +191,6 @@ protected: BufferInfo mBufferInfo; - std::optional<compositionengine::LayerFE::LayerSettings> prepareClientComposition( - compositionengine::LayerFE::ClientCompositionTargetSettings&) override; - /* * compositionengine::LayerFE overrides */ @@ -236,7 +236,7 @@ private: // Computes the transform matrix using the setFilteringEnabled to determine whether the // transform matrix should be computed for use with bilinear filtering. - void getDrawingTransformMatrix(bool filteringEnabled, float outMatrix[16]); + void getDrawingTransformMatrix(bool filteringEnabled, float outMatrix[16]) const; std::unique_ptr<compositionengine::LayerFECompositionState> mCompositionState; @@ -270,6 +270,9 @@ private: const sp<Fence>& releaseFence, uint32_t currentMaxAcquiredBufferCount); + std::optional<compositionengine::LayerFE::LayerSettings> prepareClientCompositionInternal( + compositionengine::LayerFE::ClientCompositionTargetSettings&) const; + ReleaseCallbackId mPreviousReleaseCallbackId = ReleaseCallbackId::INVALID_ID; uint64_t mPreviousReleasedFrameNumber = 0; diff --git a/services/surfaceflinger/CompositionEngine/include/compositionengine/LayerFE.h b/services/surfaceflinger/CompositionEngine/include/compositionengine/LayerFE.h index ec610c1b1d..f93fd99f29 100644 --- a/services/surfaceflinger/CompositionEngine/include/compositionengine/LayerFE.h +++ b/services/surfaceflinger/CompositionEngine/include/compositionengine/LayerFE.h @@ -150,11 +150,11 @@ public: uint64_t frameNumber = 0; }; - // Returns the z-ordered list of LayerSettings to pass to RenderEngine::drawLayers. The list - // may contain shadows casted by the layer or the content of the layer itself. If the layer - // does not render then an empty list will be returned. - virtual std::vector<LayerSettings> prepareClientCompositionList( - ClientCompositionTargetSettings&) = 0; + // Returns the LayerSettings to pass to RenderEngine::drawLayers. The state may contain shadows + // casted by the layer or the content of the layer itself. If the layer does not render then an + // empty optional will be returned. + virtual std::optional<LayerSettings> prepareClientComposition( + ClientCompositionTargetSettings&) const = 0; // Called after the layer is displayed to update the presentation fence virtual void onLayerDisplayed(ftl::SharedFuture<FenceResult>) = 0; diff --git a/services/surfaceflinger/CompositionEngine/include/compositionengine/OutputLayer.h b/services/surfaceflinger/CompositionEngine/include/compositionengine/OutputLayer.h index bf5184e997..6d0c395b2f 100644 --- a/services/surfaceflinger/CompositionEngine/include/compositionengine/OutputLayer.h +++ b/services/surfaceflinger/CompositionEngine/include/compositionengine/OutputLayer.h @@ -126,9 +126,9 @@ public: // Returns true if the composition settings scale pixels virtual bool needsFiltering() const = 0; - // Returns a composition list to be used by RenderEngine if the layer has been overridden + // Returns LayerSettings to be used by RenderEngine if the layer has been overridden // during the composition process - virtual std::vector<LayerFE::LayerSettings> getOverrideCompositionList() const = 0; + virtual std::optional<LayerFE::LayerSettings> getOverrideCompositionSettings() const = 0; // Debugging virtual void dump(std::string& result) const = 0; diff --git a/services/surfaceflinger/CompositionEngine/include/compositionengine/impl/OutputLayer.h b/services/surfaceflinger/CompositionEngine/include/compositionengine/impl/OutputLayer.h index ecd432f629..6d4abf9f47 100644 --- a/services/surfaceflinger/CompositionEngine/include/compositionengine/impl/OutputLayer.h +++ b/services/surfaceflinger/CompositionEngine/include/compositionengine/impl/OutputLayer.h @@ -18,6 +18,7 @@ #include <cstdint> #include <memory> +#include <optional> #include <string> #include <compositionengine/LayerFE.h> @@ -57,7 +58,7 @@ public: void prepareForDeviceLayerRequests() override; void applyDeviceLayerRequest(Hwc2::IComposerClient::LayerRequest request) override; bool needsFiltering() const override; - std::vector<LayerFE::LayerSettings> getOverrideCompositionList() const override; + std::optional<LayerFE::LayerSettings> getOverrideCompositionSettings() const override; void dump(std::string&) const override; virtual FloatRect calculateOutputSourceCrop(uint32_t internalDisplayRotationFlags) const; diff --git a/services/surfaceflinger/CompositionEngine/include/compositionengine/mock/LayerFE.h b/services/surfaceflinger/CompositionEngine/include/compositionengine/mock/LayerFE.h index 1c5c10f823..2b704e697f 100644 --- a/services/surfaceflinger/CompositionEngine/include/compositionengine/mock/LayerFE.h +++ b/services/surfaceflinger/CompositionEngine/include/compositionengine/mock/LayerFE.h @@ -45,9 +45,9 @@ public: MOCK_METHOD1(onPreComposition, bool(nsecs_t)); MOCK_METHOD1(prepareCompositionState, void(compositionengine::LayerFE::StateSubset)); - MOCK_METHOD1(prepareClientCompositionList, - std::vector<compositionengine::LayerFE::LayerSettings>( - compositionengine::LayerFE::ClientCompositionTargetSettings&)); + MOCK_CONST_METHOD1(prepareClientComposition, + std::optional<compositionengine::LayerFE::LayerSettings>( + compositionengine::LayerFE::ClientCompositionTargetSettings&)); MOCK_METHOD(void, onLayerDisplayed, (ftl::SharedFuture<FenceResult>), (override)); diff --git a/services/surfaceflinger/CompositionEngine/include/compositionengine/mock/OutputLayer.h b/services/surfaceflinger/CompositionEngine/include/compositionengine/mock/OutputLayer.h index a6cb811468..c22f1bf260 100644 --- a/services/surfaceflinger/CompositionEngine/include/compositionengine/mock/OutputLayer.h +++ b/services/surfaceflinger/CompositionEngine/include/compositionengine/mock/OutputLayer.h @@ -16,6 +16,8 @@ #pragma once +#include <optional> + #include <compositionengine/CompositionEngine.h> #include <compositionengine/LayerFE.h> #include <compositionengine/Output.h> @@ -51,7 +53,7 @@ public: MOCK_METHOD0(prepareForDeviceLayerRequests, void()); MOCK_METHOD1(applyDeviceLayerRequest, void(Hwc2::IComposerClient::LayerRequest request)); MOCK_CONST_METHOD0(needsFiltering, bool()); - MOCK_CONST_METHOD0(getOverrideCompositionList, std::vector<LayerFE::LayerSettings>()); + MOCK_CONST_METHOD0(getOverrideCompositionSettings, std::optional<LayerFE::LayerSettings>()); MOCK_CONST_METHOD1(dump, void(std::string&)); }; diff --git a/services/surfaceflinger/CompositionEngine/src/Output.cpp b/services/surfaceflinger/CompositionEngine/src/Output.cpp index 8ebc5b1702..6edc00f1e1 100644 --- a/services/surfaceflinger/CompositionEngine/src/Output.cpp +++ b/services/surfaceflinger/CompositionEngine/src/Output.cpp @@ -1366,7 +1366,7 @@ std::vector<LayerFE::LayerSettings> Output::generateClientCompositionRequests( bool firstLayer = true; bool disableBlurs = false; - sp<GraphicBuffer> previousOverrideBuffer = nullptr; + uint64_t previousOverrideBufferId = 0; for (auto* layer : getOutputLayersOrderedByZ()) { const auto& layerState = layer->getState(); @@ -1402,11 +1402,10 @@ std::vector<LayerFE::LayerSettings> Output::generateClientCompositionRequests( !layerState.visibleRegion.subtract(layerState.shadowRegion).isEmpty(); if (clientComposition || clearClientComposition) { - std::vector<LayerFE::LayerSettings> results; - if (layer->getState().overrideInfo.buffer != nullptr) { - if (layer->getState().overrideInfo.buffer->getBuffer() != previousOverrideBuffer) { - results = layer->getOverrideCompositionList(); - previousOverrideBuffer = layer->getState().overrideInfo.buffer->getBuffer(); + if (auto overrideSettings = layer->getOverrideCompositionSettings()) { + if (overrideSettings->bufferId != previousOverrideBufferId) { + previousOverrideBufferId = overrideSettings->bufferId; + clientCompositionLayers.push_back(std::move(*overrideSettings)); ALOGV("Replacing [%s] with override in RE", layer->getLayerFE().getDebugName()); } else { ALOGV("Skipping redundant override buffer for [%s] in RE", @@ -1432,20 +1431,18 @@ std::vector<LayerFE::LayerSettings> Output::generateClientCompositionRequests( .clearContent = !clientComposition, .blurSetting = blurSetting, .whitePointNits = layerState.whitePointNits}; - results = layerFE.prepareClientCompositionList(targetSettings); - if (realContentIsVisible && !results.empty()) { - layer->editState().clientCompositionTimestamp = systemTime(); + if (auto clientCompositionSettings = + layerFE.prepareClientComposition(targetSettings)) { + clientCompositionLayers.push_back(std::move(*clientCompositionSettings)); + if (realContentIsVisible) { + layer->editState().clientCompositionTimestamp = systemTime(); + } } } if (clientComposition) { outLayerFEs.push_back(&layerFE); } - - clientCompositionLayers.insert(clientCompositionLayers.end(), - std::make_move_iterator(results.begin()), - std::make_move_iterator(results.end())); - results.clear(); } firstLayer = false; diff --git a/services/surfaceflinger/CompositionEngine/src/OutputLayer.cpp b/services/surfaceflinger/CompositionEngine/src/OutputLayer.cpp index 1bb9d0eb63..a39c527655 100644 --- a/services/surfaceflinger/CompositionEngine/src/OutputLayer.cpp +++ b/services/surfaceflinger/CompositionEngine/src/OutputLayer.cpp @@ -787,7 +787,7 @@ bool OutputLayer::needsFiltering() const { sourceCrop.getWidth() != displayFrame.getWidth(); } -std::vector<LayerFE::LayerSettings> OutputLayer::getOverrideCompositionList() const { +std::optional<LayerFE::LayerSettings> OutputLayer::getOverrideCompositionSettings() const { if (getState().overrideInfo.buffer == nullptr) { return {}; } @@ -816,7 +816,7 @@ std::vector<LayerFE::LayerSettings> OutputLayer::getOverrideCompositionList() co settings.alpha = 1.0f; settings.whitePointNits = getOutput().getState().sdrWhitePointNits; - return {static_cast<LayerFE::LayerSettings>(settings)}; + return settings; } void OutputLayer::dump(std::string& out) const { diff --git a/services/surfaceflinger/CompositionEngine/src/planner/CachedSet.cpp b/services/surfaceflinger/CompositionEngine/src/planner/CachedSet.cpp index 641b806aec..9058f6709f 100644 --- a/services/surfaceflinger/CompositionEngine/src/planner/CachedSet.cpp +++ b/services/surfaceflinger/CompositionEngine/src/planner/CachedSet.cpp @@ -190,11 +190,11 @@ void CachedSet::render(renderengine::RenderEngine& renderEngine, TexturePool& te std::vector<renderengine::LayerSettings> layerSettings; renderengine::LayerSettings highlight; for (const auto& layer : mLayers) { - const auto clientCompositionList = - layer.getState()->getOutputLayer()->getLayerFE().prepareClientCompositionList( - targetSettings); - layerSettings.insert(layerSettings.end(), clientCompositionList.cbegin(), - clientCompositionList.cend()); + if (auto clientCompositionSettings = + layer.getState()->getOutputLayer()->getLayerFE().prepareClientComposition( + targetSettings)) { + layerSettings.push_back(std::move(*clientCompositionSettings)); + } } renderengine::LayerSettings blurLayerSettings; @@ -202,43 +202,40 @@ void CachedSet::render(renderengine::RenderEngine& renderEngine, TexturePool& te auto blurSettings = targetSettings; blurSettings.blurSetting = LayerFE::ClientCompositionTargetSettings::BlurSetting::BackgroundBlurOnly; - auto clientCompositionList = - mBlurLayer->getOutputLayer()->getLayerFE().prepareClientCompositionList( - blurSettings); - blurLayerSettings = clientCompositionList.back(); + + auto blurLayerSettings = + mBlurLayer->getOutputLayer()->getLayerFE().prepareClientComposition(blurSettings); // This mimics Layer::prepareClearClientComposition - blurLayerSettings.skipContentDraw = true; - blurLayerSettings.name = std::string("blur layer"); + blurLayerSettings->skipContentDraw = true; + blurLayerSettings->name = std::string("blur layer"); // Clear out the shadow settings - blurLayerSettings.shadow = {}; - layerSettings.push_back(blurLayerSettings); + blurLayerSettings->shadow = {}; + layerSettings.push_back(std::move(*blurLayerSettings)); } - renderengine::LayerSettings holePunchSettings; - renderengine::LayerSettings holePunchBackgroundSettings; if (mHolePunchLayer) { auto& layerFE = mHolePunchLayer->getOutputLayer()->getLayerFE(); - auto clientCompositionList = layerFE.prepareClientCompositionList(targetSettings); - // Assume that the final layer contains the buffer that we want to - // replace with a hole punch. - holePunchSettings = clientCompositionList.back(); + + auto holePunchSettings = layerFE.prepareClientComposition(targetSettings); // This mimics Layer::prepareClearClientComposition - holePunchSettings.source.buffer.buffer = nullptr; - holePunchSettings.source.solidColor = half3(0.0f, 0.0f, 0.0f); - holePunchSettings.disableBlending = true; - holePunchSettings.alpha = 0.0f; - holePunchSettings.name = + holePunchSettings->source.buffer.buffer = nullptr; + holePunchSettings->source.solidColor = half3(0.0f, 0.0f, 0.0f); + holePunchSettings->disableBlending = true; + holePunchSettings->alpha = 0.0f; + holePunchSettings->name = android::base::StringPrintf("hole punch layer for %s", layerFE.getDebugName()); - layerSettings.push_back(holePunchSettings); // Add a solid background as the first layer in case there is no opaque // buffer behind the punch hole + renderengine::LayerSettings holePunchBackgroundSettings; holePunchBackgroundSettings.alpha = 1.0f; holePunchBackgroundSettings.name = std::string("holePunchBackground"); - holePunchBackgroundSettings.geometry.boundaries = holePunchSettings.geometry.boundaries; + holePunchBackgroundSettings.geometry.boundaries = holePunchSettings->geometry.boundaries; holePunchBackgroundSettings.geometry.positionTransform = - holePunchSettings.geometry.positionTransform; - layerSettings.emplace(layerSettings.begin(), holePunchBackgroundSettings); + holePunchSettings->geometry.positionTransform; + layerSettings.emplace(layerSettings.begin(), std::move(holePunchBackgroundSettings)); + + layerSettings.push_back(std::move(*holePunchSettings)); } if (sDebugHighlighLayers) { diff --git a/services/surfaceflinger/CompositionEngine/tests/OutputTest.cpp b/services/surfaceflinger/CompositionEngine/tests/OutputTest.cpp index ad0fb9d6c4..163a11ccd1 100644 --- a/services/surfaceflinger/CompositionEngine/tests/OutputTest.cpp +++ b/services/surfaceflinger/CompositionEngine/tests/OutputTest.cpp @@ -4308,6 +4308,8 @@ struct GenerateClientCompositionRequestsTest : public testing::Test { struct Layer { Layer() { + EXPECT_CALL(mOutputLayer, getOverrideCompositionSettings()) + .WillRepeatedly(Return(std::nullopt)); EXPECT_CALL(mOutputLayer, getState()).WillRepeatedly(ReturnRef(mOutputLayerState)); EXPECT_CALL(mOutputLayer, editState()).WillRepeatedly(ReturnRef(mOutputLayerState)); EXPECT_CALL(mOutputLayer, getLayerFE()).WillRepeatedly(ReturnRef(*mLayerFE)); @@ -4405,23 +4407,18 @@ TEST_F(GenerateClientCompositionRequestsTest_ThreeLayers, requiresVisibleRegionA } TEST_F(GenerateClientCompositionRequestsTest_ThreeLayers, gathersClientCompositionRequests) { - LayerFE::LayerSettings mShadowSettings; - mShadowSettings.source.solidColor = {0.1f, 0.1f, 0.1f}; - - EXPECT_CALL(*mLayers[0].mLayerFE, prepareClientCompositionList(_)) - .WillOnce(Return(std::vector<LayerFE::LayerSettings>())); - EXPECT_CALL(*mLayers[1].mLayerFE, prepareClientCompositionList(_)) - .WillOnce(Return(std::vector<LayerFE::LayerSettings>({mLayers[1].mLayerSettings}))); - EXPECT_CALL(*mLayers[2].mLayerFE, prepareClientCompositionList(_)) - .WillOnce(Return(std::vector<LayerFE::LayerSettings>( - {mShadowSettings, mLayers[2].mLayerSettings}))); + EXPECT_CALL(*mLayers[0].mLayerFE, prepareClientComposition(_)) + .WillOnce(Return(std::optional<LayerFE::LayerSettings>())); + EXPECT_CALL(*mLayers[1].mLayerFE, prepareClientComposition(_)) + .WillOnce(Return(std::optional<LayerFE::LayerSettings>(mLayers[1].mLayerSettings))); + EXPECT_CALL(*mLayers[2].mLayerFE, prepareClientComposition(_)) + .WillOnce(Return(std::optional<LayerFE::LayerSettings>(mLayers[2].mLayerSettings))); auto requests = mOutput.generateClientCompositionRequestsHelper(false /* supportsProtectedContent */, kDisplayDataspace); - ASSERT_EQ(3u, requests.size()); + ASSERT_EQ(2u, requests.size()); EXPECT_EQ(mLayers[1].mLayerSettings, requests[0]); - EXPECT_EQ(mShadowSettings, requests[1]); - EXPECT_EQ(mLayers[2].mLayerSettings, requests[2]); + EXPECT_EQ(mLayers[2].mLayerSettings, requests[1]); // Check that a timestamp was set for the layers that generated requests EXPECT_TRUE(0 == mLayers[0].mOutputLayerState.clientCompositionTimestamp); @@ -4438,27 +4435,21 @@ MATCHER_P(ClientCompositionTargetSettingsBlurSettingsEq, expectedBlurSetting, "" } TEST_F(GenerateClientCompositionRequestsTest_ThreeLayers, overridesBlur) { - LayerFE::LayerSettings mShadowSettings; - mShadowSettings.source.solidColor = {0.1f, 0.1f, 0.1f}; - mLayers[2].mOutputLayerState.overrideInfo.disableBackgroundBlur = true; - EXPECT_CALL(*mLayers[0].mLayerFE, prepareClientCompositionList(_)) - .WillOnce(Return(std::vector<LayerFE::LayerSettings>())); - EXPECT_CALL(*mLayers[1].mLayerFE, prepareClientCompositionList(_)) - .WillOnce(Return(std::vector<LayerFE::LayerSettings>({mLayers[1].mLayerSettings}))); + EXPECT_CALL(*mLayers[0].mLayerFE, prepareClientComposition(_)) + .WillOnce(Return(std::optional<LayerFE::LayerSettings>())); + EXPECT_CALL(*mLayers[1].mLayerFE, prepareClientComposition(_)) + .WillOnce(Return(std::optional<LayerFE::LayerSettings>(mLayers[1].mLayerSettings))); EXPECT_CALL(*mLayers[2].mLayerFE, - prepareClientCompositionList(ClientCompositionTargetSettingsBlurSettingsEq( + prepareClientComposition(ClientCompositionTargetSettingsBlurSettingsEq( LayerFE::ClientCompositionTargetSettings::BlurSetting::BlurRegionsOnly))) - .WillOnce(Return(std::vector<LayerFE::LayerSettings>( - {mShadowSettings, mLayers[2].mLayerSettings}))); - + .WillOnce(Return(std::optional<LayerFE::LayerSettings>(mLayers[2].mLayerSettings))); auto requests = mOutput.generateClientCompositionRequestsHelper(false /* supportsProtectedContent */, kDisplayDataspace); - ASSERT_EQ(3u, requests.size()); + ASSERT_EQ(2u, requests.size()); EXPECT_EQ(mLayers[1].mLayerSettings, requests[0]); - EXPECT_EQ(mShadowSettings, requests[1]); - EXPECT_EQ(mLayers[2].mLayerSettings, requests[2]); + EXPECT_EQ(mLayers[2].mLayerSettings, requests[1]); // Check that a timestamp was set for the layers that generated requests EXPECT_TRUE(0 == mLayers[0].mOutputLayerState.clientCompositionTimestamp); @@ -4480,8 +4471,8 @@ TEST_F(GenerateClientCompositionRequestsTest_ThreeLayers, mLayers[1].mLayerFEState.isOpaque = true; mLayers[2].mLayerFEState.isOpaque = true; - EXPECT_CALL(*mLayers[2].mLayerFE, prepareClientCompositionList(_)) - .WillOnce(Return(std::vector<LayerFE::LayerSettings>({mLayers[2].mLayerSettings}))); + EXPECT_CALL(*mLayers[2].mLayerFE, prepareClientComposition(_)) + .WillOnce(Return(std::optional<LayerFE::LayerSettings>(mLayers[2].mLayerSettings))); auto requests = mOutput.generateClientCompositionRequestsHelper(false /* supportsProtectedContent */, kDisplayDataspace); @@ -4503,8 +4494,8 @@ TEST_F(GenerateClientCompositionRequestsTest_ThreeLayers, mLayers[1].mLayerFEState.isOpaque = false; mLayers[2].mLayerFEState.isOpaque = false; - EXPECT_CALL(*mLayers[2].mLayerFE, prepareClientCompositionList(_)) - .WillOnce(Return(std::vector<LayerFE::LayerSettings>({mLayers[2].mLayerSettings}))); + EXPECT_CALL(*mLayers[2].mLayerFE, prepareClientComposition(_)) + .WillOnce(Return(std::optional<LayerFE::LayerSettings>(mLayers[2].mLayerSettings))); auto requests = mOutput.generateClientCompositionRequestsHelper(false /* supportsProtectedContent */, kDisplayDataspace); @@ -4562,10 +4553,10 @@ TEST_F(GenerateClientCompositionRequestsTest_ThreeLayers, clearsHWCLayersIfOpaqu mBlackoutSettings.alpha = 0.f; mBlackoutSettings.disableBlending = true; - EXPECT_CALL(*mLayers[1].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer1TargetSettings)))) - .WillOnce(Return(std::vector<LayerFE::LayerSettings>({mBlackoutSettings}))); - EXPECT_CALL(*mLayers[2].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer2TargetSettings)))) - .WillOnce(Return(std::vector<LayerFE::LayerSettings>({mLayers[2].mLayerSettings}))); + EXPECT_CALL(*mLayers[1].mLayerFE, prepareClientComposition(Eq(ByRef(layer1TargetSettings)))) + .WillOnce(Return(std::optional<LayerFE::LayerSettings>(mBlackoutSettings))); + EXPECT_CALL(*mLayers[2].mLayerFE, prepareClientComposition(Eq(ByRef(layer2TargetSettings)))) + .WillOnce(Return(std::optional<LayerFE::LayerSettings>(mLayers[2].mLayerSettings))); auto requests = mOutput.generateClientCompositionRequestsHelper(false /* supportsProtectedContent */, kDisplayDataspace); @@ -4620,12 +4611,12 @@ TEST_F(GenerateClientCompositionRequestsTest_ThreeLayers, kLayerWhitePointNits, }; - EXPECT_CALL(*mLayers[0].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer0TargetSettings)))) - .WillOnce(Return(std::vector<LayerFE::LayerSettings>())); - EXPECT_CALL(*mLayers[1].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer1TargetSettings)))) - .WillOnce(Return(std::vector<LayerFE::LayerSettings>())); - EXPECT_CALL(*mLayers[2].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer2TargetSettings)))) - .WillOnce(Return(std::vector<LayerFE::LayerSettings>())); + EXPECT_CALL(*mLayers[0].mLayerFE, prepareClientComposition(Eq(ByRef(layer0TargetSettings)))) + .WillOnce(Return(std::optional<LayerFE::LayerSettings>())); + EXPECT_CALL(*mLayers[1].mLayerFE, prepareClientComposition(Eq(ByRef(layer1TargetSettings)))) + .WillOnce(Return(std::optional<LayerFE::LayerSettings>())); + EXPECT_CALL(*mLayers[2].mLayerFE, prepareClientComposition(Eq(ByRef(layer2TargetSettings)))) + .WillOnce(Return(std::optional<LayerFE::LayerSettings>())); static_cast<void>( mOutput.generateClientCompositionRequestsHelper(false /* supportsProtectedContent */, @@ -4674,12 +4665,12 @@ TEST_F(GenerateClientCompositionRequestsTest_ThreeLayers, kLayerWhitePointNits, }; - EXPECT_CALL(*mLayers[0].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer0TargetSettings)))) - .WillOnce(Return(std::vector<LayerFE::LayerSettings>())); - EXPECT_CALL(*mLayers[1].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer1TargetSettings)))) - .WillOnce(Return(std::vector<LayerFE::LayerSettings>())); - EXPECT_CALL(*mLayers[2].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer2TargetSettings)))) - .WillOnce(Return(std::vector<LayerFE::LayerSettings>())); + EXPECT_CALL(*mLayers[0].mLayerFE, prepareClientComposition(Eq(ByRef(layer0TargetSettings)))) + .WillOnce(Return(std::optional<LayerFE::LayerSettings>())); + EXPECT_CALL(*mLayers[1].mLayerFE, prepareClientComposition(Eq(ByRef(layer1TargetSettings)))) + .WillOnce(Return(std::optional<LayerFE::LayerSettings>())); + EXPECT_CALL(*mLayers[2].mLayerFE, prepareClientComposition(Eq(ByRef(layer2TargetSettings)))) + .WillOnce(Return(std::optional<LayerFE::LayerSettings>())); static_cast<void>( mOutput.generateClientCompositionRequestsHelper(false /* supportsProtectedContent */, @@ -4728,12 +4719,12 @@ TEST_F(GenerateClientCompositionRequestsTest_ThreeLayers, kLayerWhitePointNits, }; - EXPECT_CALL(*mLayers[0].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer0TargetSettings)))) - .WillOnce(Return(std::vector<LayerFE::LayerSettings>())); - EXPECT_CALL(*mLayers[1].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer1TargetSettings)))) - .WillOnce(Return(std::vector<LayerFE::LayerSettings>())); - EXPECT_CALL(*mLayers[2].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer2TargetSettings)))) - .WillOnce(Return(std::vector<LayerFE::LayerSettings>())); + EXPECT_CALL(*mLayers[0].mLayerFE, prepareClientComposition(Eq(ByRef(layer0TargetSettings)))) + .WillOnce(Return(std::optional<LayerFE::LayerSettings>())); + EXPECT_CALL(*mLayers[1].mLayerFE, prepareClientComposition(Eq(ByRef(layer1TargetSettings)))) + .WillOnce(Return(std::optional<LayerFE::LayerSettings>())); + EXPECT_CALL(*mLayers[2].mLayerFE, prepareClientComposition(Eq(ByRef(layer2TargetSettings)))) + .WillOnce(Return(std::optional<LayerFE::LayerSettings>())); static_cast<void>( mOutput.generateClientCompositionRequestsHelper(false /* supportsProtectedContent */, @@ -4781,12 +4772,12 @@ TEST_F(GenerateClientCompositionRequestsTest_ThreeLayers, kLayerWhitePointNits, }; - EXPECT_CALL(*mLayers[0].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer0TargetSettings)))) - .WillOnce(Return(std::vector<LayerFE::LayerSettings>())); - EXPECT_CALL(*mLayers[1].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer1TargetSettings)))) - .WillOnce(Return(std::vector<LayerFE::LayerSettings>())); - EXPECT_CALL(*mLayers[2].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer2TargetSettings)))) - .WillOnce(Return(std::vector<LayerFE::LayerSettings>())); + EXPECT_CALL(*mLayers[0].mLayerFE, prepareClientComposition(Eq(ByRef(layer0TargetSettings)))) + .WillOnce(Return(std::optional<LayerFE::LayerSettings>())); + EXPECT_CALL(*mLayers[1].mLayerFE, prepareClientComposition(Eq(ByRef(layer1TargetSettings)))) + .WillOnce(Return(std::optional<LayerFE::LayerSettings>())); + EXPECT_CALL(*mLayers[2].mLayerFE, prepareClientComposition(Eq(ByRef(layer2TargetSettings)))) + .WillOnce(Return(std::optional<LayerFE::LayerSettings>())); static_cast<void>( mOutput.generateClientCompositionRequestsHelper(false /* supportsProtectedContent */, @@ -4832,12 +4823,12 @@ TEST_F(GenerateClientCompositionRequestsTest_ThreeLayers, kLayerWhitePointNits, }; - EXPECT_CALL(*mLayers[0].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer0TargetSettings)))) - .WillOnce(Return(std::vector<LayerFE::LayerSettings>())); - EXPECT_CALL(*mLayers[1].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer1TargetSettings)))) - .WillOnce(Return(std::vector<LayerFE::LayerSettings>())); - EXPECT_CALL(*mLayers[2].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer2TargetSettings)))) - .WillOnce(Return(std::vector<LayerFE::LayerSettings>())); + EXPECT_CALL(*mLayers[0].mLayerFE, prepareClientComposition(Eq(ByRef(layer0TargetSettings)))) + .WillOnce(Return(std::optional<LayerFE::LayerSettings>())); + EXPECT_CALL(*mLayers[1].mLayerFE, prepareClientComposition(Eq(ByRef(layer1TargetSettings)))) + .WillOnce(Return(std::optional<LayerFE::LayerSettings>())); + EXPECT_CALL(*mLayers[2].mLayerFE, prepareClientComposition(Eq(ByRef(layer2TargetSettings)))) + .WillOnce(Return(std::optional<LayerFE::LayerSettings>())); static_cast<void>(mOutput.generateClientCompositionRequestsHelper(true /* supportsProtectedContent */, kDisplayDataspace)); @@ -5018,8 +5009,8 @@ TEST_F(GenerateClientCompositionRequestsTest, handlesLandscapeModeSplitScreenReq EXPECT_CALL(leftLayer.mOutputLayer, requiresClientComposition()).WillRepeatedly(Return(true)); EXPECT_CALL(leftLayer.mOutputLayer, needsFiltering()).WillRepeatedly(Return(false)); - EXPECT_CALL(*leftLayer.mLayerFE, prepareClientCompositionList(Eq(ByRef(leftLayerSettings)))) - .WillOnce(Return(std::vector<LayerFE::LayerSettings>({leftLayer.mLayerSettings}))); + EXPECT_CALL(*leftLayer.mLayerFE, prepareClientComposition(Eq(ByRef(leftLayerSettings)))) + .WillOnce(Return(std::optional<LayerFE::LayerSettings>(leftLayer.mLayerSettings))); compositionengine::LayerFE::ClientCompositionTargetSettings rightLayerSettings{ Region(Rect(1000, 0, 2000, 1000)), @@ -5036,8 +5027,8 @@ TEST_F(GenerateClientCompositionRequestsTest, handlesLandscapeModeSplitScreenReq EXPECT_CALL(rightLayer.mOutputLayer, requiresClientComposition()).WillRepeatedly(Return(true)); EXPECT_CALL(rightLayer.mOutputLayer, needsFiltering()).WillRepeatedly(Return(false)); - EXPECT_CALL(*rightLayer.mLayerFE, prepareClientCompositionList(Eq(ByRef(rightLayerSettings)))) - .WillOnce(Return(std::vector<LayerFE::LayerSettings>({rightLayer.mLayerSettings}))); + EXPECT_CALL(*rightLayer.mLayerFE, prepareClientComposition(Eq(ByRef(rightLayerSettings)))) + .WillOnce(Return(std::optional<LayerFE::LayerSettings>(rightLayer.mLayerSettings))); constexpr bool supportsProtectedContent = true; auto requests = @@ -5075,8 +5066,8 @@ TEST_F(GenerateClientCompositionRequestsTest_ThreeLayers, EXPECT_CALL(mLayers[0].mOutputLayer, requiresClientComposition()).WillOnce(Return(false)); EXPECT_CALL(mLayers[1].mOutputLayer, requiresClientComposition()).WillOnce(Return(false)); - EXPECT_CALL(*mLayers[2].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer2Settings)))) - .WillOnce(Return(std::vector<LayerFE::LayerSettings>({mShadowSettings}))); + EXPECT_CALL(*mLayers[2].mLayerFE, prepareClientComposition(Eq(ByRef(layer2Settings)))) + .WillOnce(Return(std::optional<LayerFE::LayerSettings>(mShadowSettings))); auto requests = mOutput.generateClientCompositionRequestsHelper(false /* supportsProtectedContent */, kDisplayDataspace); @@ -5093,9 +5084,6 @@ TEST_F(GenerateClientCompositionRequestsTest_ThreeLayers, const Region kPartialContentWithPartialShadowRegion = Region(kContentWithShadow).subtract(Rect(40, 40, 50, 80)); - LayerFE::LayerSettings mShadowSettings; - mShadowSettings.source.solidColor = {0.1f, 0.1f, 0.1f}; - mLayers[2].mOutputLayerState.visibleRegion = kPartialContentWithPartialShadowRegion; mLayers[2].mOutputLayerState.shadowRegion = kShadowRegion; @@ -5114,16 +5102,14 @@ TEST_F(GenerateClientCompositionRequestsTest_ThreeLayers, EXPECT_CALL(mLayers[0].mOutputLayer, requiresClientComposition()).WillOnce(Return(false)); EXPECT_CALL(mLayers[1].mOutputLayer, requiresClientComposition()).WillOnce(Return(false)); - EXPECT_CALL(*mLayers[2].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer2Settings)))) - .WillOnce(Return(std::vector<LayerFE::LayerSettings>( - {mShadowSettings, mLayers[2].mLayerSettings}))); + EXPECT_CALL(*mLayers[2].mLayerFE, prepareClientComposition(Eq(ByRef(layer2Settings)))) + .WillOnce(Return(std::optional<LayerFE::LayerSettings>(mLayers[2].mLayerSettings))); auto requests = mOutput.generateClientCompositionRequestsHelper(false /* supportsProtectedContent */, kDisplayDataspace); - ASSERT_EQ(2u, requests.size()); + ASSERT_EQ(1u, requests.size()); - EXPECT_EQ(mShadowSettings, requests[0]); - EXPECT_EQ(mLayers[2].mLayerSettings, requests[1]); + EXPECT_EQ(mLayers[2].mLayerSettings, requests[0]); } } // namespace diff --git a/services/surfaceflinger/CompositionEngine/tests/planner/CachedSetTest.cpp b/services/surfaceflinger/CompositionEngine/tests/planner/CachedSetTest.cpp index 8a99e4e2e8..cb4c4e23fe 100644 --- a/services/surfaceflinger/CompositionEngine/tests/planner/CachedSetTest.cpp +++ b/services/surfaceflinger/CompositionEngine/tests/planner/CachedSetTest.cpp @@ -345,13 +345,13 @@ TEST_F(CachedSetTest, renderUnsecureOutput) { CachedSet cachedSet(layer1); cachedSet.append(CachedSet(layer2)); - std::vector<compositionengine::LayerFE::LayerSettings> clientCompList1; - clientCompList1.push_back({}); - clientCompList1[0].alpha = 0.5f; + std::optional<compositionengine::LayerFE::LayerSettings> clientComp1; + clientComp1.emplace(); + clientComp1->alpha = 0.5f; - std::vector<compositionengine::LayerFE::LayerSettings> clientCompList2; - clientCompList2.push_back({}); - clientCompList2[0].alpha = 0.75f; + std::optional<compositionengine::LayerFE::LayerSettings> clientComp2; + clientComp2.emplace(); + clientComp2->alpha = 0.75f; const auto drawLayers = [&](const renderengine::DisplaySettings& displaySettings, @@ -368,12 +368,10 @@ TEST_F(CachedSetTest, renderUnsecureOutput) { return futureOf<renderengine::RenderEngineResult>({NO_ERROR, base::unique_fd()}); }; - EXPECT_CALL(*layerFE1, - prepareClientCompositionList(ClientCompositionTargetSettingsSecureEq(false))) - .WillOnce(Return(clientCompList1)); - EXPECT_CALL(*layerFE2, - prepareClientCompositionList(ClientCompositionTargetSettingsSecureEq(false))) - .WillOnce(Return(clientCompList2)); + EXPECT_CALL(*layerFE1, prepareClientComposition(ClientCompositionTargetSettingsSecureEq(false))) + .WillOnce(Return(clientComp1)); + EXPECT_CALL(*layerFE2, prepareClientComposition(ClientCompositionTargetSettingsSecureEq(false))) + .WillOnce(Return(clientComp2)); EXPECT_CALL(mRenderEngine, drawLayers(_, _, _, _, _)).WillOnce(Invoke(drawLayers)); mOutputState.isSecure = false; cachedSet.render(mRenderEngine, mTexturePool, mOutputState); @@ -397,13 +395,13 @@ TEST_F(CachedSetTest, renderSecureOutput) { CachedSet cachedSet(layer1); cachedSet.append(CachedSet(layer2)); - std::vector<compositionengine::LayerFE::LayerSettings> clientCompList1; - clientCompList1.push_back({}); - clientCompList1[0].alpha = 0.5f; + std::optional<compositionengine::LayerFE::LayerSettings> clientComp1; + clientComp1.emplace(); + clientComp1->alpha = 0.5f; - std::vector<compositionengine::LayerFE::LayerSettings> clientCompList2; - clientCompList2.push_back({}); - clientCompList2[0].alpha = 0.75f; + std::optional<compositionengine::LayerFE::LayerSettings> clientComp2; + clientComp2.emplace(); + clientComp2->alpha = 0.75f; const auto drawLayers = [&](const renderengine::DisplaySettings& displaySettings, @@ -421,12 +419,10 @@ TEST_F(CachedSetTest, renderSecureOutput) { return futureOf<renderengine::RenderEngineResult>({NO_ERROR, base::unique_fd()}); }; - EXPECT_CALL(*layerFE1, - prepareClientCompositionList(ClientCompositionTargetSettingsSecureEq(true))) - .WillOnce(Return(clientCompList1)); - EXPECT_CALL(*layerFE2, - prepareClientCompositionList(ClientCompositionTargetSettingsSecureEq(true))) - .WillOnce(Return(clientCompList2)); + EXPECT_CALL(*layerFE1, prepareClientComposition(ClientCompositionTargetSettingsSecureEq(true))) + .WillOnce(Return(clientComp1)); + EXPECT_CALL(*layerFE2, prepareClientComposition(ClientCompositionTargetSettingsSecureEq(true))) + .WillOnce(Return(clientComp2)); EXPECT_CALL(mRenderEngine, drawLayers(_, _, _, _, _)).WillOnce(Invoke(drawLayers)); mOutputState.isSecure = true; cachedSet.render(mRenderEngine, mTexturePool, mOutputState); @@ -450,11 +446,11 @@ TEST_F(CachedSetTest, renderWhitePoint) { CachedSet cachedSet(layer1); cachedSet.append(CachedSet(layer2)); - std::vector<compositionengine::LayerFE::LayerSettings> clientCompList1; - clientCompList1.push_back({}); + std::optional<compositionengine::LayerFE::LayerSettings> clientComp1; + clientComp1.emplace(); - std::vector<compositionengine::LayerFE::LayerSettings> clientCompList2; - clientCompList2.push_back({}); + std::optional<compositionengine::LayerFE::LayerSettings> clientComp2; + clientComp2.emplace(); mOutputState.displayBrightnessNits = 400.f; @@ -468,13 +464,13 @@ TEST_F(CachedSetTest, renderWhitePoint) { }; EXPECT_CALL(*layerFE1, - prepareClientCompositionList(ClientCompositionTargetSettingsWhitePointEq( + prepareClientComposition(ClientCompositionTargetSettingsWhitePointEq( mOutputState.displayBrightnessNits))) - .WillOnce(Return(clientCompList1)); + .WillOnce(Return(clientComp1)); EXPECT_CALL(*layerFE2, - prepareClientCompositionList(ClientCompositionTargetSettingsWhitePointEq( + prepareClientComposition(ClientCompositionTargetSettingsWhitePointEq( mOutputState.displayBrightnessNits))) - .WillOnce(Return(clientCompList2)); + .WillOnce(Return(clientComp2)); EXPECT_CALL(mRenderEngine, drawLayers(_, _, _, _, _)).WillOnce(Invoke(drawLayers)); mOutputState.isSecure = true; cachedSet.render(mRenderEngine, mTexturePool, mOutputState); @@ -498,13 +494,13 @@ TEST_F(CachedSetTest, rendersWithOffsetFramebufferContent) { CachedSet cachedSet(layer1); cachedSet.append(CachedSet(layer2)); - std::vector<compositionengine::LayerFE::LayerSettings> clientCompList1; - clientCompList1.push_back({}); - clientCompList1[0].alpha = 0.5f; + std::optional<compositionengine::LayerFE::LayerSettings> clientComp1; + clientComp1.emplace(); + clientComp1->alpha = 0.5f; - std::vector<compositionengine::LayerFE::LayerSettings> clientCompList2; - clientCompList2.push_back({}); - clientCompList2[0].alpha = 0.75f; + std::optional<compositionengine::LayerFE::LayerSettings> clientComp2; + clientComp2.emplace(); + clientComp2->alpha = 0.75f; mOutputState.framebufferSpace = ProjectionSpace(ui::Size(10, 20), Rect(2, 3, 10, 5)); @@ -524,8 +520,8 @@ TEST_F(CachedSetTest, rendersWithOffsetFramebufferContent) { return futureOf<renderengine::RenderEngineResult>({NO_ERROR, base::unique_fd()}); }; - EXPECT_CALL(*layerFE1, prepareClientCompositionList(_)).WillOnce(Return(clientCompList1)); - EXPECT_CALL(*layerFE2, prepareClientCompositionList(_)).WillOnce(Return(clientCompList2)); + EXPECT_CALL(*layerFE1, prepareClientComposition(_)).WillOnce(Return(clientComp1)); + EXPECT_CALL(*layerFE2, prepareClientComposition(_)).WillOnce(Return(clientComp2)); EXPECT_CALL(mRenderEngine, drawLayers(_, _, _, _, _)).WillOnce(Invoke(drawLayers)); cachedSet.render(mRenderEngine, mTexturePool, mOutputState); expectReadyBuffer(cachedSet); @@ -722,22 +718,22 @@ TEST_F(CachedSetTest, addHolePunch) { cachedSet.addHolePunchLayerIfFeasible(layer3, true); - std::vector<compositionengine::LayerFE::LayerSettings> clientCompList1; - clientCompList1.push_back({}); - std::vector<compositionengine::LayerFE::LayerSettings> clientCompList2; - clientCompList2.push_back({}); - std::vector<compositionengine::LayerFE::LayerSettings> clientCompList3; - clientCompList3.push_back({}); + std::optional<compositionengine::LayerFE::LayerSettings> clientComp1; + clientComp1.emplace(); + std::optional<compositionengine::LayerFE::LayerSettings> clientComp2; + clientComp2.emplace(); + std::optional<compositionengine::LayerFE::LayerSettings> clientComp3; + clientComp3.emplace(); - clientCompList3[0].source.buffer.buffer = + clientComp3->source.buffer.buffer = std::make_shared<renderengine::mock::FakeExternalTexture>(1U /*width*/, 1U /*height*/, 1ULL /* bufferId */, HAL_PIXEL_FORMAT_RGBA_8888, 0ULL /*usage*/); - EXPECT_CALL(*layerFE1, prepareClientCompositionList(_)).WillOnce(Return(clientCompList1)); - EXPECT_CALL(*layerFE2, prepareClientCompositionList(_)).WillOnce(Return(clientCompList2)); - EXPECT_CALL(*layerFE3, prepareClientCompositionList(_)).WillOnce(Return(clientCompList3)); + EXPECT_CALL(*layerFE1, prepareClientComposition(_)).WillOnce(Return(clientComp1)); + EXPECT_CALL(*layerFE2, prepareClientComposition(_)).WillOnce(Return(clientComp2)); + EXPECT_CALL(*layerFE3, prepareClientComposition(_)).WillOnce(Return(clientComp3)); const auto drawLayers = [&](const renderengine::DisplaySettings&, @@ -771,7 +767,7 @@ TEST_F(CachedSetTest, addHolePunch) { } TEST_F(CachedSetTest, addHolePunch_noBuffer) { - // Same as addHolePunch, except that clientCompList3 does not contain a + // Same as addHolePunch, except that clientComp3 does not contain a // buffer. This imitates the case where the buffer had protected content, so // BufferLayer did not add it to the LayerSettings. This should not assert. mTestLayers[0]->outputLayerCompositionState.displayFrame = Rect(0, 0, 5, 5); @@ -789,16 +785,16 @@ TEST_F(CachedSetTest, addHolePunch_noBuffer) { cachedSet.addHolePunchLayerIfFeasible(layer3, true); - std::vector<compositionengine::LayerFE::LayerSettings> clientCompList1; - clientCompList1.push_back({}); - std::vector<compositionengine::LayerFE::LayerSettings> clientCompList2; - clientCompList2.push_back({}); - std::vector<compositionengine::LayerFE::LayerSettings> clientCompList3; - clientCompList3.push_back({}); + std::optional<compositionengine::LayerFE::LayerSettings> clientComp1; + clientComp1.emplace(); + std::optional<compositionengine::LayerFE::LayerSettings> clientComp2; + clientComp2.emplace(); + std::optional<compositionengine::LayerFE::LayerSettings> clientComp3; + clientComp3.emplace(); - EXPECT_CALL(*layerFE1, prepareClientCompositionList(_)).WillOnce(Return(clientCompList1)); - EXPECT_CALL(*layerFE2, prepareClientCompositionList(_)).WillOnce(Return(clientCompList2)); - EXPECT_CALL(*layerFE3, prepareClientCompositionList(_)).WillOnce(Return(clientCompList3)); + EXPECT_CALL(*layerFE1, prepareClientComposition(_)).WillOnce(Return(clientComp1)); + EXPECT_CALL(*layerFE2, prepareClientComposition(_)).WillOnce(Return(clientComp2)); + EXPECT_CALL(*layerFE3, prepareClientComposition(_)).WillOnce(Return(clientComp3)); const auto drawLayers = [&](const renderengine::DisplaySettings&, @@ -923,34 +919,34 @@ TEST_F(CachedSetTest, addBlur) { cachedSet.addBackgroundBlurLayer(layer3); - std::vector<compositionengine::LayerFE::LayerSettings> clientCompList1; - clientCompList1.push_back({}); - std::vector<compositionengine::LayerFE::LayerSettings> clientCompList2; - clientCompList2.push_back({}); - std::vector<compositionengine::LayerFE::LayerSettings> clientCompList3; - clientCompList3.push_back({}); + std::optional<compositionengine::LayerFE::LayerSettings> clientComp1; + clientComp1.emplace(); + std::optional<compositionengine::LayerFE::LayerSettings> clientComp2; + clientComp2.emplace(); + std::optional<compositionengine::LayerFE::LayerSettings> clientComp3; + clientComp3.emplace(); - clientCompList3[0].source.buffer.buffer = + clientComp3->source.buffer.buffer = std::make_shared<renderengine::mock::FakeExternalTexture>(1U /*width*/, 1U /*height*/, 1ULL /* bufferId */, HAL_PIXEL_FORMAT_RGBA_8888, 0ULL /*usage*/); EXPECT_CALL(*layerFE1, - prepareClientCompositionList(ClientCompositionTargetSettingsBlurSettingsEq( + prepareClientComposition(ClientCompositionTargetSettingsBlurSettingsEq( compositionengine::LayerFE::ClientCompositionTargetSettings::BlurSetting:: Enabled))) - .WillOnce(Return(clientCompList1)); + .WillOnce(Return(clientComp1)); EXPECT_CALL(*layerFE2, - prepareClientCompositionList(ClientCompositionTargetSettingsBlurSettingsEq( + prepareClientComposition(ClientCompositionTargetSettingsBlurSettingsEq( compositionengine::LayerFE::ClientCompositionTargetSettings::BlurSetting:: Enabled))) - .WillOnce(Return(clientCompList2)); + .WillOnce(Return(clientComp2)); EXPECT_CALL(*layerFE3, - prepareClientCompositionList(ClientCompositionTargetSettingsBlurSettingsEq( + prepareClientComposition(ClientCompositionTargetSettingsBlurSettingsEq( compositionengine::LayerFE::ClientCompositionTargetSettings::BlurSetting:: BackgroundBlurOnly))) - .WillOnce(Return(clientCompList3)); + .WillOnce(Return(clientComp3)); const auto drawLayers = [&](const renderengine::DisplaySettings&, diff --git a/services/surfaceflinger/CompositionEngine/tests/planner/FlattenerTest.cpp b/services/surfaceflinger/CompositionEngine/tests/planner/FlattenerTest.cpp index 200278cb84..b624d1a2ea 100644 --- a/services/surfaceflinger/CompositionEngine/tests/planner/FlattenerTest.cpp +++ b/services/surfaceflinger/CompositionEngine/tests/planner/FlattenerTest.cpp @@ -124,12 +124,11 @@ void FlattenerTest::SetUp() { EXPECT_CALL(*testLayer->layerFE, getCompositionState) .WillRepeatedly(Return(&testLayer->layerFECompositionState)); - std::vector<LayerFE::LayerSettings> clientCompositionList = { - LayerFE::LayerSettings{}, - }; + std::optional<LayerFE::LayerSettings> clientComposition; + clientComposition.emplace(); - EXPECT_CALL(*testLayer->layerFE, prepareClientCompositionList) - .WillRepeatedly(Return(clientCompositionList)); + EXPECT_CALL(*testLayer->layerFE, prepareClientComposition) + .WillRepeatedly(Return(clientComposition)); EXPECT_CALL(testLayer->outputLayer, getLayerFE) .WillRepeatedly(ReturnRef(*testLayer->layerFE)); EXPECT_CALL(testLayer->outputLayer, getState) @@ -638,16 +637,15 @@ TEST_F(FlattenerTest, flattenLayers_pip) { EXPECT_CALL(*mTestLayers[2]->layerFE, hasRoundedCorners()).WillRepeatedly(Return(true)); - std::vector<LayerFE::LayerSettings> clientCompositionList = { - LayerFE::LayerSettings{}, - }; - clientCompositionList[0].source.buffer.buffer = std::make_shared< + std::optional<LayerFE::LayerSettings> clientComposition; + clientComposition.emplace(); + clientComposition->source.buffer.buffer = std::make_shared< renderengine::impl::ExternalTexture>(mTestLayers[2]->layerFECompositionState.buffer, mRenderEngine, renderengine::impl::ExternalTexture::Usage:: READABLE); - EXPECT_CALL(*mTestLayers[2]->layerFE, prepareClientCompositionList(_)) - .WillOnce(Return(clientCompositionList)); + EXPECT_CALL(*mTestLayers[2]->layerFE, prepareClientComposition(_)) + .WillOnce(Return(clientComposition)); const std::vector<const LayerState*> layers = { layerState1.get(), @@ -712,16 +710,15 @@ TEST_F(FlattenerTest, flattenLayers_holePunchSingleLayer) { EXPECT_CALL(*mTestLayers[1]->layerFE, hasRoundedCorners()).WillRepeatedly(Return(true)); - std::vector<LayerFE::LayerSettings> clientCompositionList = { - LayerFE::LayerSettings{}, - }; - clientCompositionList[0].source.buffer.buffer = std::make_shared< + std::optional<LayerFE::LayerSettings> clientComposition; + clientComposition.emplace(); + clientComposition->source.buffer.buffer = std::make_shared< renderengine::impl::ExternalTexture>(mTestLayers[1]->layerFECompositionState.buffer, mRenderEngine, renderengine::impl::ExternalTexture::Usage:: READABLE); - EXPECT_CALL(*mTestLayers[1]->layerFE, prepareClientCompositionList(_)) - .WillOnce(Return(clientCompositionList)); + EXPECT_CALL(*mTestLayers[1]->layerFE, prepareClientComposition(_)) + .WillOnce(Return(clientComposition)); const std::vector<const LayerState*> layers = { layerState0.get(), @@ -784,16 +781,15 @@ TEST_F(FlattenerTest, flattenLayers_holePunchSingleColorLayer) { EXPECT_CALL(*mTestLayers[1]->layerFE, hasRoundedCorners()).WillRepeatedly(Return(true)); - std::vector<LayerFE::LayerSettings> clientCompositionList = { - LayerFE::LayerSettings{}, - }; - clientCompositionList[0].source.buffer.buffer = std::make_shared< + std::optional<LayerFE::LayerSettings> clientComposition; + clientComposition.emplace(); + clientComposition->source.buffer.buffer = std::make_shared< renderengine::impl::ExternalTexture>(mTestLayers[1]->layerFECompositionState.buffer, mRenderEngine, renderengine::impl::ExternalTexture::Usage:: READABLE); - EXPECT_CALL(*mTestLayers[1]->layerFE, prepareClientCompositionList(_)) - .WillOnce(Return(clientCompositionList)); + EXPECT_CALL(*mTestLayers[1]->layerFE, prepareClientComposition(_)) + .WillOnce(Return(clientComposition)); const std::vector<const LayerState*> layers = { layerState0.get(), diff --git a/services/surfaceflinger/EffectLayer.cpp b/services/surfaceflinger/EffectLayer.cpp index d8bbc306e4..d161c510fd 100644 --- a/services/surfaceflinger/EffectLayer.cpp +++ b/services/surfaceflinger/EffectLayer.cpp @@ -47,11 +47,10 @@ EffectLayer::EffectLayer(const LayerCreationArgs& args) EffectLayer::~EffectLayer() = default; -std::vector<compositionengine::LayerFE::LayerSettings> EffectLayer::prepareClientCompositionList( - compositionengine::LayerFE::ClientCompositionTargetSettings& targetSettings) { - std::vector<compositionengine::LayerFE::LayerSettings> results; +std::optional<compositionengine::LayerFE::LayerSettings> EffectLayer::prepareClientComposition( + compositionengine::LayerFE::ClientCompositionTargetSettings& targetSettings) const { std::optional<compositionengine::LayerFE::LayerSettings> layerSettings = - prepareClientComposition(targetSettings); + Layer::prepareClientComposition(targetSettings); // Nothing to render. if (!layerSettings) { return {}; @@ -64,13 +63,13 @@ std::vector<compositionengine::LayerFE::LayerSettings> EffectLayer::prepareClien if (targetSettings.realContentIsVisible && fillsColor()) { // Set color for color fill settings. layerSettings->source.solidColor = getColor().rgb; - results.push_back(*layerSettings); + return layerSettings; } else if (hasBlur() || drawShadows()) { layerSettings->skipContentDraw = true; - results.push_back(*layerSettings); + return layerSettings; } - return results; + return {}; } bool EffectLayer::isVisible() const { diff --git a/services/surfaceflinger/EffectLayer.h b/services/surfaceflinger/EffectLayer.h index 1dcb633251..747b0bfe9a 100644 --- a/services/surfaceflinger/EffectLayer.h +++ b/services/surfaceflinger/EffectLayer.h @@ -52,8 +52,9 @@ protected: */ const compositionengine::LayerFECompositionState* getCompositionState() const override; void preparePerFrameCompositionState() override; - std::vector<compositionengine::LayerFE::LayerSettings> prepareClientCompositionList( - compositionengine::LayerFE::ClientCompositionTargetSettings& targetSettings) override; + std::optional<compositionengine::LayerFE::LayerSettings> prepareClientComposition( + compositionengine::LayerFE::ClientCompositionTargetSettings& targetSettings) + const override; std::unique_ptr<compositionengine::LayerFECompositionState> mCompositionState; diff --git a/services/surfaceflinger/Layer.cpp b/services/surfaceflinger/Layer.cpp index 5e1a858d0e..dfff8fe8ee 100644 --- a/services/surfaceflinger/Layer.cpp +++ b/services/surfaceflinger/Layer.cpp @@ -575,7 +575,7 @@ const char* Layer::getDebugName() const { // --------------------------------------------------------------------------- std::optional<compositionengine::LayerFE::LayerSettings> Layer::prepareClientComposition( - compositionengine::LayerFE::ClientCompositionTargetSettings& targetSettings) { + compositionengine::LayerFE::ClientCompositionTargetSettings& targetSettings) const { if (!getCompositionState()) { return {}; } @@ -653,30 +653,6 @@ void Layer::prepareClearClientComposition(LayerFE::LayerSettings& layerSettings, layerSettings.name = getName(); } -// TODO(b/188891810): This method now only ever returns 0 or 1 layers so we should return -// std::optional instead of a vector. Additionally, we should consider removing -// this method entirely in favor of calling prepareClientComposition directly. -std::vector<compositionengine::LayerFE::LayerSettings> Layer::prepareClientCompositionList( - compositionengine::LayerFE::ClientCompositionTargetSettings& targetSettings) { - std::optional<compositionengine::LayerFE::LayerSettings> layerSettings = - prepareClientComposition(targetSettings); - // Nothing to render. - if (!layerSettings) { - return {}; - } - - // HWC requests to clear this layer. - if (targetSettings.clearContent) { - prepareClearClientComposition(*layerSettings, false /* blackout */); - return {*layerSettings}; - } - - // set the shadow for the layer if needed - prepareShadowClientComposition(*layerSettings, targetSettings.viewport); - - return {*layerSettings}; -} - aidl::android::hardware::graphics::composer3::Composition Layer::getCompositionType( const DisplayDevice& display) const { const auto outputLayer = findOutputLayerForDisplay(&display); @@ -2006,7 +1982,7 @@ Layer::RoundedCornerState Layer::getRoundedCornerState() const { } void Layer::prepareShadowClientComposition(LayerFE::LayerSettings& caster, - const Rect& layerStackRect) { + const Rect& layerStackRect) const { renderengine::ShadowSettings state = mFlinger->mDrawingState.globalShadowSettings; // Note: this preserves existing behavior of shadowing the entire layer and not cropping it if diff --git a/services/surfaceflinger/Layer.h b/services/surfaceflinger/Layer.h index 22bb866368..6e83b235d4 100644 --- a/services/surfaceflinger/Layer.h +++ b/services/surfaceflinger/Layer.h @@ -618,8 +618,9 @@ public: const compositionengine::LayerFECompositionState* getCompositionState() const override; bool onPreComposition(nsecs_t) override; void prepareCompositionState(compositionengine::LayerFE::StateSubset subset) override; - std::vector<compositionengine::LayerFE::LayerSettings> prepareClientCompositionList( - compositionengine::LayerFE::ClientCompositionTargetSettings&) override; + + std::optional<compositionengine::LayerFE::LayerSettings> prepareClientComposition( + compositionengine::LayerFE::ClientCompositionTargetSettings&) const override; void onLayerDisplayed(ftl::SharedFuture<FenceResult>) override; void setWasClientComposed(const sp<Fence>& fence) override { @@ -918,8 +919,6 @@ protected: friend class TransactionSurfaceFrameTest; virtual void setInitialValuesForClone(const sp<Layer>& clonedFrom); - virtual std::optional<compositionengine::LayerFE::LayerSettings> prepareClientComposition( - compositionengine::LayerFE::ClientCompositionTargetSettings&); virtual void preparePerFrameCompositionState(); virtual void commitTransaction(State& stateToCommit); virtual void onSurfaceFrameCreated(const std::shared_ptr<frametimeline::SurfaceFrame>&) {} @@ -940,7 +939,8 @@ protected: // Modifies the passed in layer settings to clear the contents. If the blackout flag is set, // the settings clears the content with a solid black fill. void prepareClearClientComposition(LayerFE::LayerSettings&, bool blackout) const; - void prepareShadowClientComposition(LayerFE::LayerSettings& caster, const Rect& layerStackRect); + void prepareShadowClientComposition(LayerFE::LayerSettings& caster, + const Rect& layerStackRect) const; void prepareBasicGeometryCompositionState(); void prepareGeometryCompositionState(); diff --git a/services/surfaceflinger/SurfaceFlinger.cpp b/services/surfaceflinger/SurfaceFlinger.cpp index db551d7077..23c0459ce7 100644 --- a/services/surfaceflinger/SurfaceFlinger.cpp +++ b/services/surfaceflinger/SurfaceFlinger.cpp @@ -6570,27 +6570,24 @@ ftl::SharedFuture<FenceResult> SurfaceFlinger::renderScreenImpl( isHdrLayer(layer) ? displayBrightnessNits : sdrWhitePointNits, }; - std::vector<compositionengine::LayerFE::LayerSettings> results = - layer->prepareClientCompositionList(targetSettings); - if (results.size() > 0) { - for (auto& settings : results) { - settings.geometry.positionTransform = - transform.asMatrix4() * settings.geometry.positionTransform; - // There's no need to process blurs when we're executing region sampling, - // we're just trying to understand what we're drawing, and doing so without - // blurs is already a pretty good approximation. - if (regionSampling) { - settings.backgroundBlurRadius = 0; - } - captureResults.capturedHdrLayers |= isHdrLayer(layer); - } + std::optional<compositionengine::LayerFE::LayerSettings> settings = + layer->prepareClientComposition(targetSettings); + if (!settings) { + return; + } - clientCompositionLayers.insert(clientCompositionLayers.end(), - std::make_move_iterator(results.begin()), - std::make_move_iterator(results.end())); - renderedLayers.push_back(layer); + settings->geometry.positionTransform = + transform.asMatrix4() * settings->geometry.positionTransform; + // There's no need to process blurs when we're executing region sampling, + // we're just trying to understand what we're drawing, and doing so without + // blurs is already a pretty good approximation. + if (regionSampling) { + settings->backgroundBlurRadius = 0; } + captureResults.capturedHdrLayers |= isHdrLayer(layer); + clientCompositionLayers.push_back(std::move(*settings)); + renderedLayers.push_back(layer); }); std::vector<renderengine::LayerSettings> clientRenderEngineLayers; |