media/audio/pulse/pulse_unified.cc

   1 // Copyright 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 "media/audio/pulse/pulse_unified.h"
   6
   7 #include "base/message_loop/message_loop.h"
   8 #include "base/time/time.h"
   9 #include "media/audio/audio_manager_base.h"
  10 #include "media/audio/audio_parameters.h"
  11 #include "media/audio/pulse/pulse_util.h"
  12 #include "media/base/seekable_buffer.h"
  13
  14 namespace media {
  15
  16 using pulse::AutoPulseLock;
  17 using pulse::WaitForOperationCompletion;
  18
  19 static const int kFifoSizeInPackets = 10;
  20
  21 // static, pa_stream_notify_cb
  22 void PulseAudioUnifiedStream::StreamNotifyCallback(pa_stream* s,
  23                                                    void* user_data) {
  24   PulseAudioUnifiedStream* stream =
  25       static_cast<PulseAudioUnifiedStream*>(user_data);
  26
  27   // Forward unexpected failures to the AudioSourceCallback if available.  All
  28   // these variables are only modified under pa_threaded_mainloop_lock() so this
  29   // should be thread safe.
  30   if (s && stream->source_callback_ &&
  31       pa_stream_get_state(s) == PA_STREAM_FAILED) {
  32     stream->source_callback_->OnError(stream);
  33   }
  34
  35   pa_threaded_mainloop_signal(stream->pa_mainloop_, 0);
  36 }
  37
  38 // static, used by pa_stream_set_read_callback.
  39 void PulseAudioUnifiedStream::ReadCallback(pa_stream* handle, size_t length,
  40                                            void* user_data) {
  41   static_cast<PulseAudioUnifiedStream*>(user_data)->ReadData();
  42 }
  43
  44 PulseAudioUnifiedStream::PulseAudioUnifiedStream(
  45     const AudioParameters& params,
  46     const std::string& input_device_id,
  47     AudioManagerBase* manager)
  48     : params_(params),
  49       input_device_id_(input_device_id),
  50       manager_(manager),
  51       pa_context_(NULL),
  52       pa_mainloop_(NULL),
  53       input_stream_(NULL),
  54       output_stream_(NULL),
  55       volume_(1.0f),
  56       source_callback_(NULL) {
  57   DCHECK(manager_->GetMessageLoop()->BelongsToCurrentThread());
  58   CHECK(params_.IsValid());
  59   input_bus_ = AudioBus::Create(params_);
  60   output_bus_ = AudioBus::Create(params_);
  61 }
  62
  63 PulseAudioUnifiedStream::~PulseAudioUnifiedStream() {
  64   // All internal structures should already have been freed in Close(), which
  65   // calls AudioManagerBase::ReleaseOutputStream() which deletes this object.
  66   DCHECK(!input_stream_);
  67   DCHECK(!output_stream_);
  68   DCHECK(!pa_context_);
  69   DCHECK(!pa_mainloop_);
  70 }
  71
  72 bool PulseAudioUnifiedStream::Open() {
  73   DCHECK(manager_->GetMessageLoop()->BelongsToCurrentThread());
  74   // Prepare the recording buffers for the callbacks.
  75   fifo_.reset(new media::SeekableBuffer(
  76       0, kFifoSizeInPackets * params_.GetBytesPerBuffer()));
  77   input_data_buffer_.reset(new uint8[params_.GetBytesPerBuffer()]);
  78
  79   if (!pulse::CreateOutputStream(&pa_mainloop_, &pa_context_, &output_stream_,
  80                                  params_, &StreamNotifyCallback, NULL, this))
  81     return false;
  82
  83   if (!pulse::CreateInputStream(pa_mainloop_, pa_context_, &input_stream_,
  84                                 params_, input_device_id_,
  85                                 &StreamNotifyCallback, this))
  86     return false;
  87
  88   DCHECK(pa_mainloop_);
  89   DCHECK(pa_context_);
  90   DCHECK(input_stream_);
  91   DCHECK(output_stream_);
  92   return true;
  93 }
  94
  95 void PulseAudioUnifiedStream::Reset() {
  96   if (!pa_mainloop_) {
  97     DCHECK(!input_stream_);
  98     DCHECK(!output_stream_);
  99     DCHECK(!pa_context_);
 100     return;
 101   }
 102
 103   {
 104     AutoPulseLock auto_lock(pa_mainloop_);
 105
 106     // Close the input stream.
 107     if (input_stream_) {
 108       // Disable all the callbacks before disconnecting.
 109       pa_stream_set_state_callback(input_stream_, NULL, NULL);
 110       pa_stream_flush(input_stream_, NULL, NULL);
 111       pa_stream_disconnect(input_stream_);
 112
 113       // Release PulseAudio structures.
 114       pa_stream_unref(input_stream_);
 115       input_stream_ = NULL;
 116     }
 117
 118     // Close the ouput stream.
 119     if (output_stream_) {
 120       // Release PulseAudio output stream structures.
 121       pa_stream_set_state_callback(output_stream_, NULL, NULL);
 122       pa_stream_disconnect(output_stream_);
 123       pa_stream_unref(output_stream_);
 124       output_stream_ = NULL;
 125     }
 126
 127     if (pa_context_) {
 128       pa_context_disconnect(pa_context_);
 129       pa_context_set_state_callback(pa_context_, NULL, NULL);
 130       pa_context_unref(pa_context_);
 131       pa_context_ = NULL;
 132     }
 133   }
 134
 135   pa_threaded_mainloop_stop(pa_mainloop_);
 136   pa_threaded_mainloop_free(pa_mainloop_);
 137   pa_mainloop_ = NULL;
 138 }
 139
 140 void PulseAudioUnifiedStream::Close() {
 141   DCHECK(manager_->GetMessageLoop()->BelongsToCurrentThread());
 142   Reset();
 143
 144   // Signal to the manager that we're closed and can be removed.
 145   // This should be the last call in the function as it deletes "this".
 146   manager_->ReleaseOutputStream(this);
 147 }
 148
 149 void PulseAudioUnifiedStream::WriteData(size_t requested_bytes) {
 150   CHECK_EQ(requested_bytes, static_cast<size_t>(params_.GetBytesPerBuffer()));
 151
 152   void* buffer = NULL;
 153   int frames_filled = 0;
 154   if (source_callback_) {
 155     CHECK_GE(pa_stream_begin_write(
 156         output_stream_, &buffer, &requested_bytes), 0);
 157     uint32 hardware_delay = pulse::GetHardwareLatencyInBytes(
 158         output_stream_, params_.sample_rate(),
 159         params_.GetBytesPerFrame());
 160     fifo_->Read(input_data_buffer_.get(), requested_bytes);
 161     input_bus_->FromInterleaved(
 162         input_data_buffer_.get(), params_.frames_per_buffer(), 2);
 163
 164     frames_filled = source_callback_->OnMoreIOData(
 165         input_bus_.get(),
 166         output_bus_.get(),
 167         AudioBuffersState(0, hardware_delay));
 168   }
 169
 170   // Zero the unfilled data so it plays back as silence.
 171   if (frames_filled < output_bus_->frames()) {
 172     output_bus_->ZeroFramesPartial(
 173         frames_filled, output_bus_->frames() - frames_filled);
 174   }
 175
 176   // Note: If this ever changes to output raw float the data must be clipped
 177   // and sanitized since it may come from an untrusted source such as NaCl.
 178   output_bus_->Scale(volume_);
 179   output_bus_->ToInterleaved(
 180       output_bus_->frames(), params_.bits_per_sample() / 8, buffer);
 181
 182   if (pa_stream_write(output_stream_, buffer, requested_bytes, NULL, 0LL,
 183                       PA_SEEK_RELATIVE) < 0) {
 184     if (source_callback_) {
 185       source_callback_->OnError(this);
 186     }
 187   }
 188 }
 189
 190 void PulseAudioUnifiedStream::ReadData() {
 191   do {
 192     size_t length = 0;
 193     const void* data = NULL;
 194     pa_stream_peek(input_stream_, &data, &length);
 195     if (!data || length == 0)
 196       break;
 197
 198     fifo_->Append(reinterpret_cast<const uint8*>(data), length);
 199
 200     // Deliver the recording data to the renderer and drive the playout.
 201     int packet_size = params_.GetBytesPerBuffer();
 202     while (fifo_->forward_bytes() >= packet_size) {
 203       WriteData(packet_size);
 204     }
 205
 206     // Checks if we still have data.
 207     pa_stream_drop(input_stream_);
 208   } while (pa_stream_readable_size(input_stream_) > 0);
 209
 210   pa_threaded_mainloop_signal(pa_mainloop_, 0);
 211 }
 212
 213 void PulseAudioUnifiedStream::Start(AudioSourceCallback* callback) {
 214   DCHECK(manager_->GetMessageLoop()->BelongsToCurrentThread());
 215   CHECK(callback);
 216   CHECK(input_stream_);
 217   CHECK(output_stream_);
 218   AutoPulseLock auto_lock(pa_mainloop_);
 219
 220   // Ensure the context and stream are ready.
 221   if (pa_context_get_state(pa_context_) != PA_CONTEXT_READY &&
 222       pa_stream_get_state(output_stream_) != PA_STREAM_READY &&
 223       pa_stream_get_state(input_stream_) != PA_STREAM_READY) {
 224     callback->OnError(this);
 225     return;
 226   }
 227
 228   source_callback_ = callback;
 229
 230   fifo_->Clear();
 231
 232   // Uncork (resume) the input stream.
 233   pa_stream_set_read_callback(input_stream_, &ReadCallback, this);
 234   pa_stream_readable_size(input_stream_);
 235   pa_operation* operation = pa_stream_cork(input_stream_, 0, NULL, NULL);
 236   WaitForOperationCompletion(pa_mainloop_, operation);
 237
 238   // Uncork (resume) the output stream.
 239   // We use the recording stream to drive the playback, so we do not need to
 240   // register the write callback using pa_stream_set_write_callback().
 241   operation = pa_stream_cork(output_stream_, 0,
 242                              &pulse::StreamSuccessCallback, pa_mainloop_);
 243   WaitForOperationCompletion(pa_mainloop_, operation);
 244 }
 245
 246 void PulseAudioUnifiedStream::Stop() {
 247   DCHECK(manager_->GetMessageLoop()->BelongsToCurrentThread());
 248
 249   // Cork (pause) the stream.  Waiting for the main loop lock will ensure
 250   // outstanding callbacks have completed.
 251   AutoPulseLock auto_lock(pa_mainloop_);
 252
 253   // Set |source_callback_| to NULL so all FulfillWriteRequest() calls which may
 254   // occur while waiting on the flush and cork exit immediately.
 255   source_callback_ = NULL;
 256
 257   // Set the read callback to NULL before flushing the stream, otherwise it
 258   // will cause deadlock on the operation.
 259   pa_stream_set_read_callback(input_stream_, NULL, NULL);
 260   pa_operation* operation = pa_stream_flush(
 261       input_stream_, &pulse::StreamSuccessCallback, pa_mainloop_);
 262   WaitForOperationCompletion(pa_mainloop_, operation);
 263
 264   operation = pa_stream_cork(input_stream_, 1, &pulse::StreamSuccessCallback,
 265                              pa_mainloop_);
 266   WaitForOperationCompletion(pa_mainloop_, operation);
 267
 268   // Flush the stream prior to cork, doing so after will cause hangs.  Write
 269   // callbacks are suspended while inside pa_threaded_mainloop_lock() so this
 270   // is all thread safe.
 271   operation = pa_stream_flush(
 272       output_stream_, &pulse::StreamSuccessCallback, pa_mainloop_);
 273   WaitForOperationCompletion(pa_mainloop_, operation);
 274
 275   operation = pa_stream_cork(output_stream_, 1, &pulse::StreamSuccessCallback,
 276                              pa_mainloop_);
 277   WaitForOperationCompletion(pa_mainloop_, operation);
 278 }
 279
 280 void PulseAudioUnifiedStream::SetVolume(double volume) {
 281   DCHECK(manager_->GetMessageLoop()->BelongsToCurrentThread());
 282
 283   volume_ = static_cast<float>(volume);
 284 }
 285
 286 void PulseAudioUnifiedStream::GetVolume(double* volume) {
 287   DCHECK(manager_->GetMessageLoop()->BelongsToCurrentThread());
 288
 289   *volume = volume_;
 290 }
 291
 292 }  // namespace media