media/audio/pulse/pulse_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 "media/audio/pulse/pulse_output.h"
   6
   7 #include <pulse/pulseaudio.h>
   8
   9 #include "base/message_loop/message_loop.h"
  10 #include "media/audio/audio_manager_base.h"
  11 #include "media/audio/audio_parameters.h"
  12 #include "media/audio/pulse/pulse_util.h"
  13
  14 namespace media {
  15
  16 using pulse::AutoPulseLock;
  17 using pulse::WaitForOperationCompletion;
  18
  19 // static, pa_stream_notify_cb
  20 void PulseAudioOutputStream::StreamNotifyCallback(pa_stream* s, void* p_this) {
  21   PulseAudioOutputStream* stream = static_cast<PulseAudioOutputStream*>(p_this);
  22
  23   // Forward unexpected failures to the AudioSourceCallback if available.  All
  24   // these variables are only modified under pa_threaded_mainloop_lock() so this
  25   // should be thread safe.
  26   if (s && stream->source_callback_ &&
  27       pa_stream_get_state(s) == PA_STREAM_FAILED) {
  28     stream->source_callback_->OnError(stream);
  29   }
  30
  31   pa_threaded_mainloop_signal(stream->pa_mainloop_, 0);
  32 }
  33
  34 // static, pa_stream_request_cb_t
  35 void PulseAudioOutputStream::StreamRequestCallback(pa_stream* s, size_t len,
  36                                                    void* p_this) {
  37   // Fulfill write request; must always result in a pa_stream_write() call.
  38   static_cast<PulseAudioOutputStream*>(p_this)->FulfillWriteRequest(len);
  39 }
  40
  41 PulseAudioOutputStream::PulseAudioOutputStream(const AudioParameters& params,
  42                                                AudioManagerBase* manager)
  43     : params_(params),
  44       manager_(manager),
  45       pa_context_(NULL),
  46       pa_mainloop_(NULL),
  47       pa_stream_(NULL),
  48       volume_(1.0f),
  49       source_callback_(NULL) {
  50   DCHECK(manager_->GetMessageLoop()->BelongsToCurrentThread());
  51
  52   CHECK(params_.IsValid());
  53   audio_bus_ = AudioBus::Create(params_);
  54 }
  55
  56 PulseAudioOutputStream::~PulseAudioOutputStream() {
  57   // All internal structures should already have been freed in Close(), which
  58   // calls AudioManagerBase::ReleaseOutputStream() which deletes this object.
  59   DCHECK(!pa_stream_);
  60   DCHECK(!pa_context_);
  61   DCHECK(!pa_mainloop_);
  62 }
  63
  64 bool PulseAudioOutputStream::Open() {
  65   DCHECK(manager_->GetMessageLoop()->BelongsToCurrentThread());
  66   return pulse::CreateOutputStream(&pa_mainloop_, &pa_context_, &pa_stream_,
  67                                    params_, &StreamNotifyCallback,
  68                                    &StreamRequestCallback, this);
  69 }
  70
  71 void PulseAudioOutputStream::Reset() {
  72   if (!pa_mainloop_) {
  73     DCHECK(!pa_stream_);
  74     DCHECK(!pa_context_);
  75     return;
  76   }
  77
  78   {
  79     AutoPulseLock auto_lock(pa_mainloop_);
  80
  81     // Close the stream.
  82     if (pa_stream_) {
  83       // Ensure all samples are played out before shutdown.
  84       pa_operation* operation = pa_stream_flush(
  85           pa_stream_, &pulse::StreamSuccessCallback, pa_mainloop_);
  86       WaitForOperationCompletion(pa_mainloop_, operation);
  87
  88       // Release PulseAudio structures.
  89       pa_stream_disconnect(pa_stream_);
  90       pa_stream_set_write_callback(pa_stream_, NULL, NULL);
  91       pa_stream_set_state_callback(pa_stream_, NULL, NULL);
  92       pa_stream_unref(pa_stream_);
  93       pa_stream_ = NULL;
  94     }
  95
  96     if (pa_context_) {
  97       pa_context_disconnect(pa_context_);
  98       pa_context_set_state_callback(pa_context_, NULL, NULL);
  99       pa_context_unref(pa_context_);
 100       pa_context_ = NULL;
 101     }
 102   }
 103
 104   pa_threaded_mainloop_stop(pa_mainloop_);
 105   pa_threaded_mainloop_free(pa_mainloop_);
 106   pa_mainloop_ = NULL;
 107 }
 108
 109 void PulseAudioOutputStream::Close() {
 110   DCHECK(manager_->GetMessageLoop()->BelongsToCurrentThread());
 111
 112   Reset();
 113
 114   // Signal to the manager that we're closed and can be removed.
 115   // This should be the last call in the function as it deletes "this".
 116   manager_->ReleaseOutputStream(this);
 117 }
 118
 119 void PulseAudioOutputStream::FulfillWriteRequest(size_t requested_bytes) {
 120   int bytes_remaining = requested_bytes;
 121   while (bytes_remaining > 0) {
 122     void* buffer = NULL;
 123     size_t bytes_to_fill = params_.GetBytesPerBuffer();
 124     CHECK_GE(pa_stream_begin_write(pa_stream_, &buffer, &bytes_to_fill), 0);
 125     CHECK_EQ(bytes_to_fill, static_cast<size_t>(params_.GetBytesPerBuffer()));
 126
 127     int frames_filled = 0;
 128     if (source_callback_) {
 129       uint32 hardware_delay = pulse::GetHardwareLatencyInBytes(
 130           pa_stream_, params_.sample_rate(),
 131           params_.GetBytesPerFrame());
 132       frames_filled = source_callback_->OnMoreData(
 133           audio_bus_.get(), AudioBuffersState(0, hardware_delay));
 134     }
 135
 136     // Zero any unfilled data so it plays back as silence.
 137     if (frames_filled < audio_bus_->frames()) {
 138       audio_bus_->ZeroFramesPartial(
 139           frames_filled, audio_bus_->frames() - frames_filled);
 140     }
 141
 142     // Note: If this ever changes to output raw float the data must be clipped
 143     // and sanitized since it may come from an untrusted source such as NaCl.
 144     audio_bus_->Scale(volume_);
 145     audio_bus_->ToInterleaved(
 146         audio_bus_->frames(), params_.bits_per_sample() / 8, buffer);
 147
 148     if (pa_stream_write(pa_stream_, buffer, bytes_to_fill, NULL, 0LL,
 149                         PA_SEEK_RELATIVE) < 0) {
 150       if (source_callback_) {
 151         source_callback_->OnError(this);
 152       }
 153     }
 154
 155     bytes_remaining -= bytes_to_fill;
 156   }
 157 }
 158
 159 void PulseAudioOutputStream::Start(AudioSourceCallback* callback) {
 160   DCHECK(manager_->GetMessageLoop()->BelongsToCurrentThread());
 161   CHECK(callback);
 162   CHECK(pa_stream_);
 163
 164   AutoPulseLock auto_lock(pa_mainloop_);
 165
 166   // Ensure the context and stream are ready.
 167   if (pa_context_get_state(pa_context_) != PA_CONTEXT_READY &&
 168       pa_stream_get_state(pa_stream_) != PA_STREAM_READY) {
 169     callback->OnError(this);
 170     return;
 171   }
 172
 173   source_callback_ = callback;
 174
 175   // Uncork (resume) the stream.
 176   pa_operation* operation = pa_stream_cork(
 177       pa_stream_, 0, &pulse::StreamSuccessCallback, pa_mainloop_);
 178   WaitForOperationCompletion(pa_mainloop_, operation);
 179 }
 180
 181 void PulseAudioOutputStream::Stop() {
 182   DCHECK(manager_->GetMessageLoop()->BelongsToCurrentThread());
 183
 184   // Cork (pause) the stream.  Waiting for the main loop lock will ensure
 185   // outstanding callbacks have completed.
 186   AutoPulseLock auto_lock(pa_mainloop_);
 187
 188   // Set |source_callback_| to NULL so all FulfillWriteRequest() calls which may
 189   // occur while waiting on the flush and cork exit immediately.
 190   source_callback_ = NULL;
 191
 192   // Flush the stream prior to cork, doing so after will cause hangs.  Write
 193   // callbacks are suspended while inside pa_threaded_mainloop_lock() so this
 194   // is all thread safe.
 195   pa_operation* operation = pa_stream_flush(
 196       pa_stream_, &pulse::StreamSuccessCallback, pa_mainloop_);
 197   WaitForOperationCompletion(pa_mainloop_, operation);
 198
 199   operation = pa_stream_cork(pa_stream_, 1, &pulse::StreamSuccessCallback,
 200                              pa_mainloop_);
 201   WaitForOperationCompletion(pa_mainloop_, operation);
 202 }
 203
 204 void PulseAudioOutputStream::SetVolume(double volume) {
 205   DCHECK(manager_->GetMessageLoop()->BelongsToCurrentThread());
 206
 207   volume_ = static_cast<float>(volume);
 208 }
 209
 210 void PulseAudioOutputStream::GetVolume(double* volume) {
 211   DCHECK(manager_->GetMessageLoop()->BelongsToCurrentThread());
 212
 213   *volume = volume_;
 214 }
 215
 216 }  // namespace media