| 1 | /* |
| 2 | * This file is part of DisOrder. |
| 3 | * Copyright (C) 2013 Richard Kettlewell, 2018 Mark Wooding |
| 4 | * |
| 5 | * This program is free software: you can redistribute it and/or modify |
| 6 | * it under the terms of the GNU General Public License as published by |
| 7 | * the Free Software Foundation, either version 3 of the License, or |
| 8 | * (at your option) any later version. |
| 9 | * |
| 10 | * This program is distributed in the hope that it will be useful, |
| 11 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 12 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 13 | * GNU General Public License for more details. |
| 14 | * |
| 15 | * You should have received a copy of the GNU General Public License |
| 16 | * along with this program. If not, see <http://www.gnu.org/licenses/>. |
| 17 | */ |
| 18 | /** @file lib/uaudio-pulseaudio.c |
| 19 | * @brief Support for PulseAudio backend */ |
| 20 | #include "common.h" |
| 21 | |
| 22 | #if HAVE_PULSEAUDIO |
| 23 | |
| 24 | #include <pulse/context.h> |
| 25 | #include <pulse/error.h> |
| 26 | #include <pulse/thread-mainloop.h> |
| 27 | #include <pulse/stream.h> |
| 28 | |
| 29 | #include "mem.h" |
| 30 | #include "log.h" |
| 31 | #include "uaudio.h" |
| 32 | #include "configuration.h" |
| 33 | |
| 34 | static const char *const pulseaudio_options[] = { |
| 35 | "application", |
| 36 | NULL |
| 37 | }; |
| 38 | |
| 39 | static pa_threaded_mainloop *loop; |
| 40 | static pa_context *ctx; |
| 41 | static pa_stream *str; |
| 42 | |
| 43 | #define PAERRSTR pa_strerror(pa_context_errno(ctx)) |
| 44 | |
| 45 | /** @brief Callback: wake up main loop when the context is ready. */ |
| 46 | static void cb_ctxstate(attribute((unused)) pa_context *xctx, |
| 47 | attribute((unused)) void *p) { |
| 48 | pa_context_state_t st = pa_context_get_state(ctx); |
| 49 | switch(st) { |
| 50 | case PA_CONTEXT_READY: |
| 51 | pa_threaded_mainloop_signal(loop, 0); |
| 52 | break; |
| 53 | default: |
| 54 | if(!PA_CONTEXT_IS_GOOD(st)) |
| 55 | disorder_fatal(0, "pulseaudio failed: %s", PAERRSTR); |
| 56 | } |
| 57 | } |
| 58 | |
| 59 | /** @brief Callback: wake up main loop when the stream is ready. */ |
| 60 | static void cb_strstate(attribute((unused)) pa_stream *xstr, |
| 61 | attribute((unused)) void *p) { |
| 62 | pa_stream_state_t st = pa_stream_get_state(str); |
| 63 | switch(st) { |
| 64 | case PA_STREAM_READY: |
| 65 | pa_threaded_mainloop_signal(loop, 0); |
| 66 | break; |
| 67 | default: |
| 68 | if(!PA_STREAM_IS_GOOD(st)) |
| 69 | disorder_fatal(0, "pulseaudio failed: %s", PAERRSTR); |
| 70 | } |
| 71 | } |
| 72 | |
| 73 | /** @brief Callback: wake up main loop when there's output buffer space. */ |
| 74 | static void cb_wakeup(attribute((unused)) pa_stream *xstr, |
| 75 | attribute((unused)) size_t sz, |
| 76 | attribute((unused)) void *p) |
| 77 | { pa_threaded_mainloop_signal(loop, 0); } |
| 78 | |
| 79 | /** @brief Open the PulseAudio sound device */ |
| 80 | static void pulseaudio_open() { |
| 81 | /* Much of the following is cribbed from the PulseAudio `simple' source. */ |
| 82 | |
| 83 | pa_sample_spec ss; |
| 84 | |
| 85 | /* Set up the sample format. */ |
| 86 | ss.format = -1; |
| 87 | switch(uaudio_bits) { |
| 88 | case 8: if(!uaudio_signed) ss.format = PA_SAMPLE_U8; break; |
| 89 | case 16: if(uaudio_signed) ss.format = PA_SAMPLE_S16NE; break; |
| 90 | case 32: if(uaudio_signed) ss.format = PA_SAMPLE_S32NE; break; |
| 91 | } |
| 92 | if(ss.format == -1) |
| 93 | disorder_fatal(0, "unsupported uaudio format (%d, %d)", |
| 94 | uaudio_bits, uaudio_signed); |
| 95 | ss.channels = uaudio_channels; |
| 96 | ss.rate = uaudio_rate; |
| 97 | |
| 98 | /* Create the random PulseAudio pieces. */ |
| 99 | loop = pa_threaded_mainloop_new(); |
| 100 | if(!loop) disorder_fatal(0, "failed to create pulseaudio main loop"); |
| 101 | pa_threaded_mainloop_lock(loop); |
| 102 | ctx = pa_context_new(pa_threaded_mainloop_get_api(loop), |
| 103 | uaudio_get("application", "DisOrder")); |
| 104 | if(!ctx) disorder_fatal(0, "failed to create pulseaudio context"); |
| 105 | pa_context_set_state_callback(ctx, cb_ctxstate, 0); |
| 106 | if(pa_context_connect(ctx, 0, 0, 0) < 0) |
| 107 | disorder_fatal(0, "failed to connect to pulseaudio server: %s", |
| 108 | PAERRSTR); |
| 109 | |
| 110 | /* Set the main loop going. */ |
| 111 | if(pa_threaded_mainloop_start(loop) < 0) |
| 112 | disorder_fatal(0, "failed to start pulseaudio main loop"); |
| 113 | while(pa_context_get_state(ctx) != PA_CONTEXT_READY) |
| 114 | pa_threaded_mainloop_wait(loop); |
| 115 | |
| 116 | /* Set up my stream. */ |
| 117 | str = pa_stream_new(ctx, "DisOrder", &ss, 0); |
| 118 | if(!str) |
| 119 | disorder_fatal(0, "failed to create pulseaudio stream: %s", PAERRSTR); |
| 120 | pa_stream_set_write_callback(str, cb_wakeup, 0); |
| 121 | if(pa_stream_connect_playback(str, 0, 0, |
| 122 | PA_STREAM_ADJUST_LATENCY, |
| 123 | 0, 0)) |
| 124 | disorder_fatal(0, "failed to connect pulseaudio stream for playback: %s", |
| 125 | PAERRSTR); |
| 126 | pa_stream_set_state_callback(str, cb_strstate, 0); |
| 127 | |
| 128 | /* Wait until the stream is ready. */ |
| 129 | while(pa_stream_get_state(str) != PA_STREAM_READY) |
| 130 | pa_threaded_mainloop_wait(loop); |
| 131 | |
| 132 | /* All done. */ |
| 133 | pa_threaded_mainloop_unlock(loop); |
| 134 | } |
| 135 | |
| 136 | /** @brief Close the PulseAudio sound device */ |
| 137 | static void pulseaudio_close(void) { |
| 138 | if(loop) pa_threaded_mainloop_stop(loop); |
| 139 | if(str) { pa_stream_unref(str); str = 0; } |
| 140 | if(ctx) { pa_context_disconnect(ctx); pa_context_unref(ctx); ctx = 0; } |
| 141 | if(loop) { pa_threaded_mainloop_free(loop); loop = 0; } |
| 142 | } |
| 143 | |
| 144 | /** @brief Actually play sound via PulseAudio */ |
| 145 | static size_t pulseaudio_play(void *buffer, size_t samples, |
| 146 | attribute((unused)) unsigned flags) { |
| 147 | unsigned char *p = buffer; |
| 148 | size_t n, sz = samples*uaudio_sample_size; |
| 149 | |
| 150 | pa_threaded_mainloop_lock(loop); |
| 151 | while(sz) { |
| 152 | |
| 153 | /* Wait until some output space becomes available. */ |
| 154 | while(!(n = pa_stream_writable_size(str))) |
| 155 | pa_threaded_mainloop_wait(loop); |
| 156 | if(n > sz) n = sz; |
| 157 | if(pa_stream_write(str, p, n, 0, 0, PA_SEEK_RELATIVE) < 0) |
| 158 | disorder_fatal(0, "failed to write pulseaudio data: %s", PAERRSTR); |
| 159 | p += n; sz -= n; |
| 160 | } |
| 161 | pa_threaded_mainloop_unlock(loop); |
| 162 | return samples; |
| 163 | } |
| 164 | |
| 165 | static void pulseaudio_start(uaudio_callback *callback, |
| 166 | void *userdata) { |
| 167 | pulseaudio_open(); |
| 168 | uaudio_thread_start(callback, userdata, pulseaudio_play, |
| 169 | 32 / uaudio_sample_size, |
| 170 | 4096 / uaudio_sample_size, |
| 171 | 0); |
| 172 | } |
| 173 | |
| 174 | static void pulseaudio_stop(void) { |
| 175 | uaudio_thread_stop(); |
| 176 | pulseaudio_close(); |
| 177 | } |
| 178 | |
| 179 | static void pulseaudio_open_mixer(void) { |
| 180 | disorder_error(0, "no pulseaudio mixer support yet"); |
| 181 | } |
| 182 | |
| 183 | static void pulseaudio_close_mixer(void) { |
| 184 | } |
| 185 | |
| 186 | static void pulseaudio_get_volume(int *left, int *right) { |
| 187 | *left = *right = 0; |
| 188 | } |
| 189 | |
| 190 | static void pulseaudio_set_volume(int *left, int *right) { |
| 191 | *left = *right = 0; |
| 192 | } |
| 193 | |
| 194 | static void pulseaudio_configure(void) { |
| 195 | } |
| 196 | |
| 197 | const struct uaudio uaudio_pulseaudio = { |
| 198 | .name = "pulseaudio", |
| 199 | .options = pulseaudio_options, |
| 200 | .start = pulseaudio_start, |
| 201 | .stop = pulseaudio_stop, |
| 202 | .activate = uaudio_thread_activate, |
| 203 | .deactivate = uaudio_thread_deactivate, |
| 204 | .open_mixer = pulseaudio_open_mixer, |
| 205 | .close_mixer = pulseaudio_close_mixer, |
| 206 | .get_volume = pulseaudio_get_volume, |
| 207 | .set_volume = pulseaudio_set_volume, |
| 208 | .configure = pulseaudio_configure, |
| 209 | .flags = UAUDIO_API_CLIENT, |
| 210 | }; |
| 211 | |
| 212 | #endif |
| 213 | |
| 214 | /* |
| 215 | Local Variables: |
| 216 | c-basic-offset:2 |
| 217 | comment-column:40 |
| 218 | fill-column:79 |
| 219 | indent-tabs-mode:nil |
| 220 | End: |
| 221 | */ |