Unmute Tab Audio For Desktop Share

media/audio/audio_output_controller.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 "media/audio/audio_output_controller.h"
 
 #include <stdint.h>
 
 #include <limits>
 
@@ skipping 101 matching lines @@
 
 void AudioOutputController::DoCreate(bool is_for_device_change) {
   DCHECK(message_loop_->BelongsToCurrentThread());
   SCOPED_UMA_HISTOGRAM_TIMER("Media.AudioOutputController.CreateTime");
   TRACE_EVENT0("audio", "AudioOutputController::DoCreate");
 
   // Close() can be called before DoCreate() is executed.
   if (state_ == kClosed)
     return;
 
-  DoStopCloseAndClearStream();  // Calls RemoveOutputDeviceChangeListener().
+  // Calls RemoveOutputDeviceChangeListener().
+  DoStopCloseAndClearStream();

[miu, 2016/05/06 22:29:50]

nit: Comment can go at end-of-line (like it was before). In other words, no
change here. ;-)

[qiangchen, 2016/05/10 22:36:53]

Done.

   DCHECK_EQ(kEmpty, state_);
 
   stream_ = diverting_to_stream_ ?
       diverting_to_stream_ :
       audio_manager_->MakeAudioOutputStreamProxy(params_, output_device_id_);
   if (!stream_) {
     state_ = kError;
     handler_->OnError();
     return;
   }
@@ skipping 161 matching lines @@
   // thread starts, its safe to compare and then increment.
   if (base::AtomicRefCountIsZero(&on_more_io_data_called_))
     base::AtomicRefCountInc(&on_more_io_data_called_);
 
   sync_reader_->Read(dest);
 
   const int frames = dest->frames();
   sync_reader_->UpdatePendingBytes(
       total_bytes_delay + frames * params_.GetBytesPerFrame(), frames_skipped);
 
+  if (!duplication_targets_.empty()) {
+    const base::TimeTicks reference_time =
+        base::TimeTicks::Now() +
+        base::TimeDelta::FromMicroseconds(base::Time::kMicrosecondsPerSecond *
+                                          total_bytes_delay /
+                                          params_.GetBytesPerSecond());
+    for (AudioPushSink* target : duplication_targets_) {

[miu, 2016/05/06 22:37:06]

Oh, I just realized something critical here: This method is being called on the
real-time audio thread, but |duplication_targets_| is being mutated on the IO
thread.

Possible solutions:

1. Locking with a mutex: However, we generally try to avoid that where at all
possible because it inevitably leads to glitches. That said, I think we *can*
reasonably assume any lock-contention would be time-bounded to a very short
duration, so the real-time audio thread should never become blocked long enough
to drop audio.

2. We could stop the AudioOutputStream, then add/remove entries to/from
|duplication_targets_|, and then re-start the stream. This would ensure no
real-time audio thread is accessing duplication_targets_ at the same time the IO
thread is mutating the map. However, the downside is that the user would
definitely hear a short "pop" of silent audio.

[DaleCurtis, 2016/05/09 18:53:25]

I'm more worried about what each target may do with the OnData() call. We don't
have a lot of time on this call and this adds a non-transparent amount of cost.
Why not post a copy to the io thread? Note, posting tasks also requires a lock,
so I'm more concerned with what OnData does.

[qiangchen, 2016/05/10 22:36:53]

Thanks for suggestions.

After my investigation, we need to also consider the thread contention between
VirtualAudioSink's OnData and ProvideInput. Now my solution post OnData call to
the thread ProvideInput is called, which is the IO thread.

And I put lock for duplication_targets_. 

+      target->OnData(*dest, reference_time);
+    }
+  }
+
   if (will_monitor_audio_levels())
     power_monitor_.Scan(*dest, frames);
 
   return frames;
 }
 
 void AudioOutputController::OnError(AudioOutputStream* stream) {
   {
     base::AutoLock auto_lock(error_lock_);
     if (ignore_errors_during_stop_close_)
@@ skipping 15 matching lines @@
       ignore_errors_during_stop_close_ = true;
     }
 
     // De-register from state change callbacks if stream_ was created via
     // AudioManager.
     if (stream_ != diverting_to_stream_)
       audio_manager_->RemoveOutputDeviceChangeListener(this);
 
     StopStream();
     stream_->Close();
+
     if (stream_ == diverting_to_stream_)
       diverting_to_stream_ = NULL;
     stream_ = NULL;
 
     // Since the stream is no longer running, no lock is necessary.
     ignore_errors_during_stop_close_ = false;
   }
 
   state_ = kEmpty;
 }
@@ skipping 36 matching lines @@
   message_loop_->PostTask(
       FROM_HERE,
       base::Bind(&AudioOutputController::DoStartDiverting, this, to_stream));
 }
 
 void AudioOutputController::StopDiverting() {
   message_loop_->PostTask(
       FROM_HERE, base::Bind(&AudioOutputController::DoStopDiverting, this));
 }
 
+void AudioOutputController::StartDuplicating(AudioPushSink* sink) {
+  message_loop_->PostTask(
+      FROM_HERE,
+      base::Bind(&AudioOutputController::DoStartDuplicating, this, sink));
+}
+
+void AudioOutputController::StopDuplicating(AudioPushSink* sink) {
+  message_loop_->PostTask(
+      FROM_HERE,
+      base::Bind(&AudioOutputController::DoStopDuplicating, this, sink));
+}
+
 void AudioOutputController::DoStartDiverting(AudioOutputStream* to_stream) {
   DCHECK(message_loop_->BelongsToCurrentThread());
 
   if (state_ == kClosed)
     return;
 
   DCHECK(!diverting_to_stream_);
   diverting_to_stream_ = to_stream;
   // Note: OnDeviceChange() will engage the "re-create" process, which will
   // detect and use the alternate AudioOutputStream rather than create a new one
   // via AudioManager.
   OnDeviceChange();
 }
 
 void AudioOutputController::DoStopDiverting() {
   DCHECK(message_loop_->BelongsToCurrentThread());
 
   if (state_ == kClosed)
     return;
 
   // Note: OnDeviceChange() will cause the existing stream (the consumer of the
   // diverted audio data) to be closed, and diverting_to_stream_ will be set
   // back to NULL.
   OnDeviceChange();
   DCHECK(!diverting_to_stream_);
 }
 
+void AudioOutputController::DoStartDuplicating(AudioPushSink* to_stream) {
+  DCHECK(message_loop_->BelongsToCurrentThread());
+  if (state_ == kClosed)
+    return;
+
+  // Already serving the stream.
+  if (duplication_targets_.find(to_stream) != duplication_targets_.end())
+    return;
+
+  duplication_targets_.insert(to_stream);
+}
+
+void AudioOutputController::DoStopDuplicating(AudioPushSink* to_stream) {
+  DCHECK(message_loop_->BelongsToCurrentThread());
+
+  to_stream->Close();
+  if (state_ == kClosed)
+    return;
+
+  duplication_targets_.erase(to_stream);
+}
+
 std::pair<float, bool> AudioOutputController::ReadCurrentPowerAndClip() {
   DCHECK(will_monitor_audio_levels());
   return power_monitor_.ReadCurrentPowerAndClip();
 }
 
 void AudioOutputController::WedgeCheck() {
   DCHECK(message_loop_->BelongsToCurrentThread());
 
   // If we should be playing and we haven't, that's a wedge.
   if (state_ == kPlaying) {
     UMA_HISTOGRAM_BOOLEAN("Media.AudioOutputControllerPlaybackStartupSuccess",
                           base::AtomicRefCountIsOne(&on_more_io_data_called_));
   }
 }
 
 }  // namespace media