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

Commit 5b3b9146 authored by Robert Carr's avatar Robert Carr Committed by Rob Carr
Browse files

SurfaceFlinger: Prepare to remove BufferQueueLayer 

To prepare to remove BufferQueueLayer we port over the public Java API
(getSurface) and a few remaining clients (largely tests), by returning
a BBQ from getSurface.

Bug: 185492007
Test: Existing tests pass
Change-Id: I0ec0d765659783e1bdbb3f243ad60e3355cfdf4f
parent 0e4c8a46

libs/gui/SurfaceComposerClient.cpp

+6 −3
Original line number Diff line number Diff line
@@ -896,7 +896,7 @@ void SurfaceComposerClient::Transaction::setEarlyWakeupEnd() { 
}



layer_state_t* SurfaceComposerClient::Transaction::getLayerState(const sp<SurfaceControl>& sc) {

    auto handle = sc->getHandle();

    auto handle = sc->getLayerStateHandle();



    if (mComposerStates.count(handle) == 0) {

        // we don't have it, add an initialized layer_state to our list
@@ -1147,8 +1147,11 @@ SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::reparent 
        mStatus = BAD_INDEX;

        return *this;

    }

    if (SurfaceControl::isSameSurface(sc, newParent)) {

        return *this;

    }

    s->what |= layer_state_t::eReparent;

    s->parentSurfaceControlForChild = newParent;

    s->parentSurfaceControlForChild = newParent ? newParent->getParentingLayer() : nullptr;



    registerSurfaceControlForCallback(sc);

    return *this;
@@ -1793,7 +1796,7 @@ status_t SurfaceComposerClient::createSurfaceChecked(const String8& name, uint32 
        }

        ALOGE_IF(err, "SurfaceComposerClient::createSurface error %s", strerror(-err));

        if (err == NO_ERROR) {

            *outSurface = new SurfaceControl(this, handle, gbp, id, transformHint);

            *outSurface = new SurfaceControl(this, handle, gbp, id, w, h, format, transformHint);

        }

    }

    return err;

libs/gui/SurfaceControl.cpp

+65 −18
Original line number Diff line number Diff line
@@ -35,6 +35,7 @@ 
#include <ui/StaticDisplayInfo.h>



#include <gui/BufferQueueCore.h>

#include <gui/BLASTBufferQueue.h>

#include <gui/ISurfaceComposer.h>

#include <gui/Surface.h>

#include <gui/SurfaceComposerClient.h>
@@ -49,12 +50,17 @@ namespace android { 


SurfaceControl::SurfaceControl(const sp<SurfaceComposerClient>& client, const sp<IBinder>& handle,

                               const sp<IGraphicBufferProducer>& gbp, int32_t layerId,

                               uint32_t transform)

                               uint32_t w, uint32_t h, PixelFormat format, uint32_t transform,

                               uint32_t flags)

      : mClient(client),

        mHandle(handle),

        mGraphicBufferProducer(gbp),

        mLayerId(layerId),

        mTransformHint(transform) {}

        mTransformHint(transform),

        mWidth(w),

        mHeight(h),

        mFormat(format),

        mCreateFlags(flags) {}



SurfaceControl::SurfaceControl(const sp<SurfaceControl>& other) {

    mClient = other->mClient;
@@ -62,6 +68,9 @@ SurfaceControl::SurfaceControl(const sp<SurfaceControl>& other) { 
    mGraphicBufferProducer = other->mGraphicBufferProducer;

    mTransformHint = other->mTransformHint;

    mLayerId = other->mLayerId;

    mWidth = other->mWidth;

    mHeight = other->mHeight;

    mCreateFlags = other->mCreateFlags;

}



SurfaceControl::~SurfaceControl()
@@ -70,13 +79,13 @@ SurfaceControl::~SurfaceControl() 
    // happen without delay, since these resources are quite heavy.

    mClient.clear();

    mHandle.clear();

    mGraphicBufferProducer.clear();

    mBbq.clear();

    IPCThreadState::self()->flushCommands();

}



void SurfaceControl::disconnect() {

    if (mGraphicBufferProducer != nullptr) {

        mGraphicBufferProducer->disconnect(

    if (getIGraphicBufferProducer() != nullptr) {

        getIGraphicBufferProducer()->disconnect(

                BufferQueueCore::CURRENTLY_CONNECTED_API);

    }

}
@@ -118,21 +127,28 @@ status_t SurfaceControl::writeSurfaceToParcel( 
{

    sp<IGraphicBufferProducer> bp;

    if (control != nullptr) {

        bp = control->mGraphicBufferProducer;

        bp = control->getIGraphicBufferProducer();

    }

    return parcel->writeStrongBinder(IInterface::asBinder(bp));

}



sp<Surface> SurfaceControl::generateSurfaceLocked() const

sp<Surface> SurfaceControl::generateSurfaceLocked()

{

    uint32_t ignore;

    auto flags = mCreateFlags & (ISurfaceComposerClient::eCursorWindow |

                                 ISurfaceComposerClient::eOpaque);

    mBbqChild = mClient->createSurface(String8("bbq-wrapper"), 0, 0, mFormat,

                                       flags, mHandle, {}, &ignore);

    mBbq = new BLASTBufferQueue("bbq-adapter", mBbqChild, mWidth, mHeight, mFormat);



    // This surface is always consumed by SurfaceFlinger, so the

    // producerControlledByApp value doesn't matter; using false.

    mSurfaceData = new Surface(mGraphicBufferProducer, false);

    mSurfaceData = mBbq->getSurface(true);



    return mSurfaceData;

}



sp<Surface> SurfaceControl::getSurface() const

sp<Surface> SurfaceControl::getSurface()

{

    Mutex::Autolock _l(mLock);

    if (mSurfaceData == nullptr) {
@@ -141,25 +157,42 @@ sp<Surface> SurfaceControl::getSurface() const 
    return mSurfaceData;

}



sp<Surface> SurfaceControl::createSurface() const

sp<Surface> SurfaceControl::createSurface()

{

    return getSurface();

}



void SurfaceControl::updateDefaultBufferSize(uint32_t width, uint32_t height) {

    Mutex::Autolock _l(mLock);

    return generateSurfaceLocked();

    mWidth = width; mHeight = height;

    if (mBbq) {

      mBbq->update(this, width, height, mFormat);

    }



sp<IBinder> SurfaceControl::getHandle() const

}



sp<IBinder> SurfaceControl::getLayerStateHandle() const

{

    return mHandle;

}



sp<IBinder> SurfaceControl::getHandle() const {

    if (mBbqChild != nullptr) {

        return mBbqChild->getHandle();

    }

    return getLayerStateHandle();

}



int32_t SurfaceControl::getLayerId() const {

    return mLayerId;

}



sp<IGraphicBufferProducer> SurfaceControl::getIGraphicBufferProducer() const

sp<IGraphicBufferProducer> SurfaceControl::getIGraphicBufferProducer()

{

    getSurface();

    Mutex::Autolock _l(mLock);

    return mGraphicBufferProducer;



    return mBbq->getIGraphicBufferProducer();

}



sp<SurfaceComposerClient> SurfaceControl::getClient() const
@@ -180,9 +213,11 @@ void SurfaceControl::setTransformHint(uint32_t hint) { 
status_t SurfaceControl::writeToParcel(Parcel& parcel) {

    SAFE_PARCEL(parcel.writeStrongBinder, ISurfaceComposerClient::asBinder(mClient->getClient()));

    SAFE_PARCEL(parcel.writeStrongBinder, mHandle);

    SAFE_PARCEL(parcel.writeStrongBinder, IGraphicBufferProducer::asBinder(mGraphicBufferProducer));

    SAFE_PARCEL(parcel.writeInt32, mLayerId);

    SAFE_PARCEL(parcel.writeUint32, mTransformHint);

    SAFE_PARCEL(parcel.writeUint32, mWidth);

    SAFE_PARCEL(parcel.writeUint32, mHeight);

    SAFE_PARCEL(parcel.writeUint32, mFormat);



    return NO_ERROR;

}
@@ -191,21 +226,26 @@ status_t SurfaceControl::readFromParcel(const Parcel& parcel, 
                                        sp<SurfaceControl>* outSurfaceControl) {

    sp<IBinder> client;

    sp<IBinder> handle;

    sp<IBinder> gbp;

    int32_t layerId;

    uint32_t transformHint;

    uint32_t width;

    uint32_t height;

    uint32_t format;



    SAFE_PARCEL(parcel.readStrongBinder, &client);

    SAFE_PARCEL(parcel.readStrongBinder, &handle);

    SAFE_PARCEL(parcel.readNullableStrongBinder, &gbp);

    SAFE_PARCEL(parcel.readInt32, &layerId);

    SAFE_PARCEL(parcel.readUint32, &transformHint);

    SAFE_PARCEL(parcel.readUint32, &width);

    SAFE_PARCEL(parcel.readUint32, &height);

    SAFE_PARCEL(parcel.readUint32, &format);



    // We aren't the original owner of the surface.

    *outSurfaceControl =

            new SurfaceControl(new SurfaceComposerClient(

                                       interface_cast<ISurfaceComposerClient>(client)),

                               handle.get(), interface_cast<IGraphicBufferProducer>(gbp), layerId,

                               handle.get(), nullptr, layerId,

                               width, height, format,

                               transformHint);



    return NO_ERROR;
@@ -233,5 +273,12 @@ status_t SurfaceControl::writeNullableToParcel(Parcel& parcel, 
    return NO_ERROR;

}



sp<SurfaceControl> SurfaceControl::getParentingLayer() {

    if (mBbqChild != nullptr) {

        return mBbqChild;

    }

    return this;

}



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

}; // namespace android

libs/gui/include/gui/SurfaceControl.h

+17 −5
Original line number Diff line number Diff line
@@ -37,6 +37,7 @@ namespace android { 
class IGraphicBufferProducer;

class Surface;

class SurfaceComposerClient;

class BLASTBufferQueue;



// ---------------------------------------------------------------------------
@@ -70,12 +71,13 @@ public: 
    static status_t writeSurfaceToParcel(

            const sp<SurfaceControl>& control, Parcel* parcel);



    sp<Surface> getSurface() const;

    sp<Surface> createSurface() const;

    sp<Surface> getSurface();

    sp<Surface> createSurface();

    sp<IBinder> getHandle() const;

    sp<IBinder> getLayerStateHandle() const;

    int32_t getLayerId() const;



    sp<IGraphicBufferProducer> getIGraphicBufferProducer() const;

    sp<IGraphicBufferProducer> getIGraphicBufferProducer();



    status_t clearLayerFrameStats() const;

    status_t getLayerFrameStats(FrameStats* outStats) const;
@@ -85,12 +87,16 @@ public: 
    uint32_t getTransformHint() const;



    void setTransformHint(uint32_t hint);

    void updateDefaultBufferSize(uint32_t width, uint32_t height);



    explicit SurfaceControl(const sp<SurfaceControl>& other);



    SurfaceControl(const sp<SurfaceComposerClient>& client, const sp<IBinder>& handle,

                   const sp<IGraphicBufferProducer>& gbp, int32_t layerId,

                   uint32_t transformHint = 0);

                   uint32_t width = 0, uint32_t height = 0, PixelFormat format = 0,

                   uint32_t transformHint = 0, uint32_t flags = 0);



    sp<SurfaceControl> getParentingLayer();



private:

    // can't be copied
@@ -102,7 +108,7 @@ private: 


    ~SurfaceControl();



    sp<Surface> generateSurfaceLocked() const;

    sp<Surface> generateSurfaceLocked();

    status_t validate() const;



    sp<SurfaceComposerClient>   mClient;
@@ -110,8 +116,14 @@ private: 
    sp<IGraphicBufferProducer>  mGraphicBufferProducer;

    mutable Mutex               mLock;

    mutable sp<Surface>         mSurfaceData;

    mutable sp<BLASTBufferQueue> mBbq;

    mutable sp<SurfaceControl> mBbqChild;

    int32_t mLayerId;

    uint32_t mTransformHint;

    uint32_t mWidth;

    uint32_t mHeight;

    PixelFormat mFormat;

    uint32_t mCreateFlags;

};



}; // namespace android

libs/gui/tests/BLASTBufferQueue_test.cpp

+0 −118
Original line number Diff line number Diff line
@@ -836,26 +836,6 @@ public: 
        if (postedTime) *postedTime = systemTime();

        igbProducer->queueBuffer(slot, input, qbOutput);

    }



    void createBufferQueueProducer(sp<IGraphicBufferProducer>* bqIgbp) {

        mBufferQueueSurfaceControl =

                mClient->createSurface(String8("BqSurface"), 0, 0, PIXEL_FORMAT_RGBA_8888,

                                       ISurfaceComposerClient::eFXSurfaceBufferQueue);

        ASSERT_NE(nullptr, mBufferQueueSurfaceControl.get());

        Transaction()

                .setLayerStack(mBufferQueueSurfaceControl, 0)

                .show(mBufferQueueSurfaceControl)

                .setDataspace(mBufferQueueSurfaceControl, ui::Dataspace::V0_SRGB)

                .setSize(mBufferQueueSurfaceControl, mDisplayWidth, mDisplayHeight)

                .setLayer(mBufferQueueSurfaceControl, std::numeric_limits<int32_t>::max())

                .apply();



        sp<Surface> bqSurface = mBufferQueueSurfaceControl->getSurface();

        ASSERT_NE(nullptr, bqSurface.get());



        *bqIgbp = bqSurface->getIGraphicBufferProducer();

        setUpProducer(*bqIgbp);

    }

    sp<SurfaceControl> mBufferQueueSurfaceControl;

};
@@ -911,55 +891,6 @@ TEST_F(BLASTFrameEventHistoryTest, FrameEventHistory_Basic) { 
    adapter.waitForCallbacks();

}



// Runs the same Frame Event History test

TEST_F(BLASTFrameEventHistoryTest, FrameEventHistory_Basic_BufferQueue) {

    sp<IGraphicBufferProducer> bqIgbp;

    createBufferQueueProducer(&bqIgbp);



    ProducerFrameEventHistory history;

    IGraphicBufferProducer::QueueBufferOutput qbOutput;

    nsecs_t requestedPresentTimeA = 0;

    nsecs_t postedTimeA = 0;

    setUpAndQueueBuffer(bqIgbp, &requestedPresentTimeA, &postedTimeA, &qbOutput, true);

    history.applyDelta(qbOutput.frameTimestamps);



    FrameEvents* events = nullptr;

    events = history.getFrame(1);

    ASSERT_NE(nullptr, events);

    ASSERT_EQ(1, events->frameNumber);

    ASSERT_EQ(requestedPresentTimeA, events->requestedPresentTime);

    ASSERT_GE(events->postedTime, postedTimeA);



    // wait for buffer to be presented

    std::this_thread::sleep_for(200ms);



    nsecs_t requestedPresentTimeB = 0;

    nsecs_t postedTimeB = 0;

    setUpAndQueueBuffer(bqIgbp, &requestedPresentTimeB, &postedTimeB, &qbOutput, true);

    history.applyDelta(qbOutput.frameTimestamps);

    events = history.getFrame(1);

    ASSERT_NE(nullptr, events);



    // frame number, requestedPresentTime, and postTime should not have changed

    ASSERT_EQ(1, events->frameNumber);

    ASSERT_EQ(requestedPresentTimeA, events->requestedPresentTime);

    ASSERT_GE(events->postedTime, postedTimeA);



    ASSERT_GE(events->latchTime, postedTimeA);

    ASSERT_FALSE(events->hasDequeueReadyInfo());



    ASSERT_NE(nullptr, events->gpuCompositionDoneFence);

    ASSERT_NE(nullptr, events->displayPresentFence);

    ASSERT_NE(nullptr, events->releaseFence);



    // we should also have gotten the initial values for the next frame

    events = history.getFrame(2);

    ASSERT_NE(nullptr, events);

    ASSERT_EQ(2, events->frameNumber);

    ASSERT_EQ(requestedPresentTimeB, events->requestedPresentTime);

    ASSERT_GE(events->postedTime, postedTimeB);

}



TEST_F(BLASTFrameEventHistoryTest, FrameEventHistory_DroppedFrame) {

    BLASTBufferQueueHelper adapter(mSurfaceControl, mDisplayWidth, mDisplayHeight);

    sp<IGraphicBufferProducer> igbProducer;
@@ -1010,53 +941,4 @@ TEST_F(BLASTFrameEventHistoryTest, FrameEventHistory_DroppedFrame) { 
    ASSERT_GE(events->postedTime, postedTimeB);

}



TEST_F(BLASTFrameEventHistoryTest, FrameEventHistory_DroppedFrame_BufferQueue) {

    sp<IGraphicBufferProducer> bqIgbp;

    createBufferQueueProducer(&bqIgbp);



    ProducerFrameEventHistory history;

    IGraphicBufferProducer::QueueBufferOutput qbOutput;

    nsecs_t requestedPresentTimeA = 0;

    nsecs_t postedTimeA = 0;

    nsecs_t presentTimeDelay = std::chrono::nanoseconds(500ms).count();

    setUpAndQueueBuffer(bqIgbp, &requestedPresentTimeA, &postedTimeA, &qbOutput, true,

                        presentTimeDelay);

    history.applyDelta(qbOutput.frameTimestamps);



    FrameEvents* events = nullptr;

    events = history.getFrame(1);

    ASSERT_NE(nullptr, events);

    ASSERT_EQ(1, events->frameNumber);

    ASSERT_EQ(requestedPresentTimeA, events->requestedPresentTime);

    ASSERT_GE(events->postedTime, postedTimeA);



    // queue another buffer so the first can be dropped

    nsecs_t requestedPresentTimeB = 0;

    nsecs_t postedTimeB = 0;

    setUpAndQueueBuffer(bqIgbp, &requestedPresentTimeB, &postedTimeB, &qbOutput, true);

    history.applyDelta(qbOutput.frameTimestamps);

    events = history.getFrame(1);

    ASSERT_NE(nullptr, events);



    // frame number, requestedPresentTime, and postTime should not have changed

    ASSERT_EQ(1, events->frameNumber);

    ASSERT_EQ(requestedPresentTimeA, events->requestedPresentTime);

    ASSERT_GE(events->postedTime, postedTimeA);



    // a valid latchtime should not be set

    ASSERT_FALSE(events->hasLatchInfo());

    ASSERT_FALSE(events->hasDequeueReadyInfo());



    ASSERT_NE(nullptr, events->gpuCompositionDoneFence);

    ASSERT_NE(nullptr, events->displayPresentFence);

    ASSERT_NE(nullptr, events->releaseFence);



    // we should also have gotten the initial values for the next frame

    events = history.getFrame(2);

    ASSERT_NE(nullptr, events);

    ASSERT_EQ(2, events->frameNumber);

    ASSERT_EQ(requestedPresentTimeB, events->requestedPresentTime);

    ASSERT_GE(events->postedTime, postedTimeB);

}



} // namespace android

services/surfaceflinger/SurfaceFlinger.cpp

+0 −4
Original line number Diff line number Diff line
@@ -4160,10 +4160,6 @@ status_t SurfaceFlinger::createLayer(const String8& name, const sp<Client>& clie 


    switch (flags & ISurfaceComposerClient::eFXSurfaceMask) {

        case ISurfaceComposerClient::eFXSurfaceBufferQueue:

            result = createBufferQueueLayer(client, std::move(uniqueName), w, h, flags,

                                            std::move(metadata), format, handle, gbp, &layer);



            break;

        case ISurfaceComposerClient::eFXSurfaceBufferState: {

            result = createBufferStateLayer(client, std::move(uniqueName), w, h, flags,

                                            std::move(metadata), handle, &layer);