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

Commit 1da59af9 authored by Sungtak Lee's avatar Sungtak Lee Committed by Automerger Merge Worker
Browse files

Merge "Vts: refactor decoder code" am: 59cbb536

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

Change-Id: Ifd75ea109f502e028efe015cf09c57e59533645c
parents c2da7da1 59cbb536
Loading
Loading
Loading
Loading
+86 −145
Original line number Diff line number Diff line
@@ -42,6 +42,45 @@ static std::vector<std::tuple<std::string, std::string, std::string>> kCsdFlushT
// Resource directory
static std::string sResourceDir = "";

struct CompToURL {
    std::string mime;
    std::string mURL;
    std::string info;
};

std::vector<CompToURL> kCompToURL = {
    {"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"},
    {"audio/mpeg",
     "bbb_mp3_stereo_192kbps_48000hz.mp3", "bbb_mp3_stereo_192kbps_48000hz.info"},
    {"audio/mpeg",
     "bbb_mp3_stereo_192kbps_48000hz.mp3", "bbb_mp3_stereo_192kbps_48000hz_multi_frame.info"},
    {"3gpp",
     "sine_amrnb_1ch_12kbps_8000hz.amrnb", "sine_amrnb_1ch_12kbps_8000hz.info"},
    {"3gpp",
     "sine_amrnb_1ch_12kbps_8000hz.amrnb", "sine_amrnb_1ch_12kbps_8000hz_multi_frame.info"},
    {"amr-wb",
     "bbb_amrwb_1ch_14kbps_16000hz.amrwb", "bbb_amrwb_1ch_14kbps_16000hz.info"},
    {"amr-wb",
     "bbb_amrwb_1ch_14kbps_16000hz.amrwb", "bbb_amrwb_1ch_14kbps_16000hz_multi_frame.info"},
    {"vorbis",
     "bbb_vorbis_stereo_128kbps_48000hz.vorbis", "bbb_vorbis_stereo_128kbps_48000hz.info"},
    {"opus",
     "bbb_opus_stereo_128kbps_48000hz.opus", "bbb_opus_stereo_128kbps_48000hz.info"},
    {"g711-alaw",
     "bbb_g711alaw_1ch_8khz.raw", "bbb_g711alaw_1ch_8khz.info"},
    {"g711-mlaw",
     "bbb_g711mulaw_1ch_8khz.raw", "bbb_g711mulaw_1ch_8khz.info"},
    {"gsm",
     "bbb_gsm_1ch_8khz_13kbps.raw", "bbb_gsm_1ch_8khz_13kbps.info"},
    {"raw",
     "bbb_raw_1ch_8khz_s32le.raw", "bbb_raw_1ch_8khz_s32le.info"},
    {"flac",
     "bbb_flac_stereo_680kbps_48000hz.flac", "bbb_flac_stereo_680kbps_48000hz.info"},
};

class LinearBuffer : public C2Buffer {
  public:
    explicit LinearBuffer(const std::shared_ptr<C2LinearBlock>& block)
@@ -76,33 +115,17 @@ class Codec2AudioDecHidlTestBase : public ::testing::Test {
        mLinearPool = std::make_shared<C2PooledBlockPool>(mLinearAllocator, mBlockPoolId++);
        ASSERT_NE(mLinearPool, nullptr);

        mCompName = unknown_comp;
        struct StringToName {
            const char* Name;
            standardComp CompName;
        };
        const StringToName kStringToName[] = {
                {"xaac", xaac},          {"mp3", mp3}, {"amrnb", amrnb},
                {"amrwb", amrwb},        {"aac", aac}, {"vorbis", vorbis},
                {"opus", opus},          {"pcm", pcm}, {"g711.alaw", g711alaw},
                {"g711.mlaw", g711mlaw}, {"gsm", gsm}, {"raw", raw},
                {"flac", flac},
        };
        const size_t kNumStringToName = sizeof(kStringToName) / sizeof(kStringToName[0]);
        std::vector<std::unique_ptr<C2Param>> queried;
        mComponent->query({}, {C2PortMediaTypeSetting::input::PARAM_TYPE}, C2_DONT_BLOCK, &queried);
        ASSERT_GT(queried.size(), 0);

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

        // Find the component type
        for (size_t i = 0; i < kNumStringToName; ++i) {
            if (strcasestr(mComponentName.c_str(), kStringToName[i].Name)) {
                mCompName = kStringToName[i].CompName;
                break;
            }
        }
        mEos = false;
        mFramesReceived = 0;
        mTimestampUs = 0u;
        mWorkResult = C2_OK;
        mTimestampDevTest = false;
        if (mCompName == unknown_comp) mDisableTest = true;
        if (mDisableTest) std::cout << "[   WARN   ] Test Disabled \n";
    }

@@ -119,6 +142,8 @@ class Codec2AudioDecHidlTestBase : public ::testing::Test {

    virtual void validateTimestampList(int32_t* bitStreamInfo);

    void GetURLForComponent(char* mURL, char* info, size_t streamIndex = 0);

    struct outputMetaData {
        uint64_t timestampUs;
        uint32_t rangeLength;
@@ -158,29 +183,12 @@ class Codec2AudioDecHidlTestBase : public ::testing::Test {
        }
    }

    enum standardComp {
        xaac,
        mp3,
        amrnb,
        amrwb,
        aac,
        vorbis,
        opus,
        pcm,
        g711alaw,
        g711mlaw,
        gsm,
        raw,
        flac,
        unknown_comp,
    };

    std::string mMime;
    std::string mInstanceName;
    std::string mComponentName;
    bool mEos;
    bool mDisableTest;
    bool mTimestampDevTest;
    standardComp mCompName;

    int32_t mWorkResult;
    uint64_t mTimestampUs;
@@ -217,7 +225,7 @@ class Codec2AudioDecHidlTest
};

void validateComponent(const std::shared_ptr<android::Codec2Client::Component>& component,
                       Codec2AudioDecHidlTest::standardComp compName, bool& disableTest) {
                       bool& disableTest) {
    // Validate its a C2 Component
    if (component->getName().find("c2") == std::string::npos) {
        ALOGE("Not a c2 component");
@@ -244,13 +252,6 @@ void validateComponent(const std::shared_ptr<android::Codec2Client::Component>&
            return;
        }
    }

    // Validates component name
    if (compName == Codec2AudioDecHidlTest::unknown_comp) {
        ALOGE("Component InValid");
        disableTest = true;
        return;
    }
    ALOGV("Component Valid");
}

@@ -271,7 +272,7 @@ bool setupConfigParam(const std::shared_ptr<android::Codec2Client::Component>& c
// parsing the header of elementary stream. Client needs to collect this
// information and reconfigure
void getInputChannelInfo(const std::shared_ptr<android::Codec2Client::Component>& component,
                         Codec2AudioDecHidlTest::standardComp compName, int32_t* bitStreamInfo) {
                         std::string mime, int32_t* bitStreamInfo) {
    // query nSampleRate and nChannels
    std::initializer_list<C2Param::Index> indices{
            C2StreamSampleRateInfo::output::PARAM_TYPE,
@@ -288,90 +289,30 @@ void getInputChannelInfo(const std::shared_ptr<android::Codec2Client::Component>
            C2Param* param = inParams[i].get();
            bitStreamInfo[i] = *(int32_t*)((uint8_t*)param + offset);
        }
        switch (compName) {
            case Codec2AudioDecHidlTest::amrnb: {
        if (mime.find("3gpp") != std::string::npos) {
            ASSERT_EQ(bitStreamInfo[0], 8000);
            ASSERT_EQ(bitStreamInfo[1], 1);
                break;
            }
            case Codec2AudioDecHidlTest::amrwb: {
        } else if (mime.find("amr-wb") != std::string::npos) {
            ASSERT_EQ(bitStreamInfo[0], 16000);
            ASSERT_EQ(bitStreamInfo[1], 1);
                break;
            }
            case Codec2AudioDecHidlTest::gsm: {
        } else if (mime.find("gsm") != std::string::npos) {
            ASSERT_EQ(bitStreamInfo[0], 8000);
                break;
            }
            default:
                break;
        }
    }
}

// number of elementary streams per component
#define STREAM_COUNT 2

// LookUpTable of clips and metadata for component testing
void GetURLForComponent(Codec2AudioDecHidlTest::standardComp comp, char* mURL, char* info,
                        size_t streamIndex = 0) {
    struct CompToURL {
        Codec2AudioDecHidlTest::standardComp comp;
        const char mURL[STREAM_COUNT][512];
        const char info[STREAM_COUNT][512];
    };
    ASSERT_TRUE(streamIndex < STREAM_COUNT);

    static const CompToURL kCompToURL[] = {
            {Codec2AudioDecHidlTest::standardComp::xaac,
             {"bbb_aac_stereo_128kbps_48000hz.aac", "bbb_aac_stereo_128kbps_48000hz.aac"},
             {"bbb_aac_stereo_128kbps_48000hz.info",
              "bbb_aac_stereo_128kbps_48000hz_multi_frame.info"}},
            {Codec2AudioDecHidlTest::standardComp::mp3,
             {"bbb_mp3_stereo_192kbps_48000hz.mp3", "bbb_mp3_stereo_192kbps_48000hz.mp3"},
             {"bbb_mp3_stereo_192kbps_48000hz.info",
              "bbb_mp3_stereo_192kbps_48000hz_multi_frame.info"}},
            {Codec2AudioDecHidlTest::standardComp::aac,
             {"bbb_aac_stereo_128kbps_48000hz.aac", "bbb_aac_stereo_128kbps_48000hz.aac"},
             {"bbb_aac_stereo_128kbps_48000hz.info",
              "bbb_aac_stereo_128kbps_48000hz_multi_frame.info"}},
            {Codec2AudioDecHidlTest::standardComp::amrnb,
             {"sine_amrnb_1ch_12kbps_8000hz.amrnb", "sine_amrnb_1ch_12kbps_8000hz.amrnb"},
             {"sine_amrnb_1ch_12kbps_8000hz.info",
              "sine_amrnb_1ch_12kbps_8000hz_multi_frame.info"}},
            {Codec2AudioDecHidlTest::standardComp::amrwb,
             {"bbb_amrwb_1ch_14kbps_16000hz.amrwb", "bbb_amrwb_1ch_14kbps_16000hz.amrwb"},
             {"bbb_amrwb_1ch_14kbps_16000hz.info",
              "bbb_amrwb_1ch_14kbps_16000hz_multi_frame.info"}},
            {Codec2AudioDecHidlTest::standardComp::vorbis,
             {"bbb_vorbis_stereo_128kbps_48000hz.vorbis", ""},
             {"bbb_vorbis_stereo_128kbps_48000hz.info", ""}},
            {Codec2AudioDecHidlTest::standardComp::opus,
             {"bbb_opus_stereo_128kbps_48000hz.opus", ""},
             {"bbb_opus_stereo_128kbps_48000hz.info", ""}},
            {Codec2AudioDecHidlTest::standardComp::g711alaw,
             {"bbb_g711alaw_1ch_8khz.raw", ""},
             {"bbb_g711alaw_1ch_8khz.info", ""}},
            {Codec2AudioDecHidlTest::standardComp::g711mlaw,
             {"bbb_g711mulaw_1ch_8khz.raw", ""},
             {"bbb_g711mulaw_1ch_8khz.info", ""}},
            {Codec2AudioDecHidlTest::standardComp::gsm,
             {"bbb_gsm_1ch_8khz_13kbps.raw", ""},
             {"bbb_gsm_1ch_8khz_13kbps.info", ""}},
            {Codec2AudioDecHidlTest::standardComp::raw,
             {"bbb_raw_1ch_8khz_s32le.raw", ""},
             {"bbb_raw_1ch_8khz_s32le.info", ""}},
            {Codec2AudioDecHidlTest::standardComp::flac,
             {"bbb_flac_stereo_680kbps_48000hz.flac", ""},
             {"bbb_flac_stereo_680kbps_48000hz.info", ""}},
    };

    for (size_t i = 0; i < sizeof(kCompToURL) / sizeof(kCompToURL[0]); ++i) {
        if (kCompToURL[i].comp == comp) {
            strcat(mURL, kCompToURL[i].mURL[streamIndex]);
            strcat(info, kCompToURL[i].info[streamIndex]);
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) {
            if (streamCount == streamIndex) {
                strcat(mURL, kCompToURL[i].mURL.c_str());
                strcat(info, kCompToURL[i].info.c_str());
                return;
            }
            streamCount++;
        }
    }
}

@@ -461,7 +402,7 @@ void decodeNFrames(const std::shared_ptr<android::Codec2Client::Component>& comp
void Codec2AudioDecHidlTestBase::validateTimestampList(int32_t* bitStreamInfo) {
    uint32_t samplesReceived = 0;
    // Update SampleRate and ChannelCount
    ASSERT_NO_FATAL_FAILURE(getInputChannelInfo(mComponent, mCompName, bitStreamInfo));
    ASSERT_NO_FATAL_FAILURE(getInputChannelInfo(mComponent, mMime, bitStreamInfo));
    int32_t nSampleRate = bitStreamInfo[0];
    int32_t nChannels = bitStreamInfo[1];
    std::list<uint64_t>::iterator itIn = mTimestampUslist.begin();
@@ -486,7 +427,7 @@ void Codec2AudioDecHidlTestBase::validateTimestampList(int32_t* bitStreamInfo) {
TEST_P(Codec2AudioDecHidlTest, validateCompName) {
    if (mDisableTest) GTEST_SKIP() << "Test is disabled";
    ALOGV("Checks if the given component is a valid audio component");
    validateComponent(mComponent, mCompName, mDisableTest);
    validateComponent(mComponent, mDisableTest);
    ASSERT_EQ(mDisableTest, false);
}

@@ -495,7 +436,7 @@ TEST_P(Codec2AudioDecHidlTest, configComp) {
    if (mDisableTest) GTEST_SKIP() << "Test is disabled";
    ASSERT_EQ(mComponent->start(), C2_OK);
    int32_t bitStreamInfo[2] = {0};
    ASSERT_NO_FATAL_FAILURE(getInputChannelInfo(mComponent, mCompName, bitStreamInfo));
    ASSERT_NO_FATAL_FAILURE(getInputChannelInfo(mComponent, mMime, bitStreamInfo));
    setupConfigParam(mComponent, bitStreamInfo);
    ASSERT_EQ(mComponent->stop(), C2_OK);
}
@@ -523,7 +464,7 @@ TEST_P(Codec2AudioDecDecodeTest, DecodeTest) {

    strcpy(mURL, sResourceDir.c_str());
    strcpy(info, sResourceDir.c_str());
    GetURLForComponent(mCompName, mURL, info, streamIndex);
    GetURLForComponent(mURL, info, streamIndex);
    if (!strcmp(mURL, sResourceDir.c_str())) {
        ALOGV("EMPTY INPUT sResourceDir.c_str() %s mURL  %s ", sResourceDir.c_str(), mURL);
        return;
@@ -536,11 +477,11 @@ TEST_P(Codec2AudioDecDecodeTest, DecodeTest) {
    mFramesReceived = 0;
    mTimestampUs = 0;
    int32_t bitStreamInfo[2] = {0};
    if (mCompName == raw) {
    if (mMime.find("raw") != std::string::npos) {
        bitStreamInfo[0] = 8000;
        bitStreamInfo[1] = 1;
    } else {
        ASSERT_NO_FATAL_FAILURE(getInputChannelInfo(mComponent, mCompName, bitStreamInfo));
        ASSERT_NO_FATAL_FAILURE(getInputChannelInfo(mComponent, mMime, bitStreamInfo));
    }
    if (!setupConfigParam(mComponent, bitStreamInfo)) {
        std::cout << "[   WARN   ] Test Skipped \n";
@@ -591,17 +532,17 @@ TEST_P(Codec2AudioDecHidlTest, ThumbnailTest) {

    strcpy(mURL, sResourceDir.c_str());
    strcpy(info, sResourceDir.c_str());
    GetURLForComponent(mCompName, mURL, info);
    GetURLForComponent(mURL, info);

    int32_t numCsds = populateInfoVector(info, &Info, mTimestampDevTest, &mTimestampUslist);
    ASSERT_GE(numCsds, 0) << "Error in parsing input info file: " << info;

    int32_t bitStreamInfo[2] = {0};
    if (mCompName == raw) {
    if (mMime.find("raw") != std::string::npos) {
        bitStreamInfo[0] = 8000;
        bitStreamInfo[1] = 1;
    } else {
        ASSERT_NO_FATAL_FAILURE(getInputChannelInfo(mComponent, mCompName, bitStreamInfo));
        ASSERT_NO_FATAL_FAILURE(getInputChannelInfo(mComponent, mMime, bitStreamInfo));
    }
    if (!setupConfigParam(mComponent, bitStreamInfo)) {
        std::cout << "[   WARN   ] Test Skipped \n";
@@ -683,17 +624,17 @@ TEST_P(Codec2AudioDecHidlTest, FlushTest) {

    strcpy(mURL, sResourceDir.c_str());
    strcpy(info, sResourceDir.c_str());
    GetURLForComponent(mCompName, mURL, info);
    GetURLForComponent(mURL, info);

    int32_t numCsds = populateInfoVector(info, &Info, mTimestampDevTest, &mTimestampUslist);
    ASSERT_GE(numCsds, 0) << "Error in parsing input info file: " << info;

    int32_t bitStreamInfo[2] = {0};
    if (mCompName == raw) {
    if (mMime.find("raw") != std::string::npos) {
        bitStreamInfo[0] = 8000;
        bitStreamInfo[1] = 1;
    } else {
        ASSERT_NO_FATAL_FAILURE(getInputChannelInfo(mComponent, mCompName, bitStreamInfo));
        ASSERT_NO_FATAL_FAILURE(getInputChannelInfo(mComponent, mMime, bitStreamInfo));
    }
    if (!setupConfigParam(mComponent, bitStreamInfo)) {
        std::cout << "[   WARN   ] Test Skipped \n";
@@ -768,7 +709,7 @@ TEST_P(Codec2AudioDecHidlTest, DecodeTestEmptyBuffersInserted) {

    strcpy(mURL, sResourceDir.c_str());
    strcpy(info, sResourceDir.c_str());
    GetURLForComponent(mCompName, mURL, info);
    GetURLForComponent(mURL, info);

    eleInfo.open(info);
    ASSERT_EQ(eleInfo.is_open(), true) << mURL << " - file not found";
@@ -798,11 +739,11 @@ TEST_P(Codec2AudioDecHidlTest, DecodeTestEmptyBuffersInserted) {
    }
    eleInfo.close();
    int32_t bitStreamInfo[2] = {0};
    if (mCompName == raw) {
    if (mMime.find("raw") != std::string::npos) {
        bitStreamInfo[0] = 8000;
        bitStreamInfo[1] = 1;
    } else {
        ASSERT_NO_FATAL_FAILURE(getInputChannelInfo(mComponent, mCompName, bitStreamInfo));
        ASSERT_NO_FATAL_FAILURE(getInputChannelInfo(mComponent, mMime, bitStreamInfo));
    }
    if (!setupConfigParam(mComponent, bitStreamInfo)) {
        std::cout << "[   WARN   ] Test Skipped \n";
@@ -853,7 +794,7 @@ TEST_P(Codec2AudioDecCsdInputTests, CSDFlushTest) {

    strcpy(mURL, sResourceDir.c_str());
    strcpy(info, sResourceDir.c_str());
    GetURLForComponent(mCompName, mURL, info);
    GetURLForComponent(mURL, info);
    if (!strcmp(mURL, sResourceDir.c_str())) {
        ALOGV("EMPTY INPUT sResourceDir.c_str() %s mURL  %s ", sResourceDir.c_str(), mURL);
        return;
@@ -864,11 +805,11 @@ TEST_P(Codec2AudioDecCsdInputTests, CSDFlushTest) {
    ASSERT_GE(numCsds, 0) << "Error in parsing input info file";

    int32_t bitStreamInfo[2] = {0};
    if (mCompName == raw) {
    if (mMime.find("raw") != std::string::npos) {
        bitStreamInfo[0] = 8000;
        bitStreamInfo[1] = 1;
    } else {
        ASSERT_NO_FATAL_FAILURE(getInputChannelInfo(mComponent, mCompName, bitStreamInfo));
        ASSERT_NO_FATAL_FAILURE(getInputChannelInfo(mComponent, mMime, bitStreamInfo));
    }
    if (!setupConfigParam(mComponent, bitStreamInfo)) {
        std::cout << "[   WARN   ] Test Skipped \n";
+80 −108

File changed.

Preview size limit exceeded, changes collapsed.