Browser-wide audio mirroring for TabCapture API

media/audio/audio_manager_base.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_manager_base.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/message_loop_proxy.h"
 #include "base/threading/thread.h"
 #include "media/audio/audio_output_dispatcher_impl.h"
 #include "media/audio/audio_output_proxy.h"
 #include "media/audio/audio_output_resampler.h"
 #include "media/audio/audio_util.h"
 #include "media/audio/fake_audio_input_stream.h"
 #include "media/audio/fake_audio_output_stream.h"
+#include "media/audio/virtual_audio_input_stream.h"
+#include "media/audio/virtual_audio_output_stream.h"
 #include "media/base/media_switches.h"
 
 // TODO(dalecurtis): Temporarily disabled while switching pipeline to use float,
 // http://crbug.com/114700
 #if defined(ENABLE_AUDIO_MIXER)
 #include "media/audio/audio_output_mixer.h"
 #endif
 
 namespace media {
 
@@ skipping 11 matching lines @@
 
 const char AudioManagerBase::kDefaultDeviceName[] = "Default";
 const char AudioManagerBase::kDefaultDeviceId[] = "default";
 
 AudioManagerBase::AudioManagerBase()
     : num_active_input_streams_(0),
       max_num_output_streams_(kDefaultMaxOutputStreams),
       max_num_input_streams_(kDefaultMaxInputStreams),
       num_output_streams_(0),
       num_input_streams_(0),
-      audio_thread_(new base::Thread("AudioThread")) {
+      audio_thread_(new base::Thread("AudioThread")),
+      virtual_audio_input_stream_(NULL) {
 #if defined(OS_WIN)
   audio_thread_->init_com_with_mta(true);
 #endif
   CHECK(audio_thread_->Start());
   message_loop_ = audio_thread_->message_loop_proxy();
 }
 
 AudioManagerBase::~AudioManagerBase() {
   // The platform specific AudioManager implementation must have already
   // stopped the audio thread. Otherwise, we may destroy audio streams before
@@ skipping 34 matching lines @@
     return NULL;
   }
 
   // If there are no audio output devices we should use a FakeAudioOutputStream
   // to ensure video playback continues to work.
   bool audio_output_disabled =
       params.format() == AudioParameters::AUDIO_FAKE ||
       !HasAudioOutputDevices();
 
   AudioOutputStream* stream = NULL;
-  if (audio_output_disabled) {
+  if (virtual_audio_input_stream_) {
+    VirtualAudioOutputStream* virtual_stream =
+        VirtualAudioOutputStream::MakeStream(this, params);
+    stream = virtual_stream;
+    virtual_audio_input_stream_->AddOutputStream(virtual_stream, params);
+  } else if (audio_output_disabled) {
     stream = FakeAudioOutputStream::MakeFakeStream(this, params);
   } else if (params.format() == AudioParameters::AUDIO_PCM_LINEAR) {
     stream = MakeLinearOutputStream(params);
   } else if (params.format() == AudioParameters::AUDIO_PCM_LOW_LATENCY) {
     stream = MakeLowLatencyOutputStream(params);
   }
 
   if (stream)
     ++num_output_streams_;
 
   return stream;
 }
 
 AudioInputStream* AudioManagerBase::MakeAudioInputStream(
     const AudioParameters& params, const std::string& device_id) {
   if (!params.IsValid() || (params.channels() > kMaxInputChannels) ||
       device_id.empty()) {
     DLOG(ERROR) << "Audio parameters are invalid for device " << device_id;
     return NULL;
   }
 
   if (num_input_streams_ >= max_num_input_streams_) {
     DLOG(ERROR) << "Number of opened input audio streams "
                 << num_input_streams_
                 << " exceed the max allowed number " << max_num_input_streams_;
     return NULL;
   }
 
   AudioInputStream* stream = NULL;
-  if (params.format() == AudioParameters::AUDIO_FAKE) {
+  if (params.format() == AudioParameters::AUDIO_WEB_CONTENTS &&
+      !virtual_audio_input_stream_) {

[DaleCurtis, 2012/11/21 23:45:43]

CHECK(!virtual_audio_input_stream) instead of if ! ?

[justinlin, 2012/11/26 20:19:20]

This brings up that what I wanted to do won't work. Fixed that. See TODO. We'll
just use a fake stream for subsequent mirroring requests.

+    // TODO(justinlin): Currently, we can only support mirroring audio from 1
+    // tab, so subsequent tab capture requests will just get microphone audio.
+    // Maybe we should just return the same stream and ref-count, so that we
+    // only actually destroy the stream when there's no mirroring?
+    virtual_audio_input_stream_ =
+        VirtualAudioInputStream::MakeStream(this, params);
+    stream = virtual_audio_input_stream_;
+    NotifyAllOutputDeviceChangeListeners();
+  } else if (params.format() == AudioParameters::AUDIO_FAKE) {
     stream = FakeAudioInputStream::MakeFakeStream(this, params);
   } else if (params.format() == AudioParameters::AUDIO_PCM_LINEAR) {
     stream = MakeLinearInputStream(params, device_id);
   } else if (params.format() == AudioParameters::AUDIO_PCM_LOW_LATENCY) {
     stream = MakeLowLatencyInputStream(params, device_id);
   }
 
   if (stream)
     ++num_input_streams_;
 
@@ skipping 81 matching lines @@
   return false;
 }
 
 void AudioManagerBase::ShowAudioInputSettings() {
 }
 
 void AudioManagerBase::GetAudioInputDeviceNames(
     media::AudioDeviceNames* device_names) {
 }
 
 void AudioManagerBase::ReleaseOutputStream(AudioOutputStream* stream) {

[DaleCurtis, 2012/11/21 23:45:43]

Is this method guaranteed to happen on the audio thread? If so can you
DCHECK(belongs to current thread) ?

[justinlin, 2012/11/26 20:19:20]

Done.

   DCHECK(stream);
   // TODO(xians) : Have a clearer destruction path for the AudioOutputStream.
   // For example, pass the ownership to AudioManager so it can delete the
   // streams.
+
+  if (virtual_audio_input_stream_) {

[DaleCurtis, 2012/11/21 23:45:43]

Hmmm, this seems incorrect. You set virtual_audio_input_stream_ above but then
fire NotifyAllOutputDeviceChangeListeners() which means non
VirtualAudioOutputStream's will be calling this method.

[justinlin, 2012/11/26 20:19:20]

Done. Added another release method for virtual output streams.

+    VirtualAudioOutputStream* virtual_stream =
+        static_cast<VirtualAudioOutputStream*>(stream);
+    virtual_audio_input_stream_->RemoveOutputStream(virtual_stream);
+  }
+
   num_output_streams_--;
   delete stream;
 }
 
 void AudioManagerBase::ReleaseInputStream(AudioInputStream* stream) {

[DaleCurtis, 2012/11/21 23:45:43]

Is this method guaranteed to happen on the audio thread? If so can you
DCHECK(belongs to current thread) ?

[justinlin, 2012/11/26 20:19:20]

Done.

   DCHECK(stream);
   // TODO(xians) : Have a clearer destruction path for the AudioInputStream.
+
+  if (virtual_audio_input_stream_ == stream) {
+    virtual_audio_input_stream_->Stop();
+    virtual_audio_input_stream_ = NULL;
+    NotifyAllOutputDeviceChangeListeners();
+  }
+
   num_input_streams_--;
   delete stream;
 }
 
 void AudioManagerBase::IncreaseActiveInputStreamCount() {
   base::AtomicRefCountInc(&num_active_input_streams_);
 }
 
 void AudioManagerBase::DecreaseActiveInputStreamCount() {
   DCHECK(IsRecordingInProcess());
@@ skipping 83 matching lines @@
   output_listeners_.RemoveObserver(listener);
 }
 
 void AudioManagerBase::NotifyAllOutputDeviceChangeListeners() {
   DCHECK(message_loop_->BelongsToCurrentThread());
   DVLOG(1) << "Firing OnDeviceChange() notifications.";
   FOR_EACH_OBSERVER(AudioDeviceListener, output_listeners_, OnDeviceChange());
 }
 
 }  // namespace media