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

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

Merge changes I20e4aa1a,I00370f05 

* changes:
  SF: Introduce LayerCompositionState
  SF: Introduce OutputLayerCompositionState
parents 7caa828e 0b785d86

services/surfaceflinger/BufferLayer.cpp

+48 −28
Original line number Diff line number Diff line
@@ -24,8 +24,12 @@ 
#include <mutex>



#include <compositionengine/CompositionEngine.h>

#include <compositionengine/Display.h>

#include <compositionengine/Layer.h>

#include <compositionengine/LayerCreationArgs.h>

#include <compositionengine/OutputLayer.h>

#include <compositionengine/impl/LayerCompositionState.h>

#include <compositionengine/impl/OutputLayerCompositionState.h>

#include <cutils/compiler.h>

#include <cutils/native_handle.h>

#include <cutils/properties.h>
@@ -66,11 +70,10 @@ BufferLayer::BufferLayer(const LayerCreationArgs& args) 
BufferLayer::~BufferLayer() {

    mFlinger->deleteTextureAsync(mTextureName);



    if (!getBE().mHwcLayers.empty()) {

    if (destroyAllHwcLayersPlusChildren()) {

        ALOGE("Found stale hardware composer layers when destroying "

              "surface flinger layer %s",

              mName.string());

        destroyAllHwcLayersPlusChildren();

    }



    mFlinger->mTimeStats->onDestroy(getSequence());
@@ -91,7 +94,7 @@ void BufferLayer::useEmptyDamage() { 
bool BufferLayer::isOpaque(const Layer::State& s) const {

    // if we don't have a buffer or sidebandStream yet, we're translucent regardless of the

    // layer's opaque flag.

    if ((getBE().compositionInfo.hwc.sidebandStream == nullptr) && (mActiveBuffer == nullptr)) {

    if ((mSidebandStream == nullptr) && (mActiveBuffer == nullptr)) {

        return false;

    }
@@ -102,7 +105,7 @@ bool BufferLayer::isOpaque(const Layer::State& s) const { 


bool BufferLayer::isVisible() const {

    return !(isHiddenByPolicy()) && getAlpha() > 0.0f &&

            (mActiveBuffer != nullptr || getBE().compositionInfo.hwc.sidebandStream != nullptr);

            (mActiveBuffer != nullptr || mSidebandStream != nullptr);

}



bool BufferLayer::isFixedSize() const {
@@ -171,7 +174,8 @@ bool BufferLayer::prepareClientLayer(const RenderArea& renderArea, const Region& 
        layer.source.buffer.usePremultipliedAlpha = getPremultipledAlpha();

        layer.source.buffer.isY410BT2020 = isHdrY410();

        // TODO: we could be more subtle with isFixedSize()

        const bool useFiltering = needsFiltering() || renderArea.needsFiltering() || isFixedSize();

        const bool useFiltering = needsFiltering(renderArea.getDisplayDevice()) ||

                renderArea.needsFiltering() || isFixedSize();



        // Query the texture matrix given our current filtering mode.

        float textureMatrix[16];
@@ -237,26 +241,31 @@ bool BufferLayer::isHdrY410() const { 
    // pixel format is HDR Y410 masquerading as RGBA_1010102

    return (mCurrentDataSpace == ui::Dataspace::BT2020_ITU_PQ &&

            getDrawingApi() == NATIVE_WINDOW_API_MEDIA &&

            getBE().compositionInfo.mBuffer->getPixelFormat() == HAL_PIXEL_FORMAT_RGBA_1010102);

            mActiveBuffer->getPixelFormat() == HAL_PIXEL_FORMAT_RGBA_1010102);

}



void BufferLayer::setPerFrameData(DisplayId displayId, const ui::Transform& transform,

                                  const Rect& viewport, int32_t supportedPerFrameMetadata) {

    RETURN_IF_NO_HWC_LAYER(displayId);

void BufferLayer::setPerFrameData(const sp<const DisplayDevice>& displayDevice,

                                  const ui::Transform& transform, const Rect& viewport,

                                  int32_t supportedPerFrameMetadata) {

    RETURN_IF_NO_HWC_LAYER(displayDevice);



    // Apply this display's projection's viewport to the visible region

    // before giving it to the HWC HAL.

    Region visible = transform.transform(visibleRegion.intersect(viewport));



    auto& hwcInfo = getBE().mHwcLayers[displayId];

    auto& hwcLayer = hwcInfo.layer;

    const auto outputLayer = findOutputLayerForDisplay(displayDevice);

    LOG_FATAL_IF(!outputLayer || !outputLayer->getState().hwc);



    auto& hwcLayer = (*outputLayer->getState().hwc).hwcLayer;

    auto error = hwcLayer->setVisibleRegion(visible);

    if (error != HWC2::Error::None) {

        ALOGE("[%s] Failed to set visible region: %s (%d)", mName.string(),

              to_string(error).c_str(), static_cast<int32_t>(error));

        visible.dump(LOG_TAG);

    }

    getBE().compositionInfo.hwc.visibleRegion = visible;

    outputLayer->editState().visibleRegion = visible;



    auto& layerCompositionState = getCompositionLayer()->editState().frontEnd;



    error = hwcLayer->setSurfaceDamage(surfaceDamageRegion);

    if (error != HWC2::Error::None) {
@@ -264,29 +273,29 @@ void BufferLayer::setPerFrameData(DisplayId displayId, const ui::Transform& tran 
              to_string(error).c_str(), static_cast<int32_t>(error));

        surfaceDamageRegion.dump(LOG_TAG);

    }

    getBE().compositionInfo.hwc.surfaceDamage = surfaceDamageRegion;

    layerCompositionState.surfaceDamage = surfaceDamageRegion;



    // Sideband layers

    if (getBE().compositionInfo.hwc.sidebandStream.get()) {

        setCompositionType(displayId, HWC2::Composition::Sideband);

    if (layerCompositionState.sidebandStream.get()) {

        setCompositionType(displayDevice, Hwc2::IComposerClient::Composition::SIDEBAND);

        ALOGV("[%s] Requesting Sideband composition", mName.string());

        error = hwcLayer->setSidebandStream(getBE().compositionInfo.hwc.sidebandStream->handle());

        error = hwcLayer->setSidebandStream(layerCompositionState.sidebandStream->handle());

        if (error != HWC2::Error::None) {

            ALOGE("[%s] Failed to set sideband stream %p: %s (%d)", mName.string(),

                  getBE().compositionInfo.hwc.sidebandStream->handle(), to_string(error).c_str(),

                  layerCompositionState.sidebandStream->handle(), to_string(error).c_str(),

                  static_cast<int32_t>(error));

        }

        getBE().compositionInfo.compositionType = HWC2::Composition::Sideband;

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

        return;

    }



    // Device or Cursor layers

    if (mPotentialCursor) {

        ALOGV("[%s] Requesting Cursor composition", mName.string());

        setCompositionType(displayId, HWC2::Composition::Cursor);

        setCompositionType(displayDevice, Hwc2::IComposerClient::Composition::CURSOR);

    } else {

        ALOGV("[%s] Requesting Device composition", mName.string());

        setCompositionType(displayId, HWC2::Composition::Device);

        setCompositionType(displayDevice, Hwc2::IComposerClient::Composition::DEVICE);

    }



    ALOGV("setPerFrameData: dataspace = %d", mCurrentDataSpace);
@@ -308,12 +317,11 @@ void BufferLayer::setPerFrameData(DisplayId displayId, const ui::Transform& tran 
        ALOGE("[%s] Failed to setColorTransform: %s (%d)", mName.string(),

                to_string(error).c_str(), static_cast<int32_t>(error));

    }

    getBE().compositionInfo.hwc.dataspace = mCurrentDataSpace;

    getBE().compositionInfo.hwc.hdrMetadata = getDrawingHdrMetadata();

    getBE().compositionInfo.hwc.supportedPerFrameMetadata = supportedPerFrameMetadata;

    getBE().compositionInfo.hwc.colorTransform = getColorTransform();

    layerCompositionState.dataspace = mCurrentDataSpace;

    layerCompositionState.colorTransform = getColorTransform();

    layerCompositionState.hdrMetadata = metadata;



    setHwcLayerBuffer(displayId);

    setHwcLayerBuffer(displayDevice);

}



bool BufferLayer::onPreComposition(nsecs_t refreshStartTime) {
@@ -605,9 +613,21 @@ bool BufferLayer::getOpacityForFormat(uint32_t format) { 
    return true;

}



bool BufferLayer::needsFiltering() const {

    const auto displayFrame = getBE().compositionInfo.hwc.displayFrame;

    const auto sourceCrop = getBE().compositionInfo.hwc.sourceCrop;

bool BufferLayer::needsFiltering(const sp<const DisplayDevice>& displayDevice) const {

    // If we are not capturing based on the state of a known display device, we

    // only return mNeedsFiltering

    if (displayDevice == nullptr) {

        return mNeedsFiltering;

    }



    const auto outputLayer = findOutputLayerForDisplay(displayDevice);

    if (outputLayer == nullptr) {

        return mNeedsFiltering;

    }



    const auto& compositionState = outputLayer->getState();

    const auto displayFrame = compositionState.displayFrame;

    const auto sourceCrop = compositionState.sourceCrop;

    return mNeedsFiltering || sourceCrop.getHeight() != displayFrame.getHeight() ||

            sourceCrop.getWidth() != displayFrame.getWidth();

}

services/surfaceflinger/BufferLayer.h

+4 −4
Original line number Diff line number Diff line
@@ -80,8 +80,8 @@ public: 


    bool isHdrY410() const override;



    void setPerFrameData(DisplayId displayId, const ui::Transform& transform, const Rect& viewport,

                         int32_t supportedPerFrameMetadata) override;

    void setPerFrameData(const sp<const DisplayDevice>& display, const ui::Transform& transform,

                         const Rect& viewport, int32_t supportedPerFrameMetadata) override;



    bool onPreComposition(nsecs_t refreshStartTime) override;

    bool onPostComposition(const std::optional<DisplayId>& displayId,
@@ -148,7 +148,7 @@ private: 
    virtual status_t updateActiveBuffer() = 0;

    virtual status_t updateFrameNumber(nsecs_t latchTime) = 0;



    virtual void setHwcLayerBuffer(DisplayId displayId) = 0;

    virtual void setHwcLayerBuffer(const sp<const DisplayDevice>& displayDevice) = 0;



protected:

    // Loads the corresponding system property once per process
@@ -177,7 +177,7 @@ protected: 


private:

    // Returns true if this layer requires filtering

    bool needsFiltering() const;

    bool needsFiltering(const sp<const DisplayDevice>& displayDevice) const;



    uint64_t getHeadFrameNumber() const;

services/surfaceflinger/BufferQueueLayer.cpp

+27 −16
Original line number Diff line number Diff line
@@ -14,13 +14,18 @@ 
 * limitations under the License.

 */



#include <compositionengine/Display.h>

#include <compositionengine/Layer.h>

#include <compositionengine/OutputLayer.h>

#include <compositionengine/impl/LayerCompositionState.h>

#include <compositionengine/impl/OutputLayerCompositionState.h>

#include <system/window.h>



#include "BufferQueueLayer.h"

#include "LayerRejecter.h"



#include "TimeStats/TimeStats.h"



#include <system/window.h>



namespace android {



BufferQueueLayer::BufferQueueLayer(const LayerCreationArgs& args) : BufferLayer(args) {}
@@ -195,8 +200,9 @@ bool BufferQueueLayer::latchSidebandStream(bool& recomputeVisibleRegions) { 
    if (mSidebandStreamChanged.compare_exchange_strong(sidebandStreamChanged, false)) {

        // mSidebandStreamChanged was changed to false

        // replicated in LayerBE until FE/BE is ready to be synchronized

        getBE().compositionInfo.hwc.sidebandStream = mConsumer->getSidebandStream();

        if (getBE().compositionInfo.hwc.sidebandStream != nullptr) {

        auto& layerCompositionState = getCompositionLayer()->editState().frontEnd;

        layerCompositionState.sidebandStream = mConsumer->getSidebandStream();

        if (layerCompositionState.sidebandStream != nullptr) {

            setTransactionFlags(eTransactionNeeded);

            mFlinger->setTransactionFlags(eTraversalNeeded);

        }
@@ -325,8 +331,9 @@ status_t BufferQueueLayer::updateTexImage(bool& recomputeVisibleRegions, nsecs_t 
status_t BufferQueueLayer::updateActiveBuffer() {

    // update the active buffer

    mActiveBuffer = mConsumer->getCurrentBuffer(&mActiveBufferSlot, &mActiveBufferFence);

    getBE().compositionInfo.mBuffer = mActiveBuffer;

    getBE().compositionInfo.mBufferSlot = mActiveBufferSlot;

    auto& layerCompositionState = getCompositionLayer()->editState().frontEnd;

    layerCompositionState.buffer = mActiveBuffer;

    layerCompositionState.bufferSlot = mActiveBufferSlot;



    if (mActiveBuffer == nullptr) {

        // this can only happen if the very first buffer was rejected.
@@ -350,24 +357,28 @@ status_t BufferQueueLayer::updateFrameNumber(nsecs_t latchTime) { 
    return NO_ERROR;

}



void BufferQueueLayer::setHwcLayerBuffer(DisplayId displayId) {

    auto& hwcInfo = getBE().mHwcLayers[displayId];

    auto& hwcLayer = hwcInfo.layer;

void BufferQueueLayer::setHwcLayerBuffer(const sp<const DisplayDevice>& display) {

    const auto outputLayer = findOutputLayerForDisplay(display);

    LOG_FATAL_IF(!outputLayer);

    LOG_FATAL_IF(!outputLayer->getState.hwc);

    auto& hwcLayer = (*outputLayer->getState().hwc).hwcLayer;



    uint32_t hwcSlot = 0;

    sp<GraphicBuffer> hwcBuffer;

    hwcInfo.bufferCache.getHwcBuffer(mActiveBufferSlot, mActiveBuffer, &hwcSlot, &hwcBuffer);

    (*outputLayer->editState().hwc)

            .hwcBufferCache.getHwcBuffer(mActiveBufferSlot, mActiveBuffer, &hwcSlot, &hwcBuffer);



    auto acquireFence = mConsumer->getCurrentFence();

    auto error = hwcLayer->setBuffer(hwcSlot, hwcBuffer, acquireFence);

    if (error != HWC2::Error::None) {

        ALOGE("[%s] Failed to set buffer %p: %s (%d)", mName.string(),

              getBE().compositionInfo.mBuffer->handle, to_string(error).c_str(),

              static_cast<int32_t>(error));

        ALOGE("[%s] Failed to set buffer %p: %s (%d)", mName.string(), mActiveBuffer->handle,

              to_string(error).c_str(), static_cast<int32_t>(error));

    }

    getBE().compositionInfo.mBufferSlot = mActiveBufferSlot;

    getBE().compositionInfo.mBuffer = mActiveBuffer;

    getBE().compositionInfo.hwc.fence = acquireFence;



    auto& layerCompositionState = getCompositionLayer()->editState().frontEnd;

    layerCompositionState.bufferSlot = mActiveBufferSlot;

    layerCompositionState.buffer = mActiveBuffer;

    layerCompositionState.acquireFence = acquireFence;

}



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

services/surfaceflinger/BufferQueueLayer.h

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

    status_t updateFrameNumber(nsecs_t latchTime) override;



    void setHwcLayerBuffer(DisplayId displayId) override;

    void setHwcLayerBuffer(const sp<const DisplayDevice>& displayDevice) override;



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

    // Interface implementation for BufferLayerConsumer::ContentsChangedListener

services/surfaceflinger/BufferStateLayer.cpp

+20 −13
Original line number Diff line number Diff line
@@ -19,15 +19,19 @@ 
#define LOG_TAG "BufferStateLayer"

#define ATRACE_TAG ATRACE_TAG_GRAPHICS



#include "BufferStateLayer.h"

#include "ColorLayer.h"



#include "TimeStats/TimeStats.h"

#include <limits>



#include <compositionengine/Display.h>

#include <compositionengine/Layer.h>

#include <compositionengine/OutputLayer.h>

#include <compositionengine/impl/LayerCompositionState.h>

#include <compositionengine/impl/OutputLayerCompositionState.h>

#include <private/gui/SyncFeatures.h>

#include <renderengine/Image.h>



#include <limits>

#include "BufferStateLayer.h"

#include "ColorLayer.h"

#include "TimeStats/TimeStats.h"



namespace android {
@@ -438,9 +442,10 @@ bool BufferStateLayer::latchSidebandStream(bool& recomputeVisibleRegions) { 
    if (mSidebandStreamChanged.exchange(false)) {

        const State& s(getDrawingState());

        // mSidebandStreamChanged was true

        // replicated in LayerBE until FE/BE is ready to be synchronized

        getBE().compositionInfo.hwc.sidebandStream = s.sidebandStream;

        if (getBE().compositionInfo.hwc.sidebandStream != nullptr) {

        LOG_ALWAYS_FATAL_IF(!getCompositionLayer());

        mSidebandStream = s.sidebandStream;

        getCompositionLayer()->editState().frontEnd.sidebandStream = mSidebandStream;

        if (mSidebandStream != nullptr) {

            setTransactionFlags(eTransactionNeeded);

            mFlinger->setTransactionFlags(eTraversalNeeded);

        }
@@ -594,8 +599,9 @@ status_t BufferStateLayer::updateActiveBuffer() { 


    mActiveBuffer = s.buffer;

    mActiveBufferFence = s.acquireFence;

    getBE().compositionInfo.mBuffer = mActiveBuffer;

    getBE().compositionInfo.mBufferSlot = 0;

    auto& layerCompositionState = getCompositionLayer()->editState().frontEnd;

    layerCompositionState.buffer = mActiveBuffer;

    layerCompositionState.bufferSlot = 0;



    return NO_ERROR;

}
@@ -611,9 +617,10 @@ status_t BufferStateLayer::updateFrameNumber(nsecs_t /*latchTime*/) { 
    return NO_ERROR;

}



void BufferStateLayer::setHwcLayerBuffer(DisplayId displayId) {

    auto& hwcInfo = getBE().mHwcLayers[displayId];

    auto& hwcLayer = hwcInfo.layer;

void BufferStateLayer::setHwcLayerBuffer(const sp<const DisplayDevice>& display) {

    const auto outputLayer = findOutputLayerForDisplay(display);

    LOG_FATAL_IF(!outputLayer || !outputLayer->getState().hwc);

    auto& hwcLayer = (*outputLayer->getState().hwc).hwcLayer;



    const State& s(getDrawingState());