Feed the WebRTC APM with empty far-end frames for the number of frames skipped by OS.

content/renderer/media/media_stream_audio_processor.cc

 // Copyright 2013 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/media_stream_audio_processor.h"
 
 #include "base/command_line.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 261 matching lines @@
 };
 
 MediaStreamAudioProcessor::MediaStreamAudioProcessor(
     const blink::WebMediaConstraints& constraints,
     const MediaStreamDevice::AudioDeviceParameters& input_params,
     WebRtcPlayoutDataSource* playout_data_source)
     : render_delay_ms_(0),
       playout_data_source_(playout_data_source),
       audio_mirroring_(false),
       typing_detected_(false),
-      stopped_(false) {
+      stopped_(false),
+      skipped_output_frames_(0) {
   capture_thread_checker_.DetachFromThread();
   render_thread_checker_.DetachFromThread();
   InitializeAudioProcessingModule(constraints, input_params);
 
   aec_dump_message_filter_ = AecDumpMessageFilter::Get();
   // In unit tests not creating a message filter, |aec_dump_message_filter_|
   // will be NULL. We can just ignore that. Other unit tests and browser tests
   // ensure that we do get the filter when we should.
   if (aec_dump_message_filter_.get())
     aec_dump_message_filter_->AddDelegate(this);
@@ skipping 132 matching lines @@
     StopEchoCancellationDump(audio_processing_.get());
 }
 
 void MediaStreamAudioProcessor::OnIpcClosing() {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   aec_dump_message_filter_ = NULL;
 }
 
 void MediaStreamAudioProcessor::OnPlayoutData(media::AudioBus* audio_bus,
                                               int sample_rate,
-                                              int audio_delay_milliseconds) {
+                                              int audio_delay_milliseconds,
+                                              uint32_t skipped_frames) {
   DCHECK(render_thread_checker_.CalledOnValidThread());
   DCHECK(audio_processing_->echo_control_mobile()->is_enabled() ^
          audio_processing_->echo_cancellation()->is_enabled());
 
   TRACE_EVENT0("audio", "MediaStreamAudioProcessor::OnPlayoutData");
   DCHECK_LT(audio_delay_milliseconds,
             std::numeric_limits<base::subtle::Atomic32>::max());
   base::subtle::Release_Store(&render_delay_ms_, audio_delay_milliseconds);
 
   InitializeRenderFifoIfNeeded(sample_rate, audio_bus->channels(),
                                audio_bus->frames());
 
   render_fifo_->Push(
       *audio_bus, base::TimeDelta::FromMilliseconds(audio_delay_milliseconds));
+
+  // Feed the APM with empty frames if frames have been skipped. The APM only
+  // accepts 10 ms chunks.
+  skipped_output_frames_ += skipped_frames;
+  uint32_t frames_per_10ms = static_cast<uint32_t>(sample_rate / 100);
+  if (skipped_output_frames_ > frames_per_10ms) {
+    MediaStreamAudioBus empty_bus(audio_bus->channels(), frames_per_10ms);
+    empty_bus.bus()->Zero();
+    while (skipped_output_frames_ > frames_per_10ms) {
+      audio_processing_->AnalyzeReverseStream(
+          empty_bus.channel_ptrs(),
+          empty_bus.bus()->frames(),
+          sample_rate,
+          ChannelsToLayout(empty_bus.bus()->channels()));
+      skipped_output_frames_ -= frames_per_10ms;
+    }
+  }
+
+  // Pull data from the fifo and feed the APM.
   MediaStreamAudioBus* analysis_bus;
   base::TimeDelta audio_delay;
   while (render_fifo_->Consume(&analysis_bus, &audio_delay)) {
     // TODO(ajm): Should AnalyzeReverseStream() account for the |audio_delay|?
     audio_processing_->AnalyzeReverseStream(
         analysis_bus->channel_ptrs(),
         analysis_bus->bus()->frames(),
         sample_rate,
-        ChannelsToLayout(audio_bus->channels()));
+        ChannelsToLayout(analysis_bus->bus()->channels()));
   }
 }
 
 void MediaStreamAudioProcessor::OnPlayoutDataSourceChanged() {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   // There is no need to hold a lock here since the caller guarantees that
   // there is no more OnPlayoutData() callback on the render thread.
   render_thread_checker_.DetachFromThread();
   render_fifo_.reset();
 }
@@ skipping 275 matching lines @@
   if (echo_information_) {
     echo_information_.get()->UpdateAecDelayStats(ap->echo_cancellation());
   }
 
   // Return 0 if the volume hasn't been changed, and otherwise the new volume.
   return (agc->stream_analog_level() == volume) ?
       0 : agc->stream_analog_level();
 }
 
 }  // namespace content