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

Commit f83ce183 authored by chaviw's avatar chaviw
Browse files

Corrected drawingTransformMatrix 

The transformMatrix needed to be calculated in prepareClientComposition
so storing it in BufferInfo was incorrect. Instead, allow the transformMatrix
to get calculated when prepareClientComposition but avoid using the consumer
for BufferQueueLayer.

Also combined getDrawingTransformMatrix and setFilteringEnabled since
setFilteringEnabled was only used to update the transformMatrix before getting
it. BufferQueueLayers no longer go through the consumer to get the
transformMatrix and just directly calculate the matrix using the GLUtils class.

Fixes: 140759442
Test: atest android.view.cts.ASurfaceControlTest
Change-Id: I09179de275bd905960fb366e45e36fb9874bc0b3
parent 7350bb20

services/surfaceflinger/BufferLayer.cpp

+7 −2
Original line number Diff line number Diff line
@@ -34,6 +34,7 @@ 
#include <cutils/properties.h>

#include <gui/BufferItem.h>

#include <gui/BufferQueue.h>

#include <gui/GLConsumer.h>

#include <gui/LayerDebugInfo.h>

#include <gui/Surface.h>

#include <renderengine/RenderEngine.h>
@@ -187,8 +188,7 @@ std::optional<renderengine::LayerSettings> BufferLayer::prepareClientComposition 


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

        float textureMatrix[16];

        setFilteringEnabled(useFiltering);

        memcpy(textureMatrix, mBufferInfo.mTransformMatrix, sizeof(mBufferInfo.mTransformMatrix));

        getDrawingTransformMatrix(useFiltering, textureMatrix);



        if (getTransformToDisplayInverse()) {

            /*
@@ -719,6 +719,11 @@ sp<GraphicBuffer> BufferLayer::getBuffer() const { 
    return mBufferInfo.mBuffer;

}



void BufferLayer::getDrawingTransformMatrix(bool filteringEnabled, float outMatrix[16]) {

    GLConsumer::computeTransformMatrix(outMatrix, mBufferInfo.mBuffer, mBufferInfo.mCrop,

                                       mBufferInfo.mTransform, filteringEnabled);

}



} // namespace android



#if defined(__gl_h_)

services/surfaceflinger/BufferLayer.h

+5 −4
Original line number Diff line number Diff line
@@ -127,6 +127,10 @@ private: 


    PixelFormat getPixelFormat() const;



    // 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]);



    virtual uint64_t getFrameNumber(nsecs_t expectedPresentTime) const = 0;



    virtual bool getAutoRefresh() const = 0;
@@ -137,8 +141,6 @@ private: 


    virtual bool hasFrameUpdate() const = 0;



    virtual void setFilteringEnabled(bool enabled) = 0;



    virtual status_t bindTextureImage() = 0;

    virtual status_t updateTexImage(bool& recomputeVisibleRegions, nsecs_t latchTime,

                                    nsecs_t expectedPresentTime) = 0;
@@ -151,9 +153,8 @@ protected: 
        nsecs_t mDesiredPresentTime;

        std::shared_ptr<FenceTime> mFenceTime;

        sp<Fence> mFence;

        float mTransformMatrix[16];

        uint32_t mTransform{0};

        ui::Dataspace mDataspace;

        ui::Dataspace mDataspace{ui::Dataspace::UNKNOWN};

        Rect mCrop;

        uint32_t mScaleMode{NATIVE_WINDOW_SCALING_MODE_FREEZE};

        Region mSurfaceDamage;

services/surfaceflinger/BufferQueueLayer.cpp

+0 −12
Original line number Diff line number Diff line
@@ -151,13 +151,6 @@ bool BufferQueueLayer::framePresentTimeIsCurrent(nsecs_t expectedPresentTime) co 
    return mQueueItems[0].mTimestamp <= expectedPresentTime;

}



// NOTE: SurfaceFlinger's definitions of "Current" and "Drawing" do not neatly map to BufferQueue's

// These functions get the fields for the frame that is currently in SurfaceFlinger's Drawing state

// so the functions start with "getDrawing". The data is retrieved from the BufferQueueConsumer's

// current buffer so the consumer functions start with "getCurrent".

//

// This results in the rather confusing functions below.



uint64_t BufferQueueLayer::getFrameNumber(nsecs_t expectedPresentTime) const {

    Mutex::Autolock lock(mQueueItemLock);

    uint64_t frameNumber = mQueueItems[0].mFrameNumber;
@@ -220,10 +213,6 @@ bool BufferQueueLayer::hasFrameUpdate() const { 
    return mQueuedFrames > 0;

}



void BufferQueueLayer::setFilteringEnabled(bool enabled) {

    return mConsumer->setFilteringEnabled(enabled);

}



status_t BufferQueueLayer::bindTextureImage() {

    return mConsumer->bindTextureImage();

}
@@ -532,7 +521,6 @@ void BufferQueueLayer::gatherBufferInfo() { 
    mBufferInfo.mDesiredPresentTime = mConsumer->getTimestamp();

    mBufferInfo.mFenceTime = mConsumer->getCurrentFenceTime();

    mBufferInfo.mFence = mConsumer->getCurrentFence();

    mConsumer->getTransformMatrix(mBufferInfo.mTransformMatrix);

    mBufferInfo.mTransform = mConsumer->getCurrentTransform();

    mBufferInfo.mDataspace = translateDataspace(mConsumer->getCurrentDataSpace());

    mBufferInfo.mCrop = mConsumer->getCurrentCrop();

services/surfaceflinger/BufferQueueLayer.h

+0 −4
Original line number Diff line number Diff line
@@ -46,7 +46,6 @@ public: 


    std::vector<OccupancyTracker::Segment> getOccupancyHistory(bool forceFlush) override;





    // If a buffer was replaced this frame, release the former buffer

    void releasePendingBuffer(nsecs_t dequeueReadyTime) override;
@@ -65,7 +64,6 @@ public: 
    bool framePresentTimeIsCurrent(nsecs_t expectedPresentTime) const override;



private:



    uint64_t getFrameNumber(nsecs_t expectedPresentTime) const override;



    bool getAutoRefresh() const override;
@@ -75,8 +73,6 @@ private: 


    bool hasFrameUpdate() const override;



    void setFilteringEnabled(bool enabled) override;



    status_t bindTextureImage() override;

    status_t updateTexImage(bool& recomputeVisibleRegions, nsecs_t latchTime,

                            nsecs_t expectedPresentTime) override;

services/surfaceflinger/BufferStateLayer.cpp

+3 −11
Original line number Diff line number Diff line
@@ -432,11 +432,6 @@ bool BufferStateLayer::hasFrameUpdate() const { 
    return mCurrentStateModified && (c.buffer != nullptr || c.bgColorLayer != nullptr);

}



void BufferStateLayer::setFilteringEnabled(bool enabled) {

    GLConsumer::computeTransformMatrix(mTransformMatrix.data(), mBufferInfo.mBuffer,

                                       mBufferInfo.mCrop, mBufferInfo.mTransform, enabled);

}



status_t BufferStateLayer::bindTextureImage() {

    const State& s(getDrawingState());

    auto& engine(mFlinger->getRenderEngine());
@@ -545,10 +540,8 @@ void BufferStateLayer::latchPerFrameState( 
        return;

    }



    const State& s(getDrawingState());



    compositionState.buffer = s.buffer;

    compositionState.bufferSlot = mHwcSlotGenerator->getHwcCacheSlot(s.clientCacheId);

    compositionState.buffer = mBufferInfo.mBuffer;

    compositionState.bufferSlot = mBufferInfo.mBufferSlot;

    compositionState.acquireFence = mBufferInfo.mFence;



    mFrameNumber++;
@@ -641,8 +634,6 @@ void BufferStateLayer::gatherBufferInfo() { 
    mBufferInfo.mDesiredPresentTime = s.desiredPresentTime;

    mBufferInfo.mFenceTime = std::make_shared<FenceTime>(s.acquireFence);

    mBufferInfo.mFence = s.acquireFence;

    std::copy(std::begin(mTransformMatrix), std::end(mTransformMatrix),

              mBufferInfo.mTransformMatrix);

    mBufferInfo.mTransform = s.transform;

    mBufferInfo.mDataspace = translateDataspace(s.dataspace);

    mBufferInfo.mCrop = computeCrop(s);
@@ -653,6 +644,7 @@ void BufferStateLayer::gatherBufferInfo() { 
    mBufferInfo.mPixelFormat =

            !mBufferInfo.mBuffer ? PIXEL_FORMAT_NONE : mBufferInfo.mBuffer->format;

    mBufferInfo.mTransformToDisplayInverse = s.transformToDisplayInverse;

    mBufferInfo.mBufferSlot = mHwcSlotGenerator->getHwcCacheSlot(s.clientCacheId);

}



Rect BufferStateLayer::computeCrop(const State& s) {