Not streaming packets of silence.

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 "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;
+
+// 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;
 }  // 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 AudioPacket* packet);
+
   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_;
@@ skipping 202 matching lines @@
     hr = audio_capture_client_->GetBuffer(
         &data, &frames, &flags, NULL, NULL);
     if (FAILED(hr)) {
       LOG(ERROR) << "Failed to GetBuffer. Error " << hr;
       return;
     }
 
     scoped_ptr<AudioPacket> packet = scoped_ptr<AudioPacket>(new AudioPacket());
     packet->set_data(data, frames * wave_format_ex_->nBlockAlign);
     packet->set_sampling_rate(sampling_rate_);
+    packet->set_bytes_per_sample(
+        static_cast<AudioPacket::BytesPerSample>(sizeof(int16)));
 
-    callback_.Run(packet.Pass());
+    if (!IsPacketOfSilence(packet.get()))
+      callback_.Run(packet.Pass());
 
     hr = audio_capture_client_->ReleaseBuffer(frames);
     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.
+bool AudioCapturerWin::IsPacketOfSilence(const AudioPacket* packet) {
+  DCHECK_EQ(static_cast<AudioPacket::BytesPerSample>(sizeof(int16)),
+            packet->bytes_per_sample());
+  const int16* data = reinterpret_cast<const int16*>(packet->data().data());
+  int number_of_samples = packet->data().size() * kBitsPerByte / kBitsPerSample;
+
+  for (int i = 0; i < number_of_samples; i++) {
+    if (abs(data[i]) > kSilenceThreshold)
+      return false;
+  }
+  return true;
+}
+
 scoped_ptr<AudioCapturer> AudioCapturer::Create() {
   return scoped_ptr<AudioCapturer>(new AudioCapturerWin());
 }
 
 }  // namespace remoting