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 30 matching lines @@
           TimeDelta::FromMilliseconds(kPowerMeasurementTimeConstantMillis)),
       on_more_io_data_called_(0),
       ignore_errors_during_stop_close_(false) {
   DCHECK(audio_manager);
   DCHECK(handler_);
   DCHECK(sync_reader_);
   DCHECK(message_loop_.get());
 }
 
 AudioOutputController::~AudioOutputController() {
   DCHECK_EQ(kClosed, state_);

[miu, 2016/05/28 02:45:00]

For safety, consider adding: DCHECK(duplication_targets_.empty());

[qiangchen, 2016/05/31 21:17:33]

Done.

 }
 
 // static
 scoped_refptr<AudioOutputController> AudioOutputController::Create(
     AudioManager* audio_manager,
     EventHandler* event_handler,
     const AudioParameters& params,
     const std::string& output_device_id,
     SyncReader* sync_reader) {
   DCHECK(audio_manager);
@@ skipping 232 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);
 
+  {
+    base::AutoLock lock(duplication_targets_lock_);
+    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_) {
+        target->OnData(*dest, reference_time);

[miu, 2016/05/28 02:45:00]

This is going to have the real-time audio thread execute a separate copy of the
audio data for each |target| (since you do the copy in VirtualAudioSink).
Instead, you should make one single copy here, and then share it with all
targets on the other thread. So, here the code should be something like:

  bool need_to_duplicate = false;
  {
    base::AutoLock lock(duplication_targets_lock_);
    need_to_duplicate = !duplication_targets_.empty();
  }
  if (need_to_duplicate) {
    const base::TimeTicks reference_time = ...;
    std::unique_ptr<AudioBus> copy = ...copy of |dest|...;
    message_loop_->PostTask(FROM_HERE,
        base::Bind(&AudioOutputController::BroadcastDataToDuplicationTargets,
this,
                   base::Passed(&copy), reference_time));
  }

...and then:

void AudioOutputController::BroadcastDataToDuplicationTargets(
    std::unique_ptr<AudioBus> audio_bus,
    base::TimeTicks reference_time) {
  DCHECK(message_loop_->BelongsToCurrentThread());
  if (state != kPlaying)
    return;
  // Note: Do not need to acquire lock since this is running on the same thread
as where the set is modified.
  for (AudioPushSink* target : duplication_targets_)
    target->OnData(*audio_bus, reference_time);
}

[qiangchen, 2016/05/31 21:17:33]

Done.

+      }
+    }
+  }
+
   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;
+
+  base::AutoLock lock(duplication_targets_lock_);
+
+  // Already serving the stream.
+  if (duplication_targets_.find(to_stream) != duplication_targets_.end())

[miu, 2016/05/28 02:45:00]

This isn't necessary since you're inserting into a std::set (it'll do this
already).

[qiangchen, 2016/05/31 21:17:33]

Done.

+    return;
+
+  duplication_targets_.insert(to_stream);
+}
+
+void AudioOutputController::DoStopDuplicating(AudioPushSink* to_stream) {
+  DCHECK(message_loop_->BelongsToCurrentThread());
+  to_stream->Close();
+  if (state_ == kClosed)

[miu, 2016/05/28 02:45:00]

I'd suggest omitting this early return when state_ == kClosed, since you want
the entry to be removed from the set anyway.

[qiangchen, 2016/05/31 21:17:33]

Done.

+    return;
+
+  base::AutoLock lock(duplication_targets_lock_);
+  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