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_cork
);
65 MAKE_FUNC(pa_stream_is_suspended
);
66 MAKE_FUNC(pa_stream_get_device_name
);
67 MAKE_FUNC(pa_path_get_filename
);
68 MAKE_FUNC(pa_get_binary_name
);
69 MAKE_FUNC(pa_threaded_mainloop_free
);
70 MAKE_FUNC(pa_context_errno
);
71 MAKE_FUNC(pa_xmalloc
);
72 MAKE_FUNC(pa_stream_unref
);
73 MAKE_FUNC(pa_threaded_mainloop_accept
);
74 MAKE_FUNC(pa_stream_set_write_callback
);
75 MAKE_FUNC(pa_threaded_mainloop_new
);
76 MAKE_FUNC(pa_context_connect
);
77 MAKE_FUNC(pa_stream_set_buffer_attr
);
78 MAKE_FUNC(pa_stream_get_buffer_attr
);
79 MAKE_FUNC(pa_stream_get_sample_spec
);
80 MAKE_FUNC(pa_stream_get_time
);
81 MAKE_FUNC(pa_stream_set_read_callback
);
82 MAKE_FUNC(pa_stream_set_state_callback
);
83 MAKE_FUNC(pa_stream_set_moved_callback
);
84 MAKE_FUNC(pa_stream_set_underflow_callback
);
85 MAKE_FUNC(pa_stream_new
);
86 MAKE_FUNC(pa_stream_disconnect
);
87 MAKE_FUNC(pa_threaded_mainloop_lock
);
88 MAKE_FUNC(pa_channel_map_init_auto
);
89 MAKE_FUNC(pa_channel_map_parse
);
90 MAKE_FUNC(pa_channel_map_snprint
);
91 MAKE_FUNC(pa_channel_map_equal
);
92 MAKE_FUNC(pa_context_get_server_info
);
93 MAKE_FUNC(pa_context_get_sink_info_by_name
);
94 MAKE_FUNC(pa_context_get_sink_info_list
);
95 MAKE_FUNC(pa_context_get_source_info_by_name
);
96 MAKE_FUNC(pa_context_get_source_info_list
);
97 MAKE_FUNC(pa_operation_get_state
);
98 MAKE_FUNC(pa_operation_unref
);
99 #if PA_CHECK_VERSION(0,9,15)
100 MAKE_FUNC(pa_channel_map_superset
);
101 MAKE_FUNC(pa_stream_set_buffer_attr_callback
);
103 #if PA_CHECK_VERSION(0,9,16)
104 MAKE_FUNC(pa_stream_begin_write
);
108 #define pa_context_unref ppa_context_unref
109 #define pa_sample_spec_valid ppa_sample_spec_valid
110 #define pa_frame_size ppa_frame_size
111 #define pa_stream_drop ppa_stream_drop
112 #define pa_strerror ppa_strerror
113 #define pa_context_get_state ppa_context_get_state
114 #define pa_stream_get_state ppa_stream_get_state
115 #define pa_threaded_mainloop_signal ppa_threaded_mainloop_signal
116 #define pa_stream_peek ppa_stream_peek
117 #define pa_threaded_mainloop_wait ppa_threaded_mainloop_wait
118 #define pa_threaded_mainloop_unlock ppa_threaded_mainloop_unlock
119 #define pa_threaded_mainloop_in_thread ppa_threaded_mainloop_in_thread
120 #define pa_context_new ppa_context_new
121 #define pa_threaded_mainloop_stop ppa_threaded_mainloop_stop
122 #define pa_context_disconnect ppa_context_disconnect
123 #define pa_threaded_mainloop_start ppa_threaded_mainloop_start
124 #define pa_threaded_mainloop_get_api ppa_threaded_mainloop_get_api
125 #define pa_context_set_state_callback ppa_context_set_state_callback
126 #define pa_stream_write ppa_stream_write
127 #define pa_xfree ppa_xfree
128 #define pa_stream_connect_record ppa_stream_connect_record
129 #define pa_stream_connect_playback ppa_stream_connect_playback
130 #define pa_stream_readable_size ppa_stream_readable_size
131 #define pa_stream_writable_size ppa_stream_writable_size
132 #define pa_stream_cork ppa_stream_cork
133 #define pa_stream_is_suspended ppa_stream_is_suspended
134 #define pa_stream_get_device_name ppa_stream_get_device_name
135 #define pa_path_get_filename ppa_path_get_filename
136 #define pa_get_binary_name ppa_get_binary_name
137 #define pa_threaded_mainloop_free ppa_threaded_mainloop_free
138 #define pa_context_errno ppa_context_errno
139 #define pa_xmalloc ppa_xmalloc
140 #define pa_stream_unref ppa_stream_unref
141 #define pa_threaded_mainloop_accept ppa_threaded_mainloop_accept
142 #define pa_stream_set_write_callback ppa_stream_set_write_callback
143 #define pa_threaded_mainloop_new ppa_threaded_mainloop_new
144 #define pa_context_connect ppa_context_connect
145 #define pa_stream_set_buffer_attr ppa_stream_set_buffer_attr
146 #define pa_stream_get_buffer_attr ppa_stream_get_buffer_attr
147 #define pa_stream_get_sample_spec ppa_stream_get_sample_spec
148 #define pa_stream_get_time ppa_stream_get_time
149 #define pa_stream_set_read_callback ppa_stream_set_read_callback
150 #define pa_stream_set_state_callback ppa_stream_set_state_callback
151 #define pa_stream_set_moved_callback ppa_stream_set_moved_callback
152 #define pa_stream_set_underflow_callback ppa_stream_set_underflow_callback
153 #define pa_stream_new ppa_stream_new
154 #define pa_stream_disconnect ppa_stream_disconnect
155 #define pa_threaded_mainloop_lock ppa_threaded_mainloop_lock
156 #define pa_channel_map_init_auto ppa_channel_map_init_auto
157 #define pa_channel_map_parse ppa_channel_map_parse
158 #define pa_channel_map_snprint ppa_channel_map_snprint
159 #define pa_channel_map_equal ppa_channel_map_equal
160 #define pa_context_get_server_info ppa_context_get_server_info
161 #define pa_context_get_sink_info_by_name ppa_context_get_sink_info_by_name
162 #define pa_context_get_sink_info_list ppa_context_get_sink_info_list
163 #define pa_context_get_source_info_by_name ppa_context_get_source_info_by_name
164 #define pa_context_get_source_info_list ppa_context_get_source_info_list
165 #define pa_operation_get_state ppa_operation_get_state
166 #define pa_operation_unref ppa_operation_unref
167 #if PA_CHECK_VERSION(0,9,15)
168 #define pa_channel_map_superset ppa_channel_map_superset
169 #define pa_stream_set_buffer_attr_callback ppa_stream_set_buffer_attr_callback
171 #if PA_CHECK_VERSION(0,9,16)
172 #define pa_stream_begin_write ppa_stream_begin_write
178 #define PATH_MAX 4096
184 const void *cap_store
;
188 ALCuint last_readable
;
193 pa_threaded_mainloop
*loop
;
196 volatile ALboolean killNow
;
208 static DevMap
*allDevNameMap
;
209 static ALuint numDevNames
;
210 static DevMap
*allCaptureDevNameMap
;
211 static ALuint numCaptureDevNames
;
212 static pa_context_flags_t pulse_ctx_flags
;
215 static void context_state_callback(pa_context
*context
, void *pdata
)
217 pa_threaded_mainloop
*loop
= pdata
;
218 pa_context_state_t state
;
220 state
= pa_context_get_state(context
);
221 if(state
== PA_CONTEXT_READY
|| !PA_CONTEXT_IS_GOOD(state
))
222 pa_threaded_mainloop_signal(loop
, 0);
225 static pa_context
*connect_context(pa_threaded_mainloop
*loop
, ALboolean silent
)
227 const char *name
= "OpenAL Soft";
228 char path_name
[PATH_MAX
];
229 pa_context_state_t state
;
233 if(pa_get_binary_name(path_name
, sizeof(path_name
)))
234 name
= pa_path_get_filename(path_name
);
236 context
= pa_context_new(pa_threaded_mainloop_get_api(loop
), name
);
239 ERR("pa_context_new() failed\n");
243 pa_context_set_state_callback(context
, context_state_callback
, loop
);
245 if((err
=pa_context_connect(context
, NULL
, pulse_ctx_flags
, NULL
)) >= 0)
247 while((state
=pa_context_get_state(context
)) != PA_CONTEXT_READY
)
249 if(!PA_CONTEXT_IS_GOOD(state
))
251 err
= pa_context_errno(context
);
252 if(err
> 0) err
= -err
;
256 pa_threaded_mainloop_wait(loop
);
259 pa_context_set_state_callback(context
, NULL
, NULL
);
264 ERR("Context did not connect: %s\n", pa_strerror(err
));
265 pa_context_unref(context
);
273 static ALCboolean
pulse_load(void) //{{{
275 ALCboolean ret
= ALC_TRUE
;
280 #define PALIB "libpulse-0.dll"
281 #elif defined(__APPLE__) && defined(__MACH__)
282 #define PALIB "libpulse.0.dylib"
284 #define PALIB "libpulse.so.0"
286 pa_handle
= LoadLib(PALIB
);
290 #define LOAD_FUNC(x) do { \
291 p##x = GetSymbol(pa_handle, #x); \
296 LOAD_FUNC(pa_context_unref
);
297 LOAD_FUNC(pa_sample_spec_valid
);
298 LOAD_FUNC(pa_stream_drop
);
299 LOAD_FUNC(pa_frame_size
);
300 LOAD_FUNC(pa_strerror
);
301 LOAD_FUNC(pa_context_get_state
);
302 LOAD_FUNC(pa_stream_get_state
);
303 LOAD_FUNC(pa_threaded_mainloop_signal
);
304 LOAD_FUNC(pa_stream_peek
);
305 LOAD_FUNC(pa_threaded_mainloop_wait
);
306 LOAD_FUNC(pa_threaded_mainloop_unlock
);
307 LOAD_FUNC(pa_threaded_mainloop_in_thread
);
308 LOAD_FUNC(pa_context_new
);
309 LOAD_FUNC(pa_threaded_mainloop_stop
);
310 LOAD_FUNC(pa_context_disconnect
);
311 LOAD_FUNC(pa_threaded_mainloop_start
);
312 LOAD_FUNC(pa_threaded_mainloop_get_api
);
313 LOAD_FUNC(pa_context_set_state_callback
);
314 LOAD_FUNC(pa_stream_write
);
316 LOAD_FUNC(pa_stream_connect_record
);
317 LOAD_FUNC(pa_stream_connect_playback
);
318 LOAD_FUNC(pa_stream_readable_size
);
319 LOAD_FUNC(pa_stream_writable_size
);
320 LOAD_FUNC(pa_stream_cork
);
321 LOAD_FUNC(pa_stream_is_suspended
);
322 LOAD_FUNC(pa_stream_get_device_name
);
323 LOAD_FUNC(pa_path_get_filename
);
324 LOAD_FUNC(pa_get_binary_name
);
325 LOAD_FUNC(pa_threaded_mainloop_free
);
326 LOAD_FUNC(pa_context_errno
);
327 LOAD_FUNC(pa_xmalloc
);
328 LOAD_FUNC(pa_stream_unref
);
329 LOAD_FUNC(pa_threaded_mainloop_accept
);
330 LOAD_FUNC(pa_stream_set_write_callback
);
331 LOAD_FUNC(pa_threaded_mainloop_new
);
332 LOAD_FUNC(pa_context_connect
);
333 LOAD_FUNC(pa_stream_set_buffer_attr
);
334 LOAD_FUNC(pa_stream_get_buffer_attr
);
335 LOAD_FUNC(pa_stream_get_sample_spec
);
336 LOAD_FUNC(pa_stream_get_time
);
337 LOAD_FUNC(pa_stream_set_read_callback
);
338 LOAD_FUNC(pa_stream_set_state_callback
);
339 LOAD_FUNC(pa_stream_set_moved_callback
);
340 LOAD_FUNC(pa_stream_set_underflow_callback
);
341 LOAD_FUNC(pa_stream_new
);
342 LOAD_FUNC(pa_stream_disconnect
);
343 LOAD_FUNC(pa_threaded_mainloop_lock
);
344 LOAD_FUNC(pa_channel_map_init_auto
);
345 LOAD_FUNC(pa_channel_map_parse
);
346 LOAD_FUNC(pa_channel_map_snprint
);
347 LOAD_FUNC(pa_channel_map_equal
);
348 LOAD_FUNC(pa_context_get_server_info
);
349 LOAD_FUNC(pa_context_get_sink_info_by_name
);
350 LOAD_FUNC(pa_context_get_sink_info_list
);
351 LOAD_FUNC(pa_context_get_source_info_by_name
);
352 LOAD_FUNC(pa_context_get_source_info_list
);
353 LOAD_FUNC(pa_operation_get_state
);
354 LOAD_FUNC(pa_operation_unref
);
356 #define LOAD_OPTIONAL_FUNC(x) do { \
357 p##x = GetSymbol(pa_handle, #x); \
359 #if PA_CHECK_VERSION(0,9,15)
360 LOAD_OPTIONAL_FUNC(pa_channel_map_superset
);
361 LOAD_OPTIONAL_FUNC(pa_stream_set_buffer_attr_callback
);
363 #if PA_CHECK_VERSION(0,9,16)
364 LOAD_OPTIONAL_FUNC(pa_stream_begin_write
);
366 #undef LOAD_OPTIONAL_FUNC
374 #endif /* HAVE_DYNLOAD */
378 // PulseAudio Event Callbacks //{{{
379 static void stream_state_callback(pa_stream
*stream
, void *pdata
) //{{{
381 pa_threaded_mainloop
*loop
= pdata
;
382 pa_stream_state_t state
;
384 state
= pa_stream_get_state(stream
);
385 if(state
== PA_STREAM_READY
|| !PA_STREAM_IS_GOOD(state
))
386 pa_threaded_mainloop_signal(loop
, 0);
389 static void stream_signal_callback(pa_stream
*stream
, void *pdata
) //{{{
391 ALCdevice
*Device
= pdata
;
392 pulse_data
*data
= Device
->ExtraData
;
395 pa_threaded_mainloop_signal(data
->loop
, 0);
398 static void stream_buffer_attr_callback(pa_stream
*stream
, void *pdata
) //{{{
400 ALCdevice
*device
= pdata
;
401 pulse_data
*data
= device
->ExtraData
;
403 data
->attr
= *pa_stream_get_buffer_attr(stream
);
404 WARN("PulseAudio modified buffer length: minreq=%d, tlength=%d\n", data
->attr
.minreq
, data
->attr
.tlength
);
406 device
->UpdateSize
= data
->attr
.minreq
/ pa_frame_size(&data
->spec
);
407 device
->NumUpdates
= data
->attr
.tlength
/ data
->attr
.minreq
;
410 static void context_state_callback2(pa_context
*context
, void *pdata
) //{{{
412 ALCdevice
*Device
= pdata
;
413 pulse_data
*data
= Device
->ExtraData
;
415 if(pa_context_get_state(context
) == PA_CONTEXT_FAILED
)
417 ERR("Received context failure!\n");
418 aluHandleDisconnect(Device
);
420 pa_threaded_mainloop_signal(data
->loop
, 0);
423 static void stream_state_callback2(pa_stream
*stream
, void *pdata
) //{{{
425 ALCdevice
*Device
= pdata
;
426 pulse_data
*data
= Device
->ExtraData
;
428 if(pa_stream_get_state(stream
) == PA_STREAM_FAILED
)
430 ERR("Received stream failure!\n");
431 aluHandleDisconnect(Device
);
433 pa_threaded_mainloop_signal(data
->loop
, 0);
436 static void stream_success_callback(pa_stream
*stream
, int success
, void *pdata
) //{{{
438 ALCdevice
*Device
= pdata
;
439 pulse_data
*data
= Device
->ExtraData
;
443 pa_threaded_mainloop_signal(data
->loop
, 0);
446 static void sink_info_callback(pa_context
*context
, const pa_sink_info
*info
, int eol
, void *pdata
) //{{{
448 ALCdevice
*device
= pdata
;
449 pulse_data
*data
= device
->ExtraData
;
450 char chanmap_str
[256] = "";
453 enum DevFmtChannels chans
;
455 { "front-left,front-right,front-center,lfe,rear-left,rear-right,side-left,side-right",
457 { "front-left,front-right,front-center,lfe,rear-center,side-left,side-right",
459 { "front-left,front-right,front-center,lfe,rear-left,rear-right",
461 { "front-left,front-right,front-center,lfe,side-left,side-right",
463 { "front-left,front-right,rear-left,rear-right", DevFmtQuad
},
464 { "front-left,front-right", DevFmtStereo
},
465 { "mono", DevFmtMono
},
473 pa_threaded_mainloop_signal(data
->loop
, 0);
477 for(i
= 0;chanmaps
[i
].str
;i
++)
480 if(!pa_channel_map_parse(&map
, chanmaps
[i
].str
))
483 if(pa_channel_map_equal(&info
->channel_map
, &map
)
484 #if PA_CHECK_VERSION(0,9,15)
485 || (pa_channel_map_superset
&&
486 pa_channel_map_superset(&info
->channel_map
, &map
))
490 device
->FmtChans
= chanmaps
[i
].chans
;
495 pa_channel_map_snprint(chanmap_str
, sizeof(chanmap_str
), &info
->channel_map
);
496 ERR("Failed to find format for channel map:\n %s\n", chanmap_str
);
499 static void sink_device_callback(pa_context
*context
, const pa_sink_info
*info
, int eol
, void *pdata
) //{{{
501 pa_threaded_mainloop
*loop
= pdata
;
509 pa_threaded_mainloop_signal(loop
, 0);
513 for(i
= 0;i
< numDevNames
;i
++)
515 if(strcmp(info
->name
, allDevNameMap
[i
].device_name
) == 0)
519 TRACE("Got device \"%s\", \"%s\"\n", info
->description
, info
->name
);
521 temp
= realloc(allDevNameMap
, (numDevNames
+1) * sizeof(*allDevNameMap
));
524 allDevNameMap
= temp
;
525 allDevNameMap
[numDevNames
].name
= strdup(info
->description
);
526 allDevNameMap
[numDevNames
].device_name
= strdup(info
->name
);
531 static void source_device_callback(pa_context
*context
, const pa_source_info
*info
, int eol
, void *pdata
) //{{{
533 pa_threaded_mainloop
*loop
= pdata
;
541 pa_threaded_mainloop_signal(loop
, 0);
545 for(i
= 0;i
< numCaptureDevNames
;i
++)
547 if(strcmp(info
->name
, allCaptureDevNameMap
[i
].device_name
) == 0)
551 TRACE("Got device \"%s\", \"%s\"\n", info
->description
, info
->name
);
553 temp
= realloc(allCaptureDevNameMap
, (numCaptureDevNames
+1) * sizeof(*allCaptureDevNameMap
));
556 allCaptureDevNameMap
= temp
;
557 allCaptureDevNameMap
[numCaptureDevNames
].name
= strdup(info
->description
);
558 allCaptureDevNameMap
[numCaptureDevNames
].device_name
= strdup(info
->name
);
559 numCaptureDevNames
++;
565 static pa_stream
*connect_playback_stream(const char *device_name
,
566 pa_threaded_mainloop
*loop
, pa_context
*context
,
567 pa_stream_flags_t flags
, pa_buffer_attr
*attr
, pa_sample_spec
*spec
,
568 pa_channel_map
*chanmap
)
570 pa_stream_state_t state
;
573 stream
= pa_stream_new(context
, "Playback Stream", spec
, chanmap
);
576 ERR("pa_stream_new() failed: %s\n", pa_strerror(pa_context_errno(context
)));
580 pa_stream_set_state_callback(stream
, stream_state_callback
, loop
);
582 if(pa_stream_connect_playback(stream
, device_name
, attr
, flags
, NULL
, NULL
) < 0)
584 ERR("Stream did not connect: %s\n", pa_strerror(pa_context_errno(context
)));
585 pa_stream_unref(stream
);
589 while((state
=pa_stream_get_state(stream
)) != PA_STREAM_READY
)
591 if(!PA_STREAM_IS_GOOD(state
))
593 ERR("Stream did not get ready: %s\n", pa_strerror(pa_context_errno(context
)));
594 pa_stream_unref(stream
);
598 pa_threaded_mainloop_wait(loop
);
600 pa_stream_set_state_callback(stream
, NULL
, NULL
);
605 static pa_stream
*connect_record_stream(const char *device_name
,
606 pa_threaded_mainloop
*loop
, pa_context
*context
,
607 pa_stream_flags_t flags
, pa_buffer_attr
*attr
, pa_sample_spec
*spec
,
608 pa_channel_map
*chanmap
)
610 pa_stream_state_t state
;
613 stream
= pa_stream_new(context
, "Capture Stream", spec
, chanmap
);
616 ERR("pa_stream_new() failed: %s\n", pa_strerror(pa_context_errno(context
)));
620 pa_stream_set_state_callback(stream
, stream_state_callback
, loop
);
622 if(pa_stream_connect_record(stream
, device_name
, attr
, flags
) < 0)
624 ERR("Stream did not connect: %s\n", pa_strerror(pa_context_errno(context
)));
625 pa_stream_unref(stream
);
629 while((state
=pa_stream_get_state(stream
)) != PA_STREAM_READY
)
631 if(!PA_STREAM_IS_GOOD(state
))
633 ERR("Stream did not get ready: %s\n", pa_strerror(pa_context_errno(context
)));
634 pa_stream_unref(stream
);
638 pa_threaded_mainloop_wait(loop
);
640 pa_stream_set_state_callback(stream
, NULL
, NULL
);
646 static void probe_devices(ALboolean capture
)
648 pa_threaded_mainloop
*loop
;
650 if(capture
== AL_FALSE
)
651 allDevNameMap
= malloc(sizeof(DevMap
) * 1);
653 allCaptureDevNameMap
= malloc(sizeof(DevMap
) * 1);
655 if((loop
=pa_threaded_mainloop_new()) &&
656 pa_threaded_mainloop_start(loop
) >= 0)
660 pa_threaded_mainloop_lock(loop
);
661 context
= connect_context(loop
, AL_FALSE
);
666 if(capture
== AL_FALSE
)
668 pa_stream_flags_t flags
;
672 flags
= PA_STREAM_FIX_FORMAT
| PA_STREAM_FIX_RATE
|
673 PA_STREAM_FIX_CHANNELS
| PA_STREAM_DONT_MOVE
;
675 spec
.format
= PA_SAMPLE_S16NE
;
679 stream
= connect_playback_stream(NULL
, loop
, context
, flags
,
683 o
= pa_context_get_sink_info_by_name(context
, pa_stream_get_device_name(stream
), sink_device_callback
, loop
);
684 while(pa_operation_get_state(o
) == PA_OPERATION_RUNNING
)
685 pa_threaded_mainloop_wait(loop
);
686 pa_operation_unref(o
);
688 pa_stream_disconnect(stream
);
689 pa_stream_unref(stream
);
693 o
= pa_context_get_sink_info_list(context
, sink_device_callback
, loop
);
697 pa_stream_flags_t flags
;
701 flags
= PA_STREAM_FIX_FORMAT
| PA_STREAM_FIX_RATE
|
702 PA_STREAM_FIX_CHANNELS
| PA_STREAM_DONT_MOVE
;
704 spec
.format
= PA_SAMPLE_S16NE
;
708 stream
= connect_record_stream(NULL
, loop
, context
, flags
,
712 o
= pa_context_get_source_info_by_name(context
, pa_stream_get_device_name(stream
), source_device_callback
, loop
);
713 while(pa_operation_get_state(o
) == PA_OPERATION_RUNNING
)
714 pa_threaded_mainloop_wait(loop
);
715 pa_operation_unref(o
);
717 pa_stream_disconnect(stream
);
718 pa_stream_unref(stream
);
722 o
= pa_context_get_source_info_list(context
, source_device_callback
, loop
);
724 while(pa_operation_get_state(o
) == PA_OPERATION_RUNNING
)
725 pa_threaded_mainloop_wait(loop
);
726 pa_operation_unref(o
);
728 pa_context_disconnect(context
);
729 pa_context_unref(context
);
731 pa_threaded_mainloop_unlock(loop
);
732 pa_threaded_mainloop_stop(loop
);
735 pa_threaded_mainloop_free(loop
);
739 static void stream_write_callback(pa_stream
*stream
, size_t len
, void *pdata
)
741 ALCdevice
*Device
= pdata
;
742 pulse_data
*data
= Device
->ExtraData
;
746 pa_threaded_mainloop_signal(data
->loop
, 0);
749 static ALuint
PulseProc(ALvoid
*param
)
751 ALCdevice
*Device
= param
;
752 pulse_data
*data
= Device
->ExtraData
;
758 frame_size
= pa_frame_size(&data
->spec
);
759 pa_threaded_mainloop_lock(data
->loop
);
761 len
= pa_stream_writable_size(data
->stream
);
762 if(len
< data
->attr
.minreq
)
764 pa_threaded_mainloop_wait(data
->loop
);
767 len
-= len
%data
->attr
.minreq
;
773 pa_free_cb_t free_func
= NULL
;
775 #if PA_CHECK_VERSION(0,9,16)
776 if(!pa_stream_begin_write
||
777 pa_stream_begin_write(data
->stream
, &buf
, &newlen
) < 0)
780 buf
= pa_xmalloc(newlen
);
781 free_func
= pa_xfree
;
783 pa_threaded_mainloop_unlock(data
->loop
);
785 aluMixData(Device
, buf
, newlen
/frame_size
);
787 pa_threaded_mainloop_lock(data
->loop
);
788 pa_stream_write(data
->stream
, buf
, newlen
, free_func
, 0, PA_SEEK_RELATIVE
);
791 } while(!data
->killNow
&& Device
->Connected
);
792 pa_threaded_mainloop_unlock(data
->loop
);
798 static ALCboolean
pulse_open(ALCdevice
*device
, const ALCchar
*device_name
) //{{{
800 pulse_data
*data
= pa_xmalloc(sizeof(pulse_data
));
801 memset(data
, 0, sizeof(*data
));
803 if(!(data
->loop
= pa_threaded_mainloop_new()))
805 ERR("pa_threaded_mainloop_new() failed!\n");
808 if(pa_threaded_mainloop_start(data
->loop
) < 0)
810 ERR("pa_threaded_mainloop_start() failed\n");
814 pa_threaded_mainloop_lock(data
->loop
);
815 device
->ExtraData
= data
;
817 data
->context
= connect_context(data
->loop
, AL_FALSE
);
820 pa_threaded_mainloop_unlock(data
->loop
);
823 pa_context_set_state_callback(data
->context
, context_state_callback2
, device
);
825 device
->szDeviceName
= strdup(device_name
);
827 pa_threaded_mainloop_unlock(data
->loop
);
833 pa_threaded_mainloop_stop(data
->loop
);
834 pa_threaded_mainloop_free(data
->loop
);
837 device
->ExtraData
= NULL
;
842 static void pulse_close(ALCdevice
*device
) //{{{
844 pulse_data
*data
= device
->ExtraData
;
846 pa_threaded_mainloop_lock(data
->loop
);
850 pa_stream_disconnect(data
->stream
);
851 pa_stream_unref(data
->stream
);
854 pa_context_disconnect(data
->context
);
855 pa_context_unref(data
->context
);
857 pa_threaded_mainloop_unlock(data
->loop
);
859 pa_threaded_mainloop_stop(data
->loop
);
860 pa_threaded_mainloop_free(data
->loop
);
862 free(data
->device_name
);
864 device
->ExtraData
= NULL
;
870 static ALCenum
pulse_open_playback(ALCdevice
*device
, const ALCchar
*device_name
) //{{{
872 const char *pulse_name
= NULL
;
876 probe_devices(AL_FALSE
);
878 if(!device_name
&& numDevNames
> 0)
880 device_name
= allDevNameMap
[0].name
;
881 pulse_name
= allDevNameMap
[0].device_name
;
887 for(i
= 0;i
< numDevNames
;i
++)
889 if(strcmp(device_name
, allDevNameMap
[i
].name
) == 0)
891 pulse_name
= allDevNameMap
[i
].device_name
;
896 return ALC_INVALID_VALUE
;
899 if(pulse_open(device
, device_name
) == ALC_FALSE
)
900 return ALC_INVALID_VALUE
;
902 data
= device
->ExtraData
;
903 data
->device_name
= strdup(pulse_name
);
908 static void pulse_close_playback(ALCdevice
*device
) //{{{
913 static ALCboolean
pulse_reset_playback(ALCdevice
*device
) //{{{
915 pulse_data
*data
= device
->ExtraData
;
916 pa_stream_flags_t flags
= 0;
917 pa_channel_map chanmap
;
919 pa_threaded_mainloop_lock(data
->loop
);
921 if(!(device
->Flags
&DEVICE_CHANNELS_REQUEST
))
924 o
= pa_context_get_sink_info_by_name(data
->context
, data
->device_name
, sink_info_callback
, device
);
925 while(pa_operation_get_state(o
) == PA_OPERATION_RUNNING
)
926 pa_threaded_mainloop_wait(data
->loop
);
927 pa_operation_unref(o
);
929 if(!(device
->Flags
&DEVICE_FREQUENCY_REQUEST
))
930 flags
|= PA_STREAM_FIX_RATE
;
932 flags
|= PA_STREAM_EARLY_REQUESTS
;
933 flags
|= PA_STREAM_INTERPOLATE_TIMING
| PA_STREAM_AUTO_TIMING_UPDATE
;
934 flags
|= PA_STREAM_DONT_MOVE
;
936 switch(device
->FmtType
)
939 device
->FmtType
= DevFmtUByte
;
942 data
->spec
.format
= PA_SAMPLE_U8
;
945 device
->FmtType
= DevFmtShort
;
948 data
->spec
.format
= PA_SAMPLE_S16NE
;
951 device
->FmtType
= DevFmtInt
;
954 data
->spec
.format
= PA_SAMPLE_S32NE
;
957 data
->spec
.format
= PA_SAMPLE_FLOAT32NE
;
960 data
->spec
.rate
= device
->Frequency
;
961 data
->spec
.channels
= ChannelsFromDevFmt(device
->FmtChans
);
963 if(pa_sample_spec_valid(&data
->spec
) == 0)
965 ERR("Invalid sample format\n");
966 pa_threaded_mainloop_unlock(data
->loop
);
970 if(!pa_channel_map_init_auto(&chanmap
, data
->spec
.channels
, PA_CHANNEL_MAP_WAVEEX
))
972 ERR("Couldn't build map for channel count (%d)!\n", data
->spec
.channels
);
973 pa_threaded_mainloop_unlock(data
->loop
);
976 SetDefaultWFXChannelOrder(device
);
978 data
->attr
.prebuf
= -1;
979 data
->attr
.fragsize
= -1;
980 data
->attr
.minreq
= device
->UpdateSize
* pa_frame_size(&data
->spec
);
981 data
->attr
.tlength
= data
->attr
.minreq
* maxu(device
->NumUpdates
, 2);
982 data
->attr
.maxlength
= -1;
984 data
->stream
= connect_playback_stream(data
->device_name
, data
->loop
,
985 data
->context
, flags
, &data
->attr
,
986 &data
->spec
, &chanmap
);
989 pa_threaded_mainloop_unlock(data
->loop
);
993 pa_stream_set_state_callback(data
->stream
, stream_state_callback2
, device
);
995 data
->spec
= *(pa_stream_get_sample_spec(data
->stream
));
996 if(device
->Frequency
!= data
->spec
.rate
)
998 size_t frame_size
= pa_frame_size(&data
->spec
);
1001 /* Server updated our playback rate, so modify the buffer attribs
1003 data
->attr
.minreq
= (ALuint64
)(data
->attr
.minreq
/frame_size
) *
1004 data
->spec
.rate
/ device
->Frequency
* frame_size
;
1005 data
->attr
.tlength
= data
->attr
.minreq
* maxu(device
->NumUpdates
, 2);
1007 o
= pa_stream_set_buffer_attr(data
->stream
, &data
->attr
,
1008 stream_success_callback
, device
);
1009 while(pa_operation_get_state(o
) == PA_OPERATION_RUNNING
)
1010 pa_threaded_mainloop_wait(data
->loop
);
1011 pa_operation_unref(o
);
1013 device
->Frequency
= data
->spec
.rate
;
1016 #if PA_CHECK_VERSION(0,9,15)
1017 if(pa_stream_set_buffer_attr_callback
)
1018 pa_stream_set_buffer_attr_callback(data
->stream
, stream_buffer_attr_callback
, device
);
1020 pa_stream_set_write_callback(data
->stream
, stream_write_callback
, device
);
1021 pa_stream_set_underflow_callback(data
->stream
, stream_signal_callback
, device
);
1023 data
->attr
= *(pa_stream_get_buffer_attr(data
->stream
));
1024 device
->UpdateSize
= data
->attr
.minreq
/ pa_frame_size(&data
->spec
);
1025 device
->NumUpdates
= data
->attr
.tlength
/ data
->attr
.minreq
;
1026 if(device
->NumUpdates
<= 1)
1030 ERR("PulseAudio returned minreq=%d, tlength=%d; expect lag or break up\n", data
->attr
.minreq
, data
->attr
.tlength
);
1032 /* Server gave a comparatively large minreq, so modify the tlength. */
1033 device
->NumUpdates
= 2;
1034 data
->attr
.tlength
= data
->attr
.minreq
* device
->NumUpdates
;
1036 o
= pa_stream_set_buffer_attr(data
->stream
, &data
->attr
,
1037 stream_success_callback
, device
);
1038 while(pa_operation_get_state(o
) == PA_OPERATION_RUNNING
)
1039 pa_threaded_mainloop_wait(data
->loop
);
1040 pa_operation_unref(o
);
1043 data
->thread
= StartThread(PulseProc
, device
);
1046 #if PA_CHECK_VERSION(0,9,15)
1047 if(pa_stream_set_buffer_attr_callback
)
1048 pa_stream_set_buffer_attr_callback(data
->stream
, NULL
, NULL
);
1050 pa_stream_set_write_callback(data
->stream
, NULL
, NULL
);
1051 pa_stream_set_underflow_callback(data
->stream
, NULL
, NULL
);
1052 pa_stream_disconnect(data
->stream
);
1053 pa_stream_unref(data
->stream
);
1054 data
->stream
= NULL
;
1056 pa_threaded_mainloop_unlock(data
->loop
);
1060 pa_threaded_mainloop_unlock(data
->loop
);
1064 static void pulse_stop_playback(ALCdevice
*device
) //{{{
1066 pulse_data
*data
= device
->ExtraData
;
1071 data
->killNow
= AL_TRUE
;
1074 pa_threaded_mainloop_signal(data
->loop
, 0);
1075 StopThread(data
->thread
);
1076 data
->thread
= NULL
;
1078 data
->killNow
= AL_FALSE
;
1080 pa_threaded_mainloop_lock(data
->loop
);
1082 #if PA_CHECK_VERSION(0,9,15)
1083 if(pa_stream_set_buffer_attr_callback
)
1084 pa_stream_set_buffer_attr_callback(data
->stream
, NULL
, NULL
);
1086 pa_stream_set_write_callback(data
->stream
, NULL
, NULL
);
1087 pa_stream_set_underflow_callback(data
->stream
, NULL
, NULL
);
1088 pa_stream_disconnect(data
->stream
);
1089 pa_stream_unref(data
->stream
);
1090 data
->stream
= NULL
;
1092 pa_threaded_mainloop_unlock(data
->loop
);
1096 static ALCenum
pulse_open_capture(ALCdevice
*device
, const ALCchar
*device_name
) //{{{
1098 const char *pulse_name
= NULL
;
1099 pa_stream_flags_t flags
= 0;
1100 pa_channel_map chanmap
;
1104 if(!allCaptureDevNameMap
)
1105 probe_devices(AL_TRUE
);
1107 if(!device_name
&& numCaptureDevNames
> 0)
1109 device_name
= allCaptureDevNameMap
[0].name
;
1110 pulse_name
= allCaptureDevNameMap
[0].device_name
;
1115 for(i
= 0;i
< numCaptureDevNames
;i
++)
1117 if(strcmp(device_name
, allCaptureDevNameMap
[i
].name
) == 0)
1119 pulse_name
= allCaptureDevNameMap
[i
].device_name
;
1123 if(i
== numCaptureDevNames
)
1124 return ALC_INVALID_VALUE
;
1127 if(pulse_open(device
, device_name
) == ALC_FALSE
)
1128 return ALC_INVALID_VALUE
;
1130 data
= device
->ExtraData
;
1131 pa_threaded_mainloop_lock(data
->loop
);
1133 data
->spec
.rate
= device
->Frequency
;
1134 data
->spec
.channels
= ChannelsFromDevFmt(device
->FmtChans
);
1136 switch(device
->FmtType
)
1139 data
->spec
.format
= PA_SAMPLE_U8
;
1142 data
->spec
.format
= PA_SAMPLE_S16NE
;
1145 data
->spec
.format
= PA_SAMPLE_S32NE
;
1148 data
->spec
.format
= PA_SAMPLE_FLOAT32NE
;
1153 ERR("%s capture samples not supported\n", DevFmtTypeString(device
->FmtType
));
1154 pa_threaded_mainloop_unlock(data
->loop
);
1158 if(pa_sample_spec_valid(&data
->spec
) == 0)
1160 ERR("Invalid sample format\n");
1161 pa_threaded_mainloop_unlock(data
->loop
);
1165 if(!pa_channel_map_init_auto(&chanmap
, data
->spec
.channels
, PA_CHANNEL_MAP_WAVEEX
))
1167 ERR("Couldn't build map for channel count (%d)!\n", data
->spec
.channels
);
1168 pa_threaded_mainloop_unlock(data
->loop
);
1172 samples
= device
->UpdateSize
* device
->NumUpdates
;
1173 samples
= maxu(samples
, 100 * device
->Frequency
/ 1000);
1175 data
->attr
.minreq
= -1;
1176 data
->attr
.prebuf
= -1;
1177 data
->attr
.maxlength
= samples
* pa_frame_size(&data
->spec
);
1178 data
->attr
.tlength
= -1;
1179 data
->attr
.fragsize
= minu(samples
, 50*device
->Frequency
/1000) *
1180 pa_frame_size(&data
->spec
);
1182 flags
|= PA_STREAM_DONT_MOVE
;
1183 flags
|= PA_STREAM_START_CORKED
|PA_STREAM_ADJUST_LATENCY
;
1184 data
->stream
= connect_record_stream(pulse_name
, data
->loop
, data
->context
,
1185 flags
, &data
->attr
, &data
->spec
,
1189 pa_threaded_mainloop_unlock(data
->loop
);
1193 pa_stream_set_state_callback(data
->stream
, stream_state_callback2
, device
);
1195 pa_threaded_mainloop_unlock(data
->loop
);
1196 return ALC_NO_ERROR
;
1199 pulse_close(device
);
1200 return ALC_INVALID_VALUE
;
1203 static void pulse_close_capture(ALCdevice
*device
) //{{{
1205 pulse_close(device
);
1208 static void pulse_start_capture(ALCdevice
*device
) //{{{
1210 pulse_data
*data
= device
->ExtraData
;
1213 pa_threaded_mainloop_lock(data
->loop
);
1214 o
= pa_stream_cork(data
->stream
, 0, stream_success_callback
, device
);
1215 while(pa_operation_get_state(o
) == PA_OPERATION_RUNNING
)
1216 pa_threaded_mainloop_wait(data
->loop
);
1217 pa_operation_unref(o
);
1218 pa_threaded_mainloop_unlock(data
->loop
);
1221 static void pulse_stop_capture(ALCdevice
*device
) //{{{
1223 pulse_data
*data
= device
->ExtraData
;
1226 pa_threaded_mainloop_lock(data
->loop
);
1227 o
= pa_stream_cork(data
->stream
, 1, stream_success_callback
, device
);
1228 while(pa_operation_get_state(o
) == PA_OPERATION_RUNNING
)
1229 pa_threaded_mainloop_wait(data
->loop
);
1230 pa_operation_unref(o
);
1231 pa_threaded_mainloop_unlock(data
->loop
);
1234 static ALCenum
pulse_capture_samples(ALCdevice
*device
, ALCvoid
*buffer
, ALCuint samples
) //{{{
1236 pulse_data
*data
= device
->ExtraData
;
1237 ALCuint todo
= samples
* pa_frame_size(&data
->spec
);
1239 pa_threaded_mainloop_lock(data
->loop
);
1240 /* Capture is done in fragment-sized chunks, so we loop until we get all
1241 * that's available */
1242 data
->last_readable
-= todo
;
1247 if(data
->cap_len
== 0)
1249 pa_stream_state_t state
;
1251 state
= pa_stream_get_state(data
->stream
);
1252 if(!PA_STREAM_IS_GOOD(state
))
1254 aluHandleDisconnect(device
);
1257 if(pa_stream_peek(data
->stream
, &data
->cap_store
, &data
->cap_len
) < 0)
1259 ERR("pa_stream_peek() failed: %s\n",
1260 pa_strerror(pa_context_errno(data
->context
)));
1261 aluHandleDisconnect(device
);
1264 data
->cap_remain
= data
->cap_len
;
1266 if(rem
> data
->cap_remain
)
1267 rem
= data
->cap_remain
;
1269 memcpy(buffer
, data
->cap_store
, rem
);
1271 buffer
= (ALbyte
*)buffer
+ rem
;
1274 data
->cap_store
= (ALbyte
*)data
->cap_store
+ rem
;
1275 data
->cap_remain
-= rem
;
1276 if(data
->cap_remain
== 0)
1278 pa_stream_drop(data
->stream
);
1283 memset(buffer
, ((device
->FmtType
==DevFmtUByte
) ? 0x80 : 0), todo
);
1284 pa_threaded_mainloop_unlock(data
->loop
);
1286 return ALC_NO_ERROR
;
1289 static ALCuint
pulse_available_samples(ALCdevice
*device
) //{{{
1291 pulse_data
*data
= device
->ExtraData
;
1292 size_t readable
= data
->cap_remain
;
1294 pa_threaded_mainloop_lock(data
->loop
);
1295 if(device
->Connected
)
1297 ssize_t got
= pa_stream_readable_size(data
->stream
);
1298 if(got
> 0 && (size_t)got
> data
->cap_len
)
1299 readable
+= got
- data
->cap_len
;
1301 pa_threaded_mainloop_unlock(data
->loop
);
1303 if(data
->last_readable
< readable
)
1304 data
->last_readable
= readable
;
1305 return data
->last_readable
/ pa_frame_size(&data
->spec
);
1309 static const BackendFuncs pulse_funcs
= { //{{{
1310 pulse_open_playback
,
1311 pulse_close_playback
,
1312 pulse_reset_playback
,
1313 pulse_stop_playback
,
1315 pulse_close_capture
,
1316 pulse_start_capture
,
1318 pulse_capture_samples
,
1319 pulse_available_samples
1322 ALCboolean
alc_pulse_init(BackendFuncs
*func_list
) //{{{
1324 ALCboolean ret
= ALC_FALSE
;
1328 pa_threaded_mainloop
*loop
;
1330 pulse_ctx_flags
= 0;
1331 if(!GetConfigValueBool("pulse", "spawn-server", 0))
1332 pulse_ctx_flags
|= PA_CONTEXT_NOAUTOSPAWN
;
1334 if((loop
=pa_threaded_mainloop_new()) &&
1335 pa_threaded_mainloop_start(loop
) >= 0)
1337 pa_context
*context
;
1339 pa_threaded_mainloop_lock(loop
);
1340 context
= connect_context(loop
, AL_TRUE
);
1345 pa_context_disconnect(context
);
1346 pa_context_unref(context
);
1348 pa_threaded_mainloop_unlock(loop
);
1349 pa_threaded_mainloop_stop(loop
);
1352 pa_threaded_mainloop_free(loop
);
1355 if(ret
!= ALC_FALSE
)
1356 *func_list
= pulse_funcs
;
1360 void alc_pulse_deinit(void) //{{{
1364 for(i
= 0;i
< numDevNames
;++i
)
1366 free(allDevNameMap
[i
].name
);
1367 free(allDevNameMap
[i
].device_name
);
1369 free(allDevNameMap
);
1370 allDevNameMap
= NULL
;
1373 for(i
= 0;i
< numCaptureDevNames
;++i
)
1375 free(allCaptureDevNameMap
[i
].name
);
1376 free(allCaptureDevNameMap
[i
].device_name
);
1378 free(allCaptureDevNameMap
);
1379 allCaptureDevNameMap
= NULL
;
1380 numCaptureDevNames
= 0;
1384 CloseLib(pa_handle
);
1389 void alc_pulse_probe(enum DevProbe type
) //{{{
1395 case ALL_DEVICE_PROBE
:
1396 for(i
= 0;i
< numDevNames
;++i
)
1398 free(allDevNameMap
[i
].name
);
1399 free(allDevNameMap
[i
].device_name
);
1401 free(allDevNameMap
);
1402 allDevNameMap
= NULL
;
1405 probe_devices(AL_FALSE
);
1407 for(i
= 0;i
< numDevNames
;i
++)
1408 AppendAllDeviceList(allDevNameMap
[i
].name
);
1411 case CAPTURE_DEVICE_PROBE
:
1412 for(i
= 0;i
< numCaptureDevNames
;++i
)
1414 free(allCaptureDevNameMap
[i
].name
);
1415 free(allCaptureDevNameMap
[i
].device_name
);
1417 free(allCaptureDevNameMap
);
1418 allCaptureDevNameMap
= NULL
;
1419 numCaptureDevNames
= 0;
1421 probe_devices(AL_TRUE
);
1423 for(i
= 0;i
< numCaptureDevNames
;i
++)
1424 AppendCaptureDeviceList(allCaptureDevNameMap
[i
].name
);
1432 #warning "Unsupported API version, backend will be unavailable!"
1434 ALCboolean
alc_pulse_init(BackendFuncs
*func_list
)
1435 { return ALC_FALSE
; (void)func_list
; }
1437 void alc_pulse_deinit(void)
1440 void alc_pulse_probe(enum DevProbe type
)