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

Commit e672cd0e authored by Pawin Vongmasa's avatar Pawin Vongmasa
Browse files

Implement converters for bufferqueue@2.0 

Test: make cts -j123 && cts-tradefed run cts-dev -m \
CtsMediaTestCases --compatibility:module-arg \
CtsMediaTestCases:include-annotation:\
android.platform.test.annotations.RequiresDevice

Bug: 112508112
Change-Id: I60f2068788136b01c45e03fc4d846d4e37edc7f2
parent bd879543

libs/gui/Android.bp

+24 −51
Original line number Diff line number Diff line
@@ -31,44 +31,7 @@ cc_library_shared { 
        "-Werror",

    ],

    cppflags: [

        "-Weverything",



        // The static constructors and destructors in this library have not been noted to

        // introduce significant overheads

        "-Wno-exit-time-destructors",

        "-Wno-global-constructors",



        // We only care about compiling as C++14

        "-Wno-c++98-compat-pedantic",



        // We don't need to enumerate every case in a switch as long as a default case

        // is present

        "-Wno-switch-enum",



        // Allow calling variadic macros without a __VA_ARGS__ list

        "-Wno-gnu-zero-variadic-macro-arguments",



        // Don't warn about struct padding

        "-Wno-padded",



        // We are aware of the risks inherent in comparing floats for equality

        "-Wno-float-equal",



        // Pure abstract classes trigger this warning

        "-Wno-weak-vtables",



        // Allow four-character integer literals

        "-Wno-four-char-constants",



        // Allow documentation warnings

        "-Wno-documentation",



        // Allow implicit instantiation for templated class function

        "-Wno-undefined-func-template",



        // Allow explicitly marking struct as packed even when unnecessary

        "-Wno-packed",



        "-Wextra",

        "-DDEBUG_ONLY_CODE=0",

    ],
@@ -121,30 +84,38 @@ cc_library_shared { 
        "view/Surface.cpp",

        "bufferqueue/1.0/B2HProducerListener.cpp",

        "bufferqueue/1.0/H2BGraphicBufferProducer.cpp",

        "bufferqueue/1.0/H2BProducerListener.cpp",

        "bufferqueue/2.0/B2HGraphicBufferProducer.cpp",

        "bufferqueue/2.0/B2HProducerListener.cpp",

        "bufferqueue/2.0/H2BGraphicBufferProducer.cpp",

        "bufferqueue/2.0/H2BProducerListener.cpp",

        "bufferqueue/2.0/types.cpp",

    ],



    shared_libs: [

        "android.frameworks.bufferhub@1.0",

        "android.hardware.graphics.bufferqueue@1.0",

        "android.hardware.graphics.bufferqueue@2.0",

        "android.hardware.graphics.common@1.1",

        "android.hardware.graphics.common@1.2",

        "android.hidl.token@1.0-utils",

        "libbase",

        "libsync",

        "libbinder",

        "libhwbinder",

        "libbufferhub",

        "libbufferhubqueue", // TODO(b/70046255): Remove this once BufferHub is integrated into libgui.

        "libpdx_default_transport",

        "libcutils",

        "libEGL",

        "libGLESv2",

        "libui",

        "libutils",

        "libnativewindow",

        "liblog",

        "libinput",

        "libhidlbase",

        "libhidltransport",

        "android.hidl.token@1.0-utils",

        "android.hardware.graphics.bufferqueue@1.0",

        "libhwbinder",

        "libinput",

        "liblog",

        "libnativewindow",

        "libpdx_default_transport",

        "libsync",

        "libui",

        "libutils",

        "libvndksupport",

    ],
@@ -163,16 +134,16 @@ cc_library_shared { 
                "android.frameworks.bufferhub@1.0",

                "libbufferhub",

                "libbufferhubqueue",

                "libpdx_default_transport",

                "libinput",

                "libpdx_default_transport",

            ],

        },

    },



    header_libs: [

        "libdvr_headers",

        "libnativebase_headers",

        "libgui_headers",

        "libnativebase_headers",

        "libpdx_headers",

    ],
@@ -181,9 +152,11 @@ cc_library_shared { 
        "libEGL",

        "libnativewindow",

        "libui",

        "android.hidl.token@1.0-utils",

        "android.hardware.graphics.bufferqueue@1.0",

        "android.hardware.graphics.bufferqueue@2.0",

        "android.hardware.graphics.common@1.1",

        "android.hardware.graphics.common@1.2",

        "android.hidl.token@1.0-utils",

    ],



    export_header_lib_headers: [

libs/gui/IGraphicBufferProducer.cpp

+11 −4
Original line number Diff line number Diff line
@@ -30,16 +30,21 @@ 
#ifndef NO_BUFFERHUB

#include <gui/BufferHubProducer.h>

#endif



#include <gui/bufferqueue/1.0/H2BGraphicBufferProducer.h>

#include <gui/bufferqueue/2.0/H2BGraphicBufferProducer.h>

#include <gui/BufferQueueDefs.h>

#include <gui/IGraphicBufferProducer.h>

#include <gui/IProducerListener.h>



#include <gui/bufferqueue/1.0/H2BGraphicBufferProducer.h>



namespace android {

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



using ::android::hardware::graphics::bufferqueue::V1_0::utils::

using H2BGraphicBufferProducerV1_0 =

        ::android::hardware::graphics::bufferqueue::V1_0::utils::

        H2BGraphicBufferProducer;

using H2BGraphicBufferProducerV2_0 =

        ::android::hardware::graphics::bufferqueue::V2_0::utils::

        H2BGraphicBufferProducer;



enum {
@@ -534,7 +539,9 @@ public: 
BpGraphicBufferProducer::~BpGraphicBufferProducer() {}



class HpGraphicBufferProducer : public HpInterface<

        BpGraphicBufferProducer, H2BGraphicBufferProducer> {

        BpGraphicBufferProducer,

        H2BGraphicBufferProducerV1_0,

        H2BGraphicBufferProducerV2_0> {

public:

    explicit HpGraphicBufferProducer(const sp<IBinder>& base) : PBase(base) {}

libs/gui/IProducerListener.cpp

+20 −2
Original line number Diff line number Diff line
@@ -15,7 +15,8 @@ 
 */



#include <binder/Parcel.h>



#include <gui/bufferqueue/1.0/H2BProducerListener.h>

#include <gui/bufferqueue/2.0/H2BProducerListener.h>

#include <gui/IProducerListener.h>



namespace android {
@@ -61,7 +62,24 @@ public: 
// translation unit (see clang warning -Wweak-vtables)

BpProducerListener::~BpProducerListener() {}



IMPLEMENT_META_INTERFACE(ProducerListener, "android.gui.IProducerListener")

class HpProducerListener : public HpInterface<

        BpProducerListener,

        hardware::graphics::bufferqueue::V1_0::utils::H2BProducerListener,

        hardware::graphics::bufferqueue::V2_0::utils::H2BProducerListener> {

public:

    explicit HpProducerListener(const sp<IBinder>& base) : PBase{base} {}



    virtual void onBufferReleased() override {

        mBase->onBufferReleased();

    }



    virtual bool needsReleaseNotify() override {

        return mBase->needsReleaseNotify();

    }

};



IMPLEMENT_HYBRID_META_INTERFACE(ProducerListener,

        "android.gui.IProducerListener")



status_t BnProducerListener::onTransact(uint32_t code, const Parcel& data,

        Parcel* reply, uint32_t flags) {

libs/gui/bufferqueue/1.0/H2BProducerListener.cpp

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

 * 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 "H2BProducerListener@1.0"



#include <android-base/logging.h>



#include <gui/bufferqueue/1.0/H2BProducerListener.h>

#include <hidl/Status.h>



namespace android {

namespace hardware {

namespace graphics {

namespace bufferqueue {

namespace V1_0 {

namespace utils {



using ::android::hardware::Return;



H2BProducerListener::H2BProducerListener(sp<HProducerListener> const& base)

      : CBase{base} {

}



void H2BProducerListener::onBufferReleased() {

    if (!mBase->onBufferReleased().isOk()) {

        LOG(ERROR) << "onBufferReleased: transaction failed.";

    }

}



bool H2BProducerListener::needsReleaseNotify() {

    Return<bool> transResult = mBase->needsReleaseNotify();

    if (!transResult.isOk()) {

        LOG(ERROR) << "needsReleaseNotify: transaction failed.";

        return false;

    }

    return static_cast<bool>(transResult);

}



}  // namespace utils

}  // namespace V1_0

}  // namespace bufferqueue

}  // namespace graphics

}  // namespace hardware

}  // namespace android

libs/gui/bufferqueue/2.0/B2HGraphicBufferProducer.cpp

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

 * 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 "H2BGraphicBufferProducer@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 {



// 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) {

    using HOutput = QueueBufferOutput;

    using BInput = BGraphicBufferProducer::QueueBufferInput;

    using BOutput = BGraphicBufferProducer::QueueBufferOutput;



    BInput 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, HOutput{});

        return {};

    }



    // Convert surfaceDamage.

    if (!h2b(hInput.surfaceDamage, &bInput.surfaceDamage)) {

        _hidl_cb(HStatus::UNKNOWN_ERROR, HOutput{});

        return {};

    }



    // Convert fence.

    if (!h2b(hInput.fence, &bInput.fence)) {

        _hidl_cb(HStatus::UNKNOWN_ERROR, HOutput{});

        return {};

    }



    BOutput bOutput{};

    HStatus hStatus{};

    bool converted = b2h(

            mBase->queueBuffer(static_cast<int>(slot), bInput, &bOutput),

            &hStatus);



    _hidl_cb(converted ? hStatus : HStatus::UNKNOWN_ERROR,

             HOutput{bOutput.width,

                     bOutput.height,

                     static_cast<int32_t>(bOutput.transformHint),

                     bOutput.numPendingBuffers,

                     bOutput.nextFrameNumber,

                     bOutput.bufferReplaced});

    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 {};

}



Return<void> B2HGraphicBufferProducer::connect(

        sp<HProducerListener> const& hListener,

        HConnectionType hConnectionType,

        bool producerControlledByApp,

        connect_cb _hidl_cb) {

    using BOutput = BGraphicBufferProducer::QueueBufferOutput;

    using HOutput = HGraphicBufferProducer::QueueBufferOutput;

    sp<BProducerListener> bListener = new H2BProducerListener(hListener);

    if (!bListener) {

        _hidl_cb(HStatus::UNKNOWN_ERROR, HOutput{});

        return {};

    }

    int bConnectionType;

    if (!h2b(hConnectionType, &bConnectionType)) {

        _hidl_cb(HStatus::UNKNOWN_ERROR, HOutput{});

        return {};

    }

    BOutput bOutput{};

    HStatus hStatus{};

    bool converted = b2h(

            mBase->connect(bListener,

                           bConnectionType,

                           producerControlledByApp,

                           &bOutput),

            &hStatus);

    _hidl_cb(converted ? hStatus : HStatus::UNKNOWN_ERROR,

             HOutput{bOutput.width,

                     bOutput.height,

                     static_cast<int32_t>(bOutput.transformHint),

                     bOutput.numPendingBuffers,

                     bOutput.nextFrameNumber,

                     bOutput.bufferReplaced});

    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);

    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