libs/gui/bufferqueue/2.0/B2HGraphicBufferProducer.cpp

/*
 * Copyright 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.
 */

//#define LOG_NDEBUG 0
#define LOG_TAG "B2HGraphicBufferProducer@2.0"

#include <android-base/logging.h>

#include <android/hardware/graphics/bufferqueue/2.0/types.h>
#include <android/hardware/graphics/common/1.2/types.h>
#include <gui/bufferqueue/2.0/H2BProducerListener.h>
#include <gui/bufferqueue/2.0/B2HGraphicBufferProducer.h>
#include <gui/bufferqueue/2.0/types.h>
#include <ui/GraphicBuffer.h>
#include <ui/Rect.h>
#include <ui/Region.h>
#include <vndk/hardware_buffer.h>

namespace android {
namespace hardware {
namespace graphics {
namespace bufferqueue {
namespace V2_0 {
namespace utils {

namespace /* unnamed */ {

using BQueueBufferInput = ::android::
        IGraphicBufferProducer::QueueBufferInput;
using HQueueBufferInput = ::android::hardware::graphics::bufferqueue::V2_0::
        IGraphicBufferProducer::QueueBufferInput;
using BQueueBufferOutput = ::android::
        IGraphicBufferProducer::QueueBufferOutput;
using HQueueBufferOutput = ::android::hardware::graphics::bufferqueue::V2_0::
        IGraphicBufferProducer::QueueBufferOutput;

using ::android::hardware::graphics::bufferqueue::V2_0::utils::b2h;
using ::android::hardware::graphics::bufferqueue::V2_0::utils::h2b;

bool b2h(BQueueBufferOutput const& from, HQueueBufferOutput* to) {
    to->width = from.width;
    to->height = from.height;
    to->transformHint = static_cast<int32_t>(from.transformHint);
    to->numPendingBuffers = from.numPendingBuffers;
    to->nextFrameNumber = from.nextFrameNumber;
    to->bufferReplaced = from.bufferReplaced;
    return true;
}

} // unnamed namespace

// B2HGraphicBufferProducer
// ========================

B2HGraphicBufferProducer::B2HGraphicBufferProducer(
        sp<BGraphicBufferProducer> const& base)
      : mBase{base} {
}

Return<HStatus> B2HGraphicBufferProducer::setMaxDequeuedBufferCount(
        int32_t maxDequeuedBuffers) {
    HStatus hStatus{};
    bool converted = b2h(
            mBase->setMaxDequeuedBufferCount(
                static_cast<int>(maxDequeuedBuffers)),
            &hStatus);
    return {converted ? hStatus : HStatus::UNKNOWN_ERROR};
}

Return<void> B2HGraphicBufferProducer::requestBuffer(
        int32_t slot,
        requestBuffer_cb _hidl_cb) {
    sp<GraphicBuffer> bBuffer;
    HStatus hStatus{};
    HardwareBuffer hBuffer{};
    uint32_t hGenerationNumber{};
    bool converted =
            b2h(mBase->requestBuffer(
                    static_cast<int>(slot), &bBuffer),
                &hStatus) &&
            b2h(bBuffer, &hBuffer, &hGenerationNumber);
    _hidl_cb(converted ? hStatus : HStatus::UNKNOWN_ERROR,
             hBuffer, hGenerationNumber);
    return {};
}

Return<HStatus> B2HGraphicBufferProducer::setAsyncMode(bool async) {
    HStatus hStatus{};
    bool converted = b2h(mBase->setAsyncMode(async), &hStatus);
    return {converted ? hStatus : HStatus::UNKNOWN_ERROR};
}

Return<void> B2HGraphicBufferProducer::dequeueBuffer(
        DequeueBufferInput const& input,
        dequeueBuffer_cb _hidl_cb) {
    int bSlot{};
    sp<BFence> bFence;
    HStatus hStatus{};
    DequeueBufferOutput hOutput{};
    HFenceWrapper hFenceWrapper;
    bool converted =
            b2h(mBase->dequeueBuffer(
                    &bSlot,
                    &bFence,
                    input.width,
                    input.height,
                    static_cast<PixelFormat>(input.format),
                    input.usage,
                    &hOutput.bufferAge,
                    nullptr /* outTimestamps */),
                &hStatus,
                &hOutput.bufferNeedsReallocation,
                &hOutput.releaseAllBuffers) &&
            b2h(bFence, &hFenceWrapper);
    hOutput.fence = hFenceWrapper.getHandle();
    _hidl_cb(converted ? hStatus : HStatus::UNKNOWN_ERROR,
             static_cast<int32_t>(bSlot),
             hOutput);
    return {};
}

Return<HStatus> B2HGraphicBufferProducer::detachBuffer(int32_t slot) {
    HStatus hStatus{};
    bool converted = b2h(
            mBase->detachBuffer(static_cast<int>(slot)), &hStatus);
    return {converted ? hStatus : HStatus::UNKNOWN_ERROR};
}

Return<void> B2HGraphicBufferProducer::detachNextBuffer(
        detachNextBuffer_cb _hidl_cb) {
    sp<GraphicBuffer> bBuffer;
    sp<BFence> bFence;
    HStatus hStatus{};
    HardwareBuffer hBuffer{};
    HFenceWrapper hFenceWrapper;
    bool converted =
            b2h(mBase->detachNextBuffer(&bBuffer, &bFence), &hStatus) &&
            b2h(bBuffer, &hBuffer) &&
            b2h(bFence, &hFenceWrapper);
    _hidl_cb(converted ? hStatus : HStatus::UNKNOWN_ERROR,
             hBuffer,
             hFenceWrapper.getHandle());
    return {};
}

Return<void> B2HGraphicBufferProducer::attachBuffer(
        HardwareBuffer const& hBuffer,
        uint32_t generationNumber,
        attachBuffer_cb _hidl_cb) {
    sp<GraphicBuffer> bBuffer;
    if (!h2b(hBuffer, &bBuffer) || !bBuffer) {
        _hidl_cb(HStatus::UNKNOWN_ERROR,
                 static_cast<int32_t>(SlotIndex::INVALID),
                 false);
        return {};
    }
    bBuffer->setGenerationNumber(generationNumber);

    int bSlot{};
    HStatus hStatus{};
    bool releaseAllBuffers{};
    bool converted = b2h(
            mBase->attachBuffer(&bSlot, bBuffer), &hStatus,
            nullptr /* bufferNeedsReallocation */,
            &releaseAllBuffers);
    _hidl_cb(converted ? hStatus : HStatus::UNKNOWN_ERROR,
             static_cast<int32_t>(bSlot),
             releaseAllBuffers);
    return {};
}

Return<void> B2HGraphicBufferProducer::queueBuffer(
        int32_t slot,
        QueueBufferInput const& hInput,
        queueBuffer_cb _hidl_cb) {
    BQueueBufferInput bInput{
            hInput.timestamp,
            hInput.isAutoTimestamp,
            static_cast<android_dataspace>(hInput.dataSpace),
            {}, /* crop */
            0 /* scalingMode = NATIVE_WINDOW_SCALING_MODE_FREEZE */,
            static_cast<uint32_t>(hInput.transform),
            {}, /* fence */
            static_cast<uint32_t>(hInput.stickyTransform),
            false /* getFrameTimestamps */};

    // Convert crop.
    if (!h2b(hInput.crop, &bInput.crop)) {
        _hidl_cb(HStatus::UNKNOWN_ERROR, QueueBufferOutput{});
        return {};
    }

    // Convert surfaceDamage.
    if (!h2b(hInput.surfaceDamage, &bInput.surfaceDamage)) {
        _hidl_cb(HStatus::UNKNOWN_ERROR, QueueBufferOutput{});
        return {};
    }

    // Convert fence.
    if (!h2b(hInput.fence, &bInput.fence)) {
        _hidl_cb(HStatus::UNKNOWN_ERROR, QueueBufferOutput{});
        return {};
    }

    BQueueBufferOutput bOutput{};
    HStatus hStatus{};
    QueueBufferOutput hOutput{};
    bool converted =
            b2h(
                mBase->queueBuffer(static_cast<int>(slot), bInput, &bOutput),
                &hStatus) &&
            b2h(bOutput, &hOutput);

    _hidl_cb(converted ? hStatus : HStatus::UNKNOWN_ERROR, hOutput);
    return {};
}

Return<HStatus> B2HGraphicBufferProducer::cancelBuffer(
        int32_t slot,
        hidl_handle const& fence) {
    sp<BFence> bFence;
    if (!h2b(fence.getNativeHandle(), &bFence)) {
        return {HStatus::UNKNOWN_ERROR};
    }
    HStatus hStatus{};
    bool converted = b2h(
            mBase->cancelBuffer(static_cast<int>(slot), bFence),
            &hStatus);
    return {converted ? hStatus : HStatus::UNKNOWN_ERROR};
}

Return<void> B2HGraphicBufferProducer::query(int32_t what, query_cb _hidl_cb) {
    int value{};
    int result = mBase->query(static_cast<int>(what), &value);
    _hidl_cb(static_cast<int32_t>(result), static_cast<int32_t>(value));
    return {};
}

struct Obituary : public hardware::hidl_death_recipient {
    wp<B2HGraphicBufferProducer> producer;
    sp<HProducerListener> listener;
    HConnectionType apiType;
    Obituary(const wp<B2HGraphicBufferProducer>& p,
             const sp<HProducerListener>& l,
             HConnectionType t)
        : producer(p), listener(l), apiType(t) {}

    void serviceDied(uint64_t /* cookie */,
            const wp<::android::hidl::base::V1_0::IBase>& /* who */) override {
        sp<B2HGraphicBufferProducer> dr = producer.promote();
        if (dr != nullptr) {
            (void)dr->disconnect(apiType);
        }
    }
};

Return<void> B2HGraphicBufferProducer::connect(
        sp<HProducerListener> const& hListener,
        HConnectionType hConnectionType,
        bool producerControlledByApp,
        connect_cb _hidl_cb) {
    sp<BProducerListener> bListener = new H2BProducerListener(hListener);
    int bConnectionType{};
    if (!bListener || !h2b(hConnectionType, &bConnectionType)) {
        _hidl_cb(HStatus::UNKNOWN_ERROR, QueueBufferOutput{});
        return {};
    }
    BQueueBufferOutput bOutput{};
    HStatus hStatus{};
    QueueBufferOutput hOutput{};
    bool converted =
            b2h(mBase->connect(bListener,
                               bConnectionType,
                               producerControlledByApp,
                               &bOutput),
                &hStatus) &&
            b2h(bOutput, &hOutput);
#ifdef NO_BINDER
    if (converted && hListener != nullptr) {
        mObituary = new Obituary(this, hListener, hConnectionType);
        hListener->linkToDeath(mObituary, 0);
    }
#endif // NO_BINDER
    _hidl_cb(converted ? hStatus : HStatus::UNKNOWN_ERROR, hOutput);
    return {};
}

Return<HStatus> B2HGraphicBufferProducer::disconnect(
        HConnectionType hConnectionType) {
    int bConnectionType;
    if (!h2b(hConnectionType, &bConnectionType)) {
        return {HStatus::UNKNOWN_ERROR};
    }
    HStatus hStatus{};
    bool converted = b2h(mBase->disconnect(bConnectionType), &hStatus);
#ifdef NO_BINDER
    if (mObituary != nullptr) {
        mObituary->listener->unlinkToDeath(mObituary);
        mObituary.clear();
    }
#endif // NO_BINDER
    return {converted ? hStatus : HStatus::UNKNOWN_ERROR};
}

Return<HStatus> B2HGraphicBufferProducer::allocateBuffers(
        uint32_t width, uint32_t height,
        uint32_t format, uint64_t usage) {
    mBase->allocateBuffers(
            width, height, static_cast<PixelFormat>(format), usage);
    return {HStatus::OK};
}

Return<HStatus> B2HGraphicBufferProducer::allowAllocation(bool allow) {
    HStatus hStatus{};
    bool converted = b2h(mBase->allowAllocation(allow), &hStatus);
    return {converted ? hStatus : HStatus::UNKNOWN_ERROR};
}

Return<HStatus> B2HGraphicBufferProducer::setGenerationNumber(
        uint32_t generationNumber) {
    HStatus hStatus{};
    bool converted = b2h(
            mBase->setGenerationNumber(generationNumber),
            &hStatus);
    return {converted ? hStatus : HStatus::UNKNOWN_ERROR};
}

Return<HStatus> B2HGraphicBufferProducer::setDequeueTimeout(
        int64_t timeoutNs) {
    HStatus hStatus{};
    bool converted = b2h(
            mBase->setDequeueTimeout(static_cast<nsecs_t>(timeoutNs)),
            &hStatus);
    return {converted ? hStatus : HStatus::UNKNOWN_ERROR};
}

Return<uint64_t> B2HGraphicBufferProducer::getUniqueId() {
    uint64_t outId{};
    HStatus hStatus{};
    bool converted = b2h(mBase->getUniqueId(&outId), &hStatus);
    return {converted ? outId : 0};
}

Return<void> B2HGraphicBufferProducer::getConsumerName(
        getConsumerName_cb _hidl_cb) {
    _hidl_cb(hidl_string{mBase->getConsumerName().c_str()});
    return {};
}

}  // namespace utils
}  // namespace V2_0
}  // namespace bufferqueue
}  // namespace graphics
}  // namespace hardware
}  // namespace android