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/host/audio_capturer_util.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;
 }  // namespace
 
@@ skipping 95 matching lines @@
   if (FAILED(hr)) {
     LOG(ERROR) << "Failed to get WAVEFORMATEX. Error " << hr;
     return false;
   }
 
   // Set the wave format
   switch (wave_format_ex_->wFormatTag) {
     case WAVE_FORMAT_IEEE_FLOAT:
       // Intentional fall-through.
     case WAVE_FORMAT_PCM:
-      if (!AudioCapturer::IsValidSampleRate(wave_format_ex_->nSamplesPerSec)) {
+      if (!IsValidSampleRate(wave_format_ex_->nSamplesPerSec)) {
         LOG(ERROR) << "Host sampling rate is neither 44.1 kHz nor 48 kHz.";
         return false;
       }
       sampling_rate_ = static_cast<AudioPacket::SamplingRate>(
           wave_format_ex_->nSamplesPerSec);
 
       wave_format_ex_->wFormatTag = WAVE_FORMAT_PCM;
       wave_format_ex_->nChannels = kChannels;
       wave_format_ex_->wBitsPerSample = kBitsPerSample;
       wave_format_ex_->nBlockAlign = kChannels * kBitsPerSample / kBitsPerByte;
       wave_format_ex_->nAvgBytesPerSec =
           sampling_rate_ * kChannels * kBitsPerSample / kBitsPerByte;
       break;
     case WAVE_FORMAT_EXTENSIBLE: {
       PWAVEFORMATEXTENSIBLE wave_format_extensible =
           reinterpret_cast<WAVEFORMATEXTENSIBLE*>(
           static_cast<WAVEFORMATEX*>(wave_format_ex_));
       if (IsEqualGUID(KSDATAFORMAT_SUBTYPE_IEEE_FLOAT,
                       wave_format_extensible->SubFormat)) {
-        if (!AudioCapturer::IsValidSampleRate(
-                wave_format_extensible->Format.nSamplesPerSec)) {
+        if (!IsValidSampleRate(wave_format_extensible->Format.nSamplesPerSec)) {
           LOG(ERROR) << "Host sampling rate is neither 44.1 kHz nor 48 kHz.";
           return false;
         }
         sampling_rate_ = static_cast<AudioPacket::SamplingRate>(
             wave_format_extensible->Format.nSamplesPerSec);
 
         wave_format_extensible->SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
         wave_format_extensible->Samples.wValidBitsPerSample = kBitsPerSample;
 
         wave_format_extensible->Format.nChannels = kChannels;
@@ skipping 62 matching lines @@
 
   thread_checker_.DetachFromThread();
 }
 
 bool AudioCapturerWin::IsRunning() {
   DCHECK(thread_checker_.CalledOnValidThread());
   return capture_timer_.get() != NULL;
 }
 
 void AudioCapturerWin::DoCapture() {
-  DCHECK(AudioCapturer::IsValidSampleRate(sampling_rate_));
+  DCHECK(IsValidSampleRate(sampling_rate_));
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(IsRunning());
 
   // Fetch all packets from the audio capture endpoint buffer.
   while (true) {
     UINT32 next_packet_size;
     HRESULT hr = audio_capture_client_->GetNextPacketSize(&next_packet_size);
     if (FAILED(hr)) {
       LOG(ERROR) << "Failed to GetNextPacketSize. Error " << hr;
       return;
@@ skipping 10 matching lines @@
         &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_);
 
-    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;
     }
   }
 }
 
 scoped_ptr<AudioCapturer> AudioCapturer::Create() {
   return scoped_ptr<AudioCapturer>(new AudioCapturerWin());
 }
 
 }  // namespace remoting