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 == 12
30 #ifndef PA_CHECK_VERSION
31 #define PA_CHECK_VERSION(major,minor,micro) \
32 ((PA_MAJOR > (major)) || \
33 (PA_MAJOR == (major) && PA_MINOR > (minor)) || \
34 (PA_MAJOR == (major) && PA_MINOR == (minor) && PA_MICRO >= (micro)))
38 static void *pa_handle
;
39 #define MAKE_FUNC(x) static typeof(x) * p##x
40 MAKE_FUNC(pa_context_unref
);
41 MAKE_FUNC(pa_sample_spec_valid
);
42 MAKE_FUNC(pa_frame_size
);
43 MAKE_FUNC(pa_stream_drop
);
44 MAKE_FUNC(pa_strerror
);
45 MAKE_FUNC(pa_context_get_state
);
46 MAKE_FUNC(pa_stream_get_state
);
47 MAKE_FUNC(pa_threaded_mainloop_signal
);
48 MAKE_FUNC(pa_stream_peek
);
49 MAKE_FUNC(pa_threaded_mainloop_wait
);
50 MAKE_FUNC(pa_threaded_mainloop_unlock
);
51 MAKE_FUNC(pa_threaded_mainloop_in_thread
);
52 MAKE_FUNC(pa_context_new
);
53 MAKE_FUNC(pa_threaded_mainloop_stop
);
54 MAKE_FUNC(pa_context_disconnect
);
55 MAKE_FUNC(pa_threaded_mainloop_start
);
56 MAKE_FUNC(pa_threaded_mainloop_get_api
);
57 MAKE_FUNC(pa_context_set_state_callback
);
58 MAKE_FUNC(pa_stream_write
);
60 MAKE_FUNC(pa_stream_connect_record
);
61 MAKE_FUNC(pa_stream_connect_playback
);
62 MAKE_FUNC(pa_stream_readable_size
);
63 MAKE_FUNC(pa_stream_writable_size
);
64 MAKE_FUNC(pa_stream_is_corked
);
65 MAKE_FUNC(pa_stream_cork
);
66 MAKE_FUNC(pa_stream_is_suspended
);
67 MAKE_FUNC(pa_stream_get_device_name
);
68 MAKE_FUNC(pa_path_get_filename
);
69 MAKE_FUNC(pa_get_binary_name
);
70 MAKE_FUNC(pa_threaded_mainloop_free
);
71 MAKE_FUNC(pa_context_errno
);
72 MAKE_FUNC(pa_xmalloc
);
73 MAKE_FUNC(pa_stream_unref
);
74 MAKE_FUNC(pa_threaded_mainloop_accept
);
75 MAKE_FUNC(pa_stream_set_write_callback
);
76 MAKE_FUNC(pa_threaded_mainloop_new
);
77 MAKE_FUNC(pa_context_connect
);
78 MAKE_FUNC(pa_stream_set_buffer_attr
);
79 MAKE_FUNC(pa_stream_get_buffer_attr
);
80 MAKE_FUNC(pa_stream_get_sample_spec
);
81 MAKE_FUNC(pa_stream_get_time
);
82 MAKE_FUNC(pa_stream_set_read_callback
);
83 MAKE_FUNC(pa_stream_set_state_callback
);
84 MAKE_FUNC(pa_stream_set_moved_callback
);
85 MAKE_FUNC(pa_stream_set_underflow_callback
);
86 MAKE_FUNC(pa_stream_new_with_proplist
);
87 MAKE_FUNC(pa_stream_disconnect
);
88 MAKE_FUNC(pa_threaded_mainloop_lock
);
89 MAKE_FUNC(pa_channel_map_init_auto
);
90 MAKE_FUNC(pa_channel_map_parse
);
91 MAKE_FUNC(pa_channel_map_snprint
);
92 MAKE_FUNC(pa_channel_map_equal
);
93 MAKE_FUNC(pa_context_get_server_info
);
94 MAKE_FUNC(pa_context_get_sink_info_by_name
);
95 MAKE_FUNC(pa_context_get_sink_info_list
);
96 MAKE_FUNC(pa_context_get_source_info_by_name
);
97 MAKE_FUNC(pa_context_get_source_info_list
);
98 MAKE_FUNC(pa_operation_get_state
);
99 MAKE_FUNC(pa_operation_unref
);
100 MAKE_FUNC(pa_proplist_new
);
101 MAKE_FUNC(pa_proplist_free
);
102 MAKE_FUNC(pa_proplist_set
);
103 #if PA_CHECK_VERSION(0,9,15)
104 MAKE_FUNC(pa_channel_map_superset
);
105 MAKE_FUNC(pa_stream_set_buffer_attr_callback
);
107 #if PA_CHECK_VERSION(0,9,16)
108 MAKE_FUNC(pa_stream_begin_write
);
112 #define pa_context_unref ppa_context_unref
113 #define pa_sample_spec_valid ppa_sample_spec_valid
114 #define pa_frame_size ppa_frame_size
115 #define pa_stream_drop ppa_stream_drop
116 #define pa_strerror ppa_strerror
117 #define pa_context_get_state ppa_context_get_state
118 #define pa_stream_get_state ppa_stream_get_state
119 #define pa_threaded_mainloop_signal ppa_threaded_mainloop_signal
120 #define pa_stream_peek ppa_stream_peek
121 #define pa_threaded_mainloop_wait ppa_threaded_mainloop_wait
122 #define pa_threaded_mainloop_unlock ppa_threaded_mainloop_unlock
123 #define pa_threaded_mainloop_in_thread ppa_threaded_mainloop_in_thread
124 #define pa_context_new ppa_context_new
125 #define pa_threaded_mainloop_stop ppa_threaded_mainloop_stop
126 #define pa_context_disconnect ppa_context_disconnect
127 #define pa_threaded_mainloop_start ppa_threaded_mainloop_start
128 #define pa_threaded_mainloop_get_api ppa_threaded_mainloop_get_api
129 #define pa_context_set_state_callback ppa_context_set_state_callback
130 #define pa_stream_write ppa_stream_write
131 #define pa_xfree ppa_xfree
132 #define pa_stream_connect_record ppa_stream_connect_record
133 #define pa_stream_connect_playback ppa_stream_connect_playback
134 #define pa_stream_readable_size ppa_stream_readable_size
135 #define pa_stream_writable_size ppa_stream_writable_size
136 #define pa_stream_is_corked ppa_stream_is_corked
137 #define pa_stream_cork ppa_stream_cork
138 #define pa_stream_is_suspended ppa_stream_is_suspended
139 #define pa_stream_get_device_name ppa_stream_get_device_name
140 #define pa_path_get_filename ppa_path_get_filename
141 #define pa_get_binary_name ppa_get_binary_name
142 #define pa_threaded_mainloop_free ppa_threaded_mainloop_free
143 #define pa_context_errno ppa_context_errno
144 #define pa_xmalloc ppa_xmalloc
145 #define pa_stream_unref ppa_stream_unref
146 #define pa_threaded_mainloop_accept ppa_threaded_mainloop_accept
147 #define pa_stream_set_write_callback ppa_stream_set_write_callback
148 #define pa_threaded_mainloop_new ppa_threaded_mainloop_new
149 #define pa_context_connect ppa_context_connect
150 #define pa_stream_set_buffer_attr ppa_stream_set_buffer_attr
151 #define pa_stream_get_buffer_attr ppa_stream_get_buffer_attr
152 #define pa_stream_get_sample_spec ppa_stream_get_sample_spec
153 #define pa_stream_get_time ppa_stream_get_time
154 #define pa_stream_set_read_callback ppa_stream_set_read_callback
155 #define pa_stream_set_state_callback ppa_stream_set_state_callback
156 #define pa_stream_set_moved_callback ppa_stream_set_moved_callback
157 #define pa_stream_set_underflow_callback ppa_stream_set_underflow_callback
158 #define pa_stream_new_with_proplist ppa_stream_new_with_proplist
159 #define pa_stream_disconnect ppa_stream_disconnect
160 #define pa_threaded_mainloop_lock ppa_threaded_mainloop_lock
161 #define pa_channel_map_init_auto ppa_channel_map_init_auto
162 #define pa_channel_map_parse ppa_channel_map_parse
163 #define pa_channel_map_snprint ppa_channel_map_snprint
164 #define pa_channel_map_equal ppa_channel_map_equal
165 #define pa_context_get_server_info ppa_context_get_server_info
166 #define pa_context_get_sink_info_by_name ppa_context_get_sink_info_by_name
167 #define pa_context_get_sink_info_list ppa_context_get_sink_info_list
168 #define pa_context_get_source_info_by_name ppa_context_get_source_info_by_name
169 #define pa_context_get_source_info_list ppa_context_get_source_info_list
170 #define pa_operation_get_state ppa_operation_get_state
171 #define pa_operation_unref ppa_operation_unref
172 #define pa_proplist_new ppa_proplist_new
173 #define pa_proplist_free ppa_proplist_free
174 #define pa_proplist_set ppa_proplist_set
175 #if PA_CHECK_VERSION(0,9,15)
176 #define pa_channel_map_superset ppa_channel_map_superset
177 #define pa_stream_set_buffer_attr_callback ppa_stream_set_buffer_attr_callback
179 #if PA_CHECK_VERSION(0,9,16)
180 #define pa_stream_begin_write ppa_stream_begin_write
186 #define PATH_MAX 4096
192 const void *cap_store
;
196 ALCuint last_readable
;
201 pa_threaded_mainloop
*loop
;
204 volatile ALboolean killNow
;
216 static DevMap
*allDevNameMap
;
217 static ALuint numDevNames
;
218 static DevMap
*allCaptureDevNameMap
;
219 static ALuint numCaptureDevNames
;
220 static pa_context_flags_t pulse_ctx_flags
;
221 static pa_proplist
*prop_filter
;
224 static ALCboolean
pulse_load(void)
226 ALCboolean ret
= ALC_TRUE
;
231 #define PALIB "libpulse-0.dll"
232 #elif defined(__APPLE__) && defined(__MACH__)
233 #define PALIB "libpulse.0.dylib"
235 #define PALIB "libpulse.so.0"
237 pa_handle
= LoadLib(PALIB
);
241 #define LOAD_FUNC(x) do { \
242 p##x = GetSymbol(pa_handle, #x); \
247 LOAD_FUNC(pa_context_unref
);
248 LOAD_FUNC(pa_sample_spec_valid
);
249 LOAD_FUNC(pa_stream_drop
);
250 LOAD_FUNC(pa_frame_size
);
251 LOAD_FUNC(pa_strerror
);
252 LOAD_FUNC(pa_context_get_state
);
253 LOAD_FUNC(pa_stream_get_state
);
254 LOAD_FUNC(pa_threaded_mainloop_signal
);
255 LOAD_FUNC(pa_stream_peek
);
256 LOAD_FUNC(pa_threaded_mainloop_wait
);
257 LOAD_FUNC(pa_threaded_mainloop_unlock
);
258 LOAD_FUNC(pa_threaded_mainloop_in_thread
);
259 LOAD_FUNC(pa_context_new
);
260 LOAD_FUNC(pa_threaded_mainloop_stop
);
261 LOAD_FUNC(pa_context_disconnect
);
262 LOAD_FUNC(pa_threaded_mainloop_start
);
263 LOAD_FUNC(pa_threaded_mainloop_get_api
);
264 LOAD_FUNC(pa_context_set_state_callback
);
265 LOAD_FUNC(pa_stream_write
);
267 LOAD_FUNC(pa_stream_connect_record
);
268 LOAD_FUNC(pa_stream_connect_playback
);
269 LOAD_FUNC(pa_stream_readable_size
);
270 LOAD_FUNC(pa_stream_writable_size
);
271 LOAD_FUNC(pa_stream_is_corked
);
272 LOAD_FUNC(pa_stream_cork
);
273 LOAD_FUNC(pa_stream_is_suspended
);
274 LOAD_FUNC(pa_stream_get_device_name
);
275 LOAD_FUNC(pa_path_get_filename
);
276 LOAD_FUNC(pa_get_binary_name
);
277 LOAD_FUNC(pa_threaded_mainloop_free
);
278 LOAD_FUNC(pa_context_errno
);
279 LOAD_FUNC(pa_xmalloc
);
280 LOAD_FUNC(pa_stream_unref
);
281 LOAD_FUNC(pa_threaded_mainloop_accept
);
282 LOAD_FUNC(pa_stream_set_write_callback
);
283 LOAD_FUNC(pa_threaded_mainloop_new
);
284 LOAD_FUNC(pa_context_connect
);
285 LOAD_FUNC(pa_stream_set_buffer_attr
);
286 LOAD_FUNC(pa_stream_get_buffer_attr
);
287 LOAD_FUNC(pa_stream_get_sample_spec
);
288 LOAD_FUNC(pa_stream_get_time
);
289 LOAD_FUNC(pa_stream_set_read_callback
);
290 LOAD_FUNC(pa_stream_set_state_callback
);
291 LOAD_FUNC(pa_stream_set_moved_callback
);
292 LOAD_FUNC(pa_stream_set_underflow_callback
);
293 LOAD_FUNC(pa_stream_new_with_proplist
);
294 LOAD_FUNC(pa_stream_disconnect
);
295 LOAD_FUNC(pa_threaded_mainloop_lock
);
296 LOAD_FUNC(pa_channel_map_init_auto
);
297 LOAD_FUNC(pa_channel_map_parse
);
298 LOAD_FUNC(pa_channel_map_snprint
);
299 LOAD_FUNC(pa_channel_map_equal
);
300 LOAD_FUNC(pa_context_get_server_info
);
301 LOAD_FUNC(pa_context_get_sink_info_by_name
);
302 LOAD_FUNC(pa_context_get_sink_info_list
);
303 LOAD_FUNC(pa_context_get_source_info_by_name
);
304 LOAD_FUNC(pa_context_get_source_info_list
);
305 LOAD_FUNC(pa_operation_get_state
);
306 LOAD_FUNC(pa_operation_unref
);
307 LOAD_FUNC(pa_proplist_new
);
308 LOAD_FUNC(pa_proplist_free
);
309 LOAD_FUNC(pa_proplist_set
);
311 #define LOAD_OPTIONAL_FUNC(x) do { \
312 p##x = GetSymbol(pa_handle, #x); \
314 #if PA_CHECK_VERSION(0,9,15)
315 LOAD_OPTIONAL_FUNC(pa_channel_map_superset
);
316 LOAD_OPTIONAL_FUNC(pa_stream_set_buffer_attr_callback
);
318 #if PA_CHECK_VERSION(0,9,16)
319 LOAD_OPTIONAL_FUNC(pa_stream_begin_write
);
321 #undef LOAD_OPTIONAL_FUNC
329 #endif /* HAVE_DYNLOAD */
333 /* PulseAudio Event Callbacks */
334 static void context_state_callback(pa_context
*context
, void *pdata
)
336 pa_threaded_mainloop
*loop
= pdata
;
337 pa_context_state_t state
;
339 state
= pa_context_get_state(context
);
340 if(state
== PA_CONTEXT_READY
|| !PA_CONTEXT_IS_GOOD(state
))
341 pa_threaded_mainloop_signal(loop
, 0);
344 static void stream_state_callback(pa_stream
*stream
, void *pdata
)
346 pa_threaded_mainloop
*loop
= pdata
;
347 pa_stream_state_t state
;
349 state
= pa_stream_get_state(stream
);
350 if(state
== PA_STREAM_READY
|| !PA_STREAM_IS_GOOD(state
))
351 pa_threaded_mainloop_signal(loop
, 0);
354 static void stream_buffer_attr_callback(pa_stream
*stream
, void *pdata
)
356 ALCdevice
*device
= pdata
;
357 pulse_data
*data
= device
->ExtraData
;
359 data
->attr
= *pa_stream_get_buffer_attr(stream
);
360 TRACE("minreq=%d, tlength=%d, prebuf=%d\n", data
->attr
.minreq
, data
->attr
.tlength
, data
->attr
.prebuf
);
363 static void context_state_callback2(pa_context
*context
, void *pdata
)
365 ALCdevice
*Device
= pdata
;
366 pulse_data
*data
= Device
->ExtraData
;
368 if(pa_context_get_state(context
) == PA_CONTEXT_FAILED
)
370 ERR("Received context failure!\n");
371 aluHandleDisconnect(Device
);
373 pa_threaded_mainloop_signal(data
->loop
, 0);
376 static void stream_state_callback2(pa_stream
*stream
, void *pdata
)
378 ALCdevice
*Device
= pdata
;
379 pulse_data
*data
= Device
->ExtraData
;
381 if(pa_stream_get_state(stream
) == PA_STREAM_FAILED
)
383 ERR("Received stream failure!\n");
384 aluHandleDisconnect(Device
);
386 pa_threaded_mainloop_signal(data
->loop
, 0);
389 static void stream_success_callback(pa_stream
*stream
, int success
, void *pdata
)
391 ALCdevice
*Device
= pdata
;
392 pulse_data
*data
= Device
->ExtraData
;
396 pa_threaded_mainloop_signal(data
->loop
, 0);
399 static void sink_info_callback(pa_context
*context
, const pa_sink_info
*info
, int eol
, void *pdata
)
401 ALCdevice
*device
= pdata
;
402 pulse_data
*data
= device
->ExtraData
;
403 char chanmap_str
[256] = "";
406 enum DevFmtChannels chans
;
408 { "front-left,front-right,front-center,lfe,rear-left,rear-right,side-left,side-right",
410 { "front-left,front-right,front-center,lfe,rear-center,side-left,side-right",
412 { "front-left,front-right,front-center,lfe,rear-left,rear-right",
414 { "front-left,front-right,front-center,lfe,side-left,side-right",
416 { "front-left,front-right,rear-left,rear-right", DevFmtQuad
},
417 { "front-left,front-right", DevFmtStereo
},
418 { "mono", DevFmtMono
},
426 pa_threaded_mainloop_signal(data
->loop
, 0);
430 for(i
= 0;chanmaps
[i
].str
;i
++)
433 if(!pa_channel_map_parse(&map
, chanmaps
[i
].str
))
436 if(pa_channel_map_equal(&info
->channel_map
, &map
)
437 #if PA_CHECK_VERSION(0,9,15)
438 || (pa_channel_map_superset
&&
439 pa_channel_map_superset(&info
->channel_map
, &map
))
443 device
->FmtChans
= chanmaps
[i
].chans
;
448 pa_channel_map_snprint(chanmap_str
, sizeof(chanmap_str
), &info
->channel_map
);
449 ERR("Failed to find format for channel map:\n %s\n", chanmap_str
);
452 static void sink_device_callback(pa_context
*context
, const pa_sink_info
*info
, int eol
, void *pdata
)
454 pa_threaded_mainloop
*loop
= pdata
;
462 pa_threaded_mainloop_signal(loop
, 0);
466 for(i
= 0;i
< numDevNames
;i
++)
468 if(strcmp(info
->name
, allDevNameMap
[i
].device_name
) == 0)
472 TRACE("Got device \"%s\", \"%s\"\n", info
->description
, info
->name
);
474 temp
= realloc(allDevNameMap
, (numDevNames
+1) * sizeof(*allDevNameMap
));
477 allDevNameMap
= temp
;
478 allDevNameMap
[numDevNames
].name
= strdup(info
->description
);
479 allDevNameMap
[numDevNames
].device_name
= strdup(info
->name
);
484 static void source_device_callback(pa_context
*context
, const pa_source_info
*info
, int eol
, void *pdata
)
486 pa_threaded_mainloop
*loop
= pdata
;
494 pa_threaded_mainloop_signal(loop
, 0);
498 for(i
= 0;i
< numCaptureDevNames
;i
++)
500 if(strcmp(info
->name
, allCaptureDevNameMap
[i
].device_name
) == 0)
504 TRACE("Got device \"%s\", \"%s\"\n", info
->description
, info
->name
);
506 temp
= realloc(allCaptureDevNameMap
, (numCaptureDevNames
+1) * sizeof(*allCaptureDevNameMap
));
509 allCaptureDevNameMap
= temp
;
510 allCaptureDevNameMap
[numCaptureDevNames
].name
= strdup(info
->description
);
511 allCaptureDevNameMap
[numCaptureDevNames
].device_name
= strdup(info
->name
);
512 numCaptureDevNames
++;
516 static void sink_name_callback(pa_context
*context
, const pa_sink_info
*info
, int eol
, void *pdata
)
518 ALCdevice
*device
= pdata
;
519 pulse_data
*data
= device
->ExtraData
;
524 pa_threaded_mainloop_signal(data
->loop
, 0);
528 free(device
->szDeviceName
);
529 device
->szDeviceName
= strdup(info
->description
);
532 static void source_name_callback(pa_context
*context
, const pa_source_info
*info
, int eol
, void *pdata
)
534 ALCdevice
*device
= pdata
;
535 pulse_data
*data
= device
->ExtraData
;
540 pa_threaded_mainloop_signal(data
->loop
, 0);
544 free(device
->szDeviceName
);
545 device
->szDeviceName
= strdup(info
->description
);
549 static pa_context
*connect_context(pa_threaded_mainloop
*loop
, ALboolean silent
)
551 const char *name
= "OpenAL Soft";
552 char path_name
[PATH_MAX
];
553 pa_context_state_t state
;
557 if(pa_get_binary_name(path_name
, sizeof(path_name
)))
558 name
= pa_path_get_filename(path_name
);
560 context
= pa_context_new(pa_threaded_mainloop_get_api(loop
), name
);
563 ERR("pa_context_new() failed\n");
567 pa_context_set_state_callback(context
, context_state_callback
, loop
);
569 if((err
=pa_context_connect(context
, NULL
, pulse_ctx_flags
, NULL
)) >= 0)
571 while((state
=pa_context_get_state(context
)) != PA_CONTEXT_READY
)
573 if(!PA_CONTEXT_IS_GOOD(state
))
575 err
= pa_context_errno(context
);
576 if(err
> 0) err
= -err
;
580 pa_threaded_mainloop_wait(loop
);
583 pa_context_set_state_callback(context
, NULL
, NULL
);
588 ERR("Context did not connect: %s\n", pa_strerror(err
));
589 pa_context_unref(context
);
596 static pa_stream
*connect_playback_stream(const char *device_name
,
597 pa_threaded_mainloop
*loop
, pa_context
*context
,
598 pa_stream_flags_t flags
, pa_buffer_attr
*attr
, pa_sample_spec
*spec
,
599 pa_channel_map
*chanmap
)
601 pa_stream_state_t state
;
604 stream
= pa_stream_new_with_proplist(context
, "Playback Stream", spec
, chanmap
, prop_filter
);
607 ERR("pa_stream_new_with_proplist() failed: %s\n", pa_strerror(pa_context_errno(context
)));
611 pa_stream_set_state_callback(stream
, stream_state_callback
, loop
);
613 if(pa_stream_connect_playback(stream
, device_name
, attr
, flags
, NULL
, NULL
) < 0)
615 ERR("Stream did not connect: %s\n", pa_strerror(pa_context_errno(context
)));
616 pa_stream_unref(stream
);
620 while((state
=pa_stream_get_state(stream
)) != PA_STREAM_READY
)
622 if(!PA_STREAM_IS_GOOD(state
))
624 ERR("Stream did not get ready: %s\n", pa_strerror(pa_context_errno(context
)));
625 pa_stream_unref(stream
);
629 pa_threaded_mainloop_wait(loop
);
631 pa_stream_set_state_callback(stream
, NULL
, NULL
);
636 static pa_stream
*connect_record_stream(const char *device_name
,
637 pa_threaded_mainloop
*loop
, pa_context
*context
,
638 pa_stream_flags_t flags
, pa_buffer_attr
*attr
, pa_sample_spec
*spec
,
639 pa_channel_map
*chanmap
)
641 pa_stream_state_t state
;
644 stream
= pa_stream_new_with_proplist(context
, "Capture Stream", spec
, chanmap
, prop_filter
);
647 ERR("pa_stream_new_with_proplist() failed: %s\n", pa_strerror(pa_context_errno(context
)));
651 pa_stream_set_state_callback(stream
, stream_state_callback
, loop
);
653 if(pa_stream_connect_record(stream
, device_name
, attr
, flags
) < 0)
655 ERR("Stream did not connect: %s\n", pa_strerror(pa_context_errno(context
)));
656 pa_stream_unref(stream
);
660 while((state
=pa_stream_get_state(stream
)) != PA_STREAM_READY
)
662 if(!PA_STREAM_IS_GOOD(state
))
664 ERR("Stream did not get ready: %s\n", pa_strerror(pa_context_errno(context
)));
665 pa_stream_unref(stream
);
669 pa_threaded_mainloop_wait(loop
);
671 pa_stream_set_state_callback(stream
, NULL
, NULL
);
677 #define WAIT_FOR_OPERATION(x, l) do { \
678 pa_threaded_mainloop *_l = (l); \
679 pa_operation *_o = (x); \
681 while(pa_operation_get_state(_o) == PA_OPERATION_RUNNING) \
682 pa_threaded_mainloop_wait(_l); \
683 pa_operation_unref(_o); \
687 static void probe_devices(ALboolean capture
)
689 pa_threaded_mainloop
*loop
;
691 if(capture
== AL_FALSE
)
692 allDevNameMap
= malloc(sizeof(DevMap
) * 1);
694 allCaptureDevNameMap
= malloc(sizeof(DevMap
) * 1);
696 if((loop
=pa_threaded_mainloop_new()) &&
697 pa_threaded_mainloop_start(loop
) >= 0)
701 pa_threaded_mainloop_lock(loop
);
702 context
= connect_context(loop
, AL_FALSE
);
707 if(capture
== AL_FALSE
)
709 pa_stream_flags_t flags
;
713 flags
= PA_STREAM_FIX_FORMAT
| PA_STREAM_FIX_RATE
|
714 PA_STREAM_FIX_CHANNELS
| PA_STREAM_DONT_MOVE
;
716 spec
.format
= PA_SAMPLE_S16NE
;
720 stream
= connect_playback_stream(NULL
, loop
, context
, flags
,
724 o
= pa_context_get_sink_info_by_name(context
, pa_stream_get_device_name(stream
), sink_device_callback
, loop
);
725 WAIT_FOR_OPERATION(o
, loop
);
727 pa_stream_disconnect(stream
);
728 pa_stream_unref(stream
);
732 o
= pa_context_get_sink_info_list(context
, sink_device_callback
, loop
);
736 pa_stream_flags_t flags
;
740 flags
= PA_STREAM_FIX_FORMAT
| PA_STREAM_FIX_RATE
|
741 PA_STREAM_FIX_CHANNELS
| PA_STREAM_DONT_MOVE
;
743 spec
.format
= PA_SAMPLE_S16NE
;
747 stream
= connect_record_stream(NULL
, loop
, context
, flags
,
751 o
= pa_context_get_source_info_by_name(context
, pa_stream_get_device_name(stream
), source_device_callback
, loop
);
752 WAIT_FOR_OPERATION(o
, loop
);
754 pa_stream_disconnect(stream
);
755 pa_stream_unref(stream
);
759 o
= pa_context_get_source_info_list(context
, source_device_callback
, loop
);
761 WAIT_FOR_OPERATION(o
, loop
);
763 pa_context_disconnect(context
);
764 pa_context_unref(context
);
766 pa_threaded_mainloop_unlock(loop
);
767 pa_threaded_mainloop_stop(loop
);
770 pa_threaded_mainloop_free(loop
);
774 static ALuint
PulseProc(ALvoid
*param
)
776 ALCdevice
*Device
= param
;
777 pulse_data
*data
= Device
->ExtraData
;
785 pa_threaded_mainloop_lock(data
->loop
);
786 frame_size
= pa_frame_size(&data
->spec
);
787 update_size
= Device
->UpdateSize
* frame_size
;
789 /* Sanitize buffer metrics, in case we actually have less than what we
791 buffer_size
= minu(update_size
*Device
->NumUpdates
, data
->attr
.tlength
);
792 update_size
= minu(update_size
, buffer_size
/2);
794 len
= pa_stream_writable_size(data
->stream
) - data
->attr
.tlength
+
796 if(len
< update_size
)
798 if(pa_stream_is_corked(data
->stream
) == 1)
801 o
= pa_stream_cork(data
->stream
, 0, NULL
, NULL
);
802 if(o
) pa_operation_unref(o
);
804 pa_threaded_mainloop_unlock(data
->loop
);
806 pa_threaded_mainloop_lock(data
->loop
);
809 len
-= len
%update_size
;
815 pa_free_cb_t free_func
= NULL
;
817 #if PA_CHECK_VERSION(0,9,16)
818 if(!pa_stream_begin_write
||
819 pa_stream_begin_write(data
->stream
, &buf
, &newlen
) < 0)
822 buf
= pa_xmalloc(newlen
);
823 free_func
= pa_xfree
;
825 pa_threaded_mainloop_unlock(data
->loop
);
827 aluMixData(Device
, buf
, newlen
/frame_size
);
829 pa_threaded_mainloop_lock(data
->loop
);
830 pa_stream_write(data
->stream
, buf
, newlen
, free_func
, 0, PA_SEEK_RELATIVE
);
833 } while(!data
->killNow
&& Device
->Connected
);
834 pa_threaded_mainloop_unlock(data
->loop
);
840 static ALCboolean
pulse_open(ALCdevice
*device
)
842 pulse_data
*data
= pa_xmalloc(sizeof(pulse_data
));
843 memset(data
, 0, sizeof(*data
));
845 if(!(data
->loop
= pa_threaded_mainloop_new()))
847 ERR("pa_threaded_mainloop_new() failed!\n");
850 if(pa_threaded_mainloop_start(data
->loop
) < 0)
852 ERR("pa_threaded_mainloop_start() failed\n");
856 pa_threaded_mainloop_lock(data
->loop
);
857 device
->ExtraData
= data
;
859 data
->context
= connect_context(data
->loop
, AL_FALSE
);
862 pa_threaded_mainloop_unlock(data
->loop
);
865 pa_context_set_state_callback(data
->context
, context_state_callback2
, device
);
867 pa_threaded_mainloop_unlock(data
->loop
);
873 pa_threaded_mainloop_stop(data
->loop
);
874 pa_threaded_mainloop_free(data
->loop
);
877 device
->ExtraData
= NULL
;
882 static void pulse_close(ALCdevice
*device
)
884 pulse_data
*data
= device
->ExtraData
;
886 pa_threaded_mainloop_lock(data
->loop
);
890 #if PA_CHECK_VERSION(0,9,15)
891 if(pa_stream_set_buffer_attr_callback
)
892 pa_stream_set_buffer_attr_callback(data
->stream
, NULL
, NULL
);
894 pa_stream_disconnect(data
->stream
);
895 pa_stream_unref(data
->stream
);
898 pa_context_disconnect(data
->context
);
899 pa_context_unref(data
->context
);
901 pa_threaded_mainloop_unlock(data
->loop
);
903 pa_threaded_mainloop_stop(data
->loop
);
904 pa_threaded_mainloop_free(data
->loop
);
906 free(data
->device_name
);
908 device
->ExtraData
= NULL
;
913 static ALCenum
pulse_open_playback(ALCdevice
*device
, const ALCchar
*device_name
)
915 const char *pulse_name
= NULL
;
916 pa_stream_flags_t flags
;
926 probe_devices(AL_FALSE
);
928 for(i
= 0;i
< numDevNames
;i
++)
930 if(strcmp(device_name
, allDevNameMap
[i
].name
) == 0)
932 pulse_name
= allDevNameMap
[i
].device_name
;
937 return ALC_INVALID_VALUE
;
940 if(pulse_open(device
) == ALC_FALSE
)
941 return ALC_INVALID_VALUE
;
943 data
= device
->ExtraData
;
944 pa_threaded_mainloop_lock(data
->loop
);
946 flags
= PA_STREAM_FIX_FORMAT
| PA_STREAM_FIX_RATE
|
947 PA_STREAM_FIX_CHANNELS
| PA_STREAM_DONT_MOVE
;
949 spec
.format
= PA_SAMPLE_S16NE
;
953 data
->stream
= connect_playback_stream(pulse_name
, data
->loop
, data
->context
,
954 flags
, NULL
, &spec
, NULL
);
957 pa_threaded_mainloop_unlock(data
->loop
);
959 return ALC_INVALID_VALUE
;
962 data
->device_name
= strdup(pa_stream_get_device_name(data
->stream
));
963 o
= pa_context_get_sink_info_by_name(data
->context
, data
->device_name
,
964 sink_name_callback
, device
);
965 WAIT_FOR_OPERATION(o
, data
->loop
);
967 pa_threaded_mainloop_unlock(data
->loop
);
972 static void pulse_close_playback(ALCdevice
*device
)
977 static ALCboolean
pulse_reset_playback(ALCdevice
*device
)
979 pulse_data
*data
= device
->ExtraData
;
980 pa_stream_flags_t flags
= 0;
981 pa_channel_map chanmap
;
983 pa_threaded_mainloop_lock(data
->loop
);
987 #if PA_CHECK_VERSION(0,9,15)
988 if(pa_stream_set_buffer_attr_callback
)
989 pa_stream_set_buffer_attr_callback(data
->stream
, NULL
, NULL
);
991 pa_stream_disconnect(data
->stream
);
992 pa_stream_unref(data
->stream
);
996 if(!(device
->Flags
&DEVICE_CHANNELS_REQUEST
))
999 o
= pa_context_get_sink_info_by_name(data
->context
, data
->device_name
, sink_info_callback
, device
);
1000 WAIT_FOR_OPERATION(o
, data
->loop
);
1002 if(!(device
->Flags
&DEVICE_FREQUENCY_REQUEST
))
1003 flags
|= PA_STREAM_FIX_RATE
;
1005 flags
|= PA_STREAM_INTERPOLATE_TIMING
| PA_STREAM_AUTO_TIMING_UPDATE
;
1006 flags
|= PA_STREAM_ADJUST_LATENCY
;
1007 flags
|= PA_STREAM_START_CORKED
;
1008 flags
|= PA_STREAM_DONT_MOVE
;
1010 switch(device
->FmtType
)
1013 device
->FmtType
= DevFmtUByte
;
1016 data
->spec
.format
= PA_SAMPLE_U8
;
1019 device
->FmtType
= DevFmtShort
;
1022 data
->spec
.format
= PA_SAMPLE_S16NE
;
1025 device
->FmtType
= DevFmtInt
;
1028 data
->spec
.format
= PA_SAMPLE_S32NE
;
1031 data
->spec
.format
= PA_SAMPLE_FLOAT32NE
;
1034 data
->spec
.rate
= device
->Frequency
;
1035 data
->spec
.channels
= ChannelsFromDevFmt(device
->FmtChans
);
1037 if(pa_sample_spec_valid(&data
->spec
) == 0)
1039 ERR("Invalid sample format\n");
1040 pa_threaded_mainloop_unlock(data
->loop
);
1044 if(!pa_channel_map_init_auto(&chanmap
, data
->spec
.channels
, PA_CHANNEL_MAP_WAVEEX
))
1046 ERR("Couldn't build map for channel count (%d)!\n", data
->spec
.channels
);
1047 pa_threaded_mainloop_unlock(data
->loop
);
1050 SetDefaultWFXChannelOrder(device
);
1052 data
->attr
.fragsize
= -1;
1053 data
->attr
.prebuf
= 0;
1054 data
->attr
.minreq
= device
->UpdateSize
* pa_frame_size(&data
->spec
);
1055 data
->attr
.tlength
= data
->attr
.minreq
* maxu(device
->NumUpdates
, 2);
1056 data
->attr
.maxlength
= -1;
1058 data
->stream
= connect_playback_stream(data
->device_name
, data
->loop
,
1059 data
->context
, flags
, &data
->attr
,
1060 &data
->spec
, &chanmap
);
1063 pa_threaded_mainloop_unlock(data
->loop
);
1066 pa_stream_set_state_callback(data
->stream
, stream_state_callback2
, device
);
1068 data
->spec
= *(pa_stream_get_sample_spec(data
->stream
));
1069 if(device
->Frequency
!= data
->spec
.rate
)
1073 /* Server updated our playback rate, so modify the buffer attribs
1075 data
->attr
.minreq
= (ALuint64
)device
->UpdateSize
* data
->spec
.rate
/
1076 device
->Frequency
* pa_frame_size(&data
->spec
);
1077 data
->attr
.tlength
= data
->attr
.minreq
* maxu(device
->NumUpdates
, 2);
1078 data
->attr
.prebuf
= 0;
1080 o
= pa_stream_set_buffer_attr(data
->stream
, &data
->attr
,
1081 stream_success_callback
, device
);
1082 WAIT_FOR_OPERATION(o
, data
->loop
);
1084 device
->Frequency
= data
->spec
.rate
;
1087 #if PA_CHECK_VERSION(0,9,15)
1088 if(pa_stream_set_buffer_attr_callback
)
1089 pa_stream_set_buffer_attr_callback(data
->stream
, stream_buffer_attr_callback
, device
);
1091 stream_buffer_attr_callback(data
->stream
, device
);
1093 device
->NumUpdates
= device
->UpdateSize
*device
->NumUpdates
/
1094 (data
->attr
.minreq
/pa_frame_size(&data
->spec
));
1095 device
->NumUpdates
= maxu(device
->NumUpdates
, 2);
1096 device
->UpdateSize
= data
->attr
.minreq
/ pa_frame_size(&data
->spec
);
1098 pa_threaded_mainloop_unlock(data
->loop
);
1102 static ALCboolean
pulse_start_playback(ALCdevice
*device
)
1104 pulse_data
*data
= device
->ExtraData
;
1106 data
->thread
= StartThread(PulseProc
, device
);
1113 static void pulse_stop_playback(ALCdevice
*device
)
1115 pulse_data
*data
= device
->ExtraData
;
1121 data
->killNow
= AL_TRUE
;
1124 StopThread(data
->thread
);
1125 data
->thread
= NULL
;
1127 data
->killNow
= AL_FALSE
;
1129 pa_threaded_mainloop_lock(data
->loop
);
1131 o
= pa_stream_cork(data
->stream
, 1, stream_success_callback
, device
);
1132 WAIT_FOR_OPERATION(o
, data
->loop
);
1134 pa_threaded_mainloop_unlock(data
->loop
);
1138 static ALCenum
pulse_open_capture(ALCdevice
*device
, const ALCchar
*device_name
)
1140 const char *pulse_name
= NULL
;
1141 pa_stream_flags_t flags
= 0;
1142 pa_channel_map chanmap
;
1151 if(!allCaptureDevNameMap
)
1152 probe_devices(AL_TRUE
);
1154 for(i
= 0;i
< numCaptureDevNames
;i
++)
1156 if(strcmp(device_name
, allCaptureDevNameMap
[i
].name
) == 0)
1158 pulse_name
= allCaptureDevNameMap
[i
].device_name
;
1162 if(i
== numCaptureDevNames
)
1163 return ALC_INVALID_VALUE
;
1166 if(pulse_open(device
) == ALC_FALSE
)
1167 return ALC_INVALID_VALUE
;
1169 data
= device
->ExtraData
;
1170 pa_threaded_mainloop_lock(data
->loop
);
1172 data
->spec
.rate
= device
->Frequency
;
1173 data
->spec
.channels
= ChannelsFromDevFmt(device
->FmtChans
);
1175 switch(device
->FmtType
)
1178 data
->spec
.format
= PA_SAMPLE_U8
;
1181 data
->spec
.format
= PA_SAMPLE_S16NE
;
1184 data
->spec
.format
= PA_SAMPLE_S32NE
;
1187 data
->spec
.format
= PA_SAMPLE_FLOAT32NE
;
1192 ERR("%s capture samples not supported\n", DevFmtTypeString(device
->FmtType
));
1193 pa_threaded_mainloop_unlock(data
->loop
);
1197 if(pa_sample_spec_valid(&data
->spec
) == 0)
1199 ERR("Invalid sample format\n");
1200 pa_threaded_mainloop_unlock(data
->loop
);
1204 if(!pa_channel_map_init_auto(&chanmap
, data
->spec
.channels
, PA_CHANNEL_MAP_WAVEEX
))
1206 ERR("Couldn't build map for channel count (%d)!\n", data
->spec
.channels
);
1207 pa_threaded_mainloop_unlock(data
->loop
);
1211 samples
= device
->UpdateSize
* device
->NumUpdates
;
1212 samples
= maxu(samples
, 100 * device
->Frequency
/ 1000);
1214 data
->attr
.minreq
= -1;
1215 data
->attr
.prebuf
= -1;
1216 data
->attr
.maxlength
= samples
* pa_frame_size(&data
->spec
);
1217 data
->attr
.tlength
= -1;
1218 data
->attr
.fragsize
= minu(samples
, 50*device
->Frequency
/1000) *
1219 pa_frame_size(&data
->spec
);
1221 flags
|= PA_STREAM_DONT_MOVE
;
1222 flags
|= PA_STREAM_START_CORKED
|PA_STREAM_ADJUST_LATENCY
;
1223 data
->stream
= connect_record_stream(pulse_name
, data
->loop
, data
->context
,
1224 flags
, &data
->attr
, &data
->spec
,
1228 pa_threaded_mainloop_unlock(data
->loop
);
1231 pa_stream_set_state_callback(data
->stream
, stream_state_callback2
, device
);
1233 data
->device_name
= strdup(pa_stream_get_device_name(data
->stream
));
1234 o
= pa_context_get_source_info_by_name(data
->context
, data
->device_name
,
1235 source_name_callback
, device
);
1236 WAIT_FOR_OPERATION(o
, data
->loop
);
1238 pa_threaded_mainloop_unlock(data
->loop
);
1239 return ALC_NO_ERROR
;
1242 pulse_close(device
);
1243 return ALC_INVALID_VALUE
;
1246 static void pulse_close_capture(ALCdevice
*device
)
1248 pulse_close(device
);
1251 static void pulse_start_capture(ALCdevice
*device
)
1253 pulse_data
*data
= device
->ExtraData
;
1256 pa_threaded_mainloop_lock(data
->loop
);
1257 o
= pa_stream_cork(data
->stream
, 0, stream_success_callback
, device
);
1258 WAIT_FOR_OPERATION(o
, data
->loop
);
1259 pa_threaded_mainloop_unlock(data
->loop
);
1262 static void pulse_stop_capture(ALCdevice
*device
)
1264 pulse_data
*data
= device
->ExtraData
;
1267 pa_threaded_mainloop_lock(data
->loop
);
1268 o
= pa_stream_cork(data
->stream
, 1, stream_success_callback
, device
);
1269 WAIT_FOR_OPERATION(o
, data
->loop
);
1270 pa_threaded_mainloop_unlock(data
->loop
);
1273 static ALCenum
pulse_capture_samples(ALCdevice
*device
, ALCvoid
*buffer
, ALCuint samples
)
1275 pulse_data
*data
= device
->ExtraData
;
1276 ALCuint todo
= samples
* pa_frame_size(&data
->spec
);
1278 pa_threaded_mainloop_lock(data
->loop
);
1279 /* Capture is done in fragment-sized chunks, so we loop until we get all
1280 * that's available */
1281 data
->last_readable
-= todo
;
1286 if(data
->cap_len
== 0)
1288 pa_stream_state_t state
;
1290 state
= pa_stream_get_state(data
->stream
);
1291 if(!PA_STREAM_IS_GOOD(state
))
1293 aluHandleDisconnect(device
);
1296 if(pa_stream_peek(data
->stream
, &data
->cap_store
, &data
->cap_len
) < 0)
1298 ERR("pa_stream_peek() failed: %s\n",
1299 pa_strerror(pa_context_errno(data
->context
)));
1300 aluHandleDisconnect(device
);
1303 data
->cap_remain
= data
->cap_len
;
1305 if(rem
> data
->cap_remain
)
1306 rem
= data
->cap_remain
;
1308 memcpy(buffer
, data
->cap_store
, rem
);
1310 buffer
= (ALbyte
*)buffer
+ rem
;
1313 data
->cap_store
= (ALbyte
*)data
->cap_store
+ rem
;
1314 data
->cap_remain
-= rem
;
1315 if(data
->cap_remain
== 0)
1317 pa_stream_drop(data
->stream
);
1322 memset(buffer
, ((device
->FmtType
==DevFmtUByte
) ? 0x80 : 0), todo
);
1323 pa_threaded_mainloop_unlock(data
->loop
);
1325 return ALC_NO_ERROR
;
1328 static ALCuint
pulse_available_samples(ALCdevice
*device
)
1330 pulse_data
*data
= device
->ExtraData
;
1331 size_t readable
= data
->cap_remain
;
1333 pa_threaded_mainloop_lock(data
->loop
);
1334 if(device
->Connected
)
1336 ssize_t got
= pa_stream_readable_size(data
->stream
);
1339 ERR("pa_stream_readable_size() failed: %s\n", pa_strerror(got
));
1340 aluHandleDisconnect(device
);
1342 else if((size_t)got
> data
->cap_len
)
1343 readable
+= got
- data
->cap_len
;
1345 pa_threaded_mainloop_unlock(data
->loop
);
1347 if(data
->last_readable
< readable
)
1348 data
->last_readable
= readable
;
1349 return data
->last_readable
/ pa_frame_size(&data
->spec
);
1353 static const BackendFuncs pulse_funcs
= {
1354 pulse_open_playback
,
1355 pulse_close_playback
,
1356 pulse_reset_playback
,
1357 pulse_start_playback
,
1358 pulse_stop_playback
,
1360 pulse_close_capture
,
1361 pulse_start_capture
,
1363 pulse_capture_samples
,
1364 pulse_available_samples
1367 ALCboolean
alc_pulse_init(BackendFuncs
*func_list
)
1369 ALCboolean ret
= ALC_FALSE
;
1373 pa_threaded_mainloop
*loop
;
1375 pulse_ctx_flags
= 0;
1376 if(!GetConfigValueBool("pulse", "spawn-server", 0))
1377 pulse_ctx_flags
|= PA_CONTEXT_NOAUTOSPAWN
;
1379 if((loop
=pa_threaded_mainloop_new()) &&
1380 pa_threaded_mainloop_start(loop
) >= 0)
1382 pa_context
*context
;
1384 pa_threaded_mainloop_lock(loop
);
1385 context
= connect_context(loop
, AL_TRUE
);
1388 *func_list
= pulse_funcs
;
1391 prop_filter
= pa_proplist_new();
1392 pa_proplist_set(prop_filter
, PA_PROP_MEDIA_ROLE
, NULL
, 0);
1393 pa_proplist_set(prop_filter
, "phonon.streamid", NULL
, 0);
1395 pa_context_disconnect(context
);
1396 pa_context_unref(context
);
1398 pa_threaded_mainloop_unlock(loop
);
1399 pa_threaded_mainloop_stop(loop
);
1402 pa_threaded_mainloop_free(loop
);
1408 void alc_pulse_deinit(void)
1412 for(i
= 0;i
< numDevNames
;++i
)
1414 free(allDevNameMap
[i
].name
);
1415 free(allDevNameMap
[i
].device_name
);
1417 free(allDevNameMap
);
1418 allDevNameMap
= NULL
;
1421 for(i
= 0;i
< numCaptureDevNames
;++i
)
1423 free(allCaptureDevNameMap
[i
].name
);
1424 free(allCaptureDevNameMap
[i
].device_name
);
1426 free(allCaptureDevNameMap
);
1427 allCaptureDevNameMap
= NULL
;
1428 numCaptureDevNames
= 0;
1431 pa_proplist_free(prop_filter
);
1434 /* PulseAudio doesn't like being CloseLib'd sometimes */
1437 void alc_pulse_probe(enum DevProbe type
)
1443 case ALL_DEVICE_PROBE
:
1444 for(i
= 0;i
< numDevNames
;++i
)
1446 free(allDevNameMap
[i
].name
);
1447 free(allDevNameMap
[i
].device_name
);
1449 free(allDevNameMap
);
1450 allDevNameMap
= NULL
;
1453 probe_devices(AL_FALSE
);
1455 for(i
= 0;i
< numDevNames
;i
++)
1456 AppendAllDeviceList(allDevNameMap
[i
].name
);
1459 case CAPTURE_DEVICE_PROBE
:
1460 for(i
= 0;i
< numCaptureDevNames
;++i
)
1462 free(allCaptureDevNameMap
[i
].name
);
1463 free(allCaptureDevNameMap
[i
].device_name
);
1465 free(allCaptureDevNameMap
);
1466 allCaptureDevNameMap
= NULL
;
1467 numCaptureDevNames
= 0;
1469 probe_devices(AL_TRUE
);
1471 for(i
= 0;i
< numCaptureDevNames
;i
++)
1472 AppendCaptureDeviceList(allCaptureDevNameMap
[i
].name
);
1479 #warning "Unsupported API version, backend will be unavailable!"
1481 ALCboolean
alc_pulse_init(BackendFuncs
*func_list
)
1482 { return ALC_FALSE
; (void)func_list
; }
1484 void alc_pulse_deinit(void)
1487 void alc_pulse_probe(enum DevProbe type
)