This repository has been archived by the owner on Feb 11, 2021. It is now read-only.
/
SDL_pulseaudio.c
510 lines (436 loc) · 15.6 KB
1
/*
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
Simple DirectMedia Layer
Copyright (C) 1997-2011 Sam Lantinga <slouken@libsdl.org>
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
20
21
22
23
24
25
26
27
28
29
*/
/*
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"
30
31
#if SDL_AUDIO_DRIVER_PULSEAUDIO
32
33
34
35
36
37
38
39
/* 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
309
SDL_free(this->hidden);
this->hidden = NULL;
}
}
static int
PULSEAUDIO_OpenDevice(_THIS, const char *devname, int iscapture)
{
310
struct SDL_PrivateAudioData *h = NULL;
311
312
313
314
Uint16 test_format = 0;
pa_sample_spec paspec;
pa_buffer_attr paattr;
pa_channel_map pacmap;
315
316
pa_stream_flags_t flags = 0;
int state = 0;
317
318
319
320
321
322
323
324
325
/* 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));
326
h = this->hidden;
327
328
329
330
331
332
333
334
335
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
336
337
338
339
340
341
342
343
344
345
346
347
348
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;
349
350
351
352
353
354
355
356
357
358
359
360
361
}
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 */
362
363
364
#ifdef PA_STREAM_ADJUST_LATENCY
this->spec.samples /= 2; /* Mix in smaller chunck to avoid underruns */
#endif
365
366
367
SDL_CalculateAudioSpec(&this->spec);
/* Allocate mixing buffer */
368
369
370
h->mixlen = this->spec.size;
h->mixbuf = (Uint8 *) SDL_AllocAudioMem(h->mixlen);
if (h->mixbuf == NULL) {
371
372
373
374
PULSEAUDIO_CloseDevice(this);
SDL_OutOfMemory();
return 0;
}
375
SDL_memset(h->mixbuf, this->spec.silence, this->spec.size);
376
377
378
379
380
paspec.channels = this->spec.channels;
paspec.rate = this->spec.freq;
/* Reduced prebuffering compared to the defaults. */
381
#ifdef PA_STREAM_ADJUST_LATENCY
382
383
/* 2x original requested bufsize */
paattr.tlength = h->mixlen * 4;
384
385
paattr.prebuf = -1;
paattr.maxlength = -1;
386
387
/* -1 can lead to pa_stream_writable_size() >= mixlen never being true */
paattr.minreq = h->mixlen;
388
389
flags = PA_STREAM_ADJUST_LATENCY;
#else
390
391
392
393
paattr.tlength = h->mixlen*2;
paattr.prebuf = h->mixlen*2;
paattr.maxlength = h->mixlen*2;
paattr.minreq = h->mixlen;
394
#endif
395
396
397
/* The SDL ALSA output hints us that we use Windows' channel mapping */
/* http://bugzilla.libsdl.org/show_bug.cgi?id=110 */
398
PULSEAUDIO_pa_channel_map_init_auto(&pacmap, this->spec.channels,
399
PA_CHANNEL_MAP_WAVEEX);
400
401
/* Set up a new main loop */
402
if (!(h->mainloop = PULSEAUDIO_pa_mainloop_new())) {
403
404
405
406
407
PULSEAUDIO_CloseDevice(this);
SDL_SetError("pa_mainloop_new() failed");
return 0;
}
408
h->mainloop_api = PULSEAUDIO_pa_mainloop_get_api(h->mainloop);
409
h->context = PULSEAUDIO_pa_context_new(h->mainloop_api, NULL);
410
if (!h->context) {
411
412
413
414
415
PULSEAUDIO_CloseDevice(this);
SDL_SetError("pa_context_new() failed");
return 0;
}
416
/* Connect to the PulseAudio server */
417
if (PULSEAUDIO_pa_context_connect(h->context, NULL, 0, NULL) < 0) {
418
419
420
421
422
423
PULSEAUDIO_CloseDevice(this);
SDL_SetError("Could not setup connection to PulseAudio");
return 0;
}
do {
424
if (PULSEAUDIO_pa_mainloop_iterate(h->mainloop, 1, NULL) < 0) {
425
426
427
428
PULSEAUDIO_CloseDevice(this);
SDL_SetError("pa_mainloop_iterate() failed");
return 0;
}
429
state = PULSEAUDIO_pa_context_get_state(h->context);
430
431
432
433
434
435
436
if (!PA_CONTEXT_IS_GOOD(state)) {
PULSEAUDIO_CloseDevice(this);
SDL_SetError("Could not connect to PulseAudio");
return 0;
}
} while (state != PA_CONTEXT_READY);
437
438
h->stream = PULSEAUDIO_pa_stream_new(
h->context,
439
440
441
"Simple DirectMedia Layer", /* stream description */
&paspec, /* sample format spec */
&pacmap /* channel map */
442
443
);
444
if (h->stream == NULL) {
445
PULSEAUDIO_CloseDevice(this);
446
SDL_SetError("Could not set up PulseAudio stream");
447
return 0;
448
449
}
450
if (PULSEAUDIO_pa_stream_connect_playback(h->stream, NULL, &paattr, flags,
451
452
453
454
455
456
457
NULL, NULL) < 0) {
PULSEAUDIO_CloseDevice(this);
SDL_SetError("Could not connect PulseAudio stream");
return 0;
}
do {
458
if (PULSEAUDIO_pa_mainloop_iterate(h->mainloop, 1, NULL) < 0) {
459
460
461
462
PULSEAUDIO_CloseDevice(this);
SDL_SetError("pa_mainloop_iterate() failed");
return 0;
}
463
state = PULSEAUDIO_pa_stream_get_state(h->stream);
464
465
466
467
468
469
if (!PA_STREAM_IS_GOOD(state)) {
PULSEAUDIO_CloseDevice(this);
SDL_SetError("Could not create to PulseAudio stream");
return 0;
}
} while (state != PA_STREAM_READY);
470
471
472
473
474
475
476
477
478
/* We're ready to rock and roll. :-) */
return 1;
}
static void
PULSEAUDIO_Deinitialize(void)
{
479
UnloadPulseAudioLibrary();
480
481
482
483
484
485
}
static int
PULSEAUDIO_Init(SDL_AudioDriverImpl * impl)
{
486
if (LoadPulseAudioLibrary() < 0) {
487
488
489
490
491
492
493
494
495
496
497
498
499
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;
500
return 1; /* this audio target is available. */
501
502
503
504
505
506
507
}
AudioBootStrap PULSEAUDIO_bootstrap = {
PULSEAUDIO_DRIVER_NAME, "PulseAudio", PULSEAUDIO_Init, 0
};
508
509
#endif /* SDL_AUDIO_DRIVER_PULSEAUDIO */
510
/* vi: set ts=4 sw=4 expandtab: */