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 == 12
33 #ifndef PA_CHECK_VERSION
34 #define PA_CHECK_VERSION(major,minor,micro) \
35 ((PA_MAJOR > (major)) || \
36 (PA_MAJOR == (major) && PA_MINOR > (minor)) || \
37 (PA_MAJOR == (major) && PA_MINOR == (minor) && PA_MICRO >= (micro)))
41 static void *pa_handle
;
42 #define MAKE_FUNC(x) static typeof(x) * p##x
43 MAKE_FUNC(pa_context_unref
);
44 MAKE_FUNC(pa_sample_spec_valid
);
45 MAKE_FUNC(pa_frame_size
);
46 MAKE_FUNC(pa_stream_drop
);
47 MAKE_FUNC(pa_strerror
);
48 MAKE_FUNC(pa_context_get_state
);
49 MAKE_FUNC(pa_stream_get_state
);
50 MAKE_FUNC(pa_threaded_mainloop_signal
);
51 MAKE_FUNC(pa_stream_peek
);
52 MAKE_FUNC(pa_threaded_mainloop_wait
);
53 MAKE_FUNC(pa_threaded_mainloop_unlock
);
54 MAKE_FUNC(pa_threaded_mainloop_in_thread
);
55 MAKE_FUNC(pa_context_new
);
56 MAKE_FUNC(pa_threaded_mainloop_stop
);
57 MAKE_FUNC(pa_context_disconnect
);
58 MAKE_FUNC(pa_threaded_mainloop_start
);
59 MAKE_FUNC(pa_threaded_mainloop_get_api
);
60 MAKE_FUNC(pa_context_set_state_callback
);
61 MAKE_FUNC(pa_stream_write
);
63 MAKE_FUNC(pa_stream_connect_record
);
64 MAKE_FUNC(pa_stream_connect_playback
);
65 MAKE_FUNC(pa_stream_readable_size
);
66 MAKE_FUNC(pa_stream_writable_size
);
67 MAKE_FUNC(pa_stream_is_corked
);
68 MAKE_FUNC(pa_stream_cork
);
69 MAKE_FUNC(pa_stream_is_suspended
);
70 MAKE_FUNC(pa_stream_get_device_name
);
71 MAKE_FUNC(pa_stream_get_latency
);
72 MAKE_FUNC(pa_path_get_filename
);
73 MAKE_FUNC(pa_get_binary_name
);
74 MAKE_FUNC(pa_threaded_mainloop_free
);
75 MAKE_FUNC(pa_context_errno
);
76 MAKE_FUNC(pa_xmalloc
);
77 MAKE_FUNC(pa_stream_unref
);
78 MAKE_FUNC(pa_threaded_mainloop_accept
);
79 MAKE_FUNC(pa_stream_set_write_callback
);
80 MAKE_FUNC(pa_threaded_mainloop_new
);
81 MAKE_FUNC(pa_context_connect
);
82 MAKE_FUNC(pa_stream_set_buffer_attr
);
83 MAKE_FUNC(pa_stream_get_buffer_attr
);
84 MAKE_FUNC(pa_stream_get_sample_spec
);
85 MAKE_FUNC(pa_stream_get_time
);
86 MAKE_FUNC(pa_stream_set_read_callback
);
87 MAKE_FUNC(pa_stream_set_state_callback
);
88 MAKE_FUNC(pa_stream_set_moved_callback
);
89 MAKE_FUNC(pa_stream_set_underflow_callback
);
90 MAKE_FUNC(pa_stream_new_with_proplist
);
91 MAKE_FUNC(pa_stream_disconnect
);
92 MAKE_FUNC(pa_threaded_mainloop_lock
);
93 MAKE_FUNC(pa_channel_map_init_auto
);
94 MAKE_FUNC(pa_channel_map_parse
);
95 MAKE_FUNC(pa_channel_map_snprint
);
96 MAKE_FUNC(pa_channel_map_equal
);
97 MAKE_FUNC(pa_context_get_server_info
);
98 MAKE_FUNC(pa_context_get_sink_info_by_name
);
99 MAKE_FUNC(pa_context_get_sink_info_list
);
100 MAKE_FUNC(pa_context_get_source_info_by_name
);
101 MAKE_FUNC(pa_context_get_source_info_list
);
102 MAKE_FUNC(pa_operation_get_state
);
103 MAKE_FUNC(pa_operation_unref
);
104 MAKE_FUNC(pa_proplist_new
);
105 MAKE_FUNC(pa_proplist_free
);
106 MAKE_FUNC(pa_proplist_set
);
107 #if PA_CHECK_VERSION(0,9,15)
108 MAKE_FUNC(pa_channel_map_superset
);
109 MAKE_FUNC(pa_stream_set_buffer_attr_callback
);
111 #if PA_CHECK_VERSION(0,9,16)
112 MAKE_FUNC(pa_stream_begin_write
);
116 #define pa_context_unref ppa_context_unref
117 #define pa_sample_spec_valid ppa_sample_spec_valid
118 #define pa_frame_size ppa_frame_size
119 #define pa_stream_drop ppa_stream_drop
120 #define pa_strerror ppa_strerror
121 #define pa_context_get_state ppa_context_get_state
122 #define pa_stream_get_state ppa_stream_get_state
123 #define pa_threaded_mainloop_signal ppa_threaded_mainloop_signal
124 #define pa_stream_peek ppa_stream_peek
125 #define pa_threaded_mainloop_wait ppa_threaded_mainloop_wait
126 #define pa_threaded_mainloop_unlock ppa_threaded_mainloop_unlock
127 #define pa_threaded_mainloop_in_thread ppa_threaded_mainloop_in_thread
128 #define pa_context_new ppa_context_new
129 #define pa_threaded_mainloop_stop ppa_threaded_mainloop_stop
130 #define pa_context_disconnect ppa_context_disconnect
131 #define pa_threaded_mainloop_start ppa_threaded_mainloop_start
132 #define pa_threaded_mainloop_get_api ppa_threaded_mainloop_get_api
133 #define pa_context_set_state_callback ppa_context_set_state_callback
134 #define pa_stream_write ppa_stream_write
135 #define pa_xfree ppa_xfree
136 #define pa_stream_connect_record ppa_stream_connect_record
137 #define pa_stream_connect_playback ppa_stream_connect_playback
138 #define pa_stream_readable_size ppa_stream_readable_size
139 #define pa_stream_writable_size ppa_stream_writable_size
140 #define pa_stream_is_corked ppa_stream_is_corked
141 #define pa_stream_cork ppa_stream_cork
142 #define pa_stream_is_suspended ppa_stream_is_suspended
143 #define pa_stream_get_device_name ppa_stream_get_device_name
144 #define pa_stream_get_latency ppa_stream_get_latency
145 #define pa_path_get_filename ppa_path_get_filename
146 #define pa_get_binary_name ppa_get_binary_name
147 #define pa_threaded_mainloop_free ppa_threaded_mainloop_free
148 #define pa_context_errno ppa_context_errno
149 #define pa_xmalloc ppa_xmalloc
150 #define pa_stream_unref ppa_stream_unref
151 #define pa_threaded_mainloop_accept ppa_threaded_mainloop_accept
152 #define pa_stream_set_write_callback ppa_stream_set_write_callback
153 #define pa_threaded_mainloop_new ppa_threaded_mainloop_new
154 #define pa_context_connect ppa_context_connect
155 #define pa_stream_set_buffer_attr ppa_stream_set_buffer_attr
156 #define pa_stream_get_buffer_attr ppa_stream_get_buffer_attr
157 #define pa_stream_get_sample_spec ppa_stream_get_sample_spec
158 #define pa_stream_get_time ppa_stream_get_time
159 #define pa_stream_set_read_callback ppa_stream_set_read_callback
160 #define pa_stream_set_state_callback ppa_stream_set_state_callback
161 #define pa_stream_set_moved_callback ppa_stream_set_moved_callback
162 #define pa_stream_set_underflow_callback ppa_stream_set_underflow_callback
163 #define pa_stream_new_with_proplist ppa_stream_new_with_proplist
164 #define pa_stream_disconnect ppa_stream_disconnect
165 #define pa_threaded_mainloop_lock ppa_threaded_mainloop_lock
166 #define pa_channel_map_init_auto ppa_channel_map_init_auto
167 #define pa_channel_map_parse ppa_channel_map_parse
168 #define pa_channel_map_snprint ppa_channel_map_snprint
169 #define pa_channel_map_equal ppa_channel_map_equal
170 #define pa_context_get_server_info ppa_context_get_server_info
171 #define pa_context_get_sink_info_by_name ppa_context_get_sink_info_by_name
172 #define pa_context_get_sink_info_list ppa_context_get_sink_info_list
173 #define pa_context_get_source_info_by_name ppa_context_get_source_info_by_name
174 #define pa_context_get_source_info_list ppa_context_get_source_info_list
175 #define pa_operation_get_state ppa_operation_get_state
176 #define pa_operation_unref ppa_operation_unref
177 #define pa_proplist_new ppa_proplist_new
178 #define pa_proplist_free ppa_proplist_free
179 #define pa_proplist_set ppa_proplist_set
180 #if PA_CHECK_VERSION(0,9,15)
181 #define pa_channel_map_superset ppa_channel_map_superset
182 #define pa_stream_set_buffer_attr_callback ppa_stream_set_buffer_attr_callback
184 #if PA_CHECK_VERSION(0,9,16)
185 #define pa_stream_begin_write ppa_stream_begin_write
191 #define PATH_MAX 4096
197 const void *cap_store
;
201 ALCuint last_readable
;
206 pa_threaded_mainloop
*loop
;
209 volatile ALboolean killNow
;
221 static DevMap
*allDevNameMap
;
222 static ALuint numDevNames
;
223 static DevMap
*allCaptureDevNameMap
;
224 static ALuint numCaptureDevNames
;
225 static pa_context_flags_t pulse_ctx_flags
;
226 static pa_proplist
*prop_filter
;
229 static ALCboolean
pulse_load(void)
231 ALCboolean ret
= ALC_TRUE
;
236 #define PALIB "libpulse-0.dll"
237 #elif defined(__APPLE__) && defined(__MACH__)
238 #define PALIB "libpulse.0.dylib"
240 #define PALIB "libpulse.so.0"
242 pa_handle
= LoadLib(PALIB
);
246 #define LOAD_FUNC(x) do { \
247 p##x = GetSymbol(pa_handle, #x); \
252 LOAD_FUNC(pa_context_unref
);
253 LOAD_FUNC(pa_sample_spec_valid
);
254 LOAD_FUNC(pa_stream_drop
);
255 LOAD_FUNC(pa_frame_size
);
256 LOAD_FUNC(pa_strerror
);
257 LOAD_FUNC(pa_context_get_state
);
258 LOAD_FUNC(pa_stream_get_state
);
259 LOAD_FUNC(pa_threaded_mainloop_signal
);
260 LOAD_FUNC(pa_stream_peek
);
261 LOAD_FUNC(pa_threaded_mainloop_wait
);
262 LOAD_FUNC(pa_threaded_mainloop_unlock
);
263 LOAD_FUNC(pa_threaded_mainloop_in_thread
);
264 LOAD_FUNC(pa_context_new
);
265 LOAD_FUNC(pa_threaded_mainloop_stop
);
266 LOAD_FUNC(pa_context_disconnect
);
267 LOAD_FUNC(pa_threaded_mainloop_start
);
268 LOAD_FUNC(pa_threaded_mainloop_get_api
);
269 LOAD_FUNC(pa_context_set_state_callback
);
270 LOAD_FUNC(pa_stream_write
);
272 LOAD_FUNC(pa_stream_connect_record
);
273 LOAD_FUNC(pa_stream_connect_playback
);
274 LOAD_FUNC(pa_stream_readable_size
);
275 LOAD_FUNC(pa_stream_writable_size
);
276 LOAD_FUNC(pa_stream_is_corked
);
277 LOAD_FUNC(pa_stream_cork
);
278 LOAD_FUNC(pa_stream_is_suspended
);
279 LOAD_FUNC(pa_stream_get_device_name
);
280 LOAD_FUNC(pa_stream_get_latency
);
281 LOAD_FUNC(pa_path_get_filename
);
282 LOAD_FUNC(pa_get_binary_name
);
283 LOAD_FUNC(pa_threaded_mainloop_free
);
284 LOAD_FUNC(pa_context_errno
);
285 LOAD_FUNC(pa_xmalloc
);
286 LOAD_FUNC(pa_stream_unref
);
287 LOAD_FUNC(pa_threaded_mainloop_accept
);
288 LOAD_FUNC(pa_stream_set_write_callback
);
289 LOAD_FUNC(pa_threaded_mainloop_new
);
290 LOAD_FUNC(pa_context_connect
);
291 LOAD_FUNC(pa_stream_set_buffer_attr
);
292 LOAD_FUNC(pa_stream_get_buffer_attr
);
293 LOAD_FUNC(pa_stream_get_sample_spec
);
294 LOAD_FUNC(pa_stream_get_time
);
295 LOAD_FUNC(pa_stream_set_read_callback
);
296 LOAD_FUNC(pa_stream_set_state_callback
);
297 LOAD_FUNC(pa_stream_set_moved_callback
);
298 LOAD_FUNC(pa_stream_set_underflow_callback
);
299 LOAD_FUNC(pa_stream_new_with_proplist
);
300 LOAD_FUNC(pa_stream_disconnect
);
301 LOAD_FUNC(pa_threaded_mainloop_lock
);
302 LOAD_FUNC(pa_channel_map_init_auto
);
303 LOAD_FUNC(pa_channel_map_parse
);
304 LOAD_FUNC(pa_channel_map_snprint
);
305 LOAD_FUNC(pa_channel_map_equal
);
306 LOAD_FUNC(pa_context_get_server_info
);
307 LOAD_FUNC(pa_context_get_sink_info_by_name
);
308 LOAD_FUNC(pa_context_get_sink_info_list
);
309 LOAD_FUNC(pa_context_get_source_info_by_name
);
310 LOAD_FUNC(pa_context_get_source_info_list
);
311 LOAD_FUNC(pa_operation_get_state
);
312 LOAD_FUNC(pa_operation_unref
);
313 LOAD_FUNC(pa_proplist_new
);
314 LOAD_FUNC(pa_proplist_free
);
315 LOAD_FUNC(pa_proplist_set
);
317 #define LOAD_OPTIONAL_FUNC(x) do { \
318 p##x = GetSymbol(pa_handle, #x); \
320 #if PA_CHECK_VERSION(0,9,15)
321 LOAD_OPTIONAL_FUNC(pa_channel_map_superset
);
322 LOAD_OPTIONAL_FUNC(pa_stream_set_buffer_attr_callback
);
324 #if PA_CHECK_VERSION(0,9,16)
325 LOAD_OPTIONAL_FUNC(pa_stream_begin_write
);
327 #undef LOAD_OPTIONAL_FUNC
335 #endif /* HAVE_DYNLOAD */
339 /* PulseAudio Event Callbacks */
340 static void context_state_callback(pa_context
*context
, void *pdata
)
342 pa_threaded_mainloop
*loop
= pdata
;
343 pa_context_state_t state
;
345 state
= pa_context_get_state(context
);
346 if(state
== PA_CONTEXT_READY
|| !PA_CONTEXT_IS_GOOD(state
))
347 pa_threaded_mainloop_signal(loop
, 0);
350 static void stream_state_callback(pa_stream
*stream
, void *pdata
)
352 pa_threaded_mainloop
*loop
= pdata
;
353 pa_stream_state_t state
;
355 state
= pa_stream_get_state(stream
);
356 if(state
== PA_STREAM_READY
|| !PA_STREAM_IS_GOOD(state
))
357 pa_threaded_mainloop_signal(loop
, 0);
360 static void stream_buffer_attr_callback(pa_stream
*stream
, void *pdata
)
362 ALCdevice
*device
= pdata
;
363 pulse_data
*data
= device
->ExtraData
;
365 data
->attr
= *pa_stream_get_buffer_attr(stream
);
366 TRACE("minreq=%d, tlength=%d, prebuf=%d\n", data
->attr
.minreq
, data
->attr
.tlength
, data
->attr
.prebuf
);
369 static void context_state_callback2(pa_context
*context
, void *pdata
)
371 ALCdevice
*Device
= pdata
;
372 pulse_data
*data
= Device
->ExtraData
;
374 if(pa_context_get_state(context
) == PA_CONTEXT_FAILED
)
376 ERR("Received context failure!\n");
377 aluHandleDisconnect(Device
);
379 pa_threaded_mainloop_signal(data
->loop
, 0);
382 static void stream_state_callback2(pa_stream
*stream
, void *pdata
)
384 ALCdevice
*Device
= pdata
;
385 pulse_data
*data
= Device
->ExtraData
;
387 if(pa_stream_get_state(stream
) == PA_STREAM_FAILED
)
389 ERR("Received stream failure!\n");
390 aluHandleDisconnect(Device
);
392 pa_threaded_mainloop_signal(data
->loop
, 0);
395 static void stream_success_callback(pa_stream
*stream
, int success
, void *pdata
)
397 ALCdevice
*Device
= pdata
;
398 pulse_data
*data
= Device
->ExtraData
;
402 pa_threaded_mainloop_signal(data
->loop
, 0);
405 static void sink_info_callback(pa_context
*context
, const pa_sink_info
*info
, int eol
, void *pdata
)
407 ALCdevice
*device
= pdata
;
408 pulse_data
*data
= device
->ExtraData
;
409 char chanmap_str
[256] = "";
412 enum DevFmtChannels chans
;
414 { "front-left,front-right,front-center,lfe,rear-left,rear-right,side-left,side-right",
416 { "front-left,front-right,front-center,lfe,rear-center,side-left,side-right",
418 { "front-left,front-right,front-center,lfe,rear-left,rear-right",
420 { "front-left,front-right,front-center,lfe,side-left,side-right",
422 { "front-left,front-right,rear-left,rear-right", DevFmtQuad
},
423 { "front-left,front-right", DevFmtStereo
},
424 { "mono", DevFmtMono
},
432 pa_threaded_mainloop_signal(data
->loop
, 0);
436 for(i
= 0;chanmaps
[i
].str
;i
++)
439 if(!pa_channel_map_parse(&map
, chanmaps
[i
].str
))
442 if(pa_channel_map_equal(&info
->channel_map
, &map
)
443 #if PA_CHECK_VERSION(0,9,15)
444 || (pa_channel_map_superset
&&
445 pa_channel_map_superset(&info
->channel_map
, &map
))
449 device
->FmtChans
= chanmaps
[i
].chans
;
454 pa_channel_map_snprint(chanmap_str
, sizeof(chanmap_str
), &info
->channel_map
);
455 ERR("Failed to find format for channel map:\n %s\n", chanmap_str
);
458 static void sink_device_callback(pa_context
*context
, const pa_sink_info
*info
, int eol
, void *pdata
)
460 pa_threaded_mainloop
*loop
= pdata
;
468 pa_threaded_mainloop_signal(loop
, 0);
472 for(i
= 0;i
< numDevNames
;i
++)
474 if(strcmp(info
->name
, allDevNameMap
[i
].device_name
) == 0)
478 TRACE("Got device \"%s\", \"%s\"\n", info
->description
, info
->name
);
480 temp
= realloc(allDevNameMap
, (numDevNames
+1) * sizeof(*allDevNameMap
));
483 allDevNameMap
= temp
;
484 allDevNameMap
[numDevNames
].name
= strdup(info
->description
);
485 allDevNameMap
[numDevNames
].device_name
= strdup(info
->name
);
490 static void source_device_callback(pa_context
*context
, const pa_source_info
*info
, int eol
, void *pdata
)
492 pa_threaded_mainloop
*loop
= pdata
;
500 pa_threaded_mainloop_signal(loop
, 0);
504 for(i
= 0;i
< numCaptureDevNames
;i
++)
506 if(strcmp(info
->name
, allCaptureDevNameMap
[i
].device_name
) == 0)
510 TRACE("Got device \"%s\", \"%s\"\n", info
->description
, info
->name
);
512 temp
= realloc(allCaptureDevNameMap
, (numCaptureDevNames
+1) * sizeof(*allCaptureDevNameMap
));
515 allCaptureDevNameMap
= temp
;
516 allCaptureDevNameMap
[numCaptureDevNames
].name
= strdup(info
->description
);
517 allCaptureDevNameMap
[numCaptureDevNames
].device_name
= strdup(info
->name
);
518 numCaptureDevNames
++;
522 static void sink_name_callback(pa_context
*context
, const pa_sink_info
*info
, int eol
, void *pdata
)
524 ALCdevice
*device
= pdata
;
525 pulse_data
*data
= device
->ExtraData
;
530 pa_threaded_mainloop_signal(data
->loop
, 0);
534 free(device
->DeviceName
);
535 device
->DeviceName
= strdup(info
->description
);
538 static void source_name_callback(pa_context
*context
, const pa_source_info
*info
, int eol
, void *pdata
)
540 ALCdevice
*device
= pdata
;
541 pulse_data
*data
= device
->ExtraData
;
546 pa_threaded_mainloop_signal(data
->loop
, 0);
550 free(device
->DeviceName
);
551 device
->DeviceName
= strdup(info
->description
);
555 static void stream_moved_callback(pa_stream
*stream
, void *pdata
)
557 ALCdevice
*device
= pdata
;
558 pulse_data
*data
= device
->ExtraData
;
561 free(data
->device_name
);
562 data
->device_name
= strdup(pa_stream_get_device_name(data
->stream
));
564 TRACE("Stream moved to %s\n", data
->device_name
);
568 static pa_context
*connect_context(pa_threaded_mainloop
*loop
, ALboolean silent
)
570 const char *name
= "OpenAL Soft";
571 char path_name
[PATH_MAX
];
572 pa_context_state_t state
;
576 if(pa_get_binary_name(path_name
, sizeof(path_name
)))
577 name
= pa_path_get_filename(path_name
);
579 context
= pa_context_new(pa_threaded_mainloop_get_api(loop
), name
);
582 ERR("pa_context_new() failed\n");
586 pa_context_set_state_callback(context
, context_state_callback
, loop
);
588 if((err
=pa_context_connect(context
, NULL
, pulse_ctx_flags
, NULL
)) >= 0)
590 while((state
=pa_context_get_state(context
)) != PA_CONTEXT_READY
)
592 if(!PA_CONTEXT_IS_GOOD(state
))
594 err
= pa_context_errno(context
);
595 if(err
> 0) err
= -err
;
599 pa_threaded_mainloop_wait(loop
);
602 pa_context_set_state_callback(context
, NULL
, NULL
);
607 ERR("Context did not connect: %s\n", pa_strerror(err
));
608 pa_context_unref(context
);
615 static pa_stream
*connect_playback_stream(const char *device_name
,
616 pa_threaded_mainloop
*loop
, pa_context
*context
,
617 pa_stream_flags_t flags
, pa_buffer_attr
*attr
, pa_sample_spec
*spec
,
618 pa_channel_map
*chanmap
)
620 pa_stream_state_t state
;
623 stream
= pa_stream_new_with_proplist(context
, "Playback Stream", spec
, chanmap
, prop_filter
);
626 ERR("pa_stream_new_with_proplist() failed: %s\n", pa_strerror(pa_context_errno(context
)));
630 pa_stream_set_state_callback(stream
, stream_state_callback
, loop
);
632 if(pa_stream_connect_playback(stream
, device_name
, attr
, flags
, NULL
, NULL
) < 0)
634 ERR("Stream did not connect: %s\n", pa_strerror(pa_context_errno(context
)));
635 pa_stream_unref(stream
);
639 while((state
=pa_stream_get_state(stream
)) != PA_STREAM_READY
)
641 if(!PA_STREAM_IS_GOOD(state
))
643 ERR("Stream did not get ready: %s\n", pa_strerror(pa_context_errno(context
)));
644 pa_stream_unref(stream
);
648 pa_threaded_mainloop_wait(loop
);
650 pa_stream_set_state_callback(stream
, NULL
, NULL
);
655 static pa_stream
*connect_record_stream(const char *device_name
,
656 pa_threaded_mainloop
*loop
, pa_context
*context
,
657 pa_stream_flags_t flags
, pa_buffer_attr
*attr
, pa_sample_spec
*spec
,
658 pa_channel_map
*chanmap
)
660 pa_stream_state_t state
;
663 stream
= pa_stream_new_with_proplist(context
, "Capture Stream", spec
, chanmap
, prop_filter
);
666 ERR("pa_stream_new_with_proplist() failed: %s\n", pa_strerror(pa_context_errno(context
)));
670 pa_stream_set_state_callback(stream
, stream_state_callback
, loop
);
672 if(pa_stream_connect_record(stream
, device_name
, attr
, flags
) < 0)
674 ERR("Stream did not connect: %s\n", pa_strerror(pa_context_errno(context
)));
675 pa_stream_unref(stream
);
679 while((state
=pa_stream_get_state(stream
)) != PA_STREAM_READY
)
681 if(!PA_STREAM_IS_GOOD(state
))
683 ERR("Stream did not get ready: %s\n", pa_strerror(pa_context_errno(context
)));
684 pa_stream_unref(stream
);
688 pa_threaded_mainloop_wait(loop
);
690 pa_stream_set_state_callback(stream
, NULL
, NULL
);
696 static void wait_for_operation(pa_operation
*op
, pa_threaded_mainloop
*loop
)
700 while(pa_operation_get_state(op
) == PA_OPERATION_RUNNING
)
701 pa_threaded_mainloop_wait(loop
);
702 pa_operation_unref(op
);
707 static void probe_devices(ALboolean capture
)
709 pa_threaded_mainloop
*loop
;
711 if(capture
== AL_FALSE
)
712 allDevNameMap
= malloc(sizeof(DevMap
) * 1);
714 allCaptureDevNameMap
= malloc(sizeof(DevMap
) * 1);
716 if((loop
=pa_threaded_mainloop_new()) &&
717 pa_threaded_mainloop_start(loop
) >= 0)
721 pa_threaded_mainloop_lock(loop
);
722 context
= connect_context(loop
, AL_FALSE
);
727 if(capture
== AL_FALSE
)
729 pa_stream_flags_t flags
;
733 flags
= PA_STREAM_FIX_FORMAT
| PA_STREAM_FIX_RATE
|
734 PA_STREAM_FIX_CHANNELS
| PA_STREAM_DONT_MOVE
;
736 spec
.format
= PA_SAMPLE_S16NE
;
740 stream
= connect_playback_stream(NULL
, loop
, context
, flags
,
744 o
= pa_context_get_sink_info_by_name(context
, pa_stream_get_device_name(stream
), sink_device_callback
, loop
);
745 wait_for_operation(o
, loop
);
747 pa_stream_disconnect(stream
);
748 pa_stream_unref(stream
);
752 o
= pa_context_get_sink_info_list(context
, sink_device_callback
, loop
);
756 pa_stream_flags_t flags
;
760 flags
= PA_STREAM_FIX_FORMAT
| PA_STREAM_FIX_RATE
|
761 PA_STREAM_FIX_CHANNELS
| PA_STREAM_DONT_MOVE
;
763 spec
.format
= PA_SAMPLE_S16NE
;
767 stream
= connect_record_stream(NULL
, loop
, context
, flags
,
771 o
= pa_context_get_source_info_by_name(context
, pa_stream_get_device_name(stream
), source_device_callback
, loop
);
772 wait_for_operation(o
, loop
);
774 pa_stream_disconnect(stream
);
775 pa_stream_unref(stream
);
779 o
= pa_context_get_source_info_list(context
, source_device_callback
, loop
);
781 wait_for_operation(o
, loop
);
783 pa_context_disconnect(context
);
784 pa_context_unref(context
);
786 pa_threaded_mainloop_unlock(loop
);
787 pa_threaded_mainloop_stop(loop
);
790 pa_threaded_mainloop_free(loop
);
794 static ALuint
PulseProc(ALvoid
*param
)
796 ALCdevice
*Device
= param
;
797 pulse_data
*data
= Device
->ExtraData
;
805 pa_threaded_mainloop_lock(data
->loop
);
806 frame_size
= pa_frame_size(&data
->spec
);
807 update_size
= Device
->UpdateSize
* frame_size
;
809 /* Sanitize buffer metrics, in case we actually have less than what we
811 buffer_size
= minu(update_size
*Device
->NumUpdates
, data
->attr
.tlength
);
812 update_size
= minu(update_size
, buffer_size
/2);
814 len
= pa_stream_writable_size(data
->stream
) - data
->attr
.tlength
+
816 if(len
< update_size
)
818 if(pa_stream_is_corked(data
->stream
) == 1)
821 o
= pa_stream_cork(data
->stream
, 0, NULL
, NULL
);
822 if(o
) pa_operation_unref(o
);
824 pa_threaded_mainloop_unlock(data
->loop
);
826 pa_threaded_mainloop_lock(data
->loop
);
829 len
-= len
%update_size
;
831 ALCdevice_Lock(Device
);
836 pa_free_cb_t free_func
= NULL
;
838 #if PA_CHECK_VERSION(0,9,16)
839 if(!pa_stream_begin_write
||
840 pa_stream_begin_write(data
->stream
, &buf
, &newlen
) < 0)
843 buf
= pa_xmalloc(newlen
);
844 free_func
= pa_xfree
;
847 aluMixData(Device
, buf
, newlen
/frame_size
);
849 pa_stream_write(data
->stream
, buf
, newlen
, free_func
, 0, PA_SEEK_RELATIVE
);
852 ALCdevice_Unlock(Device
);
853 } while(!data
->killNow
&& Device
->Connected
);
854 pa_threaded_mainloop_unlock(data
->loop
);
860 static ALCboolean
pulse_open(ALCdevice
*device
)
862 pulse_data
*data
= pa_xmalloc(sizeof(pulse_data
));
863 memset(data
, 0, sizeof(*data
));
865 if(!(data
->loop
= pa_threaded_mainloop_new()))
867 ERR("pa_threaded_mainloop_new() failed!\n");
870 if(pa_threaded_mainloop_start(data
->loop
) < 0)
872 ERR("pa_threaded_mainloop_start() failed\n");
876 pa_threaded_mainloop_lock(data
->loop
);
877 device
->ExtraData
= data
;
879 data
->context
= connect_context(data
->loop
, AL_FALSE
);
882 pa_threaded_mainloop_unlock(data
->loop
);
885 pa_context_set_state_callback(data
->context
, context_state_callback2
, device
);
887 pa_threaded_mainloop_unlock(data
->loop
);
893 pa_threaded_mainloop_stop(data
->loop
);
894 pa_threaded_mainloop_free(data
->loop
);
897 device
->ExtraData
= NULL
;
902 static void pulse_close(ALCdevice
*device
)
904 pulse_data
*data
= device
->ExtraData
;
906 pa_threaded_mainloop_lock(data
->loop
);
910 pa_stream_set_moved_callback(data
->stream
, NULL
, NULL
);
911 #if PA_CHECK_VERSION(0,9,15)
912 if(pa_stream_set_buffer_attr_callback
)
913 pa_stream_set_buffer_attr_callback(data
->stream
, NULL
, NULL
);
915 pa_stream_disconnect(data
->stream
);
916 pa_stream_unref(data
->stream
);
919 pa_context_disconnect(data
->context
);
920 pa_context_unref(data
->context
);
922 pa_threaded_mainloop_unlock(data
->loop
);
924 pa_threaded_mainloop_stop(data
->loop
);
925 pa_threaded_mainloop_free(data
->loop
);
927 free(data
->device_name
);
929 device
->ExtraData
= NULL
;
934 static ALCenum
pulse_open_playback(ALCdevice
*device
, const ALCchar
*device_name
)
936 const char *pulse_name
= NULL
;
937 pa_stream_flags_t flags
;
947 probe_devices(AL_FALSE
);
949 for(i
= 0;i
< numDevNames
;i
++)
951 if(strcmp(device_name
, allDevNameMap
[i
].name
) == 0)
953 pulse_name
= allDevNameMap
[i
].device_name
;
958 return ALC_INVALID_VALUE
;
961 if(pulse_open(device
) == ALC_FALSE
)
962 return ALC_INVALID_VALUE
;
964 data
= device
->ExtraData
;
965 pa_threaded_mainloop_lock(data
->loop
);
967 flags
= PA_STREAM_FIX_FORMAT
| PA_STREAM_FIX_RATE
|
968 PA_STREAM_FIX_CHANNELS
;
969 if(!GetConfigValueBool("pulse", "allow-moves", 0))
970 flags
|= PA_STREAM_DONT_MOVE
;
972 spec
.format
= PA_SAMPLE_S16NE
;
976 data
->stream
= connect_playback_stream(pulse_name
, data
->loop
, data
->context
,
977 flags
, NULL
, &spec
, NULL
);
980 pa_threaded_mainloop_unlock(data
->loop
);
982 return ALC_INVALID_VALUE
;
985 data
->device_name
= strdup(pa_stream_get_device_name(data
->stream
));
986 o
= pa_context_get_sink_info_by_name(data
->context
, data
->device_name
,
987 sink_name_callback
, device
);
988 wait_for_operation(o
, data
->loop
);
990 pa_stream_set_moved_callback(data
->stream
, stream_moved_callback
, device
);
992 pa_threaded_mainloop_unlock(data
->loop
);
997 static void pulse_close_playback(ALCdevice
*device
)
1002 static ALCboolean
pulse_reset_playback(ALCdevice
*device
)
1004 pulse_data
*data
= device
->ExtraData
;
1005 pa_stream_flags_t flags
= 0;
1006 pa_channel_map chanmap
;
1009 pa_threaded_mainloop_lock(data
->loop
);
1013 pa_stream_set_moved_callback(data
->stream
, NULL
, NULL
);
1014 #if PA_CHECK_VERSION(0,9,15)
1015 if(pa_stream_set_buffer_attr_callback
)
1016 pa_stream_set_buffer_attr_callback(data
->stream
, NULL
, NULL
);
1018 pa_stream_disconnect(data
->stream
);
1019 pa_stream_unref(data
->stream
);
1020 data
->stream
= NULL
;
1023 if(!(device
->Flags
&DEVICE_CHANNELS_REQUEST
))
1026 o
= pa_context_get_sink_info_by_name(data
->context
, data
->device_name
, sink_info_callback
, device
);
1027 wait_for_operation(o
, data
->loop
);
1029 if(!(device
->Flags
&DEVICE_FREQUENCY_REQUEST
))
1030 flags
|= PA_STREAM_FIX_RATE
;
1032 flags
|= PA_STREAM_INTERPOLATE_TIMING
| PA_STREAM_AUTO_TIMING_UPDATE
;
1033 flags
|= PA_STREAM_ADJUST_LATENCY
;
1034 flags
|= PA_STREAM_START_CORKED
;
1035 if(!GetConfigValueBool("pulse", "allow-moves", 0))
1036 flags
|= PA_STREAM_DONT_MOVE
;
1038 switch(device
->FmtType
)
1041 device
->FmtType
= DevFmtUByte
;
1044 data
->spec
.format
= PA_SAMPLE_U8
;
1047 device
->FmtType
= DevFmtShort
;
1050 data
->spec
.format
= PA_SAMPLE_S16NE
;
1053 device
->FmtType
= DevFmtInt
;
1056 data
->spec
.format
= PA_SAMPLE_S32NE
;
1059 data
->spec
.format
= PA_SAMPLE_FLOAT32NE
;
1062 data
->spec
.rate
= device
->Frequency
;
1063 data
->spec
.channels
= ChannelsFromDevFmt(device
->FmtChans
);
1065 if(pa_sample_spec_valid(&data
->spec
) == 0)
1067 ERR("Invalid sample format\n");
1068 pa_threaded_mainloop_unlock(data
->loop
);
1072 if(!pa_channel_map_init_auto(&chanmap
, data
->spec
.channels
, PA_CHANNEL_MAP_WAVEEX
))
1074 ERR("Couldn't build map for channel count (%d)!\n", data
->spec
.channels
);
1075 pa_threaded_mainloop_unlock(data
->loop
);
1078 SetDefaultWFXChannelOrder(device
);
1080 data
->attr
.fragsize
= -1;
1081 data
->attr
.prebuf
= 0;
1082 data
->attr
.minreq
= device
->UpdateSize
* pa_frame_size(&data
->spec
);
1083 data
->attr
.tlength
= data
->attr
.minreq
* maxu(device
->NumUpdates
, 2);
1084 data
->attr
.maxlength
= -1;
1086 data
->stream
= connect_playback_stream(data
->device_name
, data
->loop
,
1087 data
->context
, flags
, &data
->attr
,
1088 &data
->spec
, &chanmap
);
1091 pa_threaded_mainloop_unlock(data
->loop
);
1094 pa_stream_set_state_callback(data
->stream
, stream_state_callback2
, device
);
1096 data
->spec
= *(pa_stream_get_sample_spec(data
->stream
));
1097 if(device
->Frequency
!= data
->spec
.rate
)
1101 /* Server updated our playback rate, so modify the buffer attribs
1103 device
->NumUpdates
= (ALuint
)((ALdouble
)device
->NumUpdates
/ device
->Frequency
*
1104 data
->spec
.rate
+ 0.5);
1105 data
->attr
.minreq
= device
->UpdateSize
* pa_frame_size(&data
->spec
);
1106 data
->attr
.tlength
= data
->attr
.minreq
* clampu(device
->NumUpdates
, 2, 16);
1107 data
->attr
.maxlength
= -1;
1108 data
->attr
.prebuf
= 0;
1110 o
= pa_stream_set_buffer_attr(data
->stream
, &data
->attr
,
1111 stream_success_callback
, device
);
1112 wait_for_operation(o
, data
->loop
);
1114 device
->Frequency
= data
->spec
.rate
;
1117 pa_stream_set_moved_callback(data
->stream
, stream_moved_callback
, device
);
1118 #if PA_CHECK_VERSION(0,9,15)
1119 if(pa_stream_set_buffer_attr_callback
)
1120 pa_stream_set_buffer_attr_callback(data
->stream
, stream_buffer_attr_callback
, device
);
1122 stream_buffer_attr_callback(data
->stream
, device
);
1124 len
= data
->attr
.minreq
/ pa_frame_size(&data
->spec
);
1125 if((CPUCapFlags
&CPU_CAP_SSE
))
1127 device
->NumUpdates
= (ALuint
)((ALdouble
)device
->NumUpdates
/len
*device
->UpdateSize
+ 0.5);
1128 device
->NumUpdates
= clampu(device
->NumUpdates
, 2, 16);
1129 device
->UpdateSize
= len
;
1131 pa_threaded_mainloop_unlock(data
->loop
);
1135 static ALCboolean
pulse_start_playback(ALCdevice
*device
)
1137 pulse_data
*data
= device
->ExtraData
;
1139 data
->thread
= StartThread(PulseProc
, device
);
1146 static void pulse_stop_playback(ALCdevice
*device
)
1148 pulse_data
*data
= device
->ExtraData
;
1154 data
->killNow
= AL_TRUE
;
1157 StopThread(data
->thread
);
1158 data
->thread
= NULL
;
1160 data
->killNow
= AL_FALSE
;
1162 pa_threaded_mainloop_lock(data
->loop
);
1164 o
= pa_stream_cork(data
->stream
, 1, stream_success_callback
, device
);
1165 wait_for_operation(o
, data
->loop
);
1167 pa_threaded_mainloop_unlock(data
->loop
);
1171 static ALCenum
pulse_open_capture(ALCdevice
*device
, const ALCchar
*device_name
)
1173 const char *pulse_name
= NULL
;
1174 pa_stream_flags_t flags
= 0;
1175 pa_channel_map chanmap
;
1184 if(!allCaptureDevNameMap
)
1185 probe_devices(AL_TRUE
);
1187 for(i
= 0;i
< numCaptureDevNames
;i
++)
1189 if(strcmp(device_name
, allCaptureDevNameMap
[i
].name
) == 0)
1191 pulse_name
= allCaptureDevNameMap
[i
].device_name
;
1195 if(i
== numCaptureDevNames
)
1196 return ALC_INVALID_VALUE
;
1199 if(pulse_open(device
) == ALC_FALSE
)
1200 return ALC_INVALID_VALUE
;
1202 data
= device
->ExtraData
;
1203 pa_threaded_mainloop_lock(data
->loop
);
1205 data
->spec
.rate
= device
->Frequency
;
1206 data
->spec
.channels
= ChannelsFromDevFmt(device
->FmtChans
);
1208 switch(device
->FmtType
)
1211 data
->spec
.format
= PA_SAMPLE_U8
;
1214 data
->spec
.format
= PA_SAMPLE_S16NE
;
1217 data
->spec
.format
= PA_SAMPLE_S32NE
;
1220 data
->spec
.format
= PA_SAMPLE_FLOAT32NE
;
1225 ERR("%s capture samples not supported\n", DevFmtTypeString(device
->FmtType
));
1226 pa_threaded_mainloop_unlock(data
->loop
);
1230 if(pa_sample_spec_valid(&data
->spec
) == 0)
1232 ERR("Invalid sample format\n");
1233 pa_threaded_mainloop_unlock(data
->loop
);
1237 if(!pa_channel_map_init_auto(&chanmap
, data
->spec
.channels
, PA_CHANNEL_MAP_WAVEEX
))
1239 ERR("Couldn't build map for channel count (%d)!\n", data
->spec
.channels
);
1240 pa_threaded_mainloop_unlock(data
->loop
);
1244 samples
= device
->UpdateSize
* device
->NumUpdates
;
1245 samples
= maxu(samples
, 100 * device
->Frequency
/ 1000);
1247 data
->attr
.minreq
= -1;
1248 data
->attr
.prebuf
= -1;
1249 data
->attr
.maxlength
= samples
* pa_frame_size(&data
->spec
);
1250 data
->attr
.tlength
= -1;
1251 data
->attr
.fragsize
= minu(samples
, 50*device
->Frequency
/1000) *
1252 pa_frame_size(&data
->spec
);
1254 flags
|= PA_STREAM_START_CORKED
|PA_STREAM_ADJUST_LATENCY
;
1255 if(!GetConfigValueBool("pulse", "allow-moves", 0))
1256 flags
|= PA_STREAM_DONT_MOVE
;
1258 data
->stream
= connect_record_stream(pulse_name
, data
->loop
, data
->context
,
1259 flags
, &data
->attr
, &data
->spec
,
1263 pa_threaded_mainloop_unlock(data
->loop
);
1266 pa_stream_set_state_callback(data
->stream
, stream_state_callback2
, device
);
1268 data
->device_name
= strdup(pa_stream_get_device_name(data
->stream
));
1269 o
= pa_context_get_source_info_by_name(data
->context
, data
->device_name
,
1270 source_name_callback
, device
);
1271 wait_for_operation(o
, data
->loop
);
1273 pa_stream_set_moved_callback(data
->stream
, stream_moved_callback
, device
);
1275 pa_threaded_mainloop_unlock(data
->loop
);
1276 return ALC_NO_ERROR
;
1279 pulse_close(device
);
1280 return ALC_INVALID_VALUE
;
1283 static void pulse_close_capture(ALCdevice
*device
)
1285 pulse_close(device
);
1288 static void pulse_start_capture(ALCdevice
*device
)
1290 pulse_data
*data
= device
->ExtraData
;
1293 pa_threaded_mainloop_lock(data
->loop
);
1294 o
= pa_stream_cork(data
->stream
, 0, stream_success_callback
, device
);
1295 wait_for_operation(o
, data
->loop
);
1296 pa_threaded_mainloop_unlock(data
->loop
);
1299 static void pulse_stop_capture(ALCdevice
*device
)
1301 pulse_data
*data
= device
->ExtraData
;
1304 pa_threaded_mainloop_lock(data
->loop
);
1305 o
= pa_stream_cork(data
->stream
, 1, stream_success_callback
, device
);
1306 wait_for_operation(o
, data
->loop
);
1307 pa_threaded_mainloop_unlock(data
->loop
);
1310 static ALCenum
pulse_capture_samples(ALCdevice
*device
, ALCvoid
*buffer
, ALCuint samples
)
1312 pulse_data
*data
= device
->ExtraData
;
1313 ALCuint todo
= samples
* pa_frame_size(&data
->spec
);
1315 pa_threaded_mainloop_lock(data
->loop
);
1316 /* Capture is done in fragment-sized chunks, so we loop until we get all
1317 * that's available */
1318 data
->last_readable
-= todo
;
1323 if(data
->cap_len
== 0)
1325 pa_stream_state_t state
;
1327 state
= pa_stream_get_state(data
->stream
);
1328 if(!PA_STREAM_IS_GOOD(state
))
1330 aluHandleDisconnect(device
);
1333 if(pa_stream_peek(data
->stream
, &data
->cap_store
, &data
->cap_len
) < 0)
1335 ERR("pa_stream_peek() failed: %s\n",
1336 pa_strerror(pa_context_errno(data
->context
)));
1337 aluHandleDisconnect(device
);
1340 data
->cap_remain
= data
->cap_len
;
1342 if(rem
> data
->cap_remain
)
1343 rem
= data
->cap_remain
;
1345 memcpy(buffer
, data
->cap_store
, rem
);
1347 buffer
= (ALbyte
*)buffer
+ rem
;
1350 data
->cap_store
= (ALbyte
*)data
->cap_store
+ rem
;
1351 data
->cap_remain
-= rem
;
1352 if(data
->cap_remain
== 0)
1354 pa_stream_drop(data
->stream
);
1359 memset(buffer
, ((device
->FmtType
==DevFmtUByte
) ? 0x80 : 0), todo
);
1360 pa_threaded_mainloop_unlock(data
->loop
);
1362 return ALC_NO_ERROR
;
1365 static ALCuint
pulse_available_samples(ALCdevice
*device
)
1367 pulse_data
*data
= device
->ExtraData
;
1368 size_t readable
= data
->cap_remain
;
1370 pa_threaded_mainloop_lock(data
->loop
);
1371 if(device
->Connected
)
1373 ssize_t got
= pa_stream_readable_size(data
->stream
);
1376 ERR("pa_stream_readable_size() failed: %s\n", pa_strerror(got
));
1377 aluHandleDisconnect(device
);
1379 else if((size_t)got
> data
->cap_len
)
1380 readable
+= got
- data
->cap_len
;
1382 pa_threaded_mainloop_unlock(data
->loop
);
1384 if(data
->last_readable
< readable
)
1385 data
->last_readable
= readable
;
1386 return data
->last_readable
/ pa_frame_size(&data
->spec
);
1390 static ALint64
pulse_get_latency(ALCdevice
*device
)
1392 pulse_data
*data
= device
->ExtraData
;
1393 pa_usec_t latency
= 0;
1396 if(pa_stream_get_latency(data
->stream
, &latency
, &neg
) == 0)
1400 return (ALint64
)minu64(latency
, MAKEU64(0x7fffffff,0xffffffff)/1000) * 1000;
1402 ERR("Failed to get stream latency!\n");
1407 static const BackendFuncs pulse_funcs
= {
1408 pulse_open_playback
,
1409 pulse_close_playback
,
1410 pulse_reset_playback
,
1411 pulse_start_playback
,
1412 pulse_stop_playback
,
1414 pulse_close_capture
,
1415 pulse_start_capture
,
1417 pulse_capture_samples
,
1418 pulse_available_samples
,
1419 ALCdevice_LockDefault
,
1420 ALCdevice_UnlockDefault
,
1424 ALCboolean
alc_pulse_init(BackendFuncs
*func_list
)
1426 ALCboolean ret
= ALC_FALSE
;
1430 pa_threaded_mainloop
*loop
;
1432 pulse_ctx_flags
= 0;
1433 if(!GetConfigValueBool("pulse", "spawn-server", 1))
1434 pulse_ctx_flags
|= PA_CONTEXT_NOAUTOSPAWN
;
1436 if((loop
=pa_threaded_mainloop_new()) &&
1437 pa_threaded_mainloop_start(loop
) >= 0)
1439 pa_context
*context
;
1441 pa_threaded_mainloop_lock(loop
);
1442 context
= connect_context(loop
, AL_TRUE
);
1445 *func_list
= pulse_funcs
;
1448 /* Some libraries (Phonon, Qt) set some pulseaudio properties
1449 * through environment variables, which causes all streams in
1450 * the process to inherit them. This attempts to filter those
1451 * properties out by setting them to 0-length data. */
1452 prop_filter
= pa_proplist_new();
1453 pa_proplist_set(prop_filter
, PA_PROP_MEDIA_ROLE
, NULL
, 0);
1454 pa_proplist_set(prop_filter
, "phonon.streamid", NULL
, 0);
1456 pa_context_disconnect(context
);
1457 pa_context_unref(context
);
1459 pa_threaded_mainloop_unlock(loop
);
1460 pa_threaded_mainloop_stop(loop
);
1463 pa_threaded_mainloop_free(loop
);
1469 void alc_pulse_deinit(void)
1473 for(i
= 0;i
< numDevNames
;++i
)
1475 free(allDevNameMap
[i
].name
);
1476 free(allDevNameMap
[i
].device_name
);
1478 free(allDevNameMap
);
1479 allDevNameMap
= NULL
;
1482 for(i
= 0;i
< numCaptureDevNames
;++i
)
1484 free(allCaptureDevNameMap
[i
].name
);
1485 free(allCaptureDevNameMap
[i
].device_name
);
1487 free(allCaptureDevNameMap
);
1488 allCaptureDevNameMap
= NULL
;
1489 numCaptureDevNames
= 0;
1492 pa_proplist_free(prop_filter
);
1495 /* PulseAudio doesn't like being CloseLib'd sometimes */
1498 void alc_pulse_probe(enum DevProbe type
)
1504 case ALL_DEVICE_PROBE
:
1505 for(i
= 0;i
< numDevNames
;++i
)
1507 free(allDevNameMap
[i
].name
);
1508 free(allDevNameMap
[i
].device_name
);
1510 free(allDevNameMap
);
1511 allDevNameMap
= NULL
;
1514 probe_devices(AL_FALSE
);
1516 for(i
= 0;i
< numDevNames
;i
++)
1517 AppendAllDevicesList(allDevNameMap
[i
].name
);
1520 case CAPTURE_DEVICE_PROBE
:
1521 for(i
= 0;i
< numCaptureDevNames
;++i
)
1523 free(allCaptureDevNameMap
[i
].name
);
1524 free(allCaptureDevNameMap
[i
].device_name
);
1526 free(allCaptureDevNameMap
);
1527 allCaptureDevNameMap
= NULL
;
1528 numCaptureDevNames
= 0;
1530 probe_devices(AL_TRUE
);
1532 for(i
= 0;i
< numCaptureDevNames
;i
++)
1533 AppendCaptureDeviceList(allCaptureDevNameMap
[i
].name
);
1540 #warning "Unsupported API version, backend will be unavailable!"
1542 ALCboolean
alc_pulse_init(BackendFuncs
*func_list
)
1543 { return ALC_FALSE
; (void)func_list
; }
1545 void alc_pulse_deinit(void)
1548 void alc_pulse_probe(enum DevProbe type
)