2 * OpenAL cross platform audio library
3 * Copyright (C) 2009 by Konstantinos Natsakis <konstantinos.natsakis@gmail.com>
4 * Copyright (C) 2010 by Chris Robinson <chris.kcat@gmail.com>
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Library General Public
7 * License as published by the Free Software Foundation; either
8 * version 2 of the License, or (at your option) any later version.
10 * This library 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 GNU
13 * Library General Public License for more details.
15 * You should have received a copy of the GNU Library General Public
16 * License along with this library; if not, write to the
17 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
18 * Boston, MA 02111-1307, USA.
19 * Or go to http://www.gnu.org/copyleft/lgpl.html
29 #include <pulse/pulseaudio.h>
31 #if PA_API_VERSION == 11
32 #define PA_STREAM_ADJUST_LATENCY 0x2000U
33 static __inline
int PA_STREAM_IS_GOOD(pa_stream_state_t x
)
35 return (x
== PA_STREAM_CREATING
|| x
== PA_STREAM_READY
);
37 static __inline
int PA_CONTEXT_IS_GOOD(pa_context_state_t x
)
39 return (x
== PA_CONTEXT_CONNECTING
|| x
== PA_CONTEXT_AUTHORIZING
||
40 x
== PA_CONTEXT_SETTING_NAME
|| x
== PA_CONTEXT_READY
);
42 #define PA_STREAM_IS_GOOD PA_STREAM_IS_GOOD
43 #define PA_CONTEXT_IS_GOOD PA_CONTEXT_IS_GOOD
44 #elif PA_API_VERSION != 12
45 #error Invalid PulseAudio API version
48 #ifndef PA_CHECK_VERSION
49 #define PA_CHECK_VERSION(major,minor,micro) \
50 ((PA_MAJOR > (major)) || \
51 (PA_MAJOR == (major) && PA_MINOR > (minor)) || \
52 (PA_MAJOR == (major) && PA_MINOR == (minor) && PA_MICRO >= (micro)))
55 static void *pa_handle
;
56 #define MAKE_FUNC(x) static typeof(x) * p##x
57 MAKE_FUNC(pa_context_unref
);
58 MAKE_FUNC(pa_sample_spec_valid
);
59 MAKE_FUNC(pa_stream_drop
);
60 MAKE_FUNC(pa_strerror
);
61 MAKE_FUNC(pa_context_get_state
);
62 MAKE_FUNC(pa_stream_get_state
);
63 MAKE_FUNC(pa_threaded_mainloop_signal
);
64 MAKE_FUNC(pa_stream_peek
);
65 MAKE_FUNC(pa_threaded_mainloop_wait
);
66 MAKE_FUNC(pa_threaded_mainloop_unlock
);
67 MAKE_FUNC(pa_threaded_mainloop_in_thread
);
68 MAKE_FUNC(pa_context_new
);
69 MAKE_FUNC(pa_threaded_mainloop_stop
);
70 MAKE_FUNC(pa_context_disconnect
);
71 MAKE_FUNC(pa_threaded_mainloop_start
);
72 MAKE_FUNC(pa_threaded_mainloop_get_api
);
73 MAKE_FUNC(pa_context_set_state_callback
);
74 MAKE_FUNC(pa_stream_write
);
76 MAKE_FUNC(pa_stream_connect_record
);
77 MAKE_FUNC(pa_stream_connect_playback
);
78 MAKE_FUNC(pa_stream_readable_size
);
79 MAKE_FUNC(pa_stream_writable_size
);
80 MAKE_FUNC(pa_stream_cork
);
81 MAKE_FUNC(pa_stream_is_suspended
);
82 MAKE_FUNC(pa_stream_get_device_name
);
83 MAKE_FUNC(pa_path_get_filename
);
84 MAKE_FUNC(pa_get_binary_name
);
85 MAKE_FUNC(pa_threaded_mainloop_free
);
86 MAKE_FUNC(pa_context_errno
);
87 MAKE_FUNC(pa_xmalloc
);
88 MAKE_FUNC(pa_stream_unref
);
89 MAKE_FUNC(pa_threaded_mainloop_accept
);
90 MAKE_FUNC(pa_stream_set_write_callback
);
91 MAKE_FUNC(pa_threaded_mainloop_new
);
92 MAKE_FUNC(pa_context_connect
);
93 MAKE_FUNC(pa_stream_set_buffer_attr
);
94 MAKE_FUNC(pa_stream_get_buffer_attr
);
95 MAKE_FUNC(pa_stream_get_sample_spec
);
96 MAKE_FUNC(pa_stream_get_time
);
97 MAKE_FUNC(pa_stream_set_read_callback
);
98 MAKE_FUNC(pa_stream_set_state_callback
);
99 MAKE_FUNC(pa_stream_set_moved_callback
);
100 MAKE_FUNC(pa_stream_set_underflow_callback
);
101 MAKE_FUNC(pa_stream_new
);
102 MAKE_FUNC(pa_stream_disconnect
);
103 MAKE_FUNC(pa_threaded_mainloop_lock
);
104 MAKE_FUNC(pa_channel_map_init_auto
);
105 MAKE_FUNC(pa_channel_map_parse
);
106 MAKE_FUNC(pa_channel_map_snprint
);
107 MAKE_FUNC(pa_channel_map_equal
);
108 MAKE_FUNC(pa_context_get_server_info
);
109 MAKE_FUNC(pa_context_get_sink_info_by_name
);
110 MAKE_FUNC(pa_context_get_sink_info_list
);
111 MAKE_FUNC(pa_context_get_source_info_list
);
112 MAKE_FUNC(pa_operation_get_state
);
113 MAKE_FUNC(pa_operation_unref
);
114 #if PA_CHECK_VERSION(0,9,15)
115 MAKE_FUNC(pa_channel_map_superset
);
116 MAKE_FUNC(pa_stream_set_buffer_attr_callback
);
118 #if PA_CHECK_VERSION(0,9,16)
119 MAKE_FUNC(pa_stream_begin_write
);
124 #define PATH_MAX 4096
138 pa_threaded_mainloop
*loop
;
144 volatile ALboolean killNow
;
156 static const ALCchar pulse_device
[] = "PulseAudio Default";
157 static DevMap
*allDevNameMap
;
158 static ALuint numDevNames
;
159 static DevMap
*allCaptureDevNameMap
;
160 static ALuint numCaptureDevNames
;
161 static pa_context_flags_t pulse_ctx_flags
;
164 void *pulse_load(void) //{{{
169 pa_handle
= LoadLibrary("libpulse-0.dll");
170 #define LOAD_FUNC(x) do { \
171 p##x = (typeof(p##x))GetProcAddress(pa_handle, #x); \
173 AL_PRINT("Could not load %s from libpulse-0.dll\n", #x); \
174 FreeLibrary(pa_handle); \
179 #define LOAD_OPTIONAL_FUNC(x) do { \
180 p##x = (typeof(p##x))GetProcAddress(pa_handle, #x); \
183 #elif defined (HAVE_DLFCN_H)
186 #if defined(__APPLE__) && defined(__MACH__)
187 pa_handle
= dlopen("libpulse.0.dylib", RTLD_NOW
);
189 pa_handle
= dlopen("libpulse.so.0", RTLD_NOW
);
193 #define LOAD_FUNC(x) do { \
194 p##x = dlsym(pa_handle, #x); \
195 if((err=dlerror()) != NULL) { \
196 AL_PRINT("Could not load %s from libpulse: %s\n", #x, err); \
197 dlclose(pa_handle); \
202 #define LOAD_OPTIONAL_FUNC(x) do { \
203 p##x = dlsym(pa_handle, #x); \
204 if((err=dlerror()) != NULL) { \
211 pa_handle
= (void*)0xDEADBEEF;
212 #define LOAD_FUNC(x) p##x = (x)
213 #define LOAD_OPTIONAL_FUNC(x) p##x = (x)
219 LOAD_FUNC(pa_context_unref
);
220 LOAD_FUNC(pa_sample_spec_valid
);
221 LOAD_FUNC(pa_stream_drop
);
222 LOAD_FUNC(pa_strerror
);
223 LOAD_FUNC(pa_context_get_state
);
224 LOAD_FUNC(pa_stream_get_state
);
225 LOAD_FUNC(pa_threaded_mainloop_signal
);
226 LOAD_FUNC(pa_stream_peek
);
227 LOAD_FUNC(pa_threaded_mainloop_wait
);
228 LOAD_FUNC(pa_threaded_mainloop_unlock
);
229 LOAD_FUNC(pa_threaded_mainloop_in_thread
);
230 LOAD_FUNC(pa_context_new
);
231 LOAD_FUNC(pa_threaded_mainloop_stop
);
232 LOAD_FUNC(pa_context_disconnect
);
233 LOAD_FUNC(pa_threaded_mainloop_start
);
234 LOAD_FUNC(pa_threaded_mainloop_get_api
);
235 LOAD_FUNC(pa_context_set_state_callback
);
236 LOAD_FUNC(pa_stream_write
);
238 LOAD_FUNC(pa_stream_connect_record
);
239 LOAD_FUNC(pa_stream_connect_playback
);
240 LOAD_FUNC(pa_stream_readable_size
);
241 LOAD_FUNC(pa_stream_writable_size
);
242 LOAD_FUNC(pa_stream_cork
);
243 LOAD_FUNC(pa_stream_is_suspended
);
244 LOAD_FUNC(pa_stream_get_device_name
);
245 LOAD_FUNC(pa_path_get_filename
);
246 LOAD_FUNC(pa_get_binary_name
);
247 LOAD_FUNC(pa_threaded_mainloop_free
);
248 LOAD_FUNC(pa_context_errno
);
249 LOAD_FUNC(pa_xmalloc
);
250 LOAD_FUNC(pa_stream_unref
);
251 LOAD_FUNC(pa_threaded_mainloop_accept
);
252 LOAD_FUNC(pa_stream_set_write_callback
);
253 LOAD_FUNC(pa_threaded_mainloop_new
);
254 LOAD_FUNC(pa_context_connect
);
255 LOAD_FUNC(pa_stream_set_buffer_attr
);
256 LOAD_FUNC(pa_stream_get_buffer_attr
);
257 LOAD_FUNC(pa_stream_get_sample_spec
);
258 LOAD_FUNC(pa_stream_get_time
);
259 LOAD_FUNC(pa_stream_set_read_callback
);
260 LOAD_FUNC(pa_stream_set_state_callback
);
261 LOAD_FUNC(pa_stream_set_moved_callback
);
262 LOAD_FUNC(pa_stream_set_underflow_callback
);
263 LOAD_FUNC(pa_stream_new
);
264 LOAD_FUNC(pa_stream_disconnect
);
265 LOAD_FUNC(pa_threaded_mainloop_lock
);
266 LOAD_FUNC(pa_channel_map_init_auto
);
267 LOAD_FUNC(pa_channel_map_parse
);
268 LOAD_FUNC(pa_channel_map_snprint
);
269 LOAD_FUNC(pa_channel_map_equal
);
270 LOAD_FUNC(pa_context_get_server_info
);
271 LOAD_FUNC(pa_context_get_sink_info_by_name
);
272 LOAD_FUNC(pa_context_get_sink_info_list
);
273 LOAD_FUNC(pa_context_get_source_info_list
);
274 LOAD_FUNC(pa_operation_get_state
);
275 LOAD_FUNC(pa_operation_unref
);
276 #if PA_CHECK_VERSION(0,9,15)
277 LOAD_OPTIONAL_FUNC(pa_channel_map_superset
);
278 LOAD_OPTIONAL_FUNC(pa_stream_set_buffer_attr_callback
);
280 #if PA_CHECK_VERSION(0,9,16)
281 LOAD_OPTIONAL_FUNC(pa_stream_begin_write
);
284 #undef LOAD_OPTIONAL_FUNC
290 // PulseAudio Event Callbacks //{{{
291 static void context_state_callback(pa_context
*context
, void *pdata
) //{{{
293 pa_threaded_mainloop
*loop
= pdata
;
294 pa_context_state_t state
;
296 state
= ppa_context_get_state(context
);
297 if(state
== PA_CONTEXT_READY
|| !PA_CONTEXT_IS_GOOD(state
))
298 ppa_threaded_mainloop_signal(loop
, 0);
301 static void stream_state_callback(pa_stream
*stream
, void *pdata
) //{{{
303 pa_threaded_mainloop
*loop
= pdata
;
304 pa_stream_state_t state
;
306 state
= ppa_stream_get_state(stream
);
307 if(state
== PA_STREAM_READY
|| !PA_STREAM_IS_GOOD(state
))
308 ppa_threaded_mainloop_signal(loop
, 0);
311 static void stream_signal_callback(pa_stream
*stream
, void *pdata
) //{{{
313 ALCdevice
*Device
= pdata
;
314 pulse_data
*data
= Device
->ExtraData
;
317 ppa_threaded_mainloop_signal(data
->loop
, 0);
320 static void stream_buffer_attr_callback(pa_stream
*stream
, void *pdata
) //{{{
322 ALCdevice
*Device
= pdata
;
323 pulse_data
*data
= Device
->ExtraData
;
325 SuspendContext(NULL
);
327 data
->attr
= *(ppa_stream_get_buffer_attr(stream
));
328 Device
->UpdateSize
= data
->attr
.minreq
/ data
->frame_size
;
329 Device
->NumUpdates
= (data
->attr
.tlength
/data
->frame_size
) / Device
->UpdateSize
;
330 if(Device
->NumUpdates
<= 1)
332 Device
->NumUpdates
= 1;
333 AL_PRINT("PulseAudio returned minreq > tlength/2; expect break up\n");
336 ProcessContext(NULL
);
339 static void stream_device_callback(pa_stream
*stream
, void *pdata
) //{{{
341 ALCdevice
*Device
= pdata
;
342 pulse_data
*data
= Device
->ExtraData
;
344 free(data
->device_name
);
345 data
->device_name
= strdup(ppa_stream_get_device_name(stream
));
348 static void context_state_callback2(pa_context
*context
, void *pdata
) //{{{
350 ALCdevice
*Device
= pdata
;
351 pulse_data
*data
= Device
->ExtraData
;
353 if(ppa_context_get_state(context
) == PA_CONTEXT_FAILED
)
355 AL_PRINT("Received context failure!\n");
356 aluHandleDisconnect(Device
);
358 ppa_threaded_mainloop_signal(data
->loop
, 0);
361 static void stream_state_callback2(pa_stream
*stream
, void *pdata
) //{{{
363 ALCdevice
*Device
= pdata
;
364 pulse_data
*data
= Device
->ExtraData
;
366 if(ppa_stream_get_state(stream
) == PA_STREAM_FAILED
)
368 AL_PRINT("Received stream failure!\n");
369 aluHandleDisconnect(Device
);
371 ppa_threaded_mainloop_signal(data
->loop
, 0);
374 static void stream_success_callback(pa_stream
*stream
, int success
, void *pdata
) //{{{
376 ALCdevice
*Device
= pdata
;
377 pulse_data
*data
= Device
->ExtraData
;
381 ppa_threaded_mainloop_signal(data
->loop
, 0);
384 static void sink_info_callback(pa_context
*context
, const pa_sink_info
*info
, int eol
, void *pdata
) //{{{
386 ALCdevice
*device
= pdata
;
387 pulse_data
*data
= device
->ExtraData
;
388 char chanmap_str
[256] = "";
393 { "front-left,front-right,front-center,lfe,rear-left,rear-right,side-left,side-right",
395 { "front-left,front-right,front-center,lfe,rear-center,side-left,side-right",
397 { "front-left,front-right,front-center,lfe,rear-left,rear-right",
399 { "front-left,front-right,rear-left,rear-right", AL_FORMAT_QUAD32
},
400 { "front-left,front-right", AL_FORMAT_STEREO_FLOAT32
},
401 { "mono", AL_FORMAT_MONO_FLOAT32
},
409 ppa_threaded_mainloop_signal(data
->loop
, 0);
413 for(i
= 0;chanmaps
[i
].str
;i
++)
416 if(!ppa_channel_map_parse(&map
, chanmaps
[i
].str
))
419 if(ppa_channel_map_equal(&info
->channel_map
, &map
)
420 #if PA_CHECK_VERSION(0,9,15)
421 || (ppa_channel_map_superset
&&
422 ppa_channel_map_superset(&info
->channel_map
, &map
))
426 device
->Format
= chanmaps
[i
].format
;
431 ppa_channel_map_snprint(chanmap_str
, sizeof(chanmap_str
), &info
->channel_map
);
432 AL_PRINT("Failed to find format for channel map:\n %s\n", chanmap_str
);
435 static void sink_device_callback(pa_context
*context
, const pa_sink_info
*info
, int eol
, void *pdata
) //{{{
437 pa_threaded_mainloop
*loop
= pdata
;
447 ppa_threaded_mainloop_signal(loop
, 0);
454 snprintf(str
, sizeof(str
), "%s via PulseAudio", info
->description
);
456 snprintf(str
, sizeof(str
), "%s #%d via PulseAudio", info
->description
, count
+1);
459 for(i
= 0;i
< numDevNames
;i
++)
461 if(strcmp(str
, allDevNameMap
[i
].name
) == 0)
464 } while(i
!= numDevNames
);
466 temp
= realloc(allDevNameMap
, (numDevNames
+1) * sizeof(*allDevNameMap
));
469 allDevNameMap
= temp
;
470 allDevNameMap
[numDevNames
].name
= strdup(str
);
471 allDevNameMap
[numDevNames
].device_name
= strdup(info
->name
);
476 static void source_device_callback(pa_context
*context
, const pa_source_info
*info
, int eol
, void *pdata
) //{{{
478 pa_threaded_mainloop
*loop
= pdata
;
488 ppa_threaded_mainloop_signal(loop
, 0);
495 snprintf(str
, sizeof(str
), "%s via PulseAudio", info
->description
);
497 snprintf(str
, sizeof(str
), "%s #%d via PulseAudio", info
->description
, count
+1);
500 for(i
= 0;i
< numCaptureDevNames
;i
++)
502 if(strcmp(str
, allCaptureDevNameMap
[i
].name
) == 0)
505 } while(i
!= numCaptureDevNames
);
507 temp
= realloc(allCaptureDevNameMap
, (numCaptureDevNames
+1) * sizeof(*allCaptureDevNameMap
));
510 allCaptureDevNameMap
= temp
;
511 allCaptureDevNameMap
[numCaptureDevNames
].name
= strdup(str
);
512 allCaptureDevNameMap
[numCaptureDevNames
].device_name
= strdup(info
->name
);
513 numCaptureDevNames
++;
518 // PulseAudio I/O Callbacks //{{{
519 static void stream_write_callback(pa_stream
*stream
, size_t len
, void *pdata
) //{{{
521 ALCdevice
*Device
= pdata
;
522 pulse_data
*data
= Device
->ExtraData
;
526 ppa_threaded_mainloop_signal(data
->loop
, 0);
530 static ALuint
PulseProc(ALvoid
*param
)
532 ALCdevice
*Device
= param
;
533 pulse_data
*data
= Device
->ExtraData
;
538 ppa_threaded_mainloop_lock(data
->loop
);
540 len
= (Device
->Connected
? ppa_stream_writable_size(data
->stream
) : 0);
541 len
-= len
%(Device
->UpdateSize
*data
->frame_size
);
544 ppa_threaded_mainloop_wait(data
->loop
);
552 pa_free_cb_t free_func
= NULL
;
554 #if PA_CHECK_VERSION(0,9,16)
555 if(!ppa_stream_begin_write
||
556 ppa_stream_begin_write(data
->stream
, &buf
, &newlen
) < 0)
559 buf
= ppa_xmalloc(newlen
);
560 free_func
= ppa_xfree
;
562 ppa_threaded_mainloop_unlock(data
->loop
);
564 aluMixData(Device
, buf
, newlen
/data
->frame_size
);
566 ppa_threaded_mainloop_lock(data
->loop
);
567 ppa_stream_write(data
->stream
, buf
, newlen
, free_func
, 0, PA_SEEK_RELATIVE
);
570 } while(Device
->Connected
&& !data
->killNow
);
571 ppa_threaded_mainloop_unlock(data
->loop
);
576 static pa_context
*connect_context(pa_threaded_mainloop
*loop
)
578 const char *name
= "OpenAL Soft";
579 char path_name
[PATH_MAX
];
580 pa_context_state_t state
;
584 if(ppa_get_binary_name(path_name
, sizeof(path_name
)))
585 name
= ppa_path_get_filename(path_name
);
587 context
= ppa_context_new(ppa_threaded_mainloop_get_api(loop
), name
);
590 AL_PRINT("pa_context_new() failed\n");
594 ppa_context_set_state_callback(context
, context_state_callback
, loop
);
596 if((err
=ppa_context_connect(context
, NULL
, pulse_ctx_flags
, NULL
)) >= 0)
598 while((state
=ppa_context_get_state(context
)) != PA_CONTEXT_READY
)
600 if(!PA_CONTEXT_IS_GOOD(state
))
602 err
= ppa_context_errno(context
);
603 if(err
> 0) err
= -err
;
607 ppa_threaded_mainloop_wait(loop
);
610 ppa_context_set_state_callback(context
, NULL
, NULL
);
614 AL_PRINT("Context did not connect: %s\n", ppa_strerror(err
));
615 ppa_context_unref(context
);
622 static pa_stream
*connect_playback_stream(ALCdevice
*device
,
623 pa_stream_flags_t flags
, pa_buffer_attr
*attr
, pa_sample_spec
*spec
,
624 pa_channel_map
*chanmap
)
626 pulse_data
*data
= device
->ExtraData
;
627 pa_stream_state_t state
;
630 stream
= ppa_stream_new(data
->context
, "Playback Stream", spec
, chanmap
);
633 AL_PRINT("pa_stream_new() failed: %s\n",
634 ppa_strerror(ppa_context_errno(data
->context
)));
638 ppa_stream_set_state_callback(stream
, stream_state_callback
, data
->loop
);
640 if(ppa_stream_connect_playback(stream
, data
->device_name
, attr
, flags
, NULL
, NULL
) < 0)
642 AL_PRINT("Stream did not connect: %s\n",
643 ppa_strerror(ppa_context_errno(data
->context
)));
644 ppa_stream_unref(stream
);
648 while((state
=ppa_stream_get_state(stream
)) != PA_STREAM_READY
)
650 if(!PA_STREAM_IS_GOOD(state
))
652 AL_PRINT("Stream did not get ready: %s\n",
653 ppa_strerror(ppa_context_errno(data
->context
)));
654 ppa_stream_unref(stream
);
658 ppa_threaded_mainloop_wait(data
->loop
);
660 ppa_stream_set_state_callback(stream
, NULL
, NULL
);
665 static void probe_devices(ALboolean capture
)
667 pa_threaded_mainloop
*loop
;
669 if(capture
== AL_FALSE
)
670 allDevNameMap
= malloc(sizeof(DevMap
) * 1);
672 allCaptureDevNameMap
= malloc(sizeof(DevMap
) * 1);
674 if((loop
=ppa_threaded_mainloop_new()) &&
675 ppa_threaded_mainloop_start(loop
) >= 0)
679 ppa_threaded_mainloop_lock(loop
);
680 context
= connect_context(loop
);
685 if(capture
== AL_FALSE
)
687 allDevNameMap
[0].name
= strdup(pulse_device
);
688 allDevNameMap
[0].device_name
= NULL
;
691 o
= ppa_context_get_sink_info_list(context
, sink_device_callback
, loop
);
695 allCaptureDevNameMap
[0].name
= strdup(pulse_device
);
696 allCaptureDevNameMap
[0].device_name
= NULL
;
697 numCaptureDevNames
= 1;
699 o
= ppa_context_get_source_info_list(context
, source_device_callback
, loop
);
701 while(ppa_operation_get_state(o
) == PA_OPERATION_RUNNING
)
702 ppa_threaded_mainloop_wait(loop
);
703 ppa_operation_unref(o
);
705 ppa_context_disconnect(context
);
706 ppa_context_unref(context
);
708 ppa_threaded_mainloop_unlock(loop
);
709 ppa_threaded_mainloop_stop(loop
);
712 ppa_threaded_mainloop_free(loop
);
716 static ALCboolean
pulse_open(ALCdevice
*device
, const ALCchar
*device_name
) //{{{
718 pulse_data
*data
= ppa_xmalloc(sizeof(pulse_data
));
719 memset(data
, 0, sizeof(*data
));
721 if(!(data
->loop
= ppa_threaded_mainloop_new()))
723 AL_PRINT("pa_threaded_mainloop_new() failed!\n");
726 if(ppa_threaded_mainloop_start(data
->loop
) < 0)
728 AL_PRINT("pa_threaded_mainloop_start() failed\n");
732 ppa_threaded_mainloop_lock(data
->loop
);
733 device
->ExtraData
= data
;
735 data
->context
= connect_context(data
->loop
);
738 ppa_threaded_mainloop_unlock(data
->loop
);
741 ppa_context_set_state_callback(data
->context
, context_state_callback2
, device
);
743 device
->szDeviceName
= strdup(device_name
);
745 ppa_threaded_mainloop_unlock(data
->loop
);
751 ppa_threaded_mainloop_stop(data
->loop
);
752 ppa_threaded_mainloop_free(data
->loop
);
755 device
->ExtraData
= NULL
;
760 static void pulse_close(ALCdevice
*device
) //{{{
762 pulse_data
*data
= device
->ExtraData
;
764 ppa_threaded_mainloop_lock(data
->loop
);
768 ppa_stream_disconnect(data
->stream
);
769 ppa_stream_unref(data
->stream
);
772 ppa_context_disconnect(data
->context
);
773 ppa_context_unref(data
->context
);
775 ppa_threaded_mainloop_unlock(data
->loop
);
777 ppa_threaded_mainloop_stop(data
->loop
);
778 ppa_threaded_mainloop_free(data
->loop
);
780 DestroyRingBuffer(data
->ring
);
781 free(data
->device_name
);
783 device
->ExtraData
= NULL
;
789 static ALCboolean
pulse_open_playback(ALCdevice
*device
, const ALCchar
*device_name
) //{{{
791 char *pulse_name
= NULL
;
799 probe_devices(AL_FALSE
);
801 if(!device_name
&& numDevNames
> 0)
802 device_name
= allDevNameMap
[0].name
;
807 for(i
= 0;i
< numDevNames
;i
++)
809 if(strcmp(device_name
, allDevNameMap
[i
].name
) == 0)
811 pulse_name
= allDevNameMap
[i
].device_name
;
819 if(pulse_open(device
, device_name
) == ALC_FALSE
)
822 data
= device
->ExtraData
;
824 ppa_threaded_mainloop_lock(data
->loop
);
826 spec
.format
= PA_SAMPLE_S16NE
;
830 data
->device_name
= pulse_name
;
831 pa_stream
*stream
= connect_playback_stream(device
, 0, NULL
, &spec
, NULL
);
834 ppa_threaded_mainloop_unlock(data
->loop
);
838 if(ppa_stream_is_suspended(stream
))
840 AL_PRINT("Device is suspended\n");
841 ppa_stream_disconnect(stream
);
842 ppa_stream_unref(stream
);
843 ppa_threaded_mainloop_unlock(data
->loop
);
846 data
->device_name
= strdup(ppa_stream_get_device_name(stream
));
848 ppa_stream_disconnect(stream
);
849 ppa_stream_unref(stream
);
851 ppa_threaded_mainloop_unlock(data
->loop
);
860 static void pulse_close_playback(ALCdevice
*device
) //{{{
865 static ALCboolean
pulse_reset_playback(ALCdevice
*device
) //{{{
867 pulse_data
*data
= device
->ExtraData
;
868 pa_stream_flags_t flags
= 0;
869 pa_channel_map chanmap
;
871 ppa_threaded_mainloop_lock(data
->loop
);
873 if(!ConfigValueExists(NULL
, "format"))
876 o
= ppa_context_get_sink_info_by_name(data
->context
, data
->device_name
, sink_info_callback
, device
);
877 while(ppa_operation_get_state(o
) == PA_OPERATION_RUNNING
)
878 ppa_threaded_mainloop_wait(data
->loop
);
879 ppa_operation_unref(o
);
881 if(!ConfigValueExists(NULL
, "frequency"))
882 flags
|= PA_STREAM_FIX_RATE
;
884 data
->frame_size
= aluFrameSizeFromFormat(device
->Format
);
885 data
->attr
.prebuf
= -1;
886 data
->attr
.fragsize
= -1;
887 data
->attr
.minreq
= device
->UpdateSize
* data
->frame_size
;
888 data
->attr
.tlength
= data
->attr
.minreq
* device
->NumUpdates
;
889 if(data
->attr
.tlength
< data
->attr
.minreq
*2)
890 data
->attr
.tlength
= data
->attr
.minreq
*2;
891 data
->attr
.maxlength
= data
->attr
.tlength
;
892 flags
|= PA_STREAM_EARLY_REQUESTS
;
893 flags
|= PA_STREAM_INTERPOLATE_TIMING
| PA_STREAM_AUTO_TIMING_UPDATE
;
895 switch(aluBytesFromFormat(device
->Format
))
898 data
->spec
.format
= PA_SAMPLE_U8
;
901 data
->spec
.format
= PA_SAMPLE_S16NE
;
904 data
->spec
.format
= PA_SAMPLE_FLOAT32NE
;
907 AL_PRINT("Unknown format: 0x%x\n", device
->Format
);
908 ppa_threaded_mainloop_unlock(data
->loop
);
911 data
->spec
.rate
= device
->Frequency
;
912 data
->spec
.channels
= aluChannelsFromFormat(device
->Format
);
914 if(ppa_sample_spec_valid(&data
->spec
) == 0)
916 AL_PRINT("Invalid sample format\n");
917 ppa_threaded_mainloop_unlock(data
->loop
);
921 if(!ppa_channel_map_init_auto(&chanmap
, data
->spec
.channels
, PA_CHANNEL_MAP_WAVEEX
))
923 AL_PRINT("Couldn't build map for channel count (%d)!\n", data
->spec
.channels
);
924 ppa_threaded_mainloop_unlock(data
->loop
);
927 SetDefaultWFXChannelOrder(device
);
929 data
->stream
= connect_playback_stream(device
, flags
, &data
->attr
, &data
->spec
, &chanmap
);
932 ppa_threaded_mainloop_unlock(data
->loop
);
936 ppa_stream_set_state_callback(data
->stream
, stream_state_callback2
, device
);
938 data
->spec
= *(ppa_stream_get_sample_spec(data
->stream
));
939 if(device
->Frequency
!= data
->spec
.rate
)
943 /* Server updated our playback rate, so modify the buffer attribs
945 data
->attr
.minreq
= (ALuint64
)(data
->attr
.minreq
/data
->frame_size
) *
946 data
->spec
.rate
/ device
->Frequency
* data
->frame_size
;
947 data
->attr
.tlength
= data
->attr
.minreq
* device
->NumUpdates
;
948 data
->attr
.maxlength
= data
->attr
.tlength
;
950 o
= ppa_stream_set_buffer_attr(data
->stream
, &data
->attr
,
951 stream_success_callback
, device
);
952 while(ppa_operation_get_state(o
) == PA_OPERATION_RUNNING
)
953 ppa_threaded_mainloop_wait(data
->loop
);
954 ppa_operation_unref(o
);
956 device
->Frequency
= data
->spec
.rate
;
959 stream_buffer_attr_callback(data
->stream
, device
);
960 #if PA_CHECK_VERSION(0,9,15)
961 if(ppa_stream_set_buffer_attr_callback
)
962 ppa_stream_set_buffer_attr_callback(data
->stream
, stream_buffer_attr_callback
, device
);
964 ppa_stream_set_moved_callback(data
->stream
, stream_device_callback
, device
);
965 ppa_stream_set_write_callback(data
->stream
, stream_write_callback
, device
);
966 ppa_stream_set_underflow_callback(data
->stream
, stream_signal_callback
, device
);
968 device
->TimeRes
= 1000;
970 data
->thread
= StartThread(PulseProc
, device
);
973 #if PA_CHECK_VERSION(0,9,15)
974 if(ppa_stream_set_buffer_attr_callback
)
975 ppa_stream_set_buffer_attr_callback(data
->stream
, NULL
, NULL
);
977 ppa_stream_set_moved_callback(data
->stream
, NULL
, NULL
);
978 ppa_stream_set_write_callback(data
->stream
, NULL
, NULL
);
979 ppa_stream_set_underflow_callback(data
->stream
, NULL
, NULL
);
980 ppa_stream_disconnect(data
->stream
);
981 ppa_stream_unref(data
->stream
);
984 ppa_threaded_mainloop_unlock(data
->loop
);
988 ppa_threaded_mainloop_unlock(data
->loop
);
992 static void pulse_stop_playback(ALCdevice
*device
) //{{{
994 pulse_data
*data
= device
->ExtraData
;
1000 data
->killNow
= AL_TRUE
;
1003 ppa_threaded_mainloop_signal(data
->loop
, 0);
1004 StopThread(data
->thread
);
1005 data
->thread
= NULL
;
1007 data
->killNow
= AL_FALSE
;
1009 ppa_threaded_mainloop_lock(data
->loop
);
1011 if(ppa_stream_get_time(data
->stream
, &usec
) != PA_OK
)
1012 usec
= data
->lastTime
;
1013 data
->baseTime
+= usec
*1000;
1016 #if PA_CHECK_VERSION(0,9,15)
1017 if(ppa_stream_set_buffer_attr_callback
)
1018 ppa_stream_set_buffer_attr_callback(data
->stream
, NULL
, NULL
);
1020 ppa_stream_set_moved_callback(data
->stream
, NULL
, NULL
);
1021 ppa_stream_set_write_callback(data
->stream
, NULL
, NULL
);
1022 ppa_stream_set_underflow_callback(data
->stream
, NULL
, NULL
);
1023 ppa_stream_disconnect(data
->stream
);
1024 ppa_stream_unref(data
->stream
);
1025 data
->stream
= NULL
;
1027 ppa_threaded_mainloop_unlock(data
->loop
);
1031 static ALCboolean
pulse_open_capture(ALCdevice
*device
, const ALCchar
*device_name
) //{{{
1033 char *pulse_name
= NULL
;
1035 pa_stream_flags_t flags
= 0;
1036 pa_stream_state_t state
;
1037 pa_channel_map chanmap
;
1042 if(!allCaptureDevNameMap
)
1043 probe_devices(AL_TRUE
);
1045 if(!device_name
&& numCaptureDevNames
> 0)
1046 device_name
= allCaptureDevNameMap
[0].name
;
1051 for(i
= 0;i
< numCaptureDevNames
;i
++)
1053 if(strcmp(device_name
, allCaptureDevNameMap
[i
].name
) == 0)
1055 pulse_name
= allCaptureDevNameMap
[i
].device_name
;
1059 if(i
== numCaptureDevNames
)
1063 if(pulse_open(device
, device_name
) == ALC_FALSE
)
1066 data
= device
->ExtraData
;
1067 ppa_threaded_mainloop_lock(data
->loop
);
1069 data
->samples
= device
->UpdateSize
* device
->NumUpdates
;
1070 data
->frame_size
= aluFrameSizeFromFormat(device
->Format
);
1071 if(data
->samples
< 100 * device
->Frequency
/ 1000)
1072 data
->samples
= 100 * device
->Frequency
/ 1000;
1074 if(!(data
->ring
= CreateRingBuffer(data
->frame_size
, data
->samples
)))
1076 ppa_threaded_mainloop_unlock(data
->loop
);
1080 data
->attr
.minreq
= -1;
1081 data
->attr
.prebuf
= -1;
1082 data
->attr
.maxlength
= data
->samples
* data
->frame_size
;
1083 data
->attr
.tlength
= -1;
1084 data
->attr
.fragsize
= min(data
->samples
, 50 * device
->Frequency
/ 1000) *
1087 data
->spec
.rate
= device
->Frequency
;
1088 data
->spec
.channels
= aluChannelsFromFormat(device
->Format
);
1090 switch(aluBytesFromFormat(device
->Format
))
1093 data
->spec
.format
= PA_SAMPLE_U8
;
1096 data
->spec
.format
= PA_SAMPLE_S16NE
;
1099 data
->spec
.format
= PA_SAMPLE_FLOAT32NE
;
1102 AL_PRINT("Unknown format: 0x%x\n", device
->Format
);
1103 ppa_threaded_mainloop_unlock(data
->loop
);
1107 if(ppa_sample_spec_valid(&data
->spec
) == 0)
1109 AL_PRINT("Invalid sample format\n");
1110 ppa_threaded_mainloop_unlock(data
->loop
);
1114 if(!ppa_channel_map_init_auto(&chanmap
, data
->spec
.channels
, PA_CHANNEL_MAP_WAVEEX
))
1116 AL_PRINT("Couldn't build map for channel count (%d)!\n", data
->spec
.channels
);
1117 ppa_threaded_mainloop_unlock(data
->loop
);
1121 data
->stream
= ppa_stream_new(data
->context
, "Capture Stream", &data
->spec
, &chanmap
);
1124 AL_PRINT("pa_stream_new() failed: %s\n",
1125 ppa_strerror(ppa_context_errno(data
->context
)));
1127 ppa_threaded_mainloop_unlock(data
->loop
);
1131 ppa_stream_set_state_callback(data
->stream
, stream_state_callback
, data
->loop
);
1133 flags
|= PA_STREAM_START_CORKED
|PA_STREAM_ADJUST_LATENCY
;
1134 if(ppa_stream_connect_record(data
->stream
, pulse_name
, &data
->attr
, flags
) < 0)
1136 AL_PRINT("Stream did not connect: %s\n",
1137 ppa_strerror(ppa_context_errno(data
->context
)));
1139 ppa_stream_unref(data
->stream
);
1140 data
->stream
= NULL
;
1142 ppa_threaded_mainloop_unlock(data
->loop
);
1146 while((state
=ppa_stream_get_state(data
->stream
)) != PA_STREAM_READY
)
1148 if(!PA_STREAM_IS_GOOD(state
))
1150 AL_PRINT("Stream did not get ready: %s\n",
1151 ppa_strerror(ppa_context_errno(data
->context
)));
1153 ppa_stream_unref(data
->stream
);
1154 data
->stream
= NULL
;
1156 ppa_threaded_mainloop_unlock(data
->loop
);
1160 ppa_threaded_mainloop_wait(data
->loop
);
1162 ppa_stream_set_state_callback(data
->stream
, stream_state_callback2
, device
);
1164 ppa_threaded_mainloop_unlock(data
->loop
);
1168 pulse_close(device
);
1172 static void pulse_close_capture(ALCdevice
*device
) //{{{
1174 pulse_close(device
);
1177 static void pulse_start_capture(ALCdevice
*device
) //{{{
1179 pulse_data
*data
= device
->ExtraData
;
1182 ppa_threaded_mainloop_lock(data
->loop
);
1183 o
= ppa_stream_cork(data
->stream
, 0, stream_success_callback
, device
);
1184 while(ppa_operation_get_state(o
) == PA_OPERATION_RUNNING
)
1185 ppa_threaded_mainloop_wait(data
->loop
);
1186 ppa_operation_unref(o
);
1187 ppa_threaded_mainloop_unlock(data
->loop
);
1190 static void pulse_stop_capture(ALCdevice
*device
) //{{{
1192 pulse_data
*data
= device
->ExtraData
;
1195 ppa_threaded_mainloop_lock(data
->loop
);
1196 o
= ppa_stream_cork(data
->stream
, 1, stream_success_callback
, device
);
1197 while(ppa_operation_get_state(o
) == PA_OPERATION_RUNNING
)
1198 ppa_threaded_mainloop_wait(data
->loop
);
1199 ppa_operation_unref(o
);
1200 ppa_threaded_mainloop_unlock(data
->loop
);
1203 static ALCuint
pulse_available_samples(ALCdevice
*device
) //{{{
1205 pulse_data
*data
= device
->ExtraData
;
1208 ppa_threaded_mainloop_lock(data
->loop
);
1209 /* Capture is done in fragment-sized chunks, so we loop until we get all
1210 * that's available */
1211 samples
= (device
->Connected
? ppa_stream_readable_size(data
->stream
) : 0);
1217 if(ppa_stream_peek(data
->stream
, &buf
, &length
) < 0)
1219 AL_PRINT("pa_stream_peek() failed: %s\n",
1220 ppa_strerror(ppa_context_errno(data
->context
)));
1224 WriteRingBuffer(data
->ring
, buf
, length
/data
->frame_size
);
1227 ppa_stream_drop(data
->stream
);
1229 ppa_threaded_mainloop_unlock(data
->loop
);
1231 return RingBufferSize(data
->ring
);
1234 static void pulse_capture_samples(ALCdevice
*device
, ALCvoid
*buffer
, ALCuint samples
) //{{{
1236 pulse_data
*data
= device
->ExtraData
;
1238 if(pulse_available_samples(device
) >= samples
)
1239 ReadRingBuffer(data
->ring
, buffer
, samples
);
1241 alcSetError(device
, ALC_INVALID_VALUE
);
1244 static ALuint64
pulse_get_time(ALCdevice
*Device
) //{{{
1246 pulse_data
*data
= Device
->ExtraData
;
1249 ppa_threaded_mainloop_lock(data
->loop
);
1250 if(!data
->stream
|| ppa_stream_get_time(data
->stream
, &usec
) != PA_OK
)
1251 usec
= data
->lastTime
;
1253 data
->lastTime
= usec
;
1254 ppa_threaded_mainloop_unlock(data
->loop
);
1256 return data
->baseTime
+ usec
*1000;
1260 BackendFuncs pulse_funcs
= { //{{{
1261 pulse_open_playback
,
1262 pulse_close_playback
,
1263 pulse_reset_playback
,
1264 pulse_stop_playback
,
1266 pulse_close_capture
,
1267 pulse_start_capture
,
1269 pulse_capture_samples
,
1270 pulse_available_samples
,
1274 void alc_pulse_init(BackendFuncs
*func_list
) //{{{
1276 *func_list
= pulse_funcs
;
1278 pulse_ctx_flags
= 0;
1279 if(!GetConfigValueBool("pulse", "spawn-server", 0))
1280 pulse_ctx_flags
|= PA_CONTEXT_NOAUTOSPAWN
;
1283 void alc_pulse_deinit(void) //{{{
1287 for(i
= 0;i
< numDevNames
;++i
)
1289 free(allDevNameMap
[i
].name
);
1290 free(allDevNameMap
[i
].device_name
);
1292 free(allDevNameMap
);
1293 allDevNameMap
= NULL
;
1296 for(i
= 0;i
< numCaptureDevNames
;++i
)
1298 free(allCaptureDevNameMap
[i
].name
);
1299 free(allCaptureDevNameMap
[i
].device_name
);
1301 free(allCaptureDevNameMap
);
1302 allCaptureDevNameMap
= NULL
;
1303 numCaptureDevNames
= 0;
1308 FreeLibrary(pa_handle
);
1309 #elif defined (HAVE_DLFCN_H)
1316 void alc_pulse_probe(int type
) //{{{
1318 if(!pulse_load()) return;
1320 if(type
== DEVICE_PROBE
)
1322 pa_threaded_mainloop
*loop
;
1324 if((loop
=ppa_threaded_mainloop_new()) &&
1325 ppa_threaded_mainloop_start(loop
) >= 0)
1327 pa_context
*context
;
1329 ppa_threaded_mainloop_lock(loop
);
1330 context
= connect_context(loop
);
1333 AppendDeviceList(pulse_device
);
1335 ppa_context_disconnect(context
);
1336 ppa_context_unref(context
);
1338 ppa_threaded_mainloop_unlock(loop
);
1339 ppa_threaded_mainloop_stop(loop
);
1342 ppa_threaded_mainloop_free(loop
);
1344 else if(type
== ALL_DEVICE_PROBE
)
1348 for(i
= 0;i
< numDevNames
;++i
)
1350 free(allDevNameMap
[i
].name
);
1351 free(allDevNameMap
[i
].device_name
);
1353 free(allDevNameMap
);
1354 allDevNameMap
= NULL
;
1357 probe_devices(AL_FALSE
);
1359 for(i
= 0;i
< numDevNames
;i
++)
1360 AppendAllDeviceList(allDevNameMap
[i
].name
);
1362 else if(type
== CAPTURE_DEVICE_PROBE
)
1366 for(i
= 0;i
< numCaptureDevNames
;++i
)
1368 free(allCaptureDevNameMap
[i
].name
);
1369 free(allCaptureDevNameMap
[i
].device_name
);
1371 free(allCaptureDevNameMap
);
1372 allCaptureDevNameMap
= NULL
;
1373 numCaptureDevNames
= 0;
1375 probe_devices(AL_TRUE
);
1377 for(i
= 0;i
< numCaptureDevNames
;i
++)
1378 AppendCaptureDeviceList(allCaptureDevNameMap
[i
].name
);