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

Commit 398fed37 authored by TreeHugger Robot's avatar TreeHugger Robot Committed by Android (Google) Code Review
Browse files

Merge changes from topic "c2_sync" into sc-dev 

* changes:
  Codec2Client: Do not crash on configuring null output surface
  Vts: add support to use Surface for decoder test
parents 74dcdac0 b6388026

media/codec2/hidl/1.0/vts/functional/video/Android.bp

+2 −0
Original line number Diff line number Diff line
@@ -36,6 +36,8 @@ cc_test { 
        "libgui",

        "libutils",

        "libcrypto",

        "libdatasource",

        "libui",

    ],

    data: [":media_c2_v1_video_decode_res"],

    test_config: "VtsHalMediaC2V1_0TargetVideoDecTest.xml",

media/codec2/hidl/1.0/vts/functional/video/VtsHalMediaC2V1_0TargetVideoDecTest.cpp

+56 −9
Original line number Diff line number Diff line
@@ -33,11 +33,18 @@ 
#include <gui/IConsumerListener.h>

#include <gui/IProducerListener.h>

#include <system/window.h>

#include <gui/GLConsumer.h>

#include <gui/Surface.h>

#include <gui/SurfaceComposerClient.h>



#include "media_c2_hidl_test_common.h"

#include "media_c2_video_hidl_test_common.h"



using DecodeTestParameters = std::tuple<std::string, std::string, uint32_t, bool>;

constexpr size_t kSmoothnessFactor = 4;

constexpr size_t kRenderingDepth = 3;

enum surfaceMode_t { NO_SURFACE, NULL_SURFACE, SURFACE };



using DecodeTestParameters = std::tuple<std::string, std::string, uint32_t, bool, surfaceMode_t>;

static std::vector<DecodeTestParameters> gDecodeTestParameters;



using CsdFlushTestParameters = std::tuple<std::string, std::string, bool>;
@@ -392,6 +399,36 @@ bool Codec2VideoDecHidlTestBase::getFileNames(size_t streamIndex) { 
    return false;

}



void setOutputSurface(const std::shared_ptr<android::Codec2Client::Component>& component,

                      surfaceMode_t surfMode) {

    using namespace android;

    sp<IGraphicBufferProducer> producer = nullptr;

    static std::atomic_uint32_t surfaceGeneration{0};

    uint32_t generation =

            (getpid() << 10) |

            ((surfaceGeneration.fetch_add(1, std::memory_order_relaxed) + 1) & ((1 << 10) - 1));

    int32_t maxDequeueBuffers = kSmoothnessFactor + kRenderingDepth;

    if (surfMode == SURFACE) {

        sp<IGraphicBufferConsumer> consumer = nullptr;

        BufferQueue::createBufferQueue(&producer, &consumer);

        ASSERT_NE(producer, nullptr) << "createBufferQueue returned invalid producer";

        ASSERT_NE(consumer, nullptr) << "createBufferQueue returned invalid consumer";



        sp<GLConsumer> texture =

                new GLConsumer(consumer, 0 /* tex */, GLConsumer::TEXTURE_EXTERNAL,

                               true /* useFenceSync */, false /* isControlledByApp */);



        sp<ANativeWindow> gSurface = new Surface(producer);

        ASSERT_NE(gSurface, nullptr) << "getSurface failed";



        producer->setGenerationNumber(generation);

    }



    c2_status_t err = component->setOutputSurface(C2BlockPool::BASIC_GRAPHIC, producer, generation,

                                                  maxDequeueBuffers);

    ASSERT_EQ(err, C2_OK) << "setOutputSurface failed";

}



void decodeNFrames(const std::shared_ptr<android::Codec2Client::Component>& component,

                   std::mutex& queueLock, std::condition_variable& queueCondition,

                   std::list<std::unique_ptr<C2Work>>& workQueue,
@@ -550,6 +587,7 @@ TEST_P(Codec2VideoDecDecodeTest, DecodeTest) { 
    if (mDisableTest) GTEST_SKIP() << "Test is disabled";



    bool signalEOS = std::get<3>(GetParam());

    surfaceMode_t surfMode = std::get<4>(GetParam());

    mTimestampDevTest = true;



    android::Vector<FrameInfo> Info;
@@ -594,6 +632,10 @@ TEST_P(Codec2VideoDecDecodeTest, DecodeTest) { 
        refChksum.close();

    }



    if (surfMode != NO_SURFACE) {

        ASSERT_NO_FATAL_FAILURE(setOutputSurface(mComponent, surfMode));

    }



    ASSERT_NO_FATAL_FAILURE(decodeNFrames(mComponent, mQueueLock, mQueueCondition, mWorkQueue,

                                          mFlushedIndices, mLinearPool, eleStream, &Info, 0,

                                          (int)Info.size(), signalEOS));
@@ -1061,18 +1103,23 @@ int main(int argc, char** argv) { 
    parseArgs(argc, argv);

    gTestParameters = getTestParameters(C2Component::DOMAIN_VIDEO, C2Component::KIND_DECODER);

    for (auto params : gTestParameters) {

        // mOutputBufferQueue->configure() crashes when surface is NULL

        std::initializer_list<surfaceMode_t> surfaceMode = {

                surfaceMode_t::NO_SURFACE, surfaceMode_t::NULL_SURFACE, surfaceMode_t::SURFACE};

        for (surfaceMode_t mode : surfaceMode) {

            gDecodeTestParameters.push_back(

                std::make_tuple(std::get<0>(params), std::get<1>(params), 0, false));

                    std::make_tuple(std::get<0>(params), std::get<1>(params), 0, false, mode));

            gDecodeTestParameters.push_back(

                std::make_tuple(std::get<0>(params), std::get<1>(params), 0, true));

                    std::make_tuple(std::get<0>(params), std::get<1>(params), 0, true, mode));

        }

        gDecodeTestParameters.push_back(

                std::make_tuple(std::get<0>(params), std::get<1>(params), 1, false));

                std::make_tuple(std::get<0>(params), std::get<1>(params), 1, false, NO_SURFACE));

        gDecodeTestParameters.push_back(

                std::make_tuple(std::get<0>(params), std::get<1>(params), 1, true));

                std::make_tuple(std::get<0>(params), std::get<1>(params), 1, true, NO_SURFACE));

        gDecodeTestParameters.push_back(

                std::make_tuple(std::get<0>(params), std::get<1>(params), 2, false));

                std::make_tuple(std::get<0>(params), std::get<1>(params), 2, false, NO_SURFACE));

        gDecodeTestParameters.push_back(

                std::make_tuple(std::get<0>(params), std::get<1>(params), 2, true));

                std::make_tuple(std::get<0>(params), std::get<1>(params), 2, true, NO_SURFACE));



        gCsdFlushTestParameters.push_back(

                std::make_tuple(std::get<0>(params), std::get<1>(params), true));

media/codec2/hidl/client/output.cpp

+4 −1
Original line number Diff line number Diff line
@@ -181,7 +181,7 @@ bool OutputBufferQueue::configure(const sp<IGraphicBufferProducer>& igbp, 
                                  int maxDequeueBufferCount,

                                  std::shared_ptr<V1_2::SurfaceSyncObj> *syncObj) {

    uint64_t consumerUsage = 0;

    if (igbp->getConsumerUsage(&consumerUsage) != OK) {

    if (igbp && igbp->getConsumerUsage(&consumerUsage) != OK) {

        ALOGW("failed to get consumer usage");

    }
@@ -254,6 +254,9 @@ bool OutputBufferQueue::configure(const sp<IGraphicBufferProducer>& igbp, 
        mBqId = bqId;

        mOwner = std::make_shared<int>(0);

        mMaxDequeueBufferCount = maxDequeueBufferCount;

        if (igbp == nullptr) {

            return false;

        }

        for (int i = 0; i < BufferQueueDefs::NUM_BUFFER_SLOTS; ++i) {

            if (mBqId == 0 || !mBuffers[i]) {

                continue;