This repository has been archived by the owner on Feb 11, 2021. It is now read-only.
/
SDL_pulseaudio.c
534 lines (458 loc) · 16.4 KB
1
2
/*
SDL - Simple DirectMedia Layer
3
Copyright (C) 1997-2009 Sam Lantinga
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Sam Lantinga
slouken@libsdl.org
*/
/*
The PulseAudio target for SDL 1.3 is based on the 1.3 arts target, with
the appropriate parts replaced with the 1.2 PulseAudio target code. This
was the cleanest way to move it to 1.3. The 1.2 target was written by
Stéphan Kochen: stephan .a.t. kochen.nl
*/
#include "SDL_config.h"
/* Allow access to a raw mixing buffer */
#ifdef HAVE_SIGNAL_H
#include <signal.h>
#endif
#include <unistd.h>
#include <sys/types.h>
#include <errno.h>
40
#include <pulse/pulseaudio.h>
41
42
43
44
45
46
47
48
49
50
51
52
#include <pulse/simple.h>
#include "SDL_timer.h"
#include "SDL_audio.h"
#include "../SDL_audiomem.h"
#include "../SDL_audio_c.h"
#include "SDL_pulseaudio.h"
#include "SDL_loadso.h"
/* The tag name used by pulse audio */
#define PULSEAUDIO_DRIVER_NAME "pulseaudio"
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
#if (PA_API_VERSION < 12)
/** Return non-zero if the passed state is one of the connected states */
static inline int PA_CONTEXT_IS_GOOD(pa_context_state_t x) {
return
x == PA_CONTEXT_CONNECTING ||
x == PA_CONTEXT_AUTHORIZING ||
x == PA_CONTEXT_SETTING_NAME ||
x == PA_CONTEXT_READY;
}
/** Return non-zero if the passed state is one of the connected states */
static inline int PA_STREAM_IS_GOOD(pa_stream_state_t x) {
return
x == PA_STREAM_CREATING ||
x == PA_STREAM_READY;
}
#endif /* pulseaudio <= 0.9.10 */
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
static pa_simple *(*PULSEAUDIO_pa_simple_new) (const char *, const char *,
pa_stream_direction_t, const char *, const char *, const pa_sample_spec *,
const pa_channel_map *, const pa_buffer_attr *, int *);
static void (*PULSEAUDIO_pa_simple_free) (pa_simple *);
static pa_channel_map *(*PULSEAUDIO_pa_channel_map_init_auto) (
pa_channel_map *, unsigned, pa_channel_map_def_t);
static const char * (*PULSEAUDIO_pa_strerror) (int);
static pa_mainloop * (*PULSEAUDIO_pa_mainloop_new) (void);
static pa_mainloop_api * (*PULSEAUDIO_pa_mainloop_get_api) (pa_mainloop *);
static int (*PULSEAUDIO_pa_mainloop_iterate) (pa_mainloop *, int, int *);
static void (*PULSEAUDIO_pa_mainloop_free) (pa_mainloop *);
static pa_operation_state_t (*PULSEAUDIO_pa_operation_get_state) (
pa_operation *);
static void (*PULSEAUDIO_pa_operation_cancel) (pa_operation *);
static void (*PULSEAUDIO_pa_operation_unref) (pa_operation *);
static pa_context * (*PULSEAUDIO_pa_context_new) (pa_mainloop_api *,
const char *);
static int (*PULSEAUDIO_pa_context_connect) (pa_context *, const char *,
pa_context_flags_t, const pa_spawn_api *);
static pa_context_state_t (*PULSEAUDIO_pa_context_get_state) (pa_context *);
static void (*PULSEAUDIO_pa_context_disconnect) (pa_context *);
static void (*PULSEAUDIO_pa_context_unref) (pa_context *);
static pa_stream * (*PULSEAUDIO_pa_stream_new) (pa_context *, const char *,
const pa_sample_spec *, const pa_channel_map *);
static int (*PULSEAUDIO_pa_stream_connect_playback) (pa_stream *, const char *,
const pa_buffer_attr *, pa_stream_flags_t, pa_cvolume *, pa_stream *);
static pa_stream_state_t (*PULSEAUDIO_pa_stream_get_state) (pa_stream *);
static size_t (*PULSEAUDIO_pa_stream_writable_size) (pa_stream *);
static int (*PULSEAUDIO_pa_stream_write) (pa_stream *, const void *, size_t,
pa_free_cb_t, int64_t, pa_seek_mode_t);
static pa_operation * (*PULSEAUDIO_pa_stream_drain) (pa_stream *,
pa_stream_success_cb_t, void *);
static int (*PULSEAUDIO_pa_stream_disconnect) (pa_stream *);
static void (*PULSEAUDIO_pa_stream_unref) (pa_stream *);
static int load_pulseaudio_syms(void);
#ifdef SDL_AUDIO_DRIVER_PULSEAUDIO_DYNAMIC
static const char *pulseaudio_library = SDL_AUDIO_DRIVER_PULSEAUDIO_DYNAMIC;
static void *pulseaudio_handle = NULL;
static int
load_pulseaudio_sym(const char *fn, void **addr)
119
{
120
121
122
123
124
*addr = SDL_LoadFunction(pulseaudio_handle, fn);
if (*addr == NULL) {
/* Don't call SDL_SetError(): SDL_LoadFunction already did. */
return 0;
}
125
126
127
128
129
130
131
return 1;
}
/* cast funcs to char* first, to please GCC's strict aliasing rules. */
#define SDL_PULSEAUDIO_SYM(x) \
if (!load_pulseaudio_sym(#x, (void **) (char *) &PULSEAUDIO_##x)) return -1
132
133
static void
134
UnloadPulseAudioLibrary(void)
135
{
136
137
138
if (pulseaudio_handle != NULL) {
SDL_UnloadObject(pulseaudio_handle);
pulseaudio_handle = NULL;
139
140
141
142
}
}
static int
143
LoadPulseAudioLibrary(void)
144
{
145
146
147
148
149
150
151
152
153
154
int retval = 0;
if (pulseaudio_handle == NULL) {
pulseaudio_handle = SDL_LoadObject(pulseaudio_library);
if (pulseaudio_handle == NULL) {
retval = -1;
/* Don't call SDL_SetError(): SDL_LoadObject already did. */
} else {
retval = load_pulseaudio_syms();
if (retval < 0) {
UnloadPulseAudioLibrary();
155
156
157
158
159
160
161
162
}
}
}
return retval;
}
#else
163
164
#define SDL_PULSEAUDIO_SYM(x) PULSEAUDIO_##x = x
165
static void
166
UnloadPulseAudioLibrary(void)
167
168
169
170
{
}
static int
171
LoadPulseAudioLibrary(void)
172
{
173
load_pulseaudio_syms();
174
175
176
177
178
return 0;
}
#endif /* SDL_AUDIO_DRIVER_PULSEAUDIO_DYNAMIC */
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
static int
load_pulseaudio_syms(void)
{
SDL_PULSEAUDIO_SYM(pa_simple_new);
SDL_PULSEAUDIO_SYM(pa_simple_free);
SDL_PULSEAUDIO_SYM(pa_mainloop_new);
SDL_PULSEAUDIO_SYM(pa_mainloop_get_api);
SDL_PULSEAUDIO_SYM(pa_mainloop_iterate);
SDL_PULSEAUDIO_SYM(pa_mainloop_free);
SDL_PULSEAUDIO_SYM(pa_operation_get_state);
SDL_PULSEAUDIO_SYM(pa_operation_cancel);
SDL_PULSEAUDIO_SYM(pa_operation_unref);
SDL_PULSEAUDIO_SYM(pa_context_new);
SDL_PULSEAUDIO_SYM(pa_context_connect);
SDL_PULSEAUDIO_SYM(pa_context_get_state);
SDL_PULSEAUDIO_SYM(pa_context_disconnect);
SDL_PULSEAUDIO_SYM(pa_context_unref);
SDL_PULSEAUDIO_SYM(pa_stream_new);
SDL_PULSEAUDIO_SYM(pa_stream_connect_playback);
SDL_PULSEAUDIO_SYM(pa_stream_get_state);
SDL_PULSEAUDIO_SYM(pa_stream_writable_size);
SDL_PULSEAUDIO_SYM(pa_stream_write);
SDL_PULSEAUDIO_SYM(pa_stream_drain);
SDL_PULSEAUDIO_SYM(pa_stream_disconnect);
SDL_PULSEAUDIO_SYM(pa_stream_unref);
SDL_PULSEAUDIO_SYM(pa_channel_map_init_auto);
SDL_PULSEAUDIO_SYM(pa_strerror);
return 0;
}
211
212
213
214
/* This function waits until it is possible to write a full sound buffer */
static void
PULSEAUDIO_WaitDevice(_THIS)
{
215
while(1) {
216
217
218
if (PULSEAUDIO_pa_context_get_state(this->hidden->context) != PA_CONTEXT_READY ||
PULSEAUDIO_pa_stream_get_state(this->hidden->stream) != PA_STREAM_READY ||
PULSEAUDIO_pa_mainloop_iterate(this->hidden->mainloop, 1, NULL) < 0) {
219
220
221
this->enabled = 0;
return;
}
222
if (PULSEAUDIO_pa_stream_writable_size(this->hidden->stream) >= this->hidden->mixlen) {
223
return;
224
225
226
227
228
229
230
231
}
}
}
static void
PULSEAUDIO_PlayDevice(_THIS)
{
/* Write the audio data */
232
if (PULSEAUDIO_pa_stream_write(this->hidden->stream, this->hidden->mixbuf,
233
234
this->hidden->mixlen, NULL, 0LL,
PA_SEEK_RELATIVE) < 0) {
235
236
237
238
this->enabled = 0;
}
}
239
240
241
242
243
244
static void
stream_drain_complete(pa_stream *s, int success, void *userdata)
{
/* no-op for pa_stream_drain() to use for callback. */
}
245
246
247
static void
PULSEAUDIO_WaitDone(_THIS)
{
248
249
pa_operation *o;
250
o = PULSEAUDIO_pa_stream_drain(this->hidden->stream, stream_drain_complete, NULL);
251
252
253
254
if (!o) {
return;
}
255
256
257
258
259
while (PULSEAUDIO_pa_operation_get_state(o) != PA_OPERATION_DONE) {
if (PULSEAUDIO_pa_context_get_state(this->hidden->context) != PA_CONTEXT_READY ||
PULSEAUDIO_pa_stream_get_state(this->hidden->stream) != PA_STREAM_READY ||
PULSEAUDIO_pa_mainloop_iterate(this->hidden->mainloop, 1, NULL) < 0) {
PULSEAUDIO_pa_operation_cancel(o);
260
261
262
263
break;
}
}
264
PULSEAUDIO_pa_operation_unref(o);
265
266
267
}
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
static Uint8 *
PULSEAUDIO_GetDeviceBuf(_THIS)
{
return (this->hidden->mixbuf);
}
static void
PULSEAUDIO_CloseDevice(_THIS)
{
if (this->hidden != NULL) {
if (this->hidden->mixbuf != NULL) {
SDL_FreeAudioMem(this->hidden->mixbuf);
this->hidden->mixbuf = NULL;
}
if (this->hidden->stream) {
285
286
PULSEAUDIO_pa_stream_disconnect(this->hidden->stream);
PULSEAUDIO_pa_stream_unref(this->hidden->stream);
287
288
this->hidden->stream = NULL;
}
289
if (this->hidden->context != NULL) {
290
291
PULSEAUDIO_pa_context_disconnect(this->hidden->context);
PULSEAUDIO_pa_context_unref(this->hidden->context);
292
293
294
this->hidden->context = NULL;
}
if (this->hidden->mainloop != NULL) {
295
PULSEAUDIO_pa_mainloop_free(this->hidden->mainloop);
296
297
this->hidden->mainloop = NULL;
}
298
299
300
301
302
303
304
305
SDL_free(this->hidden);
this->hidden = NULL;
}
}
/* !!! FIXME: this could probably be expanded. */
/* Try to get the name of the program */
306
307
static char *
get_progname(void)
308
309
{
#ifdef __LINUX__
310
char *progname = NULL;
311
312
313
314
315
FILE *fp;
static char temp[BUFSIZ];
SDL_snprintf(temp, SDL_arraysize(temp), "/proc/%d/cmdline", getpid());
fp = fopen(temp, "r");
316
317
if (fp != NULL) {
if (fgets(temp, sizeof(temp) - 1, fp)) {
318
progname = SDL_strrchr(temp, '/');
319
if (progname == NULL) {
320
321
progname = temp;
} else {
322
progname = progname + 1;
323
324
325
326
}
}
fclose(fp);
}
327
328
329
330
331
return(progname);
#elif defined(__NetBSD__)
return getprogname();
#else
return("unknown");
332
333
334
335
336
337
338
#endif
}
static int
PULSEAUDIO_OpenDevice(_THIS, const char *devname, int iscapture)
{
339
340
341
342
Uint16 test_format = 0;
pa_sample_spec paspec;
pa_buffer_attr paattr;
pa_channel_map pacmap;
343
344
pa_stream_flags_t flags = 0;
int state = 0;
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
/* Initialize all variables that we clean on shutdown */
this->hidden = (struct SDL_PrivateAudioData *)
SDL_malloc((sizeof *this->hidden));
if (this->hidden == NULL) {
SDL_OutOfMemory();
return 0;
}
SDL_memset(this->hidden, 0, (sizeof *this->hidden));
paspec.format = PA_SAMPLE_INVALID;
/* Try for a closest match on audio format */
for (test_format = SDL_FirstAudioFormat(this->spec.format);
(paspec.format == PA_SAMPLE_INVALID) && test_format;) {
#ifdef DEBUG_AUDIO
fprintf(stderr, "Trying format 0x%4.4x\n", test_format);
#endif
363
364
365
366
367
368
369
370
371
372
373
374
375
switch (test_format) {
case AUDIO_U8:
paspec.format = PA_SAMPLE_U8;
break;
case AUDIO_S16LSB:
paspec.format = PA_SAMPLE_S16LE;
break;
case AUDIO_S16MSB:
paspec.format = PA_SAMPLE_S16BE;
break;
default:
paspec.format = PA_SAMPLE_INVALID;
break;
376
377
378
379
380
381
382
383
384
385
386
387
388
}
if (paspec.format == PA_SAMPLE_INVALID) {
test_format = SDL_NextAudioFormat();
}
}
if (paspec.format == PA_SAMPLE_INVALID) {
PULSEAUDIO_CloseDevice(this);
SDL_SetError("Couldn't find any hardware audio formats");
return 0;
}
this->spec.format = test_format;
/* Calculate the final parameters for this audio specification */
389
390
391
#ifdef PA_STREAM_ADJUST_LATENCY
this->spec.samples /= 2; /* Mix in smaller chunck to avoid underruns */
#endif
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
SDL_CalculateAudioSpec(&this->spec);
/* Allocate mixing buffer */
this->hidden->mixlen = this->spec.size;
this->hidden->mixbuf = (Uint8 *) SDL_AllocAudioMem(this->hidden->mixlen);
if (this->hidden->mixbuf == NULL) {
PULSEAUDIO_CloseDevice(this);
SDL_OutOfMemory();
return 0;
}
SDL_memset(this->hidden->mixbuf, this->spec.silence, this->spec.size);
paspec.channels = this->spec.channels;
paspec.rate = this->spec.freq;
/* Reduced prebuffering compared to the defaults. */
408
409
410
411
412
#ifdef PA_STREAM_ADJUST_LATENCY
paattr.tlength = this->hidden->mixlen * 4; /* 2x original requested bufsize */
paattr.prebuf = -1;
paattr.maxlength = -1;
/* -1 can lead to pa_stream_writable_size() >= this->hidden->mixlen never being true */
413
paattr.minreq = this->hidden->mixlen;
414
415
416
417
418
419
420
flags = PA_STREAM_ADJUST_LATENCY;
#else
paattr.tlength = this->hidden->mixlen*2;
paattr.prebuf = this->hidden->mixlen*2;
paattr.maxlength = this->hidden->mixlen*2;
paattr.minreq = this->hidden->mixlen;
#endif
421
422
423
/* The SDL ALSA output hints us that we use Windows' channel mapping */
/* http://bugzilla.libsdl.org/show_bug.cgi?id=110 */
424
PULSEAUDIO_pa_channel_map_init_auto(&pacmap, this->spec.channels,
425
PA_CHANNEL_MAP_WAVEEX);
426
427
/* Set up a new main loop */
428
if (!(this->hidden->mainloop = PULSEAUDIO_pa_mainloop_new())) {
429
430
431
432
433
PULSEAUDIO_CloseDevice(this);
SDL_SetError("pa_mainloop_new() failed");
return 0;
}
434
435
this->hidden->mainloop_api = PULSEAUDIO_pa_mainloop_get_api(this->hidden->mainloop);
if (!(this->hidden->context = PULSEAUDIO_pa_context_new(this->hidden->mainloop_api, get_progname()))) {
436
437
438
439
440
PULSEAUDIO_CloseDevice(this);
SDL_SetError("pa_context_new() failed");
return 0;
}
441
/* Connect to the PulseAudio server */
442
if (PULSEAUDIO_pa_context_connect(this->hidden->context, NULL, 0, NULL) < 0) {
443
444
445
446
447
448
PULSEAUDIO_CloseDevice(this);
SDL_SetError("Could not setup connection to PulseAudio");
return 0;
}
do {
449
if (PULSEAUDIO_pa_mainloop_iterate(this->hidden->mainloop, 1, NULL) < 0) {
450
451
452
453
PULSEAUDIO_CloseDevice(this);
SDL_SetError("pa_mainloop_iterate() failed");
return 0;
}
454
state = PULSEAUDIO_pa_context_get_state(this->hidden->context);
455
456
457
458
459
460
461
if (!PA_CONTEXT_IS_GOOD(state)) {
PULSEAUDIO_CloseDevice(this);
SDL_SetError("Could not connect to PulseAudio");
return 0;
}
} while (state != PA_CONTEXT_READY);
462
this->hidden->stream = PULSEAUDIO_pa_stream_new(
463
464
465
466
this->hidden->context,
"Simple DirectMedia Layer", /* stream description */
&paspec, /* sample format spec */
&pacmap /* channel map */
467
468
469
);
if (this->hidden->stream == NULL) {
470
PULSEAUDIO_CloseDevice(this);
471
SDL_SetError("Could not set up PulseAudio stream");
472
return 0;
473
474
}
475
if (PULSEAUDIO_pa_stream_connect_playback(this->hidden->stream, NULL, &paattr, flags,
476
477
478
479
480
481
482
NULL, NULL) < 0) {
PULSEAUDIO_CloseDevice(this);
SDL_SetError("Could not connect PulseAudio stream");
return 0;
}
do {
483
if (PULSEAUDIO_pa_mainloop_iterate(this->hidden->mainloop, 1, NULL) < 0) {
484
485
486
487
PULSEAUDIO_CloseDevice(this);
SDL_SetError("pa_mainloop_iterate() failed");
return 0;
}
488
state = PULSEAUDIO_pa_stream_get_state(this->hidden->stream);
489
490
491
492
493
494
if (!PA_STREAM_IS_GOOD(state)) {
PULSEAUDIO_CloseDevice(this);
SDL_SetError("Could not create to PulseAudio stream");
return 0;
}
} while (state != PA_STREAM_READY);
495
496
497
498
499
500
501
502
503
/* We're ready to rock and roll. :-) */
return 1;
}
static void
PULSEAUDIO_Deinitialize(void)
{
504
UnloadPulseAudioLibrary();
505
506
507
508
509
510
}
static int
PULSEAUDIO_Init(SDL_AudioDriverImpl * impl)
{
511
if (LoadPulseAudioLibrary() < 0) {
512
513
514
515
516
517
518
519
520
521
522
523
524
return 0;
}
/* Set the function pointers */
impl->OpenDevice = PULSEAUDIO_OpenDevice;
impl->PlayDevice = PULSEAUDIO_PlayDevice;
impl->WaitDevice = PULSEAUDIO_WaitDevice;
impl->GetDeviceBuf = PULSEAUDIO_GetDeviceBuf;
impl->CloseDevice = PULSEAUDIO_CloseDevice;
impl->WaitDone = PULSEAUDIO_WaitDone;
impl->Deinitialize = PULSEAUDIO_Deinitialize;
impl->OnlyHasDefaultOutputDevice = 1;
525
/* !!! FIXME: should test if server is available here, return 2 if so. */
526
527
528
529
530
531
532
533
534
return 1;
}
AudioBootStrap PULSEAUDIO_bootstrap = {
PULSEAUDIO_DRIVER_NAME, "PulseAudio", PULSEAUDIO_Init, 0
};
/* vi: set ts=4 sw=4 expandtab: */