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

Commit da0f906c authored by TreeHugger Robot's avatar TreeHugger Robot Committed by Android (Google) Code Review
Browse files

Merge "CE: Remove compositionengine::Layer"

parents 3729f2c6 de196651

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>
@@ -223,9 +222,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);

        }
@@ -359,8 +358,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.
@@ -380,18 +379,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>
@@ -464,9 +463,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);
@@ -573,8 +571,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;

}
@@ -590,16 +587,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) {