2 * OpenAL cross platform audio library
3 * Copyright (C) 2009 by Konstantinos Natsakis <konstantinos.natsakis@gmail.com>
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Library General Public
6 * License as published by the Free Software Foundation; either
7 * version 2 of the License, or (at your option) any later version.
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Library General Public License for more details.
14 * You should have received a copy of the GNU Library General Public
15 * License along with this library; if not, write to the
16 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
17 * Boston, MA 02111-1307, USA.
18 * Or go to http://www.gnu.org/copyleft/lgpl.html
28 #include <pulse/pulseaudio.h>
30 #if PA_API_VERSION == 11
31 #define PA_STREAM_ADJUST_LATENCY 0x2000U
32 static inline int PA_STREAM_IS_GOOD(pa_stream_state_t x
)
34 return (x
== PA_STREAM_CREATING
|| x
== PA_STREAM_READY
);
36 static inline int PA_CONTEXT_IS_GOOD(pa_context_state_t x
)
38 return (x
== PA_CONTEXT_CONNECTING
|| x
== PA_CONTEXT_AUTHORIZING
||
39 x
== PA_CONTEXT_SETTING_NAME
|| x
== PA_CONTEXT_READY
);
41 #define PA_STREAM_IS_GOOD PA_STREAM_IS_GOOD
42 #define PA_CONTEXT_IS_GOOD PA_CONTEXT_IS_GOOD
43 #elif PA_API_VERSION != 12
44 #error Invalid PulseAudio API version
47 static void *pa_handle
;
48 #define MAKE_FUNC(x) static typeof(x) * p##x
49 MAKE_FUNC(pa_context_unref
);
50 MAKE_FUNC(pa_sample_spec_valid
);
51 MAKE_FUNC(pa_stream_drop
);
52 MAKE_FUNC(pa_strerror
);
53 MAKE_FUNC(pa_context_get_state
);
54 MAKE_FUNC(pa_stream_get_state
);
55 MAKE_FUNC(pa_threaded_mainloop_signal
);
56 MAKE_FUNC(pa_stream_peek
);
57 MAKE_FUNC(pa_threaded_mainloop_wait
);
58 MAKE_FUNC(pa_threaded_mainloop_unlock
);
59 MAKE_FUNC(pa_context_new
);
60 MAKE_FUNC(pa_threaded_mainloop_stop
);
61 MAKE_FUNC(pa_context_disconnect
);
62 MAKE_FUNC(pa_threaded_mainloop_start
);
63 MAKE_FUNC(pa_threaded_mainloop_get_api
);
64 MAKE_FUNC(pa_context_set_state_callback
);
65 MAKE_FUNC(pa_stream_write
);
67 MAKE_FUNC(pa_stream_connect_record
);
68 MAKE_FUNC(pa_stream_connect_playback
);
69 MAKE_FUNC(pa_path_get_filename
);
70 MAKE_FUNC(pa_get_binary_name
);
71 MAKE_FUNC(pa_threaded_mainloop_free
);
72 MAKE_FUNC(pa_context_errno
);
73 MAKE_FUNC(pa_xmalloc0
);
74 MAKE_FUNC(pa_stream_unref
);
75 MAKE_FUNC(pa_threaded_mainloop_accept
);
76 MAKE_FUNC(pa_stream_set_write_callback
);
77 MAKE_FUNC(pa_threaded_mainloop_new
);
78 MAKE_FUNC(pa_context_connect
);
79 MAKE_FUNC(pa_stream_get_buffer_attr
);
80 MAKE_FUNC(pa_stream_set_read_callback
);
81 MAKE_FUNC(pa_stream_set_state_callback
);
82 MAKE_FUNC(pa_stream_new
);
83 MAKE_FUNC(pa_stream_disconnect
);
84 MAKE_FUNC(pa_threaded_mainloop_lock
);
100 char path_name
[PATH_MAX
];
101 const char *context_name
;
102 const char *stream_name
;
104 pa_threaded_mainloop
*loop
;
110 static const ALCchar pulse_device
[] = "PulseAudio Software";
111 static const ALCchar pulse_capture_device
[] = "PulseAudio Capture";
112 static volatile ALuint load_count
;
115 void pulse_load(void) //{{{
120 pa_handle
= LoadLibrary("libpulse-0.dll");
121 #define LOAD_FUNC(x) do { \
122 p##x = GetProcAddress(pa_handle, #x); \
124 AL_PRINT("Could not load %s from libpulse-0.dll\n", #x); \
125 FreeLibrary(pa_handle); \
131 #elif defined (HAVE_DLFCN_H)
134 #if defined(__APPLE__) && defined(__MACH__)
135 pa_handle
= dlopen("libpulse.0.dylib", RTLD_NOW
);
137 pa_handle
= dlopen("libpulse.so.0", RTLD_NOW
);
141 #define LOAD_FUNC(x) do { \
142 p##x = dlsym(pa_handle, #x); \
143 if((err=dlerror()) != NULL) { \
144 AL_PRINT("Could not load %s from libpulse: %s\n", #x, err); \
145 dlclose(pa_handle); \
153 pa_handle
= (void*)0xDEADBEEF;
154 #define LOAD_FUNC(x) p##x = (x)
160 LOAD_FUNC(pa_context_unref
);
161 LOAD_FUNC(pa_sample_spec_valid
);
162 LOAD_FUNC(pa_stream_drop
);
163 LOAD_FUNC(pa_strerror
);
164 LOAD_FUNC(pa_context_get_state
);
165 LOAD_FUNC(pa_stream_get_state
);
166 LOAD_FUNC(pa_threaded_mainloop_signal
);
167 LOAD_FUNC(pa_stream_peek
);
168 LOAD_FUNC(pa_threaded_mainloop_wait
);
169 LOAD_FUNC(pa_threaded_mainloop_unlock
);
170 LOAD_FUNC(pa_context_new
);
171 LOAD_FUNC(pa_threaded_mainloop_stop
);
172 LOAD_FUNC(pa_context_disconnect
);
173 LOAD_FUNC(pa_threaded_mainloop_start
);
174 LOAD_FUNC(pa_threaded_mainloop_get_api
);
175 LOAD_FUNC(pa_context_set_state_callback
);
176 LOAD_FUNC(pa_stream_write
);
178 LOAD_FUNC(pa_stream_connect_record
);
179 LOAD_FUNC(pa_stream_connect_playback
);
180 LOAD_FUNC(pa_path_get_filename
);
181 LOAD_FUNC(pa_get_binary_name
);
182 LOAD_FUNC(pa_threaded_mainloop_free
);
183 LOAD_FUNC(pa_context_errno
);
184 LOAD_FUNC(pa_xmalloc0
);
185 LOAD_FUNC(pa_stream_unref
);
186 LOAD_FUNC(pa_threaded_mainloop_accept
);
187 LOAD_FUNC(pa_stream_set_write_callback
);
188 LOAD_FUNC(pa_threaded_mainloop_new
);
189 LOAD_FUNC(pa_context_connect
);
190 LOAD_FUNC(pa_stream_get_buffer_attr
);
191 LOAD_FUNC(pa_stream_set_read_callback
);
192 LOAD_FUNC(pa_stream_set_state_callback
);
193 LOAD_FUNC(pa_stream_new
);
194 LOAD_FUNC(pa_stream_disconnect
);
195 LOAD_FUNC(pa_threaded_mainloop_lock
);
202 void pulse_unload(void) //{{{
204 if(load_count
== 0 || --load_count
> 0)
208 FreeLibrary(pa_handle
);
209 #elif defined (HAVE_DLFCN_H)
216 // PulseAudio I/O Callbacks //{{{
217 static void stream_write_callback(pa_stream
*stream
, size_t len
, void *pdata
) //{{{
219 ALCdevice
*Device
= pdata
;
220 pulse_data
*data
= Device
->ExtraData
;
221 void *buf
= ppa_xmalloc0(data
->attr
.minreq
);
224 aluMixData(Device
, buf
, data
->attr
.minreq
/data
->frame_size
);
225 ppa_stream_write(stream
, buf
, data
->attr
.minreq
, ppa_xfree
, 0,
229 static void stream_read_callback(pa_stream
*stream
, size_t length
, void *pdata
) //{{{
231 ALCdevice
*Device
= pdata
;
232 pulse_data
*data
= Device
->ExtraData
;
235 if(ppa_stream_peek(stream
, &buf
, &length
) < 0)
237 AL_PRINT("pa_stream_peek() failed: %s\n",
238 ppa_strerror(ppa_context_errno(data
->context
)));
245 length
/= data
->frame_size
;
247 if(data
->samples
< length
)
248 AL_PRINT("stream_read_callback: buffer overflow!\n");
250 WriteRingBuffer(data
->ring
, buf
, (length
<data
->samples
) ? length
: data
->samples
);
252 ppa_stream_drop(stream
);
256 static ALCboolean
pulse_open(ALCdevice
*device
, const ALCchar
*device_name
) //{{{
258 pulse_data
*data
= ppa_xmalloc0(sizeof(pulse_data
));
259 pa_context_state_t state
;
261 if(ppa_get_binary_name(data
->path_name
, sizeof(data
->path_name
)))
262 data
->context_name
= ppa_path_get_filename(data
->path_name
);
264 data
->context_name
= "OpenAL Soft";
266 if(!(data
->loop
= ppa_threaded_mainloop_new()))
268 AL_PRINT("pa_threaded_mainloop_new() failed!\n");
272 if(ppa_threaded_mainloop_start(data
->loop
) < 0)
274 AL_PRINT("pa_threaded_mainloop_start() failed\n");
278 ppa_threaded_mainloop_lock(data
->loop
);
280 data
->context
= ppa_context_new(ppa_threaded_mainloop_get_api(data
->loop
), data
->context_name
);
283 AL_PRINT("pa_context_new() failed: %s\n",
284 ppa_strerror(ppa_context_errno(data
->context
)));
286 ppa_threaded_mainloop_unlock(data
->loop
);
290 if(ppa_context_connect(data
->context
, NULL
, PA_CONTEXT_NOAUTOSPAWN
, NULL
) < 0)
292 AL_PRINT("Context did not connect: %s\n",
293 ppa_strerror(ppa_context_errno(data
->context
)));
295 ppa_context_unref(data
->context
);
296 data
->context
= NULL
;
298 ppa_threaded_mainloop_unlock(data
->loop
);
302 while((state
=ppa_context_get_state(data
->context
)) != PA_CONTEXT_READY
)
304 if(!PA_CONTEXT_IS_GOOD(state
))
306 AL_PRINT("Context did not get ready: %s\n",
307 ppa_strerror(ppa_context_errno(data
->context
)));
309 ppa_context_unref(data
->context
);
310 data
->context
= NULL
;
312 ppa_threaded_mainloop_unlock(data
->loop
);
316 ppa_threaded_mainloop_unlock(data
->loop
);
318 ppa_threaded_mainloop_lock(data
->loop
);
321 device
->szDeviceName
= strdup(device_name
);
322 device
->ExtraData
= data
;
324 ppa_threaded_mainloop_unlock(data
->loop
);
330 ppa_threaded_mainloop_stop(data
->loop
);
331 ppa_threaded_mainloop_free(data
->loop
);
338 static void pulse_close(ALCdevice
*device
) //{{{
340 pulse_data
*data
= device
->ExtraData
;
342 ppa_threaded_mainloop_lock(data
->loop
);
346 ppa_stream_disconnect(data
->stream
);
347 ppa_stream_unref(data
->stream
);
350 ppa_context_disconnect(data
->context
);
351 ppa_context_unref(data
->context
);
353 ppa_threaded_mainloop_unlock(data
->loop
);
355 ppa_threaded_mainloop_stop(data
->loop
);
356 ppa_threaded_mainloop_free(data
->loop
);
358 device
->ExtraData
= NULL
;
359 free(device
->szDeviceName
);
360 device
->szDeviceName
= NULL
;
361 DestroyRingBuffer(data
->ring
);
368 static ALCboolean
pulse_open_playback(ALCdevice
*device
, const ALCchar
*device_name
) //{{{
371 device_name
= pulse_device
;
372 else if(strcmp(device_name
, pulse_device
) != 0)
379 if(pulse_open(device
, device_name
) != ALC_FALSE
)
386 static void pulse_close_playback(ALCdevice
*device
) //{{{
392 static ALCboolean
pulse_reset_playback(ALCdevice
*device
) //{{{
394 pulse_data
*data
= device
->ExtraData
;
395 pa_stream_state_t state
;
397 ppa_threaded_mainloop_lock(data
->loop
);
399 data
->frame_size
= aluBytesFromFormat(device
->Format
) *
400 aluChannelsFromFormat(device
->Format
);
401 data
->attr
.minreq
= data
->frame_size
* device
->UpdateSize
;
402 data
->attr
.prebuf
= -1;
403 data
->attr
.maxlength
= -1;
404 data
->attr
.fragsize
= -1;
405 data
->attr
.tlength
= data
->attr
.minreq
* device
->NumUpdates
;
406 data
->stream_name
= "Playback Stream";
408 switch(aluBytesFromFormat(device
->Format
))
411 data
->spec
.format
= PA_SAMPLE_U8
;
414 data
->spec
.format
= PA_SAMPLE_S16NE
;
417 data
->spec
.format
= PA_SAMPLE_FLOAT32NE
;
420 AL_PRINT("Unknown format: 0x%x\n", device
->Format
);
421 ppa_threaded_mainloop_unlock(data
->loop
);
424 data
->spec
.rate
= device
->Frequency
;
425 data
->spec
.channels
= aluChannelsFromFormat(device
->Format
);
427 if(ppa_sample_spec_valid(&data
->spec
) == 0)
429 AL_PRINT("Invalid sample format\n");
430 ppa_threaded_mainloop_unlock(data
->loop
);
434 data
->stream
= ppa_stream_new(data
->context
, data
->stream_name
, &data
->spec
, NULL
);
437 AL_PRINT("pa_stream_new() failed: %s\n",
438 ppa_strerror(ppa_context_errno(data
->context
)));
440 ppa_threaded_mainloop_unlock(data
->loop
);
444 if(ppa_stream_connect_playback(data
->stream
, NULL
, &data
->attr
, PA_STREAM_ADJUST_LATENCY
, NULL
, NULL
) < 0)
446 AL_PRINT("Stream did not connect: %s\n",
447 ppa_strerror(ppa_context_errno(data
->context
)));
449 ppa_stream_unref(data
->stream
);
452 ppa_threaded_mainloop_unlock(data
->loop
);
456 while((state
=ppa_stream_get_state(data
->stream
)) != PA_STREAM_READY
)
458 if(!PA_STREAM_IS_GOOD(state
))
460 AL_PRINT("Stream did not get ready: %s\n",
461 ppa_strerror(ppa_context_errno(data
->context
)));
463 ppa_stream_unref(data
->stream
);
466 ppa_threaded_mainloop_unlock(data
->loop
);
470 ppa_threaded_mainloop_unlock(data
->loop
);
472 ppa_threaded_mainloop_lock(data
->loop
);
475 data
->attr
= *(ppa_stream_get_buffer_attr(data
->stream
));
476 if((data
->attr
.tlength
%data
->attr
.minreq
) != 0)
477 AL_PRINT("tlength (%d) is not a multiple of minreq (%d)!\n",
478 data
->attr
.tlength
, data
->attr
.minreq
);
479 device
->UpdateSize
= data
->attr
.minreq
;
480 device
->NumUpdates
= data
->attr
.tlength
/data
->attr
.minreq
;
482 ppa_stream_set_write_callback(data
->stream
, stream_write_callback
, device
);
484 ppa_threaded_mainloop_unlock(data
->loop
);
488 static void pulse_stop_playback(ALCdevice
*device
) //{{{
490 pulse_data
*data
= device
->ExtraData
;
495 ppa_threaded_mainloop_lock(data
->loop
);
497 ppa_stream_disconnect(data
->stream
);
498 ppa_stream_unref(data
->stream
);
501 ppa_threaded_mainloop_unlock(data
->loop
);
505 static ALCboolean
pulse_open_capture(ALCdevice
*device
, const ALCchar
*device_name
) //{{{
508 pa_stream_state_t state
;
511 device_name
= pulse_capture_device
;
512 else if(strcmp(device_name
, pulse_capture_device
) != 0)
519 if(pulse_open(device
, device_name
) == ALC_FALSE
)
525 data
= device
->ExtraData
;
526 ppa_threaded_mainloop_lock(data
->loop
);
528 data
->samples
= device
->UpdateSize
* device
->NumUpdates
;
529 data
->frame_size
= aluBytesFromFormat(device
->Format
) *
530 aluChannelsFromFormat(device
->Format
);
532 if(!(data
->ring
= CreateRingBuffer(data
->frame_size
, data
->samples
)))
534 ppa_threaded_mainloop_unlock(data
->loop
);
540 data
->attr
.minreq
= -1;
541 data
->attr
.prebuf
= -1;
542 data
->attr
.maxlength
= -1;
543 data
->attr
.tlength
= -1;
544 data
->attr
.fragsize
= data
->frame_size
* data
->samples
/ 2;
545 data
->stream_name
= "Capture Stream";
547 data
->spec
.rate
= device
->Frequency
;
548 data
->spec
.channels
= aluChannelsFromFormat(device
->Format
);
550 switch(aluBytesFromFormat(device
->Format
))
553 data
->spec
.format
= PA_SAMPLE_U8
;
556 data
->spec
.format
= PA_SAMPLE_S16NE
;
559 data
->spec
.format
= PA_SAMPLE_FLOAT32NE
;
562 AL_PRINT("Unknown format: 0x%x\n", device
->Format
);
563 ppa_threaded_mainloop_unlock(data
->loop
);
569 if(ppa_sample_spec_valid(&data
->spec
) == 0)
571 AL_PRINT("Invalid sample format\n");
572 ppa_threaded_mainloop_unlock(data
->loop
);
578 data
->stream
= ppa_stream_new(data
->context
, data
->stream_name
, &data
->spec
, NULL
);
581 AL_PRINT("pa_stream_new() failed: %s\n",
582 ppa_strerror(ppa_context_errno(data
->context
)));
584 ppa_threaded_mainloop_unlock(data
->loop
);
590 if(ppa_stream_connect_record(data
->stream
, NULL
, &data
->attr
, PA_STREAM_ADJUST_LATENCY
) < 0)
592 AL_PRINT("Stream did not connect: %s\n",
593 ppa_strerror(ppa_context_errno(data
->context
)));
595 ppa_stream_unref(data
->stream
);
596 ppa_threaded_mainloop_unlock(data
->loop
);
604 while((state
=ppa_stream_get_state(data
->stream
)) != PA_STREAM_READY
)
606 if(!PA_STREAM_IS_GOOD(state
))
608 AL_PRINT("Stream did not get ready: %s\n",
609 ppa_strerror(ppa_context_errno(data
->context
)));
611 ppa_stream_unref(data
->stream
);
612 ppa_threaded_mainloop_unlock(data
->loop
);
620 ppa_threaded_mainloop_unlock(data
->loop
);
622 ppa_threaded_mainloop_lock(data
->loop
);
625 ppa_threaded_mainloop_unlock(data
->loop
);
629 static void pulse_close_capture(ALCdevice
*device
) //{{{
635 static void pulse_start_capture(ALCdevice
*device
) //{{{
637 pulse_data
*data
= device
->ExtraData
;
639 ppa_threaded_mainloop_lock(data
->loop
);
640 ppa_stream_set_read_callback(data
->stream
, stream_read_callback
, device
);
641 ppa_threaded_mainloop_unlock(data
->loop
);
644 static void pulse_stop_capture(ALCdevice
*device
) //{{{
646 pulse_data
*data
= device
->ExtraData
;
648 ppa_threaded_mainloop_lock(data
->loop
);
649 ppa_stream_set_read_callback(data
->stream
, NULL
, NULL
);
650 ppa_threaded_mainloop_unlock(data
->loop
);
653 static void pulse_capture_samples(ALCdevice
*device
, ALCvoid
*buffer
, ALCuint samples
) //{{{
655 pulse_data
*data
= device
->ExtraData
;
656 ALCuint available
= RingBufferSize(data
->ring
);
658 if(available
< samples
)
659 alcSetError(ALC_INVALID_VALUE
);
661 ReadRingBuffer(data
->ring
, buffer
, samples
);
664 static ALCuint
pulse_available_samples(ALCdevice
*device
) //{{{
666 pulse_data
*data
= device
->ExtraData
;
667 return RingBufferSize(data
->ring
);
670 BackendFuncs pulse_funcs
= { //{{{
672 pulse_close_playback
,
673 pulse_reset_playback
,
679 pulse_capture_samples
,
680 pulse_available_samples
683 void alc_pulse_init(BackendFuncs
*func_list
) //{{{
685 *func_list
= pulse_funcs
;
688 void alc_pulse_deinit(void) //{{{
692 void alc_pulse_probe(int type
) //{{{
695 if(!pa_handle
) return;
697 if(type
== DEVICE_PROBE
)
698 AppendDeviceList(pulse_device
);
699 else if(type
== ALL_DEVICE_PROBE
)
700 AppendAllDeviceList(pulse_device
);
701 else if(type
== CAPTURE_DEVICE_PROBE
)
702 AppendCaptureDeviceList(pulse_capture_device
);