This repository has been archived by the owner on Feb 11, 2021. It is now read-only.
/
SDL_pulseaudio.c
540 lines (463 loc) · 16.2 KB
1
2
/*
SDL - Simple DirectMedia Layer
3
Copyright (C) 1997-2010 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
216
struct SDL_PrivateAudioData *h = this->hidden;
217
while(1) {
218
219
220
if (PULSEAUDIO_pa_context_get_state(h->context) != PA_CONTEXT_READY ||
PULSEAUDIO_pa_stream_get_state(h->stream) != PA_STREAM_READY ||
PULSEAUDIO_pa_mainloop_iterate(h->mainloop, 1, NULL) < 0) {
221
222
223
this->enabled = 0;
return;
}
224
if (PULSEAUDIO_pa_stream_writable_size(h->stream) >= h->mixlen) {
225
return;
226
227
228
229
230
231
232
233
}
}
}
static void
PULSEAUDIO_PlayDevice(_THIS)
{
/* Write the audio data */
234
235
struct SDL_PrivateAudioData *h = this->hidden;
if (PULSEAUDIO_pa_stream_write(h->stream, h->mixbuf, h->mixlen, NULL, 0LL,
236
PA_SEEK_RELATIVE) < 0) {
237
238
239
240
this->enabled = 0;
}
}
241
242
243
244
245
246
static void
stream_drain_complete(pa_stream *s, int success, void *userdata)
{
/* no-op for pa_stream_drain() to use for callback. */
}
247
248
249
static void
PULSEAUDIO_WaitDone(_THIS)
{
250
struct SDL_PrivateAudioData *h = this->hidden;
251
252
pa_operation *o;
253
o = PULSEAUDIO_pa_stream_drain(h->stream, stream_drain_complete, NULL);
254
255
256
257
if (!o) {
return;
}
258
while (PULSEAUDIO_pa_operation_get_state(o) != PA_OPERATION_DONE) {
259
260
261
if (PULSEAUDIO_pa_context_get_state(h->context) != PA_CONTEXT_READY ||
PULSEAUDIO_pa_stream_get_state(h->stream) != PA_STREAM_READY ||
PULSEAUDIO_pa_mainloop_iterate(h->mainloop, 1, NULL) < 0) {
262
PULSEAUDIO_pa_operation_cancel(o);
263
264
265
266
break;
}
}
267
PULSEAUDIO_pa_operation_unref(o);
268
269
270
}
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
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) {
288
289
PULSEAUDIO_pa_stream_disconnect(this->hidden->stream);
PULSEAUDIO_pa_stream_unref(this->hidden->stream);
290
291
this->hidden->stream = NULL;
}
292
if (this->hidden->context != NULL) {
293
294
PULSEAUDIO_pa_context_disconnect(this->hidden->context);
PULSEAUDIO_pa_context_unref(this->hidden->context);
295
296
297
this->hidden->context = NULL;
}
if (this->hidden->mainloop != NULL) {
298
PULSEAUDIO_pa_mainloop_free(this->hidden->mainloop);
299
300
this->hidden->mainloop = NULL;
}
301
302
303
304
305
306
307
308
SDL_free(this->hidden);
this->hidden = NULL;
}
}
/* !!! FIXME: this could probably be expanded. */
/* Try to get the name of the program */
309
310
static char *
get_progname(void)
311
312
{
#ifdef __LINUX__
313
char *progname = NULL;
314
315
316
317
318
FILE *fp;
static char temp[BUFSIZ];
SDL_snprintf(temp, SDL_arraysize(temp), "/proc/%d/cmdline", getpid());
fp = fopen(temp, "r");
319
320
if (fp != NULL) {
if (fgets(temp, sizeof(temp) - 1, fp)) {
321
progname = SDL_strrchr(temp, '/');
322
if (progname == NULL) {
323
324
progname = temp;
} else {
325
progname = progname + 1;
326
327
328
329
}
}
fclose(fp);
}
330
331
332
333
334
return(progname);
#elif defined(__NetBSD__)
return getprogname();
#else
return("unknown");
335
336
337
338
339
340
341
#endif
}
static int
PULSEAUDIO_OpenDevice(_THIS, const char *devname, int iscapture)
{
342
struct SDL_PrivateAudioData *h = NULL;
343
344
345
346
Uint16 test_format = 0;
pa_sample_spec paspec;
pa_buffer_attr paattr;
pa_channel_map pacmap;
347
348
pa_stream_flags_t flags = 0;
int state = 0;
349
350
351
352
353
354
355
356
357
/* 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));
358
h = this->hidden;
359
360
361
362
363
364
365
366
367
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
368
369
370
371
372
373
374
375
376
377
378
379
380
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;
381
382
383
384
385
386
387
388
389
390
391
392
393
}
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 */
394
395
396
#ifdef PA_STREAM_ADJUST_LATENCY
this->spec.samples /= 2; /* Mix in smaller chunck to avoid underruns */
#endif
397
398
399
SDL_CalculateAudioSpec(&this->spec);
/* Allocate mixing buffer */
400
401
402
h->mixlen = this->spec.size;
h->mixbuf = (Uint8 *) SDL_AllocAudioMem(h->mixlen);
if (h->mixbuf == NULL) {
403
404
405
406
PULSEAUDIO_CloseDevice(this);
SDL_OutOfMemory();
return 0;
}
407
SDL_memset(h->mixbuf, this->spec.silence, this->spec.size);
408
409
410
411
412
paspec.channels = this->spec.channels;
paspec.rate = this->spec.freq;
/* Reduced prebuffering compared to the defaults. */
413
#ifdef PA_STREAM_ADJUST_LATENCY
414
415
/* 2x original requested bufsize */
paattr.tlength = h->mixlen * 4;
416
417
paattr.prebuf = -1;
paattr.maxlength = -1;
418
419
/* -1 can lead to pa_stream_writable_size() >= mixlen never being true */
paattr.minreq = h->mixlen;
420
421
flags = PA_STREAM_ADJUST_LATENCY;
#else
422
423
424
425
paattr.tlength = h->mixlen*2;
paattr.prebuf = h->mixlen*2;
paattr.maxlength = h->mixlen*2;
paattr.minreq = h->mixlen;
426
#endif
427
428
429
/* The SDL ALSA output hints us that we use Windows' channel mapping */
/* http://bugzilla.libsdl.org/show_bug.cgi?id=110 */
430
PULSEAUDIO_pa_channel_map_init_auto(&pacmap, this->spec.channels,
431
PA_CHANNEL_MAP_WAVEEX);
432
433
/* Set up a new main loop */
434
if (!(h->mainloop = PULSEAUDIO_pa_mainloop_new())) {
435
436
437
438
439
PULSEAUDIO_CloseDevice(this);
SDL_SetError("pa_mainloop_new() failed");
return 0;
}
440
441
442
h->mainloop_api = PULSEAUDIO_pa_mainloop_get_api(h->mainloop);
h->context = PULSEAUDIO_pa_context_new(h->mainloop_api, get_progname());
if (!h->context) {
443
444
445
446
447
PULSEAUDIO_CloseDevice(this);
SDL_SetError("pa_context_new() failed");
return 0;
}
448
/* Connect to the PulseAudio server */
449
if (PULSEAUDIO_pa_context_connect(h->context, NULL, 0, NULL) < 0) {
450
451
452
453
454
455
PULSEAUDIO_CloseDevice(this);
SDL_SetError("Could not setup connection to PulseAudio");
return 0;
}
do {
456
if (PULSEAUDIO_pa_mainloop_iterate(h->mainloop, 1, NULL) < 0) {
457
458
459
460
PULSEAUDIO_CloseDevice(this);
SDL_SetError("pa_mainloop_iterate() failed");
return 0;
}
461
state = PULSEAUDIO_pa_context_get_state(h->context);
462
463
464
465
466
467
468
if (!PA_CONTEXT_IS_GOOD(state)) {
PULSEAUDIO_CloseDevice(this);
SDL_SetError("Could not connect to PulseAudio");
return 0;
}
} while (state != PA_CONTEXT_READY);
469
470
h->stream = PULSEAUDIO_pa_stream_new(
h->context,
471
472
473
"Simple DirectMedia Layer", /* stream description */
&paspec, /* sample format spec */
&pacmap /* channel map */
474
475
);
476
if (h->stream == NULL) {
477
PULSEAUDIO_CloseDevice(this);
478
SDL_SetError("Could not set up PulseAudio stream");
479
return 0;
480
481
}
482
if (PULSEAUDIO_pa_stream_connect_playback(h->stream, NULL, &paattr, flags,
483
484
485
486
487
488
489
NULL, NULL) < 0) {
PULSEAUDIO_CloseDevice(this);
SDL_SetError("Could not connect PulseAudio stream");
return 0;
}
do {
490
if (PULSEAUDIO_pa_mainloop_iterate(h->mainloop, 1, NULL) < 0) {
491
492
493
494
PULSEAUDIO_CloseDevice(this);
SDL_SetError("pa_mainloop_iterate() failed");
return 0;
}
495
state = PULSEAUDIO_pa_stream_get_state(h->stream);
496
497
498
499
500
501
if (!PA_STREAM_IS_GOOD(state)) {
PULSEAUDIO_CloseDevice(this);
SDL_SetError("Could not create to PulseAudio stream");
return 0;
}
} while (state != PA_STREAM_READY);
502
503
504
505
506
507
508
509
510
/* We're ready to rock and roll. :-) */
return 1;
}
static void
PULSEAUDIO_Deinitialize(void)
{
511
UnloadPulseAudioLibrary();
512
513
514
515
516
517
}
static int
PULSEAUDIO_Init(SDL_AudioDriverImpl * impl)
{
518
if (LoadPulseAudioLibrary() < 0) {
519
520
521
522
523
524
525
526
527
528
529
530
531
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;
532
return 1; /* this audio target is available. */
533
534
535
536
537
538
539
540
}
AudioBootStrap PULSEAUDIO_bootstrap = {
PULSEAUDIO_DRIVER_NAME, "PulseAudio", PULSEAUDIO_Init, 0
};
/* vi: set ts=4 sw=4 expandtab: */