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 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) 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: 50 AudioEventObserverAPI(AudioDeviceModule* audioDevice) 51 : error_(kRecordingError), 52 warning_(kRecordingWarning), 53 audio_device_(audioDevice) { 54 } 55 56 ~AudioEventObserverAPI() {} 57 58 virtual void OnErrorIsReported(const ErrorCode error) { 59 TEST_LOG("\n[*** ERROR ***] => OnErrorIsReported(%d)\n\n", error); 60 error_ = error; 61 } 62 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: 79 AudioTransportAPI(AudioDeviceModule* audioDevice) 80 : rec_count_(0), 81 play_count_(0) { 82 } 83 84 ~AudioTransportAPI() {} 85 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 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 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 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 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: 164 AudioDeviceAPITest() {} 165 166 virtual ~AudioDeviceAPITest() {} 167 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 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 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 301 void TearDown() { 302 EXPECT_EQ(0, audio_device_->Terminate()); 303 } 304 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 315 void CheckInitialPlayoutStates() { 316 EXPECT_FALSE(audio_device_->PlayoutIsInitialized()); 317 EXPECT_FALSE(audio_device_->Playing()); 318 EXPECT_FALSE(audio_device_->SpeakerIsInitialized()); 319 } 320 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 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 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 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 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 379 TEST_F(AudioDeviceAPITest, PlayoutDevices) { 380 EXPECT_GT(audio_device_->PlayoutDevices(), 0); 381 EXPECT_GT(audio_device_->PlayoutDevices(), 0); 382 } 383 384 TEST_F(AudioDeviceAPITest, RecordingDevices) { 385 EXPECT_GT(audio_device_->RecordingDevices(), 0); 386 EXPECT_GT(audio_device_->RecordingDevices(), 0); 387 } 388 389 // TODO(henrika): uncomment when you have decided what to do with issue 3675. 390 #if 0 391 TEST_F(AudioDeviceAPITest, PlayoutDeviceName) { 392 char name[kAdmMaxDeviceNameSize]; 393 char guid[kAdmMaxGuidSize]; 394 int16_t no_devices = audio_device_->PlayoutDevices(); 395 396 // fail tests 397 EXPECT_EQ(-1, audio_device_->PlayoutDeviceName(-2, name, guid)); 398 EXPECT_EQ(-1, audio_device_->PlayoutDeviceName(no_devices, name, guid)); 399 EXPECT_EQ(-1, audio_device_->PlayoutDeviceName(0, NULL, guid)); 400 401 // bulk tests 402 EXPECT_EQ(0, audio_device_->PlayoutDeviceName(0, name, NULL)); 403 #ifdef _WIN32 404 // shall be mapped to 0. 405 EXPECT_EQ(0, audio_device_->PlayoutDeviceName(-1, name, NULL)); 406 #else 407 EXPECT_EQ(-1, audio_device_->PlayoutDeviceName(-1, name, NULL)); 408 #endif 409 for (int i = 0; i < no_devices; i++) { 410 EXPECT_EQ(0, audio_device_->PlayoutDeviceName(i, name, guid)); 411 EXPECT_EQ(0, audio_device_->PlayoutDeviceName(i, name, NULL)); 412 } 413 } 414 415 TEST_F(AudioDeviceAPITest, RecordingDeviceName) { 416 char name[kAdmMaxDeviceNameSize]; 417 char guid[kAdmMaxGuidSize]; 418 int16_t no_devices = audio_device_->RecordingDevices(); 419 420 // fail tests 421 EXPECT_EQ(-1, audio_device_->RecordingDeviceName(-2, name, guid)); 422 EXPECT_EQ(-1, audio_device_->RecordingDeviceName(no_devices, name, guid)); 423 EXPECT_EQ(-1, audio_device_->RecordingDeviceName(0, NULL, guid)); 424 425 // bulk tests 426 EXPECT_EQ(0, audio_device_->RecordingDeviceName(0, name, NULL)); 427 #ifdef _WIN32 428 // shall me mapped to 0 429 EXPECT_EQ(0, audio_device_->RecordingDeviceName(-1, name, NULL)); 430 #else 431 EXPECT_EQ(-1, audio_device_->RecordingDeviceName(-1, name, NULL)); 432 #endif 433 for (int i = 0; i < no_devices; i++) { 434 EXPECT_EQ(0, audio_device_->RecordingDeviceName(i, name, guid)); 435 EXPECT_EQ(0, audio_device_->RecordingDeviceName(i, name, NULL)); 436 } 437 } 438 439 TEST_F(AudioDeviceAPITest, SetPlayoutDevice) { 440 int16_t no_devices = audio_device_->PlayoutDevices(); 441 442 // fail tests 443 EXPECT_EQ(-1, audio_device_->SetPlayoutDevice(-1)); 444 EXPECT_EQ(-1, audio_device_->SetPlayoutDevice(no_devices)); 445 446 // bulk tests 447 #ifdef _WIN32 448 EXPECT_EQ(0, audio_device_->SetPlayoutDevice( 449 AudioDeviceModule::kDefaultCommunicationDevice)); 450 EXPECT_EQ(0, audio_device_->SetPlayoutDevice( 451 AudioDeviceModule::kDefaultDevice)); 452 #else 453 EXPECT_EQ(-1, audio_device_->SetPlayoutDevice( 454 AudioDeviceModule::kDefaultCommunicationDevice)); 455 EXPECT_EQ(-1, audio_device_->SetPlayoutDevice( 456 AudioDeviceModule::kDefaultDevice)); 457 #endif 458 for (int i = 0; i < no_devices; i++) { 459 EXPECT_EQ(0, audio_device_->SetPlayoutDevice(i)); 460 } 461 } 462 463 TEST_F(AudioDeviceAPITest, SetRecordingDevice) { 464 EXPECT_EQ(0, audio_device_->Init()); 465 int16_t no_devices = audio_device_->RecordingDevices(); 466 467 // fail tests 468 EXPECT_EQ(-1, audio_device_->SetRecordingDevice(-1)); 469 EXPECT_EQ(-1, audio_device_->SetRecordingDevice(no_devices)); 470 471 // bulk tests 472 #ifdef _WIN32 473 EXPECT_TRUE(audio_device_->SetRecordingDevice( 474 AudioDeviceModule::kDefaultCommunicationDevice) == 0); 475 EXPECT_EQ(0, audio_device_->SetRecordingDevice( 476 AudioDeviceModule::kDefaultDevice)); 477 #else 478 EXPECT_TRUE(audio_device_->SetRecordingDevice( 479 AudioDeviceModule::kDefaultCommunicationDevice) == -1); 480 EXPECT_TRUE(audio_device_->SetRecordingDevice( 481 AudioDeviceModule::kDefaultDevice) == -1); 482 #endif 483 for (int i = 0; i < no_devices; i++) { 484 EXPECT_EQ(0, audio_device_->SetRecordingDevice(i)); 485 } 486 } 487 #endif // 0 488 489 TEST_F(AudioDeviceAPITest, PlayoutIsAvailable) { 490 bool available; 491 #ifdef _WIN32 492 EXPECT_TRUE(audio_device_->SetPlayoutDevice( 493 AudioDeviceModule::kDefaultCommunicationDevice) == 0); 494 EXPECT_EQ(0, audio_device_->PlayoutIsAvailable(&available)); 495 // Availability check should not initialize. 496 EXPECT_FALSE(audio_device_->PlayoutIsInitialized()); 497 498 EXPECT_EQ(0, 499 audio_device_->SetPlayoutDevice(AudioDeviceModule::kDefaultDevice)); 500 EXPECT_EQ(0, audio_device_->PlayoutIsAvailable(&available)); 501 EXPECT_FALSE(audio_device_->PlayoutIsInitialized()); 502 #endif 503 504 int16_t no_devices = audio_device_->PlayoutDevices(); 505 for (int i = 0; i < no_devices; i++) { 506 EXPECT_EQ(0, audio_device_->SetPlayoutDevice(i)); 507 EXPECT_EQ(0, audio_device_->PlayoutIsAvailable(&available)); 508 EXPECT_FALSE(audio_device_->PlayoutIsInitialized()); 509 } 510 } 511 512 TEST_F(AudioDeviceAPITest, RecordingIsAvailable) { 513 bool available; 514 #ifdef _WIN32 515 EXPECT_EQ(0, audio_device_->SetRecordingDevice( 516 AudioDeviceModule::kDefaultCommunicationDevice)); 517 EXPECT_EQ(0, audio_device_->RecordingIsAvailable(&available)); 518 EXPECT_FALSE(audio_device_->RecordingIsInitialized()); 519 520 EXPECT_EQ(0, audio_device_->SetRecordingDevice( 521 AudioDeviceModule::kDefaultDevice)); 522 EXPECT_EQ(0, audio_device_->RecordingIsAvailable(&available)); 523 EXPECT_FALSE(audio_device_->RecordingIsInitialized()); 524 #endif 525 526 int16_t no_devices = audio_device_->RecordingDevices(); 527 for (int i = 0; i < no_devices; i++) { 528 EXPECT_EQ(0, audio_device_->SetRecordingDevice(i)); 529 EXPECT_EQ(0, audio_device_->RecordingIsAvailable(&available)); 530 EXPECT_FALSE(audio_device_->RecordingIsInitialized()); 531 } 532 } 533 534 TEST_F(AudioDeviceAPITest, InitPlayout) { 535 // check initial state 536 EXPECT_FALSE(audio_device_->PlayoutIsInitialized()); 537 538 // ensure that device must be set before we can initialize 539 EXPECT_EQ(-1, audio_device_->InitPlayout()); 540 EXPECT_EQ(0, audio_device_->SetPlayoutDevice(MACRO_DEFAULT_DEVICE)); 541 EXPECT_EQ(0, audio_device_->InitPlayout()); 542 EXPECT_TRUE(audio_device_->PlayoutIsInitialized()); 543 544 // bulk tests 545 bool available; 546 EXPECT_EQ(0, audio_device_->PlayoutIsAvailable(&available)); 547 if (available) { 548 EXPECT_EQ(0, audio_device_->InitPlayout()); 549 EXPECT_TRUE(audio_device_->PlayoutIsInitialized()); 550 EXPECT_EQ(0, audio_device_->InitPlayout()); 551 EXPECT_EQ(-1, audio_device_->SetPlayoutDevice( 552 MACRO_DEFAULT_COMMUNICATION_DEVICE)); 553 EXPECT_EQ(0, audio_device_->StopPlayout()); 554 EXPECT_FALSE(audio_device_->PlayoutIsInitialized()); 555 } 556 557 EXPECT_EQ(0, audio_device_->SetPlayoutDevice( 558 MACRO_DEFAULT_COMMUNICATION_DEVICE)); 559 EXPECT_EQ(0, audio_device_->PlayoutIsAvailable(&available)); 560 if (available) { 561 EXPECT_EQ(0, audio_device_->InitPlayout()); 562 // Sleep is needed for e.g. iPhone since we after stopping then starting may 563 // have a hangover time of a couple of ms before initialized. 564 SleepMs(50); 565 EXPECT_TRUE(audio_device_->PlayoutIsInitialized()); 566 } 567 568 int16_t no_devices = audio_device_->PlayoutDevices(); 569 for (int i = 0; i < no_devices; i++) { 570 EXPECT_EQ(0, audio_device_->PlayoutIsAvailable(&available)); 571 if (available) { 572 EXPECT_EQ(0, audio_device_->StopPlayout()); 573 EXPECT_FALSE(audio_device_->PlayoutIsInitialized()); 574 EXPECT_EQ(0, audio_device_->SetPlayoutDevice(i)); 575 EXPECT_EQ(0, audio_device_->PlayoutIsAvailable(&available)); 576 if (available) { 577 EXPECT_EQ(0, audio_device_->InitPlayout()); 578 EXPECT_TRUE(audio_device_->PlayoutIsInitialized()); 579 } 580 } 581 } 582 EXPECT_EQ(0, audio_device_->StopPlayout()); 583 } 584 585 TEST_F(AudioDeviceAPITest, InitRecording) { 586 // check initial state 587 EXPECT_FALSE(audio_device_->RecordingIsInitialized()); 588 589 // ensure that device must be set before we can initialize 590 EXPECT_EQ(-1, audio_device_->InitRecording()); 591 EXPECT_EQ(0, audio_device_->SetRecordingDevice(MACRO_DEFAULT_DEVICE)); 592 EXPECT_EQ(0, audio_device_->InitRecording()); 593 EXPECT_TRUE(audio_device_->RecordingIsInitialized()); 594 595 // bulk tests 596 bool available; 597 EXPECT_EQ(0, audio_device_->RecordingIsAvailable(&available)); 598 if (available) { 599 EXPECT_EQ(0, audio_device_->InitRecording()); 600 EXPECT_TRUE(audio_device_->RecordingIsInitialized()); 601 EXPECT_EQ(0, audio_device_->InitRecording()); 602 EXPECT_EQ(-1, 603 audio_device_->SetRecordingDevice(MACRO_DEFAULT_COMMUNICATION_DEVICE)); 604 EXPECT_EQ(0, audio_device_->StopRecording()); 605 EXPECT_FALSE(audio_device_->RecordingIsInitialized()); 606 } 607 608 EXPECT_EQ(0, 609 audio_device_->SetRecordingDevice(MACRO_DEFAULT_COMMUNICATION_DEVICE)); 610 EXPECT_EQ(0, audio_device_->RecordingIsAvailable(&available)); 611 if (available) { 612 EXPECT_EQ(0, audio_device_->InitRecording()); 613 SleepMs(50); 614 EXPECT_TRUE(audio_device_->RecordingIsInitialized()); 615 } 616 617 int16_t no_devices = audio_device_->RecordingDevices(); 618 for (int i = 0; i < no_devices; i++) { 619 EXPECT_EQ(0, audio_device_->RecordingIsAvailable(&available)); 620 if (available) { 621 EXPECT_EQ(0, audio_device_->StopRecording()); 622 EXPECT_FALSE(audio_device_->RecordingIsInitialized()); 623 EXPECT_EQ(0, audio_device_->SetRecordingDevice(i)); 624 EXPECT_EQ(0, audio_device_->RecordingIsAvailable(&available)); 625 if (available) { 626 EXPECT_EQ(0, audio_device_->InitRecording()); 627 EXPECT_TRUE(audio_device_->RecordingIsInitialized()); 628 } 629 } 630 } 631 EXPECT_EQ(0, audio_device_->StopRecording()); 632 } 633 634 TEST_F(AudioDeviceAPITest, StartAndStopPlayout) { 635 bool available; 636 EXPECT_EQ(0, audio_device_->RegisterAudioCallback(NULL)); 637 638 CheckInitialPlayoutStates(); 639 640 EXPECT_EQ(-1, audio_device_->StartPlayout()); 641 EXPECT_EQ(0, audio_device_->StopPlayout()); 642 643 #ifdef _WIN32 644 // kDefaultCommunicationDevice 645 EXPECT_TRUE(audio_device_->SetPlayoutDevice( 646 AudioDeviceModule::kDefaultCommunicationDevice) == 0); 647 EXPECT_EQ(0, audio_device_->PlayoutIsAvailable(&available)); 648 if (available) 649 { 650 EXPECT_FALSE(audio_device_->PlayoutIsInitialized()); 651 EXPECT_EQ(0, audio_device_->InitPlayout()); 652 EXPECT_EQ(0, audio_device_->StartPlayout()); 653 EXPECT_TRUE(audio_device_->Playing()); 654 EXPECT_EQ(0, audio_device_->RegisterAudioCallback(audio_transport_)); 655 EXPECT_EQ(0, audio_device_->StopPlayout()); 656 EXPECT_FALSE(audio_device_->Playing()); 657 EXPECT_EQ(0, audio_device_->RegisterAudioCallback(NULL)); 658 } 659 #endif 660 661 // repeat test but for kDefaultDevice 662 EXPECT_EQ(0, audio_device_->SetPlayoutDevice(MACRO_DEFAULT_DEVICE)); 663 EXPECT_EQ(0, audio_device_->PlayoutIsAvailable(&available)); 664 if (available) { 665 EXPECT_FALSE(audio_device_->PlayoutIsInitialized()); 666 EXPECT_EQ(0, audio_device_->InitPlayout()); 667 EXPECT_EQ(0, audio_device_->StartPlayout()); 668 EXPECT_TRUE(audio_device_->Playing()); 669 EXPECT_EQ(0, audio_device_->RegisterAudioCallback(audio_transport_)); 670 EXPECT_EQ(0, audio_device_->StopPlayout()); 671 EXPECT_FALSE(audio_device_->Playing()); 672 } 673 674 // repeat test for all devices 675 int16_t no_devices = audio_device_->PlayoutDevices(); 676 for (int i = 0; i < no_devices; i++) { 677 EXPECT_EQ(0, audio_device_->SetPlayoutDevice(i)); 678 EXPECT_EQ(0, audio_device_->PlayoutIsAvailable(&available)); 679 if (available) { 680 EXPECT_FALSE(audio_device_->PlayoutIsInitialized()); 681 EXPECT_EQ(0, audio_device_->InitPlayout()); 682 EXPECT_EQ(0, audio_device_->StartPlayout()); 683 EXPECT_TRUE(audio_device_->Playing()); 684 EXPECT_EQ(0, audio_device_->RegisterAudioCallback(audio_transport_)); 685 EXPECT_EQ(0, audio_device_->StopPlayout()); 686 EXPECT_FALSE(audio_device_->Playing()); 687 } 688 } 689 } 690 691 TEST_F(AudioDeviceAPITest, StartAndStopRecording) { 692 bool available; 693 EXPECT_EQ(0, audio_device_->RegisterAudioCallback(NULL)); 694 695 CheckInitialRecordingStates(); 696 697 EXPECT_EQ(-1, audio_device_->StartRecording()); 698 EXPECT_EQ(0, audio_device_->StopRecording()); 699 700 #ifdef _WIN32 701 // kDefaultCommunicationDevice 702 EXPECT_TRUE(audio_device_->SetRecordingDevice( 703 AudioDeviceModule::kDefaultCommunicationDevice) == 0); 704 EXPECT_EQ(0, audio_device_->RecordingIsAvailable(&available)); 705 if (available) 706 { 707 EXPECT_FALSE(audio_device_->RecordingIsInitialized()); 708 EXPECT_EQ(0, audio_device_->InitRecording()); 709 EXPECT_EQ(0, audio_device_->StartRecording()); 710 EXPECT_TRUE(audio_device_->Recording()); 711 EXPECT_EQ(0, audio_device_->RegisterAudioCallback(audio_transport_)); 712 EXPECT_EQ(0, audio_device_->StopRecording()); 713 EXPECT_FALSE(audio_device_->Recording()); 714 EXPECT_EQ(0, audio_device_->RegisterAudioCallback(NULL)); 715 } 716 #endif 717 718 // repeat test but for kDefaultDevice 719 EXPECT_EQ(0, audio_device_->SetRecordingDevice(MACRO_DEFAULT_DEVICE)); 720 EXPECT_EQ(0, audio_device_->RecordingIsAvailable(&available)); 721 if (available) { 722 EXPECT_FALSE(audio_device_->RecordingIsInitialized()); 723 EXPECT_EQ(0, audio_device_->InitRecording()); 724 EXPECT_EQ(0, audio_device_->StartRecording()); 725 EXPECT_TRUE(audio_device_->Recording()); 726 EXPECT_EQ(0, audio_device_->RegisterAudioCallback(audio_transport_)); 727 EXPECT_EQ(0, audio_device_->StopRecording()); 728 EXPECT_FALSE(audio_device_->Recording()); 729 } 730 731 // repeat test for all devices 732 int16_t no_devices = audio_device_->RecordingDevices(); 733 for (int i = 0; i < no_devices; i++) { 734 EXPECT_EQ(0, audio_device_->SetRecordingDevice(i)); 735 EXPECT_EQ(0, audio_device_->RecordingIsAvailable(&available)); 736 if (available) { 737 EXPECT_FALSE(audio_device_->RecordingIsInitialized()); 738 EXPECT_EQ(0, audio_device_->InitRecording()); 739 EXPECT_EQ(0, audio_device_->StartRecording()); 740 EXPECT_TRUE(audio_device_->Recording()); 741 EXPECT_EQ(0, audio_device_->RegisterAudioCallback(audio_transport_)); 742 EXPECT_EQ(0, audio_device_->StopRecording()); 743 EXPECT_FALSE(audio_device_->Recording()); 744 } 745 } 746 } 747 748 #if defined(_WIN32) && !defined(WEBRTC_WINDOWS_CORE_AUDIO_BUILD) 749 TEST_F(AudioDeviceAPITest, SetAndGetWaveOutVolume) { 750 uint32_t vol(0); 751 // NOTE 1: Windows Wave only! 752 // NOTE 2: It seems like the waveOutSetVolume API returns 753 // MMSYSERR_NOTSUPPORTED on some Vista machines! 754 const uint16_t maxVol(0xFFFF); 755 uint16_t volL, volR; 756 757 CheckInitialPlayoutStates(); 758 759 // make dummy test to see if this API is supported 760 int32_t works = audio_device_->SetWaveOutVolume(vol, vol); 761 WARNING(works == 0); 762 763 if (works == 0) 764 { 765 // set volume without open playout device 766 for (vol = 0; vol <= maxVol; vol += (maxVol/5)) 767 { 768 EXPECT_EQ(0, audio_device_->SetWaveOutVolume(vol, vol)); 769 EXPECT_EQ(0, audio_device_->WaveOutVolume(volL, volR)); 770 EXPECT_TRUE((volL == vol) && (volR == vol)); 771 } 772 773 // repeat test but this time with an open (default) output device 774 EXPECT_EQ(0, audio_device_->SetPlayoutDevice( 775 AudioDeviceModule::kDefaultDevice)); 776 EXPECT_EQ(0, audio_device_->InitPlayout()); 777 EXPECT_TRUE(audio_device_->PlayoutIsInitialized()); 778 for (vol = 0; vol <= maxVol; vol += (maxVol/5)) 779 { 780 EXPECT_EQ(0, audio_device_->SetWaveOutVolume(vol, vol)); 781 EXPECT_EQ(0, audio_device_->WaveOutVolume(volL, volR)); 782 EXPECT_TRUE((volL == vol) && (volR == vol)); 783 } 784 785 // as above but while playout is active 786 EXPECT_EQ(0, audio_device_->StartPlayout()); 787 EXPECT_TRUE(audio_device_->Playing()); 788 for (vol = 0; vol <= maxVol; vol += (maxVol/5)) 789 { 790 EXPECT_EQ(0, audio_device_->SetWaveOutVolume(vol, vol)); 791 EXPECT_EQ(0, audio_device_->WaveOutVolume(volL, volR)); 792 EXPECT_TRUE((volL == vol) && (volR == vol)); 793 } 794 } 795 796 EXPECT_EQ(0, audio_device_->StopPlayout()); 797 EXPECT_FALSE(audio_device_->Playing()); 798 } 799 #endif // defined(_WIN32) && !defined(WEBRTC_WINDOWS_CORE_AUDIO_BUILD) 800 801 TEST_F(AudioDeviceAPITest, InitSpeaker) { 802 // NOTE: By calling Terminate (in TearDown) followed by Init (in SetUp) we 803 // ensure that any existing output mixer handle is set to NULL. 804 // The mixer handle is closed and reopened again for each call to 805 // SetPlayoutDevice. 806 CheckInitialPlayoutStates(); 807 808 // kDefaultCommunicationDevice 809 EXPECT_EQ(0, audio_device_->SetPlayoutDevice( 810 MACRO_DEFAULT_COMMUNICATION_DEVICE)); 811 EXPECT_EQ(0, audio_device_->InitSpeaker()); 812 813 // fail tests 814 bool available; 815 EXPECT_EQ(0, audio_device_->PlayoutIsAvailable(&available)); 816 if (available) { 817 EXPECT_EQ(0, audio_device_->InitPlayout()); 818 EXPECT_EQ(0, audio_device_->StartPlayout()); 819 EXPECT_EQ(-1, audio_device_->InitSpeaker()); 820 EXPECT_EQ(0, audio_device_->StopPlayout()); 821 } 822 823 // kDefaultDevice 824 EXPECT_EQ(0, audio_device_->SetPlayoutDevice(MACRO_DEFAULT_DEVICE)); 825 EXPECT_EQ(0, audio_device_->InitSpeaker()); 826 827 // repeat test for all devices 828 int16_t no_devices = audio_device_->PlayoutDevices(); 829 for (int i = 0; i < no_devices; i++) { 830 EXPECT_EQ(0, audio_device_->SetPlayoutDevice(i)); 831 EXPECT_EQ(0, audio_device_->InitSpeaker()); 832 } 833 } 834 835 TEST_F(AudioDeviceAPITest, InitMicrophone) { 836 // NOTE: By calling Terminate (in TearDown) followed by Init (in SetUp) we 837 // ensure that any existing output mixer handle is set to NULL. 838 // The mixer handle is closed and reopened again for each call to 839 // SetRecordingDevice. 840 CheckInitialRecordingStates(); 841 842 // kDefaultCommunicationDevice 843 EXPECT_EQ(0, 844 audio_device_->SetRecordingDevice(MACRO_DEFAULT_COMMUNICATION_DEVICE)); 845 EXPECT_EQ(0, audio_device_->InitMicrophone()); 846 847 // fail tests 848 bool available; 849 EXPECT_EQ(0, audio_device_->RecordingIsAvailable(&available)); 850 if (available) { 851 EXPECT_EQ(0, audio_device_->InitRecording()); 852 EXPECT_EQ(0, audio_device_->StartRecording()); 853 EXPECT_EQ(-1, audio_device_->InitMicrophone()); 854 EXPECT_EQ(0, audio_device_->StopRecording()); 855 } 856 857 // kDefaultDevice 858 EXPECT_EQ(0, audio_device_->SetRecordingDevice(MACRO_DEFAULT_DEVICE)); 859 EXPECT_EQ(0, audio_device_->InitMicrophone()); 860 861 // repeat test for all devices 862 int16_t no_devices = audio_device_->RecordingDevices(); 863 for (int i = 0; i < no_devices; i++) { 864 EXPECT_EQ(0, audio_device_->SetRecordingDevice(i)); 865 EXPECT_EQ(0, audio_device_->InitMicrophone()); 866 } 867 } 868 869 TEST_F(AudioDeviceAPITest, SpeakerVolumeIsAvailable) { 870 CheckInitialPlayoutStates(); 871 bool available; 872 873 #ifdef _WIN32 874 // check the kDefaultCommunicationDevice 875 EXPECT_TRUE(audio_device_->SetPlayoutDevice( 876 AudioDeviceModule::kDefaultCommunicationDevice) == 0); 877 EXPECT_EQ(0, audio_device_->SpeakerVolumeIsAvailable(&available)); 878 // check for availability should not lead to initialization 879 EXPECT_FALSE(audio_device_->SpeakerIsInitialized()); 880 #endif 881 882 // check the kDefaultDevice 883 EXPECT_EQ(0, audio_device_->SetPlayoutDevice(MACRO_DEFAULT_DEVICE)); 884 EXPECT_EQ(0, audio_device_->SpeakerVolumeIsAvailable(&available)); 885 EXPECT_FALSE(audio_device_->SpeakerIsInitialized()); 886 887 // check all availiable devices 888 int16_t no_devices = audio_device_->PlayoutDevices(); 889 for (int i = 0; i < no_devices; i++) { 890 EXPECT_EQ(0, audio_device_->SetPlayoutDevice(i)); 891 EXPECT_EQ(0, audio_device_->SpeakerVolumeIsAvailable(&available)); 892 EXPECT_FALSE(audio_device_->SpeakerIsInitialized()); 893 } 894 } 895 896 // Tests the following methods: 897 // SetSpeakerVolume 898 // SpeakerVolume 899 // MaxSpeakerVolume 900 // MinSpeakerVolume 901 // NOTE: Disabled on mac due to issue 257. 902 #ifndef WEBRTC_MAC 903 TEST_F(AudioDeviceAPITest, SpeakerVolumeTests) { 904 uint32_t vol(0); 905 uint32_t volume(0); 906 uint32_t maxVolume(0); 907 uint32_t minVolume(0); 908 uint16_t stepSize(0); 909 bool available; 910 CheckInitialPlayoutStates(); 911 912 // fail tests 913 EXPECT_EQ(-1, audio_device_->SetSpeakerVolume(0)); 914 // speaker must be initialized first 915 EXPECT_EQ(-1, audio_device_->SpeakerVolume(&volume)); 916 EXPECT_EQ(-1, audio_device_->MaxSpeakerVolume(&maxVolume)); 917 EXPECT_EQ(-1, audio_device_->MinSpeakerVolume(&minVolume)); 918 EXPECT_EQ(-1, audio_device_->SpeakerVolumeStepSize(&stepSize)); 919 920 #if defined(_WIN32) && !defined(WEBRTC_WINDOWS_CORE_AUDIO_BUILD) 921 // test for warning (can e.g. happen on Vista with Wave API) 922 EXPECT_EQ(0, 923 audio_device_->SetPlayoutDevice(AudioDeviceModule::kDefaultDevice)); 924 EXPECT_EQ(0, audio_device_->SpeakerVolumeIsAvailable(&available)); 925 if (available) { 926 EXPECT_EQ(0, audio_device_->InitSpeaker()); 927 EXPECT_EQ(0, audio_device_->SetSpeakerVolume(19001)); 928 EXPECT_EQ(0, audio_device_->SpeakerVolume(&volume)); 929 WARNING(volume == 19001); 930 } 931 #endif 932 933 #ifdef _WIN32 934 // use kDefaultCommunicationDevice and modify/retrieve the volume 935 EXPECT_TRUE(audio_device_->SetPlayoutDevice( 936 AudioDeviceModule::kDefaultCommunicationDevice) == 0); 937 EXPECT_EQ(0, audio_device_->SpeakerVolumeIsAvailable(&available)); 938 if (available) { 939 EXPECT_EQ(0, audio_device_->InitSpeaker()); 940 EXPECT_EQ(0, audio_device_->MaxSpeakerVolume(&maxVolume)); 941 EXPECT_EQ(0, audio_device_->MinSpeakerVolume(&minVolume)); 942 EXPECT_EQ(0, audio_device_->SpeakerVolumeStepSize(&stepSize)); 943 for (vol = minVolume; vol < (int)maxVolume; vol += 20*stepSize) { 944 EXPECT_EQ(0, audio_device_->SetSpeakerVolume(vol)); 945 EXPECT_EQ(0, audio_device_->SpeakerVolume(&volume)); 946 CheckVolume(volume, vol); 947 } 948 } 949 #endif 950 951 // use kDefaultDevice and modify/retrieve the volume 952 EXPECT_EQ(0, audio_device_->SetPlayoutDevice(MACRO_DEFAULT_DEVICE)); 953 EXPECT_EQ(0, audio_device_->SpeakerVolumeIsAvailable(&available)); 954 if (available) { 955 EXPECT_EQ(0, audio_device_->InitSpeaker()); 956 EXPECT_EQ(0, audio_device_->MaxSpeakerVolume(&maxVolume)); 957 EXPECT_EQ(0, audio_device_->MinSpeakerVolume(&minVolume)); 958 EXPECT_EQ(0, audio_device_->SpeakerVolumeStepSize(&stepSize)); 959 uint32_t step = (maxVolume - minVolume) / 10; 960 step = (step < stepSize ? stepSize : step); 961 for (vol = minVolume; vol <= maxVolume; vol += step) { 962 EXPECT_EQ(0, audio_device_->SetSpeakerVolume(vol)); 963 EXPECT_EQ(0, audio_device_->SpeakerVolume(&volume)); 964 CheckVolume(volume, vol); 965 } 966 } 967 968 // use all (indexed) devices and modify/retrieve the volume 969 int16_t no_devices = audio_device_->PlayoutDevices(); 970 for (int i = 0; i < no_devices; i++) { 971 EXPECT_EQ(0, audio_device_->SetPlayoutDevice(i)); 972 EXPECT_EQ(0, audio_device_->SpeakerVolumeIsAvailable(&available)); 973 if (available) { 974 EXPECT_EQ(0, audio_device_->InitSpeaker()); 975 EXPECT_EQ(0, audio_device_->MaxSpeakerVolume(&maxVolume)); 976 EXPECT_EQ(0, audio_device_->MinSpeakerVolume(&minVolume)); 977 EXPECT_EQ(0, audio_device_->SpeakerVolumeStepSize(&stepSize)); 978 uint32_t step = (maxVolume - minVolume) / 10; 979 step = (step < stepSize ? stepSize : step); 980 for (vol = minVolume; vol <= maxVolume; vol += step) { 981 EXPECT_EQ(0, audio_device_->SetSpeakerVolume(vol)); 982 EXPECT_EQ(0, audio_device_->SpeakerVolume(&volume)); 983 CheckVolume(volume, vol); 984 } 985 } 986 } 987 988 // restore reasonable level 989 EXPECT_EQ(0, audio_device_->SetPlayoutDevice(MACRO_DEFAULT_DEVICE)); 990 EXPECT_EQ(0, audio_device_->SpeakerVolumeIsAvailable(&available)); 991 if (available) { 992 EXPECT_EQ(0, audio_device_->InitSpeaker()); 993 EXPECT_EQ(0, audio_device_->MaxSpeakerVolume(&maxVolume)); 994 EXPECT_TRUE(audio_device_->SetSpeakerVolume(maxVolume < 10 ? 995 maxVolume/3 : maxVolume/10) == 0); 996 } 997 } 998 #endif // !WEBRTC_MAC 999 1000 TEST_F(AudioDeviceAPITest, AGC) { 1001 // NOTE: The AGC API only enables/disables the AGC. To ensure that it will 1002 // have an effect, use it in combination with MicrophoneVolumeIsAvailable. 1003 CheckInitialRecordingStates(); 1004 EXPECT_FALSE(audio_device_->AGC()); 1005 1006 // set/get tests 1007 EXPECT_EQ(0, audio_device_->SetAGC(true)); 1008 EXPECT_TRUE(audio_device_->AGC()); 1009 EXPECT_EQ(0, audio_device_->SetAGC(false)); 1010 EXPECT_FALSE(audio_device_->AGC()); 1011 } 1012 1013 TEST_F(AudioDeviceAPITest, MicrophoneVolumeIsAvailable) { 1014 CheckInitialRecordingStates(); 1015 bool available; 1016 1017 #ifdef _WIN32 1018 // check the kDefaultCommunicationDevice 1019 EXPECT_TRUE(audio_device_->SetRecordingDevice( 1020 AudioDeviceModule::kDefaultCommunicationDevice) == 0); 1021 EXPECT_EQ(0, audio_device_->MicrophoneVolumeIsAvailable(&available)); 1022 // check for availability should not lead to initialization 1023 EXPECT_FALSE(audio_device_->MicrophoneIsInitialized()); 1024 #endif 1025 1026 // check the kDefaultDevice 1027 EXPECT_EQ(0, audio_device_->SetRecordingDevice(MACRO_DEFAULT_DEVICE)); 1028 EXPECT_EQ(0, audio_device_->MicrophoneVolumeIsAvailable(&available)); 1029 EXPECT_FALSE(audio_device_->MicrophoneIsInitialized()); 1030 1031 // check all availiable devices 1032 int16_t no_devices = audio_device_->RecordingDevices(); 1033 for (int i = 0; i < no_devices; i++) { 1034 EXPECT_EQ(0, audio_device_->SetRecordingDevice(i)); 1035 EXPECT_EQ(0, audio_device_->MicrophoneVolumeIsAvailable(&available)); 1036 EXPECT_FALSE(audio_device_->MicrophoneIsInitialized()); 1037 } 1038 } 1039 1040 // Tests the methods: 1041 // SetMicrophoneVolume 1042 // MicrophoneVolume 1043 // MaxMicrophoneVolume 1044 // MinMicrophoneVolume 1045 // NOTE: Disabled on mac due to issue 257. 1046 #ifndef WEBRTC_MAC 1047 TEST_F(AudioDeviceAPITest, MicrophoneVolumeTests) { 1048 uint32_t vol(0); 1049 uint32_t volume(0); 1050 uint32_t maxVolume(0); 1051 uint32_t minVolume(0); 1052 uint16_t stepSize(0); 1053 bool available; 1054 CheckInitialRecordingStates(); 1055 1056 // fail tests 1057 EXPECT_EQ(-1, audio_device_->SetMicrophoneVolume(0)); 1058 // must be initialized first 1059 EXPECT_EQ(-1, audio_device_->MicrophoneVolume(&volume)); 1060 EXPECT_EQ(-1, audio_device_->MaxMicrophoneVolume(&maxVolume)); 1061 EXPECT_EQ(-1, audio_device_->MinMicrophoneVolume(&minVolume)); 1062 EXPECT_EQ(-1, audio_device_->MicrophoneVolumeStepSize(&stepSize)); 1063 1064 #if defined(_WIN32) && !defined(WEBRTC_WINDOWS_CORE_AUDIO_BUILD) 1065 // test for warning (can e.g. happen on Vista with Wave API) 1066 EXPECT_EQ(0, audio_device_->SetRecordingDevice( 1067 AudioDeviceModule::kDefaultDevice)); 1068 EXPECT_EQ(0, audio_device_->MicrophoneVolumeIsAvailable(&available)); 1069 if (available) 1070 { 1071 EXPECT_EQ(0, audio_device_->InitMicrophone()); 1072 EXPECT_EQ(0, audio_device_->SetMicrophoneVolume(19001)); 1073 EXPECT_EQ(0, audio_device_->MicrophoneVolume(&volume)); 1074 WARNING(volume == 19001); 1075 } 1076 #endif 1077 1078 #ifdef _WIN32 1079 // initialize kDefaultCommunicationDevice and modify/retrieve the volume 1080 EXPECT_TRUE(audio_device_->SetRecordingDevice( 1081 AudioDeviceModule::kDefaultCommunicationDevice) == 0); 1082 EXPECT_EQ(0, audio_device_->MicrophoneVolumeIsAvailable(&available)); 1083 if (available) 1084 { 1085 EXPECT_EQ(0, audio_device_->InitMicrophone()); 1086 EXPECT_EQ(0, audio_device_->MaxMicrophoneVolume(&maxVolume)); 1087 EXPECT_EQ(0, audio_device_->MinMicrophoneVolume(&minVolume)); 1088 EXPECT_EQ(0, audio_device_->MicrophoneVolumeStepSize(&stepSize)); 1089 for (vol = minVolume; vol < (int)maxVolume; vol += 10*stepSize) 1090 { 1091 EXPECT_EQ(0, audio_device_->SetMicrophoneVolume(vol)); 1092 EXPECT_EQ(0, audio_device_->MicrophoneVolume(&volume)); 1093 CheckVolume(volume, vol); 1094 } 1095 } 1096 #endif 1097 1098 // reinitialize kDefaultDevice and modify/retrieve the volume 1099 EXPECT_EQ(0, audio_device_->SetRecordingDevice(MACRO_DEFAULT_DEVICE)); 1100 EXPECT_EQ(0, audio_device_->MicrophoneVolumeIsAvailable(&available)); 1101 if (available) { 1102 EXPECT_EQ(0, audio_device_->InitMicrophone()); 1103 EXPECT_EQ(0, audio_device_->MaxMicrophoneVolume(&maxVolume)); 1104 EXPECT_EQ(0, audio_device_->MinMicrophoneVolume(&minVolume)); 1105 EXPECT_EQ(0, audio_device_->MicrophoneVolumeStepSize(&stepSize)); 1106 for (vol = minVolume; vol < maxVolume; vol += 10 * stepSize) { 1107 EXPECT_EQ(0, audio_device_->SetMicrophoneVolume(vol)); 1108 EXPECT_EQ(0, audio_device_->MicrophoneVolume(&volume)); 1109 CheckVolume(volume, vol); 1110 } 1111 } 1112 1113 // use all (indexed) devices and modify/retrieve the volume 1114 int16_t no_devices = audio_device_->RecordingDevices(); 1115 for (int i = 0; i < no_devices; i++) { 1116 EXPECT_EQ(0, audio_device_->SetRecordingDevice(i)); 1117 EXPECT_EQ(0, audio_device_->MicrophoneVolumeIsAvailable(&available)); 1118 if (available) { 1119 EXPECT_EQ(0, audio_device_->InitMicrophone()); 1120 EXPECT_EQ(0, audio_device_->MaxMicrophoneVolume(&maxVolume)); 1121 EXPECT_EQ(0, audio_device_->MinMicrophoneVolume(&minVolume)); 1122 EXPECT_EQ(0, audio_device_->MicrophoneVolumeStepSize(&stepSize)); 1123 for (vol = minVolume; vol < maxVolume; vol += 20 * stepSize) { 1124 EXPECT_EQ(0, audio_device_->SetMicrophoneVolume(vol)); 1125 EXPECT_EQ(0, audio_device_->MicrophoneVolume(&volume)); 1126 CheckVolume(volume, vol); 1127 } 1128 } 1129 } 1130 1131 // restore reasonable level 1132 EXPECT_EQ(0, audio_device_->SetRecordingDevice(MACRO_DEFAULT_DEVICE)); 1133 EXPECT_EQ(0, audio_device_->MicrophoneVolumeIsAvailable(&available)); 1134 if (available) { 1135 EXPECT_EQ(0, audio_device_->InitMicrophone()); 1136 EXPECT_EQ(0, audio_device_->MaxMicrophoneVolume(&maxVolume)); 1137 EXPECT_EQ(0, audio_device_->SetMicrophoneVolume(maxVolume/10)); 1138 } 1139 } 1140 #endif // !WEBRTC_MAC 1141 1142 TEST_F(AudioDeviceAPITest, SpeakerMuteIsAvailable) { 1143 bool available; 1144 CheckInitialPlayoutStates(); 1145 #ifdef _WIN32 1146 // check the kDefaultCommunicationDevice 1147 EXPECT_TRUE(audio_device_->SetPlayoutDevice( 1148 AudioDeviceModule::kDefaultCommunicationDevice) == 0); 1149 EXPECT_EQ(0, audio_device_->SpeakerMuteIsAvailable(&available)); 1150 // check for availability should not lead to initialization 1151 EXPECT_FALSE(audio_device_->SpeakerIsInitialized()); 1152 #endif 1153 1154 // check the kDefaultDevice 1155 EXPECT_EQ(0, audio_device_->SetPlayoutDevice(MACRO_DEFAULT_DEVICE)); 1156 EXPECT_EQ(0, audio_device_->SpeakerMuteIsAvailable(&available)); 1157 EXPECT_FALSE(audio_device_->SpeakerIsInitialized()); 1158 1159 // check all availiable devices 1160 int16_t no_devices = audio_device_->PlayoutDevices(); 1161 for (int i = 0; i < no_devices; i++) { 1162 EXPECT_EQ(0, audio_device_->SetPlayoutDevice(i)); 1163 EXPECT_EQ(0, audio_device_->SpeakerMuteIsAvailable(&available)); 1164 EXPECT_FALSE(audio_device_->SpeakerIsInitialized()); 1165 } 1166 } 1167 1168 TEST_F(AudioDeviceAPITest, MicrophoneMuteIsAvailable) { 1169 bool available; 1170 CheckInitialRecordingStates(); 1171 #ifdef _WIN32 1172 // check the kDefaultCommunicationDevice 1173 EXPECT_TRUE(audio_device_->SetRecordingDevice( 1174 AudioDeviceModule::kDefaultCommunicationDevice) == 0); 1175 EXPECT_EQ(0, audio_device_->MicrophoneMuteIsAvailable(&available)); 1176 // check for availability should not lead to initialization 1177 #endif 1178 EXPECT_FALSE(audio_device_->MicrophoneIsInitialized()); 1179 1180 // check the kDefaultDevice 1181 EXPECT_EQ(0, audio_device_->SetRecordingDevice(MACRO_DEFAULT_DEVICE)); 1182 EXPECT_EQ(0, audio_device_->MicrophoneMuteIsAvailable(&available)); 1183 EXPECT_FALSE(audio_device_->MicrophoneIsInitialized()); 1184 1185 // check all availiable devices 1186 int16_t no_devices = audio_device_->RecordingDevices(); 1187 for (int i = 0; i < no_devices; i++) { 1188 EXPECT_EQ(0, audio_device_->SetRecordingDevice(i)); 1189 EXPECT_EQ(0, audio_device_->MicrophoneMuteIsAvailable(&available)); 1190 EXPECT_FALSE(audio_device_->MicrophoneIsInitialized()); 1191 } 1192 } 1193 1194 TEST_F(AudioDeviceAPITest, MicrophoneBoostIsAvailable) { 1195 bool available; 1196 CheckInitialRecordingStates(); 1197 #ifdef _WIN32 1198 // check the kDefaultCommunicationDevice 1199 EXPECT_TRUE(audio_device_->SetRecordingDevice( 1200 AudioDeviceModule::kDefaultCommunicationDevice) == 0); 1201 EXPECT_EQ(0, audio_device_->MicrophoneBoostIsAvailable(&available)); 1202 // check for availability should not lead to initialization 1203 EXPECT_FALSE(audio_device_->MicrophoneIsInitialized()); 1204 #endif 1205 1206 // check the kDefaultDevice 1207 EXPECT_EQ(0, audio_device_->SetRecordingDevice(MACRO_DEFAULT_DEVICE)); 1208 EXPECT_EQ(0, audio_device_->MicrophoneBoostIsAvailable(&available)); 1209 EXPECT_FALSE(audio_device_->MicrophoneIsInitialized()); 1210 1211 // check all availiable devices 1212 int16_t no_devices = audio_device_->RecordingDevices(); 1213 for (int i = 0; i < no_devices; i++) { 1214 EXPECT_EQ(0, audio_device_->SetRecordingDevice(i)); 1215 EXPECT_EQ(0, audio_device_->MicrophoneBoostIsAvailable(&available)); 1216 EXPECT_FALSE(audio_device_->MicrophoneIsInitialized()); 1217 } 1218 } 1219 1220 TEST_F(AudioDeviceAPITest, SpeakerMuteTests) { 1221 bool available; 1222 bool enabled; 1223 CheckInitialPlayoutStates(); 1224 // fail tests 1225 EXPECT_EQ(-1, audio_device_->SetSpeakerMute(true)); 1226 // requires initialization 1227 EXPECT_EQ(-1, audio_device_->SpeakerMute(&enabled)); 1228 1229 #ifdef _WIN32 1230 // initialize kDefaultCommunicationDevice and modify/retrieve the mute state 1231 EXPECT_EQ(0, audio_device_->SetPlayoutDevice( 1232 AudioDeviceModule::kDefaultCommunicationDevice)); 1233 EXPECT_EQ(0, audio_device_->SpeakerMuteIsAvailable(&available)); 1234 if (available) 1235 { 1236 EXPECT_EQ(0, audio_device_->InitSpeaker()); 1237 EXPECT_EQ(0, audio_device_->SetSpeakerMute(true)); 1238 EXPECT_EQ(0, audio_device_->SpeakerMute(&enabled)); 1239 EXPECT_TRUE(enabled); 1240 EXPECT_EQ(0, audio_device_->SetSpeakerMute(false)); 1241 EXPECT_EQ(0, audio_device_->SpeakerMute(&enabled)); 1242 EXPECT_FALSE(enabled); 1243 } 1244 #endif 1245 1246 // reinitialize kDefaultDevice and modify/retrieve the mute state 1247 EXPECT_EQ(0, audio_device_->SetPlayoutDevice(MACRO_DEFAULT_DEVICE)); 1248 EXPECT_EQ(0, audio_device_->SpeakerMuteIsAvailable(&available)); 1249 if (available) { 1250 EXPECT_EQ(0, audio_device_->InitSpeaker()); 1251 EXPECT_EQ(0, audio_device_->SetSpeakerMute(true)); 1252 EXPECT_EQ(0, audio_device_->SpeakerMute(&enabled)); 1253 EXPECT_TRUE(enabled); 1254 EXPECT_EQ(0, audio_device_->SetSpeakerMute(false)); 1255 EXPECT_EQ(0, audio_device_->SpeakerMute(&enabled)); 1256 EXPECT_FALSE(enabled); 1257 } 1258 1259 // reinitialize the default device (0) and modify/retrieve the mute state 1260 EXPECT_EQ(0, audio_device_->SetPlayoutDevice(0)); 1261 EXPECT_EQ(0, audio_device_->SpeakerMuteIsAvailable(&available)); 1262 if (available) { 1263 EXPECT_EQ(0, audio_device_->InitSpeaker()); 1264 EXPECT_EQ(0, audio_device_->SetSpeakerMute(true)); 1265 EXPECT_EQ(0, audio_device_->SpeakerMute(&enabled)); 1266 EXPECT_TRUE(enabled); 1267 EXPECT_EQ(0, audio_device_->SetSpeakerMute(false)); 1268 EXPECT_EQ(0, audio_device_->SpeakerMute(&enabled)); 1269 EXPECT_FALSE(enabled); 1270 } 1271 } 1272 1273 TEST_F(AudioDeviceAPITest, MicrophoneMuteTests) { 1274 CheckInitialRecordingStates(); 1275 1276 // fail tests 1277 EXPECT_EQ(-1, audio_device_->SetMicrophoneMute(true)); 1278 // requires initialization 1279 bool available; 1280 bool enabled; 1281 EXPECT_EQ(-1, audio_device_->MicrophoneMute(&enabled)); 1282 1283 #ifdef _WIN32 1284 // initialize kDefaultCommunicationDevice and modify/retrieve the mute 1285 EXPECT_TRUE(audio_device_->SetRecordingDevice( 1286 AudioDeviceModule::kDefaultCommunicationDevice) == 0); 1287 EXPECT_EQ(0, audio_device_->MicrophoneMuteIsAvailable(&available)); 1288 if (available) 1289 { 1290 EXPECT_EQ(0, audio_device_->InitMicrophone()); 1291 EXPECT_EQ(0, audio_device_->SetMicrophoneMute(true)); 1292 EXPECT_EQ(0, audio_device_->MicrophoneMute(&enabled)); 1293 EXPECT_TRUE(enabled); 1294 EXPECT_EQ(0, audio_device_->SetMicrophoneMute(false)); 1295 EXPECT_EQ(0, audio_device_->MicrophoneMute(&enabled)); 1296 EXPECT_FALSE(enabled); 1297 } 1298 #endif 1299 1300 // reinitialize kDefaultDevice and modify/retrieve the mute 1301 EXPECT_EQ(0, audio_device_->SetRecordingDevice(MACRO_DEFAULT_DEVICE)); 1302 EXPECT_EQ(0, audio_device_->MicrophoneMuteIsAvailable(&available)); 1303 if (available) { 1304 EXPECT_EQ(0, audio_device_->InitMicrophone()); 1305 EXPECT_EQ(0, audio_device_->SetMicrophoneMute(true)); 1306 EXPECT_EQ(0, audio_device_->MicrophoneMute(&enabled)); 1307 EXPECT_TRUE(enabled); 1308 EXPECT_EQ(0, audio_device_->SetMicrophoneMute(false)); 1309 EXPECT_EQ(0, audio_device_->MicrophoneMute(&enabled)); 1310 EXPECT_FALSE(enabled); 1311 } 1312 1313 // reinitialize the default device (0) and modify/retrieve the Mute 1314 EXPECT_EQ(0, audio_device_->SetRecordingDevice(0)); 1315 EXPECT_EQ(0, audio_device_->MicrophoneMuteIsAvailable(&available)); 1316 if (available) { 1317 EXPECT_EQ(0, audio_device_->InitMicrophone()); 1318 EXPECT_EQ(0, audio_device_->SetMicrophoneMute(true)); 1319 EXPECT_EQ(0, audio_device_->MicrophoneMute(&enabled)); 1320 EXPECT_TRUE(enabled); 1321 EXPECT_EQ(0, audio_device_->SetMicrophoneMute(false)); 1322 EXPECT_EQ(0, audio_device_->MicrophoneMute(&enabled)); 1323 EXPECT_FALSE(enabled); 1324 } 1325 } 1326 1327 TEST_F(AudioDeviceAPITest, MicrophoneBoostTests) { 1328 bool available; 1329 bool enabled; 1330 CheckInitialRecordingStates(); 1331 1332 // fail tests 1333 EXPECT_EQ(-1, audio_device_->SetMicrophoneBoost(true)); 1334 // requires initialization 1335 EXPECT_EQ(-1, audio_device_->MicrophoneBoost(&enabled)); 1336 1337 #ifdef _WIN32 1338 // initialize kDefaultCommunicationDevice and modify/retrieve the boost 1339 EXPECT_TRUE(audio_device_->SetRecordingDevice( 1340 AudioDeviceModule::kDefaultCommunicationDevice) == 0); 1341 EXPECT_EQ(0, audio_device_->MicrophoneBoostIsAvailable(&available)); 1342 if (available) 1343 { 1344 EXPECT_EQ(0, audio_device_->InitMicrophone()); 1345 EXPECT_EQ(0, audio_device_->SetMicrophoneBoost(true)); 1346 EXPECT_EQ(0, audio_device_->MicrophoneBoost(&enabled)); 1347 EXPECT_TRUE(enabled); 1348 EXPECT_EQ(0, audio_device_->SetMicrophoneBoost(false)); 1349 EXPECT_EQ(0, audio_device_->MicrophoneBoost(&enabled)); 1350 EXPECT_FALSE(enabled); 1351 } 1352 #endif 1353 1354 // reinitialize kDefaultDevice and modify/retrieve the boost 1355 EXPECT_EQ(0, audio_device_->SetRecordingDevice(MACRO_DEFAULT_DEVICE)); 1356 EXPECT_EQ(0, audio_device_->MicrophoneBoostIsAvailable(&available)); 1357 if (available) { 1358 EXPECT_EQ(0, audio_device_->InitMicrophone()); 1359 EXPECT_EQ(0, audio_device_->SetMicrophoneBoost(true)); 1360 EXPECT_EQ(0, audio_device_->MicrophoneBoost(&enabled)); 1361 EXPECT_TRUE(enabled); 1362 EXPECT_EQ(0, audio_device_->SetMicrophoneBoost(false)); 1363 EXPECT_EQ(0, audio_device_->MicrophoneBoost(&enabled)); 1364 EXPECT_FALSE(enabled); 1365 } 1366 1367 // reinitialize the default device (0) and modify/retrieve the boost 1368 EXPECT_EQ(0, audio_device_->SetRecordingDevice(0)); 1369 EXPECT_EQ(0, audio_device_->MicrophoneBoostIsAvailable(&available)); 1370 if (available) { 1371 EXPECT_EQ(0, audio_device_->InitMicrophone()); 1372 EXPECT_EQ(0, audio_device_->SetMicrophoneBoost(true)); 1373 EXPECT_EQ(0, audio_device_->MicrophoneBoost(&enabled)); 1374 EXPECT_TRUE(enabled); 1375 EXPECT_EQ(0, audio_device_->SetMicrophoneBoost(false)); 1376 EXPECT_EQ(0, audio_device_->MicrophoneBoost(&enabled)); 1377 EXPECT_FALSE(enabled); 1378 } 1379 } 1380 1381 TEST_F(AudioDeviceAPITest, StereoPlayoutTests) { 1382 CheckInitialPlayoutStates(); 1383 1384 // fail tests 1385 EXPECT_EQ(-1, audio_device_->InitPlayout()); 1386 EXPECT_EQ(0, audio_device_->SetPlayoutDevice( 1387 MACRO_DEFAULT_COMMUNICATION_DEVICE)); 1388 1389 // TODO(kjellander): Fix so these tests pass on Mac. 1390 #if !defined(WEBRTC_MAC) 1391 EXPECT_EQ(0, audio_device_->InitPlayout()); 1392 EXPECT_TRUE(audio_device_->PlayoutIsInitialized()); 1393 // must be performed before initialization 1394 EXPECT_EQ(-1, audio_device_->SetStereoPlayout(true)); 1395 #endif 1396 1397 // ensure that we can set the stereo mode for playout 1398 EXPECT_EQ(0, audio_device_->StopPlayout()); 1399 EXPECT_FALSE(audio_device_->PlayoutIsInitialized()); 1400 1401 // initialize kDefaultCommunicationDevice and modify/retrieve stereo support 1402 EXPECT_EQ(0, audio_device_->SetPlayoutDevice( 1403 MACRO_DEFAULT_COMMUNICATION_DEVICE)); 1404 bool available; 1405 bool enabled; 1406 EXPECT_EQ(0, audio_device_->StereoPlayoutIsAvailable(&available)); 1407 if (available) { 1408 EXPECT_EQ(0, audio_device_->SetStereoPlayout(true)); 1409 EXPECT_EQ(0, audio_device_->StereoPlayout(&enabled)); 1410 EXPECT_TRUE(enabled); 1411 EXPECT_EQ(0, audio_device_->SetStereoPlayout(false)); 1412 EXPECT_EQ(0, audio_device_->StereoPlayout(&enabled)); 1413 EXPECT_FALSE(enabled); 1414 EXPECT_EQ(0, audio_device_->SetStereoPlayout(true)); 1415 EXPECT_EQ(0, audio_device_->StereoPlayout(&enabled)); 1416 EXPECT_TRUE(enabled); 1417 } 1418 1419 // initialize kDefaultDevice and modify/retrieve stereo support 1420 EXPECT_EQ(0, audio_device_->SetPlayoutDevice(MACRO_DEFAULT_DEVICE)); 1421 EXPECT_EQ(0, audio_device_->StereoPlayoutIsAvailable(&available)); 1422 if (available) { 1423 EXPECT_EQ(0, audio_device_->SetStereoPlayout(true)); 1424 EXPECT_EQ(0, audio_device_->StereoPlayout(&enabled)); 1425 EXPECT_TRUE(enabled); 1426 EXPECT_EQ(0, audio_device_->SetStereoPlayout(false)); 1427 EXPECT_EQ(0, audio_device_->StereoPlayout(&enabled)); 1428 EXPECT_FALSE(enabled); 1429 EXPECT_EQ(0, audio_device_->SetStereoPlayout(true)); 1430 EXPECT_EQ(0, audio_device_->StereoPlayout(&enabled)); 1431 EXPECT_TRUE(enabled); 1432 } 1433 1434 // initialize default device (0) and modify/retrieve stereo support 1435 EXPECT_EQ(0, audio_device_->SetPlayoutDevice(0)); 1436 EXPECT_EQ(0, audio_device_->StereoPlayoutIsAvailable(&available)); 1437 if (available) { 1438 EXPECT_EQ(0, audio_device_->SetStereoPlayout(true)); 1439 EXPECT_EQ(0, audio_device_->StereoPlayout(&enabled)); 1440 EXPECT_TRUE(enabled); 1441 EXPECT_EQ(0, audio_device_->SetStereoPlayout(false)); 1442 EXPECT_EQ(0, audio_device_->StereoPlayout(&enabled)); 1443 EXPECT_FALSE(enabled); 1444 EXPECT_EQ(0, audio_device_->SetStereoPlayout(true)); 1445 EXPECT_EQ(0, audio_device_->StereoPlayout(&enabled)); 1446 EXPECT_TRUE(enabled); 1447 } 1448 } 1449 1450 TEST_F(AudioDeviceAPITest, StereoRecordingTests) { 1451 CheckInitialRecordingStates(); 1452 EXPECT_FALSE(audio_device_->Playing()); 1453 1454 // fail tests 1455 EXPECT_EQ(-1, audio_device_->InitRecording()); 1456 EXPECT_EQ(0, audio_device_->SetRecordingDevice( 1457 MACRO_DEFAULT_COMMUNICATION_DEVICE)); 1458 1459 // TODO(kjellander): Fix so these tests pass on Mac. 1460 #if !defined(WEBRTC_MAC) 1461 EXPECT_EQ(0, audio_device_->InitRecording()); 1462 EXPECT_TRUE(audio_device_->RecordingIsInitialized()); 1463 // must be performed before initialization 1464 EXPECT_EQ(-1, audio_device_->SetStereoRecording(true)); 1465 #endif 1466 // ensures that we can set the stereo mode for recording 1467 EXPECT_EQ(0, audio_device_->StopRecording()); 1468 EXPECT_FALSE(audio_device_->RecordingIsInitialized()); 1469 1470 // initialize kDefaultCommunicationDevice and modify/retrieve stereo support 1471 EXPECT_EQ(0, audio_device_->SetRecordingDevice( 1472 MACRO_DEFAULT_COMMUNICATION_DEVICE)); 1473 bool available; 1474 bool enabled; 1475 EXPECT_EQ(0, audio_device_->StereoRecordingIsAvailable(&available)); 1476 if (available) { 1477 EXPECT_EQ(0, audio_device_->SetStereoRecording(true)); 1478 EXPECT_EQ(0, audio_device_->StereoRecording(&enabled)); 1479 EXPECT_TRUE(enabled); 1480 EXPECT_EQ(0, audio_device_->SetStereoRecording(false)); 1481 EXPECT_EQ(0, audio_device_->StereoRecording(&enabled)); 1482 EXPECT_FALSE(enabled); 1483 } 1484 1485 // initialize kDefaultDevice and modify/retrieve stereo support 1486 EXPECT_EQ(0, audio_device_->SetRecordingDevice(MACRO_DEFAULT_DEVICE)); 1487 EXPECT_EQ(0, audio_device_->StereoRecordingIsAvailable(&available)); 1488 if (available) { 1489 EXPECT_EQ(0, audio_device_->SetStereoRecording(true)); 1490 EXPECT_EQ(0, audio_device_->StereoRecording(&enabled)); 1491 EXPECT_TRUE(enabled); 1492 EXPECT_EQ(0, audio_device_->SetStereoRecording(false)); 1493 EXPECT_EQ(0, audio_device_->StereoRecording(&enabled)); 1494 EXPECT_FALSE(enabled); 1495 } 1496 1497 // initialize default device (0) and modify/retrieve stereo support 1498 EXPECT_EQ(0, audio_device_->SetRecordingDevice(0)); 1499 EXPECT_EQ(0, audio_device_->StereoRecordingIsAvailable(&available)); 1500 if (available) { 1501 EXPECT_EQ(0, audio_device_->SetStereoRecording(true)); 1502 EXPECT_EQ(0, audio_device_->StereoRecording(&enabled)); 1503 EXPECT_TRUE(enabled); 1504 EXPECT_EQ(0, audio_device_->SetStereoRecording(false)); 1505 EXPECT_EQ(0, audio_device_->StereoRecording(&enabled)); 1506 EXPECT_FALSE(enabled); 1507 } 1508 } 1509 1510 TEST_F(AudioDeviceAPITest, RecordingChannelTests) { 1511 // the user in Win Core Audio 1512 AudioDeviceModule::ChannelType channelType(AudioDeviceModule::kChannelBoth); 1513 CheckInitialRecordingStates(); 1514 EXPECT_FALSE(audio_device_->Playing()); 1515 1516 // fail tests 1517 EXPECT_EQ(0, audio_device_->SetStereoRecording(false)); 1518 EXPECT_EQ(-1, audio_device_->SetRecordingChannel( 1519 AudioDeviceModule::kChannelBoth)); 1520 1521 // initialize kDefaultCommunicationDevice and modify/retrieve stereo support 1522 EXPECT_EQ(0, audio_device_->SetRecordingDevice( 1523 MACRO_DEFAULT_COMMUNICATION_DEVICE)); 1524 bool available; 1525 EXPECT_EQ(0, audio_device_->StereoRecordingIsAvailable(&available)); 1526 if (available) { 1527 EXPECT_EQ(0, audio_device_->SetStereoRecording(true)); 1528 EXPECT_EQ(0, audio_device_->SetRecordingChannel( 1529 AudioDeviceModule::kChannelBoth)); 1530 EXPECT_EQ(0, audio_device_->RecordingChannel(&channelType)); 1531 EXPECT_EQ(AudioDeviceModule::kChannelBoth, channelType); 1532 EXPECT_EQ(0, audio_device_->SetRecordingChannel( 1533 AudioDeviceModule::kChannelLeft)); 1534 EXPECT_EQ(0, audio_device_->RecordingChannel(&channelType)); 1535 EXPECT_EQ(AudioDeviceModule::kChannelLeft, channelType); 1536 EXPECT_EQ(0, audio_device_->SetRecordingChannel( 1537 AudioDeviceModule::kChannelRight)); 1538 EXPECT_EQ(0, audio_device_->RecordingChannel(&channelType)); 1539 EXPECT_EQ(AudioDeviceModule::kChannelRight, channelType); 1540 } 1541 } 1542 1543 TEST_F(AudioDeviceAPITest, PlayoutBufferTests) { 1544 AudioDeviceModule::BufferType bufferType; 1545 uint16_t sizeMS(0); 1546 1547 CheckInitialPlayoutStates(); 1548 EXPECT_EQ(0, audio_device_->PlayoutBuffer(&bufferType, &sizeMS)); 1549 #if defined(_WIN32) || defined(ANDROID) || defined(WEBRTC_IOS) 1550 EXPECT_EQ(AudioDeviceModule::kAdaptiveBufferSize, bufferType); 1551 #else 1552 EXPECT_EQ(AudioDeviceModule::kFixedBufferSize, bufferType); 1553 #endif 1554 1555 // fail tests 1556 EXPECT_EQ(-1, audio_device_->InitPlayout()); 1557 // must set device first 1558 EXPECT_EQ(0, audio_device_->SetPlayoutDevice( 1559 MACRO_DEFAULT_COMMUNICATION_DEVICE)); 1560 1561 // TODO(kjellander): Fix so these tests pass on Mac. 1562 #if !defined(WEBRTC_MAC) 1563 EXPECT_EQ(0, audio_device_->InitPlayout()); 1564 EXPECT_TRUE(audio_device_->PlayoutIsInitialized()); 1565 #endif 1566 EXPECT_TRUE(audio_device_->SetPlayoutBuffer( 1567 AudioDeviceModule::kAdaptiveBufferSize, 100) == -1); 1568 EXPECT_EQ(0, audio_device_->StopPlayout()); 1569 EXPECT_TRUE(audio_device_->SetPlayoutBuffer( 1570 AudioDeviceModule::kFixedBufferSize, kAdmMinPlayoutBufferSizeMs-1) == -1); 1571 EXPECT_TRUE(audio_device_->SetPlayoutBuffer( 1572 AudioDeviceModule::kFixedBufferSize, kAdmMaxPlayoutBufferSizeMs+1) == -1); 1573 1574 // bulk tests (all should be successful) 1575 EXPECT_FALSE(audio_device_->PlayoutIsInitialized()); 1576 #ifdef _WIN32 1577 EXPECT_EQ(0, audio_device_->SetPlayoutBuffer( 1578 AudioDeviceModule::kAdaptiveBufferSize, 0)); 1579 EXPECT_EQ(0, audio_device_->PlayoutBuffer(&bufferType, &sizeMS)); 1580 EXPECT_EQ(AudioDeviceModule::kAdaptiveBufferSize, bufferType); 1581 EXPECT_EQ(0, audio_device_->SetPlayoutBuffer( 1582 AudioDeviceModule::kAdaptiveBufferSize, 10000)); 1583 EXPECT_EQ(0, audio_device_->PlayoutBuffer(&bufferType, &sizeMS)); 1584 EXPECT_EQ(AudioDeviceModule::kAdaptiveBufferSize, bufferType); 1585 #endif 1586 #if defined(ANDROID) || defined(WEBRTC_IOS) 1587 EXPECT_EQ(-1, 1588 audio_device_->SetPlayoutBuffer(AudioDeviceModule::kFixedBufferSize, 1589 kAdmMinPlayoutBufferSizeMs)); 1590 #else 1591 EXPECT_EQ(0, audio_device_->SetPlayoutBuffer( 1592 AudioDeviceModule::kFixedBufferSize, kAdmMinPlayoutBufferSizeMs)); 1593 EXPECT_EQ(0, audio_device_->PlayoutBuffer(&bufferType, &sizeMS)); 1594 EXPECT_EQ(AudioDeviceModule::kFixedBufferSize, bufferType); 1595 EXPECT_EQ(kAdmMinPlayoutBufferSizeMs, sizeMS); 1596 EXPECT_EQ(0, audio_device_->SetPlayoutBuffer( 1597 AudioDeviceModule::kFixedBufferSize, kAdmMaxPlayoutBufferSizeMs)); 1598 EXPECT_EQ(0, audio_device_->PlayoutBuffer(&bufferType, &sizeMS)); 1599 EXPECT_EQ(AudioDeviceModule::kFixedBufferSize, bufferType); 1600 EXPECT_EQ(kAdmMaxPlayoutBufferSizeMs, sizeMS); 1601 EXPECT_EQ(0, audio_device_->SetPlayoutBuffer( 1602 AudioDeviceModule::kFixedBufferSize, 100)); 1603 EXPECT_EQ(0, audio_device_->PlayoutBuffer(&bufferType, &sizeMS)); 1604 EXPECT_EQ(AudioDeviceModule::kFixedBufferSize, bufferType); 1605 EXPECT_EQ(100, sizeMS); 1606 #endif 1607 1608 #ifdef _WIN32 1609 // restore default 1610 EXPECT_EQ(0, audio_device_->SetPlayoutBuffer( 1611 AudioDeviceModule::kAdaptiveBufferSize, 0)); 1612 EXPECT_EQ(0, audio_device_->PlayoutBuffer(&bufferType, &sizeMS)); 1613 #endif 1614 } 1615 1616 TEST_F(AudioDeviceAPITest, PlayoutDelay) { 1617 // NOTE: this API is better tested in a functional test 1618 uint16_t sizeMS(0); 1619 CheckInitialPlayoutStates(); 1620 // bulk tests 1621 EXPECT_EQ(0, audio_device_->PlayoutDelay(&sizeMS)); 1622 EXPECT_EQ(0, audio_device_->PlayoutDelay(&sizeMS)); 1623 } 1624 1625 TEST_F(AudioDeviceAPITest, RecordingDelay) { 1626 // NOTE: this API is better tested in a functional test 1627 uint16_t sizeMS(0); 1628 CheckInitialRecordingStates(); 1629 1630 // bulk tests 1631 EXPECT_EQ(0, audio_device_->RecordingDelay(&sizeMS)); 1632 EXPECT_EQ(0, audio_device_->RecordingDelay(&sizeMS)); 1633 } 1634 1635 TEST_F(AudioDeviceAPITest, CPULoad) { 1636 // NOTE: this API is better tested in a functional test 1637 uint16_t load(0); 1638 1639 // bulk tests 1640 #ifdef _WIN32 1641 EXPECT_EQ(0, audio_device_->CPULoad(&load)); 1642 EXPECT_EQ(0, load); 1643 #else 1644 EXPECT_EQ(-1, audio_device_->CPULoad(&load)); 1645 #endif 1646 } 1647 1648 // TODO(kjellander): Fix flakiness causing failures on Windows. 1649 // TODO(phoglund): Fix flakiness causing failures on Linux. 1650 #if !defined(_WIN32) && !defined(WEBRTC_LINUX) 1651 TEST_F(AudioDeviceAPITest, StartAndStopRawOutputFileRecording) { 1652 // NOTE: this API is better tested in a functional test 1653 CheckInitialPlayoutStates(); 1654 1655 // fail tests 1656 EXPECT_EQ(-1, audio_device_->StartRawOutputFileRecording(NULL)); 1657 1658 // bulk tests 1659 EXPECT_EQ(0, audio_device_->StartRawOutputFileRecording( 1660 GetFilename("raw_output_not_playing.pcm"))); 1661 EXPECT_EQ(0, audio_device_->StopRawOutputFileRecording()); 1662 EXPECT_EQ(0, audio_device_->SetPlayoutDevice( 1663 MACRO_DEFAULT_COMMUNICATION_DEVICE)); 1664 1665 // TODO(kjellander): Fix so these tests pass on Mac. 1666 #if !defined(WEBRTC_MAC) 1667 EXPECT_EQ(0, audio_device_->InitPlayout()); 1668 EXPECT_EQ(0, audio_device_->StartPlayout()); 1669 #endif 1670 1671 EXPECT_EQ(0, audio_device_->StartRawOutputFileRecording( 1672 GetFilename("raw_output_playing.pcm"))); 1673 SleepMs(100); 1674 EXPECT_EQ(0, audio_device_->StopRawOutputFileRecording()); 1675 EXPECT_EQ(0, audio_device_->StopPlayout()); 1676 EXPECT_EQ(0, audio_device_->StartRawOutputFileRecording( 1677 GetFilename("raw_output_not_playing.pcm"))); 1678 EXPECT_EQ(0, audio_device_->StopRawOutputFileRecording()); 1679 1680 // results after this test: 1681 // 1682 // - size of raw_output_not_playing.pcm shall be 0 1683 // - size of raw_output_playing.pcm shall be > 0 1684 } 1685 1686 TEST_F(AudioDeviceAPITest, StartAndStopRawInputFileRecording) { 1687 // NOTE: this API is better tested in a functional test 1688 CheckInitialRecordingStates(); 1689 EXPECT_FALSE(audio_device_->Playing()); 1690 1691 // fail tests 1692 EXPECT_EQ(-1, audio_device_->StartRawInputFileRecording(NULL)); 1693 1694 // bulk tests 1695 EXPECT_EQ(0, audio_device_->StartRawInputFileRecording( 1696 GetFilename("raw_input_not_recording.pcm"))); 1697 EXPECT_EQ(0, audio_device_->StopRawInputFileRecording()); 1698 EXPECT_EQ(0, audio_device_->SetRecordingDevice(MACRO_DEFAULT_DEVICE)); 1699 1700 // TODO(kjellander): Fix so these tests pass on Mac. 1701 #if !defined(WEBRTC_MAC) 1702 EXPECT_EQ(0, audio_device_->InitRecording()); 1703 EXPECT_EQ(0, audio_device_->StartRecording()); 1704 #endif 1705 EXPECT_EQ(0, audio_device_->StartRawInputFileRecording( 1706 GetFilename("raw_input_recording.pcm"))); 1707 SleepMs(100); 1708 EXPECT_EQ(0, audio_device_->StopRawInputFileRecording()); 1709 EXPECT_EQ(0, audio_device_->StopRecording()); 1710 EXPECT_EQ(0, audio_device_->StartRawInputFileRecording( 1711 GetFilename("raw_input_not_recording.pcm"))); 1712 EXPECT_EQ(0, audio_device_->StopRawInputFileRecording()); 1713 1714 // results after this test: 1715 // 1716 // - size of raw_input_not_recording.pcm shall be 0 1717 // - size of raw_input_not_recording.pcm shall be > 0 1718 } 1719 #endif // !WIN32 && !WEBRTC_LINUX 1720 1721 TEST_F(AudioDeviceAPITest, RecordingSampleRate) { 1722 uint32_t sampleRate(0); 1723 1724 // bulk tests 1725 EXPECT_EQ(0, audio_device_->RecordingSampleRate(&sampleRate)); 1726 #if defined(_WIN32) && !defined(WEBRTC_WINDOWS_CORE_AUDIO_BUILD) 1727 EXPECT_EQ(48000, sampleRate); 1728 #elif defined(ANDROID) 1729 TEST_LOG("Recording sample rate is %u\n\n", sampleRate); 1730 EXPECT_TRUE((sampleRate == 44000) || (sampleRate == 16000)); 1731 #elif defined(WEBRTC_IOS) 1732 TEST_LOG("Recording sample rate is %u\n\n", sampleRate); 1733 EXPECT_TRUE((sampleRate == 44000) || (sampleRate == 16000) || 1734 (sampleRate == 8000)); 1735 #endif 1736 1737 // @TODO(xians) - add tests for all platforms here... 1738 } 1739 1740 TEST_F(AudioDeviceAPITest, PlayoutSampleRate) { 1741 uint32_t sampleRate(0); 1742 1743 // bulk tests 1744 EXPECT_EQ(0, audio_device_->PlayoutSampleRate(&sampleRate)); 1745 #if defined(_WIN32) && !defined(WEBRTC_WINDOWS_CORE_AUDIO_BUILD) 1746 EXPECT_EQ(48000, sampleRate); 1747 #elif defined(ANDROID) 1748 TEST_LOG("Playout sample rate is %u\n\n", sampleRate); 1749 EXPECT_TRUE((sampleRate == 44000) || (sampleRate == 16000)); 1750 #elif defined(WEBRTC_IOS) 1751 TEST_LOG("Playout sample rate is %u\n\n", sampleRate); 1752 EXPECT_TRUE((sampleRate == 44000) || (sampleRate == 16000) || 1753 (sampleRate == 8000)); 1754 #endif 1755 } 1756 1757 TEST_F(AudioDeviceAPITest, ResetAudioDevice) { 1758 CheckInitialPlayoutStates(); 1759 CheckInitialRecordingStates(); 1760 EXPECT_EQ(0, audio_device_->SetPlayoutDevice(MACRO_DEFAULT_DEVICE)); 1761 EXPECT_EQ(0, audio_device_->SetRecordingDevice(MACRO_DEFAULT_DEVICE)); 1762 1763 #if defined(WEBRTC_IOS) 1764 // Not playing or recording, should just return 0 1765 EXPECT_EQ(0, audio_device_->ResetAudioDevice()); 1766 1767 EXPECT_EQ(0, audio_device_->InitRecording()); 1768 EXPECT_EQ(0, audio_device_->StartRecording()); 1769 EXPECT_EQ(0, audio_device_->InitPlayout()); 1770 EXPECT_EQ(0, audio_device_->StartPlayout()); 1771 for (int l=0; l<20; ++l) 1772 { 1773 TEST_LOG("Resetting sound device several time with pause %d ms\n", l); 1774 EXPECT_EQ(0, audio_device_->ResetAudioDevice()); 1775 SleepMs(l); 1776 } 1777 #else 1778 // Fail tests 1779 EXPECT_EQ(-1, audio_device_->ResetAudioDevice()); 1780 1781 // TODO(kjellander): Fix so these tests pass on Mac. 1782 #if !defined(WEBRTC_MAC) 1783 EXPECT_EQ(0, audio_device_->InitRecording()); 1784 EXPECT_EQ(0, audio_device_->StartRecording()); 1785 EXPECT_EQ(0, audio_device_->InitPlayout()); 1786 EXPECT_EQ(0, audio_device_->StartPlayout()); 1787 #endif 1788 EXPECT_EQ(-1, audio_device_->ResetAudioDevice()); 1789 #endif 1790 EXPECT_EQ(0, audio_device_->StopRecording()); 1791 EXPECT_EQ(0, audio_device_->StopPlayout()); 1792 } 1793 1794 TEST_F(AudioDeviceAPITest, SetPlayoutSpeaker) { 1795 CheckInitialPlayoutStates(); 1796 EXPECT_EQ(0, audio_device_->SetPlayoutDevice(MACRO_DEFAULT_DEVICE)); 1797 1798 bool loudspeakerOn(false); 1799 #if defined(WEBRTC_IOS) 1800 // Not playing or recording, should just return a success 1801 EXPECT_EQ(0, audio_device_->SetLoudspeakerStatus(true)); 1802 EXPECT_EQ(0, audio_device_->GetLoudspeakerStatus(&loudspeakerOn)); 1803 EXPECT_TRUE(loudspeakerOn); 1804 EXPECT_EQ(0, audio_device_->SetLoudspeakerStatus(false)); 1805 EXPECT_EQ(0, audio_device_->GetLoudspeakerStatus(&loudspeakerOn)); 1806 EXPECT_FALSE(loudspeakerOn); 1807 1808 EXPECT_EQ(0, audio_device_->InitPlayout()); 1809 EXPECT_EQ(0, audio_device_->StartPlayout()); 1810 EXPECT_EQ(0, audio_device_->SetLoudspeakerStatus(true)); 1811 EXPECT_EQ(0, audio_device_->GetLoudspeakerStatus(&loudspeakerOn)); 1812 EXPECT_TRUE(loudspeakerOn); 1813 EXPECT_EQ(0, audio_device_->SetLoudspeakerStatus(false)); 1814 EXPECT_EQ(0, audio_device_->GetLoudspeakerStatus(&loudspeakerOn)); 1815 EXPECT_FALSE(loudspeakerOn); 1816 1817 #else 1818 // Fail tests 1819 EXPECT_EQ(-1, audio_device_->SetLoudspeakerStatus(true)); 1820 EXPECT_EQ(-1, audio_device_->SetLoudspeakerStatus(false)); 1821 EXPECT_EQ(-1, audio_device_->SetLoudspeakerStatus(true)); 1822 EXPECT_EQ(-1, audio_device_->SetLoudspeakerStatus(false)); 1823 1824 // TODO(kjellander): Fix so these tests pass on Mac. 1825 #if !defined(WEBRTC_MAC) 1826 EXPECT_EQ(0, audio_device_->InitPlayout()); 1827 EXPECT_EQ(0, audio_device_->StartPlayout()); 1828 #endif 1829 1830 EXPECT_EQ(-1, audio_device_->GetLoudspeakerStatus(&loudspeakerOn)); 1831 #endif 1832 EXPECT_EQ(0, audio_device_->StopPlayout()); 1833 } 1834
