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

Commit 16334036 authored by Treehugger Robot's avatar Treehugger Robot Committed by Automerger Merge Worker
Browse files

Merge "C2 Vts: renaming dynamic and constant variables" am: 73f67d3e 

Original change: https://android-review.googlesource.com/c/platform/frameworks/av/+/1685965

Change-Id: Iba89bb722fa65c86b342b808e5f69669cfee4813
parents 77f55e21 73f67d3e

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

+18 −18
Original line number Diff line number Diff line
@@ -34,10 +34,10 @@ using android::C2AllocatorIon; 


#include "media_c2_hidl_test_common.h"

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

static std::vector<DecodeTestParameters> kDecodeTestParameters;

static std::vector<DecodeTestParameters> gDecodeTestParameters;



using CsdFlushTestParameters = std::tuple<std::string, std::string, bool>;

static std::vector<CsdFlushTestParameters> kCsdFlushTestParameters;

static std::vector<CsdFlushTestParameters> gCsdFlushTestParameters;



struct CompToURL {

    std::string mime;
@@ -45,7 +45,7 @@ struct CompToURL { 
    std::string info;

};



std::vector<CompToURL> kCompToURL = {

std::vector<CompToURL> gCompToURL = {

        {"mp4a-latm", "bbb_aac_stereo_128kbps_48000hz.aac", "bbb_aac_stereo_128kbps_48000hz.info"},

        {"mp4a-latm", "bbb_aac_stereo_128kbps_48000hz.aac",

         "bbb_aac_stereo_128kbps_48000hz_multi_frame.info"},
@@ -290,11 +290,11 @@ void getInputChannelInfo(const std::shared_ptr<android::Codec2Client::Component> 
// LookUpTable of clips and metadata for component testing

void Codec2AudioDecHidlTestBase::GetURLForComponent(char* mURL, char* info, size_t streamIndex) {

    int streamCount = 0;

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

        if (mMime.find(kCompToURL[i].mime) != std::string::npos) {

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

        if (mMime.find(gCompToURL[i].mime) != std::string::npos) {

            if (streamCount == streamIndex) {

                strcat(mURL, kCompToURL[i].mURL.c_str());

                strcat(info, kCompToURL[i].info.c_str());

                strcat(mURL, gCompToURL[i].mURL.c_str());

                strcat(info, gCompToURL[i].info.c_str());

                return;

            }

            streamCount++;
@@ -859,36 +859,36 @@ TEST_P(Codec2AudioDecCsdInputTests, CSDFlushTest) { 
    ASSERT_EQ(mComponent->stop(), C2_OK);

}



INSTANTIATE_TEST_SUITE_P(PerInstance, Codec2AudioDecHidlTest, testing::ValuesIn(kTestParameters),

INSTANTIATE_TEST_SUITE_P(PerInstance, Codec2AudioDecHidlTest, testing::ValuesIn(gTestParameters),

                         PrintInstanceTupleNameToString<>);



// DecodeTest with StreamIndex and EOS / No EOS

INSTANTIATE_TEST_SUITE_P(StreamIndexAndEOS, Codec2AudioDecDecodeTest,

                         testing::ValuesIn(kDecodeTestParameters),

                         testing::ValuesIn(gDecodeTestParameters),

                         PrintInstanceTupleNameToString<>);



INSTANTIATE_TEST_SUITE_P(CsdInputs, Codec2AudioDecCsdInputTests,

                         testing::ValuesIn(kCsdFlushTestParameters),

                         testing::ValuesIn(gCsdFlushTestParameters),

                         PrintInstanceTupleNameToString<>);



}  // anonymous namespace



int main(int argc, char** argv) {

    parseArgs(argc, argv);

    kTestParameters = getTestParameters(C2Component::DOMAIN_AUDIO, C2Component::KIND_DECODER);

    for (auto params : kTestParameters) {

        kDecodeTestParameters.push_back(

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

    for (auto params : gTestParameters) {

        gDecodeTestParameters.push_back(

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

        kDecodeTestParameters.push_back(

        gDecodeTestParameters.push_back(

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

        kDecodeTestParameters.push_back(

        gDecodeTestParameters.push_back(

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

        kDecodeTestParameters.push_back(

        gDecodeTestParameters.push_back(

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



        kCsdFlushTestParameters.push_back(

        gCsdFlushTestParameters.push_back(

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

        kCsdFlushTestParameters.push_back(

        gCsdFlushTestParameters.push_back(

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

    }

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

+9 −9
Original line number Diff line number Diff line
@@ -37,7 +37,7 @@ using android::C2AllocatorIon; 


using EncodeTestParameters = std::tuple<std::string, std::string, bool, int32_t>;



static std::vector<EncodeTestParameters> kEncodeTestParameters;

static std::vector<EncodeTestParameters> gEncodeTestParameters;



class LinearBuffer : public C2Buffer {

  public:
@@ -748,28 +748,28 @@ TEST_P(Codec2AudioEncHidlTest, MultiSampleRateTest) { 
    }

}



INSTANTIATE_TEST_SUITE_P(PerInstance, Codec2AudioEncHidlTest, testing::ValuesIn(kTestParameters),

INSTANTIATE_TEST_SUITE_P(PerInstance, Codec2AudioEncHidlTest, testing::ValuesIn(gTestParameters),

                         PrintInstanceTupleNameToString<>);



// EncodeTest with EOS / No EOS and inputMaxBufRatio

// inputMaxBufRatio is ratio w.r.t. to mInputMaxBufSize

INSTANTIATE_TEST_SUITE_P(EncodeTest, Codec2AudioEncEncodeTest,

                         testing::ValuesIn(kEncodeTestParameters),

                         testing::ValuesIn(gEncodeTestParameters),

                         PrintInstanceTupleNameToString<>);



}  // anonymous namespace



int main(int argc, char** argv) {

    parseArgs(argc, argv);

    kTestParameters = getTestParameters(C2Component::DOMAIN_AUDIO, C2Component::KIND_ENCODER);

    for (auto params : kTestParameters) {

        kEncodeTestParameters.push_back(

    gTestParameters = getTestParameters(C2Component::DOMAIN_AUDIO, C2Component::KIND_ENCODER);

    for (auto params : gTestParameters) {

        gEncodeTestParameters.push_back(

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

        kEncodeTestParameters.push_back(

        gEncodeTestParameters.push_back(

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

        kEncodeTestParameters.push_back(

        gEncodeTestParameters.push_back(

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

        kEncodeTestParameters.push_back(

        gEncodeTestParameters.push_back(

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

    }

media/codec2/hidl/1.0/vts/functional/common/media_c2_hidl_test_common.h

+1 −1
Original line number Diff line number Diff line
@@ -41,7 +41,7 @@ using ::android::hardware::Void; 
using namespace ::std::chrono;



using TestParameters = std::tuple<std::string, std::string>;

static std::vector<TestParameters> kTestParameters;

static std::vector<TestParameters> gTestParameters;



// Resource directory

extern std::string sResourceDir;

media/codec2/hidl/1.0/vts/functional/component/VtsHalMediaC2V1_0TargetComponentTest.cpp

+10 −10
Original line number Diff line number Diff line
@@ -54,7 +54,7 @@ 


namespace {

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

static std::vector<InputTestParameters> kInputTestParameters;

static std::vector<InputTestParameters> gInputTestParameters;



// google.codec2 Component test setup

class Codec2ComponentHidlTestBase : public ::testing::Test {
@@ -345,28 +345,28 @@ TEST_P(Codec2ComponentInputTests, InputBufferTest) { 
    ASSERT_EQ(mComponent->reset(), C2_OK);

}



INSTANTIATE_TEST_SUITE_P(PerInstance, Codec2ComponentHidlTest, testing::ValuesIn(kTestParameters),

INSTANTIATE_TEST_SUITE_P(PerInstance, Codec2ComponentHidlTest, testing::ValuesIn(gTestParameters),

                         PrintInstanceTupleNameToString<>);



INSTANTIATE_TEST_CASE_P(NonStdInputs, Codec2ComponentInputTests,

                        testing::ValuesIn(kInputTestParameters), PrintInstanceTupleNameToString<>);

                        testing::ValuesIn(gInputTestParameters), PrintInstanceTupleNameToString<>);

}  // anonymous namespace



// TODO: Add test for Invalid work,

// TODO: Add test for Invalid states

int main(int argc, char** argv) {

    parseArgs(argc, argv);

    kTestParameters = getTestParameters();

    for (auto params : kTestParameters) {

        kInputTestParameters.push_back(

    gTestParameters = getTestParameters();

    for (auto params : gTestParameters) {

        gInputTestParameters.push_back(

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

        kInputTestParameters.push_back(std::make_tuple(std::get<0>(params), std::get<1>(params),

        gInputTestParameters.push_back(std::make_tuple(std::get<0>(params), std::get<1>(params),

                                                       C2FrameData::FLAG_END_OF_STREAM, true));

        kInputTestParameters.push_back(

        gInputTestParameters.push_back(

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

        kInputTestParameters.push_back(std::make_tuple(std::get<0>(params), std::get<1>(params),

        gInputTestParameters.push_back(std::make_tuple(std::get<0>(params), std::get<1>(params),

                                                       C2FrameData::FLAG_CODEC_CONFIG, false));

        kInputTestParameters.push_back(std::make_tuple(std::get<0>(params), std::get<1>(params),

        gInputTestParameters.push_back(std::make_tuple(std::get<0>(params), std::get<1>(params),

                                                       C2FrameData::FLAG_END_OF_STREAM, false));

    }

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

+21 −21
Original line number Diff line number Diff line
@@ -41,10 +41,10 @@ using android::C2AllocatorIon; 
#include "media_c2_video_hidl_test_common.h"



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

static std::vector<DecodeTestParameters> kDecodeTestParameters;

static std::vector<DecodeTestParameters> gDecodeTestParameters;



using CsdFlushTestParameters = std::tuple<std::string, std::string, bool>;

static std::vector<CsdFlushTestParameters> kCsdFlushTestParameters;

static std::vector<CsdFlushTestParameters> gCsdFlushTestParameters;



struct CompToURL {

    std::string mime;
@@ -52,7 +52,7 @@ struct CompToURL { 
    std::string info;

    std::string chksum;

};

std::vector<CompToURL> kCompToURL = {

std::vector<CompToURL> gCompToURL = {

        {"avc", "bbb_avc_176x144_300kbps_60fps.h264", "bbb_avc_176x144_300kbps_60fps.info",

         "bbb_avc_176x144_300kbps_60fps_chksum.md5"},

        {"avc", "bbb_avc_640x360_768kbps_30fps.h264", "bbb_avc_640x360_768kbps_30fps.info",
@@ -365,12 +365,12 @@ void validateComponent(const std::shared_ptr<android::Codec2Client::Component>& 
void Codec2VideoDecHidlTestBase::GetURLChksmForComponent(char* mURL, char* info, char* chksum,

                                                         size_t streamIndex) {

    int streamCount = 0;

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

        if (mMime.find(kCompToURL[i].mime) != std::string::npos) {

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

        if (mMime.find(gCompToURL[i].mime) != std::string::npos) {

            if (streamCount == streamIndex) {

                strcat(mURL, kCompToURL[i].mURL.c_str());

                strcat(info, kCompToURL[i].info.c_str());

                strcat(chksum, kCompToURL[i].chksum.c_str());

                strcat(mURL, gCompToURL[i].mURL.c_str());

                strcat(info, gCompToURL[i].info.c_str());

                strcat(chksum, gCompToURL[i].chksum.c_str());

                return;

            }

            streamCount++;
@@ -1074,16 +1074,16 @@ TEST_P(Codec2VideoDecCsdInputTests, CSDFlushTest) { 
    ASSERT_EQ(mComponent->stop(), C2_OK);

}



INSTANTIATE_TEST_SUITE_P(PerInstance, Codec2VideoDecHidlTest, testing::ValuesIn(kTestParameters),

INSTANTIATE_TEST_SUITE_P(PerInstance, Codec2VideoDecHidlTest, testing::ValuesIn(gTestParameters),

                         PrintInstanceTupleNameToString<>);



// DecodeTest with StreamIndex and EOS / No EOS

INSTANTIATE_TEST_SUITE_P(StreamIndexAndEOS, Codec2VideoDecDecodeTest,

                         testing::ValuesIn(kDecodeTestParameters),

                         testing::ValuesIn(gDecodeTestParameters),

                         PrintInstanceTupleNameToString<>);



INSTANTIATE_TEST_SUITE_P(CsdInputs, Codec2VideoDecCsdInputTests,

                         testing::ValuesIn(kCsdFlushTestParameters),

                         testing::ValuesIn(gCsdFlushTestParameters),

                         PrintInstanceTupleNameToString<>);



}  // anonymous namespace
@@ -1091,24 +1091,24 @@ INSTANTIATE_TEST_SUITE_P(CsdInputs, Codec2VideoDecCsdInputTests, 
// TODO : Video specific configuration Test

int main(int argc, char** argv) {

    parseArgs(argc, argv);

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

    for (auto params : kTestParameters) {

        kDecodeTestParameters.push_back(

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

    for (auto params : gTestParameters) {

        gDecodeTestParameters.push_back(

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

        kDecodeTestParameters.push_back(

        gDecodeTestParameters.push_back(

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

        kDecodeTestParameters.push_back(

        gDecodeTestParameters.push_back(

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

        kDecodeTestParameters.push_back(

        gDecodeTestParameters.push_back(

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

        kDecodeTestParameters.push_back(

        gDecodeTestParameters.push_back(

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

        kDecodeTestParameters.push_back(

        gDecodeTestParameters.push_back(

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



        kCsdFlushTestParameters.push_back(

        gCsdFlushTestParameters.push_back(

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

        kCsdFlushTestParameters.push_back(

        gCsdFlushTestParameters.push_back(

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

    }