Modified Windows buffer size to avoid audio glitches.

remoting/host/audio_capturer_win.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <windows.h>
 #include <audioclient.h>
 #include <avrt.h>
 #include <mmdeviceapi.h>
 #include <mmreg.h>
 #include <mmsystem.h>
@@ skipping 16 matching lines @@
 const int kBitsPerSample = 16;
 const int kBitsPerByte = 8;
 // Conversion factor from 100ns to 1ms.
 const int kHnsToMs = 10000;
 
 // Tolerance for catching packets of silence. If all samples have absolute
 // value less than this threshold, the packet will be counted as a packet of
 // silence. A value of 2 was chosen, because Windows can give samples of 1 and
 // -1, even when no audio is playing.
 const int kSilenceThreshold = 2;
+
+// Number of packets that can be stored in the Windows capture buffer.
+// Even if we capture once every |audio_device_period_| * |kWindowsBufferSize|,
+// we will buffer enough to avoid glitches.
+const int kWindowsBufferSize = 10;

[Wez, 2012/08/15 21:32:29]

Why 10? Surely we want to configure things to cope with some maximum
timer-triggering latency, rather than a fixed multiplier of the audio capture
period, which is device-specific?

e.g. If we know we can only do 10ms granularity timers, but that we might see
bursts of 30ms latency between timers, and Windows reports a 5ms audio sample
period then we want 6x buffers.

[kxing, 2012/08/16 17:30:57]

Done.

 }  // namespace
 
 namespace remoting {
 
 class AudioCapturerWin : public AudioCapturer {
  public:
   AudioCapturerWin();
   virtual ~AudioCapturerWin();
 
   // AudioCapturer interface.
@@ skipping 141 matching lines @@
       break;
     }
     default:
       LOG(ERROR) << "Failed to force 16-bit PCM";
       return false;
   }
 
   // Initialize the IAudioClient.
   hr = audio_client_->Initialize(AUDCLNT_SHAREMODE_SHARED,
                                  AUDCLNT_STREAMFLAGS_LOOPBACK,
-                                 0,
+                                 device_period * kWindowsBufferSize,

[Sergey Ulanov, 2012/08/15 21:43:22]

Does this have to be multiple of device_period? Can we just specify the double
of the desired latency. E.g. we could have the buffer allocated for 100ms and
then schedule the timer to pull the data from the buffer every 50ms. That will
also give us enough room in the buffer to cope with timer volatility.

[kxing, 2012/08/16 17:30:57]

Done.

                                  0,
                                  wave_format_ex_,
                                  NULL);
   if (FAILED(hr)) {
     LOG(ERROR) << "Failed to initialize IAudioClient. Error " << hr;
     return false;
   }
 
   // Get an IAudioCaptureClient.
   hr = audio_client_->GetService(__uuidof(IAudioCaptureClient),
                                  audio_capture_client_.ReceiveVoid());
   if (FAILED(hr)) {
     LOG(ERROR) << "Failed to get an IAudioCaptureClient. Error " << hr;
     return false;
   }
 
   // Start the IAudioClient.
   hr = audio_client_->Start();
   if (FAILED(hr)) {
     LOG(ERROR) << "Failed to start IAudioClient. Error " << hr;
     return false;
   }
 
   // Start capturing.
   capture_timer_->Start(FROM_HERE,
                         audio_device_period_,

[Sergey Ulanov, 2012/08/15 21:43:22]

why do we need timer to be scheduled with device_period? I think we should
schedule it to run on some interval that doesn't depend on device period. E.g.
something like 30 or 50 ms. device_period_ might be too short for our purposes.

[Wez, 2012/08/15 21:55:30]

We need to cope with the case where the device period exceeds our hard-coded
timer period; in that case the device will expect to give us sample data in
buffers larger than our timer period would correspond to.

[kxing, 2012/08/16 17:30:57]

Done.

[kxing, 2012/08/16 17:30:57]

Done.

                         this,
                         &AudioCapturerWin::DoCapture);
   return true;
 }
 
 void AudioCapturerWin::Stop() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(IsRunning());
 
   capture_timer_.reset();
@@ skipping 71 matching lines @@
       return false;
   }
   return true;
 }
 
 scoped_ptr<AudioCapturer> AudioCapturer::Create() {
   return scoped_ptr<AudioCapturer>(new AudioCapturerWin());
 }
 
 }  // namespace remoting