Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit de196651 authored by Lloyd Pique's avatar Lloyd Pique
Browse files

CE: Remove compositionengine::Layer 

This was a mostly straightforward refactor that restructures the
interface between SurfaceFlinger and CompositionEngine.

1) Instead of each SurfaceFlinger Layer creating and owning a
   compositionengine::Layer, each Layer instead creates and owns a
   compositionengine::LayerFECompositionState structure. Containing this
   state structure was the only real purpose for
   compositionengine::Layer.

2) Use the compositionengine::LayerFE interface in CompositionEngine in
   place of compositionengine::Layer. This includes passing a
   std::vector for the layers when SurfaceFlinger calls into
   CompositionEngine.

3) Alters the LayerFE interface to add the ability to get the state, as
   well as changing the existing "latchCompositionState" calls taking a
   state reference as the first argument into "prepareCompositionState"
   calls that do not need it, as the target of the call owns the state.

4) Alters the SurfaceFlinger Layer implementations to match the LayerFE
   interface changes.

Test: atest libcompositionengine_test libsurfaceflinger_unittest
Test: atest CtsColorModeTestCases
Test: atest CtsDisplayTestCases
Test: atest CtsGraphicsTestCases
Test: atest CtsUiRenderingTestCases
Test: atest CtsViewTestCases
Test: atest android.media.cts.EncodeVirtualDisplayWithCompositionTest
Test: go/wm-smoke
Bug: 144117494
Change-Id: Id45df7c9cc389c8fd834ba379bc0d6360a984dac
parent 77707d96

services/surfaceflinger/BufferLayer.cpp

+21 −16
Original line number Diff line number Diff line
@@ -26,8 +26,6 @@ 
#include "BufferLayer.h"



#include <compositionengine/CompositionEngine.h>

#include <compositionengine/Layer.h>

#include <compositionengine/LayerCreationArgs.h>

#include <compositionengine/LayerFECompositionState.h>

#include <compositionengine/OutputLayer.h>

#include <compositionengine/impl/OutputLayerCompositionState.h>
@@ -66,8 +64,7 @@ static constexpr float defaultMaxContentLuminance = 1000.0; 
BufferLayer::BufferLayer(const LayerCreationArgs& args)

      : Layer(args),

        mTextureName(args.textureName),

        mCompositionLayer{mFlinger->getCompositionEngine().createLayer(

                compositionengine::LayerCreationArgs{this})} {

        mCompositionState{mFlinger->getCompositionEngine().createLayerFECompositionState()} {

    ALOGV("Creating Layer %s", getDebugName());



    mPremultipliedAlpha = !(args.flags & ISurfaceComposerClient::eNonPremultiplied);
@@ -184,7 +181,7 @@ std::optional<compositionengine::LayerFE::LayerSettings> BufferLayer::prepareCli 
    bool blackOutLayer = (isProtected() && !targetSettings.supportsProtectedContent) ||

            (isSecure() && !targetSettings.isSecure);

    const State& s(getDrawingState());

    LayerFE::LayerSettings& layer = *result;

    compositionengine::LayerFE::LayerSettings& layer = *result;

    if (!blackOutLayer) {

        layer.source.buffer.buffer = mBufferInfo.mBuffer;

        layer.source.buffer.isOpaque = isOpaque(s);
@@ -282,17 +279,29 @@ bool BufferLayer::isHdrY410() const { 
            mBufferInfo.mBuffer->getPixelFormat() == HAL_PIXEL_FORMAT_RGBA_1010102);

}



void BufferLayer::latchPerFrameState(

        compositionengine::LayerFECompositionState& compositionState) const {

    Layer::latchPerFrameState(compositionState);

sp<compositionengine::LayerFE> BufferLayer::getCompositionEngineLayerFE() const {

    return asLayerFE();

}



compositionengine::LayerFECompositionState* BufferLayer::editCompositionState() {

    return mCompositionState.get();

}



const compositionengine::LayerFECompositionState* BufferLayer::getCompositionState() const {

    return mCompositionState.get();

}



void BufferLayer::preparePerFrameCompositionState() {

    Layer::preparePerFrameCompositionState();



    // Sideband layers

    if (compositionState.sidebandStream.get()) {

        compositionState.compositionType = Hwc2::IComposerClient::Composition::SIDEBAND;

    auto* compositionState = editCompositionState();

    if (compositionState->sidebandStream.get()) {

        compositionState->compositionType = Hwc2::IComposerClient::Composition::SIDEBAND;

    } else {

        // Normal buffer layers

        compositionState.hdrMetadata = mBufferInfo.mHdrMetadata;

        compositionState.compositionType = mPotentialCursor

        compositionState->hdrMetadata = mBufferInfo.mHdrMetadata;

        compositionState->compositionType = mPotentialCursor

                ? Hwc2::IComposerClient::Composition::CURSOR

                : Hwc2::IComposerClient::Composition::DEVICE;

    }
@@ -641,10 +650,6 @@ Rect BufferLayer::getBufferSize(const State& s) const { 
    return Rect(bufWidth, bufHeight);

}



std::shared_ptr<compositionengine::Layer> BufferLayer::getCompositionLayer() const {

    return mCompositionLayer;

}



FloatRect BufferLayer::computeSourceBounds(const FloatRect& parentBounds) const {

    const State& s(getDrawingState());

services/surfaceflinger/BufferLayer.h

+5 −3
Original line number Diff line number Diff line
@@ -54,7 +54,8 @@ public: 
    // Overriden from Layer

    // -----------------------------------------------------------------------

public:

    std::shared_ptr<compositionengine::Layer> getCompositionLayer() const override;

    sp<compositionengine::LayerFE> getCompositionEngineLayerFE() const override;

    compositionengine::LayerFECompositionState* editCompositionState() override;



    // If we have received a new buffer this frame, we will pass its surface

    // damage down to hardware composer. Otherwise, we must send a region with
@@ -175,8 +176,9 @@ protected: 
    /*

     * compositionengine::LayerFE overrides

     */

    const compositionengine::LayerFECompositionState* getCompositionState() const override;

    bool onPreComposition(nsecs_t) override;

    void latchPerFrameState(compositionengine::LayerFECompositionState&) const override;

    void preparePerFrameCompositionState() override;

    std::optional<compositionengine::LayerFE::LayerSettings> prepareClientComposition(

            compositionengine::LayerFE::ClientCompositionTargetSettings&) override;
@@ -210,7 +212,7 @@ private: 
    // and its parent layer is not bounded

    Rect getBufferSize(const State& s) const override;



    std::shared_ptr<compositionengine::Layer> mCompositionLayer;

    std::unique_ptr<compositionengine::LayerFECompositionState> mCompositionState;



    FloatRect computeSourceBounds(const FloatRect& parentBounds) const override;

};

services/surfaceflinger/BufferQueueLayer.cpp

+13 −13
Original line number Diff line number Diff line
@@ -23,7 +23,6 @@ 
#define ATRACE_TAG ATRACE_TAG_GRAPHICS

#include "BufferQueueLayer.h"



#include <compositionengine/Layer.h>

#include <compositionengine/LayerFECompositionState.h>

#include <gui/BufferQueueConsumer.h>

#include <system/window.h>
@@ -215,9 +214,9 @@ bool BufferQueueLayer::latchSidebandStream(bool& recomputeVisibleRegions) { 
    if (mSidebandStreamChanged.compare_exchange_strong(sidebandStreamChanged, false)) {

        // mSidebandStreamChanged was changed to false

        mSidebandStream = mConsumer->getSidebandStream();

        auto& layerCompositionState = getCompositionLayer()->editFEState();

        layerCompositionState.sidebandStream = mSidebandStream;

        if (layerCompositionState.sidebandStream != nullptr) {

        auto* layerCompositionState = editCompositionState();

        layerCompositionState->sidebandStream = mSidebandStream;

        if (layerCompositionState->sidebandStream != nullptr) {

            setTransactionFlags(eTransactionNeeded);

            mFlinger->setTransactionFlags(eTraversalNeeded);

        }
@@ -351,8 +350,8 @@ status_t BufferQueueLayer::updateActiveBuffer() { 
    mPreviousBufferId = getCurrentBufferId();

    mBufferInfo.mBuffer =

            mConsumer->getCurrentBuffer(&mBufferInfo.mBufferSlot, &mBufferInfo.mFence);

    auto& layerCompositionState = getCompositionLayer()->editFEState();

    layerCompositionState.buffer = mBufferInfo.mBuffer;

    auto* layerCompositionState = editCompositionState();

    layerCompositionState->buffer = mBufferInfo.mBuffer;



    if (mBufferInfo.mBuffer == nullptr) {

        // this can only happen if the very first buffer was rejected.
@@ -372,18 +371,19 @@ status_t BufferQueueLayer::updateFrameNumber(nsecs_t latchTime) { 
    return NO_ERROR;

}



void BufferQueueLayer::latchPerFrameState(

        compositionengine::LayerFECompositionState& compositionState) const {

    BufferLayer::latchPerFrameState(compositionState);

    if (compositionState.compositionType == Hwc2::IComposerClient::Composition::SIDEBAND) {

void BufferQueueLayer::preparePerFrameCompositionState() {

    BufferLayer::preparePerFrameCompositionState();



    auto* compositionState = editCompositionState();

    if (compositionState->compositionType == Hwc2::IComposerClient::Composition::SIDEBAND) {

        return;

    }



    compositionState.buffer = mBufferInfo.mBuffer;

    compositionState.bufferSlot = (mBufferInfo.mBufferSlot == BufferQueue::INVALID_BUFFER_SLOT)

    compositionState->buffer = mBufferInfo.mBuffer;

    compositionState->bufferSlot = (mBufferInfo.mBufferSlot == BufferQueue::INVALID_BUFFER_SLOT)

            ? 0

            : mBufferInfo.mBufferSlot;

    compositionState.acquireFence = mBufferInfo.mFence;

    compositionState->acquireFence = mBufferInfo.mFence;

}



// -----------------------------------------------------------------------

services/surfaceflinger/BufferQueueLayer.h

+1 −1
Original line number Diff line number Diff line
@@ -85,7 +85,7 @@ private: 
    status_t updateActiveBuffer() override;

    status_t updateFrameNumber(nsecs_t latchTime) override;



    void latchPerFrameState(compositionengine::LayerFECompositionState&) const override;

    void preparePerFrameCompositionState() override;

    sp<Layer> createClone() override;



    void onFrameAvailable(const BufferItem& item);

services/surfaceflinger/BufferStateLayer.cpp

+10 −12
Original line number Diff line number Diff line
@@ -27,7 +27,6 @@ 


#include <limits>



#include <compositionengine/Layer.h>

#include <compositionengine/LayerFECompositionState.h>

#include <gui/BufferQueue.h>

#include <private/gui/SyncFeatures.h>
@@ -430,9 +429,8 @@ bool BufferStateLayer::latchSidebandStream(bool& recomputeVisibleRegions) { 
    if (mSidebandStreamChanged.exchange(false)) {

        const State& s(getDrawingState());

        // mSidebandStreamChanged was true

        LOG_ALWAYS_FATAL_IF(!getCompositionLayer());

        mSidebandStream = s.sidebandStream;

        getCompositionLayer()->editFEState().sidebandStream = mSidebandStream;

        editCompositionState()->sidebandStream = mSidebandStream;

        if (mSidebandStream != nullptr) {

            setTransactionFlags(eTransactionNeeded);

            mFlinger->setTransactionFlags(eTraversalNeeded);
@@ -539,8 +537,7 @@ status_t BufferStateLayer::updateActiveBuffer() { 
    mPreviousBufferId = getCurrentBufferId();

    mBufferInfo.mBuffer = s.buffer;

    mBufferInfo.mFence = s.acquireFence;

    auto& layerCompositionState = getCompositionLayer()->editFEState();

    layerCompositionState.buffer = mBufferInfo.mBuffer;

    editCompositionState()->buffer = mBufferInfo.mBuffer;



    return NO_ERROR;

}
@@ -552,16 +549,17 @@ status_t BufferStateLayer::updateFrameNumber(nsecs_t /*latchTime*/) { 
    return NO_ERROR;

}



void BufferStateLayer::latchPerFrameState(

        compositionengine::LayerFECompositionState& compositionState) const {

    BufferLayer::latchPerFrameState(compositionState);

    if (compositionState.compositionType == Hwc2::IComposerClient::Composition::SIDEBAND) {

void BufferStateLayer::preparePerFrameCompositionState() {

    BufferLayer::preparePerFrameCompositionState();



    auto* compositionState = editCompositionState();

    if (compositionState->compositionType == Hwc2::IComposerClient::Composition::SIDEBAND) {

        return;

    }



    compositionState.buffer = mBufferInfo.mBuffer;

    compositionState.bufferSlot = mBufferInfo.mBufferSlot;

    compositionState.acquireFence = mBufferInfo.mFence;

    compositionState->buffer = mBufferInfo.mBuffer;

    compositionState->bufferSlot = mBufferInfo.mBufferSlot;

    compositionState->acquireFence = mBufferInfo.mFence;

}



void BufferStateLayer::HwcSlotGenerator::bufferErased(const client_cache_t& clientCacheId) {