src/third_party/webrtc/modules/audio_device/win/audio_device_wave_win.cc

   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 "webrtc/modules/audio_device/audio_device_config.h"
  12 #include "webrtc/modules/audio_device/audio_device_utility.h"
  13 #include "webrtc/modules/audio_device/win/audio_device_wave_win.h"
  14
  15 #include "webrtc/system_wrappers/interface/event_wrapper.h"
  16 #include "webrtc/system_wrappers/interface/thread_wrapper.h"
  17 #include "webrtc/system_wrappers/interface/trace.h"
  18
  19 #include <windows.h>
  20 #include <objbase.h>    // CoTaskMemAlloc, CoTaskMemFree
  21 #include <strsafe.h>    // StringCchCopy(), StringCchCat(), StringCchPrintf()
  22 #include <assert.h>
  23
  24 // Avoids the need of Windows 7 SDK
  25 #ifndef WAVE_MAPPED_DEFAULT_COMMUNICATION_DEVICE
  26 #define WAVE_MAPPED_DEFAULT_COMMUNICATION_DEVICE   0x0010
  27 #endif
  28
  29 // Supported in Windows Vista and Windows 7.
  30 // http://msdn.microsoft.com/en-us/library/dd370819(v=VS.85).aspx
  31 // Taken from Mmddk.h.
  32 #define DRV_RESERVED                      0x0800
  33 #define DRV_QUERYFUNCTIONINSTANCEID       (DRV_RESERVED + 17)
  34 #define DRV_QUERYFUNCTIONINSTANCEIDSIZE   (DRV_RESERVED + 18)
  35
  36 #define POW2(A) (2 << ((A) - 1))
  37
  38 namespace webrtc {
  39
  40 // ============================================================================
  41 //                            Construction & Destruction
  42 // ============================================================================
  43
  44 // ----------------------------------------------------------------------------
  45 //  AudioDeviceWindowsWave - ctor
  46 // ----------------------------------------------------------------------------
  47
  48 AudioDeviceWindowsWave::AudioDeviceWindowsWave(const int32_t id) :
  49     _ptrAudioBuffer(NULL),
  50     _critSect(*CriticalSectionWrapper::CreateCriticalSection()),
  51     _timeEvent(*EventWrapper::Create()),
  52     _recStartEvent(*EventWrapper::Create()),
  53     _playStartEvent(*EventWrapper::Create()),
  54     _hGetCaptureVolumeThread(NULL),
  55     _hShutdownGetVolumeEvent(NULL),
  56     _hSetCaptureVolumeThread(NULL),
  57     _hShutdownSetVolumeEvent(NULL),
  58     _hSetCaptureVolumeEvent(NULL),
  59     _ptrThread(NULL),
  60     _threadID(0),
  61     _critSectCb(*CriticalSectionWrapper::CreateCriticalSection()),
  62     _id(id),
  63     _mixerManager(id),
  64     _usingInputDeviceIndex(false),
  65     _usingOutputDeviceIndex(false),
  66     _inputDevice(AudioDeviceModule::kDefaultDevice),
  67     _outputDevice(AudioDeviceModule::kDefaultDevice),
  68     _inputDeviceIndex(0),
  69     _outputDeviceIndex(0),
  70     _inputDeviceIsSpecified(false),
  71     _outputDeviceIsSpecified(false),
  72     _initialized(false),
  73     _recIsInitialized(false),
  74     _playIsInitialized(false),
  75     _recording(false),
  76     _playing(false),
  77     _startRec(false),
  78     _stopRec(false),
  79     _startPlay(false),
  80     _stopPlay(false),
  81     _AGC(false),
  82     _hWaveIn(NULL),
  83     _hWaveOut(NULL),
  84     _recChannels(N_REC_CHANNELS),
  85     _playChannels(N_PLAY_CHANNELS),
  86     _recBufCount(0),
  87     _recPutBackDelay(0),
  88     _recDelayCount(0),
  89     _playBufCount(0),
  90     _prevPlayTime(0),
  91     _prevRecTime(0),
  92     _prevTimerCheckTime(0),
  93     _timesdwBytes(0),
  94     _timerFaults(0),
  95     _timerRestartAttempts(0),
  96     _no_of_msecleft_warnings(0),
  97     _MAX_minBuffer(65),
  98     _useHeader(0),
  99     _dTcheckPlayBufDelay(10),
 100     _playBufDelay(80),
 101     _playBufDelayFixed(80),
 102     _minPlayBufDelay(20),
 103     _avgCPULoad(0),
 104     _sndCardPlayDelay(0),
 105     _sndCardRecDelay(0),
 106     _plSampOld(0),
 107     _rcSampOld(0),
 108     _playBufType(AudioDeviceModule::kAdaptiveBufferSize),
 109     _recordedBytes(0),
 110     _playWarning(0),
 111     _playError(0),
 112     _recWarning(0),
 113     _recError(0),
 114     _newMicLevel(0),
 115     _minMicVolume(0),
 116     _maxMicVolume(0)
 117 {
 118     WEBRTC_TRACE(kTraceMemory, kTraceAudioDevice, id, "%s created", __FUNCTION__);
 119
 120     // Initialize value, set to 0 if it fails
 121     if (!QueryPerformanceFrequency(&_perfFreq))
 122     {
 123         _perfFreq.QuadPart = 0;
 124     }
 125
 126     _hShutdownGetVolumeEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
 127     _hShutdownSetVolumeEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
 128     _hSetCaptureVolumeEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
 129 }
 130
 131 // ----------------------------------------------------------------------------
 132 //  AudioDeviceWindowsWave - dtor
 133 // ----------------------------------------------------------------------------
 134
 135 AudioDeviceWindowsWave::~AudioDeviceWindowsWave()
 136 {
 137     WEBRTC_TRACE(kTraceMemory, kTraceAudioDevice, _id, "%s destroyed", __FUNCTION__);
 138
 139     Terminate();
 140
 141     delete &_recStartEvent;
 142     delete &_playStartEvent;
 143     delete &_timeEvent;
 144     delete &_critSect;
 145     delete &_critSectCb;
 146
 147     if (NULL != _hShutdownGetVolumeEvent)
 148     {
 149         CloseHandle(_hShutdownGetVolumeEvent);
 150         _hShutdownGetVolumeEvent = NULL;
 151     }
 152
 153     if (NULL != _hShutdownSetVolumeEvent)
 154     {
 155         CloseHandle(_hShutdownSetVolumeEvent);
 156         _hShutdownSetVolumeEvent = NULL;
 157     }
 158
 159     if (NULL != _hSetCaptureVolumeEvent)
 160     {
 161         CloseHandle(_hSetCaptureVolumeEvent);
 162         _hSetCaptureVolumeEvent = NULL;
 163     }
 164 }
 165
 166 // ============================================================================
 167 //                                     API
 168 // ============================================================================
 169
 170 // ----------------------------------------------------------------------------
 171 //  AttachAudioBuffer
 172 // ----------------------------------------------------------------------------
 173
 174 void AudioDeviceWindowsWave::AttachAudioBuffer(AudioDeviceBuffer* audioBuffer)
 175 {
 176
 177     CriticalSectionScoped lock(&_critSect);
 178
 179     _ptrAudioBuffer = audioBuffer;
 180
 181     // inform the AudioBuffer about default settings for this implementation
 182     _ptrAudioBuffer->SetRecordingSampleRate(N_REC_SAMPLES_PER_SEC);
 183     _ptrAudioBuffer->SetPlayoutSampleRate(N_PLAY_SAMPLES_PER_SEC);
 184     _ptrAudioBuffer->SetRecordingChannels(N_REC_CHANNELS);
 185     _ptrAudioBuffer->SetPlayoutChannels(N_PLAY_CHANNELS);
 186 }
 187
 188 // ----------------------------------------------------------------------------
 189 //  ActiveAudioLayer
 190 // ----------------------------------------------------------------------------
 191
 192 int32_t AudioDeviceWindowsWave::ActiveAudioLayer(AudioDeviceModule::AudioLayer& audioLayer) const
 193 {
 194     audioLayer = AudioDeviceModule::kWindowsWaveAudio;
 195     return 0;
 196 }
 197
 198 // ----------------------------------------------------------------------------
 199 //  Init
 200 // ----------------------------------------------------------------------------
 201
 202 int32_t AudioDeviceWindowsWave::Init()
 203 {
 204
 205     CriticalSectionScoped lock(&_critSect);
 206
 207     if (_initialized)
 208     {
 209         return 0;
 210     }
 211
 212     const uint32_t nowTime(AudioDeviceUtility::GetTimeInMS());
 213
 214     _recordedBytes = 0;
 215     _prevRecByteCheckTime = nowTime;
 216     _prevRecTime = nowTime;
 217     _prevPlayTime = nowTime;
 218     _prevTimerCheckTime = nowTime;
 219
 220     _playWarning = 0;
 221     _playError = 0;
 222     _recWarning = 0;
 223     _recError = 0;
 224
 225     _mixerManager.EnumerateAll();
 226
 227     if (_ptrThread)
 228     {
 229         // thread is already created and active
 230         return 0;
 231     }
 232
 233     const char* threadName = "webrtc_audio_module_thread";
 234     _ptrThread = ThreadWrapper::CreateThread(ThreadFunc,
 235                                              this,
 236                                              kRealtimePriority,
 237                                              threadName);
 238     if (_ptrThread == NULL)
 239     {
 240         WEBRTC_TRACE(kTraceCritical, kTraceAudioDevice, _id,
 241                      "failed to create the audio thread");
 242         return -1;
 243     }
 244
 245     unsigned int threadID(0);
 246     if (!_ptrThread->Start(threadID))
 247     {
 248         WEBRTC_TRACE(kTraceCritical, kTraceAudioDevice, _id,
 249                      "failed to start the audio thread");
 250         delete _ptrThread;
 251         _ptrThread = NULL;
 252         return -1;
 253     }
 254     _threadID = threadID;
 255
 256     const bool periodic(true);
 257     if (!_timeEvent.StartTimer(periodic, TIMER_PERIOD_MS))
 258     {
 259         WEBRTC_TRACE(kTraceCritical, kTraceAudioDevice, _id,
 260                      "failed to start the timer event");
 261         if (_ptrThread->Stop())
 262         {
 263             delete _ptrThread;
 264             _ptrThread = NULL;
 265         }
 266         else
 267         {
 268             WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
 269                          "unable to stop the activated thread");
 270         }
 271         return -1;
 272     }
 273     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
 274                  "periodic timer (dT=%d) is now active", TIMER_PERIOD_MS);
 275
 276     _hGetCaptureVolumeThread = CreateThread(NULL,
 277                                             0,
 278                                             GetCaptureVolumeThread,
 279                                             this,
 280                                             0,
 281                                             NULL);
 282     if (_hGetCaptureVolumeThread == NULL)
 283     {
 284         WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
 285             "  failed to create the volume getter thread");
 286         return -1;
 287     }
 288
 289     SetThreadPriority(_hGetCaptureVolumeThread, THREAD_PRIORITY_NORMAL);
 290
 291     _hSetCaptureVolumeThread = CreateThread(NULL,
 292                                             0,
 293                                             SetCaptureVolumeThread,
 294                                             this,
 295                                             0,
 296                                             NULL);
 297     if (_hSetCaptureVolumeThread == NULL)
 298     {
 299         WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
 300             "  failed to create the volume setter thread");
 301         return -1;
 302     }
 303
 304     SetThreadPriority(_hSetCaptureVolumeThread, THREAD_PRIORITY_NORMAL);
 305
 306     _initialized = true;
 307
 308     return 0;
 309 }
 310
 311 // ----------------------------------------------------------------------------
 312 //  Terminate
 313 // ----------------------------------------------------------------------------
 314
 315 int32_t AudioDeviceWindowsWave::Terminate()
 316 {
 317
 318     if (!_initialized)
 319     {
 320         return 0;
 321     }
 322
 323     _critSect.Enter();
 324
 325     _mixerManager.Close();
 326
 327     if (_ptrThread)
 328     {
 329         ThreadWrapper* tmpThread = _ptrThread;
 330         _ptrThread = NULL;
 331         _critSect.Leave();
 332
 333         tmpThread->SetNotAlive();
 334         _timeEvent.Set();
 335
 336         if (tmpThread->Stop())
 337         {
 338             delete tmpThread;
 339         }
 340         else
 341         {
 342             _critSect.Leave();
 343             WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
 344                          "failed to close down the audio thread");
 345             return -1;
 346         }
 347     }
 348     else
 349     {
 350         _critSect.Leave();
 351     }
 352
 353     _critSect.Enter();
 354     SetEvent(_hShutdownGetVolumeEvent);
 355     _critSect.Leave();
 356     int32_t ret = WaitForSingleObject(_hGetCaptureVolumeThread, 2000);
 357     if (ret != WAIT_OBJECT_0)
 358     {
 359         // the thread did not stop as it should
 360         WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
 361             "  failed to close down volume getter thread");
 362         CloseHandle(_hGetCaptureVolumeThread);
 363         _hGetCaptureVolumeThread = NULL;
 364         return -1;
 365     }
 366     _critSect.Enter();
 367     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
 368         "  volume getter thread is now closed");
 369
 370     SetEvent(_hShutdownSetVolumeEvent);
 371     _critSect.Leave();
 372     ret = WaitForSingleObject(_hSetCaptureVolumeThread, 2000);
 373     if (ret != WAIT_OBJECT_0)
 374     {
 375         // the thread did not stop as it should
 376         WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
 377             "  failed to close down volume setter thread");
 378         CloseHandle(_hSetCaptureVolumeThread);
 379         _hSetCaptureVolumeThread = NULL;
 380         return -1;
 381     }
 382     _critSect.Enter();
 383     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
 384         "  volume setter thread is now closed");
 385
 386     CloseHandle(_hGetCaptureVolumeThread);
 387     _hGetCaptureVolumeThread = NULL;
 388
 389     CloseHandle(_hSetCaptureVolumeThread);
 390     _hSetCaptureVolumeThread = NULL;
 391
 392     _critSect.Leave();
 393
 394     _timeEvent.StopTimer();
 395
 396     _initialized = false;
 397     _outputDeviceIsSpecified = false;
 398     _inputDeviceIsSpecified = false;
 399
 400     return 0;
 401 }
 402
 403
 404 DWORD WINAPI AudioDeviceWindowsWave::GetCaptureVolumeThread(LPVOID context)
 405 {
 406     return(((AudioDeviceWindowsWave*)context)->DoGetCaptureVolumeThread());
 407 }
 408
 409 DWORD WINAPI AudioDeviceWindowsWave::SetCaptureVolumeThread(LPVOID context)
 410 {
 411     return(((AudioDeviceWindowsWave*)context)->DoSetCaptureVolumeThread());
 412 }
 413
 414 DWORD AudioDeviceWindowsWave::DoGetCaptureVolumeThread()
 415 {
 416     HANDLE waitObject = _hShutdownGetVolumeEvent;
 417
 418     while (1)
 419     {
 420         DWORD waitResult = WaitForSingleObject(waitObject,
 421                                                GET_MIC_VOLUME_INTERVAL_MS);
 422         switch (waitResult)
 423         {
 424             case WAIT_OBJECT_0: // _hShutdownGetVolumeEvent
 425                 return 0;
 426             case WAIT_TIMEOUT:  // timeout notification
 427                 break;
 428             default:            // unexpected error
 429                 WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
 430                     "  unknown wait termination on get volume thread");
 431                 return -1;
 432         }
 433
 434         if (AGC())
 435         {
 436             uint32_t currentMicLevel = 0;
 437             if (MicrophoneVolume(currentMicLevel) == 0)
 438             {
 439                 // This doesn't set the system volume, just stores it.
 440                 _critSect.Enter();
 441                 if (_ptrAudioBuffer)
 442                 {
 443                     _ptrAudioBuffer->SetCurrentMicLevel(currentMicLevel);
 444                 }
 445                 _critSect.Leave();
 446             }
 447         }
 448     }
 449 }
 450
 451 DWORD AudioDeviceWindowsWave::DoSetCaptureVolumeThread()
 452 {
 453     HANDLE waitArray[2] = {_hShutdownSetVolumeEvent, _hSetCaptureVolumeEvent};
 454
 455     while (1)
 456     {
 457         DWORD waitResult = WaitForMultipleObjects(2, waitArray, FALSE, INFINITE);
 458         switch (waitResult)
 459         {
 460             case WAIT_OBJECT_0:     // _hShutdownSetVolumeEvent
 461                 return 0;
 462             case WAIT_OBJECT_0 + 1: // _hSetCaptureVolumeEvent
 463                 break;
 464             default:                // unexpected error
 465                 WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
 466                     "  unknown wait termination on set volume thread");
 467                 return -1;
 468         }
 469
 470         _critSect.Enter();
 471         uint32_t newMicLevel = _newMicLevel;
 472         _critSect.Leave();
 473
 474         if (SetMicrophoneVolume(newMicLevel) == -1)
 475         {
 476             WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
 477                 "  the required modification of the microphone volume failed");
 478         }
 479     }
 480     return 0;
 481 }
 482
 483 // ----------------------------------------------------------------------------
 484 //  Initialized
 485 // ----------------------------------------------------------------------------
 486
 487 bool AudioDeviceWindowsWave::Initialized() const
 488 {
 489     return (_initialized);
 490 }
 491
 492 // ----------------------------------------------------------------------------
 493 //  InitSpeaker
 494 // ----------------------------------------------------------------------------
 495
 496 int32_t AudioDeviceWindowsWave::InitSpeaker()
 497 {
 498
 499     CriticalSectionScoped lock(&_critSect);
 500
 501     if (_playing)
 502     {
 503         return -1;
 504     }
 505
 506     if (_mixerManager.EnumerateSpeakers() == -1)
 507     {
 508         // failed to locate any valid/controllable speaker
 509         return -1;
 510     }
 511
 512     if (IsUsingOutputDeviceIndex())
 513     {
 514         if (_mixerManager.OpenSpeaker(OutputDeviceIndex()) == -1)
 515         {
 516             return -1;
 517         }
 518     }
 519     else
 520     {
 521         if (_mixerManager.OpenSpeaker(OutputDevice()) == -1)
 522         {
 523             return -1;
 524         }
 525     }
 526
 527     return 0;
 528 }
 529
 530 // ----------------------------------------------------------------------------
 531 //  InitMicrophone
 532 // ----------------------------------------------------------------------------
 533
 534 int32_t AudioDeviceWindowsWave::InitMicrophone()
 535 {
 536
 537     CriticalSectionScoped lock(&_critSect);
 538
 539     if (_recording)
 540     {
 541         return -1;
 542     }
 543
 544     if (_mixerManager.EnumerateMicrophones() == -1)
 545     {
 546         // failed to locate any valid/controllable microphone
 547         return -1;
 548     }
 549
 550     if (IsUsingInputDeviceIndex())
 551     {
 552         if (_mixerManager.OpenMicrophone(InputDeviceIndex()) == -1)
 553         {
 554             return -1;
 555         }
 556     }
 557     else
 558     {
 559         if (_mixerManager.OpenMicrophone(InputDevice()) == -1)
 560         {
 561             return -1;
 562         }
 563     }
 564
 565     uint32_t maxVol = 0;
 566     if (_mixerManager.MaxMicrophoneVolume(maxVol) == -1)
 567     {
 568         WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
 569             "  unable to retrieve max microphone volume");
 570     }
 571     _maxMicVolume = maxVol;
 572
 573     uint32_t minVol = 0;
 574     if (_mixerManager.MinMicrophoneVolume(minVol) == -1)
 575     {
 576         WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
 577             "  unable to retrieve min microphone volume");
 578     }
 579     _minMicVolume = minVol;
 580
 581     return 0;
 582 }
 583
 584 // ----------------------------------------------------------------------------
 585 //  SpeakerIsInitialized
 586 // ----------------------------------------------------------------------------
 587
 588 bool AudioDeviceWindowsWave::SpeakerIsInitialized() const
 589 {
 590     return (_mixerManager.SpeakerIsInitialized());
 591 }
 592
 593 // ----------------------------------------------------------------------------
 594 //  MicrophoneIsInitialized
 595 // ----------------------------------------------------------------------------
 596
 597 bool AudioDeviceWindowsWave::MicrophoneIsInitialized() const
 598 {
 599     return (_mixerManager.MicrophoneIsInitialized());
 600 }
 601
 602 // ----------------------------------------------------------------------------
 603 //  SpeakerVolumeIsAvailable
 604 // ----------------------------------------------------------------------------
 605
 606 int32_t AudioDeviceWindowsWave::SpeakerVolumeIsAvailable(bool& available)
 607 {
 608
 609     bool isAvailable(false);
 610
 611     // Enumerate all avaliable speakers and make an attempt to open up the
 612     // output mixer corresponding to the currently selected output device.
 613     //
 614     if (InitSpeaker() == -1)
 615     {
 616         // failed to find a valid speaker
 617         available = false;
 618         return 0;
 619     }
 620
 621     // Check if the selected speaker has a volume control
 622     //
 623     _mixerManager.SpeakerVolumeIsAvailable(isAvailable);
 624     available = isAvailable;
 625
 626     // Close the initialized output mixer
 627     //
 628     _mixerManager.CloseSpeaker();
 629
 630     return 0;
 631 }
 632
 633 // ----------------------------------------------------------------------------
 634 //  SetSpeakerVolume
 635 // ----------------------------------------------------------------------------
 636
 637 int32_t AudioDeviceWindowsWave::SetSpeakerVolume(uint32_t volume)
 638 {
 639
 640     return (_mixerManager.SetSpeakerVolume(volume));
 641 }
 642
 643 // ----------------------------------------------------------------------------
 644 //  SpeakerVolume
 645 // ----------------------------------------------------------------------------
 646
 647 int32_t AudioDeviceWindowsWave::SpeakerVolume(uint32_t& volume) const
 648 {
 649
 650     uint32_t level(0);
 651
 652     if (_mixerManager.SpeakerVolume(level) == -1)
 653     {
 654         return -1;
 655     }
 656
 657     volume = level;
 658     return 0;
 659 }
 660
 661 // ----------------------------------------------------------------------------
 662 //  SetWaveOutVolume
 663 //
 664 //    The low-order word contains the left-channel volume setting, and the
 665 //    high-order word contains the right-channel setting.
 666 //    A value of 0xFFFF represents full volume, and a value of 0x0000 is silence.
 667 //
 668 //    If a device does not support both left and right volume control,
 669 //    the low-order word of dwVolume specifies the volume level,
 670 //    and the high-order word is ignored.
 671 //
 672 //    Most devices do not support the full 16 bits of volume-level control
 673 //    and will not use the least-significant bits of the requested volume setting.
 674 //    For example, if a device supports 4 bits of volume control, the values
 675 //    0x4000, 0x4FFF, and 0x43BE will all be truncated to 0x4000.
 676 // ----------------------------------------------------------------------------
 677
 678 int32_t AudioDeviceWindowsWave::SetWaveOutVolume(uint16_t volumeLeft, uint16_t volumeRight)
 679 {
 680
 681     MMRESULT res(0);
 682     WAVEOUTCAPS caps;
 683
 684     CriticalSectionScoped lock(&_critSect);
 685
 686     if (_hWaveOut == NULL)
 687     {
 688         WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "no open playout device exists => using default");
 689     }
 690
 691     // To determine whether the device supports volume control on both
 692     // the left and right channels, use the WAVECAPS_LRVOLUME flag.
 693     //
 694     res = waveOutGetDevCaps((UINT_PTR)_hWaveOut, &caps, sizeof(WAVEOUTCAPS));
 695     if (MMSYSERR_NOERROR != res)
 696     {
 697         WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "waveOutGetDevCaps() failed (err=%d)", res);
 698         TraceWaveOutError(res);
 699     }
 700     if (!(caps.dwSupport & WAVECAPS_VOLUME))
 701     {
 702         // this device does not support volume control using the waveOutSetVolume API
 703         WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, "device does not support volume control using the Wave API");
 704         return -1;
 705     }
 706     if (!(caps.dwSupport & WAVECAPS_LRVOLUME))
 707     {
 708         // high-order word (right channel) is ignored
 709         WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "device does not support volume control on both channels");
 710     }
 711
 712     DWORD dwVolume(0x00000000);
 713     dwVolume = (DWORD)(((volumeRight & 0xFFFF) << 16) | (volumeLeft & 0xFFFF));
 714
 715     res = waveOutSetVolume(_hWaveOut, dwVolume);
 716     if (MMSYSERR_NOERROR != res)
 717     {
 718         WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, "waveOutSetVolume() failed (err=%d)", res);
 719         TraceWaveOutError(res);
 720         return -1;
 721     }
 722
 723     return 0;
 724 }
 725
 726 // ----------------------------------------------------------------------------
 727 //  WaveOutVolume
 728 //
 729 //    The low-order word of this location contains the left-channel volume setting,
 730 //    and the high-order word contains the right-channel setting.
 731 //    A value of 0xFFFF (65535) represents full volume, and a value of 0x0000
 732 //    is silence.
 733 //
 734 //    If a device does not support both left and right volume control,
 735 //    the low-order word of the specified location contains the mono volume level.
 736 //
 737 //    The full 16-bit setting(s) set with the waveOutSetVolume function is returned,
 738 //    regardless of whether the device supports the full 16 bits of volume-level
 739 //    control.
 740 // ----------------------------------------------------------------------------
 741
 742 int32_t AudioDeviceWindowsWave::WaveOutVolume(uint16_t& volumeLeft, uint16_t& volumeRight) const
 743 {
 744
 745     MMRESULT res(0);
 746     WAVEOUTCAPS caps;
 747
 748     CriticalSectionScoped lock(&_critSect);
 749
 750     if (_hWaveOut == NULL)
 751     {
 752         WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "no open playout device exists => using default");
 753     }
 754
 755     // To determine whether the device supports volume control on both
 756     // the left and right channels, use the WAVECAPS_LRVOLUME flag.
 757     //
 758     res = waveOutGetDevCaps((UINT_PTR)_hWaveOut, &caps, sizeof(WAVEOUTCAPS));
 759     if (MMSYSERR_NOERROR != res)
 760     {
 761         WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "waveOutGetDevCaps() failed (err=%d)", res);
 762         TraceWaveOutError(res);
 763     }
 764     if (!(caps.dwSupport & WAVECAPS_VOLUME))
 765     {
 766         // this device does not support volume control using the waveOutSetVolume API
 767         WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, "device does not support volume control using the Wave API");
 768         return -1;
 769     }
 770     if (!(caps.dwSupport & WAVECAPS_LRVOLUME))
 771     {
 772         // high-order word (right channel) is ignored
 773         WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "device does not support volume control on both channels");
 774     }
 775
 776     DWORD dwVolume(0x00000000);
 777
 778     res = waveOutGetVolume(_hWaveOut, &dwVolume);
 779     if (MMSYSERR_NOERROR != res)
 780     {
 781         WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, "waveOutGetVolume() failed (err=%d)", res);
 782         TraceWaveOutError(res);
 783         return -1;
 784     }
 785
 786     WORD wVolumeLeft = LOWORD(dwVolume);
 787     WORD wVolumeRight = HIWORD(dwVolume);
 788
 789     volumeLeft = static_cast<uint16_t> (wVolumeLeft);
 790     volumeRight = static_cast<uint16_t> (wVolumeRight);
 791
 792     return 0;
 793 }
 794
 795 // ----------------------------------------------------------------------------
 796 //  MaxSpeakerVolume
 797 // ----------------------------------------------------------------------------
 798
 799 int32_t AudioDeviceWindowsWave::MaxSpeakerVolume(uint32_t& maxVolume) const
 800 {
 801
 802     uint32_t maxVol(0);
 803
 804     if (_mixerManager.MaxSpeakerVolume(maxVol) == -1)
 805     {
 806         return -1;
 807     }
 808
 809     maxVolume = maxVol;
 810     return 0;
 811 }
 812
 813 // ----------------------------------------------------------------------------
 814 //  MinSpeakerVolume
 815 // ----------------------------------------------------------------------------
 816
 817 int32_t AudioDeviceWindowsWave::MinSpeakerVolume(uint32_t& minVolume) const
 818 {
 819
 820     uint32_t minVol(0);
 821
 822     if (_mixerManager.MinSpeakerVolume(minVol) == -1)
 823     {
 824         return -1;
 825     }
 826
 827     minVolume = minVol;
 828     return 0;
 829 }
 830
 831 // ----------------------------------------------------------------------------
 832 //  SpeakerVolumeStepSize
 833 // ----------------------------------------------------------------------------
 834
 835 int32_t AudioDeviceWindowsWave::SpeakerVolumeStepSize(uint16_t& stepSize) const
 836 {
 837
 838     uint16_t delta(0);
 839
 840     if (_mixerManager.SpeakerVolumeStepSize(delta) == -1)
 841     {
 842         return -1;
 843     }
 844
 845     stepSize = delta;
 846     return 0;
 847 }
 848
 849 // ----------------------------------------------------------------------------
 850 //  SpeakerMuteIsAvailable
 851 // ----------------------------------------------------------------------------
 852
 853 int32_t AudioDeviceWindowsWave::SpeakerMuteIsAvailable(bool& available)
 854 {
 855
 856     bool isAvailable(false);
 857
 858     // Enumerate all avaliable speakers and make an attempt to open up the
 859     // output mixer corresponding to the currently selected output device.
 860     //
 861     if (InitSpeaker() == -1)
 862     {
 863         // If we end up here it means that the selected speaker has no volume
 864         // control, hence it is safe to state that there is no mute control
 865         // already at this stage.
 866         available = false;
 867         return 0;
 868     }
 869
 870     // Check if the selected speaker has a mute control
 871     //
 872     _mixerManager.SpeakerMuteIsAvailable(isAvailable);
 873     available = isAvailable;
 874
 875     // Close the initialized output mixer
 876     //
 877     _mixerManager.CloseSpeaker();
 878
 879     return 0;
 880 }
 881
 882 // ----------------------------------------------------------------------------
 883 //  SetSpeakerMute
 884 // ----------------------------------------------------------------------------
 885
 886 int32_t AudioDeviceWindowsWave::SetSpeakerMute(bool enable)
 887 {
 888     return (_mixerManager.SetSpeakerMute(enable));
 889 }
 890
 891 // ----------------------------------------------------------------------------
 892 //  SpeakerMute
 893 // ----------------------------------------------------------------------------
 894
 895 int32_t AudioDeviceWindowsWave::SpeakerMute(bool& enabled) const
 896 {
 897
 898     bool muted(0);
 899
 900     if (_mixerManager.SpeakerMute(muted) == -1)
 901     {
 902         return -1;
 903     }
 904
 905     enabled = muted;
 906     return 0;
 907 }
 908
 909 // ----------------------------------------------------------------------------
 910 //  MicrophoneMuteIsAvailable
 911 // ----------------------------------------------------------------------------
 912
 913 int32_t AudioDeviceWindowsWave::MicrophoneMuteIsAvailable(bool& available)
 914 {
 915
 916     bool isAvailable(false);
 917
 918     // Enumerate all avaliable microphones and make an attempt to open up the
 919     // input mixer corresponding to the currently selected input device.
 920     //
 921     if (InitMicrophone() == -1)
 922     {
 923         // If we end up here it means that the selected microphone has no volume
 924         // control, hence it is safe to state that there is no boost control
 925         // already at this stage.
 926         available = false;
 927         return 0;
 928     }
 929
 930     // Check if the selected microphone has a mute control
 931     //
 932     _mixerManager.MicrophoneMuteIsAvailable(isAvailable);
 933     available = isAvailable;
 934
 935     // Close the initialized input mixer
 936     //
 937     _mixerManager.CloseMicrophone();
 938
 939     return 0;
 940 }
 941
 942 // ----------------------------------------------------------------------------
 943 //  SetMicrophoneMute
 944 // ----------------------------------------------------------------------------
 945
 946 int32_t AudioDeviceWindowsWave::SetMicrophoneMute(bool enable)
 947 {
 948     return (_mixerManager.SetMicrophoneMute(enable));
 949 }
 950
 951 // ----------------------------------------------------------------------------
 952 //  MicrophoneMute
 953 // ----------------------------------------------------------------------------
 954
 955 int32_t AudioDeviceWindowsWave::MicrophoneMute(bool& enabled) const
 956 {
 957
 958     bool muted(0);
 959
 960     if (_mixerManager.MicrophoneMute(muted) == -1)
 961     {
 962         return -1;
 963     }
 964
 965     enabled = muted;
 966     return 0;
 967 }
 968
 969 // ----------------------------------------------------------------------------
 970 //  MicrophoneBoostIsAvailable
 971 // ----------------------------------------------------------------------------
 972
 973 int32_t AudioDeviceWindowsWave::MicrophoneBoostIsAvailable(bool& available)
 974 {
 975
 976     bool isAvailable(false);
 977
 978     // Enumerate all avaliable microphones and make an attempt to open up the
 979     // input mixer corresponding to the currently selected input device.
 980     //
 981     if (InitMicrophone() == -1)
 982     {
 983         // If we end up here it means that the selected microphone has no volume
 984         // control, hence it is safe to state that there is no boost control
 985         // already at this stage.
 986         available = false;
 987         return 0;
 988     }
 989
 990     // Check if the selected microphone has a boost control
 991     //
 992     _mixerManager.MicrophoneBoostIsAvailable(isAvailable);
 993     available = isAvailable;
 994
 995     // Close the initialized input mixer
 996     //
 997     _mixerManager.CloseMicrophone();
 998
 999     return 0;
1000 }
1001
1002 // ----------------------------------------------------------------------------
1003 //  SetMicrophoneBoost
1004 // ----------------------------------------------------------------------------
1005
1006 int32_t AudioDeviceWindowsWave::SetMicrophoneBoost(bool enable)
1007 {
1008
1009     return (_mixerManager.SetMicrophoneBoost(enable));
1010 }
1011
1012 // ----------------------------------------------------------------------------
1013 //  MicrophoneBoost
1014 // ----------------------------------------------------------------------------
1015
1016 int32_t AudioDeviceWindowsWave::MicrophoneBoost(bool& enabled) const
1017 {
1018
1019     bool onOff(0);
1020
1021     if (_mixerManager.MicrophoneBoost(onOff) == -1)
1022     {
1023         return -1;
1024     }
1025
1026     enabled = onOff;
1027     return 0;
1028 }
1029
1030 // ----------------------------------------------------------------------------
1031 //  StereoRecordingIsAvailable
1032 // ----------------------------------------------------------------------------
1033
1034 int32_t AudioDeviceWindowsWave::StereoRecordingIsAvailable(bool& available)
1035 {
1036     available = true;
1037     return 0;
1038 }
1039
1040 // ----------------------------------------------------------------------------
1041 //  SetStereoRecording
1042 // ----------------------------------------------------------------------------
1043
1044 int32_t AudioDeviceWindowsWave::SetStereoRecording(bool enable)
1045 {
1046
1047     if (enable)
1048         _recChannels = 2;
1049     else
1050         _recChannels = 1;
1051
1052     return 0;
1053 }
1054
1055 // ----------------------------------------------------------------------------
1056 //  StereoRecording
1057 // ----------------------------------------------------------------------------
1058
1059 int32_t AudioDeviceWindowsWave::StereoRecording(bool& enabled) const
1060 {
1061
1062     if (_recChannels == 2)
1063         enabled = true;
1064     else
1065         enabled = false;
1066
1067     return 0;
1068 }
1069
1070 // ----------------------------------------------------------------------------
1071 //  StereoPlayoutIsAvailable
1072 // ----------------------------------------------------------------------------
1073
1074 int32_t AudioDeviceWindowsWave::StereoPlayoutIsAvailable(bool& available)
1075 {
1076     available = true;
1077     return 0;
1078 }
1079
1080 // ----------------------------------------------------------------------------
1081 //  SetStereoPlayout
1082 //
1083 //  Specifies the number of output channels.
1084 //
1085 //  NOTE - the setting will only have an effect after InitPlayout has
1086 //  been called.
1087 //
1088 //  16-bit mono:
1089 //
1090 //  Each sample is 2 bytes. Sample 1 is followed by samples 2, 3, 4, and so on.
1091 //  For each sample, the first byte is the low-order byte of channel 0 and the
1092 //  second byte is the high-order byte of channel 0.
1093 //
1094 //  16-bit stereo:
1095 //
1096 //  Each sample is 4 bytes. Sample 1 is followed by samples 2, 3, 4, and so on.
1097 //  For each sample, the first byte is the low-order byte of channel 0 (left channel);
1098 //  the second byte is the high-order byte of channel 0; the third byte is the
1099 //  low-order byte of channel 1 (right channel); and the fourth byte is the
1100 //  high-order byte of channel 1.
1101 // ----------------------------------------------------------------------------
1102
1103 int32_t AudioDeviceWindowsWave::SetStereoPlayout(bool enable)
1104 {
1105
1106     if (enable)
1107         _playChannels = 2;
1108     else
1109         _playChannels = 1;
1110
1111     return 0;
1112 }
1113
1114 // ----------------------------------------------------------------------------
1115 //  StereoPlayout
1116 // ----------------------------------------------------------------------------
1117
1118 int32_t AudioDeviceWindowsWave::StereoPlayout(bool& enabled) const
1119 {
1120
1121     if (_playChannels == 2)
1122         enabled = true;
1123     else
1124         enabled = false;
1125
1126     return 0;
1127 }
1128
1129 // ----------------------------------------------------------------------------
1130 //  SetAGC
1131 // ----------------------------------------------------------------------------
1132
1133 int32_t AudioDeviceWindowsWave::SetAGC(bool enable)
1134 {
1135
1136     _AGC = enable;
1137
1138     return 0;
1139 }
1140
1141 // ----------------------------------------------------------------------------
1142 //  AGC
1143 // ----------------------------------------------------------------------------
1144
1145 bool AudioDeviceWindowsWave::AGC() const
1146 {
1147     return _AGC;
1148 }
1149
1150 // ----------------------------------------------------------------------------
1151 //  MicrophoneVolumeIsAvailable
1152 // ----------------------------------------------------------------------------
1153
1154 int32_t AudioDeviceWindowsWave::MicrophoneVolumeIsAvailable(bool& available)
1155 {
1156
1157     bool isAvailable(false);
1158
1159     // Enumerate all avaliable microphones and make an attempt to open up the
1160     // input mixer corresponding to the currently selected output device.
1161     //
1162     if (InitMicrophone() == -1)
1163     {
1164         // Failed to find valid microphone
1165         available = false;
1166         return 0;
1167     }
1168
1169     // Check if the selected microphone has a volume control
1170     //
1171     _mixerManager.MicrophoneVolumeIsAvailable(isAvailable);
1172     available = isAvailable;
1173
1174     // Close the initialized input mixer
1175     //
1176     _mixerManager.CloseMicrophone();
1177
1178     return 0;
1179 }
1180
1181 // ----------------------------------------------------------------------------
1182 //  SetMicrophoneVolume
1183 // ----------------------------------------------------------------------------
1184
1185 int32_t AudioDeviceWindowsWave::SetMicrophoneVolume(uint32_t volume)
1186 {
1187     return (_mixerManager.SetMicrophoneVolume(volume));
1188 }
1189
1190 // ----------------------------------------------------------------------------
1191 //  MicrophoneVolume
1192 // ----------------------------------------------------------------------------
1193
1194 int32_t AudioDeviceWindowsWave::MicrophoneVolume(uint32_t& volume) const
1195 {
1196     uint32_t level(0);
1197
1198     if (_mixerManager.MicrophoneVolume(level) == -1)
1199     {
1200         WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "failed to retrive current microphone level");
1201         return -1;
1202     }
1203
1204     volume = level;
1205     return 0;
1206 }
1207
1208 // ----------------------------------------------------------------------------
1209 //  MaxMicrophoneVolume
1210 // ----------------------------------------------------------------------------
1211
1212 int32_t AudioDeviceWindowsWave::MaxMicrophoneVolume(uint32_t& maxVolume) const
1213 {
1214     // _maxMicVolume can be zero in AudioMixerManager::MaxMicrophoneVolume():
1215     // (1) API GetLineControl() returns failure at querying the max Mic level.
1216     // (2) API GetLineControl() returns maxVolume as zero in rare cases.
1217     // Both cases show we don't have access to the mixer controls.
1218     // We return -1 here to indicate that.
1219     if (_maxMicVolume == 0)
1220     {
1221         return -1;
1222     }
1223
1224     maxVolume = _maxMicVolume;;
1225     return 0;
1226 }
1227
1228 // ----------------------------------------------------------------------------
1229 //  MinMicrophoneVolume
1230 // ----------------------------------------------------------------------------
1231
1232 int32_t AudioDeviceWindowsWave::MinMicrophoneVolume(uint32_t& minVolume) const
1233 {
1234     minVolume = _minMicVolume;
1235     return 0;
1236 }
1237
1238 // ----------------------------------------------------------------------------
1239 //  MicrophoneVolumeStepSize
1240 // ----------------------------------------------------------------------------
1241
1242 int32_t AudioDeviceWindowsWave::MicrophoneVolumeStepSize(uint16_t& stepSize) const
1243 {
1244
1245     uint16_t delta(0);
1246
1247     if (_mixerManager.MicrophoneVolumeStepSize(delta) == -1)
1248     {
1249         return -1;
1250     }
1251
1252     stepSize = delta;
1253     return 0;
1254 }
1255
1256 // ----------------------------------------------------------------------------
1257 //  PlayoutDevices
1258 // ----------------------------------------------------------------------------
1259
1260 int16_t AudioDeviceWindowsWave::PlayoutDevices()
1261 {
1262
1263     return (waveOutGetNumDevs());
1264 }
1265
1266 // ----------------------------------------------------------------------------
1267 //  SetPlayoutDevice I (II)
1268 // ----------------------------------------------------------------------------
1269
1270 int32_t AudioDeviceWindowsWave::SetPlayoutDevice(uint16_t index)
1271 {
1272
1273     if (_playIsInitialized)
1274     {
1275         return -1;
1276     }
1277
1278     UINT nDevices = waveOutGetNumDevs();
1279     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "number of availiable waveform-audio output devices is %u", nDevices);
1280
1281     if (index < 0 || index > (nDevices-1))
1282     {
1283         WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, "device index is out of range [0,%u]", (nDevices-1));
1284         return -1;
1285     }
1286
1287     _usingOutputDeviceIndex = true;
1288     _outputDeviceIndex = index;
1289     _outputDeviceIsSpecified = true;
1290
1291     return 0;
1292 }
1293
1294 // ----------------------------------------------------------------------------
1295 //  SetPlayoutDevice II (II)
1296 // ----------------------------------------------------------------------------
1297
1298 int32_t AudioDeviceWindowsWave::SetPlayoutDevice(AudioDeviceModule::WindowsDeviceType device)
1299 {
1300     if (_playIsInitialized)
1301     {
1302         return -1;
1303     }
1304
1305     if (device == AudioDeviceModule::kDefaultDevice)
1306     {
1307     }
1308     else if (device == AudioDeviceModule::kDefaultCommunicationDevice)
1309     {
1310     }
1311
1312     _usingOutputDeviceIndex = false;
1313     _outputDevice = device;
1314     _outputDeviceIsSpecified = true;
1315
1316     return 0;
1317 }
1318
1319 // ----------------------------------------------------------------------------
1320 //  PlayoutDeviceName
1321 // ----------------------------------------------------------------------------
1322
1323 int32_t AudioDeviceWindowsWave::PlayoutDeviceName(
1324     uint16_t index,
1325     char name[kAdmMaxDeviceNameSize],
1326     char guid[kAdmMaxGuidSize])
1327 {
1328
1329     uint16_t nDevices(PlayoutDevices());
1330
1331     // Special fix for the case when the user asks for the name of the default device.
1332     //
1333     if (index == (uint16_t)(-1))
1334     {
1335         index = 0;
1336     }
1337
1338     if ((index > (nDevices-1)) || (name == NULL))
1339     {
1340         return -1;
1341     }
1342
1343     memset(name, 0, kAdmMaxDeviceNameSize);
1344
1345     if (guid != NULL)
1346     {
1347         memset(guid, 0, kAdmMaxGuidSize);
1348     }
1349
1350     WAVEOUTCAPSW caps;    // szPname member (product name (NULL terminated) is a WCHAR
1351     MMRESULT res;
1352
1353     res = waveOutGetDevCapsW(index, &caps, sizeof(WAVEOUTCAPSW));
1354     if (res != MMSYSERR_NOERROR)
1355     {
1356         WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "waveOutGetDevCapsW() failed (err=%d)", res);
1357         return -1;
1358     }
1359     if (WideCharToMultiByte(CP_UTF8, 0, caps.szPname, -1, name, kAdmMaxDeviceNameSize, NULL, NULL) == 0)
1360     {
1361         WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, "WideCharToMultiByte(CP_UTF8) failed with error code %d - 1", GetLastError());
1362     }
1363
1364     if (guid == NULL)
1365     {
1366         return 0;
1367     }
1368
1369     // It is possible to get the unique endpoint ID string using the Wave API.
1370     // However, it is only supported on Windows Vista and Windows 7.
1371
1372     size_t cbEndpointId(0);
1373
1374     // Get the size (including the terminating null) of the endpoint ID string of the waveOut device.
1375     // Windows Vista supports the DRV_QUERYFUNCTIONINSTANCEIDSIZE and DRV_QUERYFUNCTIONINSTANCEID messages.
1376     res = waveOutMessage((HWAVEOUT)IntToPtr(index),
1377                           DRV_QUERYFUNCTIONINSTANCEIDSIZE,
1378                          (DWORD_PTR)&cbEndpointId, NULL);
1379     if (res != MMSYSERR_NOERROR)
1380     {
1381         // DRV_QUERYFUNCTIONINSTANCEIDSIZE is not supported <=> earlier version of Windows than Vista
1382         WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "waveOutMessage(DRV_QUERYFUNCTIONINSTANCEIDSIZE) failed (err=%d)", res);
1383         TraceWaveOutError(res);
1384         // Best we can do is to copy the friendly name and use it as guid
1385         if (WideCharToMultiByte(CP_UTF8, 0, caps.szPname, -1, guid, kAdmMaxGuidSize, NULL, NULL) == 0)
1386         {
1387             WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, "WideCharToMultiByte(CP_UTF8) failed with error code %d - 2", GetLastError());
1388         }
1389         return 0;
1390     }
1391
1392     // waveOutMessage(DRV_QUERYFUNCTIONINSTANCEIDSIZE) worked => we are on a Vista or Windows 7 device
1393
1394     WCHAR *pstrEndpointId = NULL;
1395     pstrEndpointId = (WCHAR*)CoTaskMemAlloc(cbEndpointId);
1396
1397     // Get the endpoint ID string for this waveOut device.
1398     res = waveOutMessage((HWAVEOUT)IntToPtr(index),
1399                           DRV_QUERYFUNCTIONINSTANCEID,
1400                          (DWORD_PTR)pstrEndpointId,
1401                           cbEndpointId);
1402     if (res != MMSYSERR_NOERROR)
1403     {
1404         WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "waveOutMessage(DRV_QUERYFUNCTIONINSTANCEID) failed (err=%d)", res);
1405         TraceWaveOutError(res);
1406         // Best we can do is to copy the friendly name and use it as guid
1407         if (WideCharToMultiByte(CP_UTF8, 0, caps.szPname, -1, guid, kAdmMaxGuidSize, NULL, NULL) == 0)
1408         {
1409             WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, "WideCharToMultiByte(CP_UTF8) failed with error code %d - 3", GetLastError());
1410         }
1411         CoTaskMemFree(pstrEndpointId);
1412         return 0;
1413     }
1414
1415     if (WideCharToMultiByte(CP_UTF8, 0, pstrEndpointId, -1, guid, kAdmMaxGuidSize, NULL, NULL) == 0)
1416     {
1417         WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, "WideCharToMultiByte(CP_UTF8) failed with error code %d - 4", GetLastError());
1418     }
1419     CoTaskMemFree(pstrEndpointId);
1420
1421     return 0;
1422 }
1423
1424 // ----------------------------------------------------------------------------
1425 //  RecordingDeviceName
1426 // ----------------------------------------------------------------------------
1427
1428 int32_t AudioDeviceWindowsWave::RecordingDeviceName(
1429     uint16_t index,
1430     char name[kAdmMaxDeviceNameSize],
1431     char guid[kAdmMaxGuidSize])
1432 {
1433
1434     uint16_t nDevices(RecordingDevices());
1435
1436     // Special fix for the case when the user asks for the name of the default device.
1437     //
1438     if (index == (uint16_t)(-1))
1439     {
1440         index = 0;
1441     }
1442
1443     if ((index > (nDevices-1)) || (name == NULL))
1444     {
1445         return -1;
1446     }
1447
1448     memset(name, 0, kAdmMaxDeviceNameSize);
1449
1450     if (guid != NULL)
1451     {
1452         memset(guid, 0, kAdmMaxGuidSize);
1453     }
1454
1455     WAVEINCAPSW caps;    // szPname member (product name (NULL terminated) is a WCHAR
1456     MMRESULT res;
1457
1458     res = waveInGetDevCapsW(index, &caps, sizeof(WAVEINCAPSW));
1459     if (res != MMSYSERR_NOERROR)
1460     {
1461         WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "waveInGetDevCapsW() failed (err=%d)", res);
1462         return -1;
1463     }
1464     if (WideCharToMultiByte(CP_UTF8, 0, caps.szPname, -1, name, kAdmMaxDeviceNameSize, NULL, NULL) == 0)
1465     {
1466         WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, "WideCharToMultiByte(CP_UTF8) failed with error code %d - 1", GetLastError());
1467     }
1468
1469     if (guid == NULL)
1470     {
1471         return 0;
1472     }
1473
1474     // It is possible to get the unique endpoint ID string using the Wave API.
1475     // However, it is only supported on Windows Vista and Windows 7.
1476
1477     size_t cbEndpointId(0);
1478
1479     // Get the size (including the terminating null) of the endpoint ID string of the waveOut device.
1480     // Windows Vista supports the DRV_QUERYFUNCTIONINSTANCEIDSIZE and DRV_QUERYFUNCTIONINSTANCEID messages.
1481     res = waveInMessage((HWAVEIN)IntToPtr(index),
1482                          DRV_QUERYFUNCTIONINSTANCEIDSIZE,
1483                         (DWORD_PTR)&cbEndpointId, NULL);
1484     if (res != MMSYSERR_NOERROR)
1485     {
1486         // DRV_QUERYFUNCTIONINSTANCEIDSIZE is not supported <=> earlier version of Windows than Vista
1487         WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "waveInMessage(DRV_QUERYFUNCTIONINSTANCEIDSIZE) failed (err=%d)", res);
1488         TraceWaveInError(res);
1489         // Best we can do is to copy the friendly name and use it as guid
1490         if (WideCharToMultiByte(CP_UTF8, 0, caps.szPname, -1, guid, kAdmMaxGuidSize, NULL, NULL) == 0)
1491         {
1492             WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, "WideCharToMultiByte(CP_UTF8) failed with error code %d - 2", GetLastError());
1493         }
1494         return 0;
1495     }
1496
1497     // waveOutMessage(DRV_QUERYFUNCTIONINSTANCEIDSIZE) worked => we are on a Vista or Windows 7 device
1498
1499     WCHAR *pstrEndpointId = NULL;
1500     pstrEndpointId = (WCHAR*)CoTaskMemAlloc(cbEndpointId);
1501
1502     // Get the endpoint ID string for this waveOut device.
1503     res = waveInMessage((HWAVEIN)IntToPtr(index),
1504                           DRV_QUERYFUNCTIONINSTANCEID,
1505                          (DWORD_PTR)pstrEndpointId,
1506                           cbEndpointId);
1507     if (res != MMSYSERR_NOERROR)
1508     {
1509         WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "waveInMessage(DRV_QUERYFUNCTIONINSTANCEID) failed (err=%d)", res);
1510         TraceWaveInError(res);
1511         // Best we can do is to copy the friendly name and use it as guid
1512         if (WideCharToMultiByte(CP_UTF8, 0, caps.szPname, -1, guid, kAdmMaxGuidSize, NULL, NULL) == 0)
1513         {
1514             WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, "WideCharToMultiByte(CP_UTF8) failed with error code %d - 3", GetLastError());
1515         }
1516         CoTaskMemFree(pstrEndpointId);
1517         return 0;
1518     }
1519
1520     if (WideCharToMultiByte(CP_UTF8, 0, pstrEndpointId, -1, guid, kAdmMaxGuidSize, NULL, NULL) == 0)
1521     {
1522         WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, "WideCharToMultiByte(CP_UTF8) failed with error code %d - 4", GetLastError());
1523     }
1524     CoTaskMemFree(pstrEndpointId);
1525
1526     return 0;
1527 }
1528
1529 // ----------------------------------------------------------------------------
1530 //  RecordingDevices
1531 // ----------------------------------------------------------------------------
1532
1533 int16_t AudioDeviceWindowsWave::RecordingDevices()
1534 {
1535
1536     return (waveInGetNumDevs());
1537 }
1538
1539 // ----------------------------------------------------------------------------
1540 //  SetRecordingDevice I (II)
1541 // ----------------------------------------------------------------------------
1542
1543 int32_t AudioDeviceWindowsWave::SetRecordingDevice(uint16_t index)
1544 {
1545
1546     if (_recIsInitialized)
1547     {
1548         return -1;
1549     }
1550
1551     UINT nDevices = waveInGetNumDevs();
1552     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "number of availiable waveform-audio input devices is %u", nDevices);
1553
1554     if (index < 0 || index > (nDevices-1))
1555     {
1556         WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, "device index is out of range [0,%u]", (nDevices-1));
1557         return -1;
1558     }
1559
1560     _usingInputDeviceIndex = true;
1561     _inputDeviceIndex = index;
1562     _inputDeviceIsSpecified = true;
1563
1564     return 0;
1565 }
1566
1567 // ----------------------------------------------------------------------------
1568 //  SetRecordingDevice II (II)
1569 // ----------------------------------------------------------------------------
1570
1571 int32_t AudioDeviceWindowsWave::SetRecordingDevice(AudioDeviceModule::WindowsDeviceType device)
1572 {
1573     if (device == AudioDeviceModule::kDefaultDevice)
1574     {
1575     }
1576     else if (device == AudioDeviceModule::kDefaultCommunicationDevice)
1577     {
1578     }
1579
1580     if (_recIsInitialized)
1581     {
1582         return -1;
1583     }
1584
1585     _usingInputDeviceIndex = false;
1586     _inputDevice = device;
1587     _inputDeviceIsSpecified = true;
1588
1589     return 0;
1590 }
1591
1592 // ----------------------------------------------------------------------------
1593 //  PlayoutIsAvailable
1594 // ----------------------------------------------------------------------------
1595
1596 int32_t AudioDeviceWindowsWave::PlayoutIsAvailable(bool& available)
1597 {
1598
1599     available = false;
1600
1601     // Try to initialize the playout side
1602     int32_t res = InitPlayout();
1603
1604     // Cancel effect of initialization
1605     StopPlayout();
1606
1607     if (res != -1)
1608     {
1609         available = true;
1610     }
1611
1612     return 0;
1613 }
1614
1615 // ----------------------------------------------------------------------------
1616 //  RecordingIsAvailable
1617 // ----------------------------------------------------------------------------
1618
1619 int32_t AudioDeviceWindowsWave::RecordingIsAvailable(bool& available)
1620 {
1621
1622     available = false;
1623
1624     // Try to initialize the recording side
1625     int32_t res = InitRecording();
1626
1627     // Cancel effect of initialization
1628     StopRecording();
1629
1630     if (res != -1)
1631     {
1632         available = true;
1633     }
1634
1635     return 0;
1636 }
1637
1638 // ----------------------------------------------------------------------------
1639 //  InitPlayout
1640 // ----------------------------------------------------------------------------
1641
1642 int32_t AudioDeviceWindowsWave::InitPlayout()
1643 {
1644
1645     CriticalSectionScoped lock(&_critSect);
1646
1647     if (_playing)
1648     {
1649         return -1;
1650     }
1651
1652     if (!_outputDeviceIsSpecified)
1653     {
1654         return -1;
1655     }
1656
1657     if (_playIsInitialized)
1658     {
1659         return 0;
1660     }
1661
1662     // Initialize the speaker (devices might have been added or removed)
1663     if (InitSpeaker() == -1)
1664     {
1665         WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "InitSpeaker() failed");
1666     }
1667
1668     // Enumerate all availiable output devices
1669     EnumeratePlayoutDevices();
1670
1671     // Start by closing any existing wave-output devices
1672     //
1673     MMRESULT res(MMSYSERR_ERROR);
1674
1675     if (_hWaveOut != NULL)
1676     {
1677         res = waveOutClose(_hWaveOut);
1678         if (MMSYSERR_NOERROR != res)
1679         {
1680             WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "waveOutClose() failed (err=%d)", res);
1681             TraceWaveOutError(res);
1682         }
1683     }
1684
1685     // Set the output wave format
1686     //
1687     WAVEFORMATEX waveFormat;
1688
1689     waveFormat.wFormatTag      = WAVE_FORMAT_PCM;
1690     waveFormat.nChannels       = _playChannels;  // mono <=> 1, stereo <=> 2
1691     waveFormat.nSamplesPerSec  = N_PLAY_SAMPLES_PER_SEC;
1692     waveFormat.wBitsPerSample  = 16;
1693     waveFormat.nBlockAlign     = waveFormat.nChannels * (waveFormat.wBitsPerSample/8);
1694     waveFormat.nAvgBytesPerSec = waveFormat.nSamplesPerSec * waveFormat.nBlockAlign;
1695     waveFormat.cbSize          = 0;
1696
1697     // Open the given waveform-audio output device for playout
1698     //
1699     HWAVEOUT hWaveOut(NULL);
1700
1701     if (IsUsingOutputDeviceIndex())
1702     {
1703         // verify settings first
1704         res = waveOutOpen(NULL, _outputDeviceIndex, &waveFormat, 0, 0, CALLBACK_NULL | WAVE_FORMAT_QUERY);
1705         if (MMSYSERR_NOERROR == res)
1706         {
1707             // open the given waveform-audio output device for recording
1708             res = waveOutOpen(&hWaveOut, _outputDeviceIndex, &waveFormat, 0, 0, CALLBACK_NULL);
1709             WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "opening output device corresponding to device ID %u", _outputDeviceIndex);
1710         }
1711     }
1712     else
1713     {
1714         if (_outputDevice == AudioDeviceModule::kDefaultCommunicationDevice)
1715         {
1716             // check if it is possible to open the default communication device (supported on Windows 7)
1717             res = waveOutOpen(NULL, WAVE_MAPPER, &waveFormat, 0, 0, CALLBACK_NULL | WAVE_MAPPED_DEFAULT_COMMUNICATION_DEVICE | WAVE_FORMAT_QUERY);
1718             if (MMSYSERR_NOERROR == res)
1719             {
1720                 // if so, open the default communication device for real
1721                 res = waveOutOpen(&hWaveOut, WAVE_MAPPER, &waveFormat, 0, 0, CALLBACK_NULL |  WAVE_MAPPED_DEFAULT_COMMUNICATION_DEVICE);
1722                 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "opening default communication device");
1723             }
1724             else
1725             {
1726                 // use default device since default communication device was not avaliable
1727                 res = waveOutOpen(&hWaveOut, WAVE_MAPPER, &waveFormat, 0, 0, CALLBACK_NULL);
1728                 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "unable to open default communication device => using default instead");
1729             }
1730         }
1731         else if (_outputDevice == AudioDeviceModule::kDefaultDevice)
1732         {
1733             // open default device since it has been requested
1734             res = waveOutOpen(NULL, WAVE_MAPPER, &waveFormat, 0, 0, CALLBACK_NULL | WAVE_FORMAT_QUERY);
1735             if (MMSYSERR_NOERROR == res)
1736             {
1737                 res = waveOutOpen(&hWaveOut, WAVE_MAPPER, &waveFormat, 0, 0, CALLBACK_NULL);
1738                 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "opening default output device");
1739             }
1740         }
1741     }
1742
1743     if (MMSYSERR_NOERROR != res)
1744     {
1745         WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, "waveOutOpen() failed (err=%d)", res);
1746         TraceWaveOutError(res);
1747         return -1;
1748     }
1749
1750     // Log information about the aquired output device
1751     //
1752     WAVEOUTCAPS caps;
1753
1754     res = waveOutGetDevCaps((UINT_PTR)hWaveOut, &caps, sizeof(WAVEOUTCAPS));
1755     if (res != MMSYSERR_NOERROR)
1756     {
1757         WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "waveOutGetDevCaps() failed (err=%d)", res);
1758         TraceWaveOutError(res);
1759     }
1760
1761     UINT deviceID(0);
1762     res = waveOutGetID(hWaveOut, &deviceID);
1763     if (res != MMSYSERR_NOERROR)
1764     {
1765         WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "waveOutGetID() failed (err=%d)", res);
1766         TraceWaveOutError(res);
1767     }
1768     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "utilized device ID : %u", deviceID);
1769     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "product name       : %s", caps.szPname);
1770
1771     // Store valid handle for the open waveform-audio output device
1772     _hWaveOut = hWaveOut;
1773
1774     // Store the input wave header as well
1775     _waveFormatOut = waveFormat;
1776
1777     // Prepare wave-out headers
1778     //
1779     const uint8_t bytesPerSample = 2*_playChannels;
1780
1781     for (int n = 0; n < N_BUFFERS_OUT; n++)
1782     {
1783         // set up the output wave header
1784         _waveHeaderOut[n].lpData          = reinterpret_cast<LPSTR>(&_playBuffer[n]);
1785         _waveHeaderOut[n].dwBufferLength  = bytesPerSample*PLAY_BUF_SIZE_IN_SAMPLES;
1786         _waveHeaderOut[n].dwFlags         = 0;
1787         _waveHeaderOut[n].dwLoops         = 0;
1788
1789         memset(_playBuffer[n], 0, bytesPerSample*PLAY_BUF_SIZE_IN_SAMPLES);
1790
1791         // The waveOutPrepareHeader function prepares a waveform-audio data block for playback.
1792         // The lpData, dwBufferLength, and dwFlags members of the WAVEHDR structure must be set
1793         // before calling this function.
1794         //
1795         res = waveOutPrepareHeader(_hWaveOut, &_waveHeaderOut[n], sizeof(WAVEHDR));
1796         if (MMSYSERR_NOERROR != res)
1797         {
1798             WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "waveOutPrepareHeader(%d) failed (err=%d)", n, res);
1799             TraceWaveOutError(res);
1800         }
1801
1802         // perform extra check to ensure that the header is prepared
1803         if (_waveHeaderOut[n].dwFlags != WHDR_PREPARED)
1804         {
1805             WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "waveOutPrepareHeader(%d) failed (dwFlags != WHDR_PREPARED)", n);
1806         }
1807     }
1808
1809     // Mark playout side as initialized
1810     _playIsInitialized = true;
1811
1812     _dTcheckPlayBufDelay = 10;  // check playback buffer delay every 10 ms
1813     _playBufCount = 0;          // index of active output wave header (<=> output buffer index)
1814     _playBufDelay = 80;         // buffer delay/size is initialized to 80 ms and slowly decreased until er < 25
1815     _minPlayBufDelay = 25;      // minimum playout buffer delay
1816     _MAX_minBuffer = 65;        // adaptive minimum playout buffer delay cannot be larger than this value
1817     _intro = 1;                 // Used to make sure that adaption starts after (2000-1700)/100 seconds
1818     _waitCounter = 1700;        // Counter for start of adaption of playback buffer
1819     _erZeroCounter = 0;         // Log how many times er = 0 in consequtive calls to RecTimeProc
1820     _useHeader = 0;             // Counts number of "useHeader" detections. Stops at 2.
1821
1822     _writtenSamples = 0;
1823     _writtenSamplesOld = 0;
1824     _playedSamplesOld = 0;
1825     _sndCardPlayDelay = 0;
1826     _sndCardRecDelay = 0;
1827
1828     WEBRTC_TRACE(kTraceInfo, kTraceUtility, _id,"initial playout status: _playBufDelay=%d, _minPlayBufDelay=%d",
1829         _playBufDelay, _minPlayBufDelay);
1830
1831     return 0;
1832 }
1833
1834 // ----------------------------------------------------------------------------
1835 //  InitRecording
1836 // ----------------------------------------------------------------------------
1837
1838 int32_t AudioDeviceWindowsWave::InitRecording()
1839 {
1840
1841     CriticalSectionScoped lock(&_critSect);
1842
1843     if (_recording)
1844     {
1845         return -1;
1846     }
1847
1848     if (!_inputDeviceIsSpecified)
1849     {
1850         return -1;
1851     }
1852
1853     if (_recIsInitialized)
1854     {
1855         return 0;
1856     }
1857
1858     _avgCPULoad = 0;
1859     _playAcc  = 0;
1860
1861     // Initialize the microphone (devices might have been added or removed)
1862     if (InitMicrophone() == -1)
1863     {
1864         WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "InitMicrophone() failed");
1865     }
1866
1867     // Enumerate all availiable input devices
1868     EnumerateRecordingDevices();
1869
1870     // Start by closing any existing wave-input devices
1871     //
1872     MMRESULT res(MMSYSERR_ERROR);
1873
1874     if (_hWaveIn != NULL)
1875     {
1876         res = waveInClose(_hWaveIn);
1877         if (MMSYSERR_NOERROR != res)
1878         {
1879             WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "waveInClose() failed (err=%d)", res);
1880             TraceWaveInError(res);
1881         }
1882     }
1883
1884     // Set the input wave format
1885     //
1886     WAVEFORMATEX waveFormat;
1887
1888     waveFormat.wFormatTag      = WAVE_FORMAT_PCM;
1889     waveFormat.nChannels       = _recChannels;  // mono <=> 1, stereo <=> 2
1890     waveFormat.nSamplesPerSec  = N_REC_SAMPLES_PER_SEC;
1891     waveFormat.wBitsPerSample  = 16;
1892     waveFormat.nBlockAlign     = waveFormat.nChannels * (waveFormat.wBitsPerSample/8);
1893     waveFormat.nAvgBytesPerSec = waveFormat.nSamplesPerSec * waveFormat.nBlockAlign;
1894     waveFormat.cbSize          = 0;
1895
1896     // Open the given waveform-audio input device for recording
1897     //
1898     HWAVEIN hWaveIn(NULL);
1899
1900     if (IsUsingInputDeviceIndex())
1901     {
1902         // verify settings first
1903         res = waveInOpen(NULL, _inputDeviceIndex, &waveFormat, 0, 0, CALLBACK_NULL | WAVE_FORMAT_QUERY);
1904         if (MMSYSERR_NOERROR == res)
1905         {
1906             // open the given waveform-audio input device for recording
1907             res = waveInOpen(&hWaveIn, _inputDeviceIndex, &waveFormat, 0, 0, CALLBACK_NULL);
1908             WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "opening input device corresponding to device ID %u", _inputDeviceIndex);
1909         }
1910     }
1911     else
1912     {
1913         if (_inputDevice == AudioDeviceModule::kDefaultCommunicationDevice)
1914         {
1915             // check if it is possible to open the default communication device (supported on Windows 7)
1916             res = waveInOpen(NULL, WAVE_MAPPER, &waveFormat, 0, 0, CALLBACK_NULL | WAVE_MAPPED_DEFAULT_COMMUNICATION_DEVICE | WAVE_FORMAT_QUERY);
1917             if (MMSYSERR_NOERROR == res)
1918             {
1919                 // if so, open the default communication device for real
1920                 res = waveInOpen(&hWaveIn, WAVE_MAPPER, &waveFormat, 0, 0, CALLBACK_NULL | WAVE_MAPPED_DEFAULT_COMMUNICATION_DEVICE);
1921                 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "opening default communication device");
1922             }
1923             else
1924             {
1925                 // use default device since default communication device was not avaliable
1926                 res = waveInOpen(&hWaveIn, WAVE_MAPPER, &waveFormat, 0, 0, CALLBACK_NULL);
1927                 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "unable to open default communication device => using default instead");
1928             }
1929         }
1930         else if (_inputDevice == AudioDeviceModule::kDefaultDevice)
1931         {
1932             // open default device since it has been requested
1933             res = waveInOpen(NULL, WAVE_MAPPER, &waveFormat, 0, 0, CALLBACK_NULL | WAVE_FORMAT_QUERY);
1934             if (MMSYSERR_NOERROR == res)
1935             {
1936                 res = waveInOpen(&hWaveIn, WAVE_MAPPER, &waveFormat, 0, 0, CALLBACK_NULL);
1937                 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "opening default input device");
1938             }
1939         }
1940     }
1941
1942     if (MMSYSERR_NOERROR != res)
1943     {
1944         WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, "waveInOpen() failed (err=%d)", res);
1945         TraceWaveInError(res);
1946         return -1;
1947     }
1948
1949     // Log information about the aquired input device
1950     //
1951     WAVEINCAPS caps;
1952
1953     res = waveInGetDevCaps((UINT_PTR)hWaveIn, &caps, sizeof(WAVEINCAPS));
1954     if (res != MMSYSERR_NOERROR)
1955     {
1956         WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "waveInGetDevCaps() failed (err=%d)", res);
1957         TraceWaveInError(res);
1958     }
1959
1960     UINT deviceID(0);
1961     res = waveInGetID(hWaveIn, &deviceID);
1962     if (res != MMSYSERR_NOERROR)
1963     {
1964         WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "waveInGetID() failed (err=%d)", res);
1965         TraceWaveInError(res);
1966     }
1967     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "utilized device ID : %u", deviceID);
1968     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "product name       : %s", caps.szPname);
1969
1970     // Store valid handle for the open waveform-audio input device
1971     _hWaveIn = hWaveIn;
1972
1973     // Store the input wave header as well
1974     _waveFormatIn = waveFormat;
1975
1976     // Mark recording side as initialized
1977     _recIsInitialized = true;
1978
1979     _recBufCount = 0;     // index of active input wave header (<=> input buffer index)
1980     _recDelayCount = 0;   // ensures that input buffers are returned with certain delay
1981
1982     return 0;
1983 }
1984
1985 // ----------------------------------------------------------------------------
1986 //  StartRecording
1987 // ----------------------------------------------------------------------------
1988
1989 int32_t AudioDeviceWindowsWave::StartRecording()
1990 {
1991
1992     if (!_recIsInitialized)
1993     {
1994         return -1;
1995     }
1996
1997     if (_recording)
1998     {
1999         return 0;
2000     }
2001
2002     // set state to ensure that the recording starts from the audio thread
2003     _startRec = true;
2004
2005     // the audio thread will signal when recording has stopped
2006     if (kEventTimeout == _recStartEvent.Wait(10000))
2007     {
2008         _startRec = false;
2009         StopRecording();
2010         WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, "failed to activate recording");
2011         return -1;
2012     }
2013
2014     if (_recording)
2015     {
2016         // the recording state is set by the audio thread after recording has started
2017     }
2018     else
2019     {
2020         WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, "failed to activate recording");
2021         return -1;
2022     }
2023
2024     return 0;
2025 }
2026
2027 // ----------------------------------------------------------------------------
2028 //  StopRecording
2029 // ----------------------------------------------------------------------------
2030
2031 int32_t AudioDeviceWindowsWave::StopRecording()
2032 {
2033
2034     CriticalSectionScoped lock(&_critSect);
2035
2036     if (!_recIsInitialized)
2037     {
2038         return 0;
2039     }
2040
2041     if (_hWaveIn == NULL)
2042     {
2043         return -1;
2044     }
2045
2046     bool wasRecording = _recording;
2047     _recIsInitialized = false;
2048     _recording = false;
2049
2050     MMRESULT res;
2051
2052     // Stop waveform-adio input. If there are any buffers in the queue, the
2053     // current buffer will be marked as done (the dwBytesRecorded member in
2054     // the header will contain the length of data), but any empty buffers in
2055     // the queue will remain there.
2056     //
2057     res = waveInStop(_hWaveIn);
2058     if (MMSYSERR_NOERROR != res)
2059     {
2060         WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "waveInStop() failed (err=%d)", res);
2061         TraceWaveInError(res);
2062     }
2063
2064     // Stop input on the given waveform-audio input device and resets the current
2065     // position to zero. All pending buffers are marked as done and returned to
2066     // the application.
2067     //
2068     res = waveInReset(_hWaveIn);
2069     if (MMSYSERR_NOERROR != res)
2070     {
2071         WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "waveInReset() failed (err=%d)", res);
2072         TraceWaveInError(res);
2073     }
2074
2075     // Clean up the preparation performed by the waveInPrepareHeader function.
2076     // Only unprepare header if recording was ever started (and headers are prepared).
2077     //
2078     if (wasRecording)
2079     {
2080         WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "waveInUnprepareHeader() will be performed");
2081         for (int n = 0; n < N_BUFFERS_IN; n++)
2082         {
2083             res = waveInUnprepareHeader(_hWaveIn, &_waveHeaderIn[n], sizeof(WAVEHDR));
2084             if (MMSYSERR_NOERROR != res)
2085             {
2086                 WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "waveInUnprepareHeader() failed (err=%d)", res);
2087                 TraceWaveInError(res);
2088             }
2089         }
2090     }
2091
2092     // Close the given waveform-audio input device.
2093     //
2094     res = waveInClose(_hWaveIn);
2095     if (MMSYSERR_NOERROR != res)
2096     {
2097         WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "waveInClose() failed (err=%d)", res);
2098         TraceWaveInError(res);
2099     }
2100
2101     // Set the wave input handle to NULL
2102     //
2103     _hWaveIn = NULL;
2104     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "_hWaveIn is now set to NULL");
2105
2106     return 0;
2107 }
2108
2109 // ----------------------------------------------------------------------------
2110 //  RecordingIsInitialized
2111 // ----------------------------------------------------------------------------
2112
2113 bool AudioDeviceWindowsWave::RecordingIsInitialized() const
2114 {
2115     return (_recIsInitialized);
2116 }
2117
2118 // ----------------------------------------------------------------------------
2119 //  Recording
2120 // ----------------------------------------------------------------------------
2121
2122 bool AudioDeviceWindowsWave::Recording() const
2123 {
2124     return (_recording);
2125 }
2126
2127 // ----------------------------------------------------------------------------
2128 //  PlayoutIsInitialized
2129 // ----------------------------------------------------------------------------
2130
2131 bool AudioDeviceWindowsWave::PlayoutIsInitialized() const
2132 {
2133     return (_playIsInitialized);
2134 }
2135
2136 // ----------------------------------------------------------------------------
2137 //  StartPlayout
2138 // ----------------------------------------------------------------------------
2139
2140 int32_t AudioDeviceWindowsWave::StartPlayout()
2141 {
2142
2143     if (!_playIsInitialized)
2144     {
2145         return -1;
2146     }
2147
2148     if (_playing)
2149     {
2150         return 0;
2151     }
2152
2153     // set state to ensure that playout starts from the audio thread
2154     _startPlay = true;
2155
2156     // the audio thread will signal when recording has started
2157     if (kEventTimeout == _playStartEvent.Wait(10000))
2158     {
2159         _startPlay = false;
2160         StopPlayout();
2161         WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, "failed to activate playout");
2162         return -1;
2163     }
2164
2165     if (_playing)
2166     {
2167         // the playing state is set by the audio thread after playout has started
2168     }
2169     else
2170     {
2171         WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, "failed to activate playing");
2172         return -1;
2173     }
2174
2175     return 0;
2176 }
2177
2178 // ----------------------------------------------------------------------------
2179 //  StopPlayout
2180 // ----------------------------------------------------------------------------
2181
2182 int32_t AudioDeviceWindowsWave::StopPlayout()
2183 {
2184
2185     CriticalSectionScoped lock(&_critSect);
2186
2187     if (!_playIsInitialized)
2188     {
2189         return 0;
2190     }
2191
2192     if (_hWaveOut == NULL)
2193     {
2194         return -1;
2195     }
2196
2197     _playIsInitialized = false;
2198     _playing = false;
2199     _sndCardPlayDelay = 0;
2200     _sndCardRecDelay = 0;
2201
2202     MMRESULT res;
2203
2204     // The waveOutReset function stops playback on the given waveform-audio
2205     // output device and resets the current position to zero. All pending
2206     // playback buffers are marked as done (WHDR_DONE) and returned to the application.
2207     // After this function returns, the application can send new playback buffers
2208     // to the device by calling waveOutWrite, or close the device by calling waveOutClose.
2209     //
2210     res = waveOutReset(_hWaveOut);
2211     if (MMSYSERR_NOERROR != res)
2212     {
2213         WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "waveOutReset() failed (err=%d)", res);
2214         TraceWaveOutError(res);
2215     }
2216
2217     // The waveOutUnprepareHeader function cleans up the preparation performed
2218     // by the waveOutPrepareHeader function. This function must be called after
2219     // the device driver is finished with a data block.
2220     // You must call this function before freeing the buffer.
2221     //
2222     for (int n = 0; n < N_BUFFERS_OUT; n++)
2223     {
2224         res = waveOutUnprepareHeader(_hWaveOut, &_waveHeaderOut[n], sizeof(WAVEHDR));
2225         if (MMSYSERR_NOERROR != res)
2226         {
2227             WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "waveOutUnprepareHeader() failed (err=%d)", res);
2228             TraceWaveOutError(res);
2229         }
2230     }
2231
2232     // The waveOutClose function closes the given waveform-audio output device.
2233     // The close operation fails if the device is still playing a waveform-audio
2234     // buffer that was previously sent by calling waveOutWrite. Before calling
2235     // waveOutClose, the application must wait for all buffers to finish playing
2236     // or call the waveOutReset function to terminate playback.
2237     //
2238     res = waveOutClose(_hWaveOut);
2239     if (MMSYSERR_NOERROR != res)
2240     {
2241         WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "waveOutClose() failed (err=%d)", res);
2242         TraceWaveOutError(res);
2243     }
2244
2245     _hWaveOut = NULL;
2246     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "_hWaveOut is now set to NULL");
2247
2248     return 0;
2249 }
2250
2251 // ----------------------------------------------------------------------------
2252 //  PlayoutDelay
2253 // ----------------------------------------------------------------------------
2254
2255 int32_t AudioDeviceWindowsWave::PlayoutDelay(uint16_t& delayMS) const
2256 {
2257     CriticalSectionScoped lock(&_critSect);
2258     delayMS = (uint16_t)_sndCardPlayDelay;
2259     return 0;
2260 }
2261
2262 // ----------------------------------------------------------------------------
2263 //  RecordingDelay
2264 // ----------------------------------------------------------------------------
2265
2266 int32_t AudioDeviceWindowsWave::RecordingDelay(uint16_t& delayMS) const
2267 {
2268     CriticalSectionScoped lock(&_critSect);
2269     delayMS = (uint16_t)_sndCardRecDelay;
2270     return 0;
2271 }
2272
2273 // ----------------------------------------------------------------------------
2274 //  Playing
2275 // ----------------------------------------------------------------------------
2276
2277 bool AudioDeviceWindowsWave::Playing() const
2278 {
2279     return (_playing);
2280 }
2281 // ----------------------------------------------------------------------------
2282 //  SetPlayoutBuffer
2283 // ----------------------------------------------------------------------------
2284
2285 int32_t AudioDeviceWindowsWave::SetPlayoutBuffer(const AudioDeviceModule::BufferType type, uint16_t sizeMS)
2286 {
2287     CriticalSectionScoped lock(&_critSect);
2288     _playBufType = type;
2289     if (type == AudioDeviceModule::kFixedBufferSize)
2290     {
2291         _playBufDelayFixed = sizeMS;
2292     }
2293     return 0;
2294 }
2295
2296 // ----------------------------------------------------------------------------
2297 //  PlayoutBuffer
2298 // ----------------------------------------------------------------------------
2299
2300 int32_t AudioDeviceWindowsWave::PlayoutBuffer(AudioDeviceModule::BufferType& type, uint16_t& sizeMS) const
2301 {
2302     CriticalSectionScoped lock(&_critSect);
2303     type = _playBufType;
2304     if (type == AudioDeviceModule::kFixedBufferSize)
2305     {
2306         sizeMS = _playBufDelayFixed;
2307     }
2308     else
2309     {
2310         sizeMS = _playBufDelay;
2311     }
2312
2313     return 0;
2314 }
2315
2316 // ----------------------------------------------------------------------------
2317 //  CPULoad
2318 // ----------------------------------------------------------------------------
2319
2320 int32_t AudioDeviceWindowsWave::CPULoad(uint16_t& load) const
2321 {
2322
2323     load = static_cast<uint16_t>(100*_avgCPULoad);
2324
2325     return 0;
2326 }
2327
2328 // ----------------------------------------------------------------------------
2329 //  PlayoutWarning
2330 // ----------------------------------------------------------------------------
2331
2332 bool AudioDeviceWindowsWave::PlayoutWarning() const
2333 {
2334     return ( _playWarning > 0);
2335 }
2336
2337 // ----------------------------------------------------------------------------
2338 //  PlayoutError
2339 // ----------------------------------------------------------------------------
2340
2341 bool AudioDeviceWindowsWave::PlayoutError() const
2342 {
2343     return ( _playError > 0);
2344 }
2345
2346 // ----------------------------------------------------------------------------
2347 //  RecordingWarning
2348 // ----------------------------------------------------------------------------
2349
2350 bool AudioDeviceWindowsWave::RecordingWarning() const
2351 {
2352     return ( _recWarning > 0);
2353 }
2354
2355 // ----------------------------------------------------------------------------
2356 //  RecordingError
2357 // ----------------------------------------------------------------------------
2358
2359 bool AudioDeviceWindowsWave::RecordingError() const
2360 {
2361     return ( _recError > 0);
2362 }
2363
2364 // ----------------------------------------------------------------------------
2365 //  ClearPlayoutWarning
2366 // ----------------------------------------------------------------------------
2367
2368 void AudioDeviceWindowsWave::ClearPlayoutWarning()
2369 {
2370     _playWarning = 0;
2371 }
2372
2373 // ----------------------------------------------------------------------------
2374 //  ClearPlayoutError
2375 // ----------------------------------------------------------------------------
2376
2377 void AudioDeviceWindowsWave::ClearPlayoutError()
2378 {
2379     _playError = 0;
2380 }
2381
2382 // ----------------------------------------------------------------------------
2383 //  ClearRecordingWarning
2384 // ----------------------------------------------------------------------------
2385
2386 void AudioDeviceWindowsWave::ClearRecordingWarning()
2387 {
2388     _recWarning = 0;
2389 }
2390
2391 // ----------------------------------------------------------------------------
2392 //  ClearRecordingError
2393 // ----------------------------------------------------------------------------
2394
2395 void AudioDeviceWindowsWave::ClearRecordingError()
2396 {
2397     _recError = 0;
2398 }
2399
2400 // ============================================================================
2401 //                                 Private Methods
2402 // ============================================================================
2403
2404 // ----------------------------------------------------------------------------
2405 //  InputSanityCheckAfterUnlockedPeriod
2406 // ----------------------------------------------------------------------------
2407
2408 int32_t AudioDeviceWindowsWave::InputSanityCheckAfterUnlockedPeriod() const
2409 {
2410     if (_hWaveIn == NULL)
2411     {
2412         WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, "input state has been modified during unlocked period");
2413         return -1;
2414     }
2415     return 0;
2416 }
2417
2418 // ----------------------------------------------------------------------------
2419 //  OutputSanityCheckAfterUnlockedPeriod
2420 // ----------------------------------------------------------------------------
2421
2422 int32_t AudioDeviceWindowsWave::OutputSanityCheckAfterUnlockedPeriod() const
2423 {
2424     if (_hWaveOut == NULL)
2425     {
2426         WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, "output state has been modified during unlocked period");
2427         return -1;
2428     }
2429     return 0;
2430 }
2431
2432 // ----------------------------------------------------------------------------
2433 //  EnumeratePlayoutDevices
2434 // ----------------------------------------------------------------------------
2435
2436 int32_t AudioDeviceWindowsWave::EnumeratePlayoutDevices()
2437 {
2438
2439     uint16_t nDevices(PlayoutDevices());
2440     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "===============================================================");
2441     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "#output devices: %u", nDevices);
2442
2443     WAVEOUTCAPS caps;
2444     MMRESULT res;
2445
2446     for (UINT deviceID = 0; deviceID < nDevices; deviceID++)
2447     {
2448         res = waveOutGetDevCaps(deviceID, &caps, sizeof(WAVEOUTCAPS));
2449         if (res != MMSYSERR_NOERROR)
2450         {
2451             WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "waveOutGetDevCaps() failed (err=%d)", res);
2452         }
2453
2454         WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "===============================================================");
2455         WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "Device ID %u:", deviceID);
2456         WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "manufacturer ID      : %u", caps.wMid);
2457         WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "product ID           : %u",caps.wPid);
2458         WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "version of driver    : %u.%u", HIBYTE(caps.vDriverVersion), LOBYTE(caps.vDriverVersion));
2459         WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "product name         : %s", caps.szPname);
2460         WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "dwFormats            : 0x%x", caps.dwFormats);
2461         if (caps.dwFormats & WAVE_FORMAT_48S16)
2462         {
2463             WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "  48kHz,stereo,16bit : SUPPORTED");
2464         }
2465         else
2466         {
2467                 WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, " 48kHz,stereo,16bit  : *NOT* SUPPORTED");
2468         }
2469         if (caps.dwFormats & WAVE_FORMAT_48M16)
2470         {
2471             WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "  48kHz,mono,16bit   : SUPPORTED");
2472         }
2473         else
2474         {
2475                 WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, " 48kHz,mono,16bit    : *NOT* SUPPORTED");
2476         }
2477         WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "wChannels            : %u", caps.wChannels);
2478         TraceSupportFlags(caps.dwSupport);
2479     }
2480
2481     return 0;
2482 }
2483
2484 // ----------------------------------------------------------------------------
2485 //  EnumerateRecordingDevices
2486 // ----------------------------------------------------------------------------
2487
2488 int32_t AudioDeviceWindowsWave::EnumerateRecordingDevices()
2489 {
2490
2491     uint16_t nDevices(RecordingDevices());
2492     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "===============================================================");
2493     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "#input devices: %u", nDevices);
2494
2495     WAVEINCAPS caps;
2496     MMRESULT res;
2497
2498     for (UINT deviceID = 0; deviceID < nDevices; deviceID++)
2499     {
2500         res = waveInGetDevCaps(deviceID, &caps, sizeof(WAVEINCAPS));
2501         if (res != MMSYSERR_NOERROR)
2502         {
2503             WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "waveInGetDevCaps() failed (err=%d)", res);
2504         }
2505
2506         WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "===============================================================");
2507         WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "Device ID %u:", deviceID);
2508         WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "manufacturer ID      : %u", caps.wMid);
2509         WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "product ID           : %u",caps.wPid);
2510         WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "version of driver    : %u.%u", HIBYTE(caps.vDriverVersion), LOBYTE(caps.vDriverVersion));
2511         WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "product name         : %s", caps.szPname);
2512         WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "dwFormats            : 0x%x", caps.dwFormats);
2513         if (caps.dwFormats & WAVE_FORMAT_48S16)
2514         {
2515             WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "  48kHz,stereo,16bit : SUPPORTED");
2516         }
2517         else
2518         {
2519                 WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, " 48kHz,stereo,16bit  : *NOT* SUPPORTED");
2520         }
2521         if (caps.dwFormats & WAVE_FORMAT_48M16)
2522         {
2523             WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "  48kHz,mono,16bit   : SUPPORTED");
2524         }
2525         else
2526         {
2527                 WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, " 48kHz,mono,16bit    : *NOT* SUPPORTED");
2528         }
2529         WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "wChannels            : %u", caps.wChannels);
2530     }
2531
2532     return 0;
2533 }
2534
2535 // ----------------------------------------------------------------------------
2536 //  TraceSupportFlags
2537 // ----------------------------------------------------------------------------
2538
2539 void AudioDeviceWindowsWave::TraceSupportFlags(DWORD dwSupport) const
2540 {
2541     TCHAR buf[256];
2542
2543     StringCchPrintf(buf, 128, TEXT("support flags        : 0x%x "), dwSupport);
2544
2545     if (dwSupport & WAVECAPS_PITCH)
2546     {
2547         // supports pitch control
2548         StringCchCat(buf, 256, TEXT("(PITCH)"));
2549     }
2550     if (dwSupport & WAVECAPS_PLAYBACKRATE)
2551     {
2552         // supports playback rate control
2553         StringCchCat(buf, 256, TEXT("(PLAYBACKRATE)"));
2554     }
2555     if (dwSupport & WAVECAPS_VOLUME)
2556     {
2557         // supports volume control
2558         StringCchCat(buf, 256, TEXT("(VOLUME)"));
2559     }
2560     if (dwSupport & WAVECAPS_LRVOLUME)
2561     {
2562         // supports separate left and right volume control
2563         StringCchCat(buf, 256, TEXT("(LRVOLUME)"));
2564     }
2565     if (dwSupport & WAVECAPS_SYNC)
2566     {
2567         // the driver is synchronous and will block while playing a buffer
2568         StringCchCat(buf, 256, TEXT("(SYNC)"));
2569     }
2570     if (dwSupport & WAVECAPS_SAMPLEACCURATE)
2571     {
2572         // returns sample-accurate position information
2573         StringCchCat(buf, 256, TEXT("(SAMPLEACCURATE)"));
2574     }
2575
2576     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "%S", buf);
2577 }
2578
2579 // ----------------------------------------------------------------------------
2580 //  TraceWaveInError
2581 // ----------------------------------------------------------------------------
2582
2583 void AudioDeviceWindowsWave::TraceWaveInError(MMRESULT error) const
2584 {
2585     TCHAR buf[MAXERRORLENGTH];
2586     TCHAR msg[MAXERRORLENGTH];
2587
2588     StringCchPrintf(buf, MAXERRORLENGTH, TEXT("Error details: "));
2589     waveInGetErrorText(error, msg, MAXERRORLENGTH);
2590     StringCchCat(buf, MAXERRORLENGTH, msg);
2591     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "%S", buf);
2592 }
2593
2594 // ----------------------------------------------------------------------------
2595 //  TraceWaveOutError
2596 // ----------------------------------------------------------------------------
2597
2598 void AudioDeviceWindowsWave::TraceWaveOutError(MMRESULT error) const
2599 {
2600     TCHAR buf[MAXERRORLENGTH];
2601     TCHAR msg[MAXERRORLENGTH];
2602
2603     StringCchPrintf(buf, MAXERRORLENGTH, TEXT("Error details: "));
2604     waveOutGetErrorText(error, msg, MAXERRORLENGTH);
2605     StringCchCat(buf, MAXERRORLENGTH, msg);
2606     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "%S", buf);
2607 }
2608
2609 // ----------------------------------------------------------------------------
2610 //  PrepareStartPlayout
2611 // ----------------------------------------------------------------------------
2612
2613 int32_t AudioDeviceWindowsWave::PrepareStartPlayout()
2614 {
2615
2616     CriticalSectionScoped lock(&_critSect);
2617
2618     if (_hWaveOut == NULL)
2619     {
2620         return -1;
2621     }
2622
2623     // A total of 30ms of data is immediately placed in the SC buffer
2624     //
2625     int8_t zeroVec[4*PLAY_BUF_SIZE_IN_SAMPLES];  // max allocation
2626     memset(zeroVec, 0, 4*PLAY_BUF_SIZE_IN_SAMPLES);
2627
2628     {
2629         Write(zeroVec, PLAY_BUF_SIZE_IN_SAMPLES);
2630         Write(zeroVec, PLAY_BUF_SIZE_IN_SAMPLES);
2631         Write(zeroVec, PLAY_BUF_SIZE_IN_SAMPLES);
2632     }
2633
2634     _playAcc = 0;
2635     _playWarning = 0;
2636     _playError = 0;
2637     _dc_diff_mean = 0;
2638     _dc_y_prev = 0;
2639     _dc_penalty_counter = 20;
2640     _dc_prevtime = 0;
2641     _dc_prevplay = 0;
2642
2643     return 0;
2644 }
2645
2646 // ----------------------------------------------------------------------------
2647 //  PrepareStartRecording
2648 // ----------------------------------------------------------------------------
2649
2650 int32_t AudioDeviceWindowsWave::PrepareStartRecording()
2651 {
2652
2653     CriticalSectionScoped lock(&_critSect);
2654
2655     if (_hWaveIn == NULL)
2656     {
2657         return -1;
2658     }
2659
2660     _playAcc = 0;
2661     _recordedBytes = 0;
2662     _recPutBackDelay = REC_PUT_BACK_DELAY;
2663
2664     MMRESULT res;
2665     MMTIME mmtime;
2666     mmtime.wType = TIME_SAMPLES;
2667
2668     res = waveInGetPosition(_hWaveIn, &mmtime, sizeof(mmtime));
2669     if (MMSYSERR_NOERROR != res)
2670     {
2671         WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "waveInGetPosition(TIME_SAMPLES) failed (err=%d)", res);
2672         TraceWaveInError(res);
2673     }
2674
2675     _read_samples = mmtime.u.sample;
2676     _read_samples_old = _read_samples;
2677     _rec_samples_old = mmtime.u.sample;
2678     _wrapCounter = 0;
2679
2680     for (int n = 0; n < N_BUFFERS_IN; n++)
2681     {
2682         const uint8_t nBytesPerSample = 2*_recChannels;
2683
2684         // set up the input wave header
2685         _waveHeaderIn[n].lpData          = reinterpret_cast<LPSTR>(&_recBuffer[n]);
2686         _waveHeaderIn[n].dwBufferLength  = nBytesPerSample * REC_BUF_SIZE_IN_SAMPLES;
2687         _waveHeaderIn[n].dwFlags         = 0;
2688         _waveHeaderIn[n].dwBytesRecorded = 0;
2689         _waveHeaderIn[n].dwUser          = 0;
2690
2691         memset(_recBuffer[n], 0, nBytesPerSample * REC_BUF_SIZE_IN_SAMPLES);
2692
2693         // prepare a buffer for waveform-audio input
2694         res = waveInPrepareHeader(_hWaveIn, &_waveHeaderIn[n], sizeof(WAVEHDR));
2695         if (MMSYSERR_NOERROR != res)
2696         {
2697             WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "waveInPrepareHeader(%d) failed (err=%d)", n, res);
2698             TraceWaveInError(res);
2699         }
2700
2701         // send an input buffer to the given waveform-audio input device
2702         res = waveInAddBuffer(_hWaveIn, &_waveHeaderIn[n], sizeof(WAVEHDR));
2703         if (MMSYSERR_NOERROR != res)
2704         {
2705             WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "waveInAddBuffer(%d) failed (err=%d)", n, res);
2706             TraceWaveInError(res);
2707         }
2708     }
2709
2710     // start input on the given waveform-audio input device
2711     res = waveInStart(_hWaveIn);
2712     if (MMSYSERR_NOERROR != res)
2713     {
2714         WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "waveInStart() failed (err=%d)", res);
2715         TraceWaveInError(res);
2716     }
2717
2718     return 0;
2719 }
2720
2721 // ----------------------------------------------------------------------------
2722 //  GetPlayoutBufferDelay
2723 // ----------------------------------------------------------------------------
2724
2725 int32_t AudioDeviceWindowsWave::GetPlayoutBufferDelay(uint32_t& writtenSamples, uint32_t& playedSamples)
2726 {
2727     int i;
2728     int ms_Header;
2729     long playedDifference;
2730     int msecInPlayoutBuffer(0);   // #milliseconds of audio in the playout buffer
2731
2732     const uint16_t nSamplesPerMs = (uint16_t)(N_PLAY_SAMPLES_PER_SEC/1000);  // default is 48000/1000 = 48
2733
2734     MMRESULT res;
2735     MMTIME mmtime;
2736
2737     if (!_playing)
2738     {
2739         playedSamples = 0;
2740         return (0);
2741     }
2742
2743     // Retrieve the current playback position.
2744     //
2745     mmtime.wType = TIME_SAMPLES;  // number of waveform-audio samples
2746     res = waveOutGetPosition(_hWaveOut, &mmtime, sizeof(mmtime));
2747     if (MMSYSERR_NOERROR != res)
2748     {
2749         WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "waveOutGetPosition() failed (err=%d)", res);
2750         TraceWaveOutError(res);
2751     }
2752
2753     writtenSamples = _writtenSamples;   // #samples written to the playout buffer
2754     playedSamples = mmtime.u.sample;    // current playout position in the playout buffer
2755
2756     // derive remaining amount (in ms) of data in the playout buffer
2757     msecInPlayoutBuffer = ((writtenSamples - playedSamples)/nSamplesPerMs);
2758
2759     playedDifference = (long) (_playedSamplesOld - playedSamples);
2760
2761     if (playedDifference > 64000)
2762     {
2763         // If the sound cards number-of-played-out-samples variable wraps around before
2764         // written_sampels wraps around this needs to be adjusted. This can happen on
2765         // sound cards that uses less than 32 bits to keep track of number of played out
2766         // sampels. To avoid being fooled by sound cards that sometimes produces false
2767         // output we compare old value minus the new value with a large value. This is
2768         // neccessary because some SC:s produce an output like 153, 198, 175, 230 which
2769         // would trigger the wrap-around function if we didn't compare with a large value.
2770         // The value 64000 is chosen because 2^16=65536 so we allow wrap around at 16 bits.
2771
2772         i = 31;
2773         while((_playedSamplesOld <= (unsigned long)POW2(i)) && (i > 14)) {
2774             i--;
2775         }
2776
2777         if((i < 31) && (i > 14)) {
2778             // Avoid adjusting when there is 32-bit wrap-around since that is
2779             // something neccessary.
2780             //
2781             WEBRTC_TRACE(kTraceDebug, kTraceUtility, _id, "msecleft() => wrap around occured: %d bits used by sound card)", (i+1));
2782
2783             _writtenSamples = _writtenSamples - POW2(i + 1);
2784             writtenSamples = _writtenSamples;
2785             msecInPlayoutBuffer = ((writtenSamples - playedSamples)/nSamplesPerMs);
2786         }
2787     }
2788     else if ((_writtenSamplesOld > POW2(31)) && (writtenSamples < 96000))
2789     {
2790         // Wrap around as expected after having used all 32 bits. (But we still
2791         // test if the wrap around happened earlier which it should not)
2792
2793         i = 31;
2794         while (_writtenSamplesOld <= (unsigned long)POW2(i)) {
2795             i--;
2796         }
2797
2798         WEBRTC_TRACE(kTraceDebug, kTraceUtility, _id, "  msecleft() (wrap around occured after having used all 32 bits)");
2799
2800         _writtenSamplesOld = writtenSamples;
2801         _playedSamplesOld = playedSamples;
2802         msecInPlayoutBuffer = (int)((writtenSamples + POW2(i + 1) - playedSamples)/nSamplesPerMs);
2803
2804     }
2805     else if ((writtenSamples < 96000) && (playedSamples > POW2(31)))
2806     {
2807         // Wrap around has, as expected, happened for written_sampels before
2808         // playedSampels so we have to adjust for this until also playedSampels
2809         // has had wrap around.
2810
2811         WEBRTC_TRACE(kTraceDebug, kTraceUtility, _id, "  msecleft() (wrap around occured: correction of output is done)");
2812
2813         _writtenSamplesOld = writtenSamples;
2814         _playedSamplesOld = playedSamples;
2815         msecInPlayoutBuffer = (int)((writtenSamples + POW2(32) - playedSamples)/nSamplesPerMs);
2816     }
2817
2818     _writtenSamplesOld = writtenSamples;
2819     _playedSamplesOld = playedSamples;
2820
2821
2822     // We use the following formaula to track that playout works as it should
2823     // y=playedSamples/48 - timeGetTime();
2824     // y represent the clock drift between system clock and sound card clock - should be fairly stable
2825     // When the exponential mean value of diff(y) goes away from zero something is wrong
2826     // The exponential formula will accept 1% clock drift but not more
2827     // The driver error means that we will play to little audio and have a high negative clock drift
2828     // We kick in our alternative method when the clock drift reaches 20%
2829
2830     int diff,y;
2831     int unsigned time =0;
2832
2833     // If we have other problems that causes playout glitches
2834     // we don't want to switch playout method.
2835     // Check if playout buffer is extremely low, or if we haven't been able to
2836     // exectue our code in more than 40 ms
2837
2838     time = timeGetTime();
2839
2840     if ((msecInPlayoutBuffer < 20) || (time - _dc_prevtime > 40))
2841     {
2842         _dc_penalty_counter = 100;
2843     }
2844
2845     if ((playedSamples != 0))
2846     {
2847         y = playedSamples/48 - time;
2848         if ((_dc_y_prev != 0) && (_dc_penalty_counter == 0))
2849         {
2850             diff = y - _dc_y_prev;
2851             _dc_diff_mean = (990*_dc_diff_mean)/1000 + 10*diff;
2852         }
2853         _dc_y_prev = y;
2854     }
2855
2856     if (_dc_penalty_counter)
2857     {
2858         _dc_penalty_counter--;
2859     }
2860
2861     if (_dc_diff_mean < -200)
2862     {
2863         // Always reset the filter
2864         _dc_diff_mean = 0;
2865
2866         // Problem is detected. Switch delay method and set min buffer to 80.
2867         // Reset the filter and keep monitoring the filter output.
2868         // If issue is detected a second time, increase min buffer to 100.
2869         // If that does not help, we must modify this scheme further.
2870
2871         _useHeader++;
2872         if (_useHeader == 1)
2873         {
2874             _minPlayBufDelay = 80;
2875             _playWarning = 1;   // only warn first time
2876             WEBRTC_TRACE(kTraceInfo, kTraceUtility, -1, "Modification #1: _useHeader = %d, _minPlayBufDelay = %d", _useHeader, _minPlayBufDelay);
2877         }
2878         else if (_useHeader == 2)
2879         {
2880             _minPlayBufDelay = 100;   // add some more safety
2881             WEBRTC_TRACE(kTraceInfo, kTraceUtility, -1, "Modification #2: _useHeader = %d, _minPlayBufDelay = %d", _useHeader, _minPlayBufDelay);
2882         }
2883         else
2884         {
2885             // This state should not be entered... (HA)
2886             WEBRTC_TRACE (kTraceWarning, kTraceUtility, -1, "further actions are required!");
2887         }
2888         if (_playWarning == 1)
2889         {
2890             WEBRTC_TRACE(kTraceWarning, kTraceUtility, _id, "pending playout warning exists");
2891         }
2892         _playWarning = 1;  // triggers callback from module process thread
2893         WEBRTC_TRACE(kTraceWarning, kTraceUtility, _id, "kPlayoutWarning message posted: switching to alternative playout delay method");
2894     }
2895     _dc_prevtime = time;
2896     _dc_prevplay = playedSamples;
2897
2898     // Try a very rough method of looking at how many buffers are still playing
2899     ms_Header = 0;
2900     for (i = 0; i < N_BUFFERS_OUT; i++) {
2901         if ((_waveHeaderOut[i].dwFlags & WHDR_INQUEUE)!=0) {
2902             ms_Header += 10;
2903         }
2904     }
2905
2906     if ((ms_Header-50) > msecInPlayoutBuffer) {
2907         // Test for cases when GetPosition appears to be screwed up (currently just log....)
2908         TCHAR infoStr[300];
2909         if (_no_of_msecleft_warnings%20==0)
2910         {
2911             StringCchPrintf(infoStr, 300, TEXT("writtenSamples=%i, playedSamples=%i, msecInPlayoutBuffer=%i, ms_Header=%i"), writtenSamples, playedSamples, msecInPlayoutBuffer, ms_Header);
2912             WEBRTC_TRACE(kTraceWarning, kTraceUtility, _id, "%S", infoStr);
2913         }
2914         _no_of_msecleft_warnings++;
2915     }
2916
2917     // If this is true we have had a problem with the playout
2918     if (_useHeader > 0)
2919     {
2920         return (ms_Header);
2921     }
2922
2923
2924     if (ms_Header < msecInPlayoutBuffer)
2925     {
2926         if (_no_of_msecleft_warnings % 100 == 0)
2927         {
2928             TCHAR str[300];
2929             StringCchPrintf(str, 300, TEXT("_no_of_msecleft_warnings=%i, msecInPlayoutBuffer=%i ms_Header=%i (minBuffer=%i buffersize=%i writtenSamples=%i playedSamples=%i)"),
2930                 _no_of_msecleft_warnings, msecInPlayoutBuffer, ms_Header, _minPlayBufDelay, _playBufDelay, writtenSamples, playedSamples);
2931             WEBRTC_TRACE(kTraceWarning, kTraceUtility, _id, "%S", str);
2932         }
2933         _no_of_msecleft_warnings++;
2934         ms_Header -= 6; // Round off as we only have 10ms resolution + Header info is usually slightly delayed compared to GetPosition
2935
2936         if (ms_Header < 0)
2937             ms_Header = 0;
2938
2939         return (ms_Header);
2940     }
2941     else
2942     {
2943         return (msecInPlayoutBuffer);
2944     }
2945 }
2946
2947 // ----------------------------------------------------------------------------
2948 //  GetRecordingBufferDelay
2949 // ----------------------------------------------------------------------------
2950
2951 int32_t AudioDeviceWindowsWave::GetRecordingBufferDelay(uint32_t& readSamples, uint32_t& recSamples)
2952 {
2953     long recDifference;
2954     MMTIME mmtime;
2955     MMRESULT mmr;
2956
2957     const uint16_t nSamplesPerMs = (uint16_t)(N_REC_SAMPLES_PER_SEC/1000);  // default is 48000/1000 = 48
2958
2959     // Retrieve the current input position of the given waveform-audio input device
2960     //
2961     mmtime.wType = TIME_SAMPLES;
2962     mmr = waveInGetPosition(_hWaveIn, &mmtime, sizeof(mmtime));
2963     if (MMSYSERR_NOERROR != mmr)
2964     {
2965         WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "waveInGetPosition() failed (err=%d)", mmr);
2966         TraceWaveInError(mmr);
2967     }
2968
2969     readSamples = _read_samples;    // updated for each full fram in RecProc()
2970     recSamples = mmtime.u.sample;   // remaining time in input queue (recorded but not read yet)
2971
2972     recDifference = (long) (_rec_samples_old - recSamples);
2973
2974     if( recDifference > 64000) {
2975         WEBRTC_TRACE (kTraceDebug, kTraceUtility, -1,"WRAP 1 (recDifference =%d)", recDifference);
2976         // If the sound cards number-of-recorded-samples variable wraps around before
2977         // read_sampels wraps around this needs to be adjusted. This can happen on
2978         // sound cards that uses less than 32 bits to keep track of number of played out
2979         // sampels. To avoid being fooled by sound cards that sometimes produces false
2980         // output we compare old value minus the new value with a large value. This is
2981         // neccessary because some SC:s produce an output like 153, 198, 175, 230 which
2982         // would trigger the wrap-around function if we didn't compare with a large value.
2983         // The value 64000 is chosen because 2^16=65536 so we allow wrap around at 16 bits.
2984         //
2985         int i = 31;
2986         while((_rec_samples_old <= (unsigned long)POW2(i)) && (i > 14))
2987             i--;
2988
2989         if((i < 31) && (i > 14)) {
2990             // Avoid adjusting when there is 32-bit wrap-around since that is
2991             // somethying neccessary.
2992             //
2993             _read_samples = _read_samples - POW2(i + 1);
2994             readSamples = _read_samples;
2995             _wrapCounter++;
2996         } else {
2997             WEBRTC_TRACE (kTraceWarning, kTraceUtility, -1,"AEC (_rec_samples_old %d recSamples %d)",_rec_samples_old, recSamples);
2998         }
2999     }
3000
3001     if((_wrapCounter>200)){
3002         // Do nothing, handled later
3003     }
3004     else if((_rec_samples_old > POW2(31)) && (recSamples < 96000)) {
3005         WEBRTC_TRACE (kTraceDebug, kTraceUtility, -1,"WRAP 2 (_rec_samples_old %d recSamples %d)",_rec_samples_old, recSamples);
3006         // Wrap around as expected after having used all 32 bits.
3007         _read_samples_old = readSamples;
3008         _rec_samples_old = recSamples;
3009         _wrapCounter++;
3010         return (int)((recSamples + POW2(32) - readSamples)/nSamplesPerMs);
3011
3012
3013     } else if((recSamples < 96000) && (readSamples > POW2(31))) {
3014         WEBRTC_TRACE (kTraceDebug, kTraceUtility, -1,"WRAP 3 (readSamples %d recSamples %d)",readSamples, recSamples);
3015         // Wrap around has, as expected, happened for rec_sampels before
3016         // readSampels so we have to adjust for this until also readSampels
3017         // has had wrap around.
3018         _read_samples_old = readSamples;
3019         _rec_samples_old = recSamples;
3020         _wrapCounter++;
3021         return (int)((recSamples + POW2(32) - readSamples)/nSamplesPerMs);
3022     }
3023
3024     _read_samples_old = _read_samples;
3025     _rec_samples_old = recSamples;
3026     int res=(((int)_rec_samples_old - (int)_read_samples_old)/nSamplesPerMs);
3027
3028     if((res > 2000)||(res < 0)||(_wrapCounter>200)){
3029         // Reset everything
3030         WEBRTC_TRACE (kTraceWarning, kTraceUtility, -1,"msec_read error (res %d wrapCounter %d)",res, _wrapCounter);
3031         MMTIME mmtime;
3032         mmtime.wType = TIME_SAMPLES;
3033
3034         mmr=waveInGetPosition(_hWaveIn, &mmtime, sizeof(mmtime));
3035         if (mmr != MMSYSERR_NOERROR) {
3036             WEBRTC_TRACE (kTraceWarning, kTraceUtility, -1, "waveInGetPosition failed (mmr=%d)", mmr);
3037         }
3038         _read_samples=mmtime.u.sample;
3039         _read_samples_old=_read_samples;
3040         _rec_samples_old=mmtime.u.sample;
3041
3042         // Guess a decent value
3043         res = 20;
3044     }
3045
3046     _wrapCounter = 0;
3047     return res;
3048 }
3049
3050 // ============================================================================
3051 //                                  Thread Methods
3052 // ============================================================================
3053
3054 // ----------------------------------------------------------------------------
3055 //  ThreadFunc
3056 // ----------------------------------------------------------------------------
3057
3058 bool AudioDeviceWindowsWave::ThreadFunc(void* pThis)
3059 {
3060     return (static_cast<AudioDeviceWindowsWave*>(pThis)->ThreadProcess());
3061 }
3062
3063 // ----------------------------------------------------------------------------
3064 //  ThreadProcess
3065 // ----------------------------------------------------------------------------
3066
3067 bool AudioDeviceWindowsWave::ThreadProcess()
3068 {
3069     uint32_t time(0);
3070     uint32_t playDiff(0);
3071     uint32_t recDiff(0);
3072
3073     LONGLONG playTime(0);
3074     LONGLONG recTime(0);
3075
3076     switch (_timeEvent.Wait(1000))
3077     {
3078     case kEventSignaled:
3079         break;
3080     case kEventError:
3081         WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "EventWrapper::Wait() failed => restarting timer");
3082         _timeEvent.StopTimer();
3083         _timeEvent.StartTimer(true, TIMER_PERIOD_MS);
3084         return true;
3085     case kEventTimeout:
3086         return true;
3087     }
3088
3089     time = AudioDeviceUtility::GetTimeInMS();
3090
3091     if (_startPlay)
3092     {
3093         if (PrepareStartPlayout() == 0)
3094         {
3095             _prevTimerCheckTime = time;
3096             _prevPlayTime = time;
3097             _startPlay = false;
3098             _playing = true;
3099             _playStartEvent.Set();
3100         }
3101     }
3102
3103     if (_startRec)
3104     {
3105         if (PrepareStartRecording() == 0)
3106         {
3107             _prevTimerCheckTime = time;
3108             _prevRecTime = time;
3109             _prevRecByteCheckTime = time;
3110             _startRec = false;
3111             _recording = true;
3112             _recStartEvent.Set();
3113         }
3114     }
3115
3116     if (_playing)
3117     {
3118         playDiff = time - _prevPlayTime;
3119     }
3120
3121     if (_recording)
3122     {
3123         recDiff = time - _prevRecTime;
3124     }
3125
3126     if (_playing || _recording)
3127     {
3128         RestartTimerIfNeeded(time);
3129     }
3130
3131     if (_playing &&
3132         (playDiff > (uint32_t)(_dTcheckPlayBufDelay - 1)) ||
3133         (playDiff < 0))
3134     {
3135         Lock();
3136         if (_playing)
3137         {
3138             if (PlayProc(playTime) == -1)
3139             {
3140                 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, "PlayProc() failed");
3141             }
3142             _prevPlayTime = time;
3143             if (playTime != 0)
3144                 _playAcc += playTime;
3145         }
3146         UnLock();
3147     }
3148
3149     if (_playing && (playDiff > 12))
3150     {
3151         // It has been a long time since we were able to play out, try to
3152         // compensate by calling PlayProc again.
3153         //
3154         Lock();
3155         if (_playing)
3156         {
3157             if (PlayProc(playTime))
3158             {
3159                 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, "PlayProc() failed");
3160             }
3161             _prevPlayTime = time;
3162             if (playTime != 0)
3163                 _playAcc += playTime;
3164         }
3165         UnLock();
3166     }
3167
3168     if (_recording &&
3169        (recDiff > REC_CHECK_TIME_PERIOD_MS) ||
3170        (recDiff < 0))
3171     {
3172         Lock();
3173         if (_recording)
3174         {
3175             int32_t nRecordedBytes(0);
3176             uint16_t maxIter(10);
3177
3178             // Deliver all availiable recorded buffers and update the CPU load measurement.
3179             // We use a while loop here to compensate for the fact that the multi-media timer
3180             // can sometimed enter a "bad state" after hibernation where the resolution is
3181             // reduced from ~1ms to ~10-15 ms.
3182             //
3183             while ((nRecordedBytes = RecProc(recTime)) > 0)
3184             {
3185                 maxIter--;
3186                 _recordedBytes += nRecordedBytes;
3187                 if (recTime && _perfFreq.QuadPart)
3188                 {
3189                     // Measure the average CPU load:
3190                     // This is a simplified expression where an exponential filter is used:
3191                     //   _avgCPULoad = 0.99 * _avgCPULoad + 0.01 * newCPU,
3192                     //   newCPU = (recTime+playAcc)/f is time in seconds
3193                     //   newCPU / 0.01 is the fraction of a 10 ms period
3194                     // The two 0.01 cancels each other.
3195                     // NOTE - assumes 10ms audio buffers.
3196                     //
3197                     _avgCPULoad = (float)(_avgCPULoad*.99 + (recTime+_playAcc)/(double)(_perfFreq.QuadPart));
3198                     _playAcc = 0;
3199                 }
3200                 if (maxIter == 0)
3201                 {
3202                     // If we get this message ofte, our compensation scheme is not sufficient.
3203                     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "failed to compensate for reduced MM-timer resolution");
3204                 }
3205             }
3206
3207             if (nRecordedBytes == -1)
3208             {
3209                 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, "RecProc() failed");
3210             }
3211
3212             _prevRecTime = time;
3213
3214             // Monitor the recording process and generate error/warning callbacks if needed
3215             MonitorRecording(time);
3216         }
3217         UnLock();
3218     }
3219
3220     if (!_recording)
3221     {
3222         _prevRecByteCheckTime = time;
3223         _avgCPULoad = 0;
3224     }
3225
3226     return true;
3227 }
3228
3229 // ----------------------------------------------------------------------------
3230 //  RecProc
3231 // ----------------------------------------------------------------------------
3232
3233 int32_t AudioDeviceWindowsWave::RecProc(LONGLONG& consumedTime)
3234 {
3235     MMRESULT res;
3236     uint32_t bufCount(0);
3237     uint32_t nBytesRecorded(0);
3238
3239     consumedTime = 0;
3240
3241     // count modulo N_BUFFERS_IN (0,1,2,...,(N_BUFFERS_IN-1),0,1,2,..)
3242     if (_recBufCount == N_BUFFERS_IN)
3243     {
3244         _recBufCount = 0;
3245     }
3246
3247     bufCount = _recBufCount;
3248
3249     // take mono/stereo mode into account when deriving size of a full buffer
3250     const uint16_t bytesPerSample = 2*_recChannels;
3251     const uint32_t fullBufferSizeInBytes = bytesPerSample * REC_BUF_SIZE_IN_SAMPLES;
3252
3253     // read number of recorded bytes for the given input-buffer
3254     nBytesRecorded = _waveHeaderIn[bufCount].dwBytesRecorded;
3255
3256     if (nBytesRecorded == fullBufferSizeInBytes ||
3257        (nBytesRecorded > 0))
3258     {
3259         int32_t msecOnPlaySide;
3260         int32_t msecOnRecordSide;
3261         uint32_t writtenSamples;
3262         uint32_t playedSamples;
3263         uint32_t readSamples, recSamples;
3264         bool send = true;
3265
3266         uint32_t nSamplesRecorded = (nBytesRecorded/bytesPerSample);  // divide by 2 or 4 depending on mono or stereo
3267
3268         if (nBytesRecorded == fullBufferSizeInBytes)
3269         {
3270             _timesdwBytes = 0;
3271         }
3272         else
3273         {
3274             // Test if it is stuck on this buffer
3275             _timesdwBytes++;
3276             if (_timesdwBytes < 5)
3277             {
3278                 // keep trying
3279                 return (0);
3280             }
3281             else
3282             {
3283                 WEBRTC_TRACE(kTraceDebug, kTraceUtility, _id,"nBytesRecorded=%d => don't use", nBytesRecorded);
3284                 _timesdwBytes = 0;
3285                 send = false;
3286             }
3287         }
3288
3289         // store the recorded buffer (no action will be taken if the #recorded samples is not a full buffer)
3290         _ptrAudioBuffer->SetRecordedBuffer(_waveHeaderIn[bufCount].lpData, nSamplesRecorded);
3291
3292         // update #samples read
3293         _read_samples += nSamplesRecorded;
3294
3295         // Check how large the playout and recording buffers are on the sound card.
3296         // This info is needed by the AEC.
3297         //
3298         msecOnPlaySide = GetPlayoutBufferDelay(writtenSamples, playedSamples);
3299         msecOnRecordSide = GetRecordingBufferDelay(readSamples, recSamples);
3300
3301         // If we use the alternative playout delay method, skip the clock drift compensation
3302         // since it will be an unreliable estimate and might degrade AEC performance.
3303         int32_t drift = (_useHeader > 0) ? 0 : GetClockDrift(playedSamples, recSamples);
3304
3305         _ptrAudioBuffer->SetVQEData(msecOnPlaySide, msecOnRecordSide, drift);
3306
3307         _ptrAudioBuffer->SetTypingStatus(KeyPressed());
3308
3309         // Store the play and rec delay values for video synchronization
3310         _sndCardPlayDelay = msecOnPlaySide;
3311         _sndCardRecDelay = msecOnRecordSide;
3312
3313         LARGE_INTEGER t1,t2;
3314
3315         if (send)
3316         {
3317             QueryPerformanceCounter(&t1);
3318
3319             // deliver recorded samples at specified sample rate, mic level etc. to the observer using callback
3320             UnLock();
3321             _ptrAudioBuffer->DeliverRecordedData();
3322             Lock();
3323
3324             QueryPerformanceCounter(&t2);
3325
3326             if (InputSanityCheckAfterUnlockedPeriod() == -1)
3327             {
3328                 // assert(false);
3329                 return -1;
3330             }
3331         }
3332
3333         if (_AGC)
3334         {
3335             uint32_t  newMicLevel = _ptrAudioBuffer->NewMicLevel();
3336             if (newMicLevel != 0)
3337             {
3338                 // The VQE will only deliver non-zero microphone levels when a change is needed.
3339                 WEBRTC_TRACE(kTraceStream, kTraceUtility, _id,"AGC change of volume: => new=%u", newMicLevel);
3340
3341                 // We store this outside of the audio buffer to avoid
3342                 // having it overwritten by the getter thread.
3343                 _newMicLevel = newMicLevel;
3344                 SetEvent(_hSetCaptureVolumeEvent);
3345             }
3346         }
3347
3348         // return utilized buffer to queue after specified delay (default is 4)
3349         if (_recDelayCount > (_recPutBackDelay-1))
3350         {
3351             // deley buffer counter to compensate for "put-back-delay"
3352             bufCount = (bufCount + N_BUFFERS_IN - _recPutBackDelay) % N_BUFFERS_IN;
3353
3354             // reset counter so we can make new detection
3355             _waveHeaderIn[bufCount].dwBytesRecorded = 0;
3356
3357             // return the utilized wave-header after certain delay (given by _recPutBackDelay)
3358             res = waveInUnprepareHeader(_hWaveIn, &(_waveHeaderIn[bufCount]), sizeof(WAVEHDR));
3359             if (MMSYSERR_NOERROR != res)
3360             {
3361                 WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "waveInUnprepareHeader(%d) failed (err=%d)", bufCount, res);
3362                 TraceWaveInError(res);
3363             }
3364
3365             // ensure that the utilized header can be used again
3366             res = waveInPrepareHeader(_hWaveIn, &(_waveHeaderIn[bufCount]), sizeof(WAVEHDR));
3367             if (res != MMSYSERR_NOERROR)
3368             {
3369                 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, "waveInPrepareHeader(%d) failed (err=%d)", bufCount, res);
3370                 TraceWaveInError(res);
3371                 return -1;
3372             }
3373
3374             // add the utilized buffer to the queue again
3375             res = waveInAddBuffer(_hWaveIn, &(_waveHeaderIn[bufCount]), sizeof(WAVEHDR));
3376             if (res != MMSYSERR_NOERROR)
3377             {
3378                 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, "waveInAddBuffer(%d) failed (err=%d)", bufCount, res);
3379                 TraceWaveInError(res);
3380                 if (_recPutBackDelay < 50)
3381                 {
3382                     _recPutBackDelay++;
3383                     WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, "_recPutBackDelay increased to %d", _recPutBackDelay);
3384                 }
3385                 else
3386                 {
3387                     if (_recError == 1)
3388                     {
3389                         WEBRTC_TRACE(kTraceWarning, kTraceUtility, _id, "pending recording error exists");
3390                     }
3391                     _recError = 1;  // triggers callback from module process thread
3392                     WEBRTC_TRACE(kTraceError, kTraceUtility, _id, "kRecordingError message posted: _recPutBackDelay=%u", _recPutBackDelay);
3393                 }
3394             }
3395         }  // if (_recDelayCount > (_recPutBackDelay-1))
3396
3397         if (_recDelayCount < (_recPutBackDelay+1))
3398         {
3399             _recDelayCount++;
3400         }
3401
3402         // increase main buffer count since one complete buffer has now been delivered
3403         _recBufCount++;
3404
3405         if (send) {
3406             // Calculate processing time
3407             consumedTime = (int)(t2.QuadPart-t1.QuadPart);
3408             // handle wraps, time should not be higher than a second
3409             if ((consumedTime > _perfFreq.QuadPart) || (consumedTime < 0))
3410                 consumedTime = 0;
3411         }
3412
3413     }  // if ((nBytesRecorded == fullBufferSizeInBytes))
3414
3415     return nBytesRecorded;
3416 }
3417
3418 // ----------------------------------------------------------------------------
3419 //  PlayProc
3420 // ----------------------------------------------------------------------------
3421
3422 int AudioDeviceWindowsWave::PlayProc(LONGLONG& consumedTime)
3423 {
3424     int32_t remTimeMS(0);
3425     int8_t playBuffer[4*PLAY_BUF_SIZE_IN_SAMPLES];
3426     uint32_t writtenSamples(0);
3427     uint32_t playedSamples(0);
3428
3429     LARGE_INTEGER t1;
3430     LARGE_INTEGER t2;
3431
3432     consumedTime = 0;
3433     _waitCounter++;
3434
3435     // Get number of ms of sound that remains in the sound card buffer for playback.
3436     //
3437     remTimeMS = GetPlayoutBufferDelay(writtenSamples, playedSamples);
3438
3439     // The threshold can be adaptive or fixed. The adaptive scheme is updated
3440     // also for fixed mode but the updated threshold is not utilized.
3441     //
3442     const uint16_t thresholdMS =
3443         (_playBufType == AudioDeviceModule::kAdaptiveBufferSize) ? _playBufDelay : _playBufDelayFixed;
3444
3445     if (remTimeMS < thresholdMS + 9)
3446     {
3447         _dTcheckPlayBufDelay = 5;
3448
3449         if (remTimeMS == 0)
3450         {
3451             WEBRTC_TRACE(kTraceInfo, kTraceUtility, _id, "playout buffer is empty => we must adapt...");
3452             if (_waitCounter > 30)
3453             {
3454                 _erZeroCounter++;
3455                 if (_erZeroCounter == 2)
3456                 {
3457                     _playBufDelay += 15;
3458                     _minPlayBufDelay += 20;
3459                     _waitCounter = 50;
3460                     WEBRTC_TRACE(kTraceDebug, kTraceUtility, _id, "New playout states (er=0,erZero=2): minPlayBufDelay=%u, playBufDelay=%u", _minPlayBufDelay, _playBufDelay);
3461                 }
3462                 else if (_erZeroCounter == 3)
3463                 {
3464                     _erZeroCounter = 0;
3465                     _playBufDelay += 30;
3466                     _minPlayBufDelay += 25;
3467                     _waitCounter = 0;
3468                     WEBRTC_TRACE(kTraceDebug, kTraceUtility, _id, "New playout states (er=0, erZero=3): minPlayBufDelay=%u, playBufDelay=%u", _minPlayBufDelay, _playBufDelay);
3469                 }
3470                 else
3471                 {
3472                     _minPlayBufDelay += 10;
3473                     _playBufDelay += 15;
3474                     _waitCounter = 50;
3475                     WEBRTC_TRACE(kTraceDebug, kTraceUtility, _id, "New playout states (er=0, erZero=1): minPlayBufDelay=%u, playBufDelay=%u", _minPlayBufDelay, _playBufDelay);
3476                 }
3477             }
3478         }
3479         else if (remTimeMS < _minPlayBufDelay)
3480         {
3481             // If there is less than 25 ms of audio in the play out buffer
3482             // increase the buffersize limit value. _waitCounter prevents
3483             // _playBufDelay to be increased every time this function is called.
3484
3485             if (_waitCounter > 30)
3486             {
3487                 _playBufDelay += 10;
3488                 if (_intro == 0)
3489                     _waitCounter = 0;
3490                 WEBRTC_TRACE(kTraceDebug, kTraceUtility, _id, "Playout threshold is increased: playBufDelay=%u", _playBufDelay);
3491             }
3492         }
3493         else if (remTimeMS < thresholdMS - 9)
3494         {
3495             _erZeroCounter = 0;
3496         }
3497         else
3498         {
3499             _erZeroCounter = 0;
3500             _dTcheckPlayBufDelay = 10;
3501         }
3502
3503         QueryPerformanceCounter(&t1);   // measure time: START
3504
3505         // Ask for new PCM data to be played out using the AudioDeviceBuffer.
3506         // Ensure that this callback is executed without taking the audio-thread lock.
3507         //
3508         UnLock();
3509         uint32_t nSamples = _ptrAudioBuffer->RequestPlayoutData(PLAY_BUF_SIZE_IN_SAMPLES);
3510         Lock();
3511
3512         if (OutputSanityCheckAfterUnlockedPeriod() == -1)
3513         {
3514             // assert(false);
3515             return -1;
3516         }
3517
3518         nSamples = _ptrAudioBuffer->GetPlayoutData(playBuffer);
3519         if (nSamples != PLAY_BUF_SIZE_IN_SAMPLES)
3520         {
3521             WEBRTC_TRACE(kTraceError, kTraceUtility, _id, "invalid number of output samples(%d)", nSamples);
3522         }
3523
3524         QueryPerformanceCounter(&t2);   // measure time: STOP
3525         consumedTime = (int)(t2.QuadPart - t1.QuadPart);
3526
3527         Write(playBuffer, PLAY_BUF_SIZE_IN_SAMPLES);
3528
3529     }  // if (er < thresholdMS + 9)
3530     else if (thresholdMS + 9 < remTimeMS )
3531     {
3532         _erZeroCounter = 0;
3533         _dTcheckPlayBufDelay = 2;    // check buffer more often
3534         WEBRTC_TRACE(kTraceDebug, kTraceUtility, _id, "Need to check playout buffer more often (dT=%u, remTimeMS=%u)", _dTcheckPlayBufDelay, remTimeMS);
3535     }
3536
3537     // If the buffersize has been stable for 20 seconds try to decrease the buffer size
3538     if (_waitCounter > 2000)
3539     {
3540         _intro = 0;
3541         _playBufDelay--;
3542         _waitCounter = 1990;
3543         WEBRTC_TRACE(kTraceDebug, kTraceUtility, _id, "Playout threshold is decreased: playBufDelay=%u", _playBufDelay);
3544     }
3545
3546     // Limit the minimum sound card (playback) delay to adaptive minimum delay
3547     if (_playBufDelay < _minPlayBufDelay)
3548     {
3549         _playBufDelay = _minPlayBufDelay;
3550         WEBRTC_TRACE(kTraceDebug, kTraceUtility, _id, "Playout threshold is limited to %u", _minPlayBufDelay);
3551     }
3552
3553     // Limit the maximum sound card (playback) delay to 150 ms
3554     if (_playBufDelay > 150)
3555     {
3556         _playBufDelay = 150;
3557         WEBRTC_TRACE(kTraceDebug, kTraceUtility, _id, "Playout threshold is limited to %d", _playBufDelay);
3558     }
3559
3560     // Upper limit of the minimum sound card (playback) delay to 65 ms.
3561     // Deactivated during "useHeader mode" (_useHeader > 0).
3562     if (_minPlayBufDelay > _MAX_minBuffer &&
3563        (_useHeader == 0))
3564     {
3565         _minPlayBufDelay = _MAX_minBuffer;
3566         WEBRTC_TRACE(kTraceDebug, kTraceUtility, _id, "Minimum playout threshold is limited to %d", _MAX_minBuffer);
3567     }
3568
3569     return (0);
3570 }
3571
3572 // ----------------------------------------------------------------------------
3573 //  Write
3574 // ----------------------------------------------------------------------------
3575
3576 int32_t AudioDeviceWindowsWave::Write(int8_t* data, uint16_t nSamples)
3577 {
3578     if (_hWaveOut == NULL)
3579     {
3580         return -1;
3581     }
3582
3583     if (_playIsInitialized)
3584     {
3585         MMRESULT res;
3586
3587         const uint16_t bufCount(_playBufCount);
3588
3589         // Place data in the memory associated with _waveHeaderOut[bufCount]
3590         //
3591         const int16_t nBytes = (2*_playChannels)*nSamples;
3592         memcpy(&_playBuffer[bufCount][0], &data[0], nBytes);
3593
3594         // Send a data block to the given waveform-audio output device.
3595         //
3596         // When the buffer is finished, the WHDR_DONE bit is set in the dwFlags
3597         // member of the WAVEHDR structure. The buffer must be prepared with the
3598         // waveOutPrepareHeader function before it is passed to waveOutWrite.
3599         // Unless the device is paused by calling the waveOutPause function,
3600         // playback begins when the first data block is sent to the device.
3601         //
3602         res = waveOutWrite(_hWaveOut, &_waveHeaderOut[bufCount], sizeof(_waveHeaderOut[bufCount]));
3603         if (MMSYSERR_NOERROR != res)
3604         {
3605             WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, "waveOutWrite(%d) failed (err=%d)", bufCount, res);
3606             TraceWaveOutError(res);
3607
3608             _writeErrors++;
3609             if (_writeErrors > 10)
3610             {
3611                 if (_playError == 1)
3612                 {
3613                     WEBRTC_TRACE(kTraceWarning, kTraceUtility, _id, "pending playout error exists");
3614                 }
3615                 _playError = 1;  // triggers callback from module process thread
3616                 WEBRTC_TRACE(kTraceError, kTraceUtility, _id, "kPlayoutError message posted: _writeErrors=%u", _writeErrors);
3617             }
3618
3619             return -1;
3620         }
3621
3622         _playBufCount = (_playBufCount+1) % N_BUFFERS_OUT;  // increase buffer counter modulo size of total buffer
3623         _writtenSamples += nSamples;                        // each sample is 2 or 4 bytes
3624         _writeErrors = 0;
3625     }
3626
3627     return 0;
3628 }
3629
3630 // ----------------------------------------------------------------------------
3631 //    GetClockDrift
3632 // ----------------------------------------------------------------------------
3633
3634 int32_t AudioDeviceWindowsWave::GetClockDrift(const uint32_t plSamp, const uint32_t rcSamp)
3635 {
3636     int drift = 0;
3637     unsigned int plSampDiff = 0, rcSampDiff = 0;
3638
3639     if (plSamp >= _plSampOld)
3640     {
3641         plSampDiff = plSamp - _plSampOld;
3642     }
3643     else
3644     {
3645         // Wrap
3646         int i = 31;
3647         while(_plSampOld <= (unsigned int)POW2(i))
3648         {
3649             i--;
3650         }
3651
3652         // Add the amount remaining prior to wrapping
3653         plSampDiff = plSamp +  POW2(i + 1) - _plSampOld;
3654     }
3655
3656     if (rcSamp >= _rcSampOld)
3657     {
3658         rcSampDiff = rcSamp - _rcSampOld;
3659     }
3660     else
3661     {   // Wrap
3662         int i = 31;
3663         while(_rcSampOld <= (unsigned int)POW2(i))
3664         {
3665             i--;
3666         }
3667
3668         rcSampDiff = rcSamp +  POW2(i + 1) - _rcSampOld;
3669     }
3670
3671     drift = plSampDiff - rcSampDiff;
3672
3673     _plSampOld = plSamp;
3674     _rcSampOld = rcSamp;
3675
3676     return drift;
3677 }
3678
3679 // ----------------------------------------------------------------------------
3680 //  MonitorRecording
3681 // ----------------------------------------------------------------------------
3682
3683 int32_t AudioDeviceWindowsWave::MonitorRecording(const uint32_t time)
3684 {
3685     const uint16_t bytesPerSample = 2*_recChannels;
3686     const uint32_t nRecordedSamples = _recordedBytes/bytesPerSample;
3687
3688     if (nRecordedSamples > 5*N_REC_SAMPLES_PER_SEC)
3689     {
3690         // 5 seconds of audio has been recorded...
3691         if ((time - _prevRecByteCheckTime) > 5700)
3692         {
3693             // ...and it was more than 5.7 seconds since we last did this check <=>
3694             // we have not been able to record 5 seconds of audio in 5.7 seconds,
3695             // hence a problem should be reported.
3696             // This problem can be related to USB overload.
3697             //
3698             if (_recWarning == 1)
3699             {
3700                 WEBRTC_TRACE(kTraceWarning, kTraceUtility, _id, "pending recording warning exists");
3701             }
3702             _recWarning = 1;  // triggers callback from module process thread
3703             WEBRTC_TRACE(kTraceWarning, kTraceUtility, _id, "kRecordingWarning message posted: time-_prevRecByteCheckTime=%d", time - _prevRecByteCheckTime);
3704         }
3705
3706         _recordedBytes = 0;            // restart "check again when 5 seconds are recorded"
3707         _prevRecByteCheckTime = time;  // reset timer to measure time for recording of 5 seconds
3708     }
3709
3710     if ((time - _prevRecByteCheckTime) > 8000)
3711     {
3712         // It has been more than 8 seconds since we able to confirm that 5 seconds of
3713         // audio was recorded, hence we have not been able to record 5 seconds in
3714         // 8 seconds => the complete recording process is most likely dead.
3715         //
3716         if (_recError == 1)
3717         {
3718             WEBRTC_TRACE(kTraceWarning, kTraceUtility, _id, "pending recording error exists");
3719         }
3720         _recError = 1;  // triggers callback from module process thread
3721         WEBRTC_TRACE(kTraceError, kTraceUtility, _id, "kRecordingError message posted: time-_prevRecByteCheckTime=%d", time - _prevRecByteCheckTime);
3722
3723         _prevRecByteCheckTime = time;
3724     }
3725
3726     return 0;
3727 }
3728
3729 // ----------------------------------------------------------------------------
3730 //  MonitorRecording
3731 //
3732 //  Restart timer if needed (they seem to be messed up after a hibernate).
3733 // ----------------------------------------------------------------------------
3734
3735 int32_t AudioDeviceWindowsWave::RestartTimerIfNeeded(const uint32_t time)
3736 {
3737     const uint32_t diffMS = time - _prevTimerCheckTime;
3738     _prevTimerCheckTime = time;
3739
3740     if (diffMS > 7)
3741     {
3742         // one timer-issue detected...
3743         _timerFaults++;
3744         if (_timerFaults > 5 && _timerRestartAttempts < 2)
3745         {
3746             // Reinitialize timer event if event fails to execute at least every 5ms.
3747             // On some machines it helps and the timer starts working as it should again;
3748             // however, not all machines (we have seen issues on e.g. IBM T60).
3749             // Therefore, the scheme below ensures that we do max 2 attempts to restart the timer.
3750             // For the cases where restart does not do the trick, we compensate for the reduced
3751             // resolution on both the recording and playout sides.
3752             WEBRTC_TRACE(kTraceWarning, kTraceUtility, _id, " timer issue detected => timer is restarted");
3753             _timeEvent.StopTimer();
3754             _timeEvent.StartTimer(true, TIMER_PERIOD_MS);
3755             // make sure timer gets time to start up and we don't kill/start timer serveral times over and over again
3756             _timerFaults = -20;
3757             _timerRestartAttempts++;
3758         }
3759     }
3760     else
3761     {
3762         // restart timer-check scheme since we are OK
3763         _timerFaults = 0;
3764         _timerRestartAttempts = 0;
3765     }
3766
3767     return 0;
3768 }
3769
3770
3771 bool AudioDeviceWindowsWave::KeyPressed() const{
3772
3773   int key_down = 0;
3774   for (int key = VK_SPACE; key < VK_NUMLOCK; key++) {
3775     short res = GetAsyncKeyState(key);
3776     key_down |= res & 0x1; // Get the LSB
3777   }
3778   return (key_down > 0);
3779 }
3780 }  // namespace webrtc