Tab Audio Mirroring: WebContentsAudioInputStream is a new implementation which represents the lifet…

media/audio/virtual_audio_input_stream.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/virtual_audio_input_stream.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/message_loop.h"
+#include "base/message_loop_proxy.h"
 #include "media/audio/virtual_audio_output_stream.h"
 
 namespace media {
 
 // LoopbackAudioConverter works similar to AudioConverter and converts input
 // streams to different audio parameters. Then, the LoopbackAudioConverter can
 // be used as an input to another AudioConverter. This allows us to
 // use converted audio from AudioOutputStreams as input to an AudioConverter.
 // For example, this allows converting multiple streams into a common format and
 // using the converted audio as input to another AudioConverter (i.e. a mixer).
@@ skipping 18 matching lines @@
                               base::TimeDelta buffer_delay) OVERRIDE {
     audio_converter_.Convert(audio_bus);
     return 1.0;
   }
 
   AudioConverter audio_converter_;
 
   DISALLOW_COPY_AND_ASSIGN(LoopbackAudioConverter);
 };
 
-VirtualAudioInputStream* VirtualAudioInputStream::MakeStream(
-    AudioManagerBase* manager, const AudioParameters& params,
-    base::MessageLoopProxy* message_loop) {
-  return new VirtualAudioInputStream(manager, params, message_loop);
-}
-
 VirtualAudioInputStream::VirtualAudioInputStream(
-    AudioManagerBase* manager, const AudioParameters& params,
-    base::MessageLoopProxy* message_loop)
-    : audio_manager_(manager),
-      message_loop_(message_loop),
+    const AudioParameters& params, base::MessageLoopProxy* message_loop)
+    : message_loop_(message_loop),
       callback_(NULL),
-      buffer_duration_ms_(base::TimeDelta::FromMilliseconds(
-          params.frames_per_buffer() * base::Time::kMillisecondsPerSecond /
-          static_cast<float>(params.sample_rate()))),
+      buffer_duration_(base::TimeDelta::FromMicroseconds(
+          params.frames_per_buffer() * base::Time::kMicrosecondsPerSecond /
+          params.sample_rate())),
       buffer_(new uint8[params.GetBytesPerBuffer()]),
       params_(params),
       audio_bus_(AudioBus::Create(params_)),
       mixer_(params_, params_, false),
-      num_attached_outputs_streams_(0) {
+      num_attached_output_streams_(0) {
+  DCHECK(params_.IsValid());
+  DCHECK(message_loop_);
 }
 
 VirtualAudioInputStream::~VirtualAudioInputStream() {
   for (AudioConvertersMap::iterator it = converters_.begin();
        it != converters_.end(); ++it)
     delete it->second;
 
-  DCHECK_EQ(0, num_attached_outputs_streams_);
+  DCHECK_EQ(0, num_attached_output_streams_);
+}
+
+void VirtualAudioInputStream::RunOnceClosed(const base::Closure& cb) {
+  DCHECK(on_close_cb_.is_null());
+  on_close_cb_ = cb;
 }
 
 bool VirtualAudioInputStream::Open() {
+  DCHECK(message_loop_->BelongsToCurrentThread());
   memset(buffer_.get(), 0, params_.GetBytesPerBuffer());
   return true;
 }
 
 void VirtualAudioInputStream::Start(AudioInputCallback* callback) {
   DCHECK(message_loop_->BelongsToCurrentThread());
   callback_ = callback;
   on_more_data_cb_.Reset(base::Bind(&VirtualAudioInputStream::ReadAudio,
                                     base::Unretained(this)));
-  audio_manager_->GetMessageLoop()->PostTask(FROM_HERE,
-                                             on_more_data_cb_.callback());
+  message_loop_->PostTask(FROM_HERE, on_more_data_cb_.callback());
 }
 
 void VirtualAudioInputStream::Stop() {
   DCHECK(message_loop_->BelongsToCurrentThread());
   on_more_data_cb_.Cancel();
 }
 
 void VirtualAudioInputStream::AddOutputStream(
     VirtualAudioOutputStream* stream, const AudioParameters& output_params) {
   DCHECK(message_loop_->BelongsToCurrentThread());
 
   AudioConvertersMap::iterator converter = converters_.find(output_params);
   if (converter == converters_.end()) {
     std::pair<AudioConvertersMap::iterator, bool> result = converters_.insert(
         std::make_pair(output_params,
                        new LoopbackAudioConverter(output_params, params_)));
     converter = result.first;
 
     // Add to main mixer if we just added a new AudioTransform.
     mixer_.AddInput(converter->second);
   }
   converter->second->AddInput(stream);
-  ++num_attached_outputs_streams_;
+  ++num_attached_output_streams_;
 }
 
 void VirtualAudioInputStream::RemoveOutputStream(
     VirtualAudioOutputStream* stream, const AudioParameters& output_params) {
   DCHECK(message_loop_->BelongsToCurrentThread());
 
   DCHECK(converters_.find(output_params) != converters_.end());
   converters_[output_params]->RemoveInput(stream);
 
-  --num_attached_outputs_streams_;
+  --num_attached_output_streams_;
+  DCHECK_LE(0, num_attached_output_streams_);
 }
 
 void VirtualAudioInputStream::ReadAudio() {
   DCHECK(message_loop_->BelongsToCurrentThread());
   DCHECK(callback_);
 
   mixer_.Convert(audio_bus_.get());
   audio_bus_->ToInterleaved(params_.frames_per_buffer(),
                             params_.bits_per_sample() / 8,
                             buffer_.get());
 
   callback_->OnData(this,
                     buffer_.get(),
                     params_.GetBytesPerBuffer(),
                     params_.GetBytesPerBuffer(),
                     1.0);
 
+  // TODO(miu): We want ReadAudio() to be called every buffer_duration_ amount
+  // of time.  However, we're not accounting for the time spent doing the
+  // conversion and data delivery above, which is significant.  Therefore, audio
+  // data is always being delivered at a slower rate than required, and this
+  // will cause cut-outs!

[DaleCurtis, 2013/01/15 22:02:18]

Justin has a fix out for this?

[miu, 2013/01/16 03:22:18]

Yep (https://codereview.chromium.org/11889041/).  The TODO comment was written
before that work was started.  I'll take it out and rebase once his change is
committed.

   message_loop_->PostDelayedTask(FROM_HERE,
                                  on_more_data_cb_.callback(),
-                                 buffer_duration_ms_);
+                                 buffer_duration_);
 }
 
 void VirtualAudioInputStream::Close() {
   DCHECK(message_loop_->BelongsToCurrentThread());
   if (callback_) {
     DCHECK(on_more_data_cb_.IsCancelled());
     callback_->OnClose(this);
     callback_ = NULL;
   }
-  audio_manager_->ReleaseInputStream(this);
+  if (!on_close_cb_.is_null()) {
+    const base::Closure cb = on_close_cb_;
+    on_close_cb_.Reset();
+    cb.Run();
+  }
 }
 
 double VirtualAudioInputStream::GetMaxVolume() {
   return 1.0;
 }
 
 void VirtualAudioInputStream::SetVolume(double volume) {}
 
 double VirtualAudioInputStream::GetVolume() {
   return 1.0;
 }
 
 void VirtualAudioInputStream::SetAutomaticGainControl(bool enabled) {}
 
 bool VirtualAudioInputStream::GetAutomaticGainControl() {
   return false;
 }
 
 }  // namespace media