content/browser/renderer_host/media/web_contents_audio_input_stream.cc

   1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "content/browser/renderer_host/media/web_contents_audio_input_stream.h"
   6
   7 #include <string>
   8
   9 #include "base/bind.h"
  10 #include "base/bind_helpers.h"
  11 #include "base/logging.h"
  12 #include "base/memory/scoped_ptr.h"
  13 #include "base/threading/thread_checker.h"
  14 #include "content/browser/renderer_host/media/audio_mirroring_manager.h"
  15 #include "content/browser/renderer_host/media/web_contents_capture_util.h"
  16 #include "content/browser/renderer_host/media/web_contents_tracker.h"
  17 #include "content/public/browser/browser_thread.h"
  18 #include "media/audio/virtual_audio_input_stream.h"
  19 #include "media/audio/virtual_audio_output_stream.h"
  20
  21 namespace content {
  22
  23 class WebContentsAudioInputStream::Impl
  24     : public base::RefCountedThreadSafe<WebContentsAudioInputStream::Impl>,
  25       public AudioMirroringManager::MirroringDestination {
  26  public:
  27   // Takes ownership of |mixer_stream|.  The rest outlive this instance.
  28   Impl(int render_process_id, int render_view_id,
  29        AudioMirroringManager* mirroring_manager,
  30        const scoped_refptr<WebContentsTracker>& tracker,
  31        media::VirtualAudioInputStream* mixer_stream);
  32
  33   // Open underlying VirtualAudioInputStream and start tracker.
  34   bool Open();
  35
  36   // Start the underlying VirtualAudioInputStream and instruct
  37   // AudioMirroringManager to begin a mirroring session.
  38   void Start(AudioInputCallback* callback);
  39
  40   // Stop the underlying VirtualAudioInputStream and instruct
  41   // AudioMirroringManager to shutdown a mirroring session.
  42   void Stop();
  43
  44   // Close the underlying VirtualAudioInputStream and stop the tracker.
  45   void Close();
  46
  47   // Accessor to underlying VirtualAudioInputStream.
  48   media::VirtualAudioInputStream* mixer_stream() const {
  49     return mixer_stream_.get();
  50   }
  51
  52  private:
  53   friend class base::RefCountedThreadSafe<WebContentsAudioInputStream::Impl>;
  54
  55   enum State {
  56     CONSTRUCTED,
  57     OPENED,
  58     MIRRORING,
  59     CLOSED
  60   };
  61
  62   virtual ~Impl();
  63
  64   // Returns true if the mirroring target has been permanently lost.
  65   bool IsTargetLost() const;
  66
  67   // Notifies the consumer callback that the stream is now dead.
  68   void ReportError();
  69
  70   // Start/Stop mirroring by posting a call to AudioMirroringManager on the IO
  71   // BrowserThread.
  72   void StartMirroring();
  73   void StopMirroring();
  74
  75   // AudioMirroringManager::MirroringDestination implementation
  76   virtual media::AudioOutputStream* AddInput(
  77       const media::AudioParameters& params) OVERRIDE;
  78
  79   // Callback which is run when |stream| is closed.  Deletes |stream|.
  80   void ReleaseInput(media::VirtualAudioOutputStream* stream);
  81
  82   // Called by WebContentsTracker when the target of the audio mirroring has
  83   // changed.
  84   void OnTargetChanged(int render_process_id, int render_view_id);
  85
  86   // Injected dependencies.
  87   AudioMirroringManager* const mirroring_manager_;
  88   const scoped_refptr<WebContentsTracker> tracker_;
  89   // The AudioInputStream implementation that handles the audio conversion and
  90   // mixing details.
  91   const scoped_ptr<media::VirtualAudioInputStream> mixer_stream_;
  92
  93   State state_;
  94
  95   // Current audio mirroring target.
  96   int target_render_process_id_;
  97   int target_render_view_id_;
  98
  99   // Current callback used to consume the resulting mixed audio data.
 100   AudioInputCallback* callback_;
 101
 102   base::ThreadChecker thread_checker_;
 103
 104   DISALLOW_COPY_AND_ASSIGN(Impl);
 105 };
 106
 107 WebContentsAudioInputStream::Impl::Impl(
 108     int render_process_id, int render_view_id,
 109     AudioMirroringManager* mirroring_manager,
 110     const scoped_refptr<WebContentsTracker>& tracker,
 111     media::VirtualAudioInputStream* mixer_stream)
 112     : mirroring_manager_(mirroring_manager),
 113       tracker_(tracker), mixer_stream_(mixer_stream), state_(CONSTRUCTED),
 114       target_render_process_id_(render_process_id),
 115       target_render_view_id_(render_view_id),
 116       callback_(NULL) {
 117   DCHECK(mirroring_manager_);
 118   DCHECK(tracker_.get());
 119   DCHECK(mixer_stream_.get());
 120
 121   // WAIS::Impl can be constructed on any thread, but will DCHECK that all
 122   // its methods from here on are called from the same thread.
 123   thread_checker_.DetachFromThread();
 124 }
 125
 126 WebContentsAudioInputStream::Impl::~Impl() {
 127   DCHECK(state_ == CONSTRUCTED || state_ == CLOSED);
 128 }
 129
 130 bool WebContentsAudioInputStream::Impl::Open() {
 131   DCHECK(thread_checker_.CalledOnValidThread());
 132
 133   DCHECK_EQ(CONSTRUCTED, state_) << "Illegal to Open more than once.";
 134
 135   if (!mixer_stream_->Open())
 136     return false;
 137
 138   state_ = OPENED;
 139
 140   tracker_->Start(
 141       target_render_process_id_, target_render_view_id_,
 142       base::Bind(&Impl::OnTargetChanged, this));
 143
 144   return true;
 145 }
 146
 147 void WebContentsAudioInputStream::Impl::Start(AudioInputCallback* callback) {
 148   DCHECK(thread_checker_.CalledOnValidThread());
 149   DCHECK(callback);
 150
 151   if (state_ != OPENED)
 152     return;
 153
 154   callback_ = callback;
 155   if (IsTargetLost()) {
 156     ReportError();
 157     callback_ = NULL;
 158     return;
 159   }
 160
 161   state_ = MIRRORING;
 162   mixer_stream_->Start(callback);
 163
 164   StartMirroring();
 165 }
 166
 167 void WebContentsAudioInputStream::Impl::Stop() {
 168   DCHECK(thread_checker_.CalledOnValidThread());
 169
 170   if (state_ != MIRRORING)
 171     return;
 172
 173   state_ = OPENED;
 174
 175   mixer_stream_->Stop();
 176   callback_ = NULL;
 177
 178   if (!IsTargetLost())
 179     StopMirroring();
 180 }
 181
 182 void WebContentsAudioInputStream::Impl::Close() {
 183   DCHECK(thread_checker_.CalledOnValidThread());
 184
 185   Stop();
 186
 187   if (state_ == OPENED) {
 188     state_ = CONSTRUCTED;
 189     tracker_->Stop();
 190     mixer_stream_->Close();
 191   }
 192
 193   DCHECK_EQ(CONSTRUCTED, state_);
 194   state_ = CLOSED;
 195 }
 196
 197 bool WebContentsAudioInputStream::Impl::IsTargetLost() const {
 198   DCHECK(thread_checker_.CalledOnValidThread());
 199
 200   return target_render_process_id_ <= 0 || target_render_view_id_ <= 0;
 201 }
 202
 203 void WebContentsAudioInputStream::Impl::ReportError() {
 204   DCHECK(thread_checker_.CalledOnValidThread());
 205
 206   // TODO(miu): Need clean-up of AudioInputCallback interface in a future
 207   // change, since its only implementation ignores the first argument entirely
 208   callback_->OnError(NULL);
 209 }
 210
 211 void WebContentsAudioInputStream::Impl::StartMirroring() {
 212   DCHECK(thread_checker_.CalledOnValidThread());
 213
 214   BrowserThread::PostTask(
 215       BrowserThread::IO,
 216       FROM_HERE,
 217       base::Bind(&AudioMirroringManager::StartMirroring,
 218                  base::Unretained(mirroring_manager_),
 219                  target_render_process_id_, target_render_view_id_,
 220                  make_scoped_refptr(this)));
 221 }
 222
 223 void WebContentsAudioInputStream::Impl::StopMirroring() {
 224   DCHECK(thread_checker_.CalledOnValidThread());
 225
 226   BrowserThread::PostTask(
 227       BrowserThread::IO,
 228       FROM_HERE,
 229       base::Bind(&AudioMirroringManager::StopMirroring,
 230                  base::Unretained(mirroring_manager_),
 231                  target_render_process_id_, target_render_view_id_,
 232                  make_scoped_refptr(this)));
 233 }
 234
 235 media::AudioOutputStream* WebContentsAudioInputStream::Impl::AddInput(
 236     const media::AudioParameters& params) {
 237   // Note: The closure created here holds a reference to "this," which will
 238   // guarantee the VirtualAudioInputStream (mixer_stream_) outlives the
 239   // VirtualAudioOutputStream.
 240   return new media::VirtualAudioOutputStream(
 241       params,
 242       mixer_stream_.get(),
 243       base::Bind(&Impl::ReleaseInput, this));
 244 }
 245
 246 void WebContentsAudioInputStream::Impl::ReleaseInput(
 247     media::VirtualAudioOutputStream* stream) {
 248   delete stream;
 249 }
 250
 251 void WebContentsAudioInputStream::Impl::OnTargetChanged(int render_process_id,
 252                                                         int render_view_id) {
 253   DCHECK(thread_checker_.CalledOnValidThread());
 254
 255   if (target_render_process_id_ == render_process_id &&
 256       target_render_view_id_ == render_view_id) {
 257     return;
 258   }
 259
 260   DVLOG(1) << "Target RenderView has changed from "
 261            << target_render_process_id_ << ':' << target_render_view_id_
 262            << " to " << render_process_id << ':' << render_view_id;
 263
 264   if (state_ == MIRRORING)
 265     StopMirroring();
 266
 267   target_render_process_id_ = render_process_id;
 268   target_render_view_id_ = render_view_id;
 269
 270   if (state_ == MIRRORING) {
 271     if (IsTargetLost()) {
 272       ReportError();
 273       Stop();
 274     } else {
 275       StartMirroring();
 276     }
 277   }
 278 }
 279
 280 // static
 281 WebContentsAudioInputStream* WebContentsAudioInputStream::Create(
 282     const std::string& device_id,
 283     const media::AudioParameters& params,
 284     const scoped_refptr<base::MessageLoopProxy>& worker_loop,
 285     AudioMirroringManager* audio_mirroring_manager) {
 286   int render_process_id;
 287   int render_view_id;
 288   if (!WebContentsCaptureUtil::ExtractTabCaptureTarget(
 289           device_id, &render_process_id, &render_view_id)) {
 290     return NULL;
 291   }
 292
 293   return new WebContentsAudioInputStream(
 294       render_process_id, render_view_id,
 295       audio_mirroring_manager,
 296       new WebContentsTracker(),
 297       new media::VirtualAudioInputStream(
 298           params, worker_loop,
 299           media::VirtualAudioInputStream::AfterCloseCallback()));
 300 }
 301
 302 WebContentsAudioInputStream::WebContentsAudioInputStream(
 303     int render_process_id, int render_view_id,
 304     AudioMirroringManager* mirroring_manager,
 305     const scoped_refptr<WebContentsTracker>& tracker,
 306     media::VirtualAudioInputStream* mixer_stream)
 307     : impl_(new Impl(render_process_id, render_view_id,
 308                      mirroring_manager, tracker, mixer_stream)) {}
 309
 310 WebContentsAudioInputStream::~WebContentsAudioInputStream() {}
 311
 312 bool WebContentsAudioInputStream::Open() {
 313   return impl_->Open();
 314 }
 315
 316 void WebContentsAudioInputStream::Start(AudioInputCallback* callback) {
 317   impl_->Start(callback);
 318 }
 319
 320 void WebContentsAudioInputStream::Stop() {
 321   impl_->Stop();
 322 }
 323
 324 void WebContentsAudioInputStream::Close() {
 325   impl_->Close();
 326   delete this;
 327 }
 328
 329 double WebContentsAudioInputStream::GetMaxVolume() {
 330   return impl_->mixer_stream()->GetMaxVolume();
 331 }
 332
 333 void WebContentsAudioInputStream::SetVolume(double volume) {
 334   impl_->mixer_stream()->SetVolume(volume);
 335 }
 336
 337 double WebContentsAudioInputStream::GetVolume() {
 338   return impl_->mixer_stream()->GetVolume();
 339 }
 340
 341 void WebContentsAudioInputStream::SetAutomaticGainControl(bool enabled) {
 342   impl_->mixer_stream()->SetAutomaticGainControl(enabled);
 343 }
 344
 345 bool WebContentsAudioInputStream::GetAutomaticGainControl() {
 346   return impl_->mixer_stream()->GetAutomaticGainControl();
 347 }
 348
 349 }  // namespace content