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

Commit 2c2a1008 authored by Ram Mohan's avatar Ram Mohan Committed by Mikhail Naganov
Browse files

Updates to audiotrack tests 

Test dual mono presentation, audio description mixing, playback rate
parameter configuration for offload tracks

Bug: 215781479
Test: atest audiotrack_tests

Change-Id: I5530dfe46e8b63121206027ce03b93d92bc51ec1
parent ef49f043

media/libaudioclient/tests/audio_test_utils.cpp

+12 −4
Original line number Diff line number Diff line
@@ -48,14 +48,15 @@ status_t OnAudioDeviceUpdateNotifier::waitForAudioDeviceCb() { 
AudioPlayback::AudioPlayback(uint32_t sampleRate, audio_format_t format,

                             audio_channel_mask_t channelMask, audio_output_flags_t flags,

                             audio_session_t sessionId, AudioTrack::transfer_type transferType,

                             audio_attributes_t* attributes)

                             audio_attributes_t* attributes, audio_offload_info_t* info)

    : mSampleRate(sampleRate),

      mFormat(format),

      mChannelMask(channelMask),

      mFlags(flags),

      mSessionId(sessionId),

      mTransferType(transferType),

      mAttributes(attributes) {

      mAttributes(attributes),

      mOffloadInfo(info) {

    mStopPlaying = false;

    mBytesUsedSoFar = 0;

    mState = PLAY_NO_INIT;
@@ -81,13 +82,14 @@ status_t AudioPlayback::create() { 
        mTrack->set(AUDIO_STREAM_MUSIC, mSampleRate, mFormat, mChannelMask, 0 /* frameCount */,

                    mFlags, nullptr /* callback */, 0 /* notificationFrames */,

                    nullptr /* sharedBuffer */, false /*canCallJava */, mSessionId, mTransferType,

                    nullptr /* offloadInfo */, attributionSource, mAttributes);

                    mOffloadInfo, attributionSource, mAttributes);

    } else if (mTransferType == AudioTrack::TRANSFER_SHARED) {

        mTrack = new AudioTrack(AUDIO_STREAM_MUSIC, mSampleRate, mFormat, mChannelMask, mMemory,

                                mFlags, wp<AudioTrack::IAudioTrackCallback>::fromExisting(this), 0,

                                mSessionId, mTransferType, nullptr, attributionSource, mAttributes);

    } else {

        ALOGE("Required Transfer type not existed");

        ALOGE("Test application is not handling transfer type %s",

              AudioTrack::convertTransferToText(mTransferType));

        return INVALID_OPERATION;

    }

    mTrack->setCallerName(packageName);
@@ -229,9 +231,15 @@ void AudioPlayback::stop() { 
    std::unique_lock<std::mutex> lock{mMutex};

    mStopPlaying = true;

    if (mState != PLAY_STOPPED) {

        int32_t msec = 0;

        (void)mTrack->pendingDuration(&msec);

        mTrack->stopAndJoinCallbacks();

        LOG_FATAL_IF(true != mTrack->stopped());

        mState = PLAY_STOPPED;

        if (msec > 0) {

            ALOGD("deleting recycled track, waiting for data drain (%d msec)", msec);

            usleep(msec * 1000LL);

        }

    }

}

media/libaudioclient/tests/audio_test_utils.h

+4 −2
Original line number Diff line number Diff line
@@ -69,7 +69,8 @@ class AudioPlayback : public AudioTrack::IAudioTrackCallback { 
                  audio_output_flags_t flags = AUDIO_OUTPUT_FLAG_NONE,

                  audio_session_t sessionId = AUDIO_SESSION_NONE,

                  AudioTrack::transfer_type transferType = AudioTrack::TRANSFER_SHARED,

                  audio_attributes_t* attributes = nullptr);

                  audio_attributes_t* attributes = nullptr, audio_offload_info_t* info = nullptr);



  public:

    status_t loadResource(const char* name);

    status_t create();
@@ -101,6 +102,7 @@ class AudioPlayback : public AudioTrack::IAudioTrackCallback { 
    const audio_session_t mSessionId;

    const AudioTrack::transfer_type mTransferType;

    const audio_attributes_t* mAttributes;

    const audio_offload_info_t* mOffloadInfo;



    size_t mBytesUsedSoFar;

    State mState;

media/libaudioclient/tests/audiotrack_tests.cpp

+79 −0
Original line number Diff line number Diff line
@@ -47,6 +47,78 @@ TEST(AudioTrackTest, TestSeek) { 
    ap->stop();

}



TEST(AudioTrackTest, OffloadOrDirectPlayback) {

    audio_offload_info_t info = AUDIO_INFO_INITIALIZER;

    info.sample_rate = 44100;

    info.channel_mask = AUDIO_CHANNEL_OUT_STEREO;

    info.format = AUDIO_FORMAT_MP3;

    info.stream_type = AUDIO_STREAM_MUSIC;

    info.bit_rate = 192;

    info.duration_us = 120 * 1000000;  // 120 sec



    audio_config_base_t config = {/* .sample_rate = */ info.sample_rate,

                                  /* .channel_mask = */ info.channel_mask,

                                  /* .format = */ AUDIO_FORMAT_PCM_16_BIT};

    audio_attributes_t attributes = AUDIO_ATTRIBUTES_INITIALIZER;

    attributes.content_type = AUDIO_CONTENT_TYPE_MUSIC;

    attributes.usage = AUDIO_USAGE_MEDIA;

    attributes.flags = AUDIO_FLAG_NONE;



    if (!AudioTrack::isDirectOutputSupported(config, attributes) &&

        AUDIO_OFFLOAD_NOT_SUPPORTED == AudioSystem::getOffloadSupport(info)) {

        GTEST_SKIP() << "offload or direct playback is not supported";

    }

    sp<AudioPlayback> ap = nullptr;

    if (AUDIO_OFFLOAD_NOT_SUPPORTED != AudioSystem::getOffloadSupport(info)) {

        ap = sp<AudioPlayback>::make(info.sample_rate, info.format, info.channel_mask,

                                     AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD, AUDIO_SESSION_NONE,

                                     AudioTrack::TRANSFER_OBTAIN, nullptr, &info);

    } else {

        ap = sp<AudioPlayback>::make(config.sample_rate, config.format, config.channel_mask,

                                     AUDIO_OUTPUT_FLAG_DIRECT, AUDIO_SESSION_NONE,

                                     AudioTrack::TRANSFER_OBTAIN);

    }

    ASSERT_NE(nullptr, ap);

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

    audio_dual_mono_mode_t mode;

    if (OK != ap->getAudioTrackHandle()->getDualMonoMode(&mode)) {

        std::cerr << "no dual mono presentation is available" << std::endl;

    }

    if (OK != ap->getAudioTrackHandle()->setDualMonoMode(AUDIO_DUAL_MONO_MODE_LR)) {

        std::cerr << "no dual mono presentation is available" << std::endl;

    } else {

        EXPECT_EQ(OK, ap->getAudioTrackHandle()->getDualMonoMode(&mode));

        EXPECT_EQ(AUDIO_DUAL_MONO_MODE_LR, mode);

    }

    float leveldB;

    if (OK != ap->getAudioTrackHandle()->getAudioDescriptionMixLevel(&leveldB)) {

        std::cerr << "Audio Description mixing is unavailable" << std::endl;

    }

    if (OK != ap->getAudioTrackHandle()->setAudioDescriptionMixLevel(3.14f)) {

        std::cerr << "Audio Description mixing is unavailable" << std::endl;

    } else {

        EXPECT_EQ(OK, ap->getAudioTrackHandle()->getAudioDescriptionMixLevel(&leveldB));

        EXPECT_EQ(3.14f, leveldB);

    }

    AudioPlaybackRate audioRate;

    audioRate = ap->getAudioTrackHandle()->getPlaybackRate();

    std::cerr << "playback speed :: " << audioRate.mSpeed << std::endl

              << "playback pitch :: " << audioRate.mPitch << std::endl;

    audioRate.mSpeed = 2.0f;

    audioRate.mPitch = 2.0f;

    audioRate.mStretchMode = AUDIO_TIMESTRETCH_STRETCH_VOICE;

    audioRate.mFallbackMode = AUDIO_TIMESTRETCH_FALLBACK_MUTE;

    EXPECT_TRUE(isAudioPlaybackRateValid(audioRate));

    if (OK != ap->getAudioTrackHandle()->setPlaybackRate(audioRate)) {

        std::cerr << "unable to set playback rate parameters" << std::endl;

    } else {

        AudioPlaybackRate audioRateLocal;

        audioRateLocal = ap->getAudioTrackHandle()->getPlaybackRate();

        EXPECT_TRUE(isAudioPlaybackRateEqual(audioRate, audioRateLocal));

    }

    ap->stop();

}



TEST(AudioTrackTest, TestAudioCbNotifier) {

    const auto ap = sp<AudioPlayback>::make(0 /* sampleRate */, AUDIO_FORMAT_PCM_16_BIT,

                                            AUDIO_CHANNEL_OUT_STEREO, AUDIO_OUTPUT_FLAG_FAST,
@@ -68,6 +140,13 @@ TEST(AudioTrackTest, TestAudioCbNotifier) { 
    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(cb->mAudioIo, ap->getAudioTrackHandle()->getOutput());

    EXPECT_EQ(cb->mDeviceId, ap->getAudioTrackHandle()->getRoutedDeviceId());

    String8 keys;

    keys = ap->getAudioTrackHandle()->getParameters(keys);

    if (!keys.isEmpty()) {

        std::cerr << "track parameters :: " << keys << std::endl;

    }

    EXPECT_TRUE(checkPatchPlayback(cb->mAudioIo, cb->mDeviceId));

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

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