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_) {
+#if defined(OS_IOS)
+    // We do not currently support iOS. It does not link.
+    NOTIMPLEMENTED();
+    return NULL;
+#else
+    stream = VirtualAudioOutputStream::MakeStream(this, params,
+        virtual_audio_input_stream_);
+#endif
+  } 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_VIRTUAL) {
+  #if defined(OS_IOS)

[DaleCurtis, 2012/12/03 19:27:28]

#if is never indented.

[justinlin, 2012/12/03 21:18:42]

Done.

+    // We do not currently support iOS.
+    NOTIMPLEMENTED();
+    return NULL;
+  #else
+    // TODO(justinlin): Currently, audio mirroring will only work for the first
+    // request. Subsequent requests will not get audio.
+    if (!virtual_audio_input_stream_) {
+      virtual_audio_input_stream_ =
+          VirtualAudioInputStream::MakeStream(this, params);
+      stream = virtual_audio_input_stream_;
+      DVLOG(1) << "Virtual audio input stream created.";
+
+      // Make all current output streams recreate themselves as
+      // VirtualAudioOutputStreams that will attach to the above
+      // VirtualAudioInputStream.
+      message_loop_->PostTask(FROM_HERE, base::Bind(
+          &AudioManagerBase::NotifyAllOutputDeviceChangeListeners,

[DaleCurtis, 2012/12/03 19:27:28]

I mentioned this to Yuri, but FYI, we'll probably start filtering these changes
to only fire when hardware output values actually change.  It should be simple
enough to always fire if virtual_audio_input_stream_ is set though.

[justinlin, 2012/12/03 21:18:42]

Acknowledged.

[DaleCurtis, 2012/12/03 21:30:56]

The previous style here was fine. You can always switch to 4 space indent when
providing for a new function.

[justinlin, 2012/12/03 22:01:48]

Done. OK, I see.

+          base::Unretained(this)));
+    } else {
+      stream = NULL;
+    }
+  #endif
+  } 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 93 matching lines @@
   // TODO(xians) : Have a clearer destruction path for the AudioOutputStream.
   // For example, pass the ownership to AudioManager so it can delete the
   // streams.
   num_output_streams_--;
   delete stream;
 }
 
 void AudioManagerBase::ReleaseInputStream(AudioInputStream* stream) {
   DCHECK(stream);
   // TODO(xians) : Have a clearer destruction path for the AudioInputStream.
+
+  if (virtual_audio_input_stream_ == stream) {
+    DVLOG(1) << "Virtual audio input stream stopping.";
+    virtual_audio_input_stream_->Stop();
+    virtual_audio_input_stream_ = NULL;
+
+    // Make all audio output streams (which should be virtual) recreate
+    // themselves as regular audio streams to return sound to hardware.
+    NotifyAllOutputDeviceChangeListeners();

[DaleCurtis, 2012/12/03 19:27:28]

Should this be PostTask'd?

[justinlin, 2012/12/03 21:18:42]

No, I don't think so. We need the output streams to detach first before we
delete the virtual audio input stream.

+  }
+
   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