aboutsummaryrefslogtreecommitdiffstats
path: root/src/output/plugins/PulseOutputPlugin.cxx
diff options
context:
space:
mode:
Diffstat (limited to 'src/output/plugins/PulseOutputPlugin.cxx')
-rw-r--r--src/output/plugins/PulseOutputPlugin.cxx882
1 files changed, 482 insertions, 400 deletions
diff --git a/src/output/plugins/PulseOutputPlugin.cxx b/src/output/plugins/PulseOutputPlugin.cxx
index 120bad090..8b5225584 100644
--- a/src/output/plugins/PulseOutputPlugin.cxx
+++ b/src/output/plugins/PulseOutputPlugin.cxx
@@ -1,5 +1,5 @@
/*
- * Copyright (C) 2003-2014 The Music Player Daemon Project
+ * Copyright (C) 2003-2015 The Music Player Daemon Project
* http://www.musicpd.org
*
* This program is free software; you can redistribute it and/or modify
@@ -19,11 +19,14 @@
#include "config.h"
#include "PulseOutputPlugin.hxx"
+#include "lib/pulse/Domain.hxx"
+#include "lib/pulse/Error.hxx"
+#include "lib/pulse/LogError.hxx"
#include "../OutputAPI.hxx"
+#include "../Wrapper.hxx"
#include "mixer/MixerList.hxx"
#include "mixer/plugins/PulseMixerPlugin.hxx"
#include "util/Error.hxx"
-#include "util/Domain.hxx"
#include "Log.hxx"
#include <pulse/thread-mainloop.h>
@@ -31,7 +34,6 @@
#include <pulse/stream.h>
#include <pulse/introspect.h>
#include <pulse/subscribe.h>
-#include <pulse/error.h>
#include <pulse/version.h>
#include <assert.h>
@@ -40,7 +42,9 @@
#define MPD_PULSE_NAME "Music Player Daemon"
-struct PulseOutput {
+class PulseOutput {
+ friend struct AudioOutputWrapper<PulseOutput>;
+
AudioOutput base;
const char *name;
@@ -56,80 +60,190 @@ struct PulseOutput {
size_t writable;
PulseOutput()
- :base(pulse_output_plugin) {}
-};
+ :base(pulse_output_plugin),
+ mixer(nullptr),
+ mainloop(nullptr), stream(nullptr) {}
-static constexpr Domain pulse_output_domain("pulse_output");
+public:
+ void SetMixer(PulseMixer &_mixer);
-static void
-SetError(Error &error, pa_context *context, const char *msg)
-{
- const int e = pa_context_errno(context);
- error.Format(pulse_output_domain, e, "%s: %s", msg, pa_strerror(e));
-}
+ void ClearMixer(gcc_unused PulseMixer &old_mixer) {
+ assert(mixer == &old_mixer);
+
+ mixer = nullptr;
+ }
+
+ bool SetVolume(const pa_cvolume &volume, Error &error);
+
+ void Lock() {
+ pa_threaded_mainloop_lock(mainloop);
+ }
+
+ void Unlock() {
+ pa_threaded_mainloop_unlock(mainloop);
+ }
+
+ void OnContextStateChanged(pa_context_state_t new_state);
+ void OnServerLayoutChanged(pa_subscription_event_type_t t,
+ uint32_t idx);
+ void OnStreamSuspended(pa_stream *_stream);
+ void OnStreamStateChanged(pa_stream *_stream,
+ pa_stream_state_t new_state);
+ void OnStreamWrite(size_t nbytes);
+
+ void OnStreamSuccess() {
+ Signal();
+ }
+
+ gcc_const
+ static bool TestDefaultDevice();
+
+ bool Configure(const ConfigBlock &block, Error &error);
+ static PulseOutput *Create(const ConfigBlock &block, Error &error);
+
+ bool Enable(Error &error);
+ void Disable();
+
+ bool Open(AudioFormat &audio_format, Error &error);
+ void Close();
+
+ unsigned Delay();
+ size_t Play(const void *chunk, size_t size, Error &error);
+ void Cancel();
+ bool Pause();
+
+private:
+ /**
+ * Attempt to connect asynchronously to the PulseAudio server.
+ *
+ * @return true on success, false on error
+ */
+ bool Connect(Error &error);
+
+ /**
+ * Create, set up and connect a context.
+ *
+ * Caller must lock the main loop.
+ *
+ * @return true on success, false on error
+ */
+ bool SetupContext(Error &error);
+
+ /**
+ * Frees and clears the context.
+ *
+ * Caller must lock the main loop.
+ */
+ void DeleteContext();
+
+ void Signal() {
+ pa_threaded_mainloop_signal(mainloop, 0);
+ }
+
+ /**
+ * Check if the context is (already) connected, and waits if
+ * not. If the context has been disconnected, retry to
+ * connect.
+ *
+ * Caller must lock the main loop.
+ *
+ * @return true on success, false on error
+ */
+ bool WaitConnection(Error &error);
+
+ /**
+ * Create, set up and connect a context.
+ *
+ * Caller must lock the main loop.
+ *
+ * @return true on success, false on error
+ */
+ bool SetupStream(const pa_sample_spec &ss, Error &error);
+
+ /**
+ * Frees and clears the stream.
+ */
+ void DeleteStream();
+
+ /**
+ * Check if the stream is (already) connected, and waits if
+ * not. The mainloop must be locked before calling this
+ * function.
+ *
+ * @return true on success, false on error
+ */
+ bool WaitStream(Error &error);
+
+ /**
+ * Sets cork mode on the stream.
+ */
+ bool StreamPause(bool pause, Error &error);
+};
void
pulse_output_lock(PulseOutput &po)
{
- pa_threaded_mainloop_lock(po.mainloop);
+ po.Lock();
}
void
pulse_output_unlock(PulseOutput &po)
{
- pa_threaded_mainloop_unlock(po.mainloop);
+ po.Unlock();
}
-void
-pulse_output_set_mixer(PulseOutput &po, PulseMixer &pm)
+inline void
+PulseOutput::SetMixer(PulseMixer &_mixer)
{
- assert(po.mixer == nullptr);
+ assert(mixer == nullptr);
- po.mixer = &pm;
+ mixer = &_mixer;
- if (po.mainloop == nullptr)
+ if (mainloop == nullptr)
return;
- pa_threaded_mainloop_lock(po.mainloop);
+ pa_threaded_mainloop_lock(mainloop);
- if (po.context != nullptr &&
- pa_context_get_state(po.context) == PA_CONTEXT_READY) {
- pulse_mixer_on_connect(pm, po.context);
+ if (context != nullptr &&
+ pa_context_get_state(context) == PA_CONTEXT_READY) {
+ pulse_mixer_on_connect(_mixer, context);
- if (po.stream != nullptr &&
- pa_stream_get_state(po.stream) == PA_STREAM_READY)
- pulse_mixer_on_change(pm, po.context, po.stream);
+ if (stream != nullptr &&
+ pa_stream_get_state(stream) == PA_STREAM_READY)
+ pulse_mixer_on_change(_mixer, context, stream);
}
- pa_threaded_mainloop_unlock(po.mainloop);
+ pa_threaded_mainloop_unlock(mainloop);
}
void
-pulse_output_clear_mixer(PulseOutput &po, gcc_unused PulseMixer &pm)
+pulse_output_set_mixer(PulseOutput &po, PulseMixer &pm)
{
- assert(po.mixer == &pm);
-
- po.mixer = nullptr;
+ po.SetMixer(pm);
}
-bool
-pulse_output_set_volume(PulseOutput &po, const pa_cvolume *volume,
- Error &error)
+void
+pulse_output_clear_mixer(PulseOutput &po, PulseMixer &pm)
{
- pa_operation *o;
+ po.ClearMixer(pm);
+}
- if (po.context == nullptr || po.stream == nullptr ||
- pa_stream_get_state(po.stream) != PA_STREAM_READY) {
- error.Set(pulse_output_domain, "disconnected");
+inline bool
+PulseOutput::SetVolume(const pa_cvolume &volume, Error &error)
+{
+ if (context == nullptr || stream == nullptr ||
+ pa_stream_get_state(stream) != PA_STREAM_READY) {
+ error.Set(pulse_domain, "disconnected");
return false;
}
- o = pa_context_set_sink_input_volume(po.context,
- pa_stream_get_index(po.stream),
- volume, nullptr, nullptr);
+ pa_operation *o =
+ pa_context_set_sink_input_volume(context,
+ pa_stream_get_index(stream),
+ &volume, nullptr, nullptr);
if (o == nullptr) {
- SetError(error, po.context,
- "failed to set PulseAudio volume");
+ SetPulseError(error, context,
+ "failed to set PulseAudio volume");
return false;
}
@@ -137,6 +251,13 @@ pulse_output_set_volume(PulseOutput &po, const pa_cvolume *volume,
return true;
}
+bool
+pulse_output_set_volume(PulseOutput &po, const pa_cvolume *volume,
+ Error &error)
+{
+ return po.SetVolume(*volume, error);
+}
+
/**
* \brief waits for a pulseaudio operation to finish, frees it and
* unlocks the mainloop
@@ -169,32 +290,30 @@ static void
pulse_output_stream_success_cb(gcc_unused pa_stream *s,
gcc_unused int success, void *userdata)
{
- PulseOutput *po = (PulseOutput *)userdata;
+ PulseOutput &po = *(PulseOutput *)userdata;
- pa_threaded_mainloop_signal(po->mainloop, 0);
+ po.OnStreamSuccess();
}
-static void
-pulse_output_context_state_cb(struct pa_context *context, void *userdata)
+inline void
+PulseOutput::OnContextStateChanged(pa_context_state_t new_state)
{
- PulseOutput *po = (PulseOutput *)userdata;
-
- switch (pa_context_get_state(context)) {
+ switch (new_state) {
case PA_CONTEXT_READY:
- if (po->mixer != nullptr)
- pulse_mixer_on_connect(*po->mixer, context);
+ if (mixer != nullptr)
+ pulse_mixer_on_connect(*mixer, context);
- pa_threaded_mainloop_signal(po->mainloop, 0);
+ Signal();
break;
case PA_CONTEXT_TERMINATED:
case PA_CONTEXT_FAILED:
- if (po->mixer != nullptr)
- pulse_mixer_on_disconnect(*po->mixer);
+ if (mixer != nullptr)
+ pulse_mixer_on_disconnect(*mixer);
/* the caller thread might be waiting for these
states */
- pa_threaded_mainloop_signal(po->mainloop, 0);
+ Signal();
break;
case PA_CONTEXT_UNCONNECTED:
@@ -206,230 +325,203 @@ pulse_output_context_state_cb(struct pa_context *context, void *userdata)
}
static void
-pulse_output_subscribe_cb(pa_context *context,
- pa_subscription_event_type_t t,
- uint32_t idx, void *userdata)
+pulse_output_context_state_cb(struct pa_context *context, void *userdata)
+{
+ PulseOutput &po = *(PulseOutput *)userdata;
+
+ po.OnContextStateChanged(pa_context_get_state(context));
+}
+
+inline void
+PulseOutput::OnServerLayoutChanged(pa_subscription_event_type_t t,
+ uint32_t idx)
{
- PulseOutput *po = (PulseOutput *)userdata;
pa_subscription_event_type_t facility =
pa_subscription_event_type_t(t & PA_SUBSCRIPTION_EVENT_FACILITY_MASK);
pa_subscription_event_type_t type =
pa_subscription_event_type_t(t & PA_SUBSCRIPTION_EVENT_TYPE_MASK);
- if (po->mixer != nullptr &&
+ if (mixer != nullptr &&
facility == PA_SUBSCRIPTION_EVENT_SINK_INPUT &&
- po->stream != nullptr &&
- pa_stream_get_state(po->stream) == PA_STREAM_READY &&
- idx == pa_stream_get_index(po->stream) &&
+ stream != nullptr &&
+ pa_stream_get_state(stream) == PA_STREAM_READY &&
+ idx == pa_stream_get_index(stream) &&
(type == PA_SUBSCRIPTION_EVENT_NEW ||
type == PA_SUBSCRIPTION_EVENT_CHANGE))
- pulse_mixer_on_change(*po->mixer, context, po->stream);
+ pulse_mixer_on_change(*mixer, context, stream);
}
-/**
- * Attempt to connect asynchronously to the PulseAudio server.
- *
- * @return true on success, false on error
- */
-static bool
-pulse_output_connect(PulseOutput *po, Error &error)
+static void
+pulse_output_subscribe_cb(gcc_unused pa_context *context,
+ pa_subscription_event_type_t t,
+ uint32_t idx, void *userdata)
{
- assert(po != nullptr);
- assert(po->context != nullptr);
+ PulseOutput &po = *(PulseOutput *)userdata;
- if (pa_context_connect(po->context, po->server,
+ po.OnServerLayoutChanged(t, idx);
+}
+
+inline bool
+PulseOutput::Connect(Error &error)
+{
+ assert(context != nullptr);
+
+ if (pa_context_connect(context, server,
(pa_context_flags_t)0, nullptr) < 0) {
- SetError(error, po->context,
- "pa_context_connect() has failed");
+ SetPulseError(error, context,
+ "pa_context_connect() has failed");
return false;
}
return true;
}
-/**
- * Frees and clears the stream.
- */
-static void
-pulse_output_delete_stream(PulseOutput *po)
+void
+PulseOutput::DeleteStream()
{
- assert(po != nullptr);
- assert(po->stream != nullptr);
+ assert(stream != nullptr);
- pa_stream_set_suspended_callback(po->stream, nullptr, nullptr);
+ pa_stream_set_suspended_callback(stream, nullptr, nullptr);
- pa_stream_set_state_callback(po->stream, nullptr, nullptr);
- pa_stream_set_write_callback(po->stream, nullptr, nullptr);
+ pa_stream_set_state_callback(stream, nullptr, nullptr);
+ pa_stream_set_write_callback(stream, nullptr, nullptr);
- pa_stream_disconnect(po->stream);
- pa_stream_unref(po->stream);
- po->stream = nullptr;
+ pa_stream_disconnect(stream);
+ pa_stream_unref(stream);
+ stream = nullptr;
}
-/**
- * Frees and clears the context.
- *
- * Caller must lock the main loop.
- */
-static void
-pulse_output_delete_context(PulseOutput *po)
+void
+PulseOutput::DeleteContext()
{
- assert(po != nullptr);
- assert(po->context != nullptr);
+ assert(context != nullptr);
- pa_context_set_state_callback(po->context, nullptr, nullptr);
- pa_context_set_subscribe_callback(po->context, nullptr, nullptr);
+ pa_context_set_state_callback(context, nullptr, nullptr);
+ pa_context_set_subscribe_callback(context, nullptr, nullptr);
- pa_context_disconnect(po->context);
- pa_context_unref(po->context);
- po->context = nullptr;
+ pa_context_disconnect(context);
+ pa_context_unref(context);
+ context = nullptr;
}
-/**
- * Create, set up and connect a context.
- *
- * Caller must lock the main loop.
- *
- * @return true on success, false on error
- */
-static bool
-pulse_output_setup_context(PulseOutput *po, Error &error)
+bool
+PulseOutput::SetupContext(Error &error)
{
- assert(po != nullptr);
- assert(po->mainloop != nullptr);
+ assert(mainloop != nullptr);
- po->context = pa_context_new(pa_threaded_mainloop_get_api(po->mainloop),
- MPD_PULSE_NAME);
- if (po->context == nullptr) {
- error.Set(pulse_output_domain, "pa_context_new() has failed");
+ context = pa_context_new(pa_threaded_mainloop_get_api(mainloop),
+ MPD_PULSE_NAME);
+ if (context == nullptr) {
+ error.Set(pulse_domain, "pa_context_new() has failed");
return false;
}
- pa_context_set_state_callback(po->context,
- pulse_output_context_state_cb, po);
- pa_context_set_subscribe_callback(po->context,
- pulse_output_subscribe_cb, po);
+ pa_context_set_state_callback(context,
+ pulse_output_context_state_cb, this);
+ pa_context_set_subscribe_callback(context,
+ pulse_output_subscribe_cb, this);
- if (!pulse_output_connect(po, error)) {
- pulse_output_delete_context(po);
+ if (!Connect(error)) {
+ DeleteContext();
return false;
}
return true;
}
-static AudioOutput *
-pulse_output_init(const config_param &param, Error &error)
+inline bool
+PulseOutput::Configure(const ConfigBlock &block, Error &error)
{
- PulseOutput *po;
+ if (!base.Configure(block, error))
+ return false;
+
+ name = block.GetBlockValue("name", "mpd_pulse");
+ server = block.GetBlockValue("server");
+ sink = block.GetBlockValue("sink");
+ return true;
+}
+
+PulseOutput *
+PulseOutput::Create(const ConfigBlock &block, Error &error)
+{
setenv("PULSE_PROP_media.role", "music", true);
setenv("PULSE_PROP_application.icon_name", "mpd", true);
- po = new PulseOutput();
- if (!po->base.Configure(param, error)) {
+ auto *po = new PulseOutput();
+ if (!po->Configure(block, error)) {
delete po;
return nullptr;
}
- po->name = param.GetBlockValue("name", "mpd_pulse");
- po->server = param.GetBlockValue("server");
- po->sink = param.GetBlockValue("sink");
-
- po->mixer = nullptr;
- po->mainloop = nullptr;
- po->context = nullptr;
- po->stream = nullptr;
-
- return &po->base;
+ return po;
}
-static void
-pulse_output_finish(AudioOutput *ao)
+inline bool
+PulseOutput::Enable(Error &error)
{
- PulseOutput *po = (PulseOutput *)ao;
-
- delete po;
-}
-
-static bool
-pulse_output_enable(AudioOutput *ao, Error &error)
-{
- PulseOutput *po = (PulseOutput *)ao;
-
- assert(po->mainloop == nullptr);
- assert(po->context == nullptr);
+ assert(mainloop == nullptr);
/* create the libpulse mainloop and start the thread */
- po->mainloop = pa_threaded_mainloop_new();
- if (po->mainloop == nullptr) {
- error.Set(pulse_output_domain,
+ mainloop = pa_threaded_mainloop_new();
+ if (mainloop == nullptr) {
+ error.Set(pulse_domain,
"pa_threaded_mainloop_new() has failed");
return false;
}
- pa_threaded_mainloop_lock(po->mainloop);
+ pa_threaded_mainloop_lock(mainloop);
- if (pa_threaded_mainloop_start(po->mainloop) < 0) {
- pa_threaded_mainloop_unlock(po->mainloop);
- pa_threaded_mainloop_free(po->mainloop);
- po->mainloop = nullptr;
+ if (pa_threaded_mainloop_start(mainloop) < 0) {
+ pa_threaded_mainloop_unlock(mainloop);
+ pa_threaded_mainloop_free(mainloop);
+ mainloop = nullptr;
- error.Set(pulse_output_domain,
+ error.Set(pulse_domain,
"pa_threaded_mainloop_start() has failed");
return false;
}
/* create the libpulse context and connect it */
- if (!pulse_output_setup_context(po, error)) {
- pa_threaded_mainloop_unlock(po->mainloop);
- pa_threaded_mainloop_stop(po->mainloop);
- pa_threaded_mainloop_free(po->mainloop);
- po->mainloop = nullptr;
+ if (!SetupContext(error)) {
+ pa_threaded_mainloop_unlock(mainloop);
+ pa_threaded_mainloop_stop(mainloop);
+ pa_threaded_mainloop_free(mainloop);
+ mainloop = nullptr;
return false;
}
- pa_threaded_mainloop_unlock(po->mainloop);
+ pa_threaded_mainloop_unlock(mainloop);
return true;
}
-static void
-pulse_output_disable(AudioOutput *ao)
+inline void
+PulseOutput::Disable()
{
- PulseOutput *po = (PulseOutput *)ao;
-
- assert(po->mainloop != nullptr);
+ assert(mainloop != nullptr);
- pa_threaded_mainloop_stop(po->mainloop);
- if (po->context != nullptr)
- pulse_output_delete_context(po);
- pa_threaded_mainloop_free(po->mainloop);
- po->mainloop = nullptr;
+ pa_threaded_mainloop_stop(mainloop);
+ if (context != nullptr)
+ DeleteContext();
+ pa_threaded_mainloop_free(mainloop);
+ mainloop = nullptr;
}
-/**
- * Check if the context is (already) connected, and waits if not. If
- * the context has been disconnected, retry to connect.
- *
- * Caller must lock the main loop.
- *
- * @return true on success, false on error
- */
-static bool
-pulse_output_wait_connection(PulseOutput *po, Error &error)
+bool
+PulseOutput::WaitConnection(Error &error)
{
- assert(po->mainloop != nullptr);
+ assert(mainloop != nullptr);
pa_context_state_t state;
- if (po->context == nullptr && !pulse_output_setup_context(po, error))
+ if (context == nullptr && !SetupContext(error))
return false;
while (true) {
- state = pa_context_get_state(po->context);
+ state = pa_context_get_state(context);
switch (state) {
case PA_CONTEXT_READY:
/* nothing to do */
@@ -439,56 +531,61 @@ pulse_output_wait_connection(PulseOutput *po, Error &error)
case PA_CONTEXT_TERMINATED:
case PA_CONTEXT_FAILED:
/* failure */
- SetError(error, po->context, "failed to connect");
- pulse_output_delete_context(po);
+ SetPulseError(error, context, "failed to connect");
+ DeleteContext();
return false;
case PA_CONTEXT_CONNECTING:
case PA_CONTEXT_AUTHORIZING:
case PA_CONTEXT_SETTING_NAME:
/* wait some more */
- pa_threaded_mainloop_wait(po->mainloop);
+ pa_threaded_mainloop_wait(mainloop);
break;
}
}
}
-static void
-pulse_output_stream_suspended_cb(gcc_unused pa_stream *stream, void *userdata)
+inline void
+PulseOutput::OnStreamSuspended(gcc_unused pa_stream *_stream)
{
- PulseOutput *po = (PulseOutput *)userdata;
-
- assert(stream == po->stream || po->stream == nullptr);
- assert(po->mainloop != nullptr);
+ assert(_stream == stream || stream == nullptr);
+ assert(mainloop != nullptr);
/* wake up the main loop to break out of the loop in
pulse_output_play() */
- pa_threaded_mainloop_signal(po->mainloop, 0);
+ Signal();
}
static void
-pulse_output_stream_state_cb(pa_stream *stream, void *userdata)
+pulse_output_stream_suspended_cb(pa_stream *stream, void *userdata)
{
- PulseOutput *po = (PulseOutput *)userdata;
+ PulseOutput &po = *(PulseOutput *)userdata;
- assert(stream == po->stream || po->stream == nullptr);
- assert(po->mainloop != nullptr);
- assert(po->context != nullptr);
+ po.OnStreamSuspended(stream);
+}
+
+inline void
+PulseOutput::OnStreamStateChanged(pa_stream *_stream,
+ pa_stream_state_t new_state)
+{
+ assert(_stream == stream || stream == nullptr);
+ assert(mainloop != nullptr);
+ assert(context != nullptr);
- switch (pa_stream_get_state(stream)) {
+ switch (new_state) {
case PA_STREAM_READY:
- if (po->mixer != nullptr)
- pulse_mixer_on_change(*po->mixer, po->context, stream);
+ if (mixer != nullptr)
+ pulse_mixer_on_change(*mixer, context, _stream);
- pa_threaded_mainloop_signal(po->mainloop, 0);
+ Signal();
break;
case PA_STREAM_FAILED:
case PA_STREAM_TERMINATED:
- if (po->mixer != nullptr)
- pulse_mixer_on_disconnect(*po->mixer);
+ if (mixer != nullptr)
+ pulse_mixer_on_disconnect(*mixer);
- pa_threaded_mainloop_signal(po->mainloop, 0);
+ Signal();
break;
case PA_STREAM_UNCONNECTED:
@@ -498,68 +595,75 @@ pulse_output_stream_state_cb(pa_stream *stream, void *userdata)
}
static void
+pulse_output_stream_state_cb(pa_stream *stream, void *userdata)
+{
+ PulseOutput &po = *(PulseOutput *)userdata;
+
+ return po.OnStreamStateChanged(stream, pa_stream_get_state(stream));
+}
+
+inline void
+PulseOutput::OnStreamWrite(size_t nbytes)
+{
+ assert(mainloop != nullptr);
+
+ writable = nbytes;
+ Signal();
+}
+
+static void
pulse_output_stream_write_cb(gcc_unused pa_stream *stream, size_t nbytes,
void *userdata)
{
- PulseOutput *po = (PulseOutput *)userdata;
-
- assert(po->mainloop != nullptr);
+ PulseOutput &po = *(PulseOutput *)userdata;
- po->writable = nbytes;
- pa_threaded_mainloop_signal(po->mainloop, 0);
+ return po.OnStreamWrite(nbytes);
}
-/**
- * Create, set up and connect a context.
- *
- * Caller must lock the main loop.
- *
- * @return true on success, false on error
- */
-static bool
-pulse_output_setup_stream(PulseOutput *po, const pa_sample_spec *ss,
- Error &error)
+inline bool
+PulseOutput::SetupStream(const pa_sample_spec &ss, Error &error)
{
- assert(po != nullptr);
- assert(po->context != nullptr);
+ assert(context != nullptr);
- po->stream = pa_stream_new(po->context, po->name, ss, nullptr);
- if (po->stream == nullptr) {
- SetError(error, po->context, "pa_stream_new() has failed");
+ /* WAVE-EX is been adopted as the speaker map for most media files */
+ pa_channel_map chan_map;
+ pa_channel_map_init_auto(&chan_map, ss.channels,
+ PA_CHANNEL_MAP_WAVEEX);
+ stream = pa_stream_new(context, name, &ss, &chan_map);
+ if (stream == nullptr) {
+ SetPulseError(error, context,
+ "pa_stream_new() has failed");
return false;
}
- pa_stream_set_suspended_callback(po->stream,
- pulse_output_stream_suspended_cb, po);
+ pa_stream_set_suspended_callback(stream,
+ pulse_output_stream_suspended_cb,
+ this);
- pa_stream_set_state_callback(po->stream,
- pulse_output_stream_state_cb, po);
- pa_stream_set_write_callback(po->stream,
- pulse_output_stream_write_cb, po);
+ pa_stream_set_state_callback(stream,
+ pulse_output_stream_state_cb, this);
+ pa_stream_set_write_callback(stream,
+ pulse_output_stream_write_cb, this);
return true;
}
-static bool
-pulse_output_open(AudioOutput *ao, AudioFormat &audio_format,
- Error &error)
+inline bool
+PulseOutput::Open(AudioFormat &audio_format, Error &error)
{
- PulseOutput *po = (PulseOutput *)ao;
- pa_sample_spec ss;
-
- assert(po->mainloop != nullptr);
+ assert(mainloop != nullptr);
- pa_threaded_mainloop_lock(po->mainloop);
+ pa_threaded_mainloop_lock(mainloop);
- if (po->context != nullptr) {
- switch (pa_context_get_state(po->context)) {
+ if (context != nullptr) {
+ switch (pa_context_get_state(context)) {
case PA_CONTEXT_UNCONNECTED:
case PA_CONTEXT_TERMINATED:
case PA_CONTEXT_FAILED:
/* the connection was closed meanwhile; delete
it, and pulse_output_wait_connection() will
reopen it */
- pulse_output_delete_context(po);
+ DeleteContext();
break;
case PA_CONTEXT_READY:
@@ -570,8 +674,8 @@ pulse_output_open(AudioOutput *ao, AudioFormat &audio_format,
}
}
- if (!pulse_output_wait_connection(po, error)) {
- pa_threaded_mainloop_unlock(po->mainloop);
+ if (!WaitConnection(error)) {
+ pa_threaded_mainloop_unlock(mainloop);
return false;
}
@@ -579,304 +683,282 @@ pulse_output_open(AudioOutput *ao, AudioFormat &audio_format,
we just force MPD to send us everything as 16 bit */
audio_format.format = SampleFormat::S16;
+ pa_sample_spec ss;
ss.format = PA_SAMPLE_S16NE;
ss.rate = audio_format.sample_rate;
ss.channels = audio_format.channels;
/* create a stream .. */
- if (!pulse_output_setup_stream(po, &ss, error)) {
- pa_threaded_mainloop_unlock(po->mainloop);
+ if (!SetupStream(ss, error)) {
+ pa_threaded_mainloop_unlock(mainloop);
return false;
}
/* .. and connect it (asynchronously) */
- if (pa_stream_connect_playback(po->stream, po->sink,
+ if (pa_stream_connect_playback(stream, sink,
nullptr, pa_stream_flags_t(0),
nullptr, nullptr) < 0) {
- pulse_output_delete_stream(po);
+ DeleteStream();
- SetError(error, po->context,
- "pa_stream_connect_playback() has failed");
- pa_threaded_mainloop_unlock(po->mainloop);
+ SetPulseError(error, context,
+ "pa_stream_connect_playback() has failed");
+ pa_threaded_mainloop_unlock(mainloop);
return false;
}
- pa_threaded_mainloop_unlock(po->mainloop);
-
+ pa_threaded_mainloop_unlock(mainloop);
return true;
}
-static void
-pulse_output_close(AudioOutput *ao)
+inline void
+PulseOutput::Close()
{
- PulseOutput *po = (PulseOutput *)ao;
- pa_operation *o;
-
- assert(po->mainloop != nullptr);
+ assert(mainloop != nullptr);
- pa_threaded_mainloop_lock(po->mainloop);
+ pa_threaded_mainloop_lock(mainloop);
- if (pa_stream_get_state(po->stream) == PA_STREAM_READY) {
- o = pa_stream_drain(po->stream,
- pulse_output_stream_success_cb, po);
+ if (pa_stream_get_state(stream) == PA_STREAM_READY) {
+ pa_operation *o =
+ pa_stream_drain(stream,
+ pulse_output_stream_success_cb, this);
if (o == nullptr) {
- FormatWarning(pulse_output_domain,
- "pa_stream_drain() has failed: %s",
- pa_strerror(pa_context_errno(po->context)));
+ LogPulseError(context,
+ "pa_stream_drain() has failed");
} else
- pulse_wait_for_operation(po->mainloop, o);
+ pulse_wait_for_operation(mainloop, o);
}
- pulse_output_delete_stream(po);
+ DeleteStream();
- if (po->context != nullptr &&
- pa_context_get_state(po->context) != PA_CONTEXT_READY)
- pulse_output_delete_context(po);
+ if (context != nullptr &&
+ pa_context_get_state(context) != PA_CONTEXT_READY)
+ DeleteContext();
- pa_threaded_mainloop_unlock(po->mainloop);
+ pa_threaded_mainloop_unlock(mainloop);
}
-/**
- * Check if the stream is (already) connected, and waits if not. The
- * mainloop must be locked before calling this function.
- *
- * @return true on success, false on error
- */
-static bool
-pulse_output_wait_stream(PulseOutput *po, Error &error)
+bool
+PulseOutput::WaitStream(Error &error)
{
while (true) {
- switch (pa_stream_get_state(po->stream)) {
+ switch (pa_stream_get_state(stream)) {
case PA_STREAM_READY:
return true;
case PA_STREAM_FAILED:
case PA_STREAM_TERMINATED:
case PA_STREAM_UNCONNECTED:
- SetError(error, po->context,
- "failed to connect the stream");
+ SetPulseError(error, context,
+ "failed to connect the stream");
return false;
case PA_STREAM_CREATING:
- pa_threaded_mainloop_wait(po->mainloop);
+ pa_threaded_mainloop_wait(mainloop);
break;
}
}
}
-/**
- * Sets cork mode on the stream.
- */
-static bool
-pulse_output_stream_pause(PulseOutput *po, bool pause,
- Error &error)
+bool
+PulseOutput::StreamPause(bool pause, Error &error)
{
- pa_operation *o;
-
- assert(po->mainloop != nullptr);
- assert(po->context != nullptr);
- assert(po->stream != nullptr);
+ assert(mainloop != nullptr);
+ assert(context != nullptr);
+ assert(stream != nullptr);
- o = pa_stream_cork(po->stream, pause,
- pulse_output_stream_success_cb, po);
+ pa_operation *o = pa_stream_cork(stream, pause,
+ pulse_output_stream_success_cb, this);
if (o == nullptr) {
- SetError(error, po->context, "pa_stream_cork() has failed");
+ SetPulseError(error, context,
+ "pa_stream_cork() has failed");
return false;
}
- if (!pulse_wait_for_operation(po->mainloop, o)) {
- SetError(error, po->context, "pa_stream_cork() has failed");
+ if (!pulse_wait_for_operation(mainloop, o)) {
+ SetPulseError(error, context,
+ "pa_stream_cork() has failed");
return false;
}
return true;
}
-static unsigned
-pulse_output_delay(AudioOutput *ao)
+inline unsigned
+PulseOutput::Delay()
{
- PulseOutput *po = (PulseOutput *)ao;
- unsigned result = 0;
-
- pa_threaded_mainloop_lock(po->mainloop);
+ pa_threaded_mainloop_lock(mainloop);
- if (po->base.pause && pa_stream_is_corked(po->stream) &&
- pa_stream_get_state(po->stream) == PA_STREAM_READY)
+ unsigned result = 0;
+ if (base.pause && pa_stream_is_corked(stream) &&
+ pa_stream_get_state(stream) == PA_STREAM_READY)
/* idle while paused */
result = 1000;
- pa_threaded_mainloop_unlock(po->mainloop);
+ pa_threaded_mainloop_unlock(mainloop);
return result;
}
-static size_t
-pulse_output_play(AudioOutput *ao, const void *chunk, size_t size,
- Error &error)
+inline size_t
+PulseOutput::Play(const void *chunk, size_t size, Error &error)
{
- PulseOutput *po = (PulseOutput *)ao;
-
- assert(po->mainloop != nullptr);
- assert(po->stream != nullptr);
+ assert(mainloop != nullptr);
+ assert(stream != nullptr);
- pa_threaded_mainloop_lock(po->mainloop);
+ pa_threaded_mainloop_lock(mainloop);
/* check if the stream is (already) connected */
- if (!pulse_output_wait_stream(po, error)) {
- pa_threaded_mainloop_unlock(po->mainloop);
+ if (!WaitStream(error)) {
+ pa_threaded_mainloop_unlock(mainloop);
return 0;
}
- assert(po->context != nullptr);
+ assert(context != nullptr);
/* unpause if previously paused */
- if (pa_stream_is_corked(po->stream) &&
- !pulse_output_stream_pause(po, false, error)) {
- pa_threaded_mainloop_unlock(po->mainloop);
+ if (pa_stream_is_corked(stream) && !StreamPause(false, error)) {
+ pa_threaded_mainloop_unlock(mainloop);
return 0;
}
/* wait until the server allows us to write */
- while (po->writable == 0) {
- if (pa_stream_is_suspended(po->stream)) {
- pa_threaded_mainloop_unlock(po->mainloop);
- error.Set(pulse_output_domain, "suspended");
+ while (writable == 0) {
+ if (pa_stream_is_suspended(stream)) {
+ pa_threaded_mainloop_unlock(mainloop);
+ error.Set(pulse_domain, "suspended");
return 0;
}
- pa_threaded_mainloop_wait(po->mainloop);
+ pa_threaded_mainloop_wait(mainloop);
- if (pa_stream_get_state(po->stream) != PA_STREAM_READY) {
- pa_threaded_mainloop_unlock(po->mainloop);
- error.Set(pulse_output_domain, "disconnected");
+ if (pa_stream_get_state(stream) != PA_STREAM_READY) {
+ pa_threaded_mainloop_unlock(mainloop);
+ error.Set(pulse_domain, "disconnected");
return 0;
}
}
/* now write */
- if (size > po->writable)
+ if (size > writable)
/* don't send more than possible */
- size = po->writable;
+ size = writable;
- po->writable -= size;
+ writable -= size;
- int result = pa_stream_write(po->stream, chunk, size, nullptr,
+ int result = pa_stream_write(stream, chunk, size, nullptr,
0, PA_SEEK_RELATIVE);
- pa_threaded_mainloop_unlock(po->mainloop);
+ pa_threaded_mainloop_unlock(mainloop);
if (result < 0) {
- SetError(error, po->context, "pa_stream_write() failed");
+ SetPulseError(error, context, "pa_stream_write() failed");
return 0;
}
return size;
}
-static void
-pulse_output_cancel(AudioOutput *ao)
+inline void
+PulseOutput::Cancel()
{
- PulseOutput *po = (PulseOutput *)ao;
- pa_operation *o;
-
- assert(po->mainloop != nullptr);
- assert(po->stream != nullptr);
+ assert(mainloop != nullptr);
+ assert(stream != nullptr);
- pa_threaded_mainloop_lock(po->mainloop);
+ pa_threaded_mainloop_lock(mainloop);
- if (pa_stream_get_state(po->stream) != PA_STREAM_READY) {
+ if (pa_stream_get_state(stream) != PA_STREAM_READY) {
/* no need to flush when the stream isn't connected
yet */
- pa_threaded_mainloop_unlock(po->mainloop);
+ pa_threaded_mainloop_unlock(mainloop);
return;
}
- assert(po->context != nullptr);
+ assert(context != nullptr);
- o = pa_stream_flush(po->stream, pulse_output_stream_success_cb, po);
+ pa_operation *o = pa_stream_flush(stream,
+ pulse_output_stream_success_cb,
+ this);
if (o == nullptr) {
- FormatWarning(pulse_output_domain,
- "pa_stream_flush() has failed: %s",
- pa_strerror(pa_context_errno(po->context)));
- pa_threaded_mainloop_unlock(po->mainloop);
+ LogPulseError(context, "pa_stream_flush() has failed");
+ pa_threaded_mainloop_unlock(mainloop);
return;
}
- pulse_wait_for_operation(po->mainloop, o);
- pa_threaded_mainloop_unlock(po->mainloop);
+ pulse_wait_for_operation(mainloop, o);
+ pa_threaded_mainloop_unlock(mainloop);
}
-static bool
-pulse_output_pause(AudioOutput *ao)
+inline bool
+PulseOutput::Pause()
{
- PulseOutput *po = (PulseOutput *)ao;
-
- assert(po->mainloop != nullptr);
- assert(po->stream != nullptr);
+ assert(mainloop != nullptr);
+ assert(stream != nullptr);
- pa_threaded_mainloop_lock(po->mainloop);
+ pa_threaded_mainloop_lock(mainloop);
/* check if the stream is (already/still) connected */
Error error;
- if (!pulse_output_wait_stream(po, error)) {
- pa_threaded_mainloop_unlock(po->mainloop);
+ if (!WaitStream(error)) {
+ pa_threaded_mainloop_unlock(mainloop);
LogError(error);
return false;
}
- assert(po->context != nullptr);
+ assert(context != nullptr);
/* cork the stream */
- if (!pa_stream_is_corked(po->stream) &&
- !pulse_output_stream_pause(po, true, error)) {
- pa_threaded_mainloop_unlock(po->mainloop);
+ if (!pa_stream_is_corked(stream) && !StreamPause(true, error)) {
+ pa_threaded_mainloop_unlock(mainloop);
LogError(error);
return false;
}
- pa_threaded_mainloop_unlock(po->mainloop);
-
+ pa_threaded_mainloop_unlock(mainloop);
return true;
}
-static bool
-pulse_output_test_default_device(void)
+inline bool
+PulseOutput::TestDefaultDevice()
{
- bool success;
-
- const config_param empty;
- PulseOutput *po = (PulseOutput *)
- pulse_output_init(empty, IgnoreError());
+ const ConfigBlock empty;
+ PulseOutput *po = PulseOutput::Create(empty, IgnoreError());
if (po == nullptr)
return false;
- success = pulse_output_wait_connection(po, IgnoreError());
- pulse_output_finish(&po->base);
-
+ bool success = po->WaitConnection(IgnoreError());
+ delete po;
return success;
}
+static bool
+pulse_output_test_default_device(void)
+{
+ return PulseOutput::TestDefaultDevice();
+}
+
+typedef AudioOutputWrapper<PulseOutput> Wrapper;
+
const struct AudioOutputPlugin pulse_output_plugin = {
"pulse",
pulse_output_test_default_device,
- pulse_output_init,
- pulse_output_finish,
- pulse_output_enable,
- pulse_output_disable,
- pulse_output_open,
- pulse_output_close,
- pulse_output_delay,
+ &Wrapper::Init,
+ &Wrapper::Finish,
+ &Wrapper::Enable,
+ &Wrapper::Disable,
+ &Wrapper::Open,
+ &Wrapper::Close,
+ &Wrapper::Delay,
nullptr,
- pulse_output_play,
+ &Wrapper::Play,
nullptr,
- pulse_output_cancel,
- pulse_output_pause,
+ &Wrapper::Cancel,
+ &Wrapper::Pause,
&pulse_mixer_plugin,
};