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 32 matching lines @@
       ignore_errors_during_stop_close_(false) {
   DCHECK(audio_manager);
   DCHECK(handler_);
   DCHECK(sync_reader_);
   DCHECK(message_loop_.get());
 }
 
 AudioOutputController::~AudioOutputController() {
   CHECK_EQ(kClosed, state_);
   CHECK_EQ(nullptr, stream_);
+  CHECK(duplication_targets_.empty());
 }
 
 // static
 scoped_refptr<AudioOutputController> AudioOutputController::Create(
     AudioManager* audio_manager,
     EventHandler* event_handler,
     const AudioParameters& params,
     const std::string& output_device_id,
     SyncReader* sync_reader) {
   CHECK(audio_manager);
@@ skipping 239 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);
 
+  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 =
+        base::TimeTicks::Now() +
+        base::TimeDelta::FromMicroseconds(base::Time::kMicrosecondsPerSecond *
+                                          total_bytes_delay /

[DaleCurtis, 2016/06/01 20:58:07]

These are integer values and will lose precision. You might cast one of these to
a double first, or better yet store kMicrosecondsPerSecond / GetBytesPerSecond()
as a double computed once.

[qiangchen, 2016/06/01 21:43:15]

Really necessary? I think multiplication is before division, so the precision
loss just happened in the last step, which is inevitable.

[DaleCurtis, 2016/06/01 21:52:09]

It depends on how you use these timestamps, but it seems fine in this case.

[qiangchen, 2016/06/01 23:11:13]

Acknowledged.

+                                          params_.GetBytesPerSecond());
+    std::unique_ptr<AudioBus> copy(AudioBus::Create(params_));
+    dest->CopyTo(copy.get());
+    message_loop_->PostTask(
+        FROM_HERE,
+        base::Bind(&AudioOutputController::BroadcastDataToDuplicationTargets,
+                   this, base::Passed(&copy), reference_time));
+  }
+
   if (will_monitor_audio_levels())
     power_monitor_.Scan(*dest, frames);
 
   return frames;
 }
 
+void AudioOutputController::BroadcastDataToDuplicationTargets(
+    std::unique_ptr<AudioBus> audio_bus,
+    base::TimeTicks reference_time) {
+  DCHECK(message_loop_->BelongsToCurrentThread());
+  if (state_ != kPlaying || duplication_targets_.empty())
+    return;
+
+  // Note: Do not need to acquire lock since this is running on the same thread
+  // as where the set is modified.
+  for (auto target = std::next(duplication_targets_.begin(), 1);

[DaleCurtis, 2016/06/01 20:58:07]

How come you need std::next here? Does for (auto a : duplication_targets_) not
work?

[qiangchen, 2016/06/01 21:43:15]

This loop skips the first target.
The statement after the loop takes care of the first target.

The motivation is to avoid an extra copy.

As we can anticipated, for most use cases, there is only one target, so this way
will avoid data copy twice.

[DaleCurtis, 2016/06/01 21:52:58]

Up to you, but it seems like this would be clearer with a if (size == 1) {
<copy> return;}

[qiangchen, 2016/06/01 23:11:13]

Not that simple.

Without using this technique, for N targets, we will copy N+1 times.
So the performance waste is more significant when N is smaller.
And when N=1, it almost double the workload. But when N=2 or 3, we still did
unnecessary work.

+       target != duplication_targets_.end(); ++target) {
+    std::unique_ptr<AudioBus> copy(AudioBus::Create(params_));
+    audio_bus->CopyTo(copy.get());
+    (*target)->OnData(std::move(copy), reference_time);
+  }
+
+  (*duplication_targets_.begin())->OnData(std::move(audio_bus), reference_time);

[DaleCurtis, 2016/06/01 20:58:07]

This looks like it broadcasts twice?

[qiangchen, 2016/06/01 21:43:15]

Explained above.

+}
+
 void AudioOutputController::OnError(AudioOutputStream* stream) {
   {
     base::AutoLock auto_lock(error_lock_);
     if (ignore_errors_during_stop_close_)
       return;
   }
 
   // Handle error on the audio controller thread.
   message_loop_->PostTask(FROM_HERE, base::Bind(
       &AudioOutputController::DoReportError, this));
 }
 
 void AudioOutputController::DoStopCloseAndClearStream() {
   DCHECK(message_loop_->BelongsToCurrentThread());
 
   // Allow calling unconditionally and bail if we don't have a stream_ to close.
   if (stream_) {
     {
       base::AutoLock auto_lock(error_lock_);
       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_);
+  duplication_targets_.insert(to_stream);
+}
+
+void AudioOutputController::DoStopDuplicating(AudioPushSink* to_stream) {
+  DCHECK(message_loop_->BelongsToCurrentThread());
+  to_stream->Close();
+
+  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