1 /*
2 * Copyright (C) 2021 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 //#define LOG_NDEBUG 0
18
19 #include <gtest/gtest.h>
20
21 #include "audio_test_utils.h"
22
23 using namespace android;
24
TEST(AudioTrackTest,TestPlayTrack)25 TEST(AudioTrackTest, TestPlayTrack) {
26 const auto ap = sp<AudioPlayback>::make(44100 /* sampleRate */, AUDIO_FORMAT_PCM_16_BIT,
27 AUDIO_CHANNEL_OUT_STEREO, AUDIO_OUTPUT_FLAG_NONE,
28 AUDIO_SESSION_NONE, AudioTrack::TRANSFER_OBTAIN);
29 ASSERT_NE(nullptr, ap);
30 ASSERT_EQ(OK, ap->loadResource("/data/local/tmp/bbb_2ch_24kHz_s16le.raw"))
31 << "Unable to open Resource";
32 EXPECT_EQ(OK, ap->create()) << "track creation failed";
33 EXPECT_EQ(OK, ap->start()) << "audio track start failed";
34 EXPECT_EQ(OK, ap->onProcess());
35 ap->stop();
36 }
37
TEST(AudioTrackTest,TestSeek)38 TEST(AudioTrackTest, TestSeek) {
39 const auto ap = sp<AudioPlayback>::make(
40 44100 /* sampleRate */, AUDIO_FORMAT_PCM_16_BIT, AUDIO_CHANNEL_OUT_STEREO);
41 ASSERT_NE(nullptr, ap);
42 ASSERT_EQ(OK, ap->loadResource("/data/local/tmp/bbb_2ch_24kHz_s16le.raw"))
43 << "Unable to open Resource";
44 EXPECT_EQ(OK, ap->create()) << "track creation failed";
45 EXPECT_EQ(OK, ap->start()) << "audio track start failed";
46 EXPECT_EQ(OK, ap->onProcess(true));
47 ap->stop();
48 }
49
TEST(AudioTrackTest,OffloadOrDirectPlayback)50 TEST(AudioTrackTest, OffloadOrDirectPlayback) {
51 audio_offload_info_t info = AUDIO_INFO_INITIALIZER;
52 info.sample_rate = 44100;
53 info.channel_mask = AUDIO_CHANNEL_OUT_STEREO;
54 info.format = AUDIO_FORMAT_MP3;
55 info.stream_type = AUDIO_STREAM_MUSIC;
56 info.bit_rate = 192;
57 info.duration_us = 120 * 1000000; // 120 sec
58
59 audio_config_base_t config = {/* .sample_rate = */ info.sample_rate,
60 /* .channel_mask = */ info.channel_mask,
61 /* .format = */ AUDIO_FORMAT_PCM_16_BIT};
62 audio_attributes_t attributes = AUDIO_ATTRIBUTES_INITIALIZER;
63 attributes.content_type = AUDIO_CONTENT_TYPE_MUSIC;
64 attributes.usage = AUDIO_USAGE_MEDIA;
65 attributes.flags = AUDIO_FLAG_NONE;
66
67 if (!AudioTrack::isDirectOutputSupported(config, attributes) &&
68 AUDIO_OFFLOAD_NOT_SUPPORTED == AudioSystem::getOffloadSupport(info)) {
69 GTEST_SKIP() << "offload or direct playback is not supported";
70 }
71 sp<AudioPlayback> ap = nullptr;
72 if (AUDIO_OFFLOAD_NOT_SUPPORTED != AudioSystem::getOffloadSupport(info)) {
73 ap = sp<AudioPlayback>::make(info.sample_rate, info.format, info.channel_mask,
74 AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD, AUDIO_SESSION_NONE,
75 AudioTrack::TRANSFER_OBTAIN, nullptr, &info);
76 } else {
77 ap = sp<AudioPlayback>::make(config.sample_rate, config.format, config.channel_mask,
78 AUDIO_OUTPUT_FLAG_DIRECT, AUDIO_SESSION_NONE,
79 AudioTrack::TRANSFER_OBTAIN);
80 }
81 ASSERT_NE(nullptr, ap);
82 EXPECT_EQ(OK, ap->create()) << "track creation failed";
83 audio_dual_mono_mode_t mode;
84 if (OK != ap->getAudioTrackHandle()->getDualMonoMode(&mode)) {
85 std::cerr << "no dual mono presentation is available" << std::endl;
86 }
87 if (OK != ap->getAudioTrackHandle()->setDualMonoMode(AUDIO_DUAL_MONO_MODE_LR)) {
88 std::cerr << "no dual mono presentation is available" << std::endl;
89 } else {
90 EXPECT_EQ(OK, ap->getAudioTrackHandle()->getDualMonoMode(&mode));
91 EXPECT_EQ(AUDIO_DUAL_MONO_MODE_LR, mode);
92 }
93 float leveldB;
94 if (OK != ap->getAudioTrackHandle()->getAudioDescriptionMixLevel(&leveldB)) {
95 std::cerr << "Audio Description mixing is unavailable" << std::endl;
96 }
97 if (OK != ap->getAudioTrackHandle()->setAudioDescriptionMixLevel(3.14f)) {
98 std::cerr << "Audio Description mixing is unavailable" << std::endl;
99 } else {
100 EXPECT_EQ(OK, ap->getAudioTrackHandle()->getAudioDescriptionMixLevel(&leveldB));
101 EXPECT_EQ(3.14f, leveldB);
102 }
103 AudioPlaybackRate audioRate;
104 audioRate = ap->getAudioTrackHandle()->getPlaybackRate();
105 std::cerr << "playback speed :: " << audioRate.mSpeed << std::endl
106 << "playback pitch :: " << audioRate.mPitch << std::endl;
107 audioRate.mSpeed = 2.0f;
108 audioRate.mPitch = 2.0f;
109 audioRate.mStretchMode = AUDIO_TIMESTRETCH_STRETCH_VOICE;
110 audioRate.mFallbackMode = AUDIO_TIMESTRETCH_FALLBACK_MUTE;
111 EXPECT_TRUE(isAudioPlaybackRateValid(audioRate));
112 if (OK != ap->getAudioTrackHandle()->setPlaybackRate(audioRate)) {
113 std::cerr << "unable to set playback rate parameters" << std::endl;
114 } else {
115 AudioPlaybackRate audioRateLocal;
116 audioRateLocal = ap->getAudioTrackHandle()->getPlaybackRate();
117 EXPECT_TRUE(isAudioPlaybackRateEqual(audioRate, audioRateLocal));
118 }
119 ap->stop();
120 }
121
TEST(AudioTrackTest,TestAudioCbNotifier)122 TEST(AudioTrackTest, TestAudioCbNotifier) {
123 const auto ap = sp<AudioPlayback>::make(0 /* sampleRate */, AUDIO_FORMAT_PCM_16_BIT,
124 AUDIO_CHANNEL_OUT_STEREO, AUDIO_OUTPUT_FLAG_FAST,
125 AUDIO_SESSION_NONE, AudioTrack::TRANSFER_SHARED);
126 ASSERT_NE(nullptr, ap);
127 ASSERT_EQ(OK, ap->loadResource("/data/local/tmp/bbb_2ch_24kHz_s16le.raw"))
128 << "Unable to open Resource";
129 EXPECT_EQ(OK, ap->create()) << "track creation failed";
130 EXPECT_EQ(BAD_VALUE, ap->getAudioTrackHandle()->addAudioDeviceCallback(nullptr));
131 sp<OnAudioDeviceUpdateNotifier> cb = sp<OnAudioDeviceUpdateNotifier>::make();
132 sp<OnAudioDeviceUpdateNotifier> cbOld = sp<OnAudioDeviceUpdateNotifier>::make();
133 EXPECT_EQ(OK, ap->getAudioTrackHandle()->addAudioDeviceCallback(cbOld));
134 EXPECT_EQ(INVALID_OPERATION, ap->getAudioTrackHandle()->addAudioDeviceCallback(cbOld));
135 EXPECT_EQ(OK, ap->getAudioTrackHandle()->addAudioDeviceCallback(cb));
136 EXPECT_EQ(OK, ap->start()) << "audio track start failed";
137 EXPECT_EQ(OK, ap->onProcess());
138 EXPECT_EQ(OK, cb->waitForAudioDeviceCb());
139 EXPECT_EQ(AUDIO_IO_HANDLE_NONE, cbOld->mAudioIo);
140 EXPECT_EQ(AUDIO_PORT_HANDLE_NONE, cbOld->mDeviceId);
141 EXPECT_NE(AUDIO_IO_HANDLE_NONE, cb->mAudioIo);
142 EXPECT_NE(AUDIO_PORT_HANDLE_NONE, cb->mDeviceId);
143 EXPECT_EQ(cb->mAudioIo, ap->getAudioTrackHandle()->getOutput());
144 EXPECT_EQ(cb->mDeviceId, ap->getAudioTrackHandle()->getRoutedDeviceId());
145 String8 keys;
146 keys = ap->getAudioTrackHandle()->getParameters(keys);
147 if (!keys.isEmpty()) {
148 std::cerr << "track parameters :: " << keys << std::endl;
149 }
150 EXPECT_TRUE(checkPatchPlayback(cb->mAudioIo, cb->mDeviceId));
151 EXPECT_EQ(BAD_VALUE, ap->getAudioTrackHandle()->removeAudioDeviceCallback(nullptr));
152 EXPECT_EQ(INVALID_OPERATION, ap->getAudioTrackHandle()->removeAudioDeviceCallback(cbOld));
153 EXPECT_EQ(OK, ap->getAudioTrackHandle()->removeAudioDeviceCallback(cb));
154 ap->stop();
155 }
156
157 class AudioTrackCreateTest
158 : public ::testing::TestWithParam<std::tuple<uint32_t, audio_format_t, audio_channel_mask_t,
159 audio_output_flags_t, audio_session_t>> {
160 public:
AudioTrackCreateTest()161 AudioTrackCreateTest()
162 : mSampleRate(std::get<0>(GetParam())),
163 mFormat(std::get<1>(GetParam())),
164 mChannelMask(std::get<2>(GetParam())),
165 mFlags(std::get<3>(GetParam())),
166 mSessionId(std::get<4>(GetParam())){};
167
168 const uint32_t mSampleRate;
169 const audio_format_t mFormat;
170 const audio_channel_mask_t mChannelMask;
171 const audio_output_flags_t mFlags;
172 const audio_session_t mSessionId;
173
174 sp<AudioPlayback> mAP;
175
SetUp()176 virtual void SetUp() override {
177 mAP = sp<AudioPlayback>::make(mSampleRate, mFormat, mChannelMask, mFlags,
178 mSessionId);
179 ASSERT_NE(nullptr, mAP);
180 ASSERT_EQ(OK, mAP->loadResource("/data/local/tmp/bbb_2ch_24kHz_s16le.raw"))
181 << "Unable to open Resource";
182 ASSERT_EQ(OK, mAP->create()) << "track creation failed";
183 }
184
TearDown()185 virtual void TearDown() override {
186 if (mAP) mAP->stop();
187 }
188 };
189
TEST_P(AudioTrackCreateTest,TestCreateTrack)190 TEST_P(AudioTrackCreateTest, TestCreateTrack) {
191 EXPECT_EQ(mFormat, mAP->getAudioTrackHandle()->format());
192 EXPECT_EQ(audio_channel_count_from_out_mask(mChannelMask),
193 mAP->getAudioTrackHandle()->channelCount());
194 if (mSampleRate != 0) EXPECT_EQ(mSampleRate, mAP->getAudioTrackHandle()->getSampleRate());
195 if (mSessionId != AUDIO_SESSION_NONE)
196 EXPECT_EQ(mSessionId, mAP->getAudioTrackHandle()->getSessionId());
197 EXPECT_EQ(mSampleRate, mAP->getAudioTrackHandle()->getOriginalSampleRate());
198 EXPECT_EQ(OK, mAP->start()) << "audio track start failed";
199 EXPECT_EQ(OK, mAP->onProcess());
200 }
201
202 // sampleRate, format, channelMask, flags, sessionId
203 INSTANTIATE_TEST_SUITE_P(
204 AudioTrackParameterizedTest, AudioTrackCreateTest,
205 ::testing::Combine(::testing::Values(48000), ::testing::Values(AUDIO_FORMAT_PCM_16_BIT),
206 ::testing::Values(AUDIO_CHANNEL_OUT_STEREO),
207 ::testing::Values(AUDIO_OUTPUT_FLAG_NONE,
208 AUDIO_OUTPUT_FLAG_PRIMARY | AUDIO_OUTPUT_FLAG_FAST,
209 AUDIO_OUTPUT_FLAG_RAW | AUDIO_OUTPUT_FLAG_FAST,
210 AUDIO_OUTPUT_FLAG_DEEP_BUFFER),
211 ::testing::Values(AUDIO_SESSION_NONE)));
212