| 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/introspect.h> |
| 27 | #include <pulse/thread-mainloop.h> |
| 28 | #include <pulse/stream.h> |
| 29 | |
| 30 | #include "mem.h" |
| 31 | #include "log.h" |
| 32 | #include "uaudio.h" |
| 33 | #include "configuration.h" |
| 34 | |
| 35 | static const char *const pulseaudio_options[] = { |
| 36 | "application", |
| 37 | NULL |
| 38 | }; |
| 39 | |
| 40 | static pa_threaded_mainloop *loop; |
| 41 | static pa_context *ctx; |
| 42 | static pa_stream *str; |
| 43 | static pa_channel_map cmap; |
| 44 | static uint32_t strix; |
| 45 | |
| 46 | #define PAERRSTR pa_strerror(pa_context_errno(ctx)) |
| 47 | |
| 48 | /** @brief Callback: wake up main loop when the context is ready. */ |
| 49 | static void cb_ctxstate(attribute((unused)) pa_context *xctx, |
| 50 | attribute((unused)) void *p) { |
| 51 | pa_context_state_t st = pa_context_get_state(ctx); |
| 52 | switch(st) { |
| 53 | case PA_CONTEXT_READY: |
| 54 | pa_threaded_mainloop_signal(loop, 0); |
| 55 | break; |
| 56 | default: |
| 57 | if(!PA_CONTEXT_IS_GOOD(st)) |
| 58 | disorder_fatal(0, "pulseaudio failed: %s", PAERRSTR); |
| 59 | } |
| 60 | } |
| 61 | |
| 62 | /** @brief Callback: wake up main loop when the stream is ready. */ |
| 63 | static void cb_strstate(attribute((unused)) pa_stream *xstr, |
| 64 | attribute((unused)) void *p) { |
| 65 | pa_stream_state_t st = pa_stream_get_state(str); |
| 66 | switch(st) { |
| 67 | case PA_STREAM_READY: |
| 68 | pa_threaded_mainloop_signal(loop, 0); |
| 69 | break; |
| 70 | default: |
| 71 | if(!PA_STREAM_IS_GOOD(st)) |
| 72 | disorder_fatal(0, "pulseaudio failed: %s", PAERRSTR); |
| 73 | } |
| 74 | } |
| 75 | |
| 76 | /** @brief Callback: wake up main loop when there's output buffer space. */ |
| 77 | static void cb_wakeup(attribute((unused)) pa_stream *xstr, |
| 78 | attribute((unused)) size_t sz, |
| 79 | attribute((unused)) void *p) |
| 80 | { pa_threaded_mainloop_signal(loop, 0); } |
| 81 | |
| 82 | struct simpleop { |
| 83 | const char *what; |
| 84 | int donep; |
| 85 | }; |
| 86 | |
| 87 | /** @brief Callback: wake up main loop when a simple operation completes. */ |
| 88 | static void cb_success(attribute((unused)) pa_context *xctx, |
| 89 | int winp, void *p) { |
| 90 | struct simpleop *sop = p; |
| 91 | if(!winp) disorder_fatal(0, "%s failed: %s", sop->what, PAERRSTR); |
| 92 | sop->donep = 1; pa_threaded_mainloop_signal(loop, 0); |
| 93 | } |
| 94 | |
| 95 | /** @brief Open the PulseAudio sound device */ |
| 96 | static void pulseaudio_open() { |
| 97 | /* Much of the following is cribbed from the PulseAudio `simple' source. */ |
| 98 | |
| 99 | pa_sample_spec ss; |
| 100 | |
| 101 | /* Set up the sample format. */ |
| 102 | ss.format = -1; |
| 103 | switch(uaudio_bits) { |
| 104 | case 8: if(!uaudio_signed) ss.format = PA_SAMPLE_U8; break; |
| 105 | case 16: if(uaudio_signed) ss.format = PA_SAMPLE_S16NE; break; |
| 106 | case 32: if(uaudio_signed) ss.format = PA_SAMPLE_S32NE; break; |
| 107 | } |
| 108 | if(ss.format == -1) |
| 109 | disorder_fatal(0, "unsupported uaudio format (%d, %d)", |
| 110 | uaudio_bits, uaudio_signed); |
| 111 | ss.channels = uaudio_channels; |
| 112 | ss.rate = uaudio_rate; |
| 113 | |
| 114 | /* Create the random PulseAudio pieces. */ |
| 115 | loop = pa_threaded_mainloop_new(); |
| 116 | if(!loop) disorder_fatal(0, "failed to create pulseaudio main loop"); |
| 117 | pa_threaded_mainloop_lock(loop); |
| 118 | ctx = pa_context_new(pa_threaded_mainloop_get_api(loop), |
| 119 | uaudio_get("application", "DisOrder")); |
| 120 | if(!ctx) disorder_fatal(0, "failed to create pulseaudio context"); |
| 121 | pa_context_set_state_callback(ctx, cb_ctxstate, 0); |
| 122 | if(pa_context_connect(ctx, 0, 0, 0) < 0) |
| 123 | disorder_fatal(0, "failed to connect to pulseaudio server: %s", |
| 124 | PAERRSTR); |
| 125 | |
| 126 | /* Set the main loop going. */ |
| 127 | if(pa_threaded_mainloop_start(loop) < 0) |
| 128 | disorder_fatal(0, "failed to start pulseaudio main loop"); |
| 129 | while(pa_context_get_state(ctx) != PA_CONTEXT_READY) |
| 130 | pa_threaded_mainloop_wait(loop); |
| 131 | |
| 132 | /* Set up my stream. */ |
| 133 | str = pa_stream_new(ctx, "DisOrder", &ss, 0); |
| 134 | if(!str) |
| 135 | disorder_fatal(0, "failed to create pulseaudio stream: %s", PAERRSTR); |
| 136 | pa_stream_set_write_callback(str, cb_wakeup, 0); |
| 137 | if(pa_stream_connect_playback(str, 0, 0, |
| 138 | PA_STREAM_ADJUST_LATENCY, |
| 139 | 0, 0)) |
| 140 | disorder_fatal(0, "failed to connect pulseaudio stream for playback: %s", |
| 141 | PAERRSTR); |
| 142 | pa_stream_set_state_callback(str, cb_strstate, 0); |
| 143 | |
| 144 | /* Wait until the stream is ready. */ |
| 145 | while(pa_stream_get_state(str) != PA_STREAM_READY) |
| 146 | pa_threaded_mainloop_wait(loop); |
| 147 | |
| 148 | /* All done. */ |
| 149 | strix = pa_stream_get_index(str); |
| 150 | pa_threaded_mainloop_unlock(loop); |
| 151 | } |
| 152 | |
| 153 | /** @brief Close the PulseAudio sound device */ |
| 154 | static void pulseaudio_close(void) { |
| 155 | if(loop) pa_threaded_mainloop_stop(loop); |
| 156 | if(str) { pa_stream_unref(str); str = 0; } |
| 157 | if(ctx) { pa_context_disconnect(ctx); pa_context_unref(ctx); ctx = 0; } |
| 158 | if(loop) { pa_threaded_mainloop_free(loop); loop = 0; } |
| 159 | } |
| 160 | |
| 161 | /** @brief Actually play sound via PulseAudio */ |
| 162 | static size_t pulseaudio_play(void *buffer, size_t samples, |
| 163 | attribute((unused)) unsigned flags) { |
| 164 | unsigned char *p = buffer; |
| 165 | size_t n, sz = samples*uaudio_sample_size; |
| 166 | |
| 167 | pa_threaded_mainloop_lock(loop); |
| 168 | while(sz) { |
| 169 | |
| 170 | /* Wait until some output space becomes available. */ |
| 171 | while(!(n = pa_stream_writable_size(str))) |
| 172 | pa_threaded_mainloop_wait(loop); |
| 173 | if(n > sz) n = sz; |
| 174 | if(pa_stream_write(str, p, n, 0, 0, PA_SEEK_RELATIVE) < 0) |
| 175 | disorder_fatal(0, "failed to write pulseaudio data: %s", PAERRSTR); |
| 176 | p += n; sz -= n; |
| 177 | } |
| 178 | pa_threaded_mainloop_unlock(loop); |
| 179 | return samples; |
| 180 | } |
| 181 | |
| 182 | static void pulseaudio_start(uaudio_callback *callback, |
| 183 | void *userdata) { |
| 184 | pulseaudio_open(); |
| 185 | uaudio_thread_start(callback, userdata, pulseaudio_play, |
| 186 | 32 / uaudio_sample_size, |
| 187 | 4096 / uaudio_sample_size, |
| 188 | 0); |
| 189 | } |
| 190 | |
| 191 | static void pulseaudio_stop(void) { |
| 192 | uaudio_thread_stop(); |
| 193 | pulseaudio_close(); |
| 194 | } |
| 195 | |
| 196 | static void pulseaudio_open_mixer(void) { |
| 197 | if(!str) |
| 198 | disorder_fatal(0, "won't open pulseaudio mixer with no stream open"); |
| 199 | switch(uaudio_channels) { |
| 200 | case 1: pa_channel_map_init_mono(&cmap); break; |
| 201 | case 2: pa_channel_map_init_stereo(&cmap); break; |
| 202 | default: disorder_error(0, "no pulseaudio mixer support for %d channels", |
| 203 | uaudio_channels); |
| 204 | } |
| 205 | } |
| 206 | |
| 207 | static void pulseaudio_close_mixer(void) { |
| 208 | } |
| 209 | |
| 210 | struct getvol { |
| 211 | pa_cvolume vol; |
| 212 | int donep; |
| 213 | }; |
| 214 | |
| 215 | /** @brief Callback: pick out our stream's volume. */ |
| 216 | static void cb_getvol(attribute((unused)) pa_context *xctx, |
| 217 | const pa_sink_input_info *info, int flag, void *p) { |
| 218 | struct getvol *gv = p; |
| 219 | |
| 220 | if(flag < 0) |
| 221 | disorder_fatal(0, "failed to read own pulseaudio sink-input volume: %s", |
| 222 | PAERRSTR); |
| 223 | else if(!flag) { |
| 224 | gv->vol = info->volume; |
| 225 | gv->donep = -1; |
| 226 | } else if (!gv->donep) |
| 227 | disorder_fatal(0, "no answer reading own pulseaudio sink-input volume"); |
| 228 | else { |
| 229 | gv->donep = 1; |
| 230 | pa_threaded_mainloop_signal(loop, 0); |
| 231 | } |
| 232 | } |
| 233 | |
| 234 | static void pulseaudio_get_volume(int *left, int *right) { |
| 235 | pa_operation *op; |
| 236 | struct getvol gv; |
| 237 | double l, r; |
| 238 | |
| 239 | pa_threaded_mainloop_lock(loop); |
| 240 | gv.donep = 0; |
| 241 | op = pa_context_get_sink_input_info(ctx, strix, cb_getvol, &gv); |
| 242 | while(gv.donep <= 0) pa_threaded_mainloop_wait(loop); |
| 243 | pa_threaded_mainloop_unlock(loop); |
| 244 | pa_operation_unref(op); |
| 245 | |
| 246 | switch(uaudio_channels) { |
| 247 | case 1: l = r = gv.vol.values[0]; break; |
| 248 | case 2: l = gv.vol.values[0]; r = gv.vol.values[1]; break; |
| 249 | default: l = r = 0; break; |
| 250 | } |
| 251 | |
| 252 | *left = 100.0*l/PA_VOLUME_NORM + 0.5; |
| 253 | *right = 100.0*r/PA_VOLUME_NORM + 0.5; |
| 254 | } |
| 255 | |
| 256 | static void pulseaudio_set_volume(int *left, int *right) { |
| 257 | pa_operation *op; |
| 258 | struct simpleop sop; |
| 259 | pa_cvolume vol; |
| 260 | double r, l; |
| 261 | |
| 262 | l = *left*PA_VOLUME_NORM/100.0 + 0.5; |
| 263 | r = *right*PA_VOLUME_NORM/100.0 + 0.5; |
| 264 | |
| 265 | pa_cvolume_init(&vol); vol.channels = uaudio_channels; |
| 266 | switch(uaudio_channels) { |
| 267 | case 1: if(r < l) r = l; vol.values[0] = vol.values[1] = r; break; |
| 268 | case 2: vol.values[0] = l; vol.values[1] = r; break; |
| 269 | default: return; |
| 270 | } |
| 271 | |
| 272 | pa_threaded_mainloop_lock(loop); |
| 273 | sop.what = "set pulseaudio volume"; sop.donep = 0; |
| 274 | op = pa_context_set_sink_input_volume(ctx, strix, &vol, cb_success, &sop); |
| 275 | while(!sop.donep) pa_threaded_mainloop_wait(loop); |
| 276 | pa_threaded_mainloop_unlock(loop); |
| 277 | pa_operation_unref(op); |
| 278 | |
| 279 | pulseaudio_get_volume(left, right); |
| 280 | } |
| 281 | |
| 282 | static void pulseaudio_configure(void) { |
| 283 | } |
| 284 | |
| 285 | const struct uaudio uaudio_pulseaudio = { |
| 286 | .name = "pulseaudio", |
| 287 | .options = pulseaudio_options, |
| 288 | .start = pulseaudio_start, |
| 289 | .stop = pulseaudio_stop, |
| 290 | .activate = uaudio_thread_activate, |
| 291 | .deactivate = uaudio_thread_deactivate, |
| 292 | .open_mixer = pulseaudio_open_mixer, |
| 293 | .close_mixer = pulseaudio_close_mixer, |
| 294 | .get_volume = pulseaudio_get_volume, |
| 295 | .set_volume = pulseaudio_set_volume, |
| 296 | .configure = pulseaudio_configure, |
| 297 | .flags = UAUDIO_API_CLIENT, |
| 298 | }; |
| 299 | |
| 300 | #endif |
| 301 | |
| 302 | /* |
| 303 | Local Variables: |
| 304 | c-basic-offset:2 |
| 305 | comment-column:40 |
| 306 | fill-column:79 |
| 307 | indent-tabs-mode:nil |
| 308 | End: |
| 309 | */ |