Updates to audiotrack tests
Test dual mono presentation, audio description mixing, playback rate
parameter configuration for offload tracks
Bug: 215781479
Test: atest audiotrack_tests
Merged-In: I5530dfe46e8b63121206027ce03b93d92bc51ec1
Change-Id: I5530dfe46e8b63121206027ce03b93d92bc51ec1
diff --git a/media/libaudioclient/tests/audio_test_utils.cpp b/media/libaudioclient/tests/audio_test_utils.cpp
index d7ce014..018d920 100644
--- a/media/libaudioclient/tests/audio_test_utils.cpp
+++ b/media/libaudioclient/tests/audio_test_utils.cpp
@@ -48,14 +48,15 @@
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 @@
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 @@
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);
+ }
}
}
diff --git a/media/libaudioclient/tests/audio_test_utils.h b/media/libaudioclient/tests/audio_test_utils.h
index fc269ed..526d5c4 100644
--- a/media/libaudioclient/tests/audio_test_utils.h
+++ b/media/libaudioclient/tests/audio_test_utils.h
@@ -64,12 +64,13 @@
// Simple AudioPlayback class.
class AudioPlayback : public AudioTrack::IAudioTrackCallback {
- friend sp<AudioPlayback>;
+ friend sp<AudioPlayback>;
AudioPlayback(uint32_t sampleRate, audio_format_t format, audio_channel_mask_t channelMask,
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 @@
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;
diff --git a/media/libaudioclient/tests/audiotrack_tests.cpp b/media/libaudioclient/tests/audiotrack_tests.cpp
index a49af96..1b42a49 100644
--- a/media/libaudioclient/tests/audiotrack_tests.cpp
+++ b/media/libaudioclient/tests/audiotrack_tests.cpp
@@ -47,6 +47,78 @@
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 @@
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));