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

Commit 78c25dd3 authored by Robert Carr's avatar Robert Carr
Browse files

Provide a basic BLASTBufferQueue implementation. 

Provide a utility class which hooks the consumer end of
a BufferQueue up to BLAST. This is a trivial implementation
to enable experimentation in the client framework to begin.

Bug: 135786080
Test: Accompanying frameworks/base changes
Change-Id: I7400dc421d264a00d14e0a928c060b94bc5e5dfc
parent adbb90ba

libs/gui/Android.bp

+1 −0
Original line number Diff line number Diff line
@@ -33,6 +33,7 @@ cc_library_shared { 


    srcs: [

        "BitTube.cpp",

        "BLASTBufferQueue.cpp",

        "BufferHubConsumer.cpp",

        "BufferHubProducer.cpp",

        "BufferItemConsumer.cpp",

libs/gui/BLASTBufferQueue.cpp

0 → 100644
+126 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2019 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



#include <gui/BLASTBufferQueue.h>

#include <gui/BufferItemConsumer.h>



#include <chrono>



using namespace std::chrono_literals;



namespace android {



BLASTBufferQueue::BLASTBufferQueue(const sp<SurfaceControl>& surface, int width, int height)

      : mSurfaceControl(surface), mWidth(width), mHeight(height) {

    BufferQueue::createBufferQueue(&mProducer, &mConsumer);

    mBufferItemConsumer =

            new BufferItemConsumer(mConsumer, AHARDWAREBUFFER_USAGE_GPU_FRAMEBUFFER, 1, true);

    mBufferItemConsumer->setName(String8("BLAST Consumer"));

    mBufferItemConsumer->setFrameAvailableListener(this);

    mBufferItemConsumer->setBufferFreedListener(this);

    mBufferItemConsumer->setDefaultBufferSize(mWidth, mHeight);

    mBufferItemConsumer->setDefaultBufferFormat(PIXEL_FORMAT_RGBA_8888);

}



void BLASTBufferQueue::update(const sp<SurfaceControl>& surface, int width, int height) {

    std::unique_lock _lock{mMutex};

    mSurfaceControl = surface;

    mWidth = width;

    mHeight = height;

    mBufferItemConsumer->setDefaultBufferSize(mWidth, mHeight);

}



static void transactionCallbackThunk(void* context, nsecs_t latchTime,

                                     const sp<Fence>& presentFence,

                                     const std::vector<SurfaceControlStats>& stats) {

    if (context == nullptr) {

        return;

    }

    BLASTBufferQueue* bq = static_cast<BLASTBufferQueue*>(context);

    bq->transactionCallback(latchTime, presentFence, stats);

}



void BLASTBufferQueue::transactionCallback(nsecs_t /*latchTime*/, const sp<Fence>& /*presentFence*/,

                                           const std::vector<SurfaceControlStats>& stats) {

    std::unique_lock _lock{mMutex};



    if (stats.size() > 0 && mNextCallbackBufferItem.mGraphicBuffer != nullptr) {

        mBufferItemConsumer->releaseBuffer(mNextCallbackBufferItem,

                                           stats[0].previousReleaseFence

                                                   ? stats[0].previousReleaseFence

                                                   : Fence::NO_FENCE);

        mNextCallbackBufferItem = BufferItem();

    }

    mDequeueWaitCV.notify_one();

    decStrong((void*)transactionCallbackThunk);

}



void BLASTBufferQueue::onFrameAvailable(const BufferItem& item) {

    std::unique_lock _lock{mMutex};



    SurfaceComposerClient::Transaction localTransaction;

    bool applyTransaction = true;

    SurfaceComposerClient::Transaction* t = &localTransaction;

    if (mNextTransaction != nullptr) {

        t = mNextTransaction;

        mNextTransaction = nullptr;

        applyTransaction = false;

    }



    int status = OK;

    mNextCallbackBufferItem = mLastSubmittedBufferItem;



    mLastSubmittedBufferItem = BufferItem();

    status = mBufferItemConsumer->acquireBuffer(&mLastSubmittedBufferItem, -1, false);

    if (status != OK) {

        ALOGE("Failed to acquire?");

    }



    auto buffer = mLastSubmittedBufferItem.mGraphicBuffer;



    if (buffer == nullptr) {

        ALOGE("Null buffer");

        return;

    }





    // Ensure BLASTBufferQueue stays alive until we receive the transaction complete callback.

    incStrong((void*)transactionCallbackThunk);



    t->setBuffer(mSurfaceControl, buffer);

    t->setAcquireFence(mSurfaceControl,

                       item.mFence ? new Fence(item.mFence->dup()) : Fence::NO_FENCE);

    t->addTransactionCompletedCallback(transactionCallbackThunk, static_cast<void*>(this));



    t->setFrame(mSurfaceControl, {0, 0, (int32_t)buffer->getWidth(), (int32_t)buffer->getHeight()});

    t->setCrop(mSurfaceControl, {0, 0, (int32_t)buffer->getWidth(), (int32_t)buffer->getHeight()});



    if (applyTransaction) {

        ALOGE("Apply transaction");

        t->apply();



        if (mNextCallbackBufferItem.mGraphicBuffer != nullptr) {

            mDequeueWaitCV.wait_for(_lock, 5000ms);

        }

    }

}



void BLASTBufferQueue::setNextTransaction(SurfaceComposerClient::Transaction* t) {

    std::unique_lock _lock{mMutex};

    mNextTransaction = t;

}



} // namespace android

libs/gui/include/gui/BLASTBufferQueue.h

0 → 100644
+92 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2019 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



#ifndef ANDROID_GUI_BLAST_BUFFER_QUEUE_H

#define ANDROID_GUI_BLAST_BUFFER_QUEUE_H



#include <gui/IGraphicBufferProducer.h>

#include <gui/BufferItemConsumer.h>

#include <gui/BufferItem.h>

#include <gui/SurfaceComposerClient.h>



#include <utils/Condition.h>

#include <utils/Mutex.h>

#include <utils/RefBase.h>



#include <system/window.h>



namespace android {



class BufferItemConsumer;



class BLASTBufferQueue

    : public ConsumerBase::FrameAvailableListener, public BufferItemConsumer::BufferFreedListener

{

public:

    BLASTBufferQueue(const sp<SurfaceControl>& surface, int width, int height);

    sp<IGraphicBufferProducer> getIGraphicBufferProducer() const {

        return mProducer;

    }



    void onBufferFreed(const wp<GraphicBuffer>&/* graphicBuffer*/) override { /* TODO */ }

    void onFrameReplaced(const BufferItem& item) override {onFrameAvailable(item);}

    void onFrameAvailable(const BufferItem& item) override;



    void transactionCallback(nsecs_t latchTime, const sp<Fence>& presentFence,

            const std::vector<SurfaceControlStats>& stats);

    void setNextTransaction(SurfaceComposerClient::Transaction *t);



    void update(const sp<SurfaceControl>& surface, int width, int height);

    



    virtual ~BLASTBufferQueue() = default;



private:

    // can't be copied

    BLASTBufferQueue& operator = (const BLASTBufferQueue& rhs);

    BLASTBufferQueue(const BLASTBufferQueue& rhs);



    sp<SurfaceControl> mSurfaceControl;

    

    mutable std::mutex mMutex;



    static const int MAX_BUFFERS = 2;

    struct BufferInfo {

        sp<GraphicBuffer> buffer;

        int fence;

    };

    

    int mDequeuedBuffers = 0;



    int mWidth;

    int mHeight;



    BufferItem mLastSubmittedBufferItem;

    BufferItem mNextCallbackBufferItem;

    sp<Fence> mLastFence;



    std::condition_variable mDequeueWaitCV;



    sp<IGraphicBufferConsumer> mConsumer;

    sp<IGraphicBufferProducer> mProducer;

    sp<BufferItemConsumer> mBufferItemConsumer;



    SurfaceComposerClient::Transaction* mNextTransaction = nullptr;

};



} // namespace android



#endif  // ANDROID_GUI_SURFACE_H