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

Commit f1c7514a authored by Harish Mahendrakar's avatar Harish Mahendrakar Committed by Sungtak Lee
Browse files

C2 VTS: Cleanup code around query() calls 

- Cleaned up the code that was reading parameters returned in query()
- Ensure both return value and size of parameter vector are valid
- Use ASSERT_EQ() instead of if () checks after query()

Also added a missing ASSERT for verifying number of channels in gsm
decoder tests

Bug: 200329093
Test: atest VtsHalMediaC2V1_0TargetAudioDecTest \
 VtsHalMediaC2V1_0TargetAudioEncTest \
 VtsHalMediaC2V1_0TargetVideoDecTest \
 VtsHalMediaC2V1_0TargetVideoEncTest \
 VtsHalMediaC2V1_0TargetComponentTest \
 VtsHalMediaC2V1_0TargetMasterTest

Change-Id: I3a910fcea6927f1ed48d2457d333a8bc92ee1dcf
Merged-In: I3a910fcea6927f1ed48d2457d333a8bc92ee1dcf
parent 10b75206

media/codec2/hidl/1.0/vts/functional/audio/VtsHalMediaC2V1_0TargetAudioDecTest.cpp

+18 −20
Original line number Diff line number Diff line
@@ -100,8 +100,10 @@ class Codec2AudioDecHidlTestBase : public ::testing::Test { 
        ASSERT_NE(mLinearPool, nullptr);



        std::vector<std::unique_ptr<C2Param>> queried;

        mComponent->query({}, {C2PortMediaTypeSetting::input::PARAM_TYPE}, C2_DONT_BLOCK, &queried);

        ASSERT_GT(queried.size(), 0);

        c2_status_t c2err = mComponent->query({}, {C2PortMediaTypeSetting::input::PARAM_TYPE},

                                              C2_DONT_BLOCK, &queried);

        ASSERT_EQ(c2err, C2_OK) << "Query media type failed";

        ASSERT_EQ(queried.size(), 1) << "Size of the vector returned is invalid";



        mMime = ((C2PortMediaTypeSetting::input*)queried[0].get())->m.value;
@@ -277,15 +279,11 @@ void getInputChannelInfo(const std::shared_ptr<android::Codec2Client::Component> 
    };

    std::vector<std::unique_ptr<C2Param>> inParams;

    c2_status_t status = component->query({}, indices, C2_DONT_BLOCK, &inParams);

    if (status != C2_OK && inParams.size() == 0) {

        ALOGE("Query media type failed => %d", status);

        ASSERT_TRUE(false);

    } else {

        size_t offset = sizeof(C2Param);

        for (size_t i = 0; i < inParams.size(); ++i) {

            C2Param* param = inParams[i].get();

            bitStreamInfo[i] = *(int32_t*)((uint8_t*)param + offset);

        }

    ASSERT_EQ(status, C2_OK) << "Query sample rate and channel count info failed";

    ASSERT_EQ(inParams.size(), indices.size()) << "Size of the vector returned is invalid";



    bitStreamInfo[0] = C2StreamSampleRateInfo::output::From(inParams[0].get())->value;

    bitStreamInfo[1] = C2StreamChannelCountInfo::output::From(inParams[1].get())->value;

    if (mime.find("3gpp") != std::string::npos) {

        ASSERT_EQ(bitStreamInfo[0], 8000);

        ASSERT_EQ(bitStreamInfo[1], 1);
@@ -294,7 +292,7 @@ void getInputChannelInfo(const std::shared_ptr<android::Codec2Client::Component> 
        ASSERT_EQ(bitStreamInfo[1], 1);

    } else if (mime.find("gsm") != std::string::npos) {

        ASSERT_EQ(bitStreamInfo[0], 8000);

        }

        ASSERT_EQ(bitStreamInfo[1], 1);

    }

}

media/codec2/hidl/1.0/vts/functional/audio/VtsHalMediaC2V1_0TargetAudioEncTest.cpp

+42 −63
Original line number Diff line number Diff line
@@ -73,9 +73,10 @@ class Codec2AudioEncHidlTestBase : public ::testing::Test { 
        ASSERT_NE(mLinearPool, nullptr);



        std::vector<std::unique_ptr<C2Param>> queried;

        mComponent->query({}, {C2PortMediaTypeSetting::output::PARAM_TYPE}, C2_DONT_BLOCK,

                          &queried);

        ASSERT_GT(queried.size(), 0);

        c2_status_t c2err = mComponent->query({}, {C2PortMediaTypeSetting::output::PARAM_TYPE},

                                              C2_DONT_BLOCK, &queried);

        ASSERT_EQ(c2err, C2_OK) << "Query media type failed";

        ASSERT_EQ(queried.size(), 1) << "Size of the vector returned is invalid";



        mMime = ((C2PortMediaTypeSetting::output*)queried[0].get())->m.value;

        mEos = false;
@@ -84,16 +85,10 @@ class Codec2AudioEncHidlTestBase : public ::testing::Test { 
        mEncoderFrameSize = 0;

        mWorkResult = C2_OK;

        mOutputSize = 0u;

        getInputMaxBufSize();



        c2_status_t status = getChannelCount(&mNumChannels);

        ASSERT_EQ(status, C2_OK) << "Unable to get supported channel count";



        status = getSampleRate(&mSampleRate);

        ASSERT_EQ(status, C2_OK) << "Unable to get supported sample rate";



        status = getSamplesPerFrame(mNumChannels, &mSamplesPerFrame);

        ASSERT_EQ(status, C2_OK) << "Unable to get supported number of samples per frame";

        ASSERT_NO_FATAL_FAILURE(getInputMaxBufSize());

        ASSERT_NO_FATAL_FAILURE(getChannelCount(&mNumChannels));

        ASSERT_NO_FATAL_FAILURE(getSampleRate(&mSampleRate));

        ASSERT_NO_FATAL_FAILURE(getSamplesPerFrame(mNumChannels, &mSamplesPerFrame));



        getFile(mNumChannels, mSampleRate);

    }
@@ -109,9 +104,9 @@ class Codec2AudioEncHidlTestBase : public ::testing::Test { 
    // Get the test parameters from GetParam call.

    virtual void getParams() {}



    c2_status_t getChannelCount(int32_t* nChannels);

    c2_status_t getSampleRate(int32_t* nSampleRate);

    c2_status_t getSamplesPerFrame(int32_t nChannels, int32_t* samplesPerFrame);

    void getChannelCount(int32_t* nChannels);

    void getSampleRate(int32_t* nSampleRate);

    void getSamplesPerFrame(int32_t nChannels, int32_t* samplesPerFrame);



    void getFile(int32_t channelCount, int32_t sampleRate);
@@ -175,21 +170,13 @@ class Codec2AudioEncHidlTestBase : public ::testing::Test { 


    // In encoder components, fetch the size of input buffer allocated

    void getInputMaxBufSize() {

        int32_t bitStreamInfo[1] = {0};

        std::vector<std::unique_ptr<C2Param>> inParams;

        c2_status_t status = mComponent->query({}, {C2StreamMaxBufferSizeInfo::input::PARAM_TYPE},

                                               C2_DONT_BLOCK, &inParams);

        if (status != C2_OK && inParams.size() == 0) {

            ALOGE("Query MaxBufferSizeInfo failed => %d", status);

            ASSERT_TRUE(false);

        } else {

            size_t offset = sizeof(C2Param);

            for (size_t i = 0; i < inParams.size(); ++i) {

                C2Param* param = inParams[i].get();

                bitStreamInfo[i] = *(int32_t*)((uint8_t*)param + offset);

            }

        }

        mInputMaxBufSize = bitStreamInfo[0];

        ASSERT_EQ(status, C2_OK) << "Query max buffer size info failed";

        ASSERT_EQ(inParams.size(), 1) << "Size of the vector returned is invalid";



        mInputMaxBufSize = C2StreamMaxBufferSizeInfo::input::From(inParams[0].get())->value;

    }

};
@@ -245,17 +232,15 @@ bool setupConfigParam(const std::shared_ptr<android::Codec2Client::Component>& c 
    return false;

}



c2_status_t Codec2AudioEncHidlTestBase::getChannelCount(int32_t* nChannels) {

void Codec2AudioEncHidlTestBase::getChannelCount(int32_t* nChannels) {

    std::unique_ptr<C2StreamChannelCountInfo::input> channelCount =

            std::make_unique<C2StreamChannelCountInfo::input>();

    std::vector<C2FieldSupportedValuesQuery> validValueInfos = {

            C2FieldSupportedValuesQuery::Current(

                    C2ParamField(channelCount.get(), &C2StreamChannelCountInfo::value))};

    c2_status_t c2err = mComponent->querySupportedValues(validValueInfos, C2_DONT_BLOCK);

    if (c2err != C2_OK || validValueInfos.size() != 1u) {

        ALOGE("querySupportedValues_vb failed for channelCount");

        return c2err;

    }

    ASSERT_EQ(c2err, C2_OK) << "Query channel count info failed";

    ASSERT_EQ(validValueInfos.size(), 1) << "Size of the vector returned is invalid";



    // setting default value of channelCount

    *nChannels = 1;
@@ -282,48 +267,45 @@ c2_status_t Codec2AudioEncHidlTestBase::getChannelCount(int32_t* nChannels) { 
            break;

        }

        default:

            ASSERT_TRUE(false) << "Unsupported type: " << c2FSV.type;

            break;

    }

    return C2_OK;

    return;

}

c2_status_t Codec2AudioEncHidlTestBase::getSampleRate(int32_t* nSampleRate) {

void Codec2AudioEncHidlTestBase::getSampleRate(int32_t* nSampleRate) {

    // Use the default sample rate for mComponents

    std::vector<std::unique_ptr<C2Param>> queried;

    c2_status_t c2err = mComponent->query({}, {C2StreamSampleRateInfo::input::PARAM_TYPE},

                                          C2_DONT_BLOCK, &queried);

    if (c2err != C2_OK || queried.size() == 0) return c2err;



    size_t offset = sizeof(C2Param);

    C2Param* param = queried[0].get();

    *nSampleRate = *(int32_t*)((uint8_t*)param + offset);

    ASSERT_EQ(c2err, C2_OK) << "Query sample rate info failed";

    ASSERT_EQ(queried.size(), 1) << "Size of the vector returned is invalid";



    return C2_OK;

    *nSampleRate = C2StreamSampleRateInfo::input::From(queried[0].get())->value;

    return;

}



c2_status_t Codec2AudioEncHidlTestBase::getSamplesPerFrame(int32_t nChannels,

                                                           int32_t* samplesPerFrame) {

void Codec2AudioEncHidlTestBase::getSamplesPerFrame(int32_t nChannels, int32_t* samplesPerFrame) {

    std::vector<std::unique_ptr<C2Param>> queried;

    c2_status_t c2err = mComponent->query({}, {C2StreamAudioFrameSizeInfo::input::PARAM_TYPE},

                                          C2_DONT_BLOCK, &queried);

    size_t offset = sizeof(C2Param);

    if (c2err == C2_OK && queried.size()) {

        C2Param* param = queried[0].get();

        mEncoderFrameSize = *(uint32_t*)((uint8_t*)param + offset);



    if (c2err == C2_OK && queried.size() == 1) {

        mEncoderFrameSize = C2StreamAudioFrameSizeInfo::input::From(queried[0].get())->value;

        if (mEncoderFrameSize) {

            *samplesPerFrame = mEncoderFrameSize;

            return C2_OK;

            return;

        }

    }



    c2err = mComponent->query({}, {C2StreamMaxBufferSizeInfo::input::PARAM_TYPE}, C2_DONT_BLOCK,

                              &queried);

    if (c2err != C2_OK || queried.size() == 0) return c2err;

    ASSERT_EQ(c2err, C2_OK) << "Query max buffer size info failed";

    ASSERT_EQ(queried.size(), 1) << "Size of the vector returned is invalid";



    C2Param* param = queried[0].get();

    uint32_t maxInputSize = *(uint32_t*)((uint8_t*)param + offset);

    uint32_t maxInputSize = C2StreamMaxBufferSizeInfo::input::From(queried[0].get())->value;

    *samplesPerFrame = std::min((maxInputSize / (nChannels * 2)), kMaxSamplesPerFrame);



    return C2_OK;

    return;

}



// LookUpTable of clips and metadata for component testing
@@ -619,12 +601,11 @@ TEST_P(Codec2AudioEncHidlTest, MultiChannelCountTest) { 
        std::vector<std::unique_ptr<C2Param>> inParams;

        c2_status_t c2_status = mComponent->query({}, {C2StreamChannelCountInfo::input::PARAM_TYPE},

                                                  C2_DONT_BLOCK, &inParams);

        ASSERT_TRUE(!c2_status && inParams.size())

                << "Query configured channelCount failed => %d" << c2_status;

        ASSERT_EQ(c2_status, C2_OK) << "Query channel count info failed";

        ASSERT_EQ(inParams.size(), 1) << "Size of the vector returned is invalid";



        int32_t channelCount = C2StreamChannelCountInfo::input::From(inParams[0].get())->value;



        size_t offset = sizeof(C2Param);

        C2Param* param = inParams[0].get();

        int32_t channelCount = *(int32_t*)((uint8_t*)param + offset);

        if (channelCount != nChannels) {

            std::cout << "[   WARN   ] Test Skipped for ChannelCount " << nChannels << "\n";

            continue;
@@ -708,13 +689,11 @@ TEST_P(Codec2AudioEncHidlTest, MultiSampleRateTest) { 
        std::vector<std::unique_ptr<C2Param>> inParams;

        c2_status_t c2_status = mComponent->query({}, {C2StreamSampleRateInfo::input::PARAM_TYPE},

                                                  C2_DONT_BLOCK, &inParams);

        ASSERT_EQ(c2_status, C2_OK) << "Query sample rate info failed";

        ASSERT_EQ(inParams.size(), 1) << "Size of the vector returned is invalid";



        ASSERT_TRUE(!c2_status && inParams.size())

                << "Query configured SampleRate failed => %d" << c2_status;

        size_t offset = sizeof(C2Param);

        C2Param* param = inParams[0].get();

        int32_t configuredSampleRate = *(int32_t*)((uint8_t*)param + offset);



        int32_t configuredSampleRate =

                C2StreamSampleRateInfo::input::From(inParams[0].get())->value;

        if (configuredSampleRate != nSampleRate) {

            std::cout << "[   WARN   ] Test Skipped for SampleRate " << nSampleRate << "\n";

            continue;

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

+4 −2
Original line number Diff line number Diff line
@@ -123,8 +123,10 @@ class Codec2VideoDecHidlTestBase : public ::testing::Test { 
        ASSERT_NE(mLinearPool, nullptr);



        std::vector<std::unique_ptr<C2Param>> queried;

        mComponent->query({}, {C2PortMediaTypeSetting::input::PARAM_TYPE}, C2_DONT_BLOCK, &queried);

        ASSERT_GT(queried.size(), 0);

        c2_status_t c2err = mComponent->query({}, {C2PortMediaTypeSetting::input::PARAM_TYPE},

                                              C2_DONT_BLOCK, &queried);

        ASSERT_EQ(c2err, C2_OK) << "Query media type failed";

        ASSERT_EQ(queried.size(), 1) << "Size of the vector returned is invalid";



        mMime = ((C2PortMediaTypeSetting::input*)queried[0].get())->m.value;

        mEos = false;

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

+15 −6
Original line number Diff line number Diff line
@@ -74,9 +74,10 @@ class Codec2VideoEncHidlTestBase : public ::testing::Test { 
        ASSERT_NE(mGraphicPool, nullptr);



        std::vector<std::unique_ptr<C2Param>> queried;

        mComponent->query({}, {C2PortMediaTypeSetting::output::PARAM_TYPE}, C2_DONT_BLOCK,

                          &queried);

        ASSERT_GT(queried.size(), 0);

        c2_status_t c2err = mComponent->query({}, {C2PortMediaTypeSetting::output::PARAM_TYPE},

                                              C2_DONT_BLOCK, &queried);

        ASSERT_EQ(c2err, C2_OK) << "Query media type failed";

        ASSERT_EQ(queried.size(), 1) << "Size of the vector returned is invalid";



        mMime = ((C2PortMediaTypeSetting::output*)queried[0].get())->m.value;

        std::cout << "mime : " << mMime << "\n";
@@ -531,9 +532,17 @@ TEST_P(Codec2VideoEncEncodeTest, EncodeTest) { 
                  << " resetting num BFrames to 0\n";

        mConfigBPictures = false;

    } else {

        size_t offset = sizeof(C2Param);

        C2Param* param = inParams[0].get();

        int32_t numBFrames = *(int32_t*)((uint8_t*)param + offset);

        int32_t numBFrames = 0;

        C2StreamGopTuning::output* gop = C2StreamGopTuning::output::From(inParams[0].get());

        if (gop && gop->flexCount() >= 1) {

            for (size_t i = 0; i < gop->flexCount(); ++i) {

                const C2GopLayerStruct& layer = gop->m.values[i];

                if (layer.type_ == C2Config::picture_type_t(P_FRAME | B_FRAME)) {

                    numBFrames = layer.count;

                    break;

                }

            }

        }



        if (!numBFrames) {

            std::cout << "[   WARN   ] Bframe not supported for " << mComponentName