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 <assert.h> 12 13 #include "webrtc/modules/audio_device/audio_device_config.h" 14 #include "webrtc/modules/audio_device/audio_device_utility.h" 15 #include "webrtc/modules/audio_device/linux/audio_device_pulse_linux.h" 16 17 #include "webrtc/system_wrappers/interface/event_wrapper.h" 18 #include "webrtc/system_wrappers/interface/thread_wrapper.h" 19 #include "webrtc/system_wrappers/interface/trace.h" 20 21 webrtc_adm_linux_pulse::PulseAudioSymbolTable PaSymbolTable; 22 23 // Accesses Pulse functions through our late-binding symbol table instead of 24 // directly. This way we don't have to link to libpulse, which means our binary 25 // will work on systems that don't have it. 26 #define LATE(sym) \ 27 LATESYM_GET(webrtc_adm_linux_pulse::PulseAudioSymbolTable, &PaSymbolTable, sym) 28 29 namespace webrtc 30 { 31 32 // ============================================================================ 33 // Static Methods 34 // ============================================================================ 35 36 AudioDeviceLinuxPulse::AudioDeviceLinuxPulse(const int32_t id) : 37 _ptrAudioBuffer(NULL), 38 _critSect(*CriticalSectionWrapper::CreateCriticalSection()), 39 _timeEventRec(*EventWrapper::Create()), 40 _timeEventPlay(*EventWrapper::Create()), 41 _recStartEvent(*EventWrapper::Create()), 42 _playStartEvent(*EventWrapper::Create()), 43 _ptrThreadPlay(NULL), 44 _ptrThreadRec(NULL), 45 _recThreadID(0), 46 _playThreadID(0), 47 _id(id), 48 _mixerManager(id), 49 _inputDeviceIndex(0), 50 _outputDeviceIndex(0), 51 _inputDeviceIsSpecified(false), 52 _outputDeviceIsSpecified(false), 53 sample_rate_hz_(0), 54 _recChannels(1), 55 _playChannels(1), 56 _playBufType(AudioDeviceModule::kFixedBufferSize), 57 _initialized(false), 58 _recording(false), 59 _playing(false), 60 _recIsInitialized(false), 61 _playIsInitialized(false), 62 _startRec(false), 63 _stopRec(false), 64 _startPlay(false), 65 _stopPlay(false), 66 _AGC(false), 67 update_speaker_volume_at_startup_(false), 68 _playBufDelayFixed(20), 69 _sndCardPlayDelay(0), 70 _sndCardRecDelay(0), 71 _writeErrors(0), 72 _playWarning(0), 73 _playError(0), 74 _recWarning(0), 75 _recError(0), 76 _deviceIndex(-1), 77 _numPlayDevices(0), 78 _numRecDevices(0), 79 _playDeviceName(NULL), 80 _recDeviceName(NULL), 81 _playDisplayDeviceName(NULL), 82 _recDisplayDeviceName(NULL), 83 _playBuffer(NULL), 84 _playbackBufferSize(0), 85 _playbackBufferUnused(0), 86 _tempBufferSpace(0), 87 _recBuffer(NULL), 88 _recordBufferSize(0), 89 _recordBufferUsed(0), 90 _tempSampleData(NULL), 91 _tempSampleDataSize(0), 92 _configuredLatencyPlay(0), 93 _configuredLatencyRec(0), 94 _paDeviceIndex(-1), 95 _paStateChanged(false), 96 _paMainloop(NULL), 97 _paMainloopApi(NULL), 98 _paContext(NULL), 99 _recStream(NULL), 100 _playStream(NULL), 101 _recStreamFlags(0), 102 _playStreamFlags(0) 103 { 104 WEBRTC_TRACE(kTraceMemory, kTraceAudioDevice, id, 105 "%s created", __FUNCTION__); 106 107 memset(_paServerVersion, 0, sizeof(_paServerVersion)); 108 memset(&_playBufferAttr, 0, sizeof(_playBufferAttr)); 109 memset(&_recBufferAttr, 0, sizeof(_recBufferAttr)); 110 memset(_oldKeyState, 0, sizeof(_oldKeyState)); 111 } 112 113 AudioDeviceLinuxPulse::~AudioDeviceLinuxPulse() 114 { 115 WEBRTC_TRACE(kTraceMemory, kTraceAudioDevice, _id, 116 "%s destroyed", __FUNCTION__); 117 118 Terminate(); 119 120 if (_recBuffer) 121 { 122 delete [] _recBuffer; 123 _recBuffer = NULL; 124 } 125 if (_playBuffer) 126 { 127 delete [] _playBuffer; 128 _playBuffer = NULL; 129 } 130 if (_playDeviceName) 131 { 132 delete [] _playDeviceName; 133 _playDeviceName = NULL; 134 } 135 if (_recDeviceName) 136 { 137 delete [] _recDeviceName; 138 _recDeviceName = NULL; 139 } 140 141 delete &_recStartEvent; 142 delete &_playStartEvent; 143 delete &_timeEventRec; 144 delete &_timeEventPlay; 145 delete &_critSect; 146 } 147 148 void AudioDeviceLinuxPulse::AttachAudioBuffer(AudioDeviceBuffer* audioBuffer) 149 { 150 151 CriticalSectionScoped lock(&_critSect); 152 153 _ptrAudioBuffer = audioBuffer; 154 155 // Inform the AudioBuffer about default settings for this implementation. 156 // Set all values to zero here since the actual settings will be done by 157 // InitPlayout and InitRecording later. 158 _ptrAudioBuffer->SetRecordingSampleRate(0); 159 _ptrAudioBuffer->SetPlayoutSampleRate(0); 160 _ptrAudioBuffer->SetRecordingChannels(0); 161 _ptrAudioBuffer->SetPlayoutChannels(0); 162 } 163 164 // ---------------------------------------------------------------------------- 165 // ActiveAudioLayer 166 // ---------------------------------------------------------------------------- 167 168 int32_t AudioDeviceLinuxPulse::ActiveAudioLayer( 169 AudioDeviceModule::AudioLayer& audioLayer) const 170 { 171 audioLayer = AudioDeviceModule::kLinuxPulseAudio; 172 return 0; 173 } 174 175 int32_t AudioDeviceLinuxPulse::Init() 176 { 177 178 CriticalSectionScoped lock(&_critSect); 179 180 if (_initialized) 181 { 182 return 0; 183 } 184 185 // Initialize PulseAudio 186 if (InitPulseAudio() < 0) 187 { 188 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, 189 " failed to initialize PulseAudio"); 190 191 if (TerminatePulseAudio() < 0) 192 { 193 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, 194 " failed to terminate PulseAudio"); 195 } 196 197 return -1; 198 } 199 200 _playWarning = 0; 201 _playError = 0; 202 _recWarning = 0; 203 _recError = 0; 204 205 //Get X display handle for typing detection 206 _XDisplay = XOpenDisplay(NULL); 207 if (!_XDisplay) 208 { 209 WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, 210 " failed to open X display, typing detection will not work"); 211 } 212 213 // RECORDING 214 const char* threadName = "webrtc_audio_module_rec_thread"; 215 _ptrThreadRec = ThreadWrapper::CreateThread(RecThreadFunc, this, 216 kRealtimePriority, threadName); 217 if (_ptrThreadRec == NULL) 218 { 219 WEBRTC_TRACE(kTraceCritical, kTraceAudioDevice, _id, 220 " failed to create the rec audio thread"); 221 return -1; 222 } 223 224 unsigned int threadID(0); 225 if (!_ptrThreadRec->Start(threadID)) 226 { 227 WEBRTC_TRACE(kTraceCritical, kTraceAudioDevice, _id, 228 " failed to start the rec audio thread"); 229 230 delete _ptrThreadRec; 231 _ptrThreadRec = NULL; 232 return -1; 233 } 234 _recThreadID = threadID; 235 236 // PLAYOUT 237 threadName = "webrtc_audio_module_play_thread"; 238 _ptrThreadPlay = ThreadWrapper::CreateThread(PlayThreadFunc, this, 239 kRealtimePriority, threadName); 240 if (_ptrThreadPlay == NULL) 241 { 242 WEBRTC_TRACE(kTraceCritical, kTraceAudioDevice, _id, 243 " failed to create the play audio thread"); 244 return -1; 245 } 246 247 threadID = 0; 248 if (!_ptrThreadPlay->Start(threadID)) 249 { 250 WEBRTC_TRACE(kTraceCritical, kTraceAudioDevice, _id, 251 " failed to start the play audio thread"); 252 253 delete _ptrThreadPlay; 254 _ptrThreadPlay = NULL; 255 return -1; 256 } 257 _playThreadID = threadID; 258 259 _initialized = true; 260 261 return 0; 262 } 263 264 int32_t AudioDeviceLinuxPulse::Terminate() 265 { 266 267 if (!_initialized) 268 { 269 return 0; 270 } 271 272 Lock(); 273 274 _mixerManager.Close(); 275 276 // RECORDING 277 if (_ptrThreadRec) 278 { 279 ThreadWrapper* tmpThread = _ptrThreadRec; 280 _ptrThreadRec = NULL; 281 UnLock(); 282 283 tmpThread->SetNotAlive(); 284 _timeEventRec.Set(); 285 if (tmpThread->Stop()) 286 { 287 delete tmpThread; 288 } else 289 { 290 WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, 291 " failed to close down the rec audio thread"); 292 } 293 // Lock again since we need to protect _ptrThreadPlay. 294 Lock(); 295 } 296 297 // PLAYOUT 298 if (_ptrThreadPlay) 299 { 300 ThreadWrapper* tmpThread = _ptrThreadPlay; 301 _ptrThreadPlay = NULL; 302 _critSect.Leave(); 303 304 tmpThread->SetNotAlive(); 305 _timeEventPlay.Set(); 306 if (tmpThread->Stop()) 307 { 308 delete tmpThread; 309 } else 310 { 311 WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, 312 " failed to close down the play audio thread"); 313 } 314 } else { 315 UnLock(); 316 } 317 318 // Terminate PulseAudio 319 if (TerminatePulseAudio() < 0) 320 { 321 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, 322 " failed to terminate PulseAudio"); 323 return -1; 324 } 325 326 if (_XDisplay) 327 { 328 XCloseDisplay(_XDisplay); 329 _XDisplay = NULL; 330 } 331 332 _initialized = false; 333 _outputDeviceIsSpecified = false; 334 _inputDeviceIsSpecified = false; 335 336 return 0; 337 } 338 339 bool AudioDeviceLinuxPulse::Initialized() const 340 { 341 return (_initialized); 342 } 343 344 int32_t AudioDeviceLinuxPulse::InitSpeaker() 345 { 346 347 CriticalSectionScoped lock(&_critSect); 348 349 if (_playing) 350 { 351 return -1; 352 } 353 354 if (!_outputDeviceIsSpecified) 355 { 356 return -1; 357 } 358 359 // check if default device 360 if (_outputDeviceIndex == 0) 361 { 362 uint16_t deviceIndex = 0; 363 GetDefaultDeviceInfo(false, NULL, deviceIndex); 364 _paDeviceIndex = deviceIndex; 365 } else 366 { 367 // get the PA device index from 368 // the callback 369 _deviceIndex = _outputDeviceIndex; 370 371 // get playout devices 372 PlayoutDevices(); 373 } 374 375 // the callback has now set the _paDeviceIndex to 376 // the PulseAudio index of the device 377 if (_mixerManager.OpenSpeaker(_paDeviceIndex) == -1) 378 { 379 return -1; 380 } 381 382 // clear _deviceIndex 383 _deviceIndex = -1; 384 _paDeviceIndex = -1; 385 386 return 0; 387 } 388 389 int32_t AudioDeviceLinuxPulse::InitMicrophone() 390 { 391 392 CriticalSectionScoped lock(&_critSect); 393 394 if (_recording) 395 { 396 return -1; 397 } 398 399 if (!_inputDeviceIsSpecified) 400 { 401 return -1; 402 } 403 404 // Check if default device 405 if (_inputDeviceIndex == 0) 406 { 407 uint16_t deviceIndex = 0; 408 GetDefaultDeviceInfo(true, NULL, deviceIndex); 409 _paDeviceIndex = deviceIndex; 410 } else 411 { 412 // Get the PA device index from 413 // the callback 414 _deviceIndex = _inputDeviceIndex; 415 416 // get recording devices 417 RecordingDevices(); 418 } 419 420 // The callback has now set the _paDeviceIndex to 421 // the PulseAudio index of the device 422 if (_mixerManager.OpenMicrophone(_paDeviceIndex) == -1) 423 { 424 return -1; 425 } 426 427 // Clear _deviceIndex 428 _deviceIndex = -1; 429 _paDeviceIndex = -1; 430 431 return 0; 432 } 433 434 bool AudioDeviceLinuxPulse::SpeakerIsInitialized() const 435 { 436 return (_mixerManager.SpeakerIsInitialized()); 437 } 438 439 bool AudioDeviceLinuxPulse::MicrophoneIsInitialized() const 440 { 441 return (_mixerManager.MicrophoneIsInitialized()); 442 } 443 444 int32_t AudioDeviceLinuxPulse::SpeakerVolumeIsAvailable(bool& available) 445 { 446 447 bool wasInitialized = _mixerManager.SpeakerIsInitialized(); 448 449 // Make an attempt to open up the 450 // output mixer corresponding to the currently selected output device. 451 if (!wasInitialized && InitSpeaker() == -1) 452 { 453 // If we end up here it means that the selected speaker has no volume 454 // control. 455 available = false; 456 return 0; 457 } 458 459 // Given that InitSpeaker was successful, we know that a volume control exists 460 available = true; 461 462 // Close the initialized output mixer 463 if (!wasInitialized) 464 { 465 _mixerManager.CloseSpeaker(); 466 } 467 468 return 0; 469 } 470 471 int32_t AudioDeviceLinuxPulse::SetSpeakerVolume(uint32_t volume) 472 { 473 if (!_playing) { 474 // Only update the volume if it's been set while we weren't playing. 475 update_speaker_volume_at_startup_ = true; 476 } 477 return (_mixerManager.SetSpeakerVolume(volume)); 478 } 479 480 int32_t AudioDeviceLinuxPulse::SpeakerVolume(uint32_t& volume) const 481 { 482 483 uint32_t level(0); 484 485 if (_mixerManager.SpeakerVolume(level) == -1) 486 { 487 return -1; 488 } 489 490 volume = level; 491 492 return 0; 493 } 494 495 int32_t AudioDeviceLinuxPulse::SetWaveOutVolume( 496 uint16_t volumeLeft, 497 uint16_t volumeRight) 498 { 499 500 WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, 501 " API call not supported on this platform"); 502 return -1; 503 } 504 505 int32_t AudioDeviceLinuxPulse::WaveOutVolume( 506 uint16_t& /*volumeLeft*/, 507 uint16_t& /*volumeRight*/) const 508 { 509 510 WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, 511 " API call not supported on this platform"); 512 return -1; 513 } 514 515 int32_t AudioDeviceLinuxPulse::MaxSpeakerVolume( 516 uint32_t& maxVolume) const 517 { 518 519 uint32_t maxVol(0); 520 521 if (_mixerManager.MaxSpeakerVolume(maxVol) == -1) 522 { 523 return -1; 524 } 525 526 maxVolume = maxVol; 527 528 return 0; 529 } 530 531 int32_t AudioDeviceLinuxPulse::MinSpeakerVolume( 532 uint32_t& minVolume) const 533 { 534 535 uint32_t minVol(0); 536 537 if (_mixerManager.MinSpeakerVolume(minVol) == -1) 538 { 539 return -1; 540 } 541 542 minVolume = minVol; 543 544 return 0; 545 } 546 547 int32_t AudioDeviceLinuxPulse::SpeakerVolumeStepSize( 548 uint16_t& stepSize) const 549 { 550 551 uint16_t delta(0); 552 553 if (_mixerManager.SpeakerVolumeStepSize(delta) == -1) 554 { 555 return -1; 556 } 557 558 stepSize = delta; 559 560 return 0; 561 } 562 563 int32_t AudioDeviceLinuxPulse::SpeakerMuteIsAvailable(bool& available) 564 { 565 566 bool isAvailable(false); 567 bool wasInitialized = _mixerManager.SpeakerIsInitialized(); 568 569 // Make an attempt to open up the 570 // output mixer corresponding to the currently selected output device. 571 // 572 if (!wasInitialized && InitSpeaker() == -1) 573 { 574 // If we end up here it means that the selected speaker has no volume 575 // control, hence it is safe to state that there is no mute control 576 // already at this stage. 577 available = false; 578 return 0; 579 } 580 581 // Check if the selected speaker has a mute control 582 _mixerManager.SpeakerMuteIsAvailable(isAvailable); 583 584 available = isAvailable; 585 586 // Close the initialized output mixer 587 if (!wasInitialized) 588 { 589 _mixerManager.CloseSpeaker(); 590 } 591 592 return 0; 593 } 594 595 int32_t AudioDeviceLinuxPulse::SetSpeakerMute(bool enable) 596 { 597 598 return (_mixerManager.SetSpeakerMute(enable)); 599 } 600 601 int32_t AudioDeviceLinuxPulse::SpeakerMute(bool& enabled) const 602 { 603 604 bool muted(0); 605 if (_mixerManager.SpeakerMute(muted) == -1) 606 { 607 return -1; 608 } 609 610 enabled = muted; 611 return 0; 612 } 613 614 int32_t AudioDeviceLinuxPulse::MicrophoneMuteIsAvailable(bool& available) 615 { 616 617 bool isAvailable(false); 618 bool wasInitialized = _mixerManager.MicrophoneIsInitialized(); 619 620 // Make an attempt to open up the 621 // input mixer corresponding to the currently selected input device. 622 // 623 if (!wasInitialized && InitMicrophone() == -1) 624 { 625 // If we end up here it means that the selected microphone has no volume 626 // control, hence it is safe to state that there is no boost control 627 // already at this stage. 628 available = false; 629 return 0; 630 } 631 632 // Check if the selected microphone has a mute control 633 // 634 _mixerManager.MicrophoneMuteIsAvailable(isAvailable); 635 available = isAvailable; 636 637 // Close the initialized input mixer 638 // 639 if (!wasInitialized) 640 { 641 _mixerManager.CloseMicrophone(); 642 } 643 644 return 0; 645 } 646 647 int32_t AudioDeviceLinuxPulse::SetMicrophoneMute(bool enable) 648 { 649 650 return (_mixerManager.SetMicrophoneMute(enable)); 651 } 652 653 int32_t AudioDeviceLinuxPulse::MicrophoneMute(bool& enabled) const 654 { 655 656 bool muted(0); 657 if (_mixerManager.MicrophoneMute(muted) == -1) 658 { 659 return -1; 660 } 661 662 enabled = muted; 663 return 0; 664 } 665 666 int32_t AudioDeviceLinuxPulse::MicrophoneBoostIsAvailable(bool& available) 667 { 668 669 bool isAvailable(false); 670 bool wasInitialized = _mixerManager.MicrophoneIsInitialized(); 671 672 // Enumerate all avaliable microphone and make an attempt to open up the 673 // input mixer corresponding to the currently selected input device. 674 // 675 if (!wasInitialized && InitMicrophone() == -1) 676 { 677 // If we end up here it means that the selected microphone has no volume 678 // control, hence it is safe to state that there is no boost control 679 // already at this stage. 680 available = false; 681 return 0; 682 } 683 684 // Check if the selected microphone has a boost control 685 _mixerManager.MicrophoneBoostIsAvailable(isAvailable); 686 available = isAvailable; 687 688 // Close the initialized input mixer 689 if (!wasInitialized) 690 { 691 _mixerManager.CloseMicrophone(); 692 } 693 694 return 0; 695 } 696 697 int32_t AudioDeviceLinuxPulse::SetMicrophoneBoost(bool enable) 698 { 699 700 return (_mixerManager.SetMicrophoneBoost(enable)); 701 } 702 703 int32_t AudioDeviceLinuxPulse::MicrophoneBoost(bool& enabled) const 704 { 705 706 bool onOff(0); 707 708 if (_mixerManager.MicrophoneBoost(onOff) == -1) 709 { 710 return -1; 711 } 712 713 enabled = onOff; 714 715 return 0; 716 } 717 718 int32_t AudioDeviceLinuxPulse::StereoRecordingIsAvailable(bool& available) 719 { 720 721 if (_recChannels == 2 && _recording) { 722 available = true; 723 return 0; 724 } 725 726 available = false; 727 bool wasInitialized = _mixerManager.MicrophoneIsInitialized(); 728 int error = 0; 729 730 if (!wasInitialized && InitMicrophone() == -1) 731 { 732 // Cannot open the specified device 733 available = false; 734 return 0; 735 } 736 737 // Check if the selected microphone can record stereo. 738 bool isAvailable(false); 739 error = _mixerManager.StereoRecordingIsAvailable(isAvailable); 740 if (!error) 741 available = isAvailable; 742 743 // Close the initialized input mixer 744 if (!wasInitialized) 745 { 746 _mixerManager.CloseMicrophone(); 747 } 748 749 return error; 750 } 751 752 int32_t AudioDeviceLinuxPulse::SetStereoRecording(bool enable) 753 { 754 755 if (enable) 756 _recChannels = 2; 757 else 758 _recChannels = 1; 759 760 return 0; 761 } 762 763 int32_t AudioDeviceLinuxPulse::StereoRecording(bool& enabled) const 764 { 765 766 if (_recChannels == 2) 767 enabled = true; 768 else 769 enabled = false; 770 771 return 0; 772 } 773 774 int32_t AudioDeviceLinuxPulse::StereoPlayoutIsAvailable(bool& available) 775 { 776 777 if (_playChannels == 2 && _playing) { 778 available = true; 779 return 0; 780 } 781 782 available = false; 783 bool wasInitialized = _mixerManager.SpeakerIsInitialized(); 784 int error = 0; 785 786 if (!wasInitialized && InitSpeaker() == -1) 787 { 788 // Cannot open the specified device. 789 return -1; 790 } 791 792 // Check if the selected speaker can play stereo. 793 bool isAvailable(false); 794 error = _mixerManager.StereoPlayoutIsAvailable(isAvailable); 795 if (!error) 796 available = isAvailable; 797 798 // Close the initialized input mixer 799 if (!wasInitialized) 800 { 801 _mixerManager.CloseSpeaker(); 802 } 803 804 return error; 805 } 806 807 int32_t AudioDeviceLinuxPulse::SetStereoPlayout(bool enable) 808 { 809 810 if (enable) 811 _playChannels = 2; 812 else 813 _playChannels = 1; 814 815 return 0; 816 } 817 818 int32_t AudioDeviceLinuxPulse::StereoPlayout(bool& enabled) const 819 { 820 821 if (_playChannels == 2) 822 enabled = true; 823 else 824 enabled = false; 825 826 return 0; 827 } 828 829 int32_t AudioDeviceLinuxPulse::SetAGC(bool enable) 830 { 831 832 _AGC = enable; 833 834 return 0; 835 } 836 837 bool AudioDeviceLinuxPulse::AGC() const 838 { 839 840 return _AGC; 841 } 842 843 int32_t AudioDeviceLinuxPulse::MicrophoneVolumeIsAvailable( 844 bool& available) 845 { 846 847 bool wasInitialized = _mixerManager.MicrophoneIsInitialized(); 848 849 // Make an attempt to open up the 850 // input mixer corresponding to the currently selected output device. 851 if (!wasInitialized && InitMicrophone() == -1) 852 { 853 // If we end up here it means that the selected microphone has no volume 854 // control. 855 available = false; 856 return 0; 857 } 858 859 // Given that InitMicrophone was successful, we know that a volume control 860 // exists 861 available = true; 862 863 // Close the initialized input mixer 864 if (!wasInitialized) 865 { 866 _mixerManager.CloseMicrophone(); 867 } 868 869 return 0; 870 } 871 872 int32_t AudioDeviceLinuxPulse::SetMicrophoneVolume(uint32_t volume) 873 { 874 875 return (_mixerManager.SetMicrophoneVolume(volume)); 876 } 877 878 int32_t AudioDeviceLinuxPulse::MicrophoneVolume( 879 uint32_t& volume) const 880 { 881 882 uint32_t level(0); 883 884 if (_mixerManager.MicrophoneVolume(level) == -1) 885 { 886 WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, 887 " failed to retrive current microphone level"); 888 return -1; 889 } 890 891 volume = level; 892 893 return 0; 894 } 895 896 int32_t AudioDeviceLinuxPulse::MaxMicrophoneVolume( 897 uint32_t& maxVolume) const 898 { 899 900 uint32_t maxVol(0); 901 902 if (_mixerManager.MaxMicrophoneVolume(maxVol) == -1) 903 { 904 return -1; 905 } 906 907 maxVolume = maxVol; 908 909 return 0; 910 } 911 912 int32_t AudioDeviceLinuxPulse::MinMicrophoneVolume( 913 uint32_t& minVolume) const 914 { 915 916 uint32_t minVol(0); 917 918 if (_mixerManager.MinMicrophoneVolume(minVol) == -1) 919 { 920 return -1; 921 } 922 923 minVolume = minVol; 924 925 return 0; 926 } 927 928 int32_t AudioDeviceLinuxPulse::MicrophoneVolumeStepSize( 929 uint16_t& stepSize) const 930 { 931 932 uint16_t delta(0); 933 934 if (_mixerManager.MicrophoneVolumeStepSize(delta) == -1) 935 { 936 return -1; 937 } 938 939 stepSize = delta; 940 941 return 0; 942 } 943 944 int16_t AudioDeviceLinuxPulse::PlayoutDevices() 945 { 946 947 PaLock(); 948 949 pa_operation* paOperation = NULL; 950 _numPlayDevices = 1; // init to 1 to account for "default" 951 952 // get the whole list of devices and update _numPlayDevices 953 paOperation = LATE(pa_context_get_sink_info_list)(_paContext, 954 PaSinkInfoCallback, 955 this); 956 957 WaitForOperationCompletion(paOperation); 958 959 PaUnLock(); 960 961 return _numPlayDevices; 962 } 963 964 int32_t AudioDeviceLinuxPulse::SetPlayoutDevice(uint16_t index) 965 { 966 967 if (_playIsInitialized) 968 { 969 return -1; 970 } 971 972 const uint16_t nDevices = PlayoutDevices(); 973 974 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, 975 " number of availiable output devices is %u", nDevices); 976 977 if (index > (nDevices - 1)) 978 { 979 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, 980 " device index is out of range [0,%u]", (nDevices - 1)); 981 return -1; 982 } 983 984 _outputDeviceIndex = index; 985 _outputDeviceIsSpecified = true; 986 987 return 0; 988 } 989 990 int32_t AudioDeviceLinuxPulse::SetPlayoutDevice( 991 AudioDeviceModule::WindowsDeviceType /*device*/) 992 { 993 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, 994 "WindowsDeviceType not supported"); 995 return -1; 996 } 997 998 int32_t AudioDeviceLinuxPulse::PlayoutDeviceName( 999 uint16_t index, 1000 char name[kAdmMaxDeviceNameSize], 1001 char guid[kAdmMaxGuidSize]) 1002 { 1003 1004 const uint16_t nDevices = PlayoutDevices(); 1005 1006 if ((index > (nDevices - 1)) || (name == NULL)) 1007 { 1008 return -1; 1009 } 1010 1011 memset(name, 0, kAdmMaxDeviceNameSize); 1012 1013 if (guid != NULL) 1014 { 1015 memset(guid, 0, kAdmMaxGuidSize); 1016 } 1017 1018 // Check if default device 1019 if (index == 0) 1020 { 1021 uint16_t deviceIndex = 0; 1022 return GetDefaultDeviceInfo(false, name, deviceIndex); 1023 } 1024 1025 // Tell the callback that we want 1026 // The name for this device 1027 _playDisplayDeviceName = name; 1028 _deviceIndex = index; 1029 1030 // get playout devices 1031 PlayoutDevices(); 1032 1033 // clear device name and index 1034 _playDisplayDeviceName = NULL; 1035 _deviceIndex = -1; 1036 1037 return 0; 1038 } 1039 1040 int32_t AudioDeviceLinuxPulse::RecordingDeviceName( 1041 uint16_t index, 1042 char name[kAdmMaxDeviceNameSize], 1043 char guid[kAdmMaxGuidSize]) 1044 { 1045 1046 const uint16_t nDevices(RecordingDevices()); 1047 1048 if ((index > (nDevices - 1)) || (name == NULL)) 1049 { 1050 return -1; 1051 } 1052 1053 memset(name, 0, kAdmMaxDeviceNameSize); 1054 1055 if (guid != NULL) 1056 { 1057 memset(guid, 0, kAdmMaxGuidSize); 1058 } 1059 1060 // Check if default device 1061 if (index == 0) 1062 { 1063 uint16_t deviceIndex = 0; 1064 return GetDefaultDeviceInfo(true, name, deviceIndex); 1065 } 1066 1067 // Tell the callback that we want 1068 // the name for this device 1069 _recDisplayDeviceName = name; 1070 _deviceIndex = index; 1071 1072 // Get recording devices 1073 RecordingDevices(); 1074 1075 // Clear device name and index 1076 _recDisplayDeviceName = NULL; 1077 _deviceIndex = -1; 1078 1079 return 0; 1080 } 1081 1082 int16_t AudioDeviceLinuxPulse::RecordingDevices() 1083 { 1084 1085 PaLock(); 1086 1087 pa_operation* paOperation = NULL; 1088 _numRecDevices = 1; // Init to 1 to account for "default" 1089 1090 // Get the whole list of devices and update _numRecDevices 1091 paOperation = LATE(pa_context_get_source_info_list)(_paContext, 1092 PaSourceInfoCallback, 1093 this); 1094 1095 WaitForOperationCompletion(paOperation); 1096 1097 PaUnLock(); 1098 1099 return _numRecDevices; 1100 } 1101 1102 int32_t AudioDeviceLinuxPulse::SetRecordingDevice(uint16_t index) 1103 { 1104 1105 if (_recIsInitialized) 1106 { 1107 return -1; 1108 } 1109 1110 const uint16_t nDevices(RecordingDevices()); 1111 1112 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, 1113 " number of availiable input devices is %u", nDevices); 1114 1115 if (index > (nDevices - 1)) 1116 { 1117 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, 1118 " device index is out of range [0,%u]", (nDevices - 1)); 1119 return -1; 1120 } 1121 1122 _inputDeviceIndex = index; 1123 _inputDeviceIsSpecified = true; 1124 1125 return 0; 1126 } 1127 1128 int32_t AudioDeviceLinuxPulse::SetRecordingDevice( 1129 AudioDeviceModule::WindowsDeviceType /*device*/) 1130 { 1131 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, 1132 "WindowsDeviceType not supported"); 1133 return -1; 1134 } 1135 1136 int32_t AudioDeviceLinuxPulse::PlayoutIsAvailable(bool& available) 1137 { 1138 1139 available = false; 1140 1141 // Try to initialize the playout side 1142 int32_t res = InitPlayout(); 1143 1144 // Cancel effect of initialization 1145 StopPlayout(); 1146 1147 if (res != -1) 1148 { 1149 available = true; 1150 } 1151 1152 return res; 1153 } 1154 1155 int32_t AudioDeviceLinuxPulse::RecordingIsAvailable(bool& available) 1156 { 1157 1158 available = false; 1159 1160 // Try to initialize the playout side 1161 int32_t res = InitRecording(); 1162 1163 // Cancel effect of initialization 1164 StopRecording(); 1165 1166 if (res != -1) 1167 { 1168 available = true; 1169 } 1170 1171 return res; 1172 } 1173 1174 int32_t AudioDeviceLinuxPulse::InitPlayout() 1175 { 1176 1177 CriticalSectionScoped lock(&_critSect); 1178 1179 if (_playing) 1180 { 1181 return -1; 1182 } 1183 1184 if (!_outputDeviceIsSpecified) 1185 { 1186 return -1; 1187 } 1188 1189 if (_playIsInitialized) 1190 { 1191 return 0; 1192 } 1193 1194 // Initialize the speaker (devices might have been added or removed) 1195 if (InitSpeaker() == -1) 1196 { 1197 WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, 1198 " InitSpeaker() failed"); 1199 } 1200 1201 // Set the play sample specification 1202 pa_sample_spec playSampleSpec; 1203 playSampleSpec.channels = _playChannels; 1204 playSampleSpec.format = PA_SAMPLE_S16LE; 1205 playSampleSpec.rate = sample_rate_hz_; 1206 1207 // Create a new play stream 1208 _playStream = LATE(pa_stream_new)(_paContext, "playStream", 1209 &playSampleSpec, NULL); 1210 1211 if (!_playStream) 1212 { 1213 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, 1214 " failed to create play stream, err=%d", 1215 LATE(pa_context_errno)(_paContext)); 1216 return -1; 1217 } 1218 1219 // Provide the playStream to the mixer 1220 _mixerManager.SetPlayStream(_playStream); 1221 1222 if (_ptrAudioBuffer) 1223 { 1224 // Update audio buffer with the selected parameters 1225 _ptrAudioBuffer->SetPlayoutSampleRate(sample_rate_hz_); 1226 _ptrAudioBuffer->SetPlayoutChannels((uint8_t) _playChannels); 1227 } 1228 1229 WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice, _id, 1230 " stream state %d\n", LATE(pa_stream_get_state)(_playStream)); 1231 1232 // Set stream flags 1233 _playStreamFlags = (pa_stream_flags_t) (PA_STREAM_AUTO_TIMING_UPDATE 1234 | PA_STREAM_INTERPOLATE_TIMING); 1235 1236 if (_configuredLatencyPlay != WEBRTC_PA_NO_LATENCY_REQUIREMENTS) 1237 { 1238 // If configuring a specific latency then we want to specify 1239 // PA_STREAM_ADJUST_LATENCY to make the server adjust parameters 1240 // automatically to reach that target latency. However, that flag doesn't 1241 // exist in Ubuntu 8.04 and many people still use that, so we have to check 1242 // the protocol version of libpulse. 1243 if (LATE(pa_context_get_protocol_version)(_paContext) 1244 >= WEBRTC_PA_ADJUST_LATENCY_PROTOCOL_VERSION) 1245 { 1246 _playStreamFlags |= PA_STREAM_ADJUST_LATENCY; 1247 } 1248 1249 const pa_sample_spec *spec = 1250 LATE(pa_stream_get_sample_spec)(_playStream); 1251 if (!spec) 1252 { 1253 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, 1254 " pa_stream_get_sample_spec()"); 1255 return -1; 1256 } 1257 1258 size_t bytesPerSec = LATE(pa_bytes_per_second)(spec); 1259 uint32_t latency = bytesPerSec 1260 * WEBRTC_PA_PLAYBACK_LATENCY_MINIMUM_MSECS / WEBRTC_PA_MSECS_PER_SEC; 1261 1262 // Set the play buffer attributes 1263 _playBufferAttr.maxlength = latency; // num bytes stored in the buffer 1264 _playBufferAttr.tlength = latency; // target fill level of play buffer 1265 // minimum free num bytes before server request more data 1266 _playBufferAttr.minreq = latency / WEBRTC_PA_PLAYBACK_REQUEST_FACTOR; 1267 _playBufferAttr.prebuf = _playBufferAttr.tlength 1268 - _playBufferAttr.minreq; // prebuffer tlength before starting playout 1269 1270 _configuredLatencyPlay = latency; 1271 } 1272 1273 // num samples in bytes * num channels 1274 _playbackBufferSize = sample_rate_hz_ / 100 * 2 * _playChannels; 1275 _playbackBufferUnused = _playbackBufferSize; 1276 _playBuffer = new int8_t[_playbackBufferSize]; 1277 1278 // Enable underflow callback 1279 LATE(pa_stream_set_underflow_callback)(_playStream, 1280 PaStreamUnderflowCallback, this); 1281 1282 // Set the state callback function for the stream 1283 LATE(pa_stream_set_state_callback)(_playStream, PaStreamStateCallback, this); 1284 1285 // Mark playout side as initialized 1286 _playIsInitialized = true; 1287 _sndCardPlayDelay = 0; 1288 _sndCardRecDelay = 0; 1289 1290 return 0; 1291 } 1292 1293 int32_t AudioDeviceLinuxPulse::InitRecording() 1294 { 1295 1296 CriticalSectionScoped lock(&_critSect); 1297 1298 if (_recording) 1299 { 1300 return -1; 1301 } 1302 1303 if (!_inputDeviceIsSpecified) 1304 { 1305 return -1; 1306 } 1307 1308 if (_recIsInitialized) 1309 { 1310 return 0; 1311 } 1312 1313 // Initialize the microphone (devices might have been added or removed) 1314 if (InitMicrophone() == -1) 1315 { 1316 WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, 1317 " InitMicrophone() failed"); 1318 } 1319 1320 // Set the rec sample specification 1321 pa_sample_spec recSampleSpec; 1322 recSampleSpec.channels = _recChannels; 1323 recSampleSpec.format = PA_SAMPLE_S16LE; 1324 recSampleSpec.rate = sample_rate_hz_; 1325 1326 // Create a new rec stream 1327 _recStream = LATE(pa_stream_new)(_paContext, "recStream", &recSampleSpec, 1328 NULL); 1329 if (!_recStream) 1330 { 1331 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, 1332 " failed to create rec stream, err=%d", 1333 LATE(pa_context_errno)(_paContext)); 1334 return -1; 1335 } 1336 1337 // Provide the recStream to the mixer 1338 _mixerManager.SetRecStream(_recStream); 1339 1340 if (_ptrAudioBuffer) 1341 { 1342 // Update audio buffer with the selected parameters 1343 _ptrAudioBuffer->SetRecordingSampleRate(sample_rate_hz_); 1344 _ptrAudioBuffer->SetRecordingChannels((uint8_t) _recChannels); 1345 } 1346 1347 if (_configuredLatencyRec != WEBRTC_PA_NO_LATENCY_REQUIREMENTS) 1348 { 1349 _recStreamFlags = (pa_stream_flags_t) (PA_STREAM_AUTO_TIMING_UPDATE 1350 | PA_STREAM_INTERPOLATE_TIMING); 1351 1352 // If configuring a specific latency then we want to specify 1353 // PA_STREAM_ADJUST_LATENCY to make the server adjust parameters 1354 // automatically to reach that target latency. However, that flag doesn't 1355 // exist in Ubuntu 8.04 and many people still use that, so we have to check 1356 // the protocol version of libpulse. 1357 if (LATE(pa_context_get_protocol_version)(_paContext) 1358 >= WEBRTC_PA_ADJUST_LATENCY_PROTOCOL_VERSION) 1359 { 1360 _recStreamFlags |= PA_STREAM_ADJUST_LATENCY; 1361 } 1362 1363 const pa_sample_spec *spec = 1364 LATE(pa_stream_get_sample_spec)(_recStream); 1365 if (!spec) 1366 { 1367 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, 1368 " pa_stream_get_sample_spec(rec)"); 1369 return -1; 1370 } 1371 1372 size_t bytesPerSec = LATE(pa_bytes_per_second)(spec); 1373 uint32_t latency = bytesPerSec 1374 * WEBRTC_PA_LOW_CAPTURE_LATENCY_MSECS / WEBRTC_PA_MSECS_PER_SEC; 1375 1376 // Set the rec buffer attributes 1377 // Note: fragsize specifies a maximum transfer size, not a minimum, so 1378 // it is not possible to force a high latency setting, only a low one. 1379 _recBufferAttr.fragsize = latency; // size of fragment 1380 _recBufferAttr.maxlength = latency + bytesPerSec 1381 * WEBRTC_PA_CAPTURE_BUFFER_EXTRA_MSECS / WEBRTC_PA_MSECS_PER_SEC; 1382 1383 _configuredLatencyRec = latency; 1384 } 1385 1386 _recordBufferSize = sample_rate_hz_ / 100 * 2 * _recChannels; 1387 _recordBufferUsed = 0; 1388 _recBuffer = new int8_t[_recordBufferSize]; 1389 1390 // Enable overflow callback 1391 LATE(pa_stream_set_overflow_callback)(_recStream, PaStreamOverflowCallback, 1392 this); 1393 1394 // Set the state callback function for the stream 1395 LATE(pa_stream_set_state_callback)(_recStream, PaStreamStateCallback, this); 1396 1397 // Mark recording side as initialized 1398 _recIsInitialized = true; 1399 1400 return 0; 1401 } 1402 1403 int32_t AudioDeviceLinuxPulse::StartRecording() 1404 { 1405 1406 if (!_recIsInitialized) 1407 { 1408 return -1; 1409 } 1410 1411 if (_recording) 1412 { 1413 return 0; 1414 } 1415 1416 // set state to ensure that the recording starts from the audio thread 1417 _startRec = true; 1418 1419 // the audio thread will signal when recording has started 1420 _timeEventRec.Set(); 1421 if (kEventTimeout == _recStartEvent.Wait(10000)) 1422 { 1423 { 1424 CriticalSectionScoped lock(&_critSect); 1425 _startRec = false; 1426 } 1427 StopRecording(); 1428 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, 1429 " failed to activate recording"); 1430 return -1; 1431 } 1432 1433 { 1434 CriticalSectionScoped lock(&_critSect); 1435 if (_recording) 1436 { 1437 // the recording state is set by the audio thread after recording has started 1438 } else 1439 { 1440 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, 1441 " failed to activate recording"); 1442 return -1; 1443 } 1444 } 1445 1446 return 0; 1447 } 1448 1449 int32_t AudioDeviceLinuxPulse::StopRecording() 1450 { 1451 1452 CriticalSectionScoped lock(&_critSect); 1453 1454 if (!_recIsInitialized) 1455 { 1456 return 0; 1457 } 1458 1459 if (_recStream == NULL) 1460 { 1461 return -1; 1462 } 1463 1464 _recIsInitialized = false; 1465 _recording = false; 1466 1467 WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice, _id, 1468 " stopping recording"); 1469 1470 // Stop Recording 1471 PaLock(); 1472 1473 DisableReadCallback(); 1474 LATE(pa_stream_set_overflow_callback)(_recStream, NULL, NULL); 1475 1476 // Unset this here so that we don't get a TERMINATED callback 1477 LATE(pa_stream_set_state_callback)(_recStream, NULL, NULL); 1478 1479 if (LATE(pa_stream_get_state)(_recStream) != PA_STREAM_UNCONNECTED) 1480 { 1481 // Disconnect the stream 1482 if (LATE(pa_stream_disconnect)(_recStream) != PA_OK) 1483 { 1484 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, 1485 " failed to disconnect rec stream, err=%d\n", 1486 LATE(pa_context_errno)(_paContext)); 1487 PaUnLock(); 1488 return -1; 1489 } 1490 1491 WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice, _id, 1492 " disconnected recording"); 1493 } 1494 1495 LATE(pa_stream_unref)(_recStream); 1496 _recStream = NULL; 1497 1498 PaUnLock(); 1499 1500 // Provide the recStream to the mixer 1501 _mixerManager.SetRecStream(_recStream); 1502 1503 if (_recBuffer) 1504 { 1505 delete [] _recBuffer; 1506 _recBuffer = NULL; 1507 } 1508 1509 return 0; 1510 } 1511 1512 bool AudioDeviceLinuxPulse::RecordingIsInitialized() const 1513 { 1514 return (_recIsInitialized); 1515 } 1516 1517 bool AudioDeviceLinuxPulse::Recording() const 1518 { 1519 CriticalSectionScoped lock(&_critSect); 1520 return (_recording); 1521 } 1522 1523 bool AudioDeviceLinuxPulse::PlayoutIsInitialized() const 1524 { 1525 return (_playIsInitialized); 1526 } 1527 1528 int32_t AudioDeviceLinuxPulse::StartPlayout() 1529 { 1530 if (!_playIsInitialized) 1531 { 1532 return -1; 1533 } 1534 1535 if (_playing) 1536 { 1537 return 0; 1538 } 1539 1540 // set state to ensure that playout starts from the audio thread 1541 _startPlay = true; 1542 1543 // Both |_startPlay| and |_playing| needs protction since they are also 1544 // accessed on the playout thread. 1545 1546 // the audio thread will signal when playout has started 1547 _timeEventPlay.Set(); 1548 if (kEventTimeout == _playStartEvent.Wait(10000)) 1549 { 1550 { 1551 CriticalSectionScoped lock(&_critSect); 1552 _startPlay = false; 1553 } 1554 StopPlayout(); 1555 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, 1556 " failed to activate playout"); 1557 return -1; 1558 } 1559 1560 { 1561 CriticalSectionScoped lock(&_critSect); 1562 if (_playing) 1563 { 1564 // the playing state is set by the audio thread after playout has started 1565 } else 1566 { 1567 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, 1568 " failed to activate playing"); 1569 return -1; 1570 } 1571 } 1572 1573 return 0; 1574 } 1575 1576 int32_t AudioDeviceLinuxPulse::StopPlayout() 1577 { 1578 1579 CriticalSectionScoped lock(&_critSect); 1580 1581 if (!_playIsInitialized) 1582 { 1583 return 0; 1584 } 1585 1586 if (_playStream == NULL) 1587 { 1588 return -1; 1589 } 1590 1591 _playIsInitialized = false; 1592 _playing = false; 1593 _sndCardPlayDelay = 0; 1594 _sndCardRecDelay = 0; 1595 1596 WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice, _id, 1597 " stopping playback"); 1598 1599 // Stop Playout 1600 PaLock(); 1601 1602 DisableWriteCallback(); 1603 LATE(pa_stream_set_underflow_callback)(_playStream, NULL, NULL); 1604 1605 // Unset this here so that we don't get a TERMINATED callback 1606 LATE(pa_stream_set_state_callback)(_playStream, NULL, NULL); 1607 1608 if (LATE(pa_stream_get_state)(_playStream) != PA_STREAM_UNCONNECTED) 1609 { 1610 // Disconnect the stream 1611 if (LATE(pa_stream_disconnect)(_playStream) != PA_OK) 1612 { 1613 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, 1614 " failed to disconnect play stream, err=%d", 1615 LATE(pa_context_errno)(_paContext)); 1616 PaUnLock(); 1617 return -1; 1618 } 1619 1620 WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice, _id, 1621 " disconnected playback"); 1622 } 1623 1624 LATE(pa_stream_unref)(_playStream); 1625 _playStream = NULL; 1626 1627 PaUnLock(); 1628 1629 // Provide the playStream to the mixer 1630 _mixerManager.SetPlayStream(_playStream); 1631 1632 if (_playBuffer) 1633 { 1634 delete [] _playBuffer; 1635 _playBuffer = NULL; 1636 } 1637 1638 return 0; 1639 } 1640 1641 int32_t AudioDeviceLinuxPulse::PlayoutDelay(uint16_t& delayMS) const 1642 { 1643 CriticalSectionScoped lock(&_critSect); 1644 delayMS = (uint16_t) _sndCardPlayDelay; 1645 return 0; 1646 } 1647 1648 int32_t AudioDeviceLinuxPulse::RecordingDelay(uint16_t& delayMS) const 1649 { 1650 CriticalSectionScoped lock(&_critSect); 1651 delayMS = (uint16_t) _sndCardRecDelay; 1652 return 0; 1653 } 1654 1655 bool AudioDeviceLinuxPulse::Playing() const 1656 { 1657 CriticalSectionScoped lock(&_critSect); 1658 return (_playing); 1659 } 1660 1661 int32_t AudioDeviceLinuxPulse::SetPlayoutBuffer( 1662 const AudioDeviceModule::BufferType type, 1663 uint16_t sizeMS) 1664 { 1665 1666 if (type != AudioDeviceModule::kFixedBufferSize) 1667 { 1668 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, 1669 " Adaptive buffer size not supported on this platform"); 1670 return -1; 1671 } 1672 1673 _playBufType = type; 1674 _playBufDelayFixed = sizeMS; 1675 1676 return 0; 1677 } 1678 1679 int32_t AudioDeviceLinuxPulse::PlayoutBuffer( 1680 AudioDeviceModule::BufferType& type, 1681 uint16_t& sizeMS) const 1682 { 1683 1684 type = _playBufType; 1685 sizeMS = _playBufDelayFixed; 1686 1687 return 0; 1688 } 1689 1690 int32_t AudioDeviceLinuxPulse::CPULoad(uint16_t& /*load*/) const 1691 { 1692 1693 WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, 1694 " API call not supported on this platform"); 1695 return -1; 1696 } 1697 1698 bool AudioDeviceLinuxPulse::PlayoutWarning() const 1699 { 1700 CriticalSectionScoped lock(&_critSect); 1701 return (_playWarning > 0); 1702 } 1703 1704 bool AudioDeviceLinuxPulse::PlayoutError() const 1705 { 1706 CriticalSectionScoped lock(&_critSect); 1707 return (_playError > 0); 1708 } 1709 1710 bool AudioDeviceLinuxPulse::RecordingWarning() const 1711 { 1712 CriticalSectionScoped lock(&_critSect); 1713 return (_recWarning > 0); 1714 } 1715 1716 bool AudioDeviceLinuxPulse::RecordingError() const 1717 { 1718 CriticalSectionScoped lock(&_critSect); 1719 return (_recError > 0); 1720 } 1721 1722 void AudioDeviceLinuxPulse::ClearPlayoutWarning() 1723 { 1724 CriticalSectionScoped lock(&_critSect); 1725 _playWarning = 0; 1726 } 1727 1728 void AudioDeviceLinuxPulse::ClearPlayoutError() 1729 { 1730 CriticalSectionScoped lock(&_critSect); 1731 _playError = 0; 1732 } 1733 1734 void AudioDeviceLinuxPulse::ClearRecordingWarning() 1735 { 1736 CriticalSectionScoped lock(&_critSect); 1737 _recWarning = 0; 1738 } 1739 1740 void AudioDeviceLinuxPulse::ClearRecordingError() 1741 { 1742 CriticalSectionScoped lock(&_critSect); 1743 _recError = 0; 1744 } 1745 1746 // ============================================================================ 1747 // Private Methods 1748 // ============================================================================ 1749 1750 void AudioDeviceLinuxPulse::PaContextStateCallback(pa_context *c, void *pThis) 1751 { 1752 static_cast<AudioDeviceLinuxPulse*> (pThis)->PaContextStateCallbackHandler( 1753 c); 1754 } 1755 1756 // ---------------------------------------------------------------------------- 1757 // PaSinkInfoCallback 1758 // ---------------------------------------------------------------------------- 1759 1760 void AudioDeviceLinuxPulse::PaSinkInfoCallback(pa_context */*c*/, 1761 const pa_sink_info *i, int eol, 1762 void *pThis) 1763 { 1764 static_cast<AudioDeviceLinuxPulse*> (pThis)->PaSinkInfoCallbackHandler( 1765 i, eol); 1766 } 1767 1768 void AudioDeviceLinuxPulse::PaSourceInfoCallback(pa_context */*c*/, 1769 const pa_source_info *i, 1770 int eol, void *pThis) 1771 { 1772 static_cast<AudioDeviceLinuxPulse*> (pThis)->PaSourceInfoCallbackHandler( 1773 i, eol); 1774 } 1775 1776 void AudioDeviceLinuxPulse::PaServerInfoCallback(pa_context */*c*/, 1777 const pa_server_info *i, 1778 void *pThis) 1779 { 1780 static_cast<AudioDeviceLinuxPulse*> (pThis)->PaServerInfoCallbackHandler(i); 1781 } 1782 1783 void AudioDeviceLinuxPulse::PaStreamStateCallback(pa_stream *p, void *pThis) 1784 { 1785 static_cast<AudioDeviceLinuxPulse*> (pThis)->PaStreamStateCallbackHandler(p); 1786 } 1787 1788 void AudioDeviceLinuxPulse::PaContextStateCallbackHandler(pa_context *c) 1789 { 1790 WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice, _id, 1791 " context state cb"); 1792 1793 pa_context_state_t state = LATE(pa_context_get_state)(c); 1794 switch (state) 1795 { 1796 case PA_CONTEXT_UNCONNECTED: 1797 WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice, _id, 1798 " unconnected"); 1799 break; 1800 case PA_CONTEXT_CONNECTING: 1801 case PA_CONTEXT_AUTHORIZING: 1802 case PA_CONTEXT_SETTING_NAME: 1803 WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice, _id, 1804 " no state"); 1805 break; 1806 case PA_CONTEXT_FAILED: 1807 case PA_CONTEXT_TERMINATED: 1808 WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice, _id, 1809 " failed"); 1810 _paStateChanged = true; 1811 LATE(pa_threaded_mainloop_signal)(_paMainloop, 0); 1812 break; 1813 case PA_CONTEXT_READY: 1814 WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice, _id, 1815 " ready"); 1816 _paStateChanged = true; 1817 LATE(pa_threaded_mainloop_signal)(_paMainloop, 0); 1818 break; 1819 } 1820 } 1821 1822 void AudioDeviceLinuxPulse::PaSinkInfoCallbackHandler(const pa_sink_info *i, 1823 int eol) 1824 { 1825 if (eol) 1826 { 1827 // Signal that we are done 1828 LATE(pa_threaded_mainloop_signal)(_paMainloop, 0); 1829 return; 1830 } 1831 1832 if (_numPlayDevices == _deviceIndex) 1833 { 1834 // Convert the device index to the one of the sink 1835 _paDeviceIndex = i->index; 1836 1837 if (_playDeviceName) 1838 { 1839 // Copy the sink name 1840 strncpy(_playDeviceName, i->name, kAdmMaxDeviceNameSize); 1841 _playDeviceName[kAdmMaxDeviceNameSize - 1] = '\0'; 1842 } 1843 if (_playDisplayDeviceName) 1844 { 1845 // Copy the sink display name 1846 strncpy(_playDisplayDeviceName, i->description, 1847 kAdmMaxDeviceNameSize); 1848 _playDisplayDeviceName[kAdmMaxDeviceNameSize - 1] = '\0'; 1849 } 1850 } 1851 1852 _numPlayDevices++; 1853 } 1854 1855 void AudioDeviceLinuxPulse::PaSourceInfoCallbackHandler( 1856 const pa_source_info *i, 1857 int eol) 1858 { 1859 if (eol) 1860 { 1861 // Signal that we are done 1862 LATE(pa_threaded_mainloop_signal)(_paMainloop, 0); 1863 return; 1864 } 1865 1866 // We don't want to list output devices 1867 if (i->monitor_of_sink == PA_INVALID_INDEX) 1868 { 1869 if (_numRecDevices == _deviceIndex) 1870 { 1871 // Convert the device index to the one of the source 1872 _paDeviceIndex = i->index; 1873 1874 if (_recDeviceName) 1875 { 1876 // copy the source name 1877 strncpy(_recDeviceName, i->name, kAdmMaxDeviceNameSize); 1878 _recDeviceName[kAdmMaxDeviceNameSize - 1] = '\0'; 1879 } 1880 if (_recDisplayDeviceName) 1881 { 1882 // Copy the source display name 1883 strncpy(_recDisplayDeviceName, i->description, 1884 kAdmMaxDeviceNameSize); 1885 _recDisplayDeviceName[kAdmMaxDeviceNameSize - 1] = '\0'; 1886 } 1887 } 1888 1889 _numRecDevices++; 1890 } 1891 } 1892 1893 void AudioDeviceLinuxPulse::PaServerInfoCallbackHandler(const pa_server_info *i) 1894 { 1895 // Use PA native sampling rate 1896 sample_rate_hz_ = i->sample_spec.rate; 1897 1898 // Copy the PA server version 1899 strncpy(_paServerVersion, i->server_version, 31); 1900 _paServerVersion[31] = '\0'; 1901 1902 if (_recDisplayDeviceName) 1903 { 1904 // Copy the source name 1905 strncpy(_recDisplayDeviceName, i->default_source_name, 1906 kAdmMaxDeviceNameSize); 1907 _recDisplayDeviceName[kAdmMaxDeviceNameSize - 1] = '\0'; 1908 } 1909 1910 if (_playDisplayDeviceName) 1911 { 1912 // Copy the sink name 1913 strncpy(_playDisplayDeviceName, i->default_sink_name, 1914 kAdmMaxDeviceNameSize); 1915 _playDisplayDeviceName[kAdmMaxDeviceNameSize - 1] = '\0'; 1916 } 1917 1918 LATE(pa_threaded_mainloop_signal)(_paMainloop, 0); 1919 } 1920 1921 void AudioDeviceLinuxPulse::PaStreamStateCallbackHandler(pa_stream *p) 1922 { 1923 WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice, _id, 1924 " stream state cb"); 1925 1926 pa_stream_state_t state = LATE(pa_stream_get_state)(p); 1927 switch (state) 1928 { 1929 case PA_STREAM_UNCONNECTED: 1930 WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice, _id, 1931 " unconnected"); 1932 break; 1933 case PA_STREAM_CREATING: 1934 WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice, _id, 1935 " creating"); 1936 break; 1937 case PA_STREAM_FAILED: 1938 case PA_STREAM_TERMINATED: 1939 WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice, _id, 1940 " failed"); 1941 break; 1942 case PA_STREAM_READY: 1943 WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice, _id, 1944 " ready"); 1945 break; 1946 } 1947 1948 LATE(pa_threaded_mainloop_signal)(_paMainloop, 0); 1949 } 1950 1951 int32_t AudioDeviceLinuxPulse::CheckPulseAudioVersion() 1952 { 1953 PaLock(); 1954 1955 pa_operation* paOperation = NULL; 1956 1957 // get the server info and update deviceName 1958 paOperation = LATE(pa_context_get_server_info)(_paContext, 1959 PaServerInfoCallback, this); 1960 1961 WaitForOperationCompletion(paOperation); 1962 1963 PaUnLock(); 1964 1965 WEBRTC_TRACE(kTraceStateInfo, kTraceAudioDevice, -1, 1966 " checking PulseAudio version: %s", _paServerVersion); 1967 1968 return 0; 1969 } 1970 1971 int32_t AudioDeviceLinuxPulse::InitSamplingFrequency() 1972 { 1973 PaLock(); 1974 1975 pa_operation* paOperation = NULL; 1976 1977 // Get the server info and update sample_rate_hz_ 1978 paOperation = LATE(pa_context_get_server_info)(_paContext, 1979 PaServerInfoCallback, this); 1980 1981 WaitForOperationCompletion(paOperation); 1982 1983 PaUnLock(); 1984 1985 return 0; 1986 } 1987 1988 int32_t AudioDeviceLinuxPulse::GetDefaultDeviceInfo(bool recDevice, 1989 char* name, 1990 uint16_t& index) 1991 { 1992 char tmpName[kAdmMaxDeviceNameSize] = {0}; 1993 // subtract length of "default: " 1994 uint16_t nameLen = kAdmMaxDeviceNameSize - 9; 1995 char* pName = NULL; 1996 1997 if (name) 1998 { 1999 // Add "default: " 2000 strcpy(name, "default: "); 2001 pName = &name[9]; 2002 } 2003 2004 // Tell the callback that we want 2005 // the name for this device 2006 if (recDevice) 2007 { 2008 _recDisplayDeviceName = tmpName; 2009 } else 2010 { 2011 _playDisplayDeviceName = tmpName; 2012 } 2013 2014 // Set members 2015 _paDeviceIndex = -1; 2016 _deviceIndex = 0; 2017 _numPlayDevices = 0; 2018 _numRecDevices = 0; 2019 2020 PaLock(); 2021 2022 pa_operation* paOperation = NULL; 2023 2024 // Get the server info and update deviceName 2025 paOperation = LATE(pa_context_get_server_info)(_paContext, 2026 PaServerInfoCallback, this); 2027 2028 WaitForOperationCompletion(paOperation); 2029 2030 // Get the device index 2031 if (recDevice) 2032 { 2033 paOperation 2034 = LATE(pa_context_get_source_info_by_name)(_paContext, 2035 (char *) tmpName, 2036 PaSourceInfoCallback, 2037 this); 2038 } else 2039 { 2040 paOperation 2041 = LATE(pa_context_get_sink_info_by_name)(_paContext, 2042 (char *) tmpName, 2043 PaSinkInfoCallback, this); 2044 } 2045 2046 WaitForOperationCompletion(paOperation); 2047 2048 PaUnLock(); 2049 2050 // Set the index 2051 index = _paDeviceIndex; 2052 2053 if (name) 2054 { 2055 // Copy to name string 2056 strncpy(pName, tmpName, nameLen); 2057 } 2058 2059 // Clear members 2060 _playDisplayDeviceName = NULL; 2061 _recDisplayDeviceName = NULL; 2062 _paDeviceIndex = -1; 2063 _deviceIndex = -1; 2064 _numPlayDevices = 0; 2065 _numRecDevices = 0; 2066 2067 return 0; 2068 } 2069 2070 int32_t AudioDeviceLinuxPulse::InitPulseAudio() 2071 { 2072 int retVal = 0; 2073 2074 // Load libpulse 2075 if (!PaSymbolTable.Load()) 2076 { 2077 // Most likely the Pulse library and sound server are not installed on 2078 // this system 2079 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, 2080 " failed to load symbol table"); 2081 return -1; 2082 } 2083 2084 // Create a mainloop API and connection to the default server 2085 // the mainloop is the internal asynchronous API event loop 2086 if (_paMainloop) { 2087 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, 2088 " PA mainloop has already existed"); 2089 return -1; 2090 } 2091 _paMainloop = LATE(pa_threaded_mainloop_new)(); 2092 if (!_paMainloop) 2093 { 2094 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, 2095 " could not create mainloop"); 2096 return -1; 2097 } 2098 2099 // Start the threaded main loop 2100 retVal = LATE(pa_threaded_mainloop_start)(_paMainloop); 2101 if (retVal != PA_OK) 2102 { 2103 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, 2104 " failed to start main loop, error=%d", retVal); 2105 return -1; 2106 } 2107 2108 WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice, _id, 2109 " mainloop running!"); 2110 2111 PaLock(); 2112 2113 _paMainloopApi = LATE(pa_threaded_mainloop_get_api)(_paMainloop); 2114 if (!_paMainloopApi) 2115 { 2116 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, 2117 " could not create mainloop API"); 2118 PaUnLock(); 2119 return -1; 2120 } 2121 2122 // Create a new PulseAudio context 2123 if (_paContext){ 2124 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, 2125 " PA context has already existed"); 2126 PaUnLock(); 2127 return -1; 2128 } 2129 _paContext = LATE(pa_context_new)(_paMainloopApi, "WEBRTC VoiceEngine"); 2130 2131 if (!_paContext) 2132 { 2133 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, 2134 " could not create context"); 2135 PaUnLock(); 2136 return -1; 2137 } 2138 2139 // Set state callback function 2140 LATE(pa_context_set_state_callback)(_paContext, PaContextStateCallback, 2141 this); 2142 2143 // Connect the context to a server (default) 2144 _paStateChanged = false; 2145 retVal = LATE(pa_context_connect)(_paContext, NULL, PA_CONTEXT_NOAUTOSPAWN, 2146 NULL); 2147 2148 if (retVal != PA_OK) 2149 { 2150 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, 2151 " failed to connect context, error=%d", retVal); 2152 PaUnLock(); 2153 return -1; 2154 } 2155 2156 // Wait for state change 2157 while (!_paStateChanged) 2158 { 2159 LATE(pa_threaded_mainloop_wait)(_paMainloop); 2160 } 2161 2162 // Now check to see what final state we reached. 2163 pa_context_state_t state = LATE(pa_context_get_state)(_paContext); 2164 2165 if (state != PA_CONTEXT_READY) 2166 { 2167 if (state == PA_CONTEXT_FAILED) 2168 { 2169 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, 2170 " failed to connect to PulseAudio sound server"); 2171 } else if (state == PA_CONTEXT_TERMINATED) 2172 { 2173 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, 2174 " PulseAudio connection terminated early"); 2175 } else 2176 { 2177 // Shouldn't happen, because we only signal on one of those three 2178 // states 2179 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, 2180 " unknown problem connecting to PulseAudio"); 2181 } 2182 PaUnLock(); 2183 return -1; 2184 } 2185 2186 PaUnLock(); 2187 2188 // Give the objects to the mixer manager 2189 _mixerManager.SetPulseAudioObjects(_paMainloop, _paContext); 2190 2191 // Check the version 2192 if (CheckPulseAudioVersion() < 0) 2193 { 2194 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, 2195 " PulseAudio version %s not supported", _paServerVersion); 2196 return -1; 2197 } 2198 2199 // Initialize sampling frequency 2200 if (InitSamplingFrequency() < 0 || sample_rate_hz_ == 0) 2201 { 2202 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, 2203 " failed to initialize sampling frequency, set to %d Hz", 2204 sample_rate_hz_); 2205 return -1; 2206 } 2207 2208 return 0; 2209 } 2210 2211 int32_t AudioDeviceLinuxPulse::TerminatePulseAudio() 2212 { 2213 // Do nothing if the instance doesn't exist 2214 // likely PaSymbolTable.Load() fails 2215 if (!_paMainloop) { 2216 return 0; 2217 } 2218 2219 PaLock(); 2220 2221 // Disconnect the context 2222 if (_paContext) 2223 { 2224 LATE(pa_context_disconnect)(_paContext); 2225 } 2226 2227 // Unreference the context 2228 if (_paContext) 2229 { 2230 LATE(pa_context_unref)(_paContext); 2231 } 2232 2233 PaUnLock(); 2234 _paContext = NULL; 2235 2236 // Stop the threaded main loop 2237 if (_paMainloop) 2238 { 2239 LATE(pa_threaded_mainloop_stop)(_paMainloop); 2240 } 2241 2242 // Free the mainloop 2243 if (_paMainloop) 2244 { 2245 LATE(pa_threaded_mainloop_free)(_paMainloop); 2246 } 2247 2248 _paMainloop = NULL; 2249 2250 WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice, _id, 2251 " PulseAudio terminated"); 2252 2253 return 0; 2254 } 2255 2256 void AudioDeviceLinuxPulse::PaLock() 2257 { 2258 LATE(pa_threaded_mainloop_lock)(_paMainloop); 2259 } 2260 2261 void AudioDeviceLinuxPulse::PaUnLock() 2262 { 2263 LATE(pa_threaded_mainloop_unlock)(_paMainloop); 2264 } 2265 2266 void AudioDeviceLinuxPulse::WaitForOperationCompletion( 2267 pa_operation* paOperation) const 2268 { 2269 if (!paOperation) 2270 { 2271 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, 2272 "paOperation NULL in WaitForOperationCompletion"); 2273 return; 2274 } 2275 2276 while (LATE(pa_operation_get_state)(paOperation) == PA_OPERATION_RUNNING) 2277 { 2278 LATE(pa_threaded_mainloop_wait)(_paMainloop); 2279 } 2280 2281 LATE(pa_operation_unref)(paOperation); 2282 } 2283 2284 // ============================================================================ 2285 // Thread Methods 2286 // ============================================================================ 2287 2288 void AudioDeviceLinuxPulse::EnableWriteCallback() 2289 { 2290 if (LATE(pa_stream_get_state)(_playStream) == PA_STREAM_READY) 2291 { 2292 // May already have available space. Must check. 2293 _tempBufferSpace = LATE(pa_stream_writable_size)(_playStream); 2294 if (_tempBufferSpace > 0) 2295 { 2296 // Yup, there is already space available, so if we register a write 2297 // callback then it will not receive any event. So dispatch one ourself 2298 // instead 2299 _timeEventPlay.Set(); 2300 return; 2301 } 2302 } 2303 2304 LATE(pa_stream_set_write_callback)(_playStream, &PaStreamWriteCallback, 2305 this); 2306 } 2307 2308 void AudioDeviceLinuxPulse::DisableWriteCallback() 2309 { 2310 LATE(pa_stream_set_write_callback)(_playStream, NULL, NULL); 2311 } 2312 2313 void AudioDeviceLinuxPulse::PaStreamWriteCallback(pa_stream */*unused*/, 2314 size_t buffer_space, 2315 void *pThis) 2316 { 2317 static_cast<AudioDeviceLinuxPulse*> (pThis)->PaStreamWriteCallbackHandler( 2318 buffer_space); 2319 } 2320 2321 void AudioDeviceLinuxPulse::PaStreamWriteCallbackHandler(size_t bufferSpace) 2322 { 2323 _tempBufferSpace = bufferSpace; 2324 2325 // Since we write the data asynchronously on a different thread, we have 2326 // to temporarily disable the write callback or else Pulse will call it 2327 // continuously until we write the data. We re-enable it below. 2328 DisableWriteCallback(); 2329 _timeEventPlay.Set(); 2330 } 2331 2332 void AudioDeviceLinuxPulse::PaStreamUnderflowCallback(pa_stream */*unused*/, 2333 void *pThis) 2334 { 2335 static_cast<AudioDeviceLinuxPulse*> (pThis)->PaStreamUnderflowCallbackHandler(); 2336 } 2337 2338 void AudioDeviceLinuxPulse::PaStreamUnderflowCallbackHandler() 2339 { 2340 WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, 2341 " Playout underflow"); 2342 2343 if (_configuredLatencyPlay == WEBRTC_PA_NO_LATENCY_REQUIREMENTS) 2344 { 2345 // We didn't configure a pa_buffer_attr before, so switching to one now 2346 // would be questionable. 2347 return; 2348 } 2349 2350 // Otherwise reconfigure the stream with a higher target latency. 2351 2352 const pa_sample_spec *spec = LATE(pa_stream_get_sample_spec)(_playStream); 2353 if (!spec) 2354 { 2355 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, 2356 " pa_stream_get_sample_spec()"); 2357 return; 2358 } 2359 2360 size_t bytesPerSec = LATE(pa_bytes_per_second)(spec); 2361 uint32_t newLatency = _configuredLatencyPlay + bytesPerSec 2362 * WEBRTC_PA_PLAYBACK_LATENCY_INCREMENT_MSECS / WEBRTC_PA_MSECS_PER_SEC; 2363 2364 // Set the play buffer attributes 2365 _playBufferAttr.maxlength = newLatency; 2366 _playBufferAttr.tlength = newLatency; 2367 _playBufferAttr.minreq = newLatency / WEBRTC_PA_PLAYBACK_REQUEST_FACTOR; 2368 _playBufferAttr.prebuf = _playBufferAttr.tlength - _playBufferAttr.minreq; 2369 2370 pa_operation *op = LATE(pa_stream_set_buffer_attr)(_playStream, 2371 &_playBufferAttr, NULL, 2372 NULL); 2373 if (!op) 2374 { 2375 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, 2376 " pa_stream_set_buffer_attr()"); 2377 return; 2378 } 2379 2380 // Don't need to wait for this to complete. 2381 LATE(pa_operation_unref)(op); 2382 2383 // Save the new latency in case we underflow again. 2384 _configuredLatencyPlay = newLatency; 2385 } 2386 2387 void AudioDeviceLinuxPulse::EnableReadCallback() 2388 { 2389 LATE(pa_stream_set_read_callback)(_recStream, &PaStreamReadCallback, this); 2390 } 2391 2392 void AudioDeviceLinuxPulse::DisableReadCallback() 2393 { 2394 LATE(pa_stream_set_read_callback)(_recStream, NULL, NULL); 2395 } 2396 2397 void AudioDeviceLinuxPulse::PaStreamReadCallback(pa_stream */*unused1*/, 2398 size_t /*unused2*/, 2399 void *pThis) 2400 { 2401 static_cast<AudioDeviceLinuxPulse*> (pThis)->PaStreamReadCallbackHandler(); 2402 } 2403 2404 void AudioDeviceLinuxPulse::PaStreamReadCallbackHandler() 2405 { 2406 // We get the data pointer and size now in order to save one Lock/Unlock 2407 // in the worker thread 2408 if (LATE(pa_stream_peek)(_recStream, &_tempSampleData, &_tempSampleDataSize) 2409 != 0) 2410 { 2411 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, 2412 " Can't read data!"); 2413 return; 2414 } 2415 2416 // Since we consume the data asynchronously on a different thread, we have 2417 // to temporarily disable the read callback or else Pulse will call it 2418 // continuously until we consume the data. We re-enable it below 2419 DisableReadCallback(); 2420 _timeEventRec.Set(); 2421 } 2422 2423 void AudioDeviceLinuxPulse::PaStreamOverflowCallback(pa_stream */*unused*/, 2424 void *pThis) 2425 { 2426 static_cast<AudioDeviceLinuxPulse*> (pThis)->PaStreamOverflowCallbackHandler(); 2427 } 2428 2429 void AudioDeviceLinuxPulse::PaStreamOverflowCallbackHandler() 2430 { 2431 WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, 2432 " Recording overflow"); 2433 } 2434 2435 int32_t AudioDeviceLinuxPulse::LatencyUsecs(pa_stream *stream) 2436 { 2437 if (!WEBRTC_PA_REPORT_LATENCY) 2438 { 2439 return 0; 2440 } 2441 2442 if (!stream) 2443 { 2444 return 0; 2445 } 2446 2447 pa_usec_t latency; 2448 int negative; 2449 if (LATE(pa_stream_get_latency)(stream, &latency, &negative) != 0) 2450 { 2451 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, 2452 " Can't query latency"); 2453 // We'd rather continue playout/capture with an incorrect delay than stop 2454 // it altogether, so return a valid value. 2455 return 0; 2456 } 2457 2458 if (negative) 2459 { 2460 WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice, _id, 2461 " warning: pa_stream_get_latency reported negative delay"); 2462 2463 // The delay can be negative for monitoring streams if the captured 2464 // samples haven't been played yet. In such a case, "latency" contains the 2465 // magnitude, so we must negate it to get the real value. 2466 int32_t tmpLatency = (int32_t) -latency; 2467 if (tmpLatency < 0) 2468 { 2469 // Make sure that we don't use a negative delay 2470 tmpLatency = 0; 2471 } 2472 2473 return tmpLatency; 2474 } else 2475 { 2476 return (int32_t) latency; 2477 } 2478 } 2479 2480 int32_t AudioDeviceLinuxPulse::ReadRecordedData(const void* bufferData, 2481 size_t bufferSize) 2482 { 2483 size_t size = bufferSize; 2484 uint32_t numRecSamples = _recordBufferSize / (2 * _recChannels); 2485 2486 // Account for the peeked data and the used data 2487 uint32_t recDelay = (uint32_t) ((LatencyUsecs(_recStream) 2488 / 1000) + 10 * ((size + _recordBufferUsed) / _recordBufferSize)); 2489 2490 _sndCardRecDelay = recDelay; 2491 2492 if (_playStream) 2493 { 2494 // Get the playout delay 2495 _sndCardPlayDelay = (uint32_t) (LatencyUsecs(_playStream) / 1000); 2496 } 2497 2498 if (_recordBufferUsed > 0) 2499 { 2500 // Have to copy to the buffer until it is full 2501 size_t copy = _recordBufferSize - _recordBufferUsed; 2502 if (size < copy) 2503 { 2504 copy = size; 2505 } 2506 2507 memcpy(&_recBuffer[_recordBufferUsed], bufferData, copy); 2508 _recordBufferUsed += copy; 2509 bufferData = static_cast<const char *> (bufferData) + copy; 2510 size -= copy; 2511 2512 if (_recordBufferUsed != _recordBufferSize) 2513 { 2514 // Not enough data yet to pass to VoE 2515 return 0; 2516 } 2517 2518 // Provide data to VoiceEngine 2519 if (ProcessRecordedData(_recBuffer, numRecSamples, recDelay) == -1) 2520 { 2521 // We have stopped recording 2522 return -1; 2523 } 2524 2525 _recordBufferUsed = 0; 2526 } 2527 2528 // Now process full 10ms sample sets directly from the input 2529 while (size >= _recordBufferSize) 2530 { 2531 // Provide data to VoiceEngine 2532 if (ProcessRecordedData( 2533 static_cast<int8_t *> (const_cast<void *> (bufferData)), 2534 numRecSamples, recDelay) == -1) 2535 { 2536 // We have stopped recording 2537 return -1; 2538 } 2539 2540 bufferData = static_cast<const char *> (bufferData) + _recordBufferSize; 2541 size -= _recordBufferSize; 2542 2543 // We have consumed 10ms of data 2544 recDelay -= 10; 2545 } 2546 2547 // Now save any leftovers for later. 2548 if (size > 0) 2549 { 2550 memcpy(_recBuffer, bufferData, size); 2551 _recordBufferUsed = size; 2552 } 2553 2554 return 0; 2555 } 2556 2557 int32_t AudioDeviceLinuxPulse::ProcessRecordedData( 2558 int8_t *bufferData, 2559 uint32_t bufferSizeInSamples, 2560 uint32_t recDelay) EXCLUSIVE_LOCKS_REQUIRED(_critSect) 2561 { 2562 uint32_t currentMicLevel(0); 2563 uint32_t newMicLevel(0); 2564 2565 _ptrAudioBuffer->SetRecordedBuffer(bufferData, bufferSizeInSamples); 2566 2567 if (AGC()) 2568 { 2569 // Store current mic level in the audio buffer if AGC is enabled 2570 if (MicrophoneVolume(currentMicLevel) == 0) 2571 { 2572 // This call does not affect the actual microphone volume 2573 _ptrAudioBuffer->SetCurrentMicLevel(currentMicLevel); 2574 } 2575 } 2576 2577 const uint32_t clockDrift(0); 2578 // TODO(andrew): this is a temporary hack, to avoid non-causal far- and 2579 // near-end signals at the AEC for PulseAudio. I think the system delay is 2580 // being correctly calculated here, but for legacy reasons we add +10 ms to 2581 // the value in the AEC. The real fix will be part of a larger investigation 2582 // into managing system delay in the AEC. 2583 if (recDelay > 10) 2584 recDelay -= 10; 2585 else 2586 recDelay = 0; 2587 _ptrAudioBuffer->SetVQEData(_sndCardPlayDelay, recDelay, clockDrift); 2588 _ptrAudioBuffer->SetTypingStatus(KeyPressed()); 2589 // Deliver recorded samples at specified sample rate, 2590 // mic level etc. to the observer using callback 2591 UnLock(); 2592 _ptrAudioBuffer->DeliverRecordedData(); 2593 Lock(); 2594 2595 // We have been unlocked - check the flag again 2596 if (!_recording) 2597 { 2598 return -1; 2599 } 2600 2601 if (AGC()) 2602 { 2603 newMicLevel = _ptrAudioBuffer->NewMicLevel(); 2604 if (newMicLevel != 0) 2605 { 2606 // The VQE will only deliver non-zero microphone levels when a 2607 // change is needed. 2608 // Set this new mic level (received from the observer as return 2609 // value in the callback). 2610 WEBRTC_TRACE(kTraceStream, kTraceAudioDevice, _id, 2611 " AGC change of volume: old=%u => new=%u", 2612 currentMicLevel, newMicLevel); 2613 if (SetMicrophoneVolume(newMicLevel) == -1) 2614 { 2615 WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, 2616 _id, 2617 " the required modification of the microphone " 2618 "volume failed"); 2619 } 2620 } 2621 } 2622 2623 return 0; 2624 } 2625 2626 bool AudioDeviceLinuxPulse::PlayThreadFunc(void* pThis) 2627 { 2628 return (static_cast<AudioDeviceLinuxPulse*> (pThis)->PlayThreadProcess()); 2629 } 2630 2631 bool AudioDeviceLinuxPulse::RecThreadFunc(void* pThis) 2632 { 2633 return (static_cast<AudioDeviceLinuxPulse*> (pThis)->RecThreadProcess()); 2634 } 2635 2636 bool AudioDeviceLinuxPulse::PlayThreadProcess() 2637 { 2638 switch (_timeEventPlay.Wait(1000)) 2639 { 2640 case kEventSignaled: 2641 _timeEventPlay.Reset(); 2642 break; 2643 case kEventError: 2644 WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, 2645 "EventWrapper::Wait() failed"); 2646 return true; 2647 case kEventTimeout: 2648 return true; 2649 } 2650 2651 Lock(); 2652 2653 if (_startPlay) 2654 { 2655 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, 2656 "_startPlay true, performing initial actions"); 2657 2658 _startPlay = false; 2659 _playDeviceName = NULL; 2660 2661 // Set if not default device 2662 if (_outputDeviceIndex > 0) 2663 { 2664 // Get the playout device name 2665 _playDeviceName = new char[kAdmMaxDeviceNameSize]; 2666 _deviceIndex = _outputDeviceIndex; 2667 PlayoutDevices(); 2668 } 2669 2670 // Start muted only supported on 0.9.11 and up 2671 if (LATE(pa_context_get_protocol_version)(_paContext) 2672 >= WEBRTC_PA_ADJUST_LATENCY_PROTOCOL_VERSION) 2673 { 2674 // Get the currently saved speaker mute status 2675 // and set the initial mute status accordingly 2676 bool enabled(false); 2677 _mixerManager.SpeakerMute(enabled); 2678 if (enabled) 2679 { 2680 _playStreamFlags |= PA_STREAM_START_MUTED; 2681 } 2682 } 2683 2684 // Get the currently saved speaker volume 2685 uint32_t volume = 0; 2686 if (update_speaker_volume_at_startup_) 2687 _mixerManager.SpeakerVolume(volume); 2688 2689 PaLock(); 2690 2691 // NULL gives PA the choice of startup volume. 2692 pa_cvolume* ptr_cvolume = NULL; 2693 if (update_speaker_volume_at_startup_) { 2694 pa_cvolume cVolumes; 2695 ptr_cvolume = &cVolumes; 2696 2697 // Set the same volume for all channels 2698 const pa_sample_spec *spec = 2699 LATE(pa_stream_get_sample_spec)(_playStream); 2700 LATE(pa_cvolume_set)(&cVolumes, spec->channels, volume); 2701 update_speaker_volume_at_startup_ = false; 2702 } 2703 2704 // Connect the stream to a sink 2705 if (LATE(pa_stream_connect_playback)( 2706 _playStream, 2707 _playDeviceName, 2708 &_playBufferAttr, 2709 (pa_stream_flags_t) _playStreamFlags, 2710 ptr_cvolume, NULL) != PA_OK) 2711 { 2712 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, 2713 " failed to connect play stream, err=%d", 2714 LATE(pa_context_errno)(_paContext)); 2715 } 2716 2717 WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice, _id, 2718 " play stream connected"); 2719 2720 // Wait for state change 2721 while (LATE(pa_stream_get_state)(_playStream) != PA_STREAM_READY) 2722 { 2723 LATE(pa_threaded_mainloop_wait)(_paMainloop); 2724 } 2725 2726 WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice, _id, 2727 " play stream ready"); 2728 2729 // We can now handle write callbacks 2730 EnableWriteCallback(); 2731 2732 PaUnLock(); 2733 2734 // Clear device name 2735 if (_playDeviceName) 2736 { 2737 delete [] _playDeviceName; 2738 _playDeviceName = NULL; 2739 } 2740 2741 _playing = true; 2742 _playStartEvent.Set(); 2743 2744 UnLock(); 2745 return true; 2746 } 2747 2748 if (_playing) 2749 { 2750 if (!_recording) 2751 { 2752 // Update the playout delay 2753 _sndCardPlayDelay = (uint32_t) (LatencyUsecs(_playStream) 2754 / 1000); 2755 } 2756 2757 if (_playbackBufferUnused < _playbackBufferSize) 2758 { 2759 2760 size_t write = _playbackBufferSize - _playbackBufferUnused; 2761 if (_tempBufferSpace < write) 2762 { 2763 write = _tempBufferSpace; 2764 } 2765 2766 PaLock(); 2767 if (LATE(pa_stream_write)( 2768 _playStream, 2769 (void *) &_playBuffer[_playbackBufferUnused], 2770 write, NULL, (int64_t) 0, 2771 PA_SEEK_RELATIVE) != PA_OK) 2772 { 2773 _writeErrors++; 2774 if (_writeErrors > 10) 2775 { 2776 if (_playError == 1) 2777 { 2778 WEBRTC_TRACE(kTraceWarning, 2779 kTraceUtility, _id, 2780 " pending playout error exists"); 2781 } 2782 _playError = 1; // Triggers callback from module process thread 2783 WEBRTC_TRACE( 2784 kTraceError, 2785 kTraceUtility, 2786 _id, 2787 " kPlayoutError message posted: " 2788 "_writeErrors=%u, error=%d", 2789 _writeErrors, 2790 LATE(pa_context_errno)(_paContext)); 2791 _writeErrors = 0; 2792 } 2793 } 2794 PaUnLock(); 2795 2796 _playbackBufferUnused += write; 2797 _tempBufferSpace -= write; 2798 } 2799 2800 uint32_t numPlaySamples = _playbackBufferSize / (2 * _playChannels); 2801 if (_tempBufferSpace > 0) // Might have been reduced to zero by the above 2802 { 2803 // Ask for new PCM data to be played out using the AudioDeviceBuffer 2804 // ensure that this callback is executed without taking the 2805 // audio-thread lock 2806 UnLock(); 2807 WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice, _id, 2808 " requesting data"); 2809 uint32_t nSamples = 2810 _ptrAudioBuffer->RequestPlayoutData(numPlaySamples); 2811 Lock(); 2812 2813 // We have been unlocked - check the flag again 2814 if (!_playing) 2815 { 2816 UnLock(); 2817 return true; 2818 } 2819 2820 nSamples = _ptrAudioBuffer->GetPlayoutData(_playBuffer); 2821 if (nSamples != numPlaySamples) 2822 { 2823 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, 2824 _id, " invalid number of output samples(%d)", 2825 nSamples); 2826 } 2827 2828 size_t write = _playbackBufferSize; 2829 if (_tempBufferSpace < write) 2830 { 2831 write = _tempBufferSpace; 2832 } 2833 2834 WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice, _id, 2835 " will write"); 2836 PaLock(); 2837 if (LATE(pa_stream_write)(_playStream, (void *) &_playBuffer[0], 2838 write, NULL, (int64_t) 0, 2839 PA_SEEK_RELATIVE) != PA_OK) 2840 { 2841 _writeErrors++; 2842 if (_writeErrors > 10) 2843 { 2844 if (_playError == 1) 2845 { 2846 WEBRTC_TRACE(kTraceWarning, 2847 kTraceUtility, _id, 2848 " pending playout error exists"); 2849 } 2850 _playError = 1; // triggers callback from module process thread 2851 WEBRTC_TRACE( 2852 kTraceError, 2853 kTraceUtility, 2854 _id, 2855 " kPlayoutError message posted: " 2856 "_writeErrors=%u, error=%d", 2857 _writeErrors, 2858 LATE(pa_context_errno)(_paContext)); 2859 _writeErrors = 0; 2860 } 2861 } 2862 PaUnLock(); 2863 2864 _playbackBufferUnused = write; 2865 } 2866 2867 _tempBufferSpace = 0; 2868 PaLock(); 2869 EnableWriteCallback(); 2870 PaUnLock(); 2871 2872 } // _playing 2873 2874 UnLock(); 2875 return true; 2876 } 2877 2878 bool AudioDeviceLinuxPulse::RecThreadProcess() 2879 { 2880 switch (_timeEventRec.Wait(1000)) 2881 { 2882 case kEventSignaled: 2883 _timeEventRec.Reset(); 2884 break; 2885 case kEventError: 2886 WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, 2887 "EventWrapper::Wait() failed"); 2888 return true; 2889 case kEventTimeout: 2890 return true; 2891 } 2892 2893 Lock(); 2894 2895 if (_startRec) 2896 { 2897 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, 2898 "_startRec true, performing initial actions"); 2899 2900 _recDeviceName = NULL; 2901 2902 // Set if not default device 2903 if (_inputDeviceIndex > 0) 2904 { 2905 // Get the recording device name 2906 _recDeviceName = new char[kAdmMaxDeviceNameSize]; 2907 _deviceIndex = _inputDeviceIndex; 2908 RecordingDevices(); 2909 } 2910 2911 PaLock(); 2912 2913 WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice, _id, 2914 " connecting stream"); 2915 2916 // Connect the stream to a source 2917 if (LATE(pa_stream_connect_record)(_recStream, _recDeviceName, 2918 &_recBufferAttr, 2919 (pa_stream_flags_t) _recStreamFlags) 2920 != PA_OK) 2921 { 2922 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, 2923 " failed to connect rec stream, err=%d", 2924 LATE(pa_context_errno)(_paContext)); 2925 } 2926 2927 WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice, _id, 2928 " connected"); 2929 2930 // Wait for state change 2931 while (LATE(pa_stream_get_state)(_recStream) != PA_STREAM_READY) 2932 { 2933 LATE(pa_threaded_mainloop_wait)(_paMainloop); 2934 } 2935 2936 WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice, _id, 2937 " done"); 2938 2939 // We can now handle read callbacks 2940 EnableReadCallback(); 2941 2942 PaUnLock(); 2943 2944 // Clear device name 2945 if (_recDeviceName) 2946 { 2947 delete [] _recDeviceName; 2948 _recDeviceName = NULL; 2949 } 2950 2951 _startRec = false; 2952 _recording = true; 2953 _recStartEvent.Set(); 2954 2955 UnLock(); 2956 return true; 2957 } 2958 2959 if (_recording) 2960 { 2961 // Read data and provide it to VoiceEngine 2962 if (ReadRecordedData(_tempSampleData, _tempSampleDataSize) == -1) 2963 { 2964 UnLock(); 2965 return true; 2966 } 2967 2968 _tempSampleData = NULL; 2969 _tempSampleDataSize = 0; 2970 2971 PaLock(); 2972 while (true) 2973 { 2974 // Ack the last thing we read 2975 if (LATE(pa_stream_drop)(_recStream) != 0) 2976 { 2977 WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, 2978 _id, " failed to drop, err=%d\n", 2979 LATE(pa_context_errno)(_paContext)); 2980 } 2981 2982 if (LATE(pa_stream_readable_size)(_recStream) <= 0) 2983 { 2984 // Then that was all the data 2985 break; 2986 } 2987 2988 // Else more data. 2989 const void *sampleData; 2990 size_t sampleDataSize; 2991 2992 if (LATE(pa_stream_peek)(_recStream, &sampleData, &sampleDataSize) 2993 != 0) 2994 { 2995 _recError = 1; // triggers callback from module process thread 2996 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, 2997 _id, " RECORD_ERROR message posted, error = %d", 2998 LATE(pa_context_errno)(_paContext)); 2999 break; 3000 } 3001 3002 _sndCardRecDelay = (uint32_t) (LatencyUsecs(_recStream) 3003 / 1000); 3004 3005 // Drop lock for sigslot dispatch, which could take a while. 3006 PaUnLock(); 3007 // Read data and provide it to VoiceEngine 3008 if (ReadRecordedData(sampleData, sampleDataSize) == -1) 3009 { 3010 UnLock(); 3011 return true; 3012 } 3013 PaLock(); 3014 3015 // Return to top of loop for the ack and the check for more data. 3016 } 3017 3018 EnableReadCallback(); 3019 PaUnLock(); 3020 3021 } // _recording 3022 3023 UnLock(); 3024 return true; 3025 } 3026 3027 bool AudioDeviceLinuxPulse::KeyPressed() const{ 3028 3029 char szKey[32]; 3030 unsigned int i = 0; 3031 char state = 0; 3032 3033 if (!_XDisplay) 3034 return false; 3035 3036 // Check key map status 3037 XQueryKeymap(_XDisplay, szKey); 3038 3039 // A bit change in keymap means a key is pressed 3040 for (i = 0; i < sizeof(szKey); i++) 3041 state |= (szKey[i] ^ _oldKeyState[i]) & szKey[i]; 3042 3043 // Save old state 3044 memcpy((char*)_oldKeyState, (char*)szKey, sizeof(_oldKeyState)); 3045 return (state != 0); 3046 } 3047 } 3048
