| // Copyright (c) 2012 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/pulse/pulse_output.h" |
| |
| #include <pulse/pulseaudio.h> |
| |
| #include "base/message_loop.h" |
| #include "media/audio/audio_manager_base.h" |
| #include "media/audio/audio_parameters.h" |
| #include "media/audio/audio_util.h" |
| |
| namespace media { |
| |
| // A helper class that acquires pa_threaded_mainloop_lock() while in scope. |
| class AutoPulseLock { |
| public: |
| explicit AutoPulseLock(pa_threaded_mainloop* pa_mainloop) |
| : pa_mainloop_(pa_mainloop) { |
| pa_threaded_mainloop_lock(pa_mainloop_); |
| } |
| |
| ~AutoPulseLock() { |
| pa_threaded_mainloop_unlock(pa_mainloop_); |
| } |
| |
| private: |
| pa_threaded_mainloop* pa_mainloop_; |
| |
| DISALLOW_COPY_AND_ASSIGN(AutoPulseLock); |
| }; |
| |
| static pa_sample_format_t BitsToPASampleFormat(int bits_per_sample) { |
| switch (bits_per_sample) { |
| case 8: |
| return PA_SAMPLE_U8; |
| case 16: |
| return PA_SAMPLE_S16LE; |
| case 24: |
| return PA_SAMPLE_S24LE; |
| case 32: |
| return PA_SAMPLE_S32LE; |
| default: |
| NOTREACHED() << "Invalid bits per sample: " << bits_per_sample; |
| return PA_SAMPLE_INVALID; |
| } |
| } |
| |
| static pa_channel_position ChromiumToPAChannelPosition(Channels channel) { |
| switch (channel) { |
| // PulseAudio does not differentiate between left/right and |
| // stereo-left/stereo-right, both translate to front-left/front-right. |
| case LEFT: |
| return PA_CHANNEL_POSITION_FRONT_LEFT; |
| case RIGHT: |
| return PA_CHANNEL_POSITION_FRONT_RIGHT; |
| case CENTER: |
| return PA_CHANNEL_POSITION_FRONT_CENTER; |
| case LFE: |
| return PA_CHANNEL_POSITION_LFE; |
| case BACK_LEFT: |
| return PA_CHANNEL_POSITION_REAR_LEFT; |
| case BACK_RIGHT: |
| return PA_CHANNEL_POSITION_REAR_RIGHT; |
| case LEFT_OF_CENTER: |
| return PA_CHANNEL_POSITION_FRONT_LEFT_OF_CENTER; |
| case RIGHT_OF_CENTER: |
| return PA_CHANNEL_POSITION_FRONT_RIGHT_OF_CENTER; |
| case BACK_CENTER: |
| return PA_CHANNEL_POSITION_REAR_CENTER; |
| case SIDE_LEFT: |
| return PA_CHANNEL_POSITION_SIDE_LEFT; |
| case SIDE_RIGHT: |
| return PA_CHANNEL_POSITION_SIDE_RIGHT; |
| case CHANNELS_MAX: |
| return PA_CHANNEL_POSITION_INVALID; |
| default: |
| NOTREACHED() << "Invalid channel: " << channel; |
| return PA_CHANNEL_POSITION_INVALID; |
| } |
| } |
| |
| static pa_channel_map ChannelLayoutToPAChannelMap( |
| ChannelLayout channel_layout) { |
| pa_channel_map channel_map; |
| pa_channel_map_init(&channel_map); |
| |
| channel_map.channels = ChannelLayoutToChannelCount(channel_layout); |
| for (Channels ch = LEFT; ch < CHANNELS_MAX; |
| ch = static_cast<Channels>(ch + 1)) { |
| int channel_index = ChannelOrder(channel_layout, ch); |
| if (channel_index < 0) |
| continue; |
| |
| channel_map.map[channel_index] = ChromiumToPAChannelPosition(ch); |
| } |
| |
| return channel_map; |
| } |
| |
| // static, pa_context_notify_cb |
| void PulseAudioOutputStream::ContextNotifyCallback(pa_context* c, |
| void* p_this) { |
| PulseAudioOutputStream* stream = static_cast<PulseAudioOutputStream*>(p_this); |
| |
| // Forward unexpected failures to the AudioSourceCallback if available. All |
| // these variables are only modified under pa_threaded_mainloop_lock() so this |
| // should be thread safe. |
| if (c && stream->source_callback_ && |
| pa_context_get_state(c) == PA_CONTEXT_FAILED) { |
| stream->source_callback_->OnError(stream, pa_context_errno(c)); |
| } |
| |
| pa_threaded_mainloop_signal(stream->pa_mainloop_, 0); |
| } |
| |
| // static, pa_stream_notify_cb |
| void PulseAudioOutputStream::StreamNotifyCallback(pa_stream* s, void* p_this) { |
| PulseAudioOutputStream* stream = static_cast<PulseAudioOutputStream*>(p_this); |
| |
| // Forward unexpected failures to the AudioSourceCallback if available. All |
| // these variables are only modified under pa_threaded_mainloop_lock() so this |
| // should be thread safe. |
| if (s && stream->source_callback_ && |
| pa_stream_get_state(s) == PA_STREAM_FAILED) { |
| stream->source_callback_->OnError( |
| stream, pa_context_errno(stream->pa_context_)); |
| } |
| |
| pa_threaded_mainloop_signal(stream->pa_mainloop_, 0); |
| } |
| |
| // static, pa_stream_success_cb_t |
| void PulseAudioOutputStream::StreamSuccessCallback(pa_stream* s, int success, |
| void* p_this) { |
| PulseAudioOutputStream* stream = static_cast<PulseAudioOutputStream*>(p_this); |
| pa_threaded_mainloop_signal(stream->pa_mainloop_, 0); |
| } |
| |
| // static, pa_stream_request_cb_t |
| void PulseAudioOutputStream::StreamRequestCallback(pa_stream* s, size_t len, |
| void* p_this) { |
| // Fulfill write request; must always result in a pa_stream_write() call. |
| static_cast<PulseAudioOutputStream*>(p_this)->FulfillWriteRequest(len); |
| } |
| |
| PulseAudioOutputStream::PulseAudioOutputStream(const AudioParameters& params, |
| AudioManagerBase* manager) |
| : params_(params), |
| manager_(manager), |
| pa_context_(NULL), |
| pa_mainloop_(NULL), |
| pa_stream_(NULL), |
| volume_(1.0f), |
| source_callback_(NULL) { |
| DCHECK(manager_->GetMessageLoop()->BelongsToCurrentThread()); |
| |
| CHECK(params_.IsValid()); |
| audio_bus_ = AudioBus::Create(params_); |
| } |
| |
| PulseAudioOutputStream::~PulseAudioOutputStream() { |
| // All internal structures should already have been freed in Close(), which |
| // calls AudioManagerBase::ReleaseOutputStream() which deletes this object. |
| DCHECK(!pa_stream_); |
| DCHECK(!pa_context_); |
| DCHECK(!pa_mainloop_); |
| } |
| |
| // Helper macro for Open() to avoid code spam and string bloat. |
| #define RETURN_ON_FAILURE(expression, message) do { \ |
| if (!(expression)) { \ |
| if (pa_context_) { \ |
| DLOG(ERROR) << message << " Error: " \ |
| << pa_strerror(pa_context_errno(pa_context_)); \ |
| } else { \ |
| DLOG(ERROR) << message; \ |
| } \ |
| return false; \ |
| } \ |
| } while(0) |
| |
| bool PulseAudioOutputStream::Open() { |
| DCHECK(manager_->GetMessageLoop()->BelongsToCurrentThread()); |
| |
| pa_mainloop_ = pa_threaded_mainloop_new(); |
| RETURN_ON_FAILURE(pa_mainloop_, "Failed to create PulseAudio main loop."); |
| |
| pa_mainloop_api* pa_mainloop_api = pa_threaded_mainloop_get_api(pa_mainloop_); |
| pa_context_ = pa_context_new(pa_mainloop_api, "Chromium"); |
| RETURN_ON_FAILURE(pa_context_, "Failed to create PulseAudio context."); |
| |
| // A state callback must be set before calling pa_threaded_mainloop_lock() or |
| // pa_threaded_mainloop_wait() calls may lead to dead lock. |
| pa_context_set_state_callback(pa_context_, &ContextNotifyCallback, this); |
| |
| // Lock the main loop while setting up the context. Failure to do so may lead |
| // to crashes as the PulseAudio thread tries to run before things are ready. |
| AutoPulseLock auto_lock(pa_mainloop_); |
| |
| RETURN_ON_FAILURE( |
| pa_threaded_mainloop_start(pa_mainloop_) == 0, |
| "Failed to start PulseAudio main loop."); |
| RETURN_ON_FAILURE( |
| pa_context_connect(pa_context_, NULL, PA_CONTEXT_NOAUTOSPAWN, NULL) == 0, |
| "Failed to connect PulseAudio context."); |
| |
| // Wait until |pa_context_| is ready. pa_threaded_mainloop_wait() must be |
| // called after pa_context_get_state() in case the context is already ready, |
| // otherwise pa_threaded_mainloop_wait() will hang indefinitely. |
| while (true) { |
| pa_context_state_t context_state = pa_context_get_state(pa_context_); |
| RETURN_ON_FAILURE( |
| PA_CONTEXT_IS_GOOD(context_state), "Invalid PulseAudio context state."); |
| if (context_state == PA_CONTEXT_READY) |
| break; |
| pa_threaded_mainloop_wait(pa_mainloop_); |
| } |
| |
| // Set sample specifications. |
| pa_sample_spec pa_sample_specifications; |
| pa_sample_specifications.format = BitsToPASampleFormat( |
| params_.bits_per_sample()); |
| pa_sample_specifications.rate = params_.sample_rate(); |
| pa_sample_specifications.channels = params_.channels(); |
| |
| // Get channel mapping and open playback stream. |
| pa_channel_map* map = NULL; |
| pa_channel_map source_channel_map = ChannelLayoutToPAChannelMap( |
| params_.channel_layout()); |
| if (source_channel_map.channels != 0) { |
| // The source data uses a supported channel map so we will use it rather |
| // than the default channel map (NULL). |
| map = &source_channel_map; |
| } |
| pa_stream_ = pa_stream_new( |
| pa_context_, "Playback", &pa_sample_specifications, map); |
| RETURN_ON_FAILURE(pa_stream_, "Failed to create PulseAudio stream."); |
| pa_stream_set_state_callback(pa_stream_, &StreamNotifyCallback, this); |
| |
| // Even though we start the stream corked below, PulseAudio will issue one |
| // stream request after setup. FulfillWriteRequest() must fulfill the write. |
| pa_stream_set_write_callback(pa_stream_, &StreamRequestCallback, this); |
| |
| // Tell pulse audio we only want callbacks of a certain size. |
| pa_buffer_attr pa_buffer_attributes; |
| pa_buffer_attributes.maxlength = params_.GetBytesPerBuffer(); |
| pa_buffer_attributes.minreq = params_.GetBytesPerBuffer(); |
| pa_buffer_attributes.prebuf = params_.GetBytesPerBuffer(); |
| pa_buffer_attributes.tlength = params_.GetBytesPerBuffer(); |
| pa_buffer_attributes.fragsize = static_cast<uint32_t>(-1); |
| |
| // Connect playback stream. |
| // TODO(dalecurtis): Pulse tends to want really large buffer sizes if we are |
| // not using the native sample rate. We should always open the stream with |
| // PA_STREAM_FIX_RATE and ensure this is true. |
| RETURN_ON_FAILURE( |
| pa_stream_connect_playback( |
| pa_stream_, NULL, &pa_buffer_attributes, |
| static_cast<pa_stream_flags_t>( |
| PA_STREAM_ADJUST_LATENCY | PA_STREAM_AUTO_TIMING_UPDATE | |
| PA_STREAM_NOT_MONOTONIC | PA_STREAM_START_CORKED), |
| NULL, NULL) == 0, |
| "Failed to connect PulseAudio stream."); |
| |
| // Wait for the stream to be ready. |
| while (true) { |
| pa_stream_state_t stream_state = pa_stream_get_state(pa_stream_); |
| RETURN_ON_FAILURE( |
| PA_STREAM_IS_GOOD(stream_state), "Invalid PulseAudio stream state."); |
| if (stream_state == PA_STREAM_READY) |
| break; |
| pa_threaded_mainloop_wait(pa_mainloop_); |
| } |
| |
| return true; |
| } |
| |
| #undef RETURN_ON_FAILURE |
| |
| void PulseAudioOutputStream::Reset() { |
| if (!pa_mainloop_) { |
| DCHECK(!pa_stream_); |
| DCHECK(!pa_context_); |
| return; |
| } |
| |
| { |
| AutoPulseLock auto_lock(pa_mainloop_); |
| |
| // Close the stream. |
| if (pa_stream_) { |
| // Ensure all samples are played out before shutdown. |
| WaitForPulseOperation(pa_stream_flush( |
| pa_stream_, &StreamSuccessCallback, this)); |
| |
| // Release PulseAudio structures. |
| pa_stream_disconnect(pa_stream_); |
| pa_stream_set_write_callback(pa_stream_, NULL, NULL); |
| pa_stream_set_state_callback(pa_stream_, NULL, NULL); |
| pa_stream_unref(pa_stream_); |
| pa_stream_ = NULL; |
| } |
| |
| if (pa_context_) { |
| pa_context_disconnect(pa_context_); |
| pa_context_set_state_callback(pa_context_, NULL, NULL); |
| pa_context_unref(pa_context_); |
| pa_context_ = NULL; |
| } |
| } |
| |
| pa_threaded_mainloop_stop(pa_mainloop_); |
| pa_threaded_mainloop_free(pa_mainloop_); |
| pa_mainloop_ = NULL; |
| } |
| |
| void PulseAudioOutputStream::Close() { |
| DCHECK(manager_->GetMessageLoop()->BelongsToCurrentThread()); |
| |
| 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); |
| } |
| |
| int PulseAudioOutputStream::GetHardwareLatencyInBytes() { |
| int negative = 0; |
| pa_usec_t pa_latency_micros = 0; |
| if (pa_stream_get_latency(pa_stream_, &pa_latency_micros, &negative) != 0) |
| return 0; |
| |
| if (negative) |
| return 0; |
| |
| return (pa_latency_micros * params_.sample_rate() * |
| params_.GetBytesPerFrame()) / base::Time::kMicrosecondsPerSecond; |
| } |
| |
| void PulseAudioOutputStream::FulfillWriteRequest(size_t requested_bytes) { |
| CHECK_EQ(requested_bytes, static_cast<size_t>(params_.GetBytesPerBuffer())); |
| |
| int frames_filled = 0; |
| if (source_callback_) { |
| frames_filled = source_callback_->OnMoreData( |
| audio_bus_.get(), AudioBuffersState(0, GetHardwareLatencyInBytes())); |
| } |
| |
| // Zero any unfilled data so it plays back as silence. |
| if (frames_filled < audio_bus_->frames()) { |
| audio_bus_->ZeroFramesPartial( |
| frames_filled, audio_bus_->frames() - frames_filled); |
| } |
| |
| // PulseAudio won't always be able to provide a buffer large enough, so we may |
| // need to request multiple buffers and fill them individually. |
| int current_frame = 0; |
| size_t bytes_remaining = requested_bytes; |
| while (bytes_remaining > 0) { |
| void* buffer = NULL; |
| size_t bytes_to_fill = bytes_remaining; |
| CHECK_GE(pa_stream_begin_write(pa_stream_, &buffer, &bytes_to_fill), 0); |
| |
| // In case PulseAudio gives us a bigger buffer than we want, cap our size. |
| bytes_to_fill = std::min( |
| std::min(bytes_remaining, bytes_to_fill), |
| static_cast<size_t>(params_.GetBytesPerBuffer())); |
| |
| int frames_to_fill = bytes_to_fill / params_.GetBytesPerFrame();; |
| |
| // Note: If this ever changes to output raw float the data must be clipped |
| // and sanitized since it may come from an untrusted source such as NaCl. |
| audio_bus_->ToInterleavedPartial( |
| current_frame, frames_to_fill, params_.bits_per_sample() / 8, buffer); |
| media::AdjustVolume(buffer, bytes_to_fill, params_.channels(), |
| params_.bits_per_sample() / 8, volume_); |
| |
| if (pa_stream_write(pa_stream_, buffer, bytes_to_fill, NULL, 0LL, |
| PA_SEEK_RELATIVE) < 0) { |
| if (source_callback_) { |
| source_callback_->OnError(this, pa_context_errno(pa_context_)); |
| } |
| } |
| |
| bytes_remaining -= bytes_to_fill; |
| current_frame = frames_to_fill; |
| } |
| } |
| |
| void PulseAudioOutputStream::Start(AudioSourceCallback* callback) { |
| DCHECK(manager_->GetMessageLoop()->BelongsToCurrentThread()); |
| CHECK(callback); |
| CHECK(pa_stream_); |
| |
| AutoPulseLock auto_lock(pa_mainloop_); |
| |
| // Ensure the context and stream are ready. |
| if (pa_context_get_state(pa_context_) != PA_CONTEXT_READY && |
| pa_stream_get_state(pa_stream_) != PA_STREAM_READY) { |
| callback->OnError(this, pa_context_errno(pa_context_)); |
| return; |
| } |
| |
| source_callback_ = callback; |
| |
| // Uncork (resume) the stream. |
| WaitForPulseOperation(pa_stream_cork( |
| pa_stream_, 0, &StreamSuccessCallback, this)); |
| } |
| |
| void PulseAudioOutputStream::Stop() { |
| DCHECK(manager_->GetMessageLoop()->BelongsToCurrentThread()); |
| |
| // Cork (pause) the stream. Waiting for the main loop lock will ensure |
| // outstanding callbacks have completed. |
| AutoPulseLock auto_lock(pa_mainloop_); |
| |
| // Flush the stream prior to cork, doing so after will cause hangs. Write |
| // callbacks are suspended while inside pa_threaded_mainloop_lock() so this |
| // is all thread safe. |
| WaitForPulseOperation(pa_stream_flush( |
| pa_stream_, &StreamSuccessCallback, this)); |
| |
| WaitForPulseOperation(pa_stream_cork( |
| pa_stream_, 1, &StreamSuccessCallback, this)); |
| |
| source_callback_ = NULL; |
| } |
| |
| void PulseAudioOutputStream::SetVolume(double volume) { |
| DCHECK(manager_->GetMessageLoop()->BelongsToCurrentThread()); |
| |
| volume_ = static_cast<float>(volume); |
| } |
| |
| void PulseAudioOutputStream::GetVolume(double* volume) { |
| DCHECK(manager_->GetMessageLoop()->BelongsToCurrentThread()); |
| |
| *volume = volume_; |
| } |
| |
| void PulseAudioOutputStream::WaitForPulseOperation(pa_operation* op) { |
| CHECK(op); |
| while (pa_operation_get_state(op) == PA_OPERATION_RUNNING) { |
| pa_threaded_mainloop_wait(pa_mainloop_); |
| } |
| pa_operation_unref(op); |
| } |
| |
| } // namespace media |