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

Commit 4695cf00 authored by Ram Mohan's avatar Ram Mohan Committed by Automerger Merge Worker
Browse files

Add audiotrack unit tests am: ba55d5a5 am: 6b2a85a7 

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



Change-Id: I4a93570f3064f7fbf443a054b52f455a9da91f29
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents 60cf9b70 6b2a85a7

media/libaudioclient/tests/Android.bp

+9 −0
Original line number Diff line number Diff line
@@ -151,3 +151,12 @@ cc_test { 
        "audio_test_utils.cpp",

    ],

}



cc_test {

    name: "audiotrack_tests",

    defaults: ["libaudioclient_gtests_defaults"],

    srcs: [

        "audiotrack_tests.cpp",

        "audio_test_utils.cpp",

    ],

}

media/libaudioclient/tests/audio_test_utils.cpp

+28 −3
Original line number Diff line number Diff line
@@ -188,11 +188,36 @@ status_t AudioPlayback::fillBuffer() { 
    return OK;

}



status_t AudioPlayback::waitForConsumption() {

status_t AudioPlayback::waitForConsumption(bool testSeek) {

    if (PLAY_STARTED != mState) return INVALID_OPERATION;

    // in static buffer mode, lets not play clips with duration > 30 sec

    int retry = 30;

    // Total number of frames in the input file.

    size_t totalFrameCount = mMemCapacity / mTrack->frameSize();

    while (!mStopPlaying && retry > 0) {

        // Get the total numbers of frames played.

        uint32_t currPosition;

        mTrack->getPosition(&currPosition);

        if (testSeek && (currPosition > totalFrameCount * 0.6)) {

            testSeek = false;

            if (!mTrack->hasStarted()) return BAD_VALUE;

            mTrack->pauseAndWait(std::chrono::seconds(2));

            if (mTrack->hasStarted()) return BAD_VALUE;

            mTrack->reload();

            mTrack->getPosition(&currPosition);

            if (currPosition != 0) return BAD_VALUE;

            mTrack->start();

            while (currPosition < totalFrameCount * 0.3) {

                mTrack->getPosition(&currPosition);

            }

            mTrack->pauseAndWait(std::chrono::seconds(2));

            uint32_t setPosition = totalFrameCount * 0.9;

            mTrack->setPosition(setPosition);

            uint32_t bufferPosition;

            mTrack->getBufferPosition(&bufferPosition);

            if (bufferPosition != setPosition) return BAD_VALUE;

            mTrack->start();

        }

        std::this_thread::sleep_for(std::chrono::milliseconds(300));

        retry--;

    }
@@ -200,9 +225,9 @@ status_t AudioPlayback::waitForConsumption() { 
    return OK;

}



status_t AudioPlayback::onProcess() {

status_t AudioPlayback::onProcess(bool testSeek) {

    if (mTransferType == AudioTrack::TRANSFER_SHARED)

        return waitForConsumption();

        return waitForConsumption(testSeek);

    else if (mTransferType == AudioTrack::TRANSFER_OBTAIN)

        return fillBuffer();

    else

media/libaudioclient/tests/audio_test_utils.h

+2 −2
Original line number Diff line number Diff line
@@ -62,9 +62,9 @@ class AudioPlayback { 
    status_t create();

    sp<AudioTrack> getAudioTrackHandle();

    status_t start();

    status_t waitForConsumption();

    status_t waitForConsumption(bool testSeek = false);

    status_t fillBuffer();

    status_t onProcess();

    status_t onProcess(bool testSeek = false);

    void stop();



    bool mStopPlaying;

media/libaudioclient/tests/audiotrack_tests.cpp

0 → 100644
+131 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2021 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



//#define LOG_NDEBUG 0



#include <gtest/gtest.h>



#include "audio_test_utils.h"



using namespace android;



TEST(AudioTrackTest, TestPlayTrack) {

    std::unique_ptr<AudioPlayback> ap(new AudioPlayback(

            44100, AUDIO_FORMAT_PCM_16_BIT, AUDIO_CHANNEL_OUT_STEREO, AUDIO_OUTPUT_FLAG_NONE,

            AUDIO_SESSION_NONE, AudioTrack::TRANSFER_OBTAIN));

    ASSERT_NE(nullptr, ap);

    ASSERT_EQ(OK, ap->loadResource("/data/local/tmp/bbb_2ch_24kHz_s16le.raw"))

            << "Unable to open Resource";

    EXPECT_EQ(OK, ap->create()) << "track creation failed";

    EXPECT_EQ(OK, ap->start()) << "audio track start failed";

    EXPECT_EQ(OK, ap->onProcess());

    ap->stop();

}



TEST(AudioTrackTest, TestSeek) {

    std::unique_ptr<AudioPlayback> ap(

            new AudioPlayback(44100, AUDIO_FORMAT_PCM_16_BIT, AUDIO_CHANNEL_OUT_STEREO));

    ASSERT_NE(nullptr, ap);

    ASSERT_EQ(OK, ap->loadResource("/data/local/tmp/bbb_2ch_24kHz_s16le.raw"))

            << "Unable to open Resource";

    EXPECT_EQ(OK, ap->create()) << "track creation failed";

    EXPECT_EQ(OK, ap->start()) << "audio track start failed";

    EXPECT_EQ(OK, ap->onProcess(true));

    ap->stop();

}



TEST(AudioTrackTest, TestAudioCbNotifier) {

    std::unique_ptr<AudioPlayback> ap(new AudioPlayback(

            0, AUDIO_FORMAT_PCM_16_BIT, AUDIO_CHANNEL_OUT_STEREO, AUDIO_OUTPUT_FLAG_FAST,

            AUDIO_SESSION_NONE, AudioTrack::TRANSFER_SHARED));

    ASSERT_NE(nullptr, ap);

    ASSERT_EQ(OK, ap->loadResource("/data/local/tmp/bbb_2ch_24kHz_s16le.raw"))

            << "Unable to open Resource";

    EXPECT_EQ(OK, ap->create()) << "track creation failed";

    EXPECT_EQ(BAD_VALUE, ap->getAudioTrackHandle()->addAudioDeviceCallback(nullptr));

    sp<OnAudioDeviceUpdateNotifier> cb = new OnAudioDeviceUpdateNotifier();

    sp<OnAudioDeviceUpdateNotifier> cbOld = new OnAudioDeviceUpdateNotifier();

    EXPECT_EQ(OK, ap->getAudioTrackHandle()->addAudioDeviceCallback(cbOld));

    EXPECT_EQ(INVALID_OPERATION, ap->getAudioTrackHandle()->addAudioDeviceCallback(cbOld));

    EXPECT_EQ(OK, ap->getAudioTrackHandle()->addAudioDeviceCallback(cb));

    EXPECT_EQ(OK, ap->start()) << "audio track start failed";

    EXPECT_EQ(OK, ap->onProcess());

    EXPECT_EQ(OK, cb->waitForAudioDeviceCb());

    EXPECT_EQ(AUDIO_IO_HANDLE_NONE, cbOld->mAudioIo);

    EXPECT_EQ(AUDIO_PORT_HANDLE_NONE, cbOld->mDeviceId);

    EXPECT_NE(AUDIO_IO_HANDLE_NONE, cb->mAudioIo);

    EXPECT_NE(AUDIO_PORT_HANDLE_NONE, cb->mDeviceId);

    EXPECT_EQ(BAD_VALUE, ap->getAudioTrackHandle()->removeAudioDeviceCallback(nullptr));

    EXPECT_EQ(INVALID_OPERATION, ap->getAudioTrackHandle()->removeAudioDeviceCallback(cbOld));

    EXPECT_EQ(OK, ap->getAudioTrackHandle()->removeAudioDeviceCallback(cb));

    ap->stop();

}



class AudioTrackCreateTest

    : public ::testing::TestWithParam<std::tuple<uint32_t, audio_format_t, audio_channel_mask_t,

                                                 audio_output_flags_t, audio_session_t>> {

  public:

    AudioTrackCreateTest()

        : mSampleRate(std::get<0>(GetParam())),

          mFormat(std::get<1>(GetParam())),

          mChannelMask(std::get<2>(GetParam())),

          mFlags(std::get<3>(GetParam())),

          mSessionId(std::get<4>(GetParam())){};



    const uint32_t mSampleRate;

    const audio_format_t mFormat;

    const audio_channel_mask_t mChannelMask;

    const audio_output_flags_t mFlags;

    const audio_session_t mSessionId;



    std::unique_ptr<AudioPlayback> mAP;



    virtual void SetUp() override {

        mAP = std::make_unique<AudioPlayback>(mSampleRate, mFormat, mChannelMask, mFlags,

                                              mSessionId);

        ASSERT_NE(nullptr, mAP);

        ASSERT_EQ(OK, mAP->loadResource("/data/local/tmp/bbb_2ch_24kHz_s16le.raw"))

                << "Unable to open Resource";

        ASSERT_EQ(OK, mAP->create()) << "track creation failed";

    }



    virtual void TearDown() override {

        if (mAP) mAP->stop();

    }

};



TEST_P(AudioTrackCreateTest, TestCreateTrack) {

    EXPECT_EQ(mFormat, mAP->getAudioTrackHandle()->format());

    EXPECT_EQ(audio_channel_count_from_out_mask(mChannelMask),

              mAP->getAudioTrackHandle()->channelCount());

    if (mSampleRate != 0) EXPECT_EQ(mSampleRate, mAP->getAudioTrackHandle()->getSampleRate());

    if (mSessionId != AUDIO_SESSION_NONE)

        EXPECT_EQ(mSessionId, mAP->getAudioTrackHandle()->getSessionId());

    EXPECT_EQ(mSampleRate, mAP->getAudioTrackHandle()->getOriginalSampleRate());

    EXPECT_EQ(OK, mAP->start()) << "audio track start failed";

    EXPECT_EQ(OK, mAP->onProcess());

}



// sampleRate, format, channelMask, flags, sessionId

INSTANTIATE_TEST_SUITE_P(

        AudioTrackParameterizedTest, AudioTrackCreateTest,

        ::testing::Combine(::testing::Values(48000), ::testing::Values(AUDIO_FORMAT_PCM_16_BIT),

                           ::testing::Values(AUDIO_CHANNEL_OUT_STEREO),

                           ::testing::Values(AUDIO_OUTPUT_FLAG_NONE,

                                             AUDIO_OUTPUT_FLAG_PRIMARY | AUDIO_OUTPUT_FLAG_FAST,

                                             AUDIO_OUTPUT_FLAG_RAW | AUDIO_OUTPUT_FLAG_FAST,

                                             AUDIO_OUTPUT_FLAG_DEEP_BUFFER),

                           ::testing::Values(AUDIO_SESSION_NONE)));