1 /*
2 * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
3 *
4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
9 */
10
11 #include <math.h>
12 #include <stdio.h>
13 #include <string.h>
14
15 #include "webrtc/modules/audio_device/test/audio_device_test_defines.h"
16
17 #include "testing/gtest/include/gtest/gtest.h"
18 #include "webrtc/test/testsupport/fileutils.h"
19
20 #include "webrtc/modules/audio_device/audio_device_config.h"
21 #include "webrtc/modules/audio_device/audio_device_impl.h"
22 #include "webrtc/modules/audio_device/audio_device_utility.h"
23 #include "webrtc/system_wrappers/interface/sleep.h"
24
25 // Helper functions
26 #if defined(ANDROID)
27 char filenameStr[2][256] =
28 { {0},
29 {0},
30 }; // Allow two buffers for those API calls taking two filenames
31 int currentStr = 0;
32
GetFilename(const char * filename)33 const char* GetFilename(const char* filename)
34 {
35 currentStr = !currentStr;
36 sprintf(filenameStr[currentStr], "/sdcard/admtest/%s", filename);
37 return filenameStr[currentStr];
38 }
39 #elif !defined(WEBRTC_IOS)
GetFilename(const char * filename)40 const char* GetFilename(const char* filename) {
41 std::string full_path_filename = webrtc::test::OutputPath() + filename;
42 return full_path_filename.c_str();
43 }
44 #endif
45
46 using namespace webrtc;
47
48 class AudioEventObserverAPI: public AudioDeviceObserver {
49 public:
AudioEventObserverAPI(AudioDeviceModule * audioDevice)50 AudioEventObserverAPI(AudioDeviceModule* audioDevice)
51 : error_(kRecordingError),
52 warning_(kRecordingWarning),
53 audio_device_(audioDevice) {
54 }
55
~AudioEventObserverAPI()56 ~AudioEventObserverAPI() {}
57
OnErrorIsReported(const ErrorCode error)58 virtual void OnErrorIsReported(const ErrorCode error) {
59 TEST_LOG("\n[*** ERROR ***] => OnErrorIsReported(%d)\n\n", error);
60 error_ = error;
61 }
62
OnWarningIsReported(const WarningCode warning)63 virtual void OnWarningIsReported(const WarningCode warning) {
64 TEST_LOG("\n[*** WARNING ***] => OnWarningIsReported(%d)\n\n", warning);
65 warning_ = warning;
66 EXPECT_EQ(0, audio_device_->StopRecording());
67 EXPECT_EQ(0, audio_device_->StopPlayout());
68 }
69
70 public:
71 ErrorCode error_;
72 WarningCode warning_;
73 private:
74 AudioDeviceModule* audio_device_;
75 };
76
77 class AudioTransportAPI: public AudioTransport {
78 public:
AudioTransportAPI(AudioDeviceModule * audioDevice)79 AudioTransportAPI(AudioDeviceModule* audioDevice)
80 : rec_count_(0),
81 play_count_(0) {
82 }
83
~AudioTransportAPI()84 ~AudioTransportAPI() {}
85
RecordedDataIsAvailable(const void * audioSamples,const uint32_t nSamples,const uint8_t nBytesPerSample,const uint8_t nChannels,const uint32_t sampleRate,const uint32_t totalDelay,const int32_t clockSkew,const uint32_t currentMicLevel,const bool keyPressed,uint32_t & newMicLevel)86 virtual int32_t RecordedDataIsAvailable(
87 const void* audioSamples,
88 const uint32_t nSamples,
89 const uint8_t nBytesPerSample,
90 const uint8_t nChannels,
91 const uint32_t sampleRate,
92 const uint32_t totalDelay,
93 const int32_t clockSkew,
94 const uint32_t currentMicLevel,
95 const bool keyPressed,
96 uint32_t& newMicLevel) {
97 rec_count_++;
98 if (rec_count_ % 100 == 0) {
99 if (nChannels == 1) {
100 // mono
101 TEST_LOG("-");
102 } else if ((nChannels == 2) && (nBytesPerSample == 2)) {
103 // stereo but only using one channel
104 TEST_LOG("-|");
105 } else {
106 // stereo
107 TEST_LOG("--");
108 }
109 }
110 return 0;
111 }
112
NeedMorePlayData(const uint32_t nSamples,const uint8_t nBytesPerSample,const uint8_t nChannels,const uint32_t sampleRate,void * audioSamples,uint32_t & nSamplesOut,int64_t * elapsed_time_ms,int64_t * ntp_time_ms)113 virtual int32_t NeedMorePlayData(
114 const uint32_t nSamples,
115 const uint8_t nBytesPerSample,
116 const uint8_t nChannels,
117 const uint32_t sampleRate,
118 void* audioSamples,
119 uint32_t& nSamplesOut,
120 int64_t* elapsed_time_ms,
121 int64_t* ntp_time_ms) {
122 play_count_++;
123 if (play_count_ % 100 == 0) {
124 if (nChannels == 1) {
125 TEST_LOG("+");
126 } else {
127 TEST_LOG("++");
128 }
129 }
130 nSamplesOut = 480;
131 return 0;
132 }
133
OnDataAvailable(const int voe_channels[],int number_of_voe_channels,const int16_t * audio_data,int sample_rate,int number_of_channels,int number_of_frames,int audio_delay_milliseconds,int current_volume,bool key_pressed,bool need_audio_processing)134 virtual int OnDataAvailable(const int voe_channels[],
135 int number_of_voe_channels,
136 const int16_t* audio_data,
137 int sample_rate,
138 int number_of_channels,
139 int number_of_frames,
140 int audio_delay_milliseconds,
141 int current_volume,
142 bool key_pressed,
143 bool need_audio_processing) {
144 return 0;
145 }
146
PushCaptureData(int voe_channel,const void * audio_data,int bits_per_sample,int sample_rate,int number_of_channels,int number_of_frames)147 virtual void PushCaptureData(int voe_channel, const void* audio_data,
148 int bits_per_sample, int sample_rate,
149 int number_of_channels,
150 int number_of_frames) {}
151
PullRenderData(int bits_per_sample,int sample_rate,int number_of_channels,int number_of_frames,void * audio_data,int64_t * elapsed_time_ms,int64_t * ntp_time_ms)152 virtual void PullRenderData(int bits_per_sample, int sample_rate,
153 int number_of_channels, int number_of_frames,
154 void* audio_data,
155 int64_t* elapsed_time_ms,
156 int64_t* ntp_time_ms) {}
157 private:
158 uint32_t rec_count_;
159 uint32_t play_count_;
160 };
161
162 class AudioDeviceAPITest: public testing::Test {
163 protected:
AudioDeviceAPITest()164 AudioDeviceAPITest() {}
165
~AudioDeviceAPITest()166 virtual ~AudioDeviceAPITest() {}
167
SetUpTestCase()168 static void SetUpTestCase() {
169 process_thread_ = ProcessThread::CreateProcessThread();
170 process_thread_->Start();
171
172 // Windows:
173 // if (WEBRTC_WINDOWS_CORE_AUDIO_BUILD)
174 // user can select between default (Core) or Wave
175 // else
176 // user can select between default (Wave) or Wave
177 const int32_t kId = 444;
178
179 #if defined(_WIN32)
180 EXPECT_TRUE((audio_device_ = AudioDeviceModuleImpl::Create(
181 kId, AudioDeviceModule::kLinuxAlsaAudio)) == NULL);
182 #if defined(WEBRTC_WINDOWS_CORE_AUDIO_BUILD)
183 TEST_LOG("WEBRTC_WINDOWS_CORE_AUDIO_BUILD is defined!\n\n");
184 // create default implementation (=Core Audio) instance
185 EXPECT_TRUE((audio_device_ = AudioDeviceModuleImpl::Create(
186 kId, AudioDeviceModule::kPlatformDefaultAudio)) != NULL);
187 audio_device_->AddRef();
188 EXPECT_EQ(0, audio_device_->Release());
189 // create non-default (=Wave Audio) instance
190 EXPECT_TRUE((audio_device_ = AudioDeviceModuleImpl::Create(
191 kId, AudioDeviceModule::kWindowsWaveAudio)) != NULL);
192 audio_device_->AddRef();
193 EXPECT_EQ(0, audio_device_->Release());
194 // explicitly specify usage of Core Audio (same as default)
195 EXPECT_TRUE((audio_device_ = AudioDeviceModuleImpl::Create(
196 kId, AudioDeviceModule::kWindowsCoreAudio)) != NULL);
197 #else
198 TEST_LOG("WEBRTC_WINDOWS_CORE_AUDIO_BUILD is *not* defined!\n");
199 EXPECT_TRUE((audio_device_ = AudioDeviceModuleImpl::Create(
200 kId, AudioDeviceModule::kWindowsCoreAudio)) == NULL);
201 // create default implementation (=Wave Audio) instance
202 EXPECT_TRUE((audio_device_ = AudioDeviceModuleImpl::Create(
203 kId, AudioDeviceModule::kPlatformDefaultAudio)) != NULL);
204 audio_device_->AddRef();
205 EXPECT_EQ(0, audio_device_->Release());
206 // explicitly specify usage of Wave Audio (same as default)
207 EXPECT_TRUE((audio_device_ = AudioDeviceModuleImpl::Create(
208 kId, AudioDeviceModule::kWindowsWaveAudio)) != NULL);
209 #endif
210 #endif
211
212 #if defined(ANDROID)
213 // Fails tests
214 EXPECT_TRUE((audio_device_ = AudioDeviceModuleImpl::Create(
215 kId, AudioDeviceModule::kWindowsWaveAudio)) == NULL);
216 EXPECT_TRUE((audio_device_ = AudioDeviceModuleImpl::Create(
217 kId, AudioDeviceModule::kWindowsCoreAudio)) == NULL);
218 EXPECT_TRUE((audio_device_ = AudioDeviceModuleImpl::Create(
219 kId, AudioDeviceModule::kLinuxAlsaAudio)) == NULL);
220 EXPECT_TRUE((audio_device_ = AudioDeviceModuleImpl::Create(
221 kId, AudioDeviceModule::kLinuxPulseAudio)) == NULL);
222 // Create default implementation instance
223 EXPECT_TRUE((audio_device_ = AudioDeviceModuleImpl::Create(
224 kId, AudioDeviceModule::kPlatformDefaultAudio)) != NULL);
225 #elif defined(WEBRTC_LINUX)
226 EXPECT_TRUE((audio_device_ = AudioDeviceModuleImpl::Create(
227 kId, AudioDeviceModule::kWindowsWaveAudio)) == NULL);
228 EXPECT_TRUE((audio_device_ = AudioDeviceModuleImpl::Create(
229 kId, AudioDeviceModule::kWindowsCoreAudio)) == NULL);
230 // create default implementation instance
231 EXPECT_TRUE((audio_device_ = AudioDeviceModuleImpl::Create(
232 kId, AudioDeviceModule::kPlatformDefaultAudio)) != NULL);
233 audio_device_->AddRef();
234 EXPECT_EQ(0, audio_device_->Terminate());
235 EXPECT_EQ(0, audio_device_->Release());
236 // explicitly specify usage of Pulse Audio (same as default)
237 EXPECT_TRUE((audio_device_ = AudioDeviceModuleImpl::Create(
238 kId, AudioDeviceModule::kLinuxPulseAudio)) != NULL);
239 #endif
240
241 #if defined(WEBRTC_MAC)
242 // Fails tests
243 EXPECT_TRUE((audio_device_ = AudioDeviceModuleImpl::Create(
244 kId, AudioDeviceModule::kWindowsWaveAudio)) == NULL);
245 EXPECT_TRUE((audio_device_ = AudioDeviceModuleImpl::Create(
246 kId, AudioDeviceModule::kWindowsCoreAudio)) == NULL);
247 EXPECT_TRUE((audio_device_ = AudioDeviceModuleImpl::Create(
248 kId, AudioDeviceModule::kLinuxAlsaAudio)) == NULL);
249 EXPECT_TRUE((audio_device_ = AudioDeviceModuleImpl::Create(
250 kId, AudioDeviceModule::kLinuxPulseAudio)) == NULL);
251 // Create default implementation instance
252 EXPECT_TRUE((audio_device_ = AudioDeviceModuleImpl::Create(
253 kId, AudioDeviceModule::kPlatformDefaultAudio)) != NULL);
254 #endif
255
256 if (audio_device_ == NULL) {
257 FAIL() << "Failed creating audio device object!";
258 }
259
260 // The ADM is reference counted.
261 audio_device_->AddRef();
262
263 process_thread_->RegisterModule(audio_device_);
264
265 AudioDeviceModule::AudioLayer audio_layer =
266 AudioDeviceModule::kPlatformDefaultAudio;
267 EXPECT_EQ(0, audio_device_->ActiveAudioLayer(&audio_layer));
268 if (audio_layer == AudioDeviceModule::kLinuxAlsaAudio) {
269 linux_alsa_ = true;
270 }
271 }
272
TearDownTestCase()273 static void TearDownTestCase() {
274 if (process_thread_) {
275 process_thread_->DeRegisterModule(audio_device_);
276 process_thread_->Stop();
277 ProcessThread::DestroyProcessThread(process_thread_);
278 }
279 if (event_observer_) {
280 delete event_observer_;
281 event_observer_ = NULL;
282 }
283 if (audio_transport_) {
284 delete audio_transport_;
285 audio_transport_ = NULL;
286 }
287 if (audio_device_) {
288 EXPECT_EQ(0, audio_device_->Release());
289 }
290 PRINT_TEST_RESULTS;
291 }
292
SetUp()293 void SetUp() {
294 if (linux_alsa_) {
295 FAIL() << "API Test is not available on ALSA on Linux!";
296 }
297 EXPECT_EQ(0, audio_device_->Init());
298 EXPECT_TRUE(audio_device_->Initialized());
299 }
300
TearDown()301 void TearDown() {
302 EXPECT_EQ(0, audio_device_->Terminate());
303 }
304
CheckVolume(uint32_t expected,uint32_t actual)305 void CheckVolume(uint32_t expected, uint32_t actual) {
306 // Mac and Windows have lower resolution on the volume settings.
307 #if defined(WEBRTC_MAC) || defined(_WIN32)
308 int diff = abs(static_cast<int>(expected - actual));
309 EXPECT_LE(diff, 5);
310 #else
311 EXPECT_TRUE((actual == expected) || (actual == expected-1));
312 #endif
313 }
314
CheckInitialPlayoutStates()315 void CheckInitialPlayoutStates() {
316 EXPECT_FALSE(audio_device_->PlayoutIsInitialized());
317 EXPECT_FALSE(audio_device_->Playing());
318 EXPECT_FALSE(audio_device_->SpeakerIsInitialized());
319 }
320
CheckInitialRecordingStates()321 void CheckInitialRecordingStates() {
322 EXPECT_FALSE(audio_device_->RecordingIsInitialized());
323 EXPECT_FALSE(audio_device_->Recording());
324 EXPECT_FALSE(audio_device_->MicrophoneIsInitialized());
325 }
326
327 static bool linux_alsa_;
328 static ProcessThread* process_thread_;
329 static AudioDeviceModule* audio_device_;
330 static AudioTransportAPI* audio_transport_;
331 static AudioEventObserverAPI* event_observer_;
332 };
333
334 // Must be initialized like this to handle static SetUpTestCase() above.
335 bool AudioDeviceAPITest::linux_alsa_ = false;
336 ProcessThread* AudioDeviceAPITest::process_thread_ = NULL;
337 AudioDeviceModule* AudioDeviceAPITest::audio_device_ = NULL;
338 AudioTransportAPI* AudioDeviceAPITest::audio_transport_ = NULL;
339 AudioEventObserverAPI* AudioDeviceAPITest::event_observer_ = NULL;
340
TEST_F(AudioDeviceAPITest,RegisterEventObserver)341 TEST_F(AudioDeviceAPITest, RegisterEventObserver) {
342 event_observer_ = new AudioEventObserverAPI(audio_device_);
343 EXPECT_EQ(0, audio_device_->RegisterEventObserver(NULL));
344 EXPECT_EQ(0, audio_device_->RegisterEventObserver(event_observer_));
345 EXPECT_EQ(0, audio_device_->RegisterEventObserver(NULL));
346 }
347
TEST_F(AudioDeviceAPITest,RegisterAudioCallback)348 TEST_F(AudioDeviceAPITest, RegisterAudioCallback) {
349 audio_transport_ = new AudioTransportAPI(audio_device_);
350 EXPECT_EQ(0, audio_device_->RegisterAudioCallback(NULL));
351 EXPECT_EQ(0, audio_device_->RegisterAudioCallback(audio_transport_));
352 EXPECT_EQ(0, audio_device_->RegisterAudioCallback(NULL));
353 }
354
TEST_F(AudioDeviceAPITest,Init)355 TEST_F(AudioDeviceAPITest, Init) {
356 EXPECT_TRUE(audio_device_->Initialized());
357 EXPECT_EQ(0, audio_device_->Init());
358 EXPECT_TRUE(audio_device_->Initialized());
359 EXPECT_EQ(0, audio_device_->Terminate());
360 EXPECT_FALSE(audio_device_->Initialized());
361 EXPECT_EQ(0, audio_device_->Init());
362 EXPECT_TRUE(audio_device_->Initialized());
363 EXPECT_EQ(0, audio_device_->Terminate());
364 EXPECT_FALSE(audio_device_->Initialized());
365 }
366
TEST_F(AudioDeviceAPITest,Terminate)367 TEST_F(AudioDeviceAPITest, Terminate) {
368 EXPECT_TRUE(audio_device_->Initialized());
369 EXPECT_EQ(0, audio_device_->Terminate());
370 EXPECT_FALSE(audio_device_->Initialized());
371 EXPECT_EQ(0, audio_device_->Terminate());
372 EXPECT_FALSE(audio_device_->Initialized());
373 EXPECT_EQ(0, audio_device_->Init());
374 EXPECT_TRUE(audio_device_->Initialized());
375 EXPECT_EQ(0, audio_device_->Terminate());
376 EXPECT_FALSE(audio_device_->Initialized());
377 }
378
TEST_F(AudioDeviceAPITest,PlayoutDevices)379 TEST_F(AudioDeviceAPITest, PlayoutDevices) {
380 EXPECT_GT(audio_device_->PlayoutDevices(), 0);
381 EXPECT_GT(audio_device_->PlayoutDevices(), 0);
382 }
383
TEST_F(AudioDeviceAPITest,RecordingDevices)384 TEST_F(AudioDeviceAPITest, RecordingDevices) {
385 EXPECT_GT(audio_device_->RecordingDevices(), 0);
386 EXPECT_GT(audio_device_->RecordingDevices(), 0);
387 }
388
TEST_F(AudioDeviceAPITest,PlayoutDeviceName)389 TEST_F(AudioDeviceAPITest, PlayoutDeviceName) {
390 char name[kAdmMaxDeviceNameSize];
391 char guid[kAdmMaxGuidSize];
392 int16_t no_devices = audio_device_->PlayoutDevices();
393
394 // fail tests
395 EXPECT_EQ(-1, audio_device_->PlayoutDeviceName(-2, name, guid));
396 EXPECT_EQ(-1, audio_device_->PlayoutDeviceName(no_devices, name, guid));
397 EXPECT_EQ(-1, audio_device_->PlayoutDeviceName(0, NULL, guid));
398
399 // bulk tests
400 EXPECT_EQ(0, audio_device_->PlayoutDeviceName(0, name, NULL));
401 #ifdef _WIN32
402 // shall be mapped to 0.
403 EXPECT_EQ(0, audio_device_->PlayoutDeviceName(-1, name, NULL));
404 #else
405 EXPECT_EQ(-1, audio_device_->PlayoutDeviceName(-1, name, NULL));
406 #endif
407 for (int i = 0; i < no_devices; i++) {
408 EXPECT_EQ(0, audio_device_->PlayoutDeviceName(i, name, guid));
409 EXPECT_EQ(0, audio_device_->PlayoutDeviceName(i, name, NULL));
410 }
411 }
412
TEST_F(AudioDeviceAPITest,RecordingDeviceName)413 TEST_F(AudioDeviceAPITest, RecordingDeviceName) {
414 char name[kAdmMaxDeviceNameSize];
415 char guid[kAdmMaxGuidSize];
416 int16_t no_devices = audio_device_->RecordingDevices();
417
418 // fail tests
419 EXPECT_EQ(-1, audio_device_->RecordingDeviceName(-2, name, guid));
420 EXPECT_EQ(-1, audio_device_->RecordingDeviceName(no_devices, name, guid));
421 EXPECT_EQ(-1, audio_device_->RecordingDeviceName(0, NULL, guid));
422
423 // bulk tests
424 EXPECT_EQ(0, audio_device_->RecordingDeviceName(0, name, NULL));
425 #ifdef _WIN32
426 // shall me mapped to 0
427 EXPECT_EQ(0, audio_device_->RecordingDeviceName(-1, name, NULL));
428 #else
429 EXPECT_EQ(-1, audio_device_->RecordingDeviceName(-1, name, NULL));
430 #endif
431 for (int i = 0; i < no_devices; i++) {
432 EXPECT_EQ(0, audio_device_->RecordingDeviceName(i, name, guid));
433 EXPECT_EQ(0, audio_device_->RecordingDeviceName(i, name, NULL));
434 }
435 }
436
TEST_F(AudioDeviceAPITest,SetPlayoutDevice)437 TEST_F(AudioDeviceAPITest, SetPlayoutDevice) {
438 int16_t no_devices = audio_device_->PlayoutDevices();
439
440 // fail tests
441 EXPECT_EQ(-1, audio_device_->SetPlayoutDevice(-1));
442 EXPECT_EQ(-1, audio_device_->SetPlayoutDevice(no_devices));
443
444 // bulk tests
445 #ifdef _WIN32
446 EXPECT_EQ(0, audio_device_->SetPlayoutDevice(
447 AudioDeviceModule::kDefaultCommunicationDevice));
448 EXPECT_EQ(0, audio_device_->SetPlayoutDevice(
449 AudioDeviceModule::kDefaultDevice));
450 #else
451 EXPECT_EQ(-1, audio_device_->SetPlayoutDevice(
452 AudioDeviceModule::kDefaultCommunicationDevice));
453 EXPECT_EQ(-1, audio_device_->SetPlayoutDevice(
454 AudioDeviceModule::kDefaultDevice));
455 #endif
456 for (int i = 0; i < no_devices; i++) {
457 EXPECT_EQ(0, audio_device_->SetPlayoutDevice(i));
458 }
459 }
460
TEST_F(AudioDeviceAPITest,SetRecordingDevice)461 TEST_F(AudioDeviceAPITest, SetRecordingDevice) {
462 EXPECT_EQ(0, audio_device_->Init());
463 int16_t no_devices = audio_device_->RecordingDevices();
464
465 // fail tests
466 EXPECT_EQ(-1, audio_device_->SetRecordingDevice(-1));
467 EXPECT_EQ(-1, audio_device_->SetRecordingDevice(no_devices));
468
469 // bulk tests
470 #ifdef _WIN32
471 EXPECT_TRUE(audio_device_->SetRecordingDevice(
472 AudioDeviceModule::kDefaultCommunicationDevice) == 0);
473 EXPECT_EQ(0, audio_device_->SetRecordingDevice(
474 AudioDeviceModule::kDefaultDevice));
475 #else
476 EXPECT_TRUE(audio_device_->SetRecordingDevice(
477 AudioDeviceModule::kDefaultCommunicationDevice) == -1);
478 EXPECT_TRUE(audio_device_->SetRecordingDevice(
479 AudioDeviceModule::kDefaultDevice) == -1);
480 #endif
481 for (int i = 0; i < no_devices; i++) {
482 EXPECT_EQ(0, audio_device_->SetRecordingDevice(i));
483 }
484 }
485
TEST_F(AudioDeviceAPITest,PlayoutIsAvailable)486 TEST_F(AudioDeviceAPITest, PlayoutIsAvailable) {
487 bool available;
488 #ifdef _WIN32
489 EXPECT_TRUE(audio_device_->SetPlayoutDevice(
490 AudioDeviceModule::kDefaultCommunicationDevice) == 0);
491 EXPECT_EQ(0, audio_device_->PlayoutIsAvailable(&available));
492 // Availability check should not initialize.
493 EXPECT_FALSE(audio_device_->PlayoutIsInitialized());
494
495 EXPECT_EQ(0,
496 audio_device_->SetPlayoutDevice(AudioDeviceModule::kDefaultDevice));
497 EXPECT_EQ(0, audio_device_->PlayoutIsAvailable(&available));
498 EXPECT_FALSE(audio_device_->PlayoutIsInitialized());
499 #endif
500
501 int16_t no_devices = audio_device_->PlayoutDevices();
502 for (int i = 0; i < no_devices; i++) {
503 EXPECT_EQ(0, audio_device_->SetPlayoutDevice(i));
504 EXPECT_EQ(0, audio_device_->PlayoutIsAvailable(&available));
505 EXPECT_FALSE(audio_device_->PlayoutIsInitialized());
506 }
507 }
508
TEST_F(AudioDeviceAPITest,RecordingIsAvailable)509 TEST_F(AudioDeviceAPITest, RecordingIsAvailable) {
510 bool available;
511 #ifdef _WIN32
512 EXPECT_EQ(0, audio_device_->SetRecordingDevice(
513 AudioDeviceModule::kDefaultCommunicationDevice));
514 EXPECT_EQ(0, audio_device_->RecordingIsAvailable(&available));
515 EXPECT_FALSE(audio_device_->RecordingIsInitialized());
516
517 EXPECT_EQ(0, audio_device_->SetRecordingDevice(
518 AudioDeviceModule::kDefaultDevice));
519 EXPECT_EQ(0, audio_device_->RecordingIsAvailable(&available));
520 EXPECT_FALSE(audio_device_->RecordingIsInitialized());
521 #endif
522
523 int16_t no_devices = audio_device_->RecordingDevices();
524 for (int i = 0; i < no_devices; i++) {
525 EXPECT_EQ(0, audio_device_->SetRecordingDevice(i));
526 EXPECT_EQ(0, audio_device_->RecordingIsAvailable(&available));
527 EXPECT_FALSE(audio_device_->RecordingIsInitialized());
528 }
529 }
530
TEST_F(AudioDeviceAPITest,InitPlayout)531 TEST_F(AudioDeviceAPITest, InitPlayout) {
532 // check initial state
533 EXPECT_FALSE(audio_device_->PlayoutIsInitialized());
534
535 // ensure that device must be set before we can initialize
536 EXPECT_EQ(-1, audio_device_->InitPlayout());
537 EXPECT_EQ(0, audio_device_->SetPlayoutDevice(MACRO_DEFAULT_DEVICE));
538 EXPECT_EQ(0, audio_device_->InitPlayout());
539 EXPECT_TRUE(audio_device_->PlayoutIsInitialized());
540
541 // bulk tests
542 bool available;
543 EXPECT_EQ(0, audio_device_->PlayoutIsAvailable(&available));
544 if (available) {
545 EXPECT_EQ(0, audio_device_->InitPlayout());
546 EXPECT_TRUE(audio_device_->PlayoutIsInitialized());
547 EXPECT_EQ(0, audio_device_->InitPlayout());
548 EXPECT_EQ(-1, audio_device_->SetPlayoutDevice(
549 MACRO_DEFAULT_COMMUNICATION_DEVICE));
550 EXPECT_EQ(0, audio_device_->StopPlayout());
551 EXPECT_FALSE(audio_device_->PlayoutIsInitialized());
552 }
553
554 EXPECT_EQ(0, audio_device_->SetPlayoutDevice(
555 MACRO_DEFAULT_COMMUNICATION_DEVICE));
556 EXPECT_EQ(0, audio_device_->PlayoutIsAvailable(&available));
557 if (available) {
558 EXPECT_EQ(0, audio_device_->InitPlayout());
559 // Sleep is needed for e.g. iPhone since we after stopping then starting may
560 // have a hangover time of a couple of ms before initialized.
561 SleepMs(50);
562 EXPECT_TRUE(audio_device_->PlayoutIsInitialized());
563 }
564
565 int16_t no_devices = audio_device_->PlayoutDevices();
566 for (int i = 0; i < no_devices; i++) {
567 EXPECT_EQ(0, audio_device_->PlayoutIsAvailable(&available));
568 if (available) {
569 EXPECT_EQ(0, audio_device_->StopPlayout());
570 EXPECT_FALSE(audio_device_->PlayoutIsInitialized());
571 EXPECT_EQ(0, audio_device_->SetPlayoutDevice(i));
572 EXPECT_EQ(0, audio_device_->PlayoutIsAvailable(&available));
573 if (available) {
574 EXPECT_EQ(0, audio_device_->InitPlayout());
575 EXPECT_TRUE(audio_device_->PlayoutIsInitialized());
576 }
577 }
578 }
579 EXPECT_EQ(0, audio_device_->StopPlayout());
580 }
581
TEST_F(AudioDeviceAPITest,InitRecording)582 TEST_F(AudioDeviceAPITest, InitRecording) {
583 // check initial state
584 EXPECT_FALSE(audio_device_->RecordingIsInitialized());
585
586 // ensure that device must be set before we can initialize
587 EXPECT_EQ(-1, audio_device_->InitRecording());
588 EXPECT_EQ(0, audio_device_->SetRecordingDevice(MACRO_DEFAULT_DEVICE));
589 EXPECT_EQ(0, audio_device_->InitRecording());
590 EXPECT_TRUE(audio_device_->RecordingIsInitialized());
591
592 // bulk tests
593 bool available;
594 EXPECT_EQ(0, audio_device_->RecordingIsAvailable(&available));
595 if (available) {
596 EXPECT_EQ(0, audio_device_->InitRecording());
597 EXPECT_TRUE(audio_device_->RecordingIsInitialized());
598 EXPECT_EQ(0, audio_device_->InitRecording());
599 EXPECT_EQ(-1,
600 audio_device_->SetRecordingDevice(MACRO_DEFAULT_COMMUNICATION_DEVICE));
601 EXPECT_EQ(0, audio_device_->StopRecording());
602 EXPECT_FALSE(audio_device_->RecordingIsInitialized());
603 }
604
605 EXPECT_EQ(0,
606 audio_device_->SetRecordingDevice(MACRO_DEFAULT_COMMUNICATION_DEVICE));
607 EXPECT_EQ(0, audio_device_->RecordingIsAvailable(&available));
608 if (available) {
609 EXPECT_EQ(0, audio_device_->InitRecording());
610 SleepMs(50);
611 EXPECT_TRUE(audio_device_->RecordingIsInitialized());
612 }
613
614 int16_t no_devices = audio_device_->RecordingDevices();
615 for (int i = 0; i < no_devices; i++) {
616 EXPECT_EQ(0, audio_device_->RecordingIsAvailable(&available));
617 if (available) {
618 EXPECT_EQ(0, audio_device_->StopRecording());
619 EXPECT_FALSE(audio_device_->RecordingIsInitialized());
620 EXPECT_EQ(0, audio_device_->SetRecordingDevice(i));
621 EXPECT_EQ(0, audio_device_->RecordingIsAvailable(&available));
622 if (available) {
623 EXPECT_EQ(0, audio_device_->InitRecording());
624 EXPECT_TRUE(audio_device_->RecordingIsInitialized());
625 }
626 }
627 }
628 EXPECT_EQ(0, audio_device_->StopRecording());
629 }
630
TEST_F(AudioDeviceAPITest,StartAndStopPlayout)631 TEST_F(AudioDeviceAPITest, StartAndStopPlayout) {
632 bool available;
633 EXPECT_EQ(0, audio_device_->RegisterAudioCallback(NULL));
634
635 CheckInitialPlayoutStates();
636
637 EXPECT_EQ(-1, audio_device_->StartPlayout());
638 EXPECT_EQ(0, audio_device_->StopPlayout());
639
640 #ifdef _WIN32
641 // kDefaultCommunicationDevice
642 EXPECT_TRUE(audio_device_->SetPlayoutDevice(
643 AudioDeviceModule::kDefaultCommunicationDevice) == 0);
644 EXPECT_EQ(0, audio_device_->PlayoutIsAvailable(&available));
645 if (available)
646 {
647 EXPECT_FALSE(audio_device_->PlayoutIsInitialized());
648 EXPECT_EQ(0, audio_device_->InitPlayout());
649 EXPECT_EQ(0, audio_device_->StartPlayout());
650 EXPECT_TRUE(audio_device_->Playing());
651 EXPECT_EQ(0, audio_device_->RegisterAudioCallback(audio_transport_));
652 EXPECT_EQ(0, audio_device_->StopPlayout());
653 EXPECT_FALSE(audio_device_->Playing());
654 EXPECT_EQ(0, audio_device_->RegisterAudioCallback(NULL));
655 }
656 #endif
657
658 // repeat test but for kDefaultDevice
659 EXPECT_EQ(0, audio_device_->SetPlayoutDevice(MACRO_DEFAULT_DEVICE));
660 EXPECT_EQ(0, audio_device_->PlayoutIsAvailable(&available));
661 if (available) {
662 EXPECT_FALSE(audio_device_->PlayoutIsInitialized());
663 EXPECT_EQ(0, audio_device_->InitPlayout());
664 EXPECT_EQ(0, audio_device_->StartPlayout());
665 EXPECT_TRUE(audio_device_->Playing());
666 EXPECT_EQ(0, audio_device_->RegisterAudioCallback(audio_transport_));
667 EXPECT_EQ(0, audio_device_->StopPlayout());
668 EXPECT_FALSE(audio_device_->Playing());
669 }
670
671 // repeat test for all devices
672 int16_t no_devices = audio_device_->PlayoutDevices();
673 for (int i = 0; i < no_devices; i++) {
674 EXPECT_EQ(0, audio_device_->SetPlayoutDevice(i));
675 EXPECT_EQ(0, audio_device_->PlayoutIsAvailable(&available));
676 if (available) {
677 EXPECT_FALSE(audio_device_->PlayoutIsInitialized());
678 EXPECT_EQ(0, audio_device_->InitPlayout());
679 EXPECT_EQ(0, audio_device_->StartPlayout());
680 EXPECT_TRUE(audio_device_->Playing());
681 EXPECT_EQ(0, audio_device_->RegisterAudioCallback(audio_transport_));
682 EXPECT_EQ(0, audio_device_->StopPlayout());
683 EXPECT_FALSE(audio_device_->Playing());
684 }
685 }
686 }
687
TEST_F(AudioDeviceAPITest,StartAndStopRecording)688 TEST_F(AudioDeviceAPITest, StartAndStopRecording) {
689 bool available;
690 EXPECT_EQ(0, audio_device_->RegisterAudioCallback(NULL));
691
692 CheckInitialRecordingStates();
693
694 EXPECT_EQ(-1, audio_device_->StartRecording());
695 EXPECT_EQ(0, audio_device_->StopRecording());
696
697 #ifdef _WIN32
698 // kDefaultCommunicationDevice
699 EXPECT_TRUE(audio_device_->SetRecordingDevice(
700 AudioDeviceModule::kDefaultCommunicationDevice) == 0);
701 EXPECT_EQ(0, audio_device_->RecordingIsAvailable(&available));
702 if (available)
703 {
704 EXPECT_FALSE(audio_device_->RecordingIsInitialized());
705 EXPECT_EQ(0, audio_device_->InitRecording());
706 EXPECT_EQ(0, audio_device_->StartRecording());
707 EXPECT_TRUE(audio_device_->Recording());
708 EXPECT_EQ(0, audio_device_->RegisterAudioCallback(audio_transport_));
709 EXPECT_EQ(0, audio_device_->StopRecording());
710 EXPECT_FALSE(audio_device_->Recording());
711 EXPECT_EQ(0, audio_device_->RegisterAudioCallback(NULL));
712 }
713 #endif
714
715 // repeat test but for kDefaultDevice
716 EXPECT_EQ(0, audio_device_->SetRecordingDevice(MACRO_DEFAULT_DEVICE));
717 EXPECT_EQ(0, audio_device_->RecordingIsAvailable(&available));
718 if (available) {
719 EXPECT_FALSE(audio_device_->RecordingIsInitialized());
720 EXPECT_EQ(0, audio_device_->InitRecording());
721 EXPECT_EQ(0, audio_device_->StartRecording());
722 EXPECT_TRUE(audio_device_->Recording());
723 EXPECT_EQ(0, audio_device_->RegisterAudioCallback(audio_transport_));
724 EXPECT_EQ(0, audio_device_->StopRecording());
725 EXPECT_FALSE(audio_device_->Recording());
726 }
727
728 // repeat test for all devices
729 int16_t no_devices = audio_device_->RecordingDevices();
730 for (int i = 0; i < no_devices; i++) {
731 EXPECT_EQ(0, audio_device_->SetRecordingDevice(i));
732 EXPECT_EQ(0, audio_device_->RecordingIsAvailable(&available));
733 if (available) {
734 EXPECT_FALSE(audio_device_->RecordingIsInitialized());
735 EXPECT_EQ(0, audio_device_->InitRecording());
736 EXPECT_EQ(0, audio_device_->StartRecording());
737 EXPECT_TRUE(audio_device_->Recording());
738 EXPECT_EQ(0, audio_device_->RegisterAudioCallback(audio_transport_));
739 EXPECT_EQ(0, audio_device_->StopRecording());
740 EXPECT_FALSE(audio_device_->Recording());
741 }
742 }
743 }
744
745 #if defined(_WIN32) && !defined(WEBRTC_WINDOWS_CORE_AUDIO_BUILD)
TEST_F(AudioDeviceAPITest,SetAndGetWaveOutVolume)746 TEST_F(AudioDeviceAPITest, SetAndGetWaveOutVolume) {
747 uint32_t vol(0);
748 // NOTE 1: Windows Wave only!
749 // NOTE 2: It seems like the waveOutSetVolume API returns
750 // MMSYSERR_NOTSUPPORTED on some Vista machines!
751 const uint16_t maxVol(0xFFFF);
752 uint16_t volL, volR;
753
754 CheckInitialPlayoutStates();
755
756 // make dummy test to see if this API is supported
757 int32_t works = audio_device_->SetWaveOutVolume(vol, vol);
758 WARNING(works == 0);
759
760 if (works == 0)
761 {
762 // set volume without open playout device
763 for (vol = 0; vol <= maxVol; vol += (maxVol/5))
764 {
765 EXPECT_EQ(0, audio_device_->SetWaveOutVolume(vol, vol));
766 EXPECT_EQ(0, audio_device_->WaveOutVolume(volL, volR));
767 EXPECT_TRUE((volL == vol) && (volR == vol));
768 }
769
770 // repeat test but this time with an open (default) output device
771 EXPECT_EQ(0, audio_device_->SetPlayoutDevice(
772 AudioDeviceModule::kDefaultDevice));
773 EXPECT_EQ(0, audio_device_->InitPlayout());
774 EXPECT_TRUE(audio_device_->PlayoutIsInitialized());
775 for (vol = 0; vol <= maxVol; vol += (maxVol/5))
776 {
777 EXPECT_EQ(0, audio_device_->SetWaveOutVolume(vol, vol));
778 EXPECT_EQ(0, audio_device_->WaveOutVolume(volL, volR));
779 EXPECT_TRUE((volL == vol) && (volR == vol));
780 }
781
782 // as above but while playout is active
783 EXPECT_EQ(0, audio_device_->StartPlayout());
784 EXPECT_TRUE(audio_device_->Playing());
785 for (vol = 0; vol <= maxVol; vol += (maxVol/5))
786 {
787 EXPECT_EQ(0, audio_device_->SetWaveOutVolume(vol, vol));
788 EXPECT_EQ(0, audio_device_->WaveOutVolume(volL, volR));
789 EXPECT_TRUE((volL == vol) && (volR == vol));
790 }
791 }
792
793 EXPECT_EQ(0, audio_device_->StopPlayout());
794 EXPECT_FALSE(audio_device_->Playing());
795 }
796 #endif // defined(_WIN32) && !defined(WEBRTC_WINDOWS_CORE_AUDIO_BUILD)
797
TEST_F(AudioDeviceAPITest,InitSpeaker)798 TEST_F(AudioDeviceAPITest, InitSpeaker) {
799 // NOTE: By calling Terminate (in TearDown) followed by Init (in SetUp) we
800 // ensure that any existing output mixer handle is set to NULL.
801 // The mixer handle is closed and reopened again for each call to
802 // SetPlayoutDevice.
803 CheckInitialPlayoutStates();
804
805 // kDefaultCommunicationDevice
806 EXPECT_EQ(0, audio_device_->SetPlayoutDevice(
807 MACRO_DEFAULT_COMMUNICATION_DEVICE));
808 EXPECT_EQ(0, audio_device_->InitSpeaker());
809
810 // fail tests
811 bool available;
812 EXPECT_EQ(0, audio_device_->PlayoutIsAvailable(&available));
813 if (available) {
814 EXPECT_EQ(0, audio_device_->InitPlayout());
815 EXPECT_EQ(0, audio_device_->StartPlayout());
816 EXPECT_EQ(-1, audio_device_->InitSpeaker());
817 EXPECT_EQ(0, audio_device_->StopPlayout());
818 }
819
820 // kDefaultDevice
821 EXPECT_EQ(0, audio_device_->SetPlayoutDevice(MACRO_DEFAULT_DEVICE));
822 EXPECT_EQ(0, audio_device_->InitSpeaker());
823
824 // repeat test for all devices
825 int16_t no_devices = audio_device_->PlayoutDevices();
826 for (int i = 0; i < no_devices; i++) {
827 EXPECT_EQ(0, audio_device_->SetPlayoutDevice(i));
828 EXPECT_EQ(0, audio_device_->InitSpeaker());
829 }
830 }
831
TEST_F(AudioDeviceAPITest,InitMicrophone)832 TEST_F(AudioDeviceAPITest, InitMicrophone) {
833 // NOTE: By calling Terminate (in TearDown) followed by Init (in SetUp) we
834 // ensure that any existing output mixer handle is set to NULL.
835 // The mixer handle is closed and reopened again for each call to
836 // SetRecordingDevice.
837 CheckInitialRecordingStates();
838
839 // kDefaultCommunicationDevice
840 EXPECT_EQ(0,
841 audio_device_->SetRecordingDevice(MACRO_DEFAULT_COMMUNICATION_DEVICE));
842 EXPECT_EQ(0, audio_device_->InitMicrophone());
843
844 // fail tests
845 bool available;
846 EXPECT_EQ(0, audio_device_->RecordingIsAvailable(&available));
847 if (available) {
848 EXPECT_EQ(0, audio_device_->InitRecording());
849 EXPECT_EQ(0, audio_device_->StartRecording());
850 EXPECT_EQ(-1, audio_device_->InitMicrophone());
851 EXPECT_EQ(0, audio_device_->StopRecording());
852 }
853
854 // kDefaultDevice
855 EXPECT_EQ(0, audio_device_->SetRecordingDevice(MACRO_DEFAULT_DEVICE));
856 EXPECT_EQ(0, audio_device_->InitMicrophone());
857
858 // repeat test for all devices
859 int16_t no_devices = audio_device_->RecordingDevices();
860 for (int i = 0; i < no_devices; i++) {
861 EXPECT_EQ(0, audio_device_->SetRecordingDevice(i));
862 EXPECT_EQ(0, audio_device_->InitMicrophone());
863 }
864 }
865
TEST_F(AudioDeviceAPITest,SpeakerVolumeIsAvailable)866 TEST_F(AudioDeviceAPITest, SpeakerVolumeIsAvailable) {
867 CheckInitialPlayoutStates();
868 bool available;
869
870 #ifdef _WIN32
871 // check the kDefaultCommunicationDevice
872 EXPECT_TRUE(audio_device_->SetPlayoutDevice(
873 AudioDeviceModule::kDefaultCommunicationDevice) == 0);
874 EXPECT_EQ(0, audio_device_->SpeakerVolumeIsAvailable(&available));
875 // check for availability should not lead to initialization
876 EXPECT_FALSE(audio_device_->SpeakerIsInitialized());
877 #endif
878
879 // check the kDefaultDevice
880 EXPECT_EQ(0, audio_device_->SetPlayoutDevice(MACRO_DEFAULT_DEVICE));
881 EXPECT_EQ(0, audio_device_->SpeakerVolumeIsAvailable(&available));
882 EXPECT_FALSE(audio_device_->SpeakerIsInitialized());
883
884 // check all availiable devices
885 int16_t no_devices = audio_device_->PlayoutDevices();
886 for (int i = 0; i < no_devices; i++) {
887 EXPECT_EQ(0, audio_device_->SetPlayoutDevice(i));
888 EXPECT_EQ(0, audio_device_->SpeakerVolumeIsAvailable(&available));
889 EXPECT_FALSE(audio_device_->SpeakerIsInitialized());
890 }
891 }
892
893 // Tests the following methods:
894 // SetSpeakerVolume
895 // SpeakerVolume
896 // MaxSpeakerVolume
897 // MinSpeakerVolume
898 // NOTE: Disabled on mac due to issue 257.
899 #ifndef WEBRTC_MAC
TEST_F(AudioDeviceAPITest,SpeakerVolumeTests)900 TEST_F(AudioDeviceAPITest, SpeakerVolumeTests) {
901 uint32_t vol(0);
902 uint32_t volume(0);
903 uint32_t maxVolume(0);
904 uint32_t minVolume(0);
905 uint16_t stepSize(0);
906 bool available;
907 CheckInitialPlayoutStates();
908
909 // fail tests
910 EXPECT_EQ(-1, audio_device_->SetSpeakerVolume(0));
911 // speaker must be initialized first
912 EXPECT_EQ(-1, audio_device_->SpeakerVolume(&volume));
913 EXPECT_EQ(-1, audio_device_->MaxSpeakerVolume(&maxVolume));
914 EXPECT_EQ(-1, audio_device_->MinSpeakerVolume(&minVolume));
915 EXPECT_EQ(-1, audio_device_->SpeakerVolumeStepSize(&stepSize));
916
917 #if defined(_WIN32) && !defined(WEBRTC_WINDOWS_CORE_AUDIO_BUILD)
918 // test for warning (can e.g. happen on Vista with Wave API)
919 EXPECT_EQ(0,
920 audio_device_->SetPlayoutDevice(AudioDeviceModule::kDefaultDevice));
921 EXPECT_EQ(0, audio_device_->SpeakerVolumeIsAvailable(&available));
922 if (available) {
923 EXPECT_EQ(0, audio_device_->InitSpeaker());
924 EXPECT_EQ(0, audio_device_->SetSpeakerVolume(19001));
925 EXPECT_EQ(0, audio_device_->SpeakerVolume(&volume));
926 WARNING(volume == 19001);
927 }
928 #endif
929
930 #ifdef _WIN32
931 // use kDefaultCommunicationDevice and modify/retrieve the volume
932 EXPECT_TRUE(audio_device_->SetPlayoutDevice(
933 AudioDeviceModule::kDefaultCommunicationDevice) == 0);
934 EXPECT_EQ(0, audio_device_->SpeakerVolumeIsAvailable(&available));
935 if (available) {
936 EXPECT_EQ(0, audio_device_->InitSpeaker());
937 EXPECT_EQ(0, audio_device_->MaxSpeakerVolume(&maxVolume));
938 EXPECT_EQ(0, audio_device_->MinSpeakerVolume(&minVolume));
939 EXPECT_EQ(0, audio_device_->SpeakerVolumeStepSize(&stepSize));
940 for (vol = minVolume; vol < (int)maxVolume; vol += 20*stepSize) {
941 EXPECT_EQ(0, audio_device_->SetSpeakerVolume(vol));
942 EXPECT_EQ(0, audio_device_->SpeakerVolume(&volume));
943 CheckVolume(volume, vol);
944 }
945 }
946 #endif
947
948 // use kDefaultDevice and modify/retrieve the volume
949 EXPECT_EQ(0, audio_device_->SetPlayoutDevice(MACRO_DEFAULT_DEVICE));
950 EXPECT_EQ(0, audio_device_->SpeakerVolumeIsAvailable(&available));
951 if (available) {
952 EXPECT_EQ(0, audio_device_->InitSpeaker());
953 EXPECT_EQ(0, audio_device_->MaxSpeakerVolume(&maxVolume));
954 EXPECT_EQ(0, audio_device_->MinSpeakerVolume(&minVolume));
955 EXPECT_EQ(0, audio_device_->SpeakerVolumeStepSize(&stepSize));
956 uint32_t step = (maxVolume - minVolume) / 10;
957 step = (step < stepSize ? stepSize : step);
958 for (vol = minVolume; vol <= maxVolume; vol += step) {
959 EXPECT_EQ(0, audio_device_->SetSpeakerVolume(vol));
960 EXPECT_EQ(0, audio_device_->SpeakerVolume(&volume));
961 CheckVolume(volume, vol);
962 }
963 }
964
965 // use all (indexed) devices and modify/retrieve the volume
966 int16_t no_devices = audio_device_->PlayoutDevices();
967 for (int i = 0; i < no_devices; i++) {
968 EXPECT_EQ(0, audio_device_->SetPlayoutDevice(i));
969 EXPECT_EQ(0, audio_device_->SpeakerVolumeIsAvailable(&available));
970 if (available) {
971 EXPECT_EQ(0, audio_device_->InitSpeaker());
972 EXPECT_EQ(0, audio_device_->MaxSpeakerVolume(&maxVolume));
973 EXPECT_EQ(0, audio_device_->MinSpeakerVolume(&minVolume));
974 EXPECT_EQ(0, audio_device_->SpeakerVolumeStepSize(&stepSize));
975 uint32_t step = (maxVolume - minVolume) / 10;
976 step = (step < stepSize ? stepSize : step);
977 for (vol = minVolume; vol <= maxVolume; vol += step) {
978 EXPECT_EQ(0, audio_device_->SetSpeakerVolume(vol));
979 EXPECT_EQ(0, audio_device_->SpeakerVolume(&volume));
980 CheckVolume(volume, vol);
981 }
982 }
983 }
984
985 // restore reasonable level
986 EXPECT_EQ(0, audio_device_->SetPlayoutDevice(MACRO_DEFAULT_DEVICE));
987 EXPECT_EQ(0, audio_device_->SpeakerVolumeIsAvailable(&available));
988 if (available) {
989 EXPECT_EQ(0, audio_device_->InitSpeaker());
990 EXPECT_EQ(0, audio_device_->MaxSpeakerVolume(&maxVolume));
991 EXPECT_TRUE(audio_device_->SetSpeakerVolume(maxVolume < 10 ?
992 maxVolume/3 : maxVolume/10) == 0);
993 }
994 }
995 #endif // !WEBRTC_MAC
996
TEST_F(AudioDeviceAPITest,AGC)997 TEST_F(AudioDeviceAPITest, AGC) {
998 // NOTE: The AGC API only enables/disables the AGC. To ensure that it will
999 // have an effect, use it in combination with MicrophoneVolumeIsAvailable.
1000 CheckInitialRecordingStates();
1001 EXPECT_FALSE(audio_device_->AGC());
1002
1003 // set/get tests
1004 EXPECT_EQ(0, audio_device_->SetAGC(true));
1005 EXPECT_TRUE(audio_device_->AGC());
1006 EXPECT_EQ(0, audio_device_->SetAGC(false));
1007 EXPECT_FALSE(audio_device_->AGC());
1008 }
1009
TEST_F(AudioDeviceAPITest,MicrophoneVolumeIsAvailable)1010 TEST_F(AudioDeviceAPITest, MicrophoneVolumeIsAvailable) {
1011 CheckInitialRecordingStates();
1012 bool available;
1013
1014 #ifdef _WIN32
1015 // check the kDefaultCommunicationDevice
1016 EXPECT_TRUE(audio_device_->SetRecordingDevice(
1017 AudioDeviceModule::kDefaultCommunicationDevice) == 0);
1018 EXPECT_EQ(0, audio_device_->MicrophoneVolumeIsAvailable(&available));
1019 // check for availability should not lead to initialization
1020 EXPECT_FALSE(audio_device_->MicrophoneIsInitialized());
1021 #endif
1022
1023 // check the kDefaultDevice
1024 EXPECT_EQ(0, audio_device_->SetRecordingDevice(MACRO_DEFAULT_DEVICE));
1025 EXPECT_EQ(0, audio_device_->MicrophoneVolumeIsAvailable(&available));
1026 EXPECT_FALSE(audio_device_->MicrophoneIsInitialized());
1027
1028 // check all availiable devices
1029 int16_t no_devices = audio_device_->RecordingDevices();
1030 for (int i = 0; i < no_devices; i++) {
1031 EXPECT_EQ(0, audio_device_->SetRecordingDevice(i));
1032 EXPECT_EQ(0, audio_device_->MicrophoneVolumeIsAvailable(&available));
1033 EXPECT_FALSE(audio_device_->MicrophoneIsInitialized());
1034 }
1035 }
1036
1037 // Tests the methods:
1038 // SetMicrophoneVolume
1039 // MicrophoneVolume
1040 // MaxMicrophoneVolume
1041 // MinMicrophoneVolume
1042 // NOTE: Disabled on mac due to issue 257.
1043 #ifndef WEBRTC_MAC
TEST_F(AudioDeviceAPITest,MicrophoneVolumeTests)1044 TEST_F(AudioDeviceAPITest, MicrophoneVolumeTests) {
1045 uint32_t vol(0);
1046 uint32_t volume(0);
1047 uint32_t maxVolume(0);
1048 uint32_t minVolume(0);
1049 uint16_t stepSize(0);
1050 bool available;
1051 CheckInitialRecordingStates();
1052
1053 // fail tests
1054 EXPECT_EQ(-1, audio_device_->SetMicrophoneVolume(0));
1055 // must be initialized first
1056 EXPECT_EQ(-1, audio_device_->MicrophoneVolume(&volume));
1057 EXPECT_EQ(-1, audio_device_->MaxMicrophoneVolume(&maxVolume));
1058 EXPECT_EQ(-1, audio_device_->MinMicrophoneVolume(&minVolume));
1059 EXPECT_EQ(-1, audio_device_->MicrophoneVolumeStepSize(&stepSize));
1060
1061 #if defined(_WIN32) && !defined(WEBRTC_WINDOWS_CORE_AUDIO_BUILD)
1062 // test for warning (can e.g. happen on Vista with Wave API)
1063 EXPECT_EQ(0, audio_device_->SetRecordingDevice(
1064 AudioDeviceModule::kDefaultDevice));
1065 EXPECT_EQ(0, audio_device_->MicrophoneVolumeIsAvailable(&available));
1066 if (available)
1067 {
1068 EXPECT_EQ(0, audio_device_->InitMicrophone());
1069 EXPECT_EQ(0, audio_device_->SetMicrophoneVolume(19001));
1070 EXPECT_EQ(0, audio_device_->MicrophoneVolume(&volume));
1071 WARNING(volume == 19001);
1072 }
1073 #endif
1074
1075 #ifdef _WIN32
1076 // initialize kDefaultCommunicationDevice and modify/retrieve the volume
1077 EXPECT_TRUE(audio_device_->SetRecordingDevice(
1078 AudioDeviceModule::kDefaultCommunicationDevice) == 0);
1079 EXPECT_EQ(0, audio_device_->MicrophoneVolumeIsAvailable(&available));
1080 if (available)
1081 {
1082 EXPECT_EQ(0, audio_device_->InitMicrophone());
1083 EXPECT_EQ(0, audio_device_->MaxMicrophoneVolume(&maxVolume));
1084 EXPECT_EQ(0, audio_device_->MinMicrophoneVolume(&minVolume));
1085 EXPECT_EQ(0, audio_device_->MicrophoneVolumeStepSize(&stepSize));
1086 for (vol = minVolume; vol < (int)maxVolume; vol += 10*stepSize)
1087 {
1088 EXPECT_EQ(0, audio_device_->SetMicrophoneVolume(vol));
1089 EXPECT_EQ(0, audio_device_->MicrophoneVolume(&volume));
1090 CheckVolume(volume, vol);
1091 }
1092 }
1093 #endif
1094
1095 // reinitialize kDefaultDevice and modify/retrieve the volume
1096 EXPECT_EQ(0, audio_device_->SetRecordingDevice(MACRO_DEFAULT_DEVICE));
1097 EXPECT_EQ(0, audio_device_->MicrophoneVolumeIsAvailable(&available));
1098 if (available) {
1099 EXPECT_EQ(0, audio_device_->InitMicrophone());
1100 EXPECT_EQ(0, audio_device_->MaxMicrophoneVolume(&maxVolume));
1101 EXPECT_EQ(0, audio_device_->MinMicrophoneVolume(&minVolume));
1102 EXPECT_EQ(0, audio_device_->MicrophoneVolumeStepSize(&stepSize));
1103 for (vol = minVolume; vol < maxVolume; vol += 10 * stepSize) {
1104 EXPECT_EQ(0, audio_device_->SetMicrophoneVolume(vol));
1105 EXPECT_EQ(0, audio_device_->MicrophoneVolume(&volume));
1106 CheckVolume(volume, vol);
1107 }
1108 }
1109
1110 // use all (indexed) devices and modify/retrieve the volume
1111 int16_t no_devices = audio_device_->RecordingDevices();
1112 for (int i = 0; i < no_devices; i++) {
1113 EXPECT_EQ(0, audio_device_->SetRecordingDevice(i));
1114 EXPECT_EQ(0, audio_device_->MicrophoneVolumeIsAvailable(&available));
1115 if (available) {
1116 EXPECT_EQ(0, audio_device_->InitMicrophone());
1117 EXPECT_EQ(0, audio_device_->MaxMicrophoneVolume(&maxVolume));
1118 EXPECT_EQ(0, audio_device_->MinMicrophoneVolume(&minVolume));
1119 EXPECT_EQ(0, audio_device_->MicrophoneVolumeStepSize(&stepSize));
1120 for (vol = minVolume; vol < maxVolume; vol += 20 * stepSize) {
1121 EXPECT_EQ(0, audio_device_->SetMicrophoneVolume(vol));
1122 EXPECT_EQ(0, audio_device_->MicrophoneVolume(&volume));
1123 CheckVolume(volume, vol);
1124 }
1125 }
1126 }
1127
1128 // restore reasonable level
1129 EXPECT_EQ(0, audio_device_->SetRecordingDevice(MACRO_DEFAULT_DEVICE));
1130 EXPECT_EQ(0, audio_device_->MicrophoneVolumeIsAvailable(&available));
1131 if (available) {
1132 EXPECT_EQ(0, audio_device_->InitMicrophone());
1133 EXPECT_EQ(0, audio_device_->MaxMicrophoneVolume(&maxVolume));
1134 EXPECT_EQ(0, audio_device_->SetMicrophoneVolume(maxVolume/10));
1135 }
1136 }
1137 #endif // !WEBRTC_MAC
1138
TEST_F(AudioDeviceAPITest,SpeakerMuteIsAvailable)1139 TEST_F(AudioDeviceAPITest, SpeakerMuteIsAvailable) {
1140 bool available;
1141 CheckInitialPlayoutStates();
1142 #ifdef _WIN32
1143 // check the kDefaultCommunicationDevice
1144 EXPECT_TRUE(audio_device_->SetPlayoutDevice(
1145 AudioDeviceModule::kDefaultCommunicationDevice) == 0);
1146 EXPECT_EQ(0, audio_device_->SpeakerMuteIsAvailable(&available));
1147 // check for availability should not lead to initialization
1148 EXPECT_FALSE(audio_device_->SpeakerIsInitialized());
1149 #endif
1150
1151 // check the kDefaultDevice
1152 EXPECT_EQ(0, audio_device_->SetPlayoutDevice(MACRO_DEFAULT_DEVICE));
1153 EXPECT_EQ(0, audio_device_->SpeakerMuteIsAvailable(&available));
1154 EXPECT_FALSE(audio_device_->SpeakerIsInitialized());
1155
1156 // check all availiable devices
1157 int16_t no_devices = audio_device_->PlayoutDevices();
1158 for (int i = 0; i < no_devices; i++) {
1159 EXPECT_EQ(0, audio_device_->SetPlayoutDevice(i));
1160 EXPECT_EQ(0, audio_device_->SpeakerMuteIsAvailable(&available));
1161 EXPECT_FALSE(audio_device_->SpeakerIsInitialized());
1162 }
1163 }
1164
TEST_F(AudioDeviceAPITest,MicrophoneMuteIsAvailable)1165 TEST_F(AudioDeviceAPITest, MicrophoneMuteIsAvailable) {
1166 bool available;
1167 CheckInitialRecordingStates();
1168 #ifdef _WIN32
1169 // check the kDefaultCommunicationDevice
1170 EXPECT_TRUE(audio_device_->SetRecordingDevice(
1171 AudioDeviceModule::kDefaultCommunicationDevice) == 0);
1172 EXPECT_EQ(0, audio_device_->MicrophoneMuteIsAvailable(&available));
1173 // check for availability should not lead to initialization
1174 #endif
1175 EXPECT_FALSE(audio_device_->MicrophoneIsInitialized());
1176
1177 // check the kDefaultDevice
1178 EXPECT_EQ(0, audio_device_->SetRecordingDevice(MACRO_DEFAULT_DEVICE));
1179 EXPECT_EQ(0, audio_device_->MicrophoneMuteIsAvailable(&available));
1180 EXPECT_FALSE(audio_device_->MicrophoneIsInitialized());
1181
1182 // check all availiable devices
1183 int16_t no_devices = audio_device_->RecordingDevices();
1184 for (int i = 0; i < no_devices; i++) {
1185 EXPECT_EQ(0, audio_device_->SetRecordingDevice(i));
1186 EXPECT_EQ(0, audio_device_->MicrophoneMuteIsAvailable(&available));
1187 EXPECT_FALSE(audio_device_->MicrophoneIsInitialized());
1188 }
1189 }
1190
TEST_F(AudioDeviceAPITest,MicrophoneBoostIsAvailable)1191 TEST_F(AudioDeviceAPITest, MicrophoneBoostIsAvailable) {
1192 bool available;
1193 CheckInitialRecordingStates();
1194 #ifdef _WIN32
1195 // check the kDefaultCommunicationDevice
1196 EXPECT_TRUE(audio_device_->SetRecordingDevice(
1197 AudioDeviceModule::kDefaultCommunicationDevice) == 0);
1198 EXPECT_EQ(0, audio_device_->MicrophoneBoostIsAvailable(&available));
1199 // check for availability should not lead to initialization
1200 EXPECT_FALSE(audio_device_->MicrophoneIsInitialized());
1201 #endif
1202
1203 // check the kDefaultDevice
1204 EXPECT_EQ(0, audio_device_->SetRecordingDevice(MACRO_DEFAULT_DEVICE));
1205 EXPECT_EQ(0, audio_device_->MicrophoneBoostIsAvailable(&available));
1206 EXPECT_FALSE(audio_device_->MicrophoneIsInitialized());
1207
1208 // check all availiable devices
1209 int16_t no_devices = audio_device_->RecordingDevices();
1210 for (int i = 0; i < no_devices; i++) {
1211 EXPECT_EQ(0, audio_device_->SetRecordingDevice(i));
1212 EXPECT_EQ(0, audio_device_->MicrophoneBoostIsAvailable(&available));
1213 EXPECT_FALSE(audio_device_->MicrophoneIsInitialized());
1214 }
1215 }
1216
TEST_F(AudioDeviceAPITest,SpeakerMuteTests)1217 TEST_F(AudioDeviceAPITest, SpeakerMuteTests) {
1218 bool available;
1219 bool enabled;
1220 CheckInitialPlayoutStates();
1221 // fail tests
1222 EXPECT_EQ(-1, audio_device_->SetSpeakerMute(true));
1223 // requires initialization
1224 EXPECT_EQ(-1, audio_device_->SpeakerMute(&enabled));
1225
1226 #ifdef _WIN32
1227 // initialize kDefaultCommunicationDevice and modify/retrieve the mute state
1228 EXPECT_EQ(0, audio_device_->SetPlayoutDevice(
1229 AudioDeviceModule::kDefaultCommunicationDevice));
1230 EXPECT_EQ(0, audio_device_->SpeakerMuteIsAvailable(&available));
1231 if (available)
1232 {
1233 EXPECT_EQ(0, audio_device_->InitSpeaker());
1234 EXPECT_EQ(0, audio_device_->SetSpeakerMute(true));
1235 EXPECT_EQ(0, audio_device_->SpeakerMute(&enabled));
1236 EXPECT_TRUE(enabled);
1237 EXPECT_EQ(0, audio_device_->SetSpeakerMute(false));
1238 EXPECT_EQ(0, audio_device_->SpeakerMute(&enabled));
1239 EXPECT_FALSE(enabled);
1240 }
1241 #endif
1242
1243 // reinitialize kDefaultDevice and modify/retrieve the mute state
1244 EXPECT_EQ(0, audio_device_->SetPlayoutDevice(MACRO_DEFAULT_DEVICE));
1245 EXPECT_EQ(0, audio_device_->SpeakerMuteIsAvailable(&available));
1246 if (available) {
1247 EXPECT_EQ(0, audio_device_->InitSpeaker());
1248 EXPECT_EQ(0, audio_device_->SetSpeakerMute(true));
1249 EXPECT_EQ(0, audio_device_->SpeakerMute(&enabled));
1250 EXPECT_TRUE(enabled);
1251 EXPECT_EQ(0, audio_device_->SetSpeakerMute(false));
1252 EXPECT_EQ(0, audio_device_->SpeakerMute(&enabled));
1253 EXPECT_FALSE(enabled);
1254 }
1255
1256 // reinitialize the default device (0) and modify/retrieve the mute state
1257 EXPECT_EQ(0, audio_device_->SetPlayoutDevice(0));
1258 EXPECT_EQ(0, audio_device_->SpeakerMuteIsAvailable(&available));
1259 if (available) {
1260 EXPECT_EQ(0, audio_device_->InitSpeaker());
1261 EXPECT_EQ(0, audio_device_->SetSpeakerMute(true));
1262 EXPECT_EQ(0, audio_device_->SpeakerMute(&enabled));
1263 EXPECT_TRUE(enabled);
1264 EXPECT_EQ(0, audio_device_->SetSpeakerMute(false));
1265 EXPECT_EQ(0, audio_device_->SpeakerMute(&enabled));
1266 EXPECT_FALSE(enabled);
1267 }
1268 }
1269
TEST_F(AudioDeviceAPITest,MicrophoneMuteTests)1270 TEST_F(AudioDeviceAPITest, MicrophoneMuteTests) {
1271 CheckInitialRecordingStates();
1272
1273 // fail tests
1274 EXPECT_EQ(-1, audio_device_->SetMicrophoneMute(true));
1275 // requires initialization
1276 bool available;
1277 bool enabled;
1278 EXPECT_EQ(-1, audio_device_->MicrophoneMute(&enabled));
1279
1280 #ifdef _WIN32
1281 // initialize kDefaultCommunicationDevice and modify/retrieve the mute
1282 EXPECT_TRUE(audio_device_->SetRecordingDevice(
1283 AudioDeviceModule::kDefaultCommunicationDevice) == 0);
1284 EXPECT_EQ(0, audio_device_->MicrophoneMuteIsAvailable(&available));
1285 if (available)
1286 {
1287 EXPECT_EQ(0, audio_device_->InitMicrophone());
1288 EXPECT_EQ(0, audio_device_->SetMicrophoneMute(true));
1289 EXPECT_EQ(0, audio_device_->MicrophoneMute(&enabled));
1290 EXPECT_TRUE(enabled);
1291 EXPECT_EQ(0, audio_device_->SetMicrophoneMute(false));
1292 EXPECT_EQ(0, audio_device_->MicrophoneMute(&enabled));
1293 EXPECT_FALSE(enabled);
1294 }
1295 #endif
1296
1297 // reinitialize kDefaultDevice and modify/retrieve the mute
1298 EXPECT_EQ(0, audio_device_->SetRecordingDevice(MACRO_DEFAULT_DEVICE));
1299 EXPECT_EQ(0, audio_device_->MicrophoneMuteIsAvailable(&available));
1300 if (available) {
1301 EXPECT_EQ(0, audio_device_->InitMicrophone());
1302 EXPECT_EQ(0, audio_device_->SetMicrophoneMute(true));
1303 EXPECT_EQ(0, audio_device_->MicrophoneMute(&enabled));
1304 EXPECT_TRUE(enabled);
1305 EXPECT_EQ(0, audio_device_->SetMicrophoneMute(false));
1306 EXPECT_EQ(0, audio_device_->MicrophoneMute(&enabled));
1307 EXPECT_FALSE(enabled);
1308 }
1309
1310 // reinitialize the default device (0) and modify/retrieve the Mute
1311 EXPECT_EQ(0, audio_device_->SetRecordingDevice(0));
1312 EXPECT_EQ(0, audio_device_->MicrophoneMuteIsAvailable(&available));
1313 if (available) {
1314 EXPECT_EQ(0, audio_device_->InitMicrophone());
1315 EXPECT_EQ(0, audio_device_->SetMicrophoneMute(true));
1316 EXPECT_EQ(0, audio_device_->MicrophoneMute(&enabled));
1317 EXPECT_TRUE(enabled);
1318 EXPECT_EQ(0, audio_device_->SetMicrophoneMute(false));
1319 EXPECT_EQ(0, audio_device_->MicrophoneMute(&enabled));
1320 EXPECT_FALSE(enabled);
1321 }
1322 }
1323
TEST_F(AudioDeviceAPITest,MicrophoneBoostTests)1324 TEST_F(AudioDeviceAPITest, MicrophoneBoostTests) {
1325 bool available;
1326 bool enabled;
1327 CheckInitialRecordingStates();
1328
1329 // fail tests
1330 EXPECT_EQ(-1, audio_device_->SetMicrophoneBoost(true));
1331 // requires initialization
1332 EXPECT_EQ(-1, audio_device_->MicrophoneBoost(&enabled));
1333
1334 #ifdef _WIN32
1335 // initialize kDefaultCommunicationDevice and modify/retrieve the boost
1336 EXPECT_TRUE(audio_device_->SetRecordingDevice(
1337 AudioDeviceModule::kDefaultCommunicationDevice) == 0);
1338 EXPECT_EQ(0, audio_device_->MicrophoneBoostIsAvailable(&available));
1339 if (available)
1340 {
1341 EXPECT_EQ(0, audio_device_->InitMicrophone());
1342 EXPECT_EQ(0, audio_device_->SetMicrophoneBoost(true));
1343 EXPECT_EQ(0, audio_device_->MicrophoneBoost(&enabled));
1344 EXPECT_TRUE(enabled);
1345 EXPECT_EQ(0, audio_device_->SetMicrophoneBoost(false));
1346 EXPECT_EQ(0, audio_device_->MicrophoneBoost(&enabled));
1347 EXPECT_FALSE(enabled);
1348 }
1349 #endif
1350
1351 // reinitialize kDefaultDevice and modify/retrieve the boost
1352 EXPECT_EQ(0, audio_device_->SetRecordingDevice(MACRO_DEFAULT_DEVICE));
1353 EXPECT_EQ(0, audio_device_->MicrophoneBoostIsAvailable(&available));
1354 if (available) {
1355 EXPECT_EQ(0, audio_device_->InitMicrophone());
1356 EXPECT_EQ(0, audio_device_->SetMicrophoneBoost(true));
1357 EXPECT_EQ(0, audio_device_->MicrophoneBoost(&enabled));
1358 EXPECT_TRUE(enabled);
1359 EXPECT_EQ(0, audio_device_->SetMicrophoneBoost(false));
1360 EXPECT_EQ(0, audio_device_->MicrophoneBoost(&enabled));
1361 EXPECT_FALSE(enabled);
1362 }
1363
1364 // reinitialize the default device (0) and modify/retrieve the boost
1365 EXPECT_EQ(0, audio_device_->SetRecordingDevice(0));
1366 EXPECT_EQ(0, audio_device_->MicrophoneBoostIsAvailable(&available));
1367 if (available) {
1368 EXPECT_EQ(0, audio_device_->InitMicrophone());
1369 EXPECT_EQ(0, audio_device_->SetMicrophoneBoost(true));
1370 EXPECT_EQ(0, audio_device_->MicrophoneBoost(&enabled));
1371 EXPECT_TRUE(enabled);
1372 EXPECT_EQ(0, audio_device_->SetMicrophoneBoost(false));
1373 EXPECT_EQ(0, audio_device_->MicrophoneBoost(&enabled));
1374 EXPECT_FALSE(enabled);
1375 }
1376 }
1377
TEST_F(AudioDeviceAPITest,StereoPlayoutTests)1378 TEST_F(AudioDeviceAPITest, StereoPlayoutTests) {
1379 CheckInitialPlayoutStates();
1380
1381 // fail tests
1382 EXPECT_EQ(-1, audio_device_->InitPlayout());
1383 EXPECT_EQ(0, audio_device_->SetPlayoutDevice(
1384 MACRO_DEFAULT_COMMUNICATION_DEVICE));
1385
1386 // TODO(kjellander): Fix so these tests pass on Mac.
1387 #if !defined(WEBRTC_MAC)
1388 EXPECT_EQ(0, audio_device_->InitPlayout());
1389 EXPECT_TRUE(audio_device_->PlayoutIsInitialized());
1390 // must be performed before initialization
1391 EXPECT_EQ(-1, audio_device_->SetStereoPlayout(true));
1392 #endif
1393
1394 // ensure that we can set the stereo mode for playout
1395 EXPECT_EQ(0, audio_device_->StopPlayout());
1396 EXPECT_FALSE(audio_device_->PlayoutIsInitialized());
1397
1398 // initialize kDefaultCommunicationDevice and modify/retrieve stereo support
1399 EXPECT_EQ(0, audio_device_->SetPlayoutDevice(
1400 MACRO_DEFAULT_COMMUNICATION_DEVICE));
1401 bool available;
1402 bool enabled;
1403 EXPECT_EQ(0, audio_device_->StereoPlayoutIsAvailable(&available));
1404 if (available) {
1405 EXPECT_EQ(0, audio_device_->SetStereoPlayout(true));
1406 EXPECT_EQ(0, audio_device_->StereoPlayout(&enabled));
1407 EXPECT_TRUE(enabled);
1408 EXPECT_EQ(0, audio_device_->SetStereoPlayout(false));
1409 EXPECT_EQ(0, audio_device_->StereoPlayout(&enabled));
1410 EXPECT_FALSE(enabled);
1411 EXPECT_EQ(0, audio_device_->SetStereoPlayout(true));
1412 EXPECT_EQ(0, audio_device_->StereoPlayout(&enabled));
1413 EXPECT_TRUE(enabled);
1414 }
1415
1416 // initialize kDefaultDevice and modify/retrieve stereo support
1417 EXPECT_EQ(0, audio_device_->SetPlayoutDevice(MACRO_DEFAULT_DEVICE));
1418 EXPECT_EQ(0, audio_device_->StereoPlayoutIsAvailable(&available));
1419 if (available) {
1420 EXPECT_EQ(0, audio_device_->SetStereoPlayout(true));
1421 EXPECT_EQ(0, audio_device_->StereoPlayout(&enabled));
1422 EXPECT_TRUE(enabled);
1423 EXPECT_EQ(0, audio_device_->SetStereoPlayout(false));
1424 EXPECT_EQ(0, audio_device_->StereoPlayout(&enabled));
1425 EXPECT_FALSE(enabled);
1426 EXPECT_EQ(0, audio_device_->SetStereoPlayout(true));
1427 EXPECT_EQ(0, audio_device_->StereoPlayout(&enabled));
1428 EXPECT_TRUE(enabled);
1429 }
1430
1431 // initialize default device (0) and modify/retrieve stereo support
1432 EXPECT_EQ(0, audio_device_->SetPlayoutDevice(0));
1433 EXPECT_EQ(0, audio_device_->StereoPlayoutIsAvailable(&available));
1434 if (available) {
1435 EXPECT_EQ(0, audio_device_->SetStereoPlayout(true));
1436 EXPECT_EQ(0, audio_device_->StereoPlayout(&enabled));
1437 EXPECT_TRUE(enabled);
1438 EXPECT_EQ(0, audio_device_->SetStereoPlayout(false));
1439 EXPECT_EQ(0, audio_device_->StereoPlayout(&enabled));
1440 EXPECT_FALSE(enabled);
1441 EXPECT_EQ(0, audio_device_->SetStereoPlayout(true));
1442 EXPECT_EQ(0, audio_device_->StereoPlayout(&enabled));
1443 EXPECT_TRUE(enabled);
1444 }
1445 }
1446
TEST_F(AudioDeviceAPITest,StereoRecordingTests)1447 TEST_F(AudioDeviceAPITest, StereoRecordingTests) {
1448 CheckInitialRecordingStates();
1449 EXPECT_FALSE(audio_device_->Playing());
1450
1451 // fail tests
1452 EXPECT_EQ(-1, audio_device_->InitRecording());
1453 EXPECT_EQ(0, audio_device_->SetRecordingDevice(
1454 MACRO_DEFAULT_COMMUNICATION_DEVICE));
1455
1456 // TODO(kjellander): Fix so these tests pass on Mac.
1457 #if !defined(WEBRTC_MAC)
1458 EXPECT_EQ(0, audio_device_->InitRecording());
1459 EXPECT_TRUE(audio_device_->RecordingIsInitialized());
1460 // must be performed before initialization
1461 EXPECT_EQ(-1, audio_device_->SetStereoRecording(true));
1462 #endif
1463 // ensures that we can set the stereo mode for recording
1464 EXPECT_EQ(0, audio_device_->StopRecording());
1465 EXPECT_FALSE(audio_device_->RecordingIsInitialized());
1466
1467 // initialize kDefaultCommunicationDevice and modify/retrieve stereo support
1468 EXPECT_EQ(0, audio_device_->SetRecordingDevice(
1469 MACRO_DEFAULT_COMMUNICATION_DEVICE));
1470 bool available;
1471 bool enabled;
1472 EXPECT_EQ(0, audio_device_->StereoRecordingIsAvailable(&available));
1473 if (available) {
1474 EXPECT_EQ(0, audio_device_->SetStereoRecording(true));
1475 EXPECT_EQ(0, audio_device_->StereoRecording(&enabled));
1476 EXPECT_TRUE(enabled);
1477 EXPECT_EQ(0, audio_device_->SetStereoRecording(false));
1478 EXPECT_EQ(0, audio_device_->StereoRecording(&enabled));
1479 EXPECT_FALSE(enabled);
1480 }
1481
1482 // initialize kDefaultDevice and modify/retrieve stereo support
1483 EXPECT_EQ(0, audio_device_->SetRecordingDevice(MACRO_DEFAULT_DEVICE));
1484 EXPECT_EQ(0, audio_device_->StereoRecordingIsAvailable(&available));
1485 if (available) {
1486 EXPECT_EQ(0, audio_device_->SetStereoRecording(true));
1487 EXPECT_EQ(0, audio_device_->StereoRecording(&enabled));
1488 EXPECT_TRUE(enabled);
1489 EXPECT_EQ(0, audio_device_->SetStereoRecording(false));
1490 EXPECT_EQ(0, audio_device_->StereoRecording(&enabled));
1491 EXPECT_FALSE(enabled);
1492 }
1493
1494 // initialize default device (0) and modify/retrieve stereo support
1495 EXPECT_EQ(0, audio_device_->SetRecordingDevice(0));
1496 EXPECT_EQ(0, audio_device_->StereoRecordingIsAvailable(&available));
1497 if (available) {
1498 EXPECT_EQ(0, audio_device_->SetStereoRecording(true));
1499 EXPECT_EQ(0, audio_device_->StereoRecording(&enabled));
1500 EXPECT_TRUE(enabled);
1501 EXPECT_EQ(0, audio_device_->SetStereoRecording(false));
1502 EXPECT_EQ(0, audio_device_->StereoRecording(&enabled));
1503 EXPECT_FALSE(enabled);
1504 }
1505 }
1506
TEST_F(AudioDeviceAPITest,RecordingChannelTests)1507 TEST_F(AudioDeviceAPITest, RecordingChannelTests) {
1508 // the user in Win Core Audio
1509 AudioDeviceModule::ChannelType channelType(AudioDeviceModule::kChannelBoth);
1510 CheckInitialRecordingStates();
1511 EXPECT_FALSE(audio_device_->Playing());
1512
1513 // fail tests
1514 EXPECT_EQ(0, audio_device_->SetStereoRecording(false));
1515 EXPECT_EQ(-1, audio_device_->SetRecordingChannel(
1516 AudioDeviceModule::kChannelBoth));
1517
1518 // initialize kDefaultCommunicationDevice and modify/retrieve stereo support
1519 EXPECT_EQ(0, audio_device_->SetRecordingDevice(
1520 MACRO_DEFAULT_COMMUNICATION_DEVICE));
1521 bool available;
1522 EXPECT_EQ(0, audio_device_->StereoRecordingIsAvailable(&available));
1523 if (available) {
1524 EXPECT_EQ(0, audio_device_->SetStereoRecording(true));
1525 EXPECT_EQ(0, audio_device_->SetRecordingChannel(
1526 AudioDeviceModule::kChannelBoth));
1527 EXPECT_EQ(0, audio_device_->RecordingChannel(&channelType));
1528 EXPECT_EQ(AudioDeviceModule::kChannelBoth, channelType);
1529 EXPECT_EQ(0, audio_device_->SetRecordingChannel(
1530 AudioDeviceModule::kChannelLeft));
1531 EXPECT_EQ(0, audio_device_->RecordingChannel(&channelType));
1532 EXPECT_EQ(AudioDeviceModule::kChannelLeft, channelType);
1533 EXPECT_EQ(0, audio_device_->SetRecordingChannel(
1534 AudioDeviceModule::kChannelRight));
1535 EXPECT_EQ(0, audio_device_->RecordingChannel(&channelType));
1536 EXPECT_EQ(AudioDeviceModule::kChannelRight, channelType);
1537 }
1538 }
1539
TEST_F(AudioDeviceAPITest,PlayoutBufferTests)1540 TEST_F(AudioDeviceAPITest, PlayoutBufferTests) {
1541 AudioDeviceModule::BufferType bufferType;
1542 uint16_t sizeMS(0);
1543
1544 CheckInitialPlayoutStates();
1545 EXPECT_EQ(0, audio_device_->PlayoutBuffer(&bufferType, &sizeMS));
1546 #if defined(_WIN32) || defined(ANDROID) || defined(WEBRTC_IOS)
1547 EXPECT_EQ(AudioDeviceModule::kAdaptiveBufferSize, bufferType);
1548 #else
1549 EXPECT_EQ(AudioDeviceModule::kFixedBufferSize, bufferType);
1550 #endif
1551
1552 // fail tests
1553 EXPECT_EQ(-1, audio_device_->InitPlayout());
1554 // must set device first
1555 EXPECT_EQ(0, audio_device_->SetPlayoutDevice(
1556 MACRO_DEFAULT_COMMUNICATION_DEVICE));
1557
1558 // TODO(kjellander): Fix so these tests pass on Mac.
1559 #if !defined(WEBRTC_MAC)
1560 EXPECT_EQ(0, audio_device_->InitPlayout());
1561 EXPECT_TRUE(audio_device_->PlayoutIsInitialized());
1562 #endif
1563 EXPECT_TRUE(audio_device_->SetPlayoutBuffer(
1564 AudioDeviceModule::kAdaptiveBufferSize, 100) == -1);
1565 EXPECT_EQ(0, audio_device_->StopPlayout());
1566 EXPECT_TRUE(audio_device_->SetPlayoutBuffer(
1567 AudioDeviceModule::kFixedBufferSize, kAdmMinPlayoutBufferSizeMs-1) == -1);
1568 EXPECT_TRUE(audio_device_->SetPlayoutBuffer(
1569 AudioDeviceModule::kFixedBufferSize, kAdmMaxPlayoutBufferSizeMs+1) == -1);
1570
1571 // bulk tests (all should be successful)
1572 EXPECT_FALSE(audio_device_->PlayoutIsInitialized());
1573 #ifdef _WIN32
1574 EXPECT_EQ(0, audio_device_->SetPlayoutBuffer(
1575 AudioDeviceModule::kAdaptiveBufferSize, 0));
1576 EXPECT_EQ(0, audio_device_->PlayoutBuffer(&bufferType, &sizeMS));
1577 EXPECT_EQ(AudioDeviceModule::kAdaptiveBufferSize, bufferType);
1578 EXPECT_EQ(0, audio_device_->SetPlayoutBuffer(
1579 AudioDeviceModule::kAdaptiveBufferSize, 10000));
1580 EXPECT_EQ(0, audio_device_->PlayoutBuffer(&bufferType, &sizeMS));
1581 EXPECT_EQ(AudioDeviceModule::kAdaptiveBufferSize, bufferType);
1582 #endif
1583 #if defined(ANDROID) || defined(WEBRTC_IOS)
1584 EXPECT_EQ(-1,
1585 audio_device_->SetPlayoutBuffer(AudioDeviceModule::kFixedBufferSize,
1586 kAdmMinPlayoutBufferSizeMs));
1587 #else
1588 EXPECT_EQ(0, audio_device_->SetPlayoutBuffer(
1589 AudioDeviceModule::kFixedBufferSize, kAdmMinPlayoutBufferSizeMs));
1590 EXPECT_EQ(0, audio_device_->PlayoutBuffer(&bufferType, &sizeMS));
1591 EXPECT_EQ(AudioDeviceModule::kFixedBufferSize, bufferType);
1592 EXPECT_EQ(kAdmMinPlayoutBufferSizeMs, sizeMS);
1593 EXPECT_EQ(0, audio_device_->SetPlayoutBuffer(
1594 AudioDeviceModule::kFixedBufferSize, kAdmMaxPlayoutBufferSizeMs));
1595 EXPECT_EQ(0, audio_device_->PlayoutBuffer(&bufferType, &sizeMS));
1596 EXPECT_EQ(AudioDeviceModule::kFixedBufferSize, bufferType);
1597 EXPECT_EQ(kAdmMaxPlayoutBufferSizeMs, sizeMS);
1598 EXPECT_EQ(0, audio_device_->SetPlayoutBuffer(
1599 AudioDeviceModule::kFixedBufferSize, 100));
1600 EXPECT_EQ(0, audio_device_->PlayoutBuffer(&bufferType, &sizeMS));
1601 EXPECT_EQ(AudioDeviceModule::kFixedBufferSize, bufferType);
1602 EXPECT_EQ(100, sizeMS);
1603 #endif
1604
1605 #ifdef _WIN32
1606 // restore default
1607 EXPECT_EQ(0, audio_device_->SetPlayoutBuffer(
1608 AudioDeviceModule::kAdaptiveBufferSize, 0));
1609 EXPECT_EQ(0, audio_device_->PlayoutBuffer(&bufferType, &sizeMS));
1610 #endif
1611 }
1612
TEST_F(AudioDeviceAPITest,PlayoutDelay)1613 TEST_F(AudioDeviceAPITest, PlayoutDelay) {
1614 // NOTE: this API is better tested in a functional test
1615 uint16_t sizeMS(0);
1616 CheckInitialPlayoutStates();
1617 // bulk tests
1618 EXPECT_EQ(0, audio_device_->PlayoutDelay(&sizeMS));
1619 EXPECT_EQ(0, audio_device_->PlayoutDelay(&sizeMS));
1620 }
1621
TEST_F(AudioDeviceAPITest,RecordingDelay)1622 TEST_F(AudioDeviceAPITest, RecordingDelay) {
1623 // NOTE: this API is better tested in a functional test
1624 uint16_t sizeMS(0);
1625 CheckInitialRecordingStates();
1626
1627 // bulk tests
1628 EXPECT_EQ(0, audio_device_->RecordingDelay(&sizeMS));
1629 EXPECT_EQ(0, audio_device_->RecordingDelay(&sizeMS));
1630 }
1631
TEST_F(AudioDeviceAPITest,CPULoad)1632 TEST_F(AudioDeviceAPITest, CPULoad) {
1633 // NOTE: this API is better tested in a functional test
1634 uint16_t load(0);
1635
1636 // bulk tests
1637 #ifdef _WIN32
1638 EXPECT_EQ(0, audio_device_->CPULoad(&load));
1639 EXPECT_EQ(0, load);
1640 #else
1641 EXPECT_EQ(-1, audio_device_->CPULoad(&load));
1642 #endif
1643 }
1644
1645 // TODO(kjellander): Fix flakiness causing failures on Windows.
1646 // TODO(phoglund): Fix flakiness causing failures on Linux.
1647 #if !defined(_WIN32) && !defined(WEBRTC_LINUX)
TEST_F(AudioDeviceAPITest,StartAndStopRawOutputFileRecording)1648 TEST_F(AudioDeviceAPITest, StartAndStopRawOutputFileRecording) {
1649 // NOTE: this API is better tested in a functional test
1650 CheckInitialPlayoutStates();
1651
1652 // fail tests
1653 EXPECT_EQ(-1, audio_device_->StartRawOutputFileRecording(NULL));
1654
1655 // bulk tests
1656 EXPECT_EQ(0, audio_device_->StartRawOutputFileRecording(
1657 GetFilename("raw_output_not_playing.pcm")));
1658 EXPECT_EQ(0, audio_device_->StopRawOutputFileRecording());
1659 EXPECT_EQ(0, audio_device_->SetPlayoutDevice(
1660 MACRO_DEFAULT_COMMUNICATION_DEVICE));
1661
1662 // TODO(kjellander): Fix so these tests pass on Mac.
1663 #if !defined(WEBRTC_MAC)
1664 EXPECT_EQ(0, audio_device_->InitPlayout());
1665 EXPECT_EQ(0, audio_device_->StartPlayout());
1666 #endif
1667
1668 EXPECT_EQ(0, audio_device_->StartRawOutputFileRecording(
1669 GetFilename("raw_output_playing.pcm")));
1670 SleepMs(100);
1671 EXPECT_EQ(0, audio_device_->StopRawOutputFileRecording());
1672 EXPECT_EQ(0, audio_device_->StopPlayout());
1673 EXPECT_EQ(0, audio_device_->StartRawOutputFileRecording(
1674 GetFilename("raw_output_not_playing.pcm")));
1675 EXPECT_EQ(0, audio_device_->StopRawOutputFileRecording());
1676
1677 // results after this test:
1678 //
1679 // - size of raw_output_not_playing.pcm shall be 0
1680 // - size of raw_output_playing.pcm shall be > 0
1681 }
1682
TEST_F(AudioDeviceAPITest,StartAndStopRawInputFileRecording)1683 TEST_F(AudioDeviceAPITest, StartAndStopRawInputFileRecording) {
1684 // NOTE: this API is better tested in a functional test
1685 CheckInitialRecordingStates();
1686 EXPECT_FALSE(audio_device_->Playing());
1687
1688 // fail tests
1689 EXPECT_EQ(-1, audio_device_->StartRawInputFileRecording(NULL));
1690
1691 // bulk tests
1692 EXPECT_EQ(0, audio_device_->StartRawInputFileRecording(
1693 GetFilename("raw_input_not_recording.pcm")));
1694 EXPECT_EQ(0, audio_device_->StopRawInputFileRecording());
1695 EXPECT_EQ(0, audio_device_->SetRecordingDevice(MACRO_DEFAULT_DEVICE));
1696
1697 // TODO(kjellander): Fix so these tests pass on Mac.
1698 #if !defined(WEBRTC_MAC)
1699 EXPECT_EQ(0, audio_device_->InitRecording());
1700 EXPECT_EQ(0, audio_device_->StartRecording());
1701 #endif
1702 EXPECT_EQ(0, audio_device_->StartRawInputFileRecording(
1703 GetFilename("raw_input_recording.pcm")));
1704 SleepMs(100);
1705 EXPECT_EQ(0, audio_device_->StopRawInputFileRecording());
1706 EXPECT_EQ(0, audio_device_->StopRecording());
1707 EXPECT_EQ(0, audio_device_->StartRawInputFileRecording(
1708 GetFilename("raw_input_not_recording.pcm")));
1709 EXPECT_EQ(0, audio_device_->StopRawInputFileRecording());
1710
1711 // results after this test:
1712 //
1713 // - size of raw_input_not_recording.pcm shall be 0
1714 // - size of raw_input_not_recording.pcm shall be > 0
1715 }
1716 #endif // !WIN32 && !WEBRTC_LINUX
1717
TEST_F(AudioDeviceAPITest,RecordingSampleRate)1718 TEST_F(AudioDeviceAPITest, RecordingSampleRate) {
1719 uint32_t sampleRate(0);
1720
1721 // bulk tests
1722 EXPECT_EQ(0, audio_device_->RecordingSampleRate(&sampleRate));
1723 #if defined(_WIN32) && !defined(WEBRTC_WINDOWS_CORE_AUDIO_BUILD)
1724 EXPECT_EQ(48000, sampleRate);
1725 #elif defined(ANDROID)
1726 TEST_LOG("Recording sample rate is %u\n\n", sampleRate);
1727 EXPECT_TRUE((sampleRate == 44000) || (sampleRate == 16000));
1728 #elif defined(WEBRTC_IOS)
1729 TEST_LOG("Recording sample rate is %u\n\n", sampleRate);
1730 EXPECT_TRUE((sampleRate == 44000) || (sampleRate == 16000) ||
1731 (sampleRate == 8000));
1732 #endif
1733
1734 // @TODO(xians) - add tests for all platforms here...
1735 }
1736
TEST_F(AudioDeviceAPITest,PlayoutSampleRate)1737 TEST_F(AudioDeviceAPITest, PlayoutSampleRate) {
1738 uint32_t sampleRate(0);
1739
1740 // bulk tests
1741 EXPECT_EQ(0, audio_device_->PlayoutSampleRate(&sampleRate));
1742 #if defined(_WIN32) && !defined(WEBRTC_WINDOWS_CORE_AUDIO_BUILD)
1743 EXPECT_EQ(48000, sampleRate);
1744 #elif defined(ANDROID)
1745 TEST_LOG("Playout sample rate is %u\n\n", sampleRate);
1746 EXPECT_TRUE((sampleRate == 44000) || (sampleRate == 16000));
1747 #elif defined(WEBRTC_IOS)
1748 TEST_LOG("Playout sample rate is %u\n\n", sampleRate);
1749 EXPECT_TRUE((sampleRate == 44000) || (sampleRate == 16000) ||
1750 (sampleRate == 8000));
1751 #endif
1752 }
1753
TEST_F(AudioDeviceAPITest,ResetAudioDevice)1754 TEST_F(AudioDeviceAPITest, ResetAudioDevice) {
1755 CheckInitialPlayoutStates();
1756 CheckInitialRecordingStates();
1757 EXPECT_EQ(0, audio_device_->SetPlayoutDevice(MACRO_DEFAULT_DEVICE));
1758 EXPECT_EQ(0, audio_device_->SetRecordingDevice(MACRO_DEFAULT_DEVICE));
1759
1760 #if defined(WEBRTC_IOS)
1761 // Not playing or recording, should just return 0
1762 EXPECT_EQ(0, audio_device_->ResetAudioDevice());
1763
1764 EXPECT_EQ(0, audio_device_->InitRecording());
1765 EXPECT_EQ(0, audio_device_->StartRecording());
1766 EXPECT_EQ(0, audio_device_->InitPlayout());
1767 EXPECT_EQ(0, audio_device_->StartPlayout());
1768 for (int l=0; l<20; ++l)
1769 {
1770 TEST_LOG("Resetting sound device several time with pause %d ms\n", l);
1771 EXPECT_EQ(0, audio_device_->ResetAudioDevice());
1772 SleepMs(l);
1773 }
1774 #else
1775 // Fail tests
1776 EXPECT_EQ(-1, audio_device_->ResetAudioDevice());
1777
1778 // TODO(kjellander): Fix so these tests pass on Mac.
1779 #if !defined(WEBRTC_MAC)
1780 EXPECT_EQ(0, audio_device_->InitRecording());
1781 EXPECT_EQ(0, audio_device_->StartRecording());
1782 EXPECT_EQ(0, audio_device_->InitPlayout());
1783 EXPECT_EQ(0, audio_device_->StartPlayout());
1784 #endif
1785 EXPECT_EQ(-1, audio_device_->ResetAudioDevice());
1786 #endif
1787 EXPECT_EQ(0, audio_device_->StopRecording());
1788 EXPECT_EQ(0, audio_device_->StopPlayout());
1789 }
1790
TEST_F(AudioDeviceAPITest,SetPlayoutSpeaker)1791 TEST_F(AudioDeviceAPITest, SetPlayoutSpeaker) {
1792 CheckInitialPlayoutStates();
1793 EXPECT_EQ(0, audio_device_->SetPlayoutDevice(MACRO_DEFAULT_DEVICE));
1794
1795 bool loudspeakerOn(false);
1796 #if defined(WEBRTC_IOS)
1797 // Not playing or recording, should just return a success
1798 EXPECT_EQ(0, audio_device_->SetLoudspeakerStatus(true));
1799 EXPECT_EQ(0, audio_device_->GetLoudspeakerStatus(&loudspeakerOn));
1800 EXPECT_TRUE(loudspeakerOn);
1801 EXPECT_EQ(0, audio_device_->SetLoudspeakerStatus(false));
1802 EXPECT_EQ(0, audio_device_->GetLoudspeakerStatus(&loudspeakerOn));
1803 EXPECT_FALSE(loudspeakerOn);
1804
1805 EXPECT_EQ(0, audio_device_->InitPlayout());
1806 EXPECT_EQ(0, audio_device_->StartPlayout());
1807 EXPECT_EQ(0, audio_device_->SetLoudspeakerStatus(true));
1808 EXPECT_EQ(0, audio_device_->GetLoudspeakerStatus(&loudspeakerOn));
1809 EXPECT_TRUE(loudspeakerOn);
1810 EXPECT_EQ(0, audio_device_->SetLoudspeakerStatus(false));
1811 EXPECT_EQ(0, audio_device_->GetLoudspeakerStatus(&loudspeakerOn));
1812 EXPECT_FALSE(loudspeakerOn);
1813
1814 #else
1815 // Fail tests
1816 EXPECT_EQ(-1, audio_device_->SetLoudspeakerStatus(true));
1817 EXPECT_EQ(-1, audio_device_->SetLoudspeakerStatus(false));
1818 EXPECT_EQ(-1, audio_device_->SetLoudspeakerStatus(true));
1819 EXPECT_EQ(-1, audio_device_->SetLoudspeakerStatus(false));
1820
1821 // TODO(kjellander): Fix so these tests pass on Mac.
1822 #if !defined(WEBRTC_MAC)
1823 EXPECT_EQ(0, audio_device_->InitPlayout());
1824 EXPECT_EQ(0, audio_device_->StartPlayout());
1825 #endif
1826
1827 EXPECT_EQ(-1, audio_device_->GetLoudspeakerStatus(&loudspeakerOn));
1828 #endif
1829 EXPECT_EQ(0, audio_device_->StopPlayout());
1830 }
1831