Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(587)

Unified Diff: media/audio/linux/pulse_output.cc

Issue 7473021: PulseAudio Sound Playback on Linux (Closed) Base URL: http://git.chromium.org/git/chromium.git@trunk
Patch Set: "New buffering scheme, per offline with vrk" Created 9 years, 4 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « media/audio/linux/pulse_output.h ('k') | media/base/media_switches.h » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: media/audio/linux/pulse_output.cc
diff --git a/media/audio/linux/pulse_output.cc b/media/audio/linux/pulse_output.cc
new file mode 100644
index 0000000000000000000000000000000000000000..05ae2247e164e9c298b14f5ba7783e670521a0ed
--- /dev/null
+++ b/media/audio/linux/pulse_output.cc
@@ -0,0 +1,325 @@
+// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "media/audio/linux/pulse_output.h"
+
+#include "media/audio/audio_util.h"
+#include "media/audio/linux/audio_manager_linux.h"
+#include "media/base/data_buffer.h"
+#include "media/base/seekable_buffer.h"
+
+static pa_sample_format_t BitsToFormat(int bits_per_sample) {
+ switch (bits_per_sample) {
+ // Unsupported sample formats shown for reference. I am assuming we want
+ // signed and little endian because that is what we gave to ALSA.
+ case 8:
+ return PA_SAMPLE_U8;
+ // Also 8-bits: PA_SAMPLE_ALAW and PA_SAMPLE_ULAW
+ case 16:
+ return PA_SAMPLE_S16LE;
+ // Also 16-bits: PA_SAMPLE_S16BE (big endian).
+ case 24:
+ return PA_SAMPLE_S24LE;
+ // Also 24-bits: PA_SAMPLE_S24BE (big endian).
+ // Other cases: PA_SAMPLE_24_32LE (in LSB of 32-bit field, little endian),
+ // and PA_SAMPLE_24_32BE (in LSB of 32-bit field, big endian),
+ case 32:
+ return PA_SAMPLE_S32LE;
+ // Also 32-bits: PA_SAMPLE_S32BE (big endian),
+ // PA_SAMPLE_FLOAT32LE (floating point little endian),
+ // and PA_SAMPLE_FLOAT32BE (floating point big endian).
+ default:
+ return PA_SAMPLE_INVALID;
+ }
+}
+
+static size_t MicrosecondsToBytes(
+ uint32 microseconds, uint32 sample_rate, size_t bytes_per_frame) {
+ return microseconds * sample_rate * bytes_per_frame /
+ base::Time::kMicrosecondsPerSecond;
+}
+
+void PulseAudioOutputStream::ContextStateCallback(pa_context* context,
+ void* userdata) {
+ pa_context_state_t* state = static_cast<pa_context_state_t*>(userdata);
+ *state = pa_context_get_state(context);
+}
+
+void PulseAudioOutputStream::StreamWriteRequestCallback(
+ pa_stream* playback_handle, size_t length, void* userdata) {
+ PulseAudioOutputStream* stream =
+ static_cast<PulseAudioOutputStream*>(userdata);
+
+ DCHECK_EQ(stream->message_loop_, MessageLoop::current());
+
+ stream->write_callback_handled_ = true;
+
+ stream->Write(length);
+
+ // Continue playback.
+ stream->message_loop_->PostTask(
+ FROM_HERE,
+ stream->method_factory_.NewRunnableMethod(
+ &PulseAudioOutputStream::WaitForWriteTask));
+}
+
+PulseAudioOutputStream::PulseAudioOutputStream(const AudioParameters& params,
+ AudioManagerLinux* manager,
+ MessageLoop* message_loop)
+ : channel_layout_(params.channel_layout),
+ channel_count_(ChannelLayoutToChannelCount(channel_layout_)),
+ sample_format_(BitsToFormat(params.bits_per_sample)),
+ sample_rate_(params.sample_rate),
+ bytes_per_frame_(params.channels * params.bits_per_sample / 8),
+ manager_(manager),
+ pa_context_(NULL),
+ pa_mainloop_(NULL),
+ playback_handle_(NULL),
+ packet_size_(params.GetPacketSize()),
+ frames_per_packet_(packet_size_ / bytes_per_frame_),
+ client_buffer_(NULL),
+ source_exhausted_(false),
+ volume_(1.0f),
+ stream_stopped_(true),
+ write_callback_handled_(false),
+ message_loop_(message_loop),
+ ALLOW_THIS_IN_INITIALIZER_LIST(method_factory_(this)),
+ source_callback_(NULL) {
+ DCHECK_EQ(message_loop_, MessageLoop::current());
+
+ DCHECK(manager_);
+
+ // TODO(slock): Sanity check input values.
+}
+
+PulseAudioOutputStream::~PulseAudioOutputStream() {
+ // All internal structures should already have been freed in Close(),
+ // which calls AudioManagerLinux::Release which deletes this object.
+ DCHECK(!playback_handle_);
+ DCHECK(!pa_context_);
+ DCHECK(!pa_mainloop_);
+}
+
+bool PulseAudioOutputStream::Open() {
+ DCHECK_EQ(message_loop_, MessageLoop::current());
+
+ // TODO(slock): Possibly move most of this to a OpenPlaybackDevice function in
+ // a new class 'pulse_util', like alsa_util.
+
+ // Create a mainloop API and connect to the default server.
+ pa_mainloop_ = pa_mainloop_new();
+ pa_mainloop_api* pa_mainloop_api = pa_mainloop_get_api(pa_mainloop_);
+ pa_context_ = pa_context_new(pa_mainloop_api, "Chromium");
+ pa_context_state_t pa_context_state = PA_CONTEXT_UNCONNECTED;
+ pa_context_connect(pa_context_, NULL, PA_CONTEXT_NOFLAGS, NULL);
+
+ // Wait until PulseAudio is ready.
+ pa_context_set_state_callback(pa_context_, &ContextStateCallback,
+ &pa_context_state);
+ while (pa_context_state != PA_CONTEXT_READY) {
+ pa_mainloop_iterate(pa_mainloop_, 1, NULL);
+ if (pa_context_state == PA_CONTEXT_FAILED ||
+ pa_context_state == PA_CONTEXT_TERMINATED) {
+ stream_stopped_ = true;
+ Reset();
+ return false;
+ }
+ }
+
+ // Set sample specifications and open playback stream.
+ pa_sample_spec pa_sample_specifications;
+ pa_sample_specifications.format = sample_format_;
+ pa_sample_specifications.rate = sample_rate_;
+ pa_sample_specifications.channels = channel_count_;
+ playback_handle_ = pa_stream_new(pa_context_, "Playback",
+ &pa_sample_specifications, NULL);
+
+ // Initialize client buffer.
+ uint32 output_packet_size = frames_per_packet_ * bytes_per_frame_;
+ client_buffer_.reset(new media::SeekableBuffer(0, output_packet_size));
+
+ // Set write callback.
+ pa_stream_set_write_callback(playback_handle_, &StreamWriteRequestCallback,
+ this);
+
+ // Set server-side buffer attributes.
+ // (uint32_t)-1 is the default and recommended value from PulseAudio's
+ // documentation, found at:
+ // http://freedesktop.org/software/pulseaudio/doxygen/structpa__buffer__attr.html.
+ pa_buffer_attr pa_buffer_attributes;
+ pa_buffer_attributes.maxlength = static_cast<uint32_t>(-1);
+ pa_buffer_attributes.tlength = output_packet_size;
+ pa_buffer_attributes.prebuf = static_cast<uint32_t>(-1);
+ pa_buffer_attributes.minreq = static_cast<uint32_t>(-1);
+ pa_buffer_attributes.fragsize = static_cast<uint32_t>(-1);
+
+ // Connect playback stream.
+ pa_stream_connect_playback(playback_handle_, NULL,
+ &pa_buffer_attributes,
+ (pa_stream_flags_t)
+ (PA_STREAM_INTERPOLATE_TIMING |
+ PA_STREAM_ADJUST_LATENCY |
+ PA_STREAM_AUTO_TIMING_UPDATE),
+ NULL, NULL);
+
+ if (!playback_handle_) {
+ stream_stopped_ = true;
+ Reset();
+ return false;
+ }
+
+ return true;
+}
+
+void PulseAudioOutputStream::Reset() {
+ // Close the stream.
+ if (playback_handle_) {
+ pa_stream_flush(playback_handle_, NULL, NULL);
+ pa_stream_disconnect(playback_handle_);
+
+ // Release PulseAudio structures.
+ pa_stream_unref(playback_handle_);
+ playback_handle_ = NULL;
+ }
+ if (pa_context_) {
+ pa_context_unref(pa_context_);
+ pa_context_ = NULL;
+ }
+ if (pa_mainloop_) {
+ pa_mainloop_free(pa_mainloop_);
+ pa_mainloop_ = NULL;
+ }
+ // |pa_mainloop_api| is freed with |pa_mainloop_|.
+
+ // Release internal buffer.
+ client_buffer_.reset();
+}
+
+void PulseAudioOutputStream::Close() {
+ DCHECK_EQ(message_loop_, MessageLoop::current());
+
+ Reset();
+
+ // Signal to the manager that we're closed and can be removed.
+ // This should be the last call in the function as it deletes "this".
+ manager_->ReleaseOutputStream(this);
+}
+
+void PulseAudioOutputStream::WaitForWriteTask() {
+ DCHECK_EQ(message_loop_, MessageLoop::current());
+
+ // Iterate the PulseAudio mainloop until the WriteCallback is called or the
+ // stream is stopped. The PulseAudio mainloop will call the WriteCallback to
+ // request more data when the server-side buffer needs more data to write to
+ // the audio sink. WriteCallback moves data from the |client_buffer_| to the
+ // server-side buffer. If the |client_buffer_| doesn't have enough data for
+ // the request, BufferPacketInClient is called to move data from the source
+ // into |client_buffer_|.
+ // WARNING: This blocks in PulseAudio until a WriteCallback occurs.
+ // TODO(slock): Fix this.
+ write_callback_handled_ = false;
+ while (!write_callback_handled_ && !stream_stopped_ && !source_exhausted_)
+ pa_mainloop_iterate(pa_mainloop_, 1, NULL);
+}
+
+void PulseAudioOutputStream::BufferPacket() {
+ uint32 buffer_delay = client_buffer_->forward_bytes();
+ pa_usec_t pa_latency_micros;
+ int negative;
+ pa_stream_get_latency(playback_handle_, &pa_latency_micros, &negative);
+ uint32 hardware_delay = MicrosecondsToBytes(pa_latency_micros,
+ sample_rate_,
+ bytes_per_frame_);
+ // TODO(slock): Deal with negative latency (negative == 1). This has yet
+ // to happen in practice though.
+ scoped_refptr<media::DataBuffer> packet =
+ new media::DataBuffer(packet_size_);
+ size_t packet_size = RunDataCallback(packet->GetWritableData(),
+ packet->GetBufferSize(),
+ AudioBuffersState(buffer_delay,
+ hardware_delay));
+
+ // TODO(slock): Swizzling and downmixing.
+
+ media::AdjustVolume(packet->GetWritableData(),
vrk (LEFT CHROMIUM) 2011/08/16 18:19:24 I would think AdjustVolume should only be called i
slock 2011/08/16 23:18:58 Done.
+ packet_size,
+ channel_count_,
+ bytes_per_frame_ / channel_count_,
+ volume_);
+
+ if (packet_size > 0) {
+ packet->SetDataSize(packet_size);
+ // Add the packet to the buffer.
+ client_buffer_->Append(packet);
+ }
+}
+
+void PulseAudioOutputStream::Write(size_t requested_bytes) {
+ // If we don't have enough data buffered, get more from the source.
+ while (client_buffer_->forward_bytes() < requested_bytes)
vrk (LEFT CHROMIUM) 2011/08/16 18:19:24 Fix the stalling here if you don't have enough dat
slock 2011/08/16 23:18:58 Done.
+ BufferPacket();
+
+ size_t bytes_written = 0;
+ while (bytes_written < requested_bytes) {
+ // If we need more data from the source to complete the request.
+
+ // Get data to write.
+ const uint8* current_chunk;
+ size_t current_chunk_size;
+ client_buffer_->GetCurrentChunk(&current_chunk, &current_chunk_size);
+
+ if (current_chunk_size > 0) {
+ pa_stream_write(playback_handle_, current_chunk, current_chunk_size,
+ NULL, 0LL, PA_SEEK_RELATIVE);
+ client_buffer_->Seek(current_chunk_size);
+ bytes_written += current_chunk_size;
+ }
+ }
+}
+
+void PulseAudioOutputStream::Start(AudioSourceCallback* callback) {
+ DCHECK_EQ(message_loop_, MessageLoop::current());
+
+ CHECK(callback);
+ source_callback_ = callback;
+
+ // Clear buffer, it might still have data in it.
+ client_buffer_->Clear();
+ stream_stopped_ = false;
+ source_exhausted_ = false;
+
+ // Start playback.
+ message_loop_->PostTask(
+ FROM_HERE,
+ method_factory_.NewRunnableMethod(
+ &PulseAudioOutputStream::WaitForWriteTask));
+}
+
+void PulseAudioOutputStream::Stop() {
+ DCHECK_EQ(message_loop_, MessageLoop::current());
+
+ // Effect will not be instantaneous as the PulseAudio server buffer drains.
+ // TODO(slock): Immediate stopping.
+ stream_stopped_ = true;
+}
+
+void PulseAudioOutputStream::SetVolume(double volume) {
+ DCHECK_EQ(message_loop_, MessageLoop::current());
+
+ volume_ = static_cast<float>(volume);
+}
+
+void PulseAudioOutputStream::GetVolume(double* volume) {
+ DCHECK_EQ(message_loop_, MessageLoop::current());
+
+ *volume = volume_;
+}
+
+uint32 PulseAudioOutputStream::RunDataCallback(
+ uint8* dest, uint32 max_size, AudioBuffersState buffers_state) {
+ if (source_callback_)
+ return source_callback_->OnMoreData(this, dest, max_size, buffers_state);
+
+ return 0;
+}
« no previous file with comments | « media/audio/linux/pulse_output.h ('k') | media/base/media_switches.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698