src/content/browser/renderer_host/media/audio_renderer_host.cc

   1 // Copyright (c) 2012 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/audio_renderer_host.h"
   6
   7 #include "base/bind.h"
   8 #include "base/bind_helpers.h"
   9 #include "base/memory/shared_memory.h"
  10 #include "base/metrics/histogram.h"
  11 #include "base/process/process.h"
  12 #include "content/browser/browser_main_loop.h"
  13 #include "content/browser/media/audio_stream_monitor.h"
  14 #include "content/browser/media/capture/audio_mirroring_manager.h"
  15 #include "content/browser/media/media_internals.h"
  16 #include "content/browser/renderer_host/media/audio_input_device_manager.h"
  17 #include "content/browser/renderer_host/media/audio_sync_reader.h"
  18 #include "content/browser/renderer_host/media/media_stream_manager.h"
  19 #include "content/common/media/audio_messages.h"
  20 #include "content/public/browser/content_browser_client.h"
  21 #include "content/public/browser/media_observer.h"
  22 #include "content/public/common/content_switches.h"
  23 #include "media/audio/audio_manager_base.h"
  24 #include "media/base/audio_bus.h"
  25 #include "media/base/limits.h"
  26
  27 using media::AudioBus;
  28 using media::AudioManager;
  29
  30 namespace content {
  31
  32 class AudioRendererHost::AudioEntry
  33     : public media::AudioOutputController::EventHandler {
  34  public:
  35   AudioEntry(AudioRendererHost* host,
  36              int stream_id,
  37              int render_view_id,
  38              int render_frame_id,
  39              const media::AudioParameters& params,
  40              const std::string& output_device_id,
  41              scoped_ptr<base::SharedMemory> shared_memory,
  42              scoped_ptr<media::AudioOutputController::SyncReader> reader);
  43   virtual ~AudioEntry();
  44
  45   int stream_id() const {
  46     return stream_id_;
  47   }
  48
  49   int render_view_id() const {
  50     return render_view_id_;
  51   }
  52
  53   int render_frame_id() const { return render_frame_id_; }
  54
  55   media::AudioOutputController* controller() const { return controller_.get(); }
  56
  57   base::SharedMemory* shared_memory() {
  58     return shared_memory_.get();
  59   }
  60
  61   media::AudioOutputController::SyncReader* reader() const {
  62     return reader_.get();
  63   }
  64
  65   bool playing() const { return playing_; }
  66   void set_playing(bool playing) { playing_ = playing; }
  67
  68  private:
  69   // media::AudioOutputController::EventHandler implementation.
  70   virtual void OnCreated() OVERRIDE;
  71   virtual void OnPlaying() OVERRIDE;
  72   virtual void OnPaused() OVERRIDE;
  73   virtual void OnError() OVERRIDE;
  74   virtual void OnDeviceChange(int new_buffer_size, int new_sample_rate)
  75       OVERRIDE;
  76
  77   AudioRendererHost* const host_;
  78   const int stream_id_;
  79
  80   // The routing ID of the source render view/frame.
  81   const int render_view_id_;
  82   const int render_frame_id_;
  83
  84   // Shared memory for transmission of the audio data.  Used by |reader_|.
  85   const scoped_ptr<base::SharedMemory> shared_memory_;
  86
  87   // The synchronous reader to be used by |controller_|.
  88   const scoped_ptr<media::AudioOutputController::SyncReader> reader_;
  89
  90   // The AudioOutputController that manages the audio stream.
  91   const scoped_refptr<media::AudioOutputController> controller_;
  92
  93   bool playing_;
  94 };
  95
  96 AudioRendererHost::AudioEntry::AudioEntry(
  97     AudioRendererHost* host,
  98     int stream_id,
  99     int render_view_id,
 100     int render_frame_id,
 101     const media::AudioParameters& params,
 102     const std::string& output_device_id,
 103     scoped_ptr<base::SharedMemory> shared_memory,
 104     scoped_ptr<media::AudioOutputController::SyncReader> reader)
 105     : host_(host),
 106       stream_id_(stream_id),
 107       render_view_id_(render_view_id),
 108       render_frame_id_(render_frame_id),
 109       shared_memory_(shared_memory.Pass()),
 110       reader_(reader.Pass()),
 111       controller_(media::AudioOutputController::Create(host->audio_manager_,
 112                                                        this,
 113                                                        params,
 114                                                        output_device_id,
 115                                                        reader_.get())),
 116       playing_(false) {
 117   DCHECK(controller_.get());
 118 }
 119
 120 AudioRendererHost::AudioEntry::~AudioEntry() {}
 121
 122 ///////////////////////////////////////////////////////////////////////////////
 123 // AudioRendererHost implementations.
 124
 125 AudioRendererHost::AudioRendererHost(
 126     int render_process_id,
 127     media::AudioManager* audio_manager,
 128     AudioMirroringManager* mirroring_manager,
 129     MediaInternals* media_internals,
 130     MediaStreamManager* media_stream_manager)
 131     : BrowserMessageFilter(AudioMsgStart),
 132       render_process_id_(render_process_id),
 133       audio_manager_(audio_manager),
 134       mirroring_manager_(mirroring_manager),
 135       audio_log_(media_internals->CreateAudioLog(
 136           media::AudioLogFactory::AUDIO_OUTPUT_CONTROLLER)),
 137       media_stream_manager_(media_stream_manager),
 138       num_playing_streams_(0) {
 139   DCHECK(audio_manager_);
 140   DCHECK(media_stream_manager_);
 141 }
 142
 143 AudioRendererHost::~AudioRendererHost() {
 144   DCHECK(audio_entries_.empty());
 145 }
 146
 147 void AudioRendererHost::GetOutputControllers(
 148     int render_view_id,
 149     const RenderViewHost::GetAudioOutputControllersCallback& callback) const {
 150   BrowserThread::PostTaskAndReplyWithResult(
 151       BrowserThread::IO,
 152       FROM_HERE,
 153       base::Bind(&AudioRendererHost::DoGetOutputControllers, this,
 154                  render_view_id),
 155       callback);
 156 }
 157
 158 void AudioRendererHost::OnChannelClosing() {
 159   // Since the IPC sender is gone, close all requested audio streams.
 160   while (!audio_entries_.empty()) {
 161     // Note: OnCloseStream() removes the entries from audio_entries_.
 162     OnCloseStream(audio_entries_.begin()->first);
 163   }
 164 }
 165
 166 void AudioRendererHost::OnDestruct() const {
 167   BrowserThread::DeleteOnIOThread::Destruct(this);
 168 }
 169
 170 void AudioRendererHost::AudioEntry::OnCreated() {
 171   BrowserThread::PostTask(
 172       BrowserThread::IO,
 173       FROM_HERE,
 174       base::Bind(&AudioRendererHost::DoCompleteCreation, host_, stream_id_));
 175 }
 176
 177 void AudioRendererHost::AudioEntry::OnPlaying() {
 178   BrowserThread::PostTask(
 179       BrowserThread::IO,
 180       FROM_HERE,
 181       base::Bind(&AudioRendererHost::DoNotifyStreamStateChanged,
 182                  host_,
 183                  stream_id_,
 184                  true));
 185 }
 186
 187 void AudioRendererHost::AudioEntry::OnPaused() {
 188   BrowserThread::PostTask(
 189       BrowserThread::IO,
 190       FROM_HERE,
 191       base::Bind(&AudioRendererHost::DoNotifyStreamStateChanged,
 192                  host_,
 193                  stream_id_,
 194                  false));
 195 }
 196
 197 void AudioRendererHost::AudioEntry::OnError() {
 198   BrowserThread::PostTask(
 199       BrowserThread::IO,
 200       FROM_HERE,
 201       base::Bind(&AudioRendererHost::ReportErrorAndClose, host_, stream_id_));
 202 }
 203
 204 void AudioRendererHost::AudioEntry::OnDeviceChange(int new_buffer_size,
 205                                                    int new_sample_rate) {
 206   BrowserThread::PostTask(
 207       BrowserThread::IO,
 208       FROM_HERE,
 209       base::Bind(base::IgnoreResult(&AudioRendererHost::Send), host_,
 210                  new AudioMsg_NotifyDeviceChanged(
 211                      stream_id_, new_buffer_size, new_sample_rate)));
 212 }
 213
 214 void AudioRendererHost::DoCompleteCreation(int stream_id) {
 215   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 216
 217   if (!PeerHandle()) {
 218     DLOG(WARNING) << "Renderer process handle is invalid.";
 219     ReportErrorAndClose(stream_id);
 220     return;
 221   }
 222
 223   AudioEntry* const entry = LookupById(stream_id);
 224   if (!entry) {
 225     ReportErrorAndClose(stream_id);
 226     return;
 227   }
 228
 229   // Once the audio stream is created then complete the creation process by
 230   // mapping shared memory and sharing with the renderer process.
 231   base::SharedMemoryHandle foreign_memory_handle;
 232   if (!entry->shared_memory()->ShareToProcess(PeerHandle(),
 233                                               &foreign_memory_handle)) {
 234     // If we failed to map and share the shared memory then close the audio
 235     // stream and send an error message.
 236     ReportErrorAndClose(entry->stream_id());
 237     return;
 238   }
 239
 240   AudioSyncReader* reader = static_cast<AudioSyncReader*>(entry->reader());
 241
 242   base::SyncSocket::TransitDescriptor socket_descriptor;
 243
 244   // If we failed to prepare the sync socket for the renderer then we fail
 245   // the construction of audio stream.
 246   if (!reader->PrepareForeignSocket(PeerHandle(), &socket_descriptor)) {
 247     ReportErrorAndClose(entry->stream_id());
 248     return;
 249   }
 250
 251   Send(new AudioMsg_NotifyStreamCreated(
 252       entry->stream_id(), foreign_memory_handle, socket_descriptor,
 253       entry->shared_memory()->requested_size()));
 254 }
 255
 256 void AudioRendererHost::DoNotifyStreamStateChanged(int stream_id,
 257                                                    bool is_playing) {
 258   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 259
 260   AudioEntry* const entry = LookupById(stream_id);
 261   if (!entry)
 262     return;
 263
 264   Send(new AudioMsg_NotifyStreamStateChanged(
 265       stream_id,
 266       is_playing ? media::AudioOutputIPCDelegate::kPlaying
 267                  : media::AudioOutputIPCDelegate::kPaused));
 268
 269   if (is_playing) {
 270     AudioStreamMonitor::StartMonitoringStream(
 271         render_process_id_,
 272         entry->render_frame_id(),
 273         entry->stream_id(),
 274         base::Bind(&media::AudioOutputController::ReadCurrentPowerAndClip,
 275                    entry->controller()));
 276     // TODO(dalecurtis): See about using AudioStreamMonitor instead.
 277     if (!entry->playing()) {
 278       entry->set_playing(true);
 279       base::AtomicRefCountInc(&num_playing_streams_);
 280     }
 281   } else {
 282     AudioStreamMonitor::StopMonitoringStream(
 283         render_process_id_, entry->render_frame_id(), entry->stream_id());
 284     // TODO(dalecurtis): See about using AudioStreamMonitor instead.
 285     if (entry->playing()) {
 286       entry->set_playing(false);
 287       base::AtomicRefCountDec(&num_playing_streams_);
 288     }
 289   }
 290 }
 291
 292 RenderViewHost::AudioOutputControllerList
 293 AudioRendererHost::DoGetOutputControllers(int render_view_id) const {
 294   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 295
 296   RenderViewHost::AudioOutputControllerList controllers;
 297   AudioEntryMap::const_iterator it = audio_entries_.begin();
 298   for (; it != audio_entries_.end(); ++it) {
 299     AudioEntry* entry = it->second;
 300     if (entry->render_view_id() == render_view_id)
 301       controllers.push_back(entry->controller());
 302   }
 303
 304   return controllers;
 305 }
 306
 307 ///////////////////////////////////////////////////////////////////////////////
 308 // IPC Messages handler
 309 bool AudioRendererHost::OnMessageReceived(const IPC::Message& message) {
 310   bool handled = true;
 311   IPC_BEGIN_MESSAGE_MAP(AudioRendererHost, message)
 312     IPC_MESSAGE_HANDLER(AudioHostMsg_CreateStream, OnCreateStream)
 313     IPC_MESSAGE_HANDLER(AudioHostMsg_PlayStream, OnPlayStream)
 314     IPC_MESSAGE_HANDLER(AudioHostMsg_PauseStream, OnPauseStream)
 315     IPC_MESSAGE_HANDLER(AudioHostMsg_CloseStream, OnCloseStream)
 316     IPC_MESSAGE_HANDLER(AudioHostMsg_SetVolume, OnSetVolume)
 317     IPC_MESSAGE_UNHANDLED(handled = false)
 318   IPC_END_MESSAGE_MAP()
 319
 320   return handled;
 321 }
 322
 323 void AudioRendererHost::OnCreateStream(
 324     int stream_id, int render_view_id, int render_frame_id, int session_id,
 325     const media::AudioParameters& params) {
 326   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 327
 328   DVLOG(1) << "AudioRendererHost@" << this
 329            << "::OnCreateStream(stream_id=" << stream_id
 330            << ", render_view_id=" << render_view_id
 331            << ", session_id=" << session_id << ")";
 332   DCHECK_GT(render_view_id, 0);
 333   DCHECK_GT(render_frame_id, 0);
 334
 335   // media::AudioParameters is validated in the deserializer.
 336   if (LookupById(stream_id) != NULL) {
 337     SendErrorMessage(stream_id);
 338     return;
 339   }
 340
 341   // Initialize the |output_device_id| to an empty string which indicates that
 342   // the default device should be used. If a StreamDeviceInfo instance was found
 343   // though, then we use the matched output device.
 344   std::string output_device_id;
 345   const StreamDeviceInfo* info = media_stream_manager_->
 346       audio_input_device_manager()->GetOpenedDeviceInfoById(session_id);
 347   if (info)
 348     output_device_id = info->device.matched_output_device_id;
 349
 350   // Create the shared memory and share with the renderer process.
 351   uint32 shared_memory_size = AudioBus::CalculateMemorySize(params);
 352   scoped_ptr<base::SharedMemory> shared_memory(new base::SharedMemory());
 353   if (!shared_memory->CreateAndMapAnonymous(shared_memory_size)) {
 354     SendErrorMessage(stream_id);
 355     return;
 356   }
 357
 358   scoped_ptr<AudioSyncReader> reader(
 359       new AudioSyncReader(shared_memory.get(), params));
 360   if (!reader->Init()) {
 361     SendErrorMessage(stream_id);
 362     return;
 363   }
 364
 365   MediaObserver* const media_observer =
 366       GetContentClient()->browser()->GetMediaObserver();
 367   if (media_observer)
 368     media_observer->OnCreatingAudioStream(render_process_id_, render_frame_id);
 369
 370   scoped_ptr<AudioEntry> entry(new AudioEntry(
 371       this,
 372       stream_id,
 373       render_view_id,
 374       render_frame_id,
 375       params,
 376       output_device_id,
 377       shared_memory.Pass(),
 378       reader.PassAs<media::AudioOutputController::SyncReader>()));
 379   if (mirroring_manager_) {
 380     mirroring_manager_->AddDiverter(
 381         render_process_id_, entry->render_frame_id(), entry->controller());
 382   }
 383   audio_entries_.insert(std::make_pair(stream_id, entry.release()));
 384   audio_log_->OnCreated(stream_id, params, output_device_id);
 385 }
 386
 387 void AudioRendererHost::OnPlayStream(int stream_id) {
 388   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 389
 390   AudioEntry* entry = LookupById(stream_id);
 391   if (!entry) {
 392     SendErrorMessage(stream_id);
 393     return;
 394   }
 395
 396   entry->controller()->Play();
 397   audio_log_->OnStarted(stream_id);
 398 }
 399
 400 void AudioRendererHost::OnPauseStream(int stream_id) {
 401   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 402
 403   AudioEntry* entry = LookupById(stream_id);
 404   if (!entry) {
 405     SendErrorMessage(stream_id);
 406     return;
 407   }
 408
 409   entry->controller()->Pause();
 410   audio_log_->OnStopped(stream_id);
 411 }
 412
 413 void AudioRendererHost::OnSetVolume(int stream_id, double volume) {
 414   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 415
 416   AudioEntry* entry = LookupById(stream_id);
 417   if (!entry) {
 418     SendErrorMessage(stream_id);
 419     return;
 420   }
 421
 422   // Make sure the volume is valid.
 423   if (volume < 0 || volume > 1.0)
 424     return;
 425   entry->controller()->SetVolume(volume);
 426   audio_log_->OnSetVolume(stream_id, volume);
 427 }
 428
 429 void AudioRendererHost::SendErrorMessage(int stream_id) {
 430   Send(new AudioMsg_NotifyStreamStateChanged(
 431       stream_id, media::AudioOutputIPCDelegate::kError));
 432 }
 433
 434 void AudioRendererHost::OnCloseStream(int stream_id) {
 435   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 436
 437   // Prevent oustanding callbacks from attempting to close/delete the same
 438   // AudioEntry twice.
 439   AudioEntryMap::iterator i = audio_entries_.find(stream_id);
 440   if (i == audio_entries_.end())
 441     return;
 442   scoped_ptr<AudioEntry> entry(i->second);
 443   audio_entries_.erase(i);
 444
 445   media::AudioOutputController* const controller = entry->controller();
 446   if (mirroring_manager_)
 447     mirroring_manager_->RemoveDiverter(controller);
 448   controller->Close(
 449       base::Bind(&AudioRendererHost::DeleteEntry, this, base::Passed(&entry)));
 450   audio_log_->OnClosed(stream_id);
 451 }
 452
 453 void AudioRendererHost::DeleteEntry(scoped_ptr<AudioEntry> entry) {
 454   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 455   AudioStreamMonitor::StopMonitoringStream(
 456       render_process_id_, entry->render_frame_id(), entry->stream_id());
 457   if (entry->playing())
 458     base::AtomicRefCountDec(&num_playing_streams_);
 459 }
 460
 461 void AudioRendererHost::ReportErrorAndClose(int stream_id) {
 462   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 463
 464   // Make sure this isn't a stray callback executing after the stream has been
 465   // closed, so error notifications aren't sent after clients believe the stream
 466   // is closed.
 467   if (!LookupById(stream_id))
 468     return;
 469
 470   SendErrorMessage(stream_id);
 471
 472   audio_log_->OnError(stream_id);
 473   OnCloseStream(stream_id);
 474 }
 475
 476 AudioRendererHost::AudioEntry* AudioRendererHost::LookupById(int stream_id) {
 477   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 478
 479   AudioEntryMap::const_iterator i = audio_entries_.find(stream_id);
 480   return i != audio_entries_.end() ? i->second : NULL;
 481 }
 482
 483 bool AudioRendererHost::HasActiveAudio() {
 484   return !base::AtomicRefCountIsZero(&num_playing_streams_);
 485 }
 486
 487 }  // namespace content