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
26 #include <pulse/pulseaudio.h>
28 #if PA_API_VERSION == 11
29 #define PA_STREAM_ADJUST_LATENCY 0x2000U
30 #define PA_STREAM_EARLY_REQUESTS 0x4000U
31 static __inline
int PA_STREAM_IS_GOOD(pa_stream_state_t x
)
33 return (x
== PA_STREAM_CREATING
|| x
== PA_STREAM_READY
);
35 static __inline
int PA_CONTEXT_IS_GOOD(pa_context_state_t x
)
37 return (x
== PA_CONTEXT_CONNECTING
|| x
== PA_CONTEXT_AUTHORIZING
||
38 x
== PA_CONTEXT_SETTING_NAME
|| x
== PA_CONTEXT_READY
);
40 #define PA_STREAM_IS_GOOD PA_STREAM_IS_GOOD
41 #define PA_CONTEXT_IS_GOOD PA_CONTEXT_IS_GOOD
42 #elif PA_API_VERSION != 12
43 #error Invalid PulseAudio API version
46 #ifndef PA_CHECK_VERSION
47 #define PA_CHECK_VERSION(major,minor,micro) \
48 ((PA_MAJOR > (major)) || \
49 (PA_MAJOR == (major) && PA_MINOR > (minor)) || \
50 (PA_MAJOR == (major) && PA_MINOR == (minor) && PA_MICRO >= (micro)))
53 static void *pa_handle
;
55 #define MAKE_FUNC(x) static typeof(x) * p##x
56 MAKE_FUNC(pa_context_unref
);
57 MAKE_FUNC(pa_sample_spec_valid
);
58 MAKE_FUNC(pa_stream_drop
);
59 MAKE_FUNC(pa_strerror
);
60 MAKE_FUNC(pa_context_get_state
);
61 MAKE_FUNC(pa_stream_get_state
);
62 MAKE_FUNC(pa_threaded_mainloop_signal
);
63 MAKE_FUNC(pa_stream_peek
);
64 MAKE_FUNC(pa_threaded_mainloop_wait
);
65 MAKE_FUNC(pa_threaded_mainloop_unlock
);
66 MAKE_FUNC(pa_threaded_mainloop_in_thread
);
67 MAKE_FUNC(pa_context_new
);
68 MAKE_FUNC(pa_threaded_mainloop_stop
);
69 MAKE_FUNC(pa_context_disconnect
);
70 MAKE_FUNC(pa_threaded_mainloop_start
);
71 MAKE_FUNC(pa_threaded_mainloop_get_api
);
72 MAKE_FUNC(pa_context_set_state_callback
);
73 MAKE_FUNC(pa_stream_write
);
75 MAKE_FUNC(pa_stream_connect_record
);
76 MAKE_FUNC(pa_stream_connect_playback
);
77 MAKE_FUNC(pa_stream_readable_size
);
78 MAKE_FUNC(pa_stream_writable_size
);
79 MAKE_FUNC(pa_stream_cork
);
80 MAKE_FUNC(pa_stream_is_suspended
);
81 MAKE_FUNC(pa_stream_get_device_name
);
82 MAKE_FUNC(pa_path_get_filename
);
83 MAKE_FUNC(pa_get_binary_name
);
84 MAKE_FUNC(pa_threaded_mainloop_free
);
85 MAKE_FUNC(pa_context_errno
);
86 MAKE_FUNC(pa_xmalloc
);
87 MAKE_FUNC(pa_stream_unref
);
88 MAKE_FUNC(pa_threaded_mainloop_accept
);
89 MAKE_FUNC(pa_stream_set_write_callback
);
90 MAKE_FUNC(pa_threaded_mainloop_new
);
91 MAKE_FUNC(pa_context_connect
);
92 MAKE_FUNC(pa_stream_set_buffer_attr
);
93 MAKE_FUNC(pa_stream_get_buffer_attr
);
94 MAKE_FUNC(pa_stream_get_sample_spec
);
95 MAKE_FUNC(pa_stream_get_time
);
96 MAKE_FUNC(pa_stream_set_read_callback
);
97 MAKE_FUNC(pa_stream_set_state_callback
);
98 MAKE_FUNC(pa_stream_set_moved_callback
);
99 MAKE_FUNC(pa_stream_set_underflow_callback
);
100 MAKE_FUNC(pa_stream_new
);
101 MAKE_FUNC(pa_stream_disconnect
);
102 MAKE_FUNC(pa_threaded_mainloop_lock
);
103 MAKE_FUNC(pa_channel_map_init_auto
);
104 MAKE_FUNC(pa_channel_map_parse
);
105 MAKE_FUNC(pa_channel_map_snprint
);
106 MAKE_FUNC(pa_channel_map_equal
);
107 MAKE_FUNC(pa_context_get_server_info
);
108 MAKE_FUNC(pa_context_get_sink_info_by_name
);
109 MAKE_FUNC(pa_context_get_sink_info_list
);
110 MAKE_FUNC(pa_context_get_source_info_list
);
111 MAKE_FUNC(pa_operation_get_state
);
112 MAKE_FUNC(pa_operation_unref
);
113 #if PA_CHECK_VERSION(0,9,15)
114 MAKE_FUNC(pa_channel_map_superset
);
115 MAKE_FUNC(pa_stream_set_buffer_attr_callback
);
117 #if PA_CHECK_VERSION(0,9,16)
118 MAKE_FUNC(pa_stream_begin_write
);
122 #define pa_context_unref ppa_context_unref
123 #define pa_sample_spec_valid ppa_sample_spec_valid
124 #define pa_stream_drop ppa_stream_drop
125 #define pa_strerror ppa_strerror
126 #define pa_context_get_state ppa_context_get_state
127 #define pa_stream_get_state ppa_stream_get_state
128 #define pa_threaded_mainloop_signal ppa_threaded_mainloop_signal
129 #define pa_stream_peek ppa_stream_peek
130 #define pa_threaded_mainloop_wait ppa_threaded_mainloop_wait
131 #define pa_threaded_mainloop_unlock ppa_threaded_mainloop_unlock
132 #define pa_threaded_mainloop_in_thread ppa_threaded_mainloop_in_thread
133 #define pa_context_new ppa_context_new
134 #define pa_threaded_mainloop_stop ppa_threaded_mainloop_stop
135 #define pa_context_disconnect ppa_context_disconnect
136 #define pa_threaded_mainloop_start ppa_threaded_mainloop_start
137 #define pa_threaded_mainloop_get_api ppa_threaded_mainloop_get_api
138 #define pa_context_set_state_callback ppa_context_set_state_callback
139 #define pa_stream_write ppa_stream_write
140 #define pa_xfree ppa_xfree
141 #define pa_stream_connect_record ppa_stream_connect_record
142 #define pa_stream_connect_playback ppa_stream_connect_playback
143 #define pa_stream_readable_size ppa_stream_readable_size
144 #define pa_stream_writable_size ppa_stream_writable_size
145 #define pa_stream_cork ppa_stream_cork
146 #define pa_stream_is_suspended ppa_stream_is_suspended
147 #define pa_stream_get_device_name ppa_stream_get_device_name
148 #define pa_path_get_filename ppa_path_get_filename
149 #define pa_get_binary_name ppa_get_binary_name
150 #define pa_threaded_mainloop_free ppa_threaded_mainloop_free
151 #define pa_context_errno ppa_context_errno
152 #define pa_xmalloc ppa_xmalloc
153 #define pa_stream_unref ppa_stream_unref
154 #define pa_threaded_mainloop_accept ppa_threaded_mainloop_accept
155 #define pa_stream_set_write_callback ppa_stream_set_write_callback
156 #define pa_threaded_mainloop_new ppa_threaded_mainloop_new
157 #define pa_context_connect ppa_context_connect
158 #define pa_stream_set_buffer_attr ppa_stream_set_buffer_attr
159 #define pa_stream_get_buffer_attr ppa_stream_get_buffer_attr
160 #define pa_stream_get_sample_spec ppa_stream_get_sample_spec
161 #define pa_stream_get_time ppa_stream_get_time
162 #define pa_stream_set_read_callback ppa_stream_set_read_callback
163 #define pa_stream_set_state_callback ppa_stream_set_state_callback
164 #define pa_stream_set_moved_callback ppa_stream_set_moved_callback
165 #define pa_stream_set_underflow_callback ppa_stream_set_underflow_callback
166 #define pa_stream_new ppa_stream_new
167 #define pa_stream_disconnect ppa_stream_disconnect
168 #define pa_threaded_mainloop_lock ppa_threaded_mainloop_lock
169 #define pa_channel_map_init_auto ppa_channel_map_init_auto
170 #define pa_channel_map_parse ppa_channel_map_parse
171 #define pa_channel_map_snprint ppa_channel_map_snprint
172 #define pa_channel_map_equal ppa_channel_map_equal
173 #define pa_context_get_server_info ppa_context_get_server_info
174 #define pa_context_get_sink_info_by_name ppa_context_get_sink_info_by_name
175 #define pa_context_get_sink_info_list ppa_context_get_sink_info_list
176 #define pa_context_get_source_info_list ppa_context_get_source_info_list
177 #define pa_operation_get_state ppa_operation_get_state
178 #define pa_operation_unref ppa_operation_unref
179 #if PA_CHECK_VERSION(0,9,15)
180 #define pa_channel_map_superset ppa_channel_map_superset
181 #define pa_stream_set_buffer_attr_callback ppa_stream_set_buffer_attr_callback
183 #if PA_CHECK_VERSION(0,9,16)
184 #define pa_stream_begin_write ppa_stream_begin_write
190 #define PATH_MAX 4096
204 pa_threaded_mainloop
*loop
;
207 volatile ALboolean killNow
;
219 static const ALCchar pulse_device
[] = "PulseAudio Default";
220 static DevMap
*allDevNameMap
;
221 static ALuint numDevNames
;
222 static DevMap
*allCaptureDevNameMap
;
223 static ALuint numCaptureDevNames
;
224 static pa_context_flags_t pulse_ctx_flags
;
227 static void context_state_callback(pa_context
*context
, void *pdata
)
229 pa_threaded_mainloop
*loop
= pdata
;
230 pa_context_state_t state
;
232 state
= pa_context_get_state(context
);
233 if(state
== PA_CONTEXT_READY
|| !PA_CONTEXT_IS_GOOD(state
))
234 pa_threaded_mainloop_signal(loop
, 0);
237 static pa_context
*connect_context(pa_threaded_mainloop
*loop
, ALboolean silent
)
239 const char *name
= "OpenAL Soft";
240 char path_name
[PATH_MAX
];
241 pa_context_state_t state
;
245 if(pa_get_binary_name(path_name
, sizeof(path_name
)))
246 name
= pa_path_get_filename(path_name
);
248 context
= pa_context_new(pa_threaded_mainloop_get_api(loop
), name
);
251 ERR("pa_context_new() failed\n");
255 pa_context_set_state_callback(context
, context_state_callback
, loop
);
257 if((err
=pa_context_connect(context
, NULL
, pulse_ctx_flags
, NULL
)) >= 0)
259 while((state
=pa_context_get_state(context
)) != PA_CONTEXT_READY
)
261 if(!PA_CONTEXT_IS_GOOD(state
))
263 err
= pa_context_errno(context
);
264 if(err
> 0) err
= -err
;
268 pa_threaded_mainloop_wait(loop
);
271 pa_context_set_state_callback(context
, NULL
, NULL
);
276 ERR("Context did not connect: %s\n", pa_strerror(err
));
277 pa_context_unref(context
);
285 static ALCboolean
pulse_load(void) //{{{
287 ALCboolean ret
= ALC_FALSE
;
290 pa_threaded_mainloop
*loop
;
295 #define PALIB "libpulse-0.dll"
296 #elif defined(__APPLE__) && defined(__MACH__)
297 #define PALIB "libpulse.0.dylib"
299 #define PALIB "libpulse.so.0"
301 pa_handle
= LoadLib(PALIB
);
305 #define LOAD_FUNC(x) do { \
306 p##x = GetSymbol(pa_handle, #x); \
308 CloseLib(pa_handle); \
313 LOAD_FUNC(pa_context_unref
);
314 LOAD_FUNC(pa_sample_spec_valid
);
315 LOAD_FUNC(pa_stream_drop
);
316 LOAD_FUNC(pa_strerror
);
317 LOAD_FUNC(pa_context_get_state
);
318 LOAD_FUNC(pa_stream_get_state
);
319 LOAD_FUNC(pa_threaded_mainloop_signal
);
320 LOAD_FUNC(pa_stream_peek
);
321 LOAD_FUNC(pa_threaded_mainloop_wait
);
322 LOAD_FUNC(pa_threaded_mainloop_unlock
);
323 LOAD_FUNC(pa_threaded_mainloop_in_thread
);
324 LOAD_FUNC(pa_context_new
);
325 LOAD_FUNC(pa_threaded_mainloop_stop
);
326 LOAD_FUNC(pa_context_disconnect
);
327 LOAD_FUNC(pa_threaded_mainloop_start
);
328 LOAD_FUNC(pa_threaded_mainloop_get_api
);
329 LOAD_FUNC(pa_context_set_state_callback
);
330 LOAD_FUNC(pa_stream_write
);
332 LOAD_FUNC(pa_stream_connect_record
);
333 LOAD_FUNC(pa_stream_connect_playback
);
334 LOAD_FUNC(pa_stream_readable_size
);
335 LOAD_FUNC(pa_stream_writable_size
);
336 LOAD_FUNC(pa_stream_cork
);
337 LOAD_FUNC(pa_stream_is_suspended
);
338 LOAD_FUNC(pa_stream_get_device_name
);
339 LOAD_FUNC(pa_path_get_filename
);
340 LOAD_FUNC(pa_get_binary_name
);
341 LOAD_FUNC(pa_threaded_mainloop_free
);
342 LOAD_FUNC(pa_context_errno
);
343 LOAD_FUNC(pa_xmalloc
);
344 LOAD_FUNC(pa_stream_unref
);
345 LOAD_FUNC(pa_threaded_mainloop_accept
);
346 LOAD_FUNC(pa_stream_set_write_callback
);
347 LOAD_FUNC(pa_threaded_mainloop_new
);
348 LOAD_FUNC(pa_context_connect
);
349 LOAD_FUNC(pa_stream_set_buffer_attr
);
350 LOAD_FUNC(pa_stream_get_buffer_attr
);
351 LOAD_FUNC(pa_stream_get_sample_spec
);
352 LOAD_FUNC(pa_stream_get_time
);
353 LOAD_FUNC(pa_stream_set_read_callback
);
354 LOAD_FUNC(pa_stream_set_state_callback
);
355 LOAD_FUNC(pa_stream_set_moved_callback
);
356 LOAD_FUNC(pa_stream_set_underflow_callback
);
357 LOAD_FUNC(pa_stream_new
);
358 LOAD_FUNC(pa_stream_disconnect
);
359 LOAD_FUNC(pa_threaded_mainloop_lock
);
360 LOAD_FUNC(pa_channel_map_init_auto
);
361 LOAD_FUNC(pa_channel_map_parse
);
362 LOAD_FUNC(pa_channel_map_snprint
);
363 LOAD_FUNC(pa_channel_map_equal
);
364 LOAD_FUNC(pa_context_get_server_info
);
365 LOAD_FUNC(pa_context_get_sink_info_by_name
);
366 LOAD_FUNC(pa_context_get_sink_info_list
);
367 LOAD_FUNC(pa_context_get_source_info_list
);
368 LOAD_FUNC(pa_operation_get_state
);
369 LOAD_FUNC(pa_operation_unref
);
371 #define LOAD_OPTIONAL_FUNC(x) do { \
372 p##x = GetSymbol(pa_handle, #x); \
374 #if PA_CHECK_VERSION(0,9,15)
375 LOAD_OPTIONAL_FUNC(pa_channel_map_superset
);
376 LOAD_OPTIONAL_FUNC(pa_stream_set_buffer_attr_callback
);
378 #if PA_CHECK_VERSION(0,9,16)
379 LOAD_OPTIONAL_FUNC(pa_stream_begin_write
);
381 #undef LOAD_OPTIONAL_FUNC
383 #else /* HAVE_DYNLOAD */
384 pa_handle
= (void*)0xDEADBEEF;
387 if((loop
=pa_threaded_mainloop_new()) &&
388 pa_threaded_mainloop_start(loop
) >= 0)
392 pa_threaded_mainloop_lock(loop
);
393 context
= connect_context(loop
, AL_TRUE
);
398 pa_context_disconnect(context
);
399 pa_context_unref(context
);
401 pa_threaded_mainloop_unlock(loop
);
402 pa_threaded_mainloop_stop(loop
);
405 pa_threaded_mainloop_free(loop
);
418 // PulseAudio Event Callbacks //{{{
419 static void stream_state_callback(pa_stream
*stream
, void *pdata
) //{{{
421 pa_threaded_mainloop
*loop
= pdata
;
422 pa_stream_state_t state
;
424 state
= pa_stream_get_state(stream
);
425 if(state
== PA_STREAM_READY
|| !PA_STREAM_IS_GOOD(state
))
426 pa_threaded_mainloop_signal(loop
, 0);
429 static void stream_signal_callback(pa_stream
*stream
, void *pdata
) //{{{
431 ALCdevice
*Device
= pdata
;
432 pulse_data
*data
= Device
->ExtraData
;
435 pa_threaded_mainloop_signal(data
->loop
, 0);
438 static void stream_buffer_attr_callback(pa_stream
*stream
, void *pdata
) //{{{
440 ALCdevice
*Device
= pdata
;
441 pulse_data
*data
= Device
->ExtraData
;
445 data
->attr
= *(pa_stream_get_buffer_attr(stream
));
446 Device
->UpdateSize
= data
->attr
.minreq
/ data
->frame_size
;
447 Device
->NumUpdates
= (data
->attr
.tlength
/data
->frame_size
) / Device
->UpdateSize
;
448 if(Device
->NumUpdates
<= 1)
450 Device
->NumUpdates
= 1;
451 ERR("PulseAudio returned minreq > tlength/2; expect lag or break up\n");
454 UnlockDevice(Device
);
457 static void stream_device_callback(pa_stream
*stream
, void *pdata
) //{{{
459 ALCdevice
*Device
= pdata
;
460 pulse_data
*data
= Device
->ExtraData
;
462 free(data
->device_name
);
463 data
->device_name
= strdup(pa_stream_get_device_name(stream
));
466 static void context_state_callback2(pa_context
*context
, void *pdata
) //{{{
468 ALCdevice
*Device
= pdata
;
469 pulse_data
*data
= Device
->ExtraData
;
471 if(pa_context_get_state(context
) == PA_CONTEXT_FAILED
)
473 ERR("Received context failure!\n");
474 aluHandleDisconnect(Device
);
476 pa_threaded_mainloop_signal(data
->loop
, 0);
479 static void stream_state_callback2(pa_stream
*stream
, void *pdata
) //{{{
481 ALCdevice
*Device
= pdata
;
482 pulse_data
*data
= Device
->ExtraData
;
484 if(pa_stream_get_state(stream
) == PA_STREAM_FAILED
)
486 ERR("Received stream failure!\n");
487 aluHandleDisconnect(Device
);
489 pa_threaded_mainloop_signal(data
->loop
, 0);
492 static void stream_success_callback(pa_stream
*stream
, int success
, void *pdata
) //{{{
494 ALCdevice
*Device
= pdata
;
495 pulse_data
*data
= Device
->ExtraData
;
499 pa_threaded_mainloop_signal(data
->loop
, 0);
502 static void sink_info_callback(pa_context
*context
, const pa_sink_info
*info
, int eol
, void *pdata
) //{{{
504 ALCdevice
*device
= pdata
;
505 pulse_data
*data
= device
->ExtraData
;
506 char chanmap_str
[256] = "";
509 enum DevFmtChannels chans
;
511 { "front-left,front-right,front-center,lfe,rear-left,rear-right,side-left,side-right",
513 { "front-left,front-right,front-center,lfe,rear-center,side-left,side-right",
515 { "front-left,front-right,front-center,lfe,rear-left,rear-right",
517 { "front-left,front-right,front-center,lfe,side-left,side-right",
519 { "front-left,front-right,rear-left,rear-right", DevFmtQuad
},
520 { "front-left,front-right", DevFmtStereo
},
521 { "mono", DevFmtMono
},
529 pa_threaded_mainloop_signal(data
->loop
, 0);
533 for(i
= 0;chanmaps
[i
].str
;i
++)
536 if(!pa_channel_map_parse(&map
, chanmaps
[i
].str
))
539 if(pa_channel_map_equal(&info
->channel_map
, &map
)
540 #if PA_CHECK_VERSION(0,9,15)
541 || (pa_channel_map_superset
&&
542 pa_channel_map_superset(&info
->channel_map
, &map
))
546 device
->FmtChans
= chanmaps
[i
].chans
;
551 pa_channel_map_snprint(chanmap_str
, sizeof(chanmap_str
), &info
->channel_map
);
552 ERR("Failed to find format for channel map:\n %s\n", chanmap_str
);
555 static void sink_device_callback(pa_context
*context
, const pa_sink_info
*info
, int eol
, void *pdata
) //{{{
557 pa_threaded_mainloop
*loop
= pdata
;
567 pa_threaded_mainloop_signal(loop
, 0);
574 snprintf(str
, sizeof(str
), "%s", info
->description
);
576 snprintf(str
, sizeof(str
), "%s #%d", info
->description
, count
+1);
579 for(i
= 0;i
< numDevNames
;i
++)
581 if(strcmp(str
, allDevNameMap
[i
].name
) == 0)
584 } while(i
!= numDevNames
);
586 temp
= realloc(allDevNameMap
, (numDevNames
+1) * sizeof(*allDevNameMap
));
589 allDevNameMap
= temp
;
590 allDevNameMap
[numDevNames
].name
= strdup(str
);
591 allDevNameMap
[numDevNames
].device_name
= strdup(info
->name
);
596 static void source_device_callback(pa_context
*context
, const pa_source_info
*info
, int eol
, void *pdata
) //{{{
598 pa_threaded_mainloop
*loop
= pdata
;
608 pa_threaded_mainloop_signal(loop
, 0);
615 snprintf(str
, sizeof(str
), "%s", info
->description
);
617 snprintf(str
, sizeof(str
), "%s #%d", info
->description
, count
+1);
620 for(i
= 0;i
< numCaptureDevNames
;i
++)
622 if(strcmp(str
, allCaptureDevNameMap
[i
].name
) == 0)
625 } while(i
!= numCaptureDevNames
);
627 temp
= realloc(allCaptureDevNameMap
, (numCaptureDevNames
+1) * sizeof(*allCaptureDevNameMap
));
630 allCaptureDevNameMap
= temp
;
631 allCaptureDevNameMap
[numCaptureDevNames
].name
= strdup(str
);
632 allCaptureDevNameMap
[numCaptureDevNames
].device_name
= strdup(info
->name
);
633 numCaptureDevNames
++;
638 // PulseAudio I/O Callbacks //{{{
639 static void stream_write_callback(pa_stream
*stream
, size_t len
, void *pdata
) //{{{
641 ALCdevice
*Device
= pdata
;
642 pulse_data
*data
= Device
->ExtraData
;
646 pa_threaded_mainloop_signal(data
->loop
, 0);
650 static ALuint
PulseProc(ALvoid
*param
)
652 ALCdevice
*Device
= param
;
653 pulse_data
*data
= Device
->ExtraData
;
658 pa_threaded_mainloop_lock(data
->loop
);
660 len
= (Device
->Connected
? pa_stream_writable_size(data
->stream
) : 0);
661 len
-= len
%(Device
->UpdateSize
*data
->frame_size
);
664 pa_threaded_mainloop_wait(data
->loop
);
672 pa_free_cb_t free_func
= NULL
;
674 #if PA_CHECK_VERSION(0,9,16)
675 if(!pa_stream_begin_write
||
676 pa_stream_begin_write(data
->stream
, &buf
, &newlen
) < 0)
679 buf
= pa_xmalloc(newlen
);
680 free_func
= pa_xfree
;
682 pa_threaded_mainloop_unlock(data
->loop
);
684 aluMixData(Device
, buf
, newlen
/data
->frame_size
);
686 pa_threaded_mainloop_lock(data
->loop
);
687 pa_stream_write(data
->stream
, buf
, newlen
, free_func
, 0, PA_SEEK_RELATIVE
);
690 } while(Device
->Connected
&& !data
->killNow
);
691 pa_threaded_mainloop_unlock(data
->loop
);
696 static pa_stream
*connect_playback_stream(ALCdevice
*device
,
697 pa_stream_flags_t flags
, pa_buffer_attr
*attr
, pa_sample_spec
*spec
,
698 pa_channel_map
*chanmap
)
700 pulse_data
*data
= device
->ExtraData
;
701 pa_stream_state_t state
;
704 stream
= pa_stream_new(data
->context
, "Playback Stream", spec
, chanmap
);
707 ERR("pa_stream_new() failed: %s\n",
708 pa_strerror(pa_context_errno(data
->context
)));
712 pa_stream_set_state_callback(stream
, stream_state_callback
, data
->loop
);
714 if(pa_stream_connect_playback(stream
, data
->device_name
, attr
, flags
, NULL
, NULL
) < 0)
716 ERR("Stream did not connect: %s\n",
717 pa_strerror(pa_context_errno(data
->context
)));
718 pa_stream_unref(stream
);
722 while((state
=pa_stream_get_state(stream
)) != PA_STREAM_READY
)
724 if(!PA_STREAM_IS_GOOD(state
))
726 ERR("Stream did not get ready: %s\n",
727 pa_strerror(pa_context_errno(data
->context
)));
728 pa_stream_unref(stream
);
732 pa_threaded_mainloop_wait(data
->loop
);
734 pa_stream_set_state_callback(stream
, NULL
, NULL
);
739 static void probe_devices(ALboolean capture
)
741 pa_threaded_mainloop
*loop
;
743 if(capture
== AL_FALSE
)
744 allDevNameMap
= malloc(sizeof(DevMap
) * 1);
746 allCaptureDevNameMap
= malloc(sizeof(DevMap
) * 1);
748 if((loop
=pa_threaded_mainloop_new()) &&
749 pa_threaded_mainloop_start(loop
) >= 0)
753 pa_threaded_mainloop_lock(loop
);
754 context
= connect_context(loop
, AL_FALSE
);
759 if(capture
== AL_FALSE
)
760 o
= pa_context_get_sink_info_list(context
, sink_device_callback
, loop
);
762 o
= pa_context_get_source_info_list(context
, source_device_callback
, loop
);
763 while(pa_operation_get_state(o
) == PA_OPERATION_RUNNING
)
764 pa_threaded_mainloop_wait(loop
);
765 pa_operation_unref(o
);
767 pa_context_disconnect(context
);
768 pa_context_unref(context
);
770 pa_threaded_mainloop_unlock(loop
);
771 pa_threaded_mainloop_stop(loop
);
774 pa_threaded_mainloop_free(loop
);
778 static ALCboolean
pulse_open(ALCdevice
*device
, const ALCchar
*device_name
) //{{{
780 pulse_data
*data
= pa_xmalloc(sizeof(pulse_data
));
781 memset(data
, 0, sizeof(*data
));
783 if(!(data
->loop
= pa_threaded_mainloop_new()))
785 ERR("pa_threaded_mainloop_new() failed!\n");
788 if(pa_threaded_mainloop_start(data
->loop
) < 0)
790 ERR("pa_threaded_mainloop_start() failed\n");
794 pa_threaded_mainloop_lock(data
->loop
);
795 device
->ExtraData
= data
;
797 data
->context
= connect_context(data
->loop
, AL_FALSE
);
800 pa_threaded_mainloop_unlock(data
->loop
);
803 pa_context_set_state_callback(data
->context
, context_state_callback2
, device
);
805 device
->szDeviceName
= strdup(device_name
);
807 pa_threaded_mainloop_unlock(data
->loop
);
813 pa_threaded_mainloop_stop(data
->loop
);
814 pa_threaded_mainloop_free(data
->loop
);
817 device
->ExtraData
= NULL
;
822 static void pulse_close(ALCdevice
*device
) //{{{
824 pulse_data
*data
= device
->ExtraData
;
826 pa_threaded_mainloop_lock(data
->loop
);
830 pa_stream_disconnect(data
->stream
);
831 pa_stream_unref(data
->stream
);
834 pa_context_disconnect(data
->context
);
835 pa_context_unref(data
->context
);
837 pa_threaded_mainloop_unlock(data
->loop
);
839 pa_threaded_mainloop_stop(data
->loop
);
840 pa_threaded_mainloop_free(data
->loop
);
842 DestroyRingBuffer(data
->ring
);
843 free(data
->device_name
);
845 device
->ExtraData
= NULL
;
851 static ALCenum
pulse_open_playback(ALCdevice
*device
, const ALCchar
*device_name
) //{{{
853 char *pulse_name
= NULL
;
858 probe_devices(AL_FALSE
);
861 device_name
= pulse_device
;
862 else if(strcmp(device_name
, pulse_device
) != 0)
866 for(i
= 0;i
< numDevNames
;i
++)
868 if(strcmp(device_name
, allDevNameMap
[i
].name
) == 0)
870 pulse_name
= allDevNameMap
[i
].device_name
;
875 return ALC_INVALID_VALUE
;
878 if(pulse_open(device
, device_name
) == ALC_FALSE
)
879 return ALC_INVALID_VALUE
;
881 data
= device
->ExtraData
;
883 pa_threaded_mainloop_lock(data
->loop
);
885 spec
.format
= PA_SAMPLE_S16NE
;
889 data
->device_name
= pulse_name
;
890 pa_stream
*stream
= connect_playback_stream(device
, 0, NULL
, &spec
, NULL
);
893 pa_threaded_mainloop_unlock(data
->loop
);
897 if(pa_stream_is_suspended(stream
))
899 ERR("Device is suspended\n");
900 pa_stream_disconnect(stream
);
901 pa_stream_unref(stream
);
902 pa_threaded_mainloop_unlock(data
->loop
);
905 data
->device_name
= strdup(pa_stream_get_device_name(stream
));
907 pa_stream_disconnect(stream
);
908 pa_stream_unref(stream
);
910 pa_threaded_mainloop_unlock(data
->loop
);
916 return ALC_INVALID_VALUE
;
919 static void pulse_close_playback(ALCdevice
*device
) //{{{
924 static ALCboolean
pulse_reset_playback(ALCdevice
*device
) //{{{
926 pulse_data
*data
= device
->ExtraData
;
927 pa_stream_flags_t flags
= 0;
928 pa_channel_map chanmap
;
930 pa_threaded_mainloop_lock(data
->loop
);
932 if(!(device
->Flags
&DEVICE_CHANNELS_REQUEST
))
935 o
= pa_context_get_sink_info_by_name(data
->context
, data
->device_name
, sink_info_callback
, device
);
936 while(pa_operation_get_state(o
) == PA_OPERATION_RUNNING
)
937 pa_threaded_mainloop_wait(data
->loop
);
938 pa_operation_unref(o
);
940 if(!(device
->Flags
&DEVICE_FREQUENCY_REQUEST
))
941 flags
|= PA_STREAM_FIX_RATE
;
943 data
->frame_size
= FrameSizeFromDevFmt(device
->FmtChans
, device
->FmtType
);
944 data
->attr
.prebuf
= -1;
945 data
->attr
.fragsize
= -1;
946 data
->attr
.minreq
= device
->UpdateSize
* data
->frame_size
;
947 data
->attr
.tlength
= data
->attr
.minreq
* maxu(device
->NumUpdates
, 2);
948 data
->attr
.maxlength
= -1;
949 flags
|= PA_STREAM_EARLY_REQUESTS
;
950 flags
|= PA_STREAM_INTERPOLATE_TIMING
| PA_STREAM_AUTO_TIMING_UPDATE
;
952 switch(device
->FmtType
)
955 device
->FmtType
= DevFmtUByte
;
958 data
->spec
.format
= PA_SAMPLE_U8
;
961 device
->FmtType
= DevFmtShort
;
964 data
->spec
.format
= PA_SAMPLE_S16NE
;
967 data
->spec
.format
= PA_SAMPLE_FLOAT32NE
;
970 data
->spec
.rate
= device
->Frequency
;
971 data
->spec
.channels
= ChannelsFromDevFmt(device
->FmtChans
);
973 if(pa_sample_spec_valid(&data
->spec
) == 0)
975 ERR("Invalid sample format\n");
976 pa_threaded_mainloop_unlock(data
->loop
);
980 if(!pa_channel_map_init_auto(&chanmap
, data
->spec
.channels
, PA_CHANNEL_MAP_WAVEEX
))
982 ERR("Couldn't build map for channel count (%d)!\n", data
->spec
.channels
);
983 pa_threaded_mainloop_unlock(data
->loop
);
986 SetDefaultWFXChannelOrder(device
);
988 data
->stream
= connect_playback_stream(device
, flags
, &data
->attr
, &data
->spec
, &chanmap
);
991 pa_threaded_mainloop_unlock(data
->loop
);
995 pa_stream_set_state_callback(data
->stream
, stream_state_callback2
, device
);
997 data
->spec
= *(pa_stream_get_sample_spec(data
->stream
));
998 if(device
->Frequency
!= data
->spec
.rate
)
1002 if((device
->Flags
&DEVICE_FREQUENCY_REQUEST
))
1003 ERR("Failed to set frequency %dhz, got %dhz instead\n", device
->Frequency
, data
->spec
.rate
);
1004 device
->Flags
&= ~DEVICE_FREQUENCY_REQUEST
;
1006 /* Server updated our playback rate, so modify the buffer attribs
1008 data
->attr
.minreq
= (ALuint64
)(data
->attr
.minreq
/data
->frame_size
) *
1009 data
->spec
.rate
/ device
->Frequency
* data
->frame_size
;
1010 data
->attr
.tlength
= data
->attr
.minreq
* maxu(device
->NumUpdates
, 2);
1012 o
= pa_stream_set_buffer_attr(data
->stream
, &data
->attr
,
1013 stream_success_callback
, device
);
1014 while(pa_operation_get_state(o
) == PA_OPERATION_RUNNING
)
1015 pa_threaded_mainloop_wait(data
->loop
);
1016 pa_operation_unref(o
);
1018 device
->Frequency
= data
->spec
.rate
;
1021 stream_buffer_attr_callback(data
->stream
, device
);
1022 if(device
->NumUpdates
< 2)
1026 /* Server gave a comparatively large minreq, so modify the tlength. */
1027 device
->NumUpdates
= 2;
1028 data
->attr
.tlength
= data
->attr
.minreq
* device
->NumUpdates
;
1030 o
= pa_stream_set_buffer_attr(data
->stream
, &data
->attr
,
1031 stream_success_callback
, device
);
1032 while(pa_operation_get_state(o
) == PA_OPERATION_RUNNING
)
1033 pa_threaded_mainloop_wait(data
->loop
);
1034 pa_operation_unref(o
);
1037 #if PA_CHECK_VERSION(0,9,15)
1038 if(pa_stream_set_buffer_attr_callback
)
1039 pa_stream_set_buffer_attr_callback(data
->stream
, stream_buffer_attr_callback
, device
);
1041 pa_stream_set_moved_callback(data
->stream
, stream_device_callback
, device
);
1042 pa_stream_set_write_callback(data
->stream
, stream_write_callback
, device
);
1043 pa_stream_set_underflow_callback(data
->stream
, stream_signal_callback
, device
);
1045 data
->thread
= StartThread(PulseProc
, device
);
1048 #if PA_CHECK_VERSION(0,9,15)
1049 if(pa_stream_set_buffer_attr_callback
)
1050 pa_stream_set_buffer_attr_callback(data
->stream
, NULL
, NULL
);
1052 pa_stream_set_moved_callback(data
->stream
, NULL
, NULL
);
1053 pa_stream_set_write_callback(data
->stream
, NULL
, NULL
);
1054 pa_stream_set_underflow_callback(data
->stream
, NULL
, NULL
);
1055 pa_stream_disconnect(data
->stream
);
1056 pa_stream_unref(data
->stream
);
1057 data
->stream
= NULL
;
1059 pa_threaded_mainloop_unlock(data
->loop
);
1063 pa_threaded_mainloop_unlock(data
->loop
);
1067 static void pulse_stop_playback(ALCdevice
*device
) //{{{
1069 pulse_data
*data
= device
->ExtraData
;
1074 data
->killNow
= AL_TRUE
;
1077 pa_threaded_mainloop_signal(data
->loop
, 0);
1078 StopThread(data
->thread
);
1079 data
->thread
= NULL
;
1081 data
->killNow
= AL_FALSE
;
1083 pa_threaded_mainloop_lock(data
->loop
);
1085 #if PA_CHECK_VERSION(0,9,15)
1086 if(pa_stream_set_buffer_attr_callback
)
1087 pa_stream_set_buffer_attr_callback(data
->stream
, NULL
, NULL
);
1089 pa_stream_set_moved_callback(data
->stream
, NULL
, NULL
);
1090 pa_stream_set_write_callback(data
->stream
, NULL
, NULL
);
1091 pa_stream_set_underflow_callback(data
->stream
, NULL
, NULL
);
1092 pa_stream_disconnect(data
->stream
);
1093 pa_stream_unref(data
->stream
);
1094 data
->stream
= NULL
;
1096 pa_threaded_mainloop_unlock(data
->loop
);
1100 static ALCenum
pulse_open_capture(ALCdevice
*device
, const ALCchar
*device_name
) //{{{
1102 char *pulse_name
= NULL
;
1104 pa_stream_flags_t flags
= 0;
1105 pa_stream_state_t state
;
1106 pa_channel_map chanmap
;
1108 if(!allCaptureDevNameMap
)
1109 probe_devices(AL_TRUE
);
1112 device_name
= pulse_device
;
1113 else if(strcmp(device_name
, pulse_device
) != 0)
1117 for(i
= 0;i
< numCaptureDevNames
;i
++)
1119 if(strcmp(device_name
, allCaptureDevNameMap
[i
].name
) == 0)
1121 pulse_name
= allCaptureDevNameMap
[i
].device_name
;
1125 if(i
== numCaptureDevNames
)
1126 return ALC_INVALID_VALUE
;
1129 if(pulse_open(device
, device_name
) == ALC_FALSE
)
1130 return ALC_INVALID_VALUE
;
1132 data
= device
->ExtraData
;
1133 pa_threaded_mainloop_lock(data
->loop
);
1135 data
->samples
= device
->UpdateSize
* device
->NumUpdates
;
1136 data
->frame_size
= FrameSizeFromDevFmt(device
->FmtChans
, device
->FmtType
);
1137 data
->samples
= maxu(data
->samples
, 100 * device
->Frequency
/ 1000);
1139 if(!(data
->ring
= CreateRingBuffer(data
->frame_size
, data
->samples
)))
1141 pa_threaded_mainloop_unlock(data
->loop
);
1145 data
->attr
.minreq
= -1;
1146 data
->attr
.prebuf
= -1;
1147 data
->attr
.maxlength
= data
->samples
* data
->frame_size
;
1148 data
->attr
.tlength
= -1;
1149 data
->attr
.fragsize
= minu(data
->samples
, 50*device
->Frequency
/1000) *
1152 data
->spec
.rate
= device
->Frequency
;
1153 data
->spec
.channels
= ChannelsFromDevFmt(device
->FmtChans
);
1155 switch(device
->FmtType
)
1158 data
->spec
.format
= PA_SAMPLE_U8
;
1161 data
->spec
.format
= PA_SAMPLE_S16NE
;
1164 data
->spec
.format
= PA_SAMPLE_FLOAT32NE
;
1168 ERR("Capture format type %#x capture not supported on PulseAudio\n", device
->FmtType
);
1169 pa_threaded_mainloop_unlock(data
->loop
);
1173 if(pa_sample_spec_valid(&data
->spec
) == 0)
1175 ERR("Invalid sample format\n");
1176 pa_threaded_mainloop_unlock(data
->loop
);
1180 if(!pa_channel_map_init_auto(&chanmap
, data
->spec
.channels
, PA_CHANNEL_MAP_WAVEEX
))
1182 ERR("Couldn't build map for channel count (%d)!\n", data
->spec
.channels
);
1183 pa_threaded_mainloop_unlock(data
->loop
);
1187 data
->stream
= pa_stream_new(data
->context
, "Capture Stream", &data
->spec
, &chanmap
);
1190 ERR("pa_stream_new() failed: %s\n",
1191 pa_strerror(pa_context_errno(data
->context
)));
1193 pa_threaded_mainloop_unlock(data
->loop
);
1197 pa_stream_set_state_callback(data
->stream
, stream_state_callback
, data
->loop
);
1199 flags
|= PA_STREAM_START_CORKED
|PA_STREAM_ADJUST_LATENCY
;
1200 if(pa_stream_connect_record(data
->stream
, pulse_name
, &data
->attr
, flags
) < 0)
1202 ERR("Stream did not connect: %s\n",
1203 pa_strerror(pa_context_errno(data
->context
)));
1205 pa_stream_unref(data
->stream
);
1206 data
->stream
= NULL
;
1208 pa_threaded_mainloop_unlock(data
->loop
);
1212 while((state
=pa_stream_get_state(data
->stream
)) != PA_STREAM_READY
)
1214 if(!PA_STREAM_IS_GOOD(state
))
1216 ERR("Stream did not get ready: %s\n",
1217 pa_strerror(pa_context_errno(data
->context
)));
1219 pa_stream_unref(data
->stream
);
1220 data
->stream
= NULL
;
1222 pa_threaded_mainloop_unlock(data
->loop
);
1226 pa_threaded_mainloop_wait(data
->loop
);
1228 pa_stream_set_state_callback(data
->stream
, stream_state_callback2
, device
);
1230 pa_threaded_mainloop_unlock(data
->loop
);
1231 return ALC_NO_ERROR
;
1234 pulse_close(device
);
1235 return ALC_INVALID_VALUE
;
1238 static void pulse_close_capture(ALCdevice
*device
) //{{{
1240 pulse_close(device
);
1243 static void pulse_start_capture(ALCdevice
*device
) //{{{
1245 pulse_data
*data
= device
->ExtraData
;
1248 pa_threaded_mainloop_lock(data
->loop
);
1249 o
= pa_stream_cork(data
->stream
, 0, stream_success_callback
, device
);
1250 while(pa_operation_get_state(o
) == PA_OPERATION_RUNNING
)
1251 pa_threaded_mainloop_wait(data
->loop
);
1252 pa_operation_unref(o
);
1253 pa_threaded_mainloop_unlock(data
->loop
);
1256 static void pulse_stop_capture(ALCdevice
*device
) //{{{
1258 pulse_data
*data
= device
->ExtraData
;
1261 pa_threaded_mainloop_lock(data
->loop
);
1262 o
= pa_stream_cork(data
->stream
, 1, stream_success_callback
, device
);
1263 while(pa_operation_get_state(o
) == PA_OPERATION_RUNNING
)
1264 pa_threaded_mainloop_wait(data
->loop
);
1265 pa_operation_unref(o
);
1266 pa_threaded_mainloop_unlock(data
->loop
);
1269 static ALCenum
pulse_capture_samples(ALCdevice
*device
, ALCvoid
*buffer
, ALCuint samples
) //{{{
1271 pulse_data
*data
= device
->ExtraData
;
1272 ReadRingBuffer(data
->ring
, buffer
, samples
);
1273 return ALC_NO_ERROR
;
1276 static ALCuint
pulse_available_samples(ALCdevice
*device
) //{{{
1278 pulse_data
*data
= device
->ExtraData
;
1281 pa_threaded_mainloop_lock(data
->loop
);
1282 /* Capture is done in fragment-sized chunks, so we loop until we get all
1283 * that's available */
1284 samples
= (device
->Connected
? pa_stream_readable_size(data
->stream
) : 0);
1290 if(pa_stream_peek(data
->stream
, &buf
, &length
) < 0)
1292 ERR("pa_stream_peek() failed: %s\n",
1293 pa_strerror(pa_context_errno(data
->context
)));
1297 WriteRingBuffer(data
->ring
, buf
, length
/data
->frame_size
);
1300 pa_stream_drop(data
->stream
);
1302 pa_threaded_mainloop_unlock(data
->loop
);
1304 return RingBufferSize(data
->ring
);
1308 static const BackendFuncs pulse_funcs
= { //{{{
1309 pulse_open_playback
,
1310 pulse_close_playback
,
1311 pulse_reset_playback
,
1312 pulse_stop_playback
,
1314 pulse_close_capture
,
1315 pulse_start_capture
,
1317 pulse_capture_samples
,
1318 pulse_available_samples
1321 ALCboolean
alc_pulse_init(BackendFuncs
*func_list
) //{{{
1326 *func_list
= pulse_funcs
;
1328 pulse_ctx_flags
= 0;
1329 if(!GetConfigValueBool("pulse", "spawn-server", 0))
1330 pulse_ctx_flags
|= PA_CONTEXT_NOAUTOSPAWN
;
1335 void alc_pulse_deinit(void) //{{{
1339 for(i
= 0;i
< numDevNames
;++i
)
1341 free(allDevNameMap
[i
].name
);
1342 free(allDevNameMap
[i
].device_name
);
1344 free(allDevNameMap
);
1345 allDevNameMap
= NULL
;
1348 for(i
= 0;i
< numCaptureDevNames
;++i
)
1350 free(allCaptureDevNameMap
[i
].name
);
1351 free(allCaptureDevNameMap
[i
].device_name
);
1353 free(allCaptureDevNameMap
);
1354 allCaptureDevNameMap
= NULL
;
1355 numCaptureDevNames
= 0;
1359 CloseLib(pa_handle
);
1364 void alc_pulse_probe(enum DevProbe type
) //{{{
1366 pa_threaded_mainloop
*loop
;
1372 if((loop
=pa_threaded_mainloop_new()) &&
1373 pa_threaded_mainloop_start(loop
) >= 0)
1375 pa_context
*context
;
1377 pa_threaded_mainloop_lock(loop
);
1378 context
= connect_context(loop
, AL_FALSE
);
1381 AppendDeviceList(pulse_device
);
1383 pa_context_disconnect(context
);
1384 pa_context_unref(context
);
1386 pa_threaded_mainloop_unlock(loop
);
1387 pa_threaded_mainloop_stop(loop
);
1390 pa_threaded_mainloop_free(loop
);
1393 case ALL_DEVICE_PROBE
:
1394 for(i
= 0;i
< numDevNames
;++i
)
1396 free(allDevNameMap
[i
].name
);
1397 free(allDevNameMap
[i
].device_name
);
1399 free(allDevNameMap
);
1400 allDevNameMap
= NULL
;
1403 probe_devices(AL_FALSE
);
1405 for(i
= 0;i
< numDevNames
;i
++)
1406 AppendAllDeviceList(allDevNameMap
[i
].name
);
1409 case CAPTURE_DEVICE_PROBE
:
1410 for(i
= 0;i
< numCaptureDevNames
;++i
)
1412 free(allCaptureDevNameMap
[i
].name
);
1413 free(allCaptureDevNameMap
[i
].device_name
);
1415 free(allCaptureDevNameMap
);
1416 allCaptureDevNameMap
= NULL
;
1417 numCaptureDevNames
= 0;
1419 probe_devices(AL_TRUE
);
1421 for(i
= 0;i
< numCaptureDevNames
;i
++)
1422 AppendCaptureDeviceList(allCaptureDevNameMap
[i
].name
);