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