Silence detection test for the Windows audio capturer.

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 "remoting/host/audio_capturer_win.h"
+
 #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 k100nsPerMillisecond = 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;
 
 // 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.
-  virtual bool Start(const PacketCapturedCallback& callback) OVERRIDE;
-  virtual void Stop() OVERRIDE;
-  virtual bool IsRunning() OVERRIDE;
-
- private:
-  // Receives all packets from the audio capture endpoint buffer and pushes them
-  // to the network.
-  void DoCapture();
-
-  static bool IsPacketOfSilence(const int16* samples, int number_of_samples);
-
-  PacketCapturedCallback callback_;
-
-  AudioPacket::SamplingRate sampling_rate_;
-
-  scoped_ptr<base::RepeatingTimer<AudioCapturerWin> > capture_timer_;
-  base::TimeDelta audio_device_period_;
-
-  base::win::ScopedCoMem<WAVEFORMATEX> wave_format_ex_;
-  base::win::ScopedComPtr<IAudioCaptureClient> audio_capture_client_;
-  base::win::ScopedComPtr<IAudioClient> audio_client_;
-  base::win::ScopedComPtr<IMMDevice> mm_device_;
-  scoped_ptr<base::win::ScopedCOMInitializer> com_initializer_;
-
-  base::ThreadChecker thread_checker_;
-
-  DISALLOW_COPY_AND_ASSIGN(AudioCapturerWin);
-};
-
 AudioCapturerWin::AudioCapturerWin()
     : sampling_rate_(AudioPacket::SAMPLING_RATE_INVALID) {
       thread_checker_.DetachFromThread();
 }
 
 AudioCapturerWin::~AudioCapturerWin() {
 }
 
 bool AudioCapturerWin::Start(const PacketCapturedCallback& callback) {
   DCHECK(!audio_capture_client_.get());
@@ skipping 212 matching lines @@
     if (FAILED(hr)) {
       LOG(ERROR) << "Failed to ReleaseBuffer. Error " << hr;
       return;
     }
   }
 }
 
 // Detects whether there is audio playing in a packet of samples.
 // Windows can give nonzero samples, even when there is no audio playing, so
 // extremely low amplitude samples are counted as silence.
+// static
 bool AudioCapturerWin::IsPacketOfSilence(
     const int16* samples, int number_of_samples) {
   for (int i = 0; i < number_of_samples; i++) {
     if (abs(samples[i]) > kSilenceThreshold)
       return false;
   }
   return true;
 }
 
 scoped_ptr<AudioCapturer> AudioCapturer::Create() {
   return scoped_ptr<AudioCapturer>(new AudioCapturerWin());
 }
 
 }  // namespace remoting