When an audio track is disabled, still pass the data to webrtc for audio processing.

content/renderer/media/webrtc_local_audio_track.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 "content/renderer/media/webrtc_local_audio_track.h"
 
 #include "content/renderer/media/webaudio_capturer_source.h"
 #include "content/renderer/media/webrtc_audio_capturer.h"
 #include "content/renderer/media/webrtc_audio_capturer_sink_owner.h"
 #include "content/renderer/media/webrtc_local_audio_source_provider.h"
@@ skipping 39 matching lines @@
   return false;
 }
 
 }  // namespace.
 
 // This is a temporary audio buffer with parameters used to send data to
 // callbacks.
 class WebRtcLocalAudioTrack::ConfiguredBuffer :
     public base::RefCounted<WebRtcLocalAudioTrack::ConfiguredBuffer> {
  public:
   ConfiguredBuffer() : sink_buffer_size_(0) {}

[no longer working on chromium, 2013/09/27 12:31:52]

, zero_output_(false)

 
   void Initialize(const media::AudioParameters& params) {
     DCHECK(params.IsValid());
     params_ = params;
 
     // Use 10ms as the sink buffer size since that is the native packet size
     // WebRtc is running on.
     sink_buffer_size_ = params.sample_rate() / 100;
     audio_wrapper_ =
         media::AudioBus::Create(params.channels(), sink_buffer_size_);
     buffer_.reset(new int16[sink_buffer_size_ * params.channels()]);
 
     // The size of the FIFO should be at least twice of the source buffer size
     // or twice of the sink buffer size.
     int buffer_size = std::max(
         kMaxNumberOfBuffersInFifo * params.frames_per_buffer(),
         kMaxNumberOfBuffersInFifo * sink_buffer_size_);
     fifo_.reset(new media::AudioFifo(params.channels(), buffer_size));
   }
 
   void Push(media::AudioBus* audio_source) {
     DCHECK(fifo_->frames() + audio_source->frames() <= fifo_->max_frames());

[no longer working on chromium, 2013/09/27 12:31:52]

zero_output_ = false;

     fifo_->Push(audio_source);
   }
 
   bool Consume() {

[no longer working on chromium, 2013/09/27 12:31:52]

add
  if (zero_output_)
    return true;

     if (fifo_->frames() < audio_wrapper_->frames())
       return false;
 
     fifo_->Consume(audio_wrapper_.get(), 0, audio_wrapper_->frames());
     audio_wrapper_->ToInterleaved(audio_wrapper_->frames(),
                                   params_.bits_per_sample() / 8,
                                   buffer());
     return true;
   }
 

[no longer working on chromium, 2013/09/27 12:31:52]

add function:

void ZeroOutput() {
  if (zero_output_)
    return;

  fifo_->Clear();
  memset(buffer_.get(), 0, sink_buffer_size_ * params_.channels() *
sizeof(int16));
  zero_output_ = true;
}

   int16* buffer() const { return buffer_.get(); }
   const media::AudioParameters& params() const { return params_; }
   int sink_buffer_size() const { return sink_buffer_size_; }
 
  private:
   ~ConfiguredBuffer() {}
   friend class base::RefCounted<WebRtcLocalAudioTrack::ConfiguredBuffer>;
 
   media::AudioParameters params_;
   scoped_ptr<media::AudioBus> audio_wrapper_;
   scoped_ptr<media::AudioFifo> fifo_;
   scoped_ptr<int16[]> buffer_;
   int sink_buffer_size_;

[no longer working on chromium, 2013/09/27 12:31:52]

add bool zero_output_;

 };
 
 scoped_refptr<WebRtcLocalAudioTrack> WebRtcLocalAudioTrack::Create(
     const std::string& id,
     const scoped_refptr<WebRtcAudioCapturer>& capturer,
     WebAudioCapturerSource* webaudio_source,
     webrtc::AudioSourceInterface* track_source,
     const webrtc::MediaConstraintsInterface* constraints) {
   talk_base::RefCountedObject<WebRtcLocalAudioTrack>* track =
       new talk_base::RefCountedObject<WebRtcLocalAudioTrack>(
@@ skipping 26 matching lines @@
 void WebRtcLocalAudioTrack::Capture(media::AudioBus* audio_source,
                                     int audio_delay_milliseconds,
                                     int volume,
                                     bool key_pressed) {
   scoped_refptr<WebRtcAudioCapturer> capturer;
   std::vector<int> voe_channels;
   int sample_rate = 0;
   int number_of_channels = 0;
   int number_of_frames = 0;
   SinkList sinks;
   scoped_refptr<ConfiguredBuffer> current_buffer;

[no longer working on chromium, 2013/09/27 12:31:52]

add bool enabled = false;

   {
     base::AutoLock auto_lock(lock_);
     // When the track is disabled, we simply return here.
     // TODO(xians): Figure out if we should feed zero to sinks instead, in
     // order to inject VAD data in such case.
-    if (!enabled())
-      return;
+    if (!enabled()) {

[no longer working on chromium, 2013/09/27 12:31:52]

remove this if check

+      volume = 0;

[no longer working on chromium, 2013/09/26 20:52:31]

This is wrong, it will confuse the APM that the current analog volume is 0, then
APM will set the microphone volume to a value closed to 0. 

+    }
 
     capturer = capturer_;
     voe_channels = voe_channels_;
     current_buffer = buffer_;
     sample_rate = current_buffer->params().sample_rate();
     number_of_channels = current_buffer->params().channels();
     number_of_frames = current_buffer->sink_buffer_size();
     sinks = sinks_;

[no longer working on chromium, 2013/09/27 12:31:52]

enabled = enabled();

   }
 
   // Push the data to the fifo.
   current_buffer->Push(audio_source);

[no longer working on chromium, 2013/09/27 12:31:52]

if (enabled) {
  // Push the data to the fifo.
  current_buffer->Push(audio_source);
} else {
  // add comment
  current_buffer->ZeroOutput();
}

   // Only turn off the audio processing when the constrain is set to false as
   // well as there is no correct delay value.
   bool need_audio_processing = need_audio_processing_ ?
       need_audio_processing_ : (audio_delay_milliseconds != 0);
   int current_volume = volume;
   while (current_buffer->Consume()) {
     // Feed the data to the sinks.
     for (SinkList::const_iterator it = sinks.begin(); it != sinks.end(); ++it) {
       int new_volume = (*it)->CaptureData(voe_channels,
                                           current_buffer->buffer(),
                                           sample_rate,
                                           number_of_channels,
                                           number_of_frames,
                                           audio_delay_milliseconds,
                                           current_volume,
                                           need_audio_processing,
                                           key_pressed);

[no longer working on chromium, 2013/09/27 12:31:52]

if (!enabled)
  break;

       if (new_volume != 0 && capturer.get()) {
         // Feed the new volume to WebRtc while changing the volume on the
         // browser.
         capturer->SetVolume(new_volume);
         current_volume = new_volume;
       }
     }
   }
 }
 
@@ skipping 137 matching lines @@
     sinks = sinks_;
     webaudio_source_ = NULL;
     capturer_ = NULL;
   }
 
   for (SinkList::const_iterator it = sinks.begin(); it != sinks.end(); ++it)
     (*it)->Reset();
 }
 
 }  // namespace content