Merge "Provide a basic BLASTBufferQueue implementation."

        ":libgui_bufferqueue_sources",

        "BitTube.cpp",

        "BLASTBufferQueue.cpp",

        "BufferHubConsumer.cpp",

        "BufferHubProducer.cpp",

        "BufferItemConsumer.cpp",

/*

 * 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

/*

 * 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