Home | History | Annotate | Download | only in pulse 
      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
    217