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

Commit c93f14a2 authored by TreeHugger Robot's avatar TreeHugger Robot Committed by Automerger Merge Worker
Browse files

Merge changes from topic "aosp-ittiam" into sc-dev am: 233a22e1 

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

Change-Id: I3d814ebe181754fae9eceb60aca5a141038d4d9e
parents adc46cce 233a22e1

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

+43 −64
Original line number Diff line number Diff line
@@ -36,13 +36,13 @@ static std::vector<DecodeTestParameters> gDecodeTestParameters; 
using CsdFlushTestParameters = std::tuple<std::string, std::string, bool>;

static std::vector<CsdFlushTestParameters> gCsdFlushTestParameters;



struct CompToURL {

struct CompToFiles {

    std::string mime;

    std::string mURL;

    std::string info;

    std::string inputFile;

    std::string infoFile;

};



std::vector<CompToURL> gCompToURL = {

std::vector<CompToFiles> gCompToFiles = {

        {"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"},
@@ -110,6 +110,15 @@ class Codec2AudioDecHidlTestBase : public ::testing::Test { 
        mTimestampUs = 0u;

        mWorkResult = C2_OK;

        mTimestampDevTest = false;



        bool valid = getFileNames(mStreamIndex);

        if (!valid) {

            GTEST_SKIP() << "No test file for  mime " << mMime << " index: " << mStreamIndex;

        }

        ALOGV("mStreamIndex : %zu", mStreamIndex);

        ALOGV("mInputFile : %s", mInputFile.c_str());

        ALOGV("mInfoFile : %s", mInfoFile.c_str());



        if (mDisableTest) std::cout << "[   WARN   ] Test Disabled \n";

    }
@@ -126,7 +135,7 @@ class Codec2AudioDecHidlTestBase : public ::testing::Test { 


    virtual void validateTimestampList(int32_t* bitStreamInfo);



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

    bool getFileNames(size_t streamIndex = 0);



    struct outputMetaData {

        uint64_t timestampUs;
@@ -193,6 +202,10 @@ class Codec2AudioDecHidlTestBase : public ::testing::Test { 
    std::shared_ptr<android::Codec2Client::Listener> mListener;

    std::shared_ptr<android::Codec2Client::Component> mComponent;



    std::string mInputFile;

    std::string mInfoFile;

    size_t mStreamIndex = 0;



  protected:

    static void description(const std::string& description) {

        RecordProperty("description", description);
@@ -204,6 +217,7 @@ class Codec2AudioDecHidlTest : public Codec2AudioDecHidlTestBase, 
    void getParams() {

        mInstanceName = std::get<0>(GetParam());

        mComponentName = std::get<1>(GetParam());

        mStreamIndex = 0;

    }

};
@@ -285,18 +299,20 @@ 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) {

bool Codec2AudioDecHidlTestBase::getFileNames(size_t streamIndex) {

    int streamCount = 0;

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

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



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

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

            if (streamCount == streamIndex) {

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

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

                return;

                mInputFile = sResourceDir + gCompToFiles[i].inputFile;

                mInfoFile = sResourceDir + gCompToFiles[i].infoFile;

                return true;

            }

            streamCount++;

        }

    }

    return false;

}



void decodeNFrames(const std::shared_ptr<android::Codec2Client::Component>& component,
@@ -429,6 +445,7 @@ class Codec2AudioDecDecodeTest : public Codec2AudioDecHidlTestBase, 
    void getParams() {

        mInstanceName = std::get<0>(GetParam());

        mComponentName = std::get<1>(GetParam());

        mStreamIndex = std::get<2>(GetParam());

    }

};
@@ -436,22 +453,12 @@ TEST_P(Codec2AudioDecDecodeTest, DecodeTest) { 
    description("Decodes input file");

    if (mDisableTest) GTEST_SKIP() << "Test is disabled";



    uint32_t streamIndex = std::get<2>(GetParam());

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

    mTimestampDevTest = true;

    char mURL[512], info[512];

    android::Vector<FrameInfo> Info;



    strcpy(mURL, sResourceDir.c_str());

    strcpy(info, sResourceDir.c_str());

    GetURLForComponent(mURL, info, streamIndex);

    if (!strcmp(mURL, sResourceDir.c_str())) {

        ALOGV("EMPTY INPUT sResourceDir.c_str() %s mURL  %s ", sResourceDir.c_str(), mURL);

        return;

    }



    int32_t numCsds = populateInfoVector(info, &Info, mTimestampDevTest, &mTimestampUslist);

    ASSERT_GE(numCsds, 0) << "Error in parsing input info file: " << info;

    int32_t numCsds = populateInfoVector(mInfoFile, &Info, mTimestampDevTest, &mTimestampUslist);

    ASSERT_GE(numCsds, 0) << "Error in parsing input info file: " << mInfoFile;



    // Reset total no of frames received

    mFramesReceived = 0;
@@ -468,9 +475,8 @@ TEST_P(Codec2AudioDecDecodeTest, DecodeTest) { 
        return;

    }

    ASSERT_EQ(mComponent->start(), C2_OK);

    ALOGV("mURL : %s", mURL);

    std::ifstream eleStream;

    eleStream.open(mURL, std::ifstream::binary);

    eleStream.open(mInputFile, std::ifstream::binary);

    ASSERT_EQ(eleStream.is_open(), true);

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

                                          mFlushedIndices, mLinearPool, eleStream, &Info, 0,
@@ -507,15 +513,10 @@ TEST_P(Codec2AudioDecHidlTest, ThumbnailTest) { 
    description("Test Request for thumbnail");

    if (mDisableTest) GTEST_SKIP() << "Test is disabled";



    char mURL[512], info[512];

    android::Vector<FrameInfo> Info;



    strcpy(mURL, sResourceDir.c_str());

    strcpy(info, sResourceDir.c_str());

    GetURLForComponent(mURL, info);



    int32_t numCsds = populateInfoVector(info, &Info, mTimestampDevTest, &mTimestampUslist);

    ASSERT_GE(numCsds, 0) << "Error in parsing input info file: " << info;

    int32_t numCsds = populateInfoVector(mInfoFile, &Info, mTimestampDevTest, &mTimestampUslist);

    ASSERT_GE(numCsds, 0) << "Error in parsing input info file: " << mInfoFile;



    int32_t bitStreamInfo[2] = {0};

    if (mMime.find("raw") != std::string::npos) {
@@ -529,7 +530,6 @@ TEST_P(Codec2AudioDecHidlTest, ThumbnailTest) { 
        return;

    }

    ASSERT_EQ(mComponent->start(), C2_OK);

    ALOGV("mURL : %s", mURL);



    // request EOS for thumbnail

    // signal EOS flag with last frame
@@ -542,7 +542,7 @@ TEST_P(Codec2AudioDecHidlTest, ThumbnailTest) { 


    } while (!(flags & SYNC_FRAME));

    std::ifstream eleStream;

    eleStream.open(mURL, std::ifstream::binary);

    eleStream.open(mInputFile, std::ifstream::binary);

    ASSERT_EQ(eleStream.is_open(), true);

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

                                          mFlushedIndices, mLinearPool, eleStream, &Info, 0,
@@ -599,15 +599,10 @@ TEST_P(Codec2AudioDecHidlTest, EOSTest) { 
TEST_P(Codec2AudioDecHidlTest, FlushTest) {

    description("Tests Flush calls");

    if (mDisableTest) GTEST_SKIP() << "Test is disabled";

    char mURL[512], info[512];

    android::Vector<FrameInfo> Info;



    strcpy(mURL, sResourceDir.c_str());

    strcpy(info, sResourceDir.c_str());

    GetURLForComponent(mURL, info);



    int32_t numCsds = populateInfoVector(info, &Info, mTimestampDevTest, &mTimestampUslist);

    ASSERT_GE(numCsds, 0) << "Error in parsing input info file: " << info;

    int32_t numCsds = populateInfoVector(mInfoFile, &Info, mTimestampDevTest, &mTimestampUslist);

    ASSERT_GE(numCsds, 0) << "Error in parsing input info file: " << mInfoFile;



    int32_t bitStreamInfo[2] = {0};

    if (mMime.find("raw") != std::string::npos) {
@@ -629,9 +624,8 @@ TEST_P(Codec2AudioDecHidlTest, FlushTest) { 
            verifyFlushOutput(flushedWork, mWorkQueue, mFlushedIndices, mQueueLock));

    ASSERT_EQ(mWorkQueue.size(), MAX_INPUT_BUFFERS);



    ALOGV("mURL : %s", mURL);

    std::ifstream eleStream;

    eleStream.open(mURL, std::ifstream::binary);

    eleStream.open(mInputFile, std::ifstream::binary);

    ASSERT_EQ(eleStream.is_open(), true);

    // Decode 30 frames and flush.

    uint32_t numFramesFlushed = FLUSH_INTERVAL;
@@ -684,15 +678,10 @@ TEST_P(Codec2AudioDecHidlTest, DecodeTestEmptyBuffersInserted) { 
    description("Decode with multiple empty input frames");

    if (mDisableTest) GTEST_SKIP() << "Test is disabled";



    char mURL[512], info[512];

    std::ifstream eleStream, eleInfo;



    strcpy(mURL, sResourceDir.c_str());

    strcpy(info, sResourceDir.c_str());

    GetURLForComponent(mURL, info);



    eleInfo.open(info);

    ASSERT_EQ(eleInfo.is_open(), true) << mURL << " - file not found";

    eleInfo.open(mInfoFile);

    ASSERT_EQ(eleInfo.is_open(), true) << mInputFile << " - file not found";

    android::Vector<FrameInfo> Info;

    int bytesCount = 0;

    uint32_t frameId = 0;
@@ -730,8 +719,7 @@ TEST_P(Codec2AudioDecHidlTest, DecodeTestEmptyBuffersInserted) { 
        return;

    }

    ASSERT_EQ(mComponent->start(), C2_OK);

    ALOGV("mURL : %s", mURL);

    eleStream.open(mURL, std::ifstream::binary);

    eleStream.open(mInputFile, std::ifstream::binary);

    ASSERT_EQ(eleStream.is_open(), true);

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

                                          mFlushedIndices, mLinearPool, eleStream, &Info, 0,
@@ -759,6 +747,7 @@ class Codec2AudioDecCsdInputTests : public Codec2AudioDecHidlTestBase, 
    void getParams() {

        mInstanceName = std::get<0>(GetParam());

        mComponentName = std::get<1>(GetParam());

        mStreamIndex = 0;

    }

};
@@ -768,19 +757,9 @@ TEST_P(Codec2AudioDecCsdInputTests, CSDFlushTest) { 
    description("Tests codecs for flush at different states");

    if (mDisableTest) GTEST_SKIP() << "Test is disabled";



    char mURL[512], info[512];

    android::Vector<FrameInfo> Info;



    strcpy(mURL, sResourceDir.c_str());

    strcpy(info, sResourceDir.c_str());

    GetURLForComponent(mURL, info);

    if (!strcmp(mURL, sResourceDir.c_str())) {

        ALOGV("EMPTY INPUT sResourceDir.c_str() %s mURL  %s ", sResourceDir.c_str(), mURL);

        return;

    }

    ALOGV("mURL : %s", mURL);



    int32_t numCsds = populateInfoVector(info, &Info, mTimestampDevTest, &mTimestampUslist);

    int32_t numCsds = populateInfoVector(mInfoFile, &Info, mTimestampDevTest, &mTimestampUslist);

    ASSERT_GE(numCsds, 0) << "Error in parsing input info file";



    int32_t bitStreamInfo[2] = {0};
@@ -797,7 +776,7 @@ TEST_P(Codec2AudioDecCsdInputTests, CSDFlushTest) { 


    ASSERT_EQ(mComponent->start(), C2_OK);

    std::ifstream eleStream;

    eleStream.open(mURL, std::ifstream::binary);

    eleStream.open(mInputFile, std::ifstream::binary);

    ASSERT_EQ(eleStream.is_open(), true);



    bool signalEOS = false;

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

+62 −115
Original line number Diff line number Diff line
@@ -84,6 +84,17 @@ class Codec2AudioEncHidlTestBase : public ::testing::Test { 
        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";



        getFile(mNumChannels, mSampleRate);

    }



    virtual void TearDown() override {
@@ -97,7 +108,11 @@ class Codec2AudioEncHidlTestBase : public ::testing::Test { 
    // Get the test parameters from GetParam call.

    virtual void getParams() {}



    void GetURLForComponent(char* mURL, int32_t channelCount, int32_t sampleRate);

    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 getFile(int32_t channelCount, int32_t sampleRate);



    // callback function to process onWorkDone received by Listener

    void handleWorkDone(std::list<std::unique_ptr<C2Work>>& workItems) {
@@ -145,6 +160,12 @@ class Codec2AudioEncHidlTestBase : public ::testing::Test { 
    std::shared_ptr<android::Codec2Client::Listener> mListener;

    std::shared_ptr<android::Codec2Client::Component> mComponent;



    int32_t mNumChannels;

    int32_t mSampleRate;

    int32_t mSamplesPerFrame;



    std::string mInputFile;



  protected:

    static void description(const std::string& description) {

        RecordProperty("description", description);
@@ -222,14 +243,13 @@ bool setupConfigParam(const std::shared_ptr<android::Codec2Client::Component>& c 
    return false;

}



c2_status_t getChannelCount(const std::shared_ptr<android::Codec2Client::Component>& component,

                            int32_t* nChannels) {

c2_status_t 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 = component->querySupportedValues(validValueInfos, C2_DONT_BLOCK);

    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;
@@ -264,12 +284,10 @@ c2_status_t getChannelCount(const std::shared_ptr<android::Codec2Client::Compone 
    }

    return C2_OK;

}



c2_status_t getSampleRate(const std::shared_ptr<android::Codec2Client::Component>& component,

                          int32_t* nSampleRate) {

    // Use the default sample rate for components

c2_status_t Codec2AudioEncHidlTestBase::getSampleRate(int32_t* nSampleRate) {

    // Use the default sample rate for mComponents

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

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

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

                                          C2_DONT_BLOCK, &queried);

    if (c2err != C2_OK || queried.size() == 0) return c2err;
@@ -280,10 +298,10 @@ c2_status_t getSampleRate(const std::shared_ptr<android::Codec2Client::Component 
    return C2_OK;

}



c2_status_t getSamplesPerFrame(const std::shared_ptr<android::Codec2Client::Component>& component,

                               int32_t nChannels, int32_t* samplesPerFrame) {

c2_status_t Codec2AudioEncHidlTestBase::getSamplesPerFrame(int32_t nChannels,

                                                           int32_t* samplesPerFrame) {

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

    c2_status_t c2err = component->query({}, {C2StreamMaxBufferSizeInfo::input::PARAM_TYPE},

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

                                          C2_DONT_BLOCK, &queried);

    if (c2err != C2_OK || queried.size() == 0) return c2err;
@@ -295,24 +313,8 @@ c2_status_t getSamplesPerFrame(const std::shared_ptr<android::Codec2Client::Comp 
    return C2_OK;

}



// Get config params for a component

bool getConfigParams(const std::shared_ptr<android::Codec2Client::Component>& component,

                     int32_t* nChannels, int32_t* nSampleRate, int32_t* samplesPerFrame) {

    c2_status_t status = getChannelCount(component, nChannels);

    if (status != C2_OK) return false;



    status = getSampleRate(component, nSampleRate);

    if (status != C2_OK) return false;



    status = getSamplesPerFrame(component, *nChannels, samplesPerFrame);

    if (status != C2_OK) return false;



    return true;

}



// LookUpTable of clips and metadata for component testing

void Codec2AudioEncHidlTestBase::GetURLForComponent(char* mURL, int32_t channelCount,

                                                    int32_t sampleRate) {

void Codec2AudioEncHidlTestBase::getFile(int32_t channelCount, int32_t sampleRate) {

    std::string rawInput = "bbb_raw_1ch_8khz_s16le.raw";

    if (channelCount == 1 && sampleRate == 16000) {

        rawInput = "bbb_raw_1ch_16khz_s16le.raw";
@@ -320,7 +322,7 @@ void Codec2AudioEncHidlTestBase::GetURLForComponent(char* mURL, int32_t channelC 
        rawInput = "bbb_raw_2ch_48khz_s16le.raw";

    }



    strcat(mURL, rawInput.c_str());

    mInputFile = sResourceDir + rawInput;

}



void encodeNFrames(const std::shared_ptr<android::Codec2Client::Component>& component,
@@ -440,38 +442,23 @@ TEST_P(Codec2AudioEncEncodeTest, EncodeTest) { 
    bool signalEOS = std::get<2>(GetParam());

    // Ratio w.r.t to mInputMaxBufSize

    int32_t inputMaxBufRatio = std::get<3>(GetParam());

    mSamplesPerFrame = ((mInputMaxBufSize / inputMaxBufRatio) / (mNumChannels * 2));



    int32_t nChannels;

    int32_t nSampleRate;

    int32_t samplesPerFrame;



    if (!getConfigParams(mComponent, &nChannels, &nSampleRate, &samplesPerFrame)) {

        std::cout << "Failed to get the config params for " << mComponentName << "\n";

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

        return;

    }



    samplesPerFrame = ((mInputMaxBufSize / inputMaxBufRatio) / (nChannels * 2));

    ALOGV("signalEOS %d mInputMaxBufSize %d samplesPerFrame %d", signalEOS, mInputMaxBufSize,

          samplesPerFrame);

    ALOGV("signalEOS %d mInputMaxBufSize %d mSamplesPerFrame %d", signalEOS, mInputMaxBufSize,

          mSamplesPerFrame);



    if (!setupConfigParam(mComponent, nChannels, nSampleRate)) {

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

        return;

    }

    char mURL[512];

    strcpy(mURL, sResourceDir.c_str());

    GetURLForComponent(mURL, nChannels, nSampleRate);

    ASSERT_TRUE(setupConfigParam(mComponent, mNumChannels, mSampleRate))

            << "Unable to configure for channels: " << mNumChannels << " and sampling rate "

            << mSampleRate;



    ASSERT_EQ(mComponent->start(), C2_OK);

    std::ifstream eleStream;

    uint32_t numFrames = 16;

    eleStream.open(mURL, std::ifstream::binary);

    eleStream.open(mInputFile, std::ifstream::binary);

    ASSERT_EQ(eleStream.is_open(), true);

    ALOGV("mURL : %s", mURL);

    ASSERT_NO_FATAL_FAILURE(encodeNFrames(

            mComponent, mQueueLock, mQueueCondition, mWorkQueue, mFlushedIndices, mLinearPool,

            eleStream, numFrames, samplesPerFrame, nChannels, nSampleRate, false, signalEOS));

            eleStream, numFrames, mSamplesPerFrame, mNumChannels, mSampleRate, false, signalEOS));



    // If EOS is not sent, sending empty input with EOS flag

    if (!signalEOS) {
@@ -545,30 +532,17 @@ TEST_P(Codec2AudioEncHidlTest, FlushTest) { 
    if (mDisableTest) GTEST_SKIP() << "Test is disabled";



    mFlushedIndices.clear();

    int32_t nChannels;

    int32_t nSampleRate;

    int32_t samplesPerFrame;



    if (!getConfigParams(mComponent, &nChannels, &nSampleRate, &samplesPerFrame)) {

        std::cout << "Failed to get the config params for " << mComponentName << "\n";

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

        return;

    }



    if (!setupConfigParam(mComponent, nChannels, nSampleRate)) {

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

        return;

    }

    char mURL[512];

    strcpy(mURL, sResourceDir.c_str());

    GetURLForComponent(mURL, nChannels, nSampleRate);

    ASSERT_TRUE(setupConfigParam(mComponent, mNumChannels, mSampleRate))

            << "Unable to configure for channels: " << mNumChannels << " and sampling rate "

            << mSampleRate;



    ASSERT_EQ(mComponent->start(), C2_OK);



    std::ifstream eleStream;

    uint32_t numFramesFlushed = 30;

    uint32_t numFrames = 128;

    eleStream.open(mURL, std::ifstream::binary);

    eleStream.open(mInputFile, std::ifstream::binary);

    ASSERT_EQ(eleStream.is_open(), true);

    // flush

    std::list<std::unique_ptr<C2Work>> flushedWork;
@@ -577,10 +551,9 @@ TEST_P(Codec2AudioEncHidlTest, FlushTest) { 
    ASSERT_NO_FATAL_FAILURE(

            verifyFlushOutput(flushedWork, mWorkQueue, mFlushedIndices, mQueueLock));

    ASSERT_EQ(mWorkQueue.size(), MAX_INPUT_BUFFERS);

    ALOGV("mURL : %s", mURL);

    ASSERT_NO_FATAL_FAILURE(encodeNFrames(mComponent, mQueueLock, mQueueCondition, mWorkQueue,

                                          mFlushedIndices, mLinearPool, eleStream, numFramesFlushed,

                                          samplesPerFrame, nChannels, nSampleRate));

                                          mSamplesPerFrame, mNumChannels, mSampleRate));

    err = mComponent->flush(C2Component::FLUSH_COMPONENT, &flushedWork);

    ASSERT_EQ(err, C2_OK);

    waitOnInputConsumption(mQueueLock, mQueueCondition, mWorkQueue,
@@ -590,8 +563,8 @@ TEST_P(Codec2AudioEncHidlTest, FlushTest) { 
    ASSERT_EQ(mWorkQueue.size(), MAX_INPUT_BUFFERS);

    ASSERT_NO_FATAL_FAILURE(encodeNFrames(mComponent, mQueueLock, mQueueCondition, mWorkQueue,

                                          mFlushedIndices, mLinearPool, eleStream,

                                          numFrames - numFramesFlushed, samplesPerFrame, nChannels,

                                          nSampleRate, true));

                                          numFrames - numFramesFlushed, mSamplesPerFrame,

                                          mNumChannels, mSampleRate, true));

    eleStream.close();

    err = mComponent->flush(C2Component::FLUSH_COMPONENT, &flushedWork);

    ASSERT_EQ(err, C2_OK);
@@ -609,33 +582,20 @@ TEST_P(Codec2AudioEncHidlTest, MultiChannelCountTest) { 
    description("Encodes input file for different channel count");

    if (mDisableTest) GTEST_SKIP() << "Test is disabled";



    int32_t nSampleRate;

    int32_t samplesPerFrame;

    int32_t nChannels;

    int32_t numFrames = 16;

    int32_t maxChannelCount = 8;



    if (!getConfigParams(mComponent, &nChannels, &nSampleRate, &samplesPerFrame)) {

        std::cout << "Failed to get the config params for " << mComponentName << "\n";

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

        return;

    }

    char mURL[512];

    strcpy(mURL, sResourceDir.c_str());

    GetURLForComponent(mURL, nChannels, nSampleRate);



    std::ifstream eleStream;

    eleStream.open(mURL, std::ifstream::binary);

    ASSERT_EQ(eleStream.is_open(), true) << mURL << " file not found";

    ALOGV("mURL : %s", mURL);

    eleStream.open(mInputFile, std::ifstream::binary);

    ASSERT_EQ(eleStream.is_open(), true) << mInputFile << " file not found";



    uint64_t prevOutputSize = 0u;

    uint32_t prevChannelCount = 0u;



    // Looping through the maximum number of channel count supported by encoder

    for (nChannels = 1; nChannels < maxChannelCount; nChannels++) {

    for (int32_t nChannels = 1; nChannels < maxChannelCount; nChannels++) {

        ALOGV("Configuring encoder %s  for channel count = %d", mComponentName.c_str(), nChannels);

        if (!setupConfigParam(mComponent, nChannels, nSampleRate)) {

        if (!setupConfigParam(mComponent, nChannels, mSampleRate)) {

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

            return;

        }
@@ -656,9 +616,9 @@ TEST_P(Codec2AudioEncHidlTest, MultiChannelCountTest) { 


        // To check if the input stream is sufficient to encode for the higher channel count

        struct stat buf;

        stat(mURL, &buf);

        stat(mInputFile.c_str(), &buf);

        size_t fileSize = buf.st_size;

        int32_t bytesCount = (samplesPerFrame * nChannels * 2) * numFrames;

        int32_t bytesCount = (mSamplesPerFrame * nChannels * 2) * numFrames;

        if (fileSize < bytesCount) {

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

                      << " because of insufficient input data\n";
@@ -669,7 +629,7 @@ TEST_P(Codec2AudioEncHidlTest, MultiChannelCountTest) { 


        ASSERT_NO_FATAL_FAILURE(encodeNFrames(mComponent, mQueueLock, mQueueCondition, mWorkQueue,

                                              mFlushedIndices, mLinearPool, eleStream, numFrames,

                                              samplesPerFrame, nChannels, nSampleRate));

                                              mSamplesPerFrame, nChannels, mSampleRate));



        // mDisableTest will be set if buffer was not fetched properly.

        // This may happen when config params is not proper but config succeeded
@@ -711,24 +671,11 @@ TEST_P(Codec2AudioEncHidlTest, MultiSampleRateTest) { 
    description("Encodes input file for different SampleRate");

    if (mDisableTest) GTEST_SKIP() << "Test is disabled";



    int32_t nSampleRate;

    int32_t samplesPerFrame;

    int32_t nChannels;

    int32_t numFrames = 16;



    if (!getConfigParams(mComponent, &nChannels, &nSampleRate, &samplesPerFrame)) {

        std::cout << "Failed to get the config params for " << mComponentName << "\n";

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

        return;

    }

    char mURL[512];

    strcpy(mURL, sResourceDir.c_str());

    GetURLForComponent(mURL, nChannels, nSampleRate);



    std::ifstream eleStream;

    eleStream.open(mURL, std::ifstream::binary);

    ASSERT_EQ(eleStream.is_open(), true) << mURL << " file not found";

    ALOGV("mURL : %s", mURL);

    eleStream.open(mInputFile, std::ifstream::binary);

    ASSERT_EQ(eleStream.is_open(), true) << mInputFile << " file not found";



    int32_t sampleRateValues[] = {1000, 8000, 16000, 24000, 48000, 96000, 192000};
@@ -737,7 +684,7 @@ TEST_P(Codec2AudioEncHidlTest, MultiSampleRateTest) { 


    for (int32_t nSampleRate : sampleRateValues) {

        ALOGV("Configuring encoder %s  for SampleRate = %d", mComponentName.c_str(), nSampleRate);

        if (!setupConfigParam(mComponent, nChannels, nSampleRate)) {

        if (!setupConfigParam(mComponent, mNumChannels, nSampleRate)) {

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

            return;

        }
@@ -759,9 +706,9 @@ TEST_P(Codec2AudioEncHidlTest, MultiSampleRateTest) { 


        // To check if the input stream is sufficient to encode for the higher SampleRate

        struct stat buf;

        stat(mURL, &buf);

        stat(mInputFile.c_str(), &buf);

        size_t fileSize = buf.st_size;

        int32_t bytesCount = (samplesPerFrame * nChannels * 2) * numFrames;

        int32_t bytesCount = (mSamplesPerFrame * mNumChannels * 2) * numFrames;

        if (fileSize < bytesCount) {

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

                      << " because of insufficient input data\n";
@@ -772,7 +719,7 @@ TEST_P(Codec2AudioEncHidlTest, MultiSampleRateTest) { 


        ASSERT_NO_FATAL_FAILURE(encodeNFrames(mComponent, mQueueLock, mQueueCondition, mWorkQueue,

                                              mFlushedIndices, mLinearPool, eleStream, numFrames,

                                              samplesPerFrame, nChannels, nSampleRate));

                                              mSamplesPerFrame, mNumChannels, nSampleRate));



        // mDisableTest will be set if buffer was not fetched properly.

        // This may happen when config params is not proper but config succeeded

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

+59 −88

File changed.

Preview size limit exceeded, changes collapsed.

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

+17 −32

File changed.

Preview size limit exceeded, changes collapsed.