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

Commit e9aa8459 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 am: 16334036

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

Change-Id: Icdba80e996d0aa4716abce9062eb101e7a781c17
parents 084f176d 16334036
Loading
Loading
Loading
Loading
+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));
    }

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

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

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

Loading