content/renderer/pepper/pepper_platform_audio_output.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/renderer/pepper/pepper_platform_audio_output.h"
   6
   7 #include "base/bind.h"
   8 #include "base/logging.h"
   9 #include "base/message_loop/message_loop_proxy.h"
  10 #include "build/build_config.h"
  11 #include "content/child/child_process.h"
  12 #include "content/common/media/audio_messages.h"
  13 #include "content/renderer/media/audio_message_filter.h"
  14 #include "content/renderer/pepper/audio_helper.h"
  15 #include "content/renderer/render_thread_impl.h"
  16 #include "media/base/audio_hardware_config.h"
  17 #include "ppapi/shared_impl/ppb_audio_config_shared.h"
  18
  19 namespace content {
  20
  21 // static
  22 PepperPlatformAudioOutput* PepperPlatformAudioOutput::Create(
  23     int sample_rate,
  24     int frames_per_buffer,
  25     int source_render_view_id,
  26     int source_render_frame_id,
  27     AudioHelper* client) {
  28   scoped_refptr<PepperPlatformAudioOutput> audio_output(
  29       new PepperPlatformAudioOutput());
  30   if (audio_output->Initialize(sample_rate,
  31                                frames_per_buffer,
  32                                source_render_view_id,
  33                                source_render_frame_id,
  34                                client)) {
  35     // Balanced by Release invoked in
  36     // PepperPlatformAudioOutput::ShutDownOnIOThread().
  37     audio_output->AddRef();
  38     return audio_output.get();
  39   }
  40   return NULL;
  41 }
  42
  43 bool PepperPlatformAudioOutput::StartPlayback() {
  44   if (ipc_) {
  45     io_message_loop_proxy_->PostTask(
  46         FROM_HERE,
  47         base::Bind(&PepperPlatformAudioOutput::StartPlaybackOnIOThread, this));
  48     return true;
  49   }
  50   return false;
  51 }
  52
  53 bool PepperPlatformAudioOutput::StopPlayback() {
  54   if (ipc_) {
  55     io_message_loop_proxy_->PostTask(
  56         FROM_HERE,
  57         base::Bind(&PepperPlatformAudioOutput::StopPlaybackOnIOThread, this));
  58     return true;
  59   }
  60   return false;
  61 }
  62
  63 void PepperPlatformAudioOutput::ShutDown() {
  64   // Called on the main thread to stop all audio callbacks. We must only change
  65   // the client on the main thread, and the delegates from the I/O thread.
  66   client_ = NULL;
  67   io_message_loop_proxy_->PostTask(
  68       FROM_HERE,
  69       base::Bind(&PepperPlatformAudioOutput::ShutDownOnIOThread, this));
  70 }
  71
  72 void PepperPlatformAudioOutput::OnStateChanged(
  73     media::AudioOutputIPCDelegate::State state) {}
  74
  75 void PepperPlatformAudioOutput::OnStreamCreated(
  76     base::SharedMemoryHandle handle,
  77     base::SyncSocket::Handle socket_handle,
  78     int length) {
  79 #if defined(OS_WIN)
  80   DCHECK(handle);
  81   DCHECK(socket_handle);
  82 #else
  83   DCHECK_NE(-1, handle.fd);
  84   DCHECK_NE(-1, socket_handle);
  85 #endif
  86   DCHECK(length);
  87
  88   if (base::MessageLoopProxy::current().get() ==
  89       main_message_loop_proxy_.get()) {
  90     // Must dereference the client only on the main thread. Shutdown may have
  91     // occurred while the request was in-flight, so we need to NULL check.
  92     if (client_)
  93       client_->StreamCreated(handle, length, socket_handle);
  94   } else {
  95     main_message_loop_proxy_->PostTask(
  96         FROM_HERE,
  97         base::Bind(&PepperPlatformAudioOutput::OnStreamCreated,
  98                    this,
  99                    handle,
 100                    socket_handle,
 101                    length));
 102   }
 103 }
 104
 105 void PepperPlatformAudioOutput::OnIPCClosed() { ipc_.reset(); }
 106
 107 PepperPlatformAudioOutput::~PepperPlatformAudioOutput() {
 108   // Make sure we have been shut down. Warning: this will usually happen on
 109   // the I/O thread!
 110   DCHECK(!ipc_);
 111   DCHECK(!client_);
 112 }
 113
 114 PepperPlatformAudioOutput::PepperPlatformAudioOutput()
 115     : client_(NULL),
 116       main_message_loop_proxy_(base::MessageLoopProxy::current()),
 117       io_message_loop_proxy_(ChildProcess::current()->io_message_loop_proxy()) {
 118 }
 119
 120 bool PepperPlatformAudioOutput::Initialize(int sample_rate,
 121                                            int frames_per_buffer,
 122                                            int source_render_view_id,
 123                                            int source_render_frame_id,
 124                                            AudioHelper* client) {
 125   DCHECK(client);
 126   client_ = client;
 127
 128   RenderThreadImpl* const render_thread = RenderThreadImpl::current();
 129   ipc_ = render_thread->audio_message_filter()->CreateAudioOutputIPC(
 130       source_render_view_id, source_render_frame_id);
 131   CHECK(ipc_);
 132
 133   media::AudioParameters params(media::AudioParameters::AUDIO_PCM_LOW_LATENCY,
 134                                 media::CHANNEL_LAYOUT_STEREO,
 135                                 sample_rate,
 136                                 ppapi::kBitsPerAudioOutputSample,
 137                                 frames_per_buffer);
 138
 139   io_message_loop_proxy_->PostTask(
 140       FROM_HERE,
 141       base::Bind(
 142           &PepperPlatformAudioOutput::InitializeOnIOThread, this, params));
 143   return true;
 144 }
 145
 146 void PepperPlatformAudioOutput::InitializeOnIOThread(
 147     const media::AudioParameters& params) {
 148   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
 149   const int kSessionId = 0;
 150   if (ipc_)
 151     ipc_->CreateStream(this, params, kSessionId);
 152 }
 153
 154 void PepperPlatformAudioOutput::StartPlaybackOnIOThread() {
 155   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
 156   if (ipc_)
 157     ipc_->PlayStream();
 158 }
 159
 160 void PepperPlatformAudioOutput::StopPlaybackOnIOThread() {
 161   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
 162   if (ipc_)
 163     ipc_->PauseStream();
 164 }
 165
 166 void PepperPlatformAudioOutput::ShutDownOnIOThread() {
 167   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
 168
 169   // Make sure we don't call shutdown more than once.
 170   if (!ipc_)
 171     return;
 172
 173   ipc_->CloseStream();
 174   ipc_.reset();
 175
 176   Release();  // Release for the delegate, balances out the reference taken in
 177               // PepperPlatformAudioOutput::Create.
 178 }
 179
 180 }  // namespace content