Turn audio ducking on by default on Windows again.

content/renderer/media/webrtc_local_audio_renderer.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_renderer.h"
 
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/metrics/histogram.h"
 #include "base/synchronization/lock.h"
 #include "content/renderer/media/audio_device_factory.h"
+#include "content/renderer/media/media_stream_dispatcher.h"
 #include "content/renderer/media/webrtc_audio_capturer.h"
+#include "content/renderer/render_view_impl.h"
 #include "media/audio/audio_output_device.h"
 #include "media/base/audio_bus.h"
 #include "media/base/audio_fifo.h"
 
 namespace content {
 
 namespace {
 
 enum LocalRendererSinkStates {
   kSinkStarted = 0,
@@ skipping 62 matching lines @@
 }
 
 void WebRtcLocalAudioRenderer::OnSetFormat(
     const media::AudioParameters& params) {
   DVLOG(1) << "WebRtcLocalAudioRenderer::OnSetFormat()";
   // If the source is restarted, we might have changed to another capture
   // thread.
   capture_thread_checker_.DetachFromThread();
   DCHECK(capture_thread_checker_.CalledOnValidThread());
 
-  // Reset the |source_params_|, |sink_params_| and |loopback_fifo_| to match
-  // the new format.
-  {
-    base::AutoLock auto_lock(thread_lock_);
-    if (source_params_ == params)
-      return;
-
-    source_params_ = params;
-
-    sink_params_ = media::AudioParameters(source_params_.format(),
-        source_params_.channel_layout(), source_params_.channels(),
-        source_params_.input_channels(), source_params_.sample_rate(),
-        source_params_.bits_per_sample(),
-#if defined(OS_ANDROID)
-        // On Android, input and output use the same sample rate. In order to
-        // use the low latency mode, we need to use the buffer size suggested by
-        // the AudioManager for the sink.  It will later be used to decide
-        // the buffer size of the shared memory buffer.
-        frames_per_buffer_,
-#else
-        2 * source_params_.frames_per_buffer(),
-#endif
-        // If DUCKING is enabled on the source, it needs to be enabled on the
-        // sink as well.
-        source_params_.effects());
-
-    // TODO(henrika): we could add a more dynamic solution here but I prefer
-    // a fixed size combined with bad audio at overflow. The alternative is
-    // that we start to build up latency and that can be more difficult to
-    // detect. Tests have shown that the FIFO never contains more than 2 or 3
-    // audio frames but I have selected a max size of ten buffers just
-    // in case since these tests were performed on a 16 core, 64GB Win 7
-    // machine. We could also add some sort of error notifier in this area if
-    // the FIFO overflows.
-    loopback_fifo_.reset(new media::AudioFifo(
-        params.channels(), 10 * params.frames_per_buffer()));
-  }
-
   // Post a task on the main render thread to reconfigure the |sink_| with the
   // new format.
   message_loop_->PostTask(
       FROM_HERE,
       base::Bind(&WebRtcLocalAudioRenderer::ReconfigureSink, this,
                  params));
 }
 
 // WebRtcLocalAudioRenderer::WebRtcLocalAudioRenderer implementation.
 WebRtcLocalAudioRenderer::WebRtcLocalAudioRenderer(
@@ skipping 124 matching lines @@
 }
 
 bool WebRtcLocalAudioRenderer::IsLocalRenderer() const {
   return true;
 }
 
 void WebRtcLocalAudioRenderer::MaybeStartSink() {
   DCHECK(message_loop_->BelongsToCurrentThread());
   DVLOG(1) << "WebRtcLocalAudioRenderer::MaybeStartSink()";
 
-  if (!sink_.get() || !source_params_.IsValid())
+  if (!sink_.get())
     return;
 
   base::AutoLock auto_lock(thread_lock_);
 
+  if (!source_params_.IsValid())
+    return;
+
   // Clear up the old data in the FIFO.
   loopback_fifo_->Clear();
 
   if (!sink_params_.IsValid() || !playing_ || !volume_ || sink_started_)
     return;
 
   DVLOG(1) << "WebRtcLocalAudioRenderer::MaybeStartSink() -- Starting sink_.";
   sink_->InitializeWithSessionId(sink_params_, this, session_id_);
   sink_->Start();
   sink_started_ = true;
   UMA_HISTOGRAM_ENUMERATION("Media.LocalRendererSinkStates",
                             kSinkStarted, kSinkStatesMax);
 }
 
 void WebRtcLocalAudioRenderer::ReconfigureSink(
     const media::AudioParameters& params) {
   DCHECK(message_loop_->BelongsToCurrentThread());
 
   DVLOG(1) << "WebRtcLocalAudioRenderer::ReconfigureSink()";
 
+  int implicit_ducking_effect = 0;
+  RenderViewImpl* render_view =
+      RenderViewImpl::FromRoutingID(source_render_view_id_);
+  if (render_view &&
+      render_view->media_stream_dispatcher() &&
+      render_view->media_stream_dispatcher()->IsAudioDuckingActive()) {
+    DVLOG(1) << "Forcing DUCKING to be ON for output";
+    implicit_ducking_effect = media::AudioParameters::DUCKING;
+  } else {
+    DVLOG(1) << "DUCKING not forced ON for output";
+  }
+
+  // Reset the |source_params_|, |sink_params_| and |loopback_fifo_| to match
+  // the new format.
+  {
+    base::AutoLock auto_lock(thread_lock_);

[no longer working on chromium, 2014/07/08 10:42:35]

with your move, I believe |source_params_| and |sink_params_| are only accessed
on the main thread, so we can move the thread_lock_ down before
loopback_fifo_.reset(new media::AudioFifo(...

[tommi (sloooow) - chröme, 2014/07/08 12:30:56]

Great. thanks for pointing that out.

+    if (source_params_ == params)
+      return;
+
+    source_params_ = params;
+
+    sink_params_ = media::AudioParameters(source_params_.format(),
+        source_params_.channel_layout(), source_params_.channels(),
+        source_params_.input_channels(), source_params_.sample_rate(),
+        source_params_.bits_per_sample(),
+#if defined(OS_ANDROID)
+        // On Android, input and output use the same sample rate. In order to
+        // use the low latency mode, we need to use the buffer size suggested by
+        // the AudioManager for the sink.  It will later be used to decide
+        // the buffer size of the shared memory buffer.
+        frames_per_buffer_,
+#else
+        2 * source_params_.frames_per_buffer(),
+#endif
+        // If DUCKING is enabled on the source, it needs to be enabled on the
+        // sink as well.
+        source_params_.effects() | implicit_ducking_effect);
+
+    // TODO(henrika): we could add a more dynamic solution here but I prefer
+    // a fixed size combined with bad audio at overflow. The alternative is
+    // that we start to build up latency and that can be more difficult to
+    // detect. Tests have shown that the FIFO never contains more than 2 or 3
+    // audio frames but I have selected a max size of ten buffers just
+    // in case since these tests were performed on a 16 core, 64GB Win 7
+    // machine. We could also add some sort of error notifier in this area if
+    // the FIFO overflows.
+    loopback_fifo_.reset(new media::AudioFifo(
+        params.channels(), 10 * params.frames_per_buffer()));
+  }
+
   if (!sink_)
     return;  // WebRtcLocalAudioRenderer has not yet been started.
 
   // Stop |sink_| and re-create a new one to be initialized with different audio
   // parameters.  Then, invoke MaybeStartSink() to restart everything again.
   if (sink_started_) {
     sink_->Stop();
     sink_started_ = false;
   }
   sink_ = AudioDeviceFactory::NewOutputDevice(source_render_view_id_,
                                               source_render_frame_id_);
   MaybeStartSink();
 }
 
 }  // namespace content