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

Commit 6075c6ae authored by Jim Shargo's avatar Jim Shargo Committed by Android (Google) Code Review
Browse files

Merge changes I13283720,Iddd8f902 into main 

* changes:
  BufferItemConsumer: Add/expose methods
  BufferQueue: Fix deadlock in setMaxAcquiredBufferCount
parents 269580ec f3b00125

libs/gui/BufferItemConsumer.cpp

+25 −2
Original line number Diff line number Diff line
@@ -17,6 +17,7 @@ 
//#define LOG_NDEBUG 0

#define LOG_TAG "BufferItemConsumer"

//#define ATRACE_TAG ATRACE_TAG_GRAPHICS

#include <utils/Errors.h>

#include <utils/Log.h>



#include <inttypes.h>
@@ -132,13 +133,36 @@ status_t BufferItemConsumer::acquireBuffer(BufferItem *item, 
    return OK;

}



status_t BufferItemConsumer::attachBuffer(const sp<GraphicBuffer>& buffer) {

    if (!buffer) {

        BI_LOGE("BufferItemConsumer::attachBuffer no input buffer specified.");

        return BAD_VALUE;

    }



    Mutex::Autolock _l(mMutex);



    int slot = INVALID_BUFFER_SLOT;

    status_t status = mConsumer->attachBuffer(&slot, buffer);

    if (status != OK) {

        BI_LOGE("BufferItemConsumer::attachBuffer unable to attach buffer %d", status);

        return status;

    }



    mSlots[slot] = {

            .mGraphicBuffer = buffer,

            .mFence = nullptr,

            .mFrameNumber = 0,

    };



    return OK;

}



status_t BufferItemConsumer::releaseBuffer(const BufferItem &item,

        const sp<Fence>& releaseFence) {

    Mutex::Autolock _l(mMutex);

    return releaseBufferSlotLocked(item.mSlot, item.mGraphicBuffer, releaseFence);

}



#if COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_PLATFORM_API_IMPROVEMENTS)

status_t BufferItemConsumer::releaseBuffer(const sp<GraphicBuffer>& buffer,

                                           const sp<Fence>& releaseFence) {

    Mutex::Autolock _l(mMutex);
@@ -154,7 +178,6 @@ status_t BufferItemConsumer::releaseBuffer(const sp<GraphicBuffer>& buffer, 


    return releaseBufferSlotLocked(slotIndex, buffer, releaseFence);

}

#endif // COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_PLATFORM_API_IMPROVEMENTS)



status_t BufferItemConsumer::releaseBufferSlotLocked(int slotIndex, const sp<GraphicBuffer>& buffer,

                                                     const sp<Fence>& releaseFence) {

libs/gui/BufferQueueConsumer.cpp

+22 −10
Original line number Diff line number Diff line
@@ -14,10 +14,6 @@ 
 * limitations under the License.

 */



#include <inttypes.h>

#include <pwd.h>

#include <sys/types.h>



#define LOG_TAG "BufferQueueConsumer"

#define ATRACE_TAG ATRACE_TAG_GRAPHICS

//#define LOG_NDEBUG 0
@@ -48,6 +44,11 @@ 


#include <com_android_graphics_libgui_flags.h>



#include <inttypes.h>

#include <pwd.h>

#include <sys/types.h>

#include <optional>



namespace android {



// Macros for include BufferQueueCore information in log messages
@@ -767,11 +768,15 @@ status_t BufferQueueConsumer::setMaxBufferCount(int bufferCount) { 
    return NO_ERROR;

}



status_t BufferQueueConsumer::setMaxAcquiredBufferCount(int maxAcquiredBuffers) {

    return setMaxAcquiredBufferCount(maxAcquiredBuffers, std::nullopt);

}



status_t BufferQueueConsumer::setMaxAcquiredBufferCount(

        int maxAcquiredBuffers) {

        int maxAcquiredBuffers, std::optional<OnBufferReleasedCallback> onBuffersReleasedCallback) {

    ATRACE_FORMAT("%s(%d)", __func__, maxAcquiredBuffers);



    sp<IConsumerListener> listener;

    std::optional<OnBufferReleasedCallback> callback;

    { // Autolock scope

        std::unique_lock<std::mutex> lock(mCore->mMutex);
@@ -833,13 +838,20 @@ status_t BufferQueueConsumer::setMaxAcquiredBufferCount( 
        BQ_LOGV("setMaxAcquiredBufferCount: %d", maxAcquiredBuffers);

        mCore->mMaxAcquiredBufferCount = maxAcquiredBuffers;

        VALIDATE_CONSISTENCY();

        if (delta < 0 && mCore->mBufferReleasedCbEnabled) {

            listener = mCore->mConsumerListener;

        if (delta < 0) {

            if (onBuffersReleasedCallback) {

                callback = std::move(onBuffersReleasedCallback);

            } else if (mCore->mBufferReleasedCbEnabled) {

                callback = [listener = mCore->mConsumerListener]() {

                    listener->onBuffersReleased();

                };

            }

        }

    }



    // Call back without lock held

    if (listener != nullptr) {

        listener->onBuffersReleased();

    if (callback) {

        (*callback)();

    }



    return NO_ERROR;

libs/gui/ConsumerBase.cpp

+5 −1
Original line number Diff line number Diff line
@@ -264,7 +264,10 @@ void ConsumerBase::onFrameReplaced(const BufferItem &item) { 


void ConsumerBase::onBuffersReleased() {

    Mutex::Autolock lock(mMutex);

    onBuffersReleasedLocked();

}



void ConsumerBase::onBuffersReleasedLocked() {

    CB_LOGV("onBuffersReleased");



    if (mAbandoned) {
@@ -481,7 +484,8 @@ status_t ConsumerBase::setMaxAcquiredBufferCount(int maxAcquiredBuffers) { 
        CB_LOGE("setMaxAcquiredBufferCount: ConsumerBase is abandoned!");

        return NO_INIT;

    }

    return mConsumer->setMaxAcquiredBufferCount(maxAcquiredBuffers);

    return mConsumer->setMaxAcquiredBufferCount(maxAcquiredBuffers,

                                                {[this]() { onBuffersReleasedLocked(); }});

}



status_t ConsumerBase::setConsumerIsProtected(bool isProtected) {

libs/gui/include/gui/BufferItemConsumer.h

+8 −2
Original line number Diff line number Diff line
@@ -96,6 +96,14 @@ class BufferItemConsumer: public ConsumerBase 
    status_t acquireBuffer(BufferItem* item, nsecs_t presentWhen,

            bool waitForFence = true);



    // Transfer ownership of a buffer to the BufferQueue. On NO_ERROR, the buffer

    // is considered as if it were acquired. Buffer must not be null.

    //

    // Returns

    //  - BAD_VALUE if buffer is null

    //  - INVALID_OPERATION if too many buffers have already been acquired

    status_t attachBuffer(const sp<GraphicBuffer>& buffer);



    // Returns an acquired buffer to the queue, allowing it to be reused. Since

    // only a fixed number of buffers may be acquired at a time, old buffers

    // must be released by calling releaseBuffer to ensure new buffers can be
@@ -105,10 +113,8 @@ class BufferItemConsumer: public ConsumerBase 
    status_t releaseBuffer(const BufferItem &item,

            const sp<Fence>& releaseFence = Fence::NO_FENCE);



#if COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_PLATFORM_API_IMPROVEMENTS)

    status_t releaseBuffer(const sp<GraphicBuffer>& buffer,

                           const sp<Fence>& releaseFence = Fence::NO_FENCE);

#endif // COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_PLATFORM_API_IMPROVEMENTS)



protected:

#if COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_CONSUMER_BASE_OWNS_BQ)

libs/gui/include/gui/BufferQueueConsumer.h

+4 −1
Original line number Diff line number Diff line
@@ -122,7 +122,10 @@ public: 
    // setMaxAcquiredBufferCount sets the maximum number of buffers that can

    // be acquired by the consumer at one time (default 1).  This call will

    // fail if a producer is connected to the BufferQueue.

    virtual status_t setMaxAcquiredBufferCount(int maxAcquiredBuffers);

    virtual status_t setMaxAcquiredBufferCount(int maxAcquiredBuffers) override;

    virtual status_t setMaxAcquiredBufferCount(

            int maxAcquiredBuffers,

            std::optional<OnBufferReleasedCallback> onBuffersReleasedCallback) override;



    // setConsumerName sets the name used in logging

    status_t setConsumerName(const String8& name) override;