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_frame_size
);
59 MAKE_FUNC(pa_stream_drop
);
60 MAKE_FUNC(pa_strerror
);
61 MAKE_FUNC(pa_context_get_state
);
62 MAKE_FUNC(pa_stream_get_state
);
63 MAKE_FUNC(pa_threaded_mainloop_signal
);
64 MAKE_FUNC(pa_stream_peek
);
65 MAKE_FUNC(pa_threaded_mainloop_wait
);
66 MAKE_FUNC(pa_threaded_mainloop_unlock
);
67 MAKE_FUNC(pa_threaded_mainloop_in_thread
);
68 MAKE_FUNC(pa_context_new
);
69 MAKE_FUNC(pa_threaded_mainloop_stop
);
70 MAKE_FUNC(pa_context_disconnect
);
71 MAKE_FUNC(pa_threaded_mainloop_start
);
72 MAKE_FUNC(pa_threaded_mainloop_get_api
);
73 MAKE_FUNC(pa_context_set_state_callback
);
74 MAKE_FUNC(pa_stream_write
);
76 MAKE_FUNC(pa_stream_connect_record
);
77 MAKE_FUNC(pa_stream_connect_playback
);
78 MAKE_FUNC(pa_stream_readable_size
);
79 MAKE_FUNC(pa_stream_writable_size
);
80 MAKE_FUNC(pa_stream_cork
);
81 MAKE_FUNC(pa_stream_is_suspended
);
82 MAKE_FUNC(pa_stream_get_device_name
);
83 MAKE_FUNC(pa_path_get_filename
);
84 MAKE_FUNC(pa_get_binary_name
);
85 MAKE_FUNC(pa_threaded_mainloop_free
);
86 MAKE_FUNC(pa_context_errno
);
87 MAKE_FUNC(pa_xmalloc
);
88 MAKE_FUNC(pa_stream_unref
);
89 MAKE_FUNC(pa_threaded_mainloop_accept
);
90 MAKE_FUNC(pa_stream_set_write_callback
);
91 MAKE_FUNC(pa_threaded_mainloop_new
);
92 MAKE_FUNC(pa_context_connect
);
93 MAKE_FUNC(pa_stream_set_buffer_attr
);
94 MAKE_FUNC(pa_stream_get_buffer_attr
);
95 MAKE_FUNC(pa_stream_get_sample_spec
);
96 MAKE_FUNC(pa_stream_get_time
);
97 MAKE_FUNC(pa_stream_set_read_callback
);
98 MAKE_FUNC(pa_stream_set_state_callback
);
99 MAKE_FUNC(pa_stream_set_moved_callback
);
100 MAKE_FUNC(pa_stream_set_underflow_callback
);
101 MAKE_FUNC(pa_stream_new
);
102 MAKE_FUNC(pa_stream_disconnect
);
103 MAKE_FUNC(pa_threaded_mainloop_lock
);
104 MAKE_FUNC(pa_channel_map_init_auto
);
105 MAKE_FUNC(pa_channel_map_parse
);
106 MAKE_FUNC(pa_channel_map_snprint
);
107 MAKE_FUNC(pa_channel_map_equal
);
108 MAKE_FUNC(pa_context_get_server_info
);
109 MAKE_FUNC(pa_context_get_sink_info_by_name
);
110 MAKE_FUNC(pa_context_get_sink_info_list
);
111 MAKE_FUNC(pa_context_get_source_info_by_name
);
112 MAKE_FUNC(pa_context_get_source_info_list
);
113 MAKE_FUNC(pa_operation_get_state
);
114 MAKE_FUNC(pa_operation_unref
);
115 #if PA_CHECK_VERSION(0,9,15)
116 MAKE_FUNC(pa_channel_map_superset
);
117 MAKE_FUNC(pa_stream_set_buffer_attr_callback
);
119 #if PA_CHECK_VERSION(0,9,16)
120 MAKE_FUNC(pa_stream_begin_write
);
124 #define pa_context_unref ppa_context_unref
125 #define pa_sample_spec_valid ppa_sample_spec_valid
126 #define pa_frame_size ppa_frame_size
127 #define pa_stream_drop ppa_stream_drop
128 #define pa_strerror ppa_strerror
129 #define pa_context_get_state ppa_context_get_state
130 #define pa_stream_get_state ppa_stream_get_state
131 #define pa_threaded_mainloop_signal ppa_threaded_mainloop_signal
132 #define pa_stream_peek ppa_stream_peek
133 #define pa_threaded_mainloop_wait ppa_threaded_mainloop_wait
134 #define pa_threaded_mainloop_unlock ppa_threaded_mainloop_unlock
135 #define pa_threaded_mainloop_in_thread ppa_threaded_mainloop_in_thread
136 #define pa_context_new ppa_context_new
137 #define pa_threaded_mainloop_stop ppa_threaded_mainloop_stop
138 #define pa_context_disconnect ppa_context_disconnect
139 #define pa_threaded_mainloop_start ppa_threaded_mainloop_start
140 #define pa_threaded_mainloop_get_api ppa_threaded_mainloop_get_api
141 #define pa_context_set_state_callback ppa_context_set_state_callback
142 #define pa_stream_write ppa_stream_write
143 #define pa_xfree ppa_xfree
144 #define pa_stream_connect_record ppa_stream_connect_record
145 #define pa_stream_connect_playback ppa_stream_connect_playback
146 #define pa_stream_readable_size ppa_stream_readable_size
147 #define pa_stream_writable_size ppa_stream_writable_size
148 #define pa_stream_cork ppa_stream_cork
149 #define pa_stream_is_suspended ppa_stream_is_suspended
150 #define pa_stream_get_device_name ppa_stream_get_device_name
151 #define pa_path_get_filename ppa_path_get_filename
152 #define pa_get_binary_name ppa_get_binary_name
153 #define pa_threaded_mainloop_free ppa_threaded_mainloop_free
154 #define pa_context_errno ppa_context_errno
155 #define pa_xmalloc ppa_xmalloc
156 #define pa_stream_unref ppa_stream_unref
157 #define pa_threaded_mainloop_accept ppa_threaded_mainloop_accept
158 #define pa_stream_set_write_callback ppa_stream_set_write_callback
159 #define pa_threaded_mainloop_new ppa_threaded_mainloop_new
160 #define pa_context_connect ppa_context_connect
161 #define pa_stream_set_buffer_attr ppa_stream_set_buffer_attr
162 #define pa_stream_get_buffer_attr ppa_stream_get_buffer_attr
163 #define pa_stream_get_sample_spec ppa_stream_get_sample_spec
164 #define pa_stream_get_time ppa_stream_get_time
165 #define pa_stream_set_read_callback ppa_stream_set_read_callback
166 #define pa_stream_set_state_callback ppa_stream_set_state_callback
167 #define pa_stream_set_moved_callback ppa_stream_set_moved_callback
168 #define pa_stream_set_underflow_callback ppa_stream_set_underflow_callback
169 #define pa_stream_new ppa_stream_new
170 #define pa_stream_disconnect ppa_stream_disconnect
171 #define pa_threaded_mainloop_lock ppa_threaded_mainloop_lock
172 #define pa_channel_map_init_auto ppa_channel_map_init_auto
173 #define pa_channel_map_parse ppa_channel_map_parse
174 #define pa_channel_map_snprint ppa_channel_map_snprint
175 #define pa_channel_map_equal ppa_channel_map_equal
176 #define pa_context_get_server_info ppa_context_get_server_info
177 #define pa_context_get_sink_info_by_name ppa_context_get_sink_info_by_name
178 #define pa_context_get_sink_info_list ppa_context_get_sink_info_list
179 #define pa_context_get_source_info_by_name ppa_context_get_source_info_by_name
180 #define pa_context_get_source_info_list ppa_context_get_source_info_list
181 #define pa_operation_get_state ppa_operation_get_state
182 #define pa_operation_unref ppa_operation_unref
183 #if PA_CHECK_VERSION(0,9,15)
184 #define pa_channel_map_superset ppa_channel_map_superset
185 #define pa_stream_set_buffer_attr_callback ppa_stream_set_buffer_attr_callback
187 #if PA_CHECK_VERSION(0,9,16)
188 #define pa_stream_begin_write ppa_stream_begin_write
194 #define PATH_MAX 4096
200 const void *cap_store
;
204 ALCuint last_readable
;
209 pa_threaded_mainloop
*loop
;
212 volatile ALboolean killNow
;
224 static DevMap
*allDevNameMap
;
225 static ALuint numDevNames
;
226 static DevMap
*allCaptureDevNameMap
;
227 static ALuint numCaptureDevNames
;
228 static pa_context_flags_t pulse_ctx_flags
;
231 static void context_state_callback(pa_context
*context
, void *pdata
)
233 pa_threaded_mainloop
*loop
= pdata
;
234 pa_context_state_t state
;
236 state
= pa_context_get_state(context
);
237 if(state
== PA_CONTEXT_READY
|| !PA_CONTEXT_IS_GOOD(state
))
238 pa_threaded_mainloop_signal(loop
, 0);
241 static pa_context
*connect_context(pa_threaded_mainloop
*loop
, ALboolean silent
)
243 const char *name
= "OpenAL Soft";
244 char path_name
[PATH_MAX
];
245 pa_context_state_t state
;
249 if(pa_get_binary_name(path_name
, sizeof(path_name
)))
250 name
= pa_path_get_filename(path_name
);
252 context
= pa_context_new(pa_threaded_mainloop_get_api(loop
), name
);
255 ERR("pa_context_new() failed\n");
259 pa_context_set_state_callback(context
, context_state_callback
, loop
);
261 if((err
=pa_context_connect(context
, NULL
, pulse_ctx_flags
, NULL
)) >= 0)
263 while((state
=pa_context_get_state(context
)) != PA_CONTEXT_READY
)
265 if(!PA_CONTEXT_IS_GOOD(state
))
267 err
= pa_context_errno(context
);
268 if(err
> 0) err
= -err
;
272 pa_threaded_mainloop_wait(loop
);
275 pa_context_set_state_callback(context
, NULL
, NULL
);
280 ERR("Context did not connect: %s\n", pa_strerror(err
));
281 pa_context_unref(context
);
289 static ALCboolean
pulse_load(void) //{{{
291 ALCboolean ret
= ALC_TRUE
;
297 #define PALIB "libpulse-0.dll"
298 #elif defined(__APPLE__) && defined(__MACH__)
299 #define PALIB "libpulse.0.dylib"
301 #define PALIB "libpulse.so.0"
303 pa_handle
= LoadLib(PALIB
);
307 #define LOAD_FUNC(x) do { \
308 p##x = GetSymbol(pa_handle, #x); \
313 LOAD_FUNC(pa_context_unref
);
314 LOAD_FUNC(pa_sample_spec_valid
);
315 LOAD_FUNC(pa_stream_drop
);
316 LOAD_FUNC(pa_frame_size
);
317 LOAD_FUNC(pa_strerror
);
318 LOAD_FUNC(pa_context_get_state
);
319 LOAD_FUNC(pa_stream_get_state
);
320 LOAD_FUNC(pa_threaded_mainloop_signal
);
321 LOAD_FUNC(pa_stream_peek
);
322 LOAD_FUNC(pa_threaded_mainloop_wait
);
323 LOAD_FUNC(pa_threaded_mainloop_unlock
);
324 LOAD_FUNC(pa_threaded_mainloop_in_thread
);
325 LOAD_FUNC(pa_context_new
);
326 LOAD_FUNC(pa_threaded_mainloop_stop
);
327 LOAD_FUNC(pa_context_disconnect
);
328 LOAD_FUNC(pa_threaded_mainloop_start
);
329 LOAD_FUNC(pa_threaded_mainloop_get_api
);
330 LOAD_FUNC(pa_context_set_state_callback
);
331 LOAD_FUNC(pa_stream_write
);
333 LOAD_FUNC(pa_stream_connect_record
);
334 LOAD_FUNC(pa_stream_connect_playback
);
335 LOAD_FUNC(pa_stream_readable_size
);
336 LOAD_FUNC(pa_stream_writable_size
);
337 LOAD_FUNC(pa_stream_cork
);
338 LOAD_FUNC(pa_stream_is_suspended
);
339 LOAD_FUNC(pa_stream_get_device_name
);
340 LOAD_FUNC(pa_path_get_filename
);
341 LOAD_FUNC(pa_get_binary_name
);
342 LOAD_FUNC(pa_threaded_mainloop_free
);
343 LOAD_FUNC(pa_context_errno
);
344 LOAD_FUNC(pa_xmalloc
);
345 LOAD_FUNC(pa_stream_unref
);
346 LOAD_FUNC(pa_threaded_mainloop_accept
);
347 LOAD_FUNC(pa_stream_set_write_callback
);
348 LOAD_FUNC(pa_threaded_mainloop_new
);
349 LOAD_FUNC(pa_context_connect
);
350 LOAD_FUNC(pa_stream_set_buffer_attr
);
351 LOAD_FUNC(pa_stream_get_buffer_attr
);
352 LOAD_FUNC(pa_stream_get_sample_spec
);
353 LOAD_FUNC(pa_stream_get_time
);
354 LOAD_FUNC(pa_stream_set_read_callback
);
355 LOAD_FUNC(pa_stream_set_state_callback
);
356 LOAD_FUNC(pa_stream_set_moved_callback
);
357 LOAD_FUNC(pa_stream_set_underflow_callback
);
358 LOAD_FUNC(pa_stream_new
);
359 LOAD_FUNC(pa_stream_disconnect
);
360 LOAD_FUNC(pa_threaded_mainloop_lock
);
361 LOAD_FUNC(pa_channel_map_init_auto
);
362 LOAD_FUNC(pa_channel_map_parse
);
363 LOAD_FUNC(pa_channel_map_snprint
);
364 LOAD_FUNC(pa_channel_map_equal
);
365 LOAD_FUNC(pa_context_get_server_info
);
366 LOAD_FUNC(pa_context_get_sink_info_by_name
);
367 LOAD_FUNC(pa_context_get_sink_info_list
);
368 LOAD_FUNC(pa_context_get_source_info_by_name
);
369 LOAD_FUNC(pa_context_get_source_info_list
);
370 LOAD_FUNC(pa_operation_get_state
);
371 LOAD_FUNC(pa_operation_unref
);
373 #define LOAD_OPTIONAL_FUNC(x) do { \
374 p##x = GetSymbol(pa_handle, #x); \
376 #if PA_CHECK_VERSION(0,9,15)
377 LOAD_OPTIONAL_FUNC(pa_channel_map_superset
);
378 LOAD_OPTIONAL_FUNC(pa_stream_set_buffer_attr_callback
);
380 #if PA_CHECK_VERSION(0,9,16)
381 LOAD_OPTIONAL_FUNC(pa_stream_begin_write
);
383 #undef LOAD_OPTIONAL_FUNC
385 #else /* HAVE_DYNLOAD */
386 pa_handle
= (void*)0xDEADBEEF;
400 // PulseAudio Event Callbacks //{{{
401 static void stream_state_callback(pa_stream
*stream
, void *pdata
) //{{{
403 pa_threaded_mainloop
*loop
= pdata
;
404 pa_stream_state_t state
;
406 state
= pa_stream_get_state(stream
);
407 if(state
== PA_STREAM_READY
|| !PA_STREAM_IS_GOOD(state
))
408 pa_threaded_mainloop_signal(loop
, 0);
411 static void stream_signal_callback(pa_stream
*stream
, void *pdata
) //{{{
413 ALCdevice
*Device
= pdata
;
414 pulse_data
*data
= Device
->ExtraData
;
417 pa_threaded_mainloop_signal(data
->loop
, 0);
420 static void stream_buffer_attr_callback(pa_stream
*stream
, void *pdata
) //{{{
422 const pa_buffer_attr
*attr
;
425 attr
= pa_stream_get_buffer_attr(stream
);
426 WARN("PulseAudio modified buffer length: minreq=%d, tlength=%d\n", attr
->minreq
, attr
->tlength
);
429 static void stream_device_callback(pa_stream
*stream
, void *pdata
) //{{{
431 ALCdevice
*Device
= pdata
;
432 pulse_data
*data
= Device
->ExtraData
;
434 free(data
->device_name
);
435 data
->device_name
= strdup(pa_stream_get_device_name(stream
));
438 static void context_state_callback2(pa_context
*context
, void *pdata
) //{{{
440 ALCdevice
*Device
= pdata
;
441 pulse_data
*data
= Device
->ExtraData
;
443 if(pa_context_get_state(context
) == PA_CONTEXT_FAILED
)
445 ERR("Received context failure!\n");
446 aluHandleDisconnect(Device
);
448 pa_threaded_mainloop_signal(data
->loop
, 0);
451 static void stream_state_callback2(pa_stream
*stream
, void *pdata
) //{{{
453 ALCdevice
*Device
= pdata
;
454 pulse_data
*data
= Device
->ExtraData
;
456 if(pa_stream_get_state(stream
) == PA_STREAM_FAILED
)
458 ERR("Received stream failure!\n");
459 aluHandleDisconnect(Device
);
461 pa_threaded_mainloop_signal(data
->loop
, 0);
464 static void stream_success_callback(pa_stream
*stream
, int success
, void *pdata
) //{{{
466 ALCdevice
*Device
= pdata
;
467 pulse_data
*data
= Device
->ExtraData
;
471 pa_threaded_mainloop_signal(data
->loop
, 0);
474 static void sink_info_callback(pa_context
*context
, const pa_sink_info
*info
, int eol
, void *pdata
) //{{{
476 ALCdevice
*device
= pdata
;
477 pulse_data
*data
= device
->ExtraData
;
478 char chanmap_str
[256] = "";
481 enum DevFmtChannels chans
;
483 { "front-left,front-right,front-center,lfe,rear-left,rear-right,side-left,side-right",
485 { "front-left,front-right,front-center,lfe,rear-center,side-left,side-right",
487 { "front-left,front-right,front-center,lfe,rear-left,rear-right",
489 { "front-left,front-right,front-center,lfe,side-left,side-right",
491 { "front-left,front-right,rear-left,rear-right", DevFmtQuad
},
492 { "front-left,front-right", DevFmtStereo
},
493 { "mono", DevFmtMono
},
501 pa_threaded_mainloop_signal(data
->loop
, 0);
505 for(i
= 0;chanmaps
[i
].str
;i
++)
508 if(!pa_channel_map_parse(&map
, chanmaps
[i
].str
))
511 if(pa_channel_map_equal(&info
->channel_map
, &map
)
512 #if PA_CHECK_VERSION(0,9,15)
513 || (pa_channel_map_superset
&&
514 pa_channel_map_superset(&info
->channel_map
, &map
))
518 device
->FmtChans
= chanmaps
[i
].chans
;
523 pa_channel_map_snprint(chanmap_str
, sizeof(chanmap_str
), &info
->channel_map
);
524 ERR("Failed to find format for channel map:\n %s\n", chanmap_str
);
527 static void sink_device_callback(pa_context
*context
, const pa_sink_info
*info
, int eol
, void *pdata
) //{{{
529 pa_threaded_mainloop
*loop
= pdata
;
537 pa_threaded_mainloop_signal(loop
, 0);
541 for(i
= 0;i
< numDevNames
;i
++)
543 if(strcmp(info
->name
, allDevNameMap
[i
].device_name
) == 0)
547 TRACE("Got device \"%s\", \"%s\"\n", info
->description
, info
->name
);
549 temp
= realloc(allDevNameMap
, (numDevNames
+1) * sizeof(*allDevNameMap
));
552 allDevNameMap
= temp
;
553 allDevNameMap
[numDevNames
].name
= strdup(info
->description
);
554 allDevNameMap
[numDevNames
].device_name
= strdup(info
->name
);
559 static void source_device_callback(pa_context
*context
, const pa_source_info
*info
, int eol
, void *pdata
) //{{{
561 pa_threaded_mainloop
*loop
= pdata
;
569 pa_threaded_mainloop_signal(loop
, 0);
573 for(i
= 0;i
< numCaptureDevNames
;i
++)
575 if(strcmp(info
->name
, allCaptureDevNameMap
[i
].device_name
) == 0)
579 TRACE("Got device \"%s\", \"%s\"\n", info
->description
, info
->name
);
581 temp
= realloc(allCaptureDevNameMap
, (numCaptureDevNames
+1) * sizeof(*allCaptureDevNameMap
));
584 allCaptureDevNameMap
= temp
;
585 allCaptureDevNameMap
[numCaptureDevNames
].name
= strdup(info
->description
);
586 allCaptureDevNameMap
[numCaptureDevNames
].device_name
= strdup(info
->name
);
587 numCaptureDevNames
++;
592 // PulseAudio I/O Callbacks //{{{
593 static void stream_write_callback(pa_stream
*stream
, size_t len
, void *pdata
) //{{{
595 ALCdevice
*Device
= pdata
;
596 pulse_data
*data
= Device
->ExtraData
;
600 pa_threaded_mainloop_signal(data
->loop
, 0);
604 static ALuint
PulseProc(ALvoid
*param
)
606 ALCdevice
*Device
= param
;
607 pulse_data
*data
= Device
->ExtraData
;
613 frame_size
= pa_frame_size(&data
->spec
);
614 pa_threaded_mainloop_lock(data
->loop
);
616 len
= pa_stream_writable_size(data
->stream
);
617 if(len
< data
->attr
.minreq
)
619 pa_threaded_mainloop_wait(data
->loop
);
622 len
-= len
%data
->attr
.minreq
;
628 pa_free_cb_t free_func
= NULL
;
630 #if PA_CHECK_VERSION(0,9,16)
631 if(!pa_stream_begin_write
||
632 pa_stream_begin_write(data
->stream
, &buf
, &newlen
) < 0)
635 buf
= pa_xmalloc(newlen
);
636 free_func
= pa_xfree
;
638 pa_threaded_mainloop_unlock(data
->loop
);
640 aluMixData(Device
, buf
, newlen
/frame_size
);
642 pa_threaded_mainloop_lock(data
->loop
);
643 pa_stream_write(data
->stream
, buf
, newlen
, free_func
, 0, PA_SEEK_RELATIVE
);
646 } while(!data
->killNow
&& Device
->Connected
);
647 pa_threaded_mainloop_unlock(data
->loop
);
652 static pa_stream
*connect_playback_stream(const char *device_name
,
653 pa_threaded_mainloop
*loop
, pa_context
*context
,
654 pa_stream_flags_t flags
, pa_buffer_attr
*attr
, pa_sample_spec
*spec
,
655 pa_channel_map
*chanmap
)
657 pa_stream_state_t state
;
660 stream
= pa_stream_new(context
, "Playback Stream", spec
, chanmap
);
663 ERR("pa_stream_new() failed: %s\n", pa_strerror(pa_context_errno(context
)));
667 pa_stream_set_state_callback(stream
, stream_state_callback
, loop
);
669 if(pa_stream_connect_playback(stream
, device_name
, attr
, flags
, NULL
, NULL
) < 0)
671 ERR("Stream did not connect: %s\n", pa_strerror(pa_context_errno(context
)));
672 pa_stream_unref(stream
);
676 while((state
=pa_stream_get_state(stream
)) != PA_STREAM_READY
)
678 if(!PA_STREAM_IS_GOOD(state
))
680 ERR("Stream did not get ready: %s\n", pa_strerror(pa_context_errno(context
)));
681 pa_stream_unref(stream
);
685 pa_threaded_mainloop_wait(loop
);
687 pa_stream_set_state_callback(stream
, NULL
, NULL
);
692 static pa_stream
*connect_record_stream(const char *device_name
,
693 pa_threaded_mainloop
*loop
, pa_context
*context
,
694 pa_stream_flags_t flags
, pa_buffer_attr
*attr
, pa_sample_spec
*spec
,
695 pa_channel_map
*chanmap
)
697 pa_stream_state_t state
;
700 stream
= pa_stream_new(context
, "Capture Stream", spec
, chanmap
);
703 ERR("pa_stream_new() failed: %s\n", pa_strerror(pa_context_errno(context
)));
707 pa_stream_set_state_callback(stream
, stream_state_callback
, loop
);
709 if(pa_stream_connect_record(stream
, device_name
, attr
, flags
) < 0)
711 ERR("Stream did not connect: %s\n", pa_strerror(pa_context_errno(context
)));
712 pa_stream_unref(stream
);
716 while((state
=pa_stream_get_state(stream
)) != PA_STREAM_READY
)
718 if(!PA_STREAM_IS_GOOD(state
))
720 ERR("Stream did not get ready: %s\n", pa_strerror(pa_context_errno(context
)));
721 pa_stream_unref(stream
);
725 pa_threaded_mainloop_wait(loop
);
727 pa_stream_set_state_callback(stream
, NULL
, NULL
);
732 static void probe_devices(ALboolean capture
)
734 pa_threaded_mainloop
*loop
;
736 if(capture
== AL_FALSE
)
737 allDevNameMap
= malloc(sizeof(DevMap
) * 1);
739 allCaptureDevNameMap
= malloc(sizeof(DevMap
) * 1);
741 if((loop
=pa_threaded_mainloop_new()) &&
742 pa_threaded_mainloop_start(loop
) >= 0)
746 pa_threaded_mainloop_lock(loop
);
747 context
= connect_context(loop
, AL_FALSE
);
752 if(capture
== AL_FALSE
)
757 spec
.format
= PA_SAMPLE_S16NE
;
761 stream
= connect_playback_stream(NULL
, loop
, context
, 0, NULL
,
765 o
= pa_context_get_sink_info_by_name(context
, pa_stream_get_device_name(stream
), sink_device_callback
, loop
);
766 while(pa_operation_get_state(o
) == PA_OPERATION_RUNNING
)
767 pa_threaded_mainloop_wait(loop
);
768 pa_operation_unref(o
);
770 pa_stream_disconnect(stream
);
771 pa_stream_unref(stream
);
775 o
= pa_context_get_sink_info_list(context
, sink_device_callback
, loop
);
782 spec
.format
= PA_SAMPLE_S16NE
;
786 stream
= connect_record_stream(NULL
, loop
, context
, 0, NULL
,
790 o
= pa_context_get_source_info_by_name(context
, pa_stream_get_device_name(stream
), source_device_callback
, loop
);
791 while(pa_operation_get_state(o
) == PA_OPERATION_RUNNING
)
792 pa_threaded_mainloop_wait(loop
);
793 pa_operation_unref(o
);
795 pa_stream_disconnect(stream
);
796 pa_stream_unref(stream
);
800 o
= pa_context_get_source_info_list(context
, source_device_callback
, loop
);
802 while(pa_operation_get_state(o
) == PA_OPERATION_RUNNING
)
803 pa_threaded_mainloop_wait(loop
);
804 pa_operation_unref(o
);
806 pa_context_disconnect(context
);
807 pa_context_unref(context
);
809 pa_threaded_mainloop_unlock(loop
);
810 pa_threaded_mainloop_stop(loop
);
813 pa_threaded_mainloop_free(loop
);
817 static ALCboolean
pulse_open(ALCdevice
*device
, const ALCchar
*device_name
) //{{{
819 pulse_data
*data
= pa_xmalloc(sizeof(pulse_data
));
820 memset(data
, 0, sizeof(*data
));
822 if(!(data
->loop
= pa_threaded_mainloop_new()))
824 ERR("pa_threaded_mainloop_new() failed!\n");
827 if(pa_threaded_mainloop_start(data
->loop
) < 0)
829 ERR("pa_threaded_mainloop_start() failed\n");
833 pa_threaded_mainloop_lock(data
->loop
);
834 device
->ExtraData
= data
;
836 data
->context
= connect_context(data
->loop
, AL_FALSE
);
839 pa_threaded_mainloop_unlock(data
->loop
);
842 pa_context_set_state_callback(data
->context
, context_state_callback2
, device
);
844 device
->szDeviceName
= strdup(device_name
);
846 pa_threaded_mainloop_unlock(data
->loop
);
852 pa_threaded_mainloop_stop(data
->loop
);
853 pa_threaded_mainloop_free(data
->loop
);
856 device
->ExtraData
= NULL
;
861 static void pulse_close(ALCdevice
*device
) //{{{
863 pulse_data
*data
= device
->ExtraData
;
865 pa_threaded_mainloop_lock(data
->loop
);
869 pa_stream_disconnect(data
->stream
);
870 pa_stream_unref(data
->stream
);
873 pa_context_disconnect(data
->context
);
874 pa_context_unref(data
->context
);
876 pa_threaded_mainloop_unlock(data
->loop
);
878 pa_threaded_mainloop_stop(data
->loop
);
879 pa_threaded_mainloop_free(data
->loop
);
881 free(data
->device_name
);
883 device
->ExtraData
= NULL
;
889 static ALCenum
pulse_open_playback(ALCdevice
*device
, const ALCchar
*device_name
) //{{{
891 char *pulse_name
= NULL
;
897 probe_devices(AL_FALSE
);
899 if(!device_name
&& numDevNames
> 0)
901 device_name
= allDevNameMap
[0].name
;
902 pulse_name
= allDevNameMap
[0].device_name
;
908 for(i
= 0;i
< numDevNames
;i
++)
910 if(strcmp(device_name
, allDevNameMap
[i
].name
) == 0)
912 pulse_name
= allDevNameMap
[i
].device_name
;
917 return ALC_INVALID_VALUE
;
920 if(pulse_open(device
, device_name
) == ALC_FALSE
)
921 return ALC_INVALID_VALUE
;
923 data
= device
->ExtraData
;
925 pa_threaded_mainloop_lock(data
->loop
);
927 spec
.format
= PA_SAMPLE_S16NE
;
931 stream
= connect_playback_stream(pulse_name
, data
->loop
, data
->context
, 0,
935 pa_threaded_mainloop_unlock(data
->loop
);
939 if(pa_stream_is_suspended(stream
))
941 ERR("Device is suspended\n");
942 pa_stream_disconnect(stream
);
943 pa_stream_unref(stream
);
944 pa_threaded_mainloop_unlock(data
->loop
);
947 data
->device_name
= strdup(pa_stream_get_device_name(stream
));
949 pa_stream_disconnect(stream
);
950 pa_stream_unref(stream
);
952 pa_threaded_mainloop_unlock(data
->loop
);
958 return ALC_INVALID_VALUE
;
961 static void pulse_close_playback(ALCdevice
*device
) //{{{
966 static ALCboolean
pulse_reset_playback(ALCdevice
*device
) //{{{
968 pulse_data
*data
= device
->ExtraData
;
969 pa_stream_flags_t flags
= 0;
970 pa_channel_map chanmap
;
972 pa_threaded_mainloop_lock(data
->loop
);
974 if(!(device
->Flags
&DEVICE_CHANNELS_REQUEST
))
977 o
= pa_context_get_sink_info_by_name(data
->context
, data
->device_name
, sink_info_callback
, device
);
978 while(pa_operation_get_state(o
) == PA_OPERATION_RUNNING
)
979 pa_threaded_mainloop_wait(data
->loop
);
980 pa_operation_unref(o
);
982 if(!(device
->Flags
&DEVICE_FREQUENCY_REQUEST
))
983 flags
|= PA_STREAM_FIX_RATE
;
985 flags
|= PA_STREAM_EARLY_REQUESTS
;
986 flags
|= PA_STREAM_INTERPOLATE_TIMING
| PA_STREAM_AUTO_TIMING_UPDATE
;
988 switch(device
->FmtType
)
991 device
->FmtType
= DevFmtUByte
;
994 data
->spec
.format
= PA_SAMPLE_U8
;
997 device
->FmtType
= DevFmtShort
;
1000 data
->spec
.format
= PA_SAMPLE_S16NE
;
1003 device
->FmtType
= DevFmtInt
;
1006 data
->spec
.format
= PA_SAMPLE_S32NE
;
1009 data
->spec
.format
= PA_SAMPLE_FLOAT32NE
;
1012 data
->spec
.rate
= device
->Frequency
;
1013 data
->spec
.channels
= ChannelsFromDevFmt(device
->FmtChans
);
1015 if(pa_sample_spec_valid(&data
->spec
) == 0)
1017 ERR("Invalid sample format\n");
1018 pa_threaded_mainloop_unlock(data
->loop
);
1022 if(!pa_channel_map_init_auto(&chanmap
, data
->spec
.channels
, PA_CHANNEL_MAP_WAVEEX
))
1024 ERR("Couldn't build map for channel count (%d)!\n", data
->spec
.channels
);
1025 pa_threaded_mainloop_unlock(data
->loop
);
1028 SetDefaultWFXChannelOrder(device
);
1030 data
->attr
.prebuf
= -1;
1031 data
->attr
.fragsize
= -1;
1032 data
->attr
.minreq
= device
->UpdateSize
* pa_frame_size(&data
->spec
);
1033 data
->attr
.tlength
= data
->attr
.minreq
* maxu(device
->NumUpdates
, 2);
1034 data
->attr
.maxlength
= -1;
1036 data
->stream
= connect_playback_stream(data
->device_name
, data
->loop
,
1037 data
->context
, flags
, &data
->attr
,
1038 &data
->spec
, &chanmap
);
1041 pa_threaded_mainloop_unlock(data
->loop
);
1045 pa_stream_set_state_callback(data
->stream
, stream_state_callback2
, device
);
1047 data
->spec
= *(pa_stream_get_sample_spec(data
->stream
));
1048 if(device
->Frequency
!= data
->spec
.rate
)
1050 size_t frame_size
= pa_frame_size(&data
->spec
);
1053 /* Server updated our playback rate, so modify the buffer attribs
1055 data
->attr
.minreq
= (ALuint64
)(data
->attr
.minreq
/frame_size
) *
1056 data
->spec
.rate
/ device
->Frequency
* frame_size
;
1057 data
->attr
.tlength
= data
->attr
.minreq
* maxu(device
->NumUpdates
, 2);
1059 o
= pa_stream_set_buffer_attr(data
->stream
, &data
->attr
,
1060 stream_success_callback
, device
);
1061 while(pa_operation_get_state(o
) == PA_OPERATION_RUNNING
)
1062 pa_threaded_mainloop_wait(data
->loop
);
1063 pa_operation_unref(o
);
1065 device
->Frequency
= data
->spec
.rate
;
1068 #if PA_CHECK_VERSION(0,9,15)
1069 if(pa_stream_set_buffer_attr_callback
)
1070 pa_stream_set_buffer_attr_callback(data
->stream
, stream_buffer_attr_callback
, device
);
1072 pa_stream_set_moved_callback(data
->stream
, stream_device_callback
, device
);
1073 pa_stream_set_write_callback(data
->stream
, stream_write_callback
, device
);
1074 pa_stream_set_underflow_callback(data
->stream
, stream_signal_callback
, device
);
1076 data
->attr
= *(pa_stream_get_buffer_attr(data
->stream
));
1077 device
->UpdateSize
= data
->attr
.minreq
/ pa_frame_size(&data
->spec
);
1078 device
->NumUpdates
= data
->attr
.tlength
/ data
->attr
.minreq
;
1079 if(device
->NumUpdates
<= 1)
1083 ERR("PulseAudio returned minreq=%d, tlength=%d; expect lag or break up\n", data
->attr
.minreq
, data
->attr
.tlength
);
1085 /* Server gave a comparatively large minreq, so modify the tlength. */
1086 device
->NumUpdates
= 2;
1087 data
->attr
.tlength
= data
->attr
.minreq
* device
->NumUpdates
;
1089 o
= pa_stream_set_buffer_attr(data
->stream
, &data
->attr
,
1090 stream_success_callback
, device
);
1091 while(pa_operation_get_state(o
) == PA_OPERATION_RUNNING
)
1092 pa_threaded_mainloop_wait(data
->loop
);
1093 pa_operation_unref(o
);
1096 data
->thread
= StartThread(PulseProc
, device
);
1099 #if PA_CHECK_VERSION(0,9,15)
1100 if(pa_stream_set_buffer_attr_callback
)
1101 pa_stream_set_buffer_attr_callback(data
->stream
, NULL
, NULL
);
1103 pa_stream_set_moved_callback(data
->stream
, NULL
, NULL
);
1104 pa_stream_set_write_callback(data
->stream
, NULL
, NULL
);
1105 pa_stream_set_underflow_callback(data
->stream
, NULL
, NULL
);
1106 pa_stream_disconnect(data
->stream
);
1107 pa_stream_unref(data
->stream
);
1108 data
->stream
= NULL
;
1110 pa_threaded_mainloop_unlock(data
->loop
);
1114 pa_threaded_mainloop_unlock(data
->loop
);
1118 static void pulse_stop_playback(ALCdevice
*device
) //{{{
1120 pulse_data
*data
= device
->ExtraData
;
1125 data
->killNow
= AL_TRUE
;
1128 pa_threaded_mainloop_signal(data
->loop
, 0);
1129 StopThread(data
->thread
);
1130 data
->thread
= NULL
;
1132 data
->killNow
= AL_FALSE
;
1134 pa_threaded_mainloop_lock(data
->loop
);
1136 #if PA_CHECK_VERSION(0,9,15)
1137 if(pa_stream_set_buffer_attr_callback
)
1138 pa_stream_set_buffer_attr_callback(data
->stream
, NULL
, NULL
);
1140 pa_stream_set_moved_callback(data
->stream
, NULL
, NULL
);
1141 pa_stream_set_write_callback(data
->stream
, NULL
, NULL
);
1142 pa_stream_set_underflow_callback(data
->stream
, NULL
, NULL
);
1143 pa_stream_disconnect(data
->stream
);
1144 pa_stream_unref(data
->stream
);
1145 data
->stream
= NULL
;
1147 pa_threaded_mainloop_unlock(data
->loop
);
1151 static ALCenum
pulse_open_capture(ALCdevice
*device
, const ALCchar
*device_name
) //{{{
1153 char *pulse_name
= NULL
;
1155 pa_stream_flags_t flags
= 0;
1156 pa_channel_map chanmap
;
1159 if(!allCaptureDevNameMap
)
1160 probe_devices(AL_TRUE
);
1162 if(!device_name
&& numCaptureDevNames
> 0)
1164 device_name
= allCaptureDevNameMap
[0].name
;
1165 pulse_name
= allCaptureDevNameMap
[0].device_name
;
1170 for(i
= 0;i
< numCaptureDevNames
;i
++)
1172 if(strcmp(device_name
, allCaptureDevNameMap
[i
].name
) == 0)
1174 pulse_name
= allCaptureDevNameMap
[i
].device_name
;
1178 if(i
== numCaptureDevNames
)
1179 return ALC_INVALID_VALUE
;
1182 if(pulse_open(device
, device_name
) == ALC_FALSE
)
1183 return ALC_INVALID_VALUE
;
1185 data
= device
->ExtraData
;
1186 pa_threaded_mainloop_lock(data
->loop
);
1188 data
->spec
.rate
= device
->Frequency
;
1189 data
->spec
.channels
= ChannelsFromDevFmt(device
->FmtChans
);
1191 switch(device
->FmtType
)
1194 data
->spec
.format
= PA_SAMPLE_U8
;
1197 data
->spec
.format
= PA_SAMPLE_S16NE
;
1200 data
->spec
.format
= PA_SAMPLE_S32NE
;
1203 data
->spec
.format
= PA_SAMPLE_FLOAT32NE
;
1208 ERR("%s capture samples not supported\n", DevFmtTypeString(device
->FmtType
));
1209 pa_threaded_mainloop_unlock(data
->loop
);
1213 if(pa_sample_spec_valid(&data
->spec
) == 0)
1215 ERR("Invalid sample format\n");
1216 pa_threaded_mainloop_unlock(data
->loop
);
1220 if(!pa_channel_map_init_auto(&chanmap
, data
->spec
.channels
, PA_CHANNEL_MAP_WAVEEX
))
1222 ERR("Couldn't build map for channel count (%d)!\n", data
->spec
.channels
);
1223 pa_threaded_mainloop_unlock(data
->loop
);
1227 samples
= device
->UpdateSize
* device
->NumUpdates
;
1228 samples
= maxu(samples
, 100 * device
->Frequency
/ 1000);
1230 data
->attr
.minreq
= -1;
1231 data
->attr
.prebuf
= -1;
1232 data
->attr
.maxlength
= samples
* pa_frame_size(&data
->spec
);
1233 data
->attr
.tlength
= -1;
1234 data
->attr
.fragsize
= minu(samples
, 50*device
->Frequency
/1000) *
1235 pa_frame_size(&data
->spec
);
1237 flags
|= PA_STREAM_START_CORKED
|PA_STREAM_ADJUST_LATENCY
;
1238 data
->stream
= connect_record_stream(pulse_name
, data
->loop
, data
->context
,
1239 flags
, &data
->attr
, &data
->spec
,
1243 pa_threaded_mainloop_unlock(data
->loop
);
1247 pa_stream_set_state_callback(data
->stream
, stream_state_callback2
, device
);
1249 pa_threaded_mainloop_unlock(data
->loop
);
1250 return ALC_NO_ERROR
;
1253 pulse_close(device
);
1254 return ALC_INVALID_VALUE
;
1257 static void pulse_close_capture(ALCdevice
*device
) //{{{
1259 pulse_close(device
);
1262 static void pulse_start_capture(ALCdevice
*device
) //{{{
1264 pulse_data
*data
= device
->ExtraData
;
1267 pa_threaded_mainloop_lock(data
->loop
);
1268 o
= pa_stream_cork(data
->stream
, 0, stream_success_callback
, device
);
1269 while(pa_operation_get_state(o
) == PA_OPERATION_RUNNING
)
1270 pa_threaded_mainloop_wait(data
->loop
);
1271 pa_operation_unref(o
);
1272 pa_threaded_mainloop_unlock(data
->loop
);
1275 static void pulse_stop_capture(ALCdevice
*device
) //{{{
1277 pulse_data
*data
= device
->ExtraData
;
1280 pa_threaded_mainloop_lock(data
->loop
);
1281 o
= pa_stream_cork(data
->stream
, 1, stream_success_callback
, device
);
1282 while(pa_operation_get_state(o
) == PA_OPERATION_RUNNING
)
1283 pa_threaded_mainloop_wait(data
->loop
);
1284 pa_operation_unref(o
);
1285 pa_threaded_mainloop_unlock(data
->loop
);
1288 static ALCenum
pulse_capture_samples(ALCdevice
*device
, ALCvoid
*buffer
, ALCuint samples
) //{{{
1290 pulse_data
*data
= device
->ExtraData
;
1291 ALCuint todo
= samples
* pa_frame_size(&data
->spec
);
1293 pa_threaded_mainloop_lock(data
->loop
);
1294 /* Capture is done in fragment-sized chunks, so we loop until we get all
1295 * that's available */
1296 data
->last_readable
-= todo
;
1301 if(data
->cap_len
== 0)
1303 pa_stream_state_t state
;
1305 state
= pa_stream_get_state(data
->stream
);
1306 if(!PA_STREAM_IS_GOOD(state
))
1308 aluHandleDisconnect(device
);
1311 if(pa_stream_peek(data
->stream
, &data
->cap_store
, &data
->cap_len
) < 0)
1313 ERR("pa_stream_peek() failed: %s\n",
1314 pa_strerror(pa_context_errno(data
->context
)));
1315 aluHandleDisconnect(device
);
1318 data
->cap_remain
= data
->cap_len
;
1320 if(rem
> data
->cap_remain
)
1321 rem
= data
->cap_remain
;
1323 memcpy(buffer
, data
->cap_store
, rem
);
1325 buffer
= (ALbyte
*)buffer
+ rem
;
1328 data
->cap_store
= (ALbyte
*)data
->cap_store
+ rem
;
1329 data
->cap_remain
-= rem
;
1330 if(data
->cap_remain
== 0)
1332 pa_stream_drop(data
->stream
);
1337 memset(buffer
, ((device
->FmtType
==DevFmtUByte
) ? 0x80 : 0), todo
);
1338 pa_threaded_mainloop_unlock(data
->loop
);
1340 return ALC_NO_ERROR
;
1343 static ALCuint
pulse_available_samples(ALCdevice
*device
) //{{{
1345 pulse_data
*data
= device
->ExtraData
;
1346 size_t readable
= data
->cap_remain
;
1348 pa_threaded_mainloop_lock(data
->loop
);
1349 if(device
->Connected
)
1351 ssize_t got
= pa_stream_readable_size(data
->stream
);
1352 if(got
> 0 && (size_t)got
> data
->cap_len
)
1353 readable
+= got
- data
->cap_len
;
1355 pa_threaded_mainloop_unlock(data
->loop
);
1357 if(data
->last_readable
< readable
)
1358 data
->last_readable
= readable
;
1359 return data
->last_readable
/ pa_frame_size(&data
->spec
);
1363 static const BackendFuncs pulse_funcs
= { //{{{
1364 pulse_open_playback
,
1365 pulse_close_playback
,
1366 pulse_reset_playback
,
1367 pulse_stop_playback
,
1369 pulse_close_capture
,
1370 pulse_start_capture
,
1372 pulse_capture_samples
,
1373 pulse_available_samples
1376 ALCboolean
alc_pulse_init(BackendFuncs
*func_list
) //{{{
1378 ALCboolean ret
= ALC_FALSE
;
1382 pa_threaded_mainloop
*loop
;
1384 pulse_ctx_flags
= 0;
1385 if(!GetConfigValueBool("pulse", "spawn-server", 0))
1386 pulse_ctx_flags
|= PA_CONTEXT_NOAUTOSPAWN
;
1388 if((loop
=pa_threaded_mainloop_new()) &&
1389 pa_threaded_mainloop_start(loop
) >= 0)
1391 pa_context
*context
;
1393 pa_threaded_mainloop_lock(loop
);
1394 context
= connect_context(loop
, AL_TRUE
);
1399 pa_context_disconnect(context
);
1400 pa_context_unref(context
);
1402 pa_threaded_mainloop_unlock(loop
);
1403 pa_threaded_mainloop_stop(loop
);
1406 pa_threaded_mainloop_free(loop
);
1409 if(ret
!= ALC_FALSE
)
1410 *func_list
= pulse_funcs
;
1414 void alc_pulse_deinit(void) //{{{
1418 for(i
= 0;i
< numDevNames
;++i
)
1420 free(allDevNameMap
[i
].name
);
1421 free(allDevNameMap
[i
].device_name
);
1423 free(allDevNameMap
);
1424 allDevNameMap
= NULL
;
1427 for(i
= 0;i
< numCaptureDevNames
;++i
)
1429 free(allCaptureDevNameMap
[i
].name
);
1430 free(allCaptureDevNameMap
[i
].device_name
);
1432 free(allCaptureDevNameMap
);
1433 allCaptureDevNameMap
= NULL
;
1434 numCaptureDevNames
= 0;
1438 CloseLib(pa_handle
);
1443 void alc_pulse_probe(enum DevProbe type
) //{{{
1449 case ALL_DEVICE_PROBE
:
1450 for(i
= 0;i
< numDevNames
;++i
)
1452 free(allDevNameMap
[i
].name
);
1453 free(allDevNameMap
[i
].device_name
);
1455 free(allDevNameMap
);
1456 allDevNameMap
= NULL
;
1459 probe_devices(AL_FALSE
);
1461 for(i
= 0;i
< numDevNames
;i
++)
1462 AppendAllDeviceList(allDevNameMap
[i
].name
);
1465 case CAPTURE_DEVICE_PROBE
:
1466 for(i
= 0;i
< numCaptureDevNames
;++i
)
1468 free(allCaptureDevNameMap
[i
].name
);
1469 free(allCaptureDevNameMap
[i
].device_name
);
1471 free(allCaptureDevNameMap
);
1472 allCaptureDevNameMap
= NULL
;
1473 numCaptureDevNames
= 0;
1475 probe_devices(AL_TRUE
);
1477 for(i
= 0;i
< numCaptureDevNames
;i
++)
1478 AppendCaptureDeviceList(allCaptureDevNameMap
[i
].name
);