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>
 
+#include <algorithm>
 #include <stdlib.h>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/timer.h"
 #include "base/win/scoped_co_mem.h"
 #include "base/win/scoped_com_initializer.h"
 #include "base/win/scoped_comptr.h"
 #include "remoting/host/audio_capturer.h"
 #include "remoting/proto/audio.pb.h"
 
 namespace {
 const int kChannels = 2;
 const int kBitsPerSample = 16;
 const int kBitsPerByte = 8;
 // Conversion factor from 100ns to 1ms.
-const int kHnsToMs = 10000;
+const int k100nsInMillisecond = 10000;

[Wez, 2012/08/16 20:20:20]

nit: k100nsPerMillisecond, to avoid ambiguity over how "in" is being used here,
and to match the constants above?

[kxing, 2012/08/16 20:38:46]

Done.

 
 // 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;
+
+// Lower bound for timer intervals, in milliseconds.
+const int kMinTimerInterval = 30;
+
+// Upper bound for the timer precision error, in milliseconds.
+// Timers are supposed to be accurate to 20ms, so we use 30ms to be safe.
+const int kMaxExpectedTimerLag = 30;
 }  // namespace
 
 namespace remoting {
 
 class AudioCapturerWin : public AudioCapturer {
  public:
   AudioCapturerWin();
   virtual ~AudioCapturerWin();
 
   // AudioCapturer interface.
@@ skipping 74 matching lines @@
     LOG(ERROR) << "Failed to get an IAudioClient. Error " << hr;
     return false;
   }
 
   REFERENCE_TIME device_period;
   hr = audio_client_->GetDevicePeriod(&device_period, NULL);
   if (FAILED(hr)) {
     LOG(ERROR) << "IAudioClient::GetDevicePeriod failed. Error " << hr;
     return false;
   }
+  // We round up, if |device_period| / |k100nsInMillisecond|
+  // is not a whole number.
+  int device_period_in_milliseconds =
+      1 + (device_period - 1) / k100nsInMillisecond;

[Wez, 2012/08/16 20:20:20]

nit: Bracket the division to make it clear to the reader that we're subtracting
1*100ns, and adding 1ms.

[kxing, 2012/08/16 20:38:46]

Done.

   audio_device_period_ = base::TimeDelta::FromMilliseconds(
-      device_period / kChannels / kHnsToMs);
+      std::max(device_period_in_milliseconds, kMinTimerInterval));
 
   // Get the wave format.
   hr = audio_client_->GetMixFormat(&wave_format_ex_);
   if (FAILED(hr)) {
     LOG(ERROR) << "Failed to get WAVEFORMATEX. Error " << hr;
     return false;
   }
 
   // Set the wave format
   switch (wave_format_ex_->wFormatTag) {
@@ skipping 43 matching lines @@
         return false;
       }
       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,
-                                 0,
-                                 wave_format_ex_,
-                                 NULL);
+  hr = audio_client_->Initialize(
+      AUDCLNT_SHAREMODE_SHARED,
+      AUDCLNT_STREAMFLAGS_LOOPBACK,
+      (kMaxExpectedTimerLag + audio_device_period_.InMilliseconds()) *
+      k100nsInMillisecond,
+      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;
@@ skipping 56 matching lines @@
     UINT32 frames;
     DWORD flags;
     hr = audio_capture_client_->GetBuffer(
         &data, &frames, &flags, NULL, NULL);
     if (FAILED(hr)) {
       LOG(ERROR) << "Failed to GetBuffer. Error " << hr;
       return;
     }
 
     if (!IsPacketOfSilence(
-          reinterpret_cast<const int16*>(data),
-          frames * kChannels)) {
+            reinterpret_cast<const int16*>(data),
+            frames * kChannels)) {
       scoped_ptr<AudioPacket> packet =
           scoped_ptr<AudioPacket>(new AudioPacket());
       packet->add_data(data, frames * wave_format_ex_->nBlockAlign);
       packet->set_sampling_rate(sampling_rate_);
       packet->set_bytes_per_sample(
           static_cast<AudioPacket::BytesPerSample>(sizeof(int16)));
       packet->set_encoding(AudioPacket::ENCODING_RAW);
 
       callback_.Run(packet.Pass());
     }
@@ skipping 16 matching lines @@
       return false;
   }
   return true;
 }
 
 scoped_ptr<AudioCapturer> AudioCapturer::Create() {
   return scoped_ptr<AudioCapturer>(new AudioCapturerWin());
 }
 
 }  // namespace remoting