?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Avoid using periods with PulseAudio, and add an option to specify its buffer length
[openal-soft.git] / Alc / pulseaudio.c
blob447a4945a9dd3d5581cdf8a0ddebc3e882692742
1 /**
2 * OpenAL cross platform audio library
3 * Copyright (C) 2009 by Konstantinos Natsakis <konstantinos.natsakis@gmail.com>
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Library General Public
6 * License as published by the Free Software Foundation; either
7 * version 2 of the License, or (at your option) any later version.
8 *
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Library General Public License for more details.
13 *
14 * You should have received a copy of the GNU Library General Public
15 * License along with this library; if not, write to the
16 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
17 * Boston, MA 02111-1307, USA.
18 * Or go to http://www.gnu.org/copyleft/lgpl.html
19 */
20
21 #include "config.h"
22
23 #include "alMain.h"
24 #ifdef HAVE_DLFCN_H
25 #include <dlfcn.h>
26 #endif
27
28 #include <pulse/pulseaudio.h>
29
30 #if PA_API_VERSION == 11
31 #define PA_STREAM_ADJUST_LATENCY 0x2000U
32 static inline int PA_STREAM_IS_GOOD(pa_stream_state_t x)
33 {
34 return (x == PA_STREAM_CREATING || x == PA_STREAM_READY);
35 }
36 static inline int PA_CONTEXT_IS_GOOD(pa_context_state_t x)
37 {
38 return (x == PA_CONTEXT_CONNECTING || x == PA_CONTEXT_AUTHORIZING ||
39 x == PA_CONTEXT_SETTING_NAME || x == PA_CONTEXT_READY);
40 }
41 #define PA_STREAM_IS_GOOD PA_STREAM_IS_GOOD
42 #define PA_CONTEXT_IS_GOOD PA_CONTEXT_IS_GOOD
43 #elif PA_API_VERSION != 12
44 #error Invalid PulseAudio API version
45 #endif
46
47 #ifndef PA_CHECK_VERSION
48 #define PA_CHECK_VERSION(major,minor,micro) \
49 ((PA_MAJOR > (major)) || \
50 (PA_MAJOR == (major) && PA_MINOR > (minor)) || \
51 (PA_MAJOR == (major) && PA_MINOR == (minor) && PA_MICRO >= (micro)))
52 #endif
53
54 static void *pa_handle;
55 #define MAKE_FUNC(x) static typeof(x) * p##x
56 MAKE_FUNC(pa_context_unref);
57 MAKE_FUNC(pa_sample_spec_valid);
58 MAKE_FUNC(pa_stream_drop);
59 MAKE_FUNC(pa_strerror);
60 MAKE_FUNC(pa_context_get_state);
61 MAKE_FUNC(pa_stream_get_state);
62 MAKE_FUNC(pa_threaded_mainloop_signal);
63 MAKE_FUNC(pa_stream_peek);
64 MAKE_FUNC(pa_threaded_mainloop_wait);
65 MAKE_FUNC(pa_threaded_mainloop_unlock);
66 MAKE_FUNC(pa_threaded_mainloop_in_thread);
67 MAKE_FUNC(pa_context_new);
68 MAKE_FUNC(pa_threaded_mainloop_stop);
69 MAKE_FUNC(pa_context_disconnect);
70 MAKE_FUNC(pa_threaded_mainloop_start);
71 MAKE_FUNC(pa_threaded_mainloop_get_api);
72 MAKE_FUNC(pa_context_set_state_callback);
73 MAKE_FUNC(pa_stream_write);
74 MAKE_FUNC(pa_xfree);
75 MAKE_FUNC(pa_stream_connect_record);
76 MAKE_FUNC(pa_stream_connect_playback);
77 MAKE_FUNC(pa_stream_readable_size);
78 MAKE_FUNC(pa_stream_cork);
79 MAKE_FUNC(pa_path_get_filename);
80 MAKE_FUNC(pa_get_binary_name);
81 MAKE_FUNC(pa_threaded_mainloop_free);
82 MAKE_FUNC(pa_context_errno);
83 MAKE_FUNC(pa_xmalloc);
84 MAKE_FUNC(pa_stream_unref);
85 MAKE_FUNC(pa_threaded_mainloop_accept);
86 MAKE_FUNC(pa_stream_set_write_callback);
87 MAKE_FUNC(pa_threaded_mainloop_new);
88 MAKE_FUNC(pa_context_connect);
89 MAKE_FUNC(pa_stream_set_buffer_attr);
90 MAKE_FUNC(pa_stream_get_buffer_attr);
91 MAKE_FUNC(pa_stream_get_sample_spec);
92 MAKE_FUNC(pa_stream_set_read_callback);
93 MAKE_FUNC(pa_stream_set_state_callback);
94 MAKE_FUNC(pa_stream_new);
95 MAKE_FUNC(pa_stream_disconnect);
96 MAKE_FUNC(pa_threaded_mainloop_lock);
97 MAKE_FUNC(pa_channel_map_init_auto);
98 MAKE_FUNC(pa_channel_map_parse);
99 MAKE_FUNC(pa_channel_map_snprint);
100 MAKE_FUNC(pa_channel_map_equal);
101 MAKE_FUNC(pa_context_get_server_info);
102 MAKE_FUNC(pa_context_get_sink_info_by_name);
103 MAKE_FUNC(pa_operation_get_state);
104 MAKE_FUNC(pa_operation_unref);
105 #if PA_CHECK_VERSION(0,9,15)
106 MAKE_FUNC(pa_channel_map_superset);
107 MAKE_FUNC(pa_stream_set_buffer_attr_callback);
108 #endif
109 #if PA_CHECK_VERSION(0,9,16)
110 MAKE_FUNC(pa_stream_begin_write);
111 #endif
112 #undef MAKE_FUNC
113
114 #ifndef PATH_MAX
115 #define PATH_MAX 4096
116 #endif
117
118 typedef struct {
119 ALCuint samples;
120 ALCuint frame_size;
121
122 RingBuffer *ring;
123
124 pa_buffer_attr attr;
125 pa_sample_spec spec;
126
127 char path_name[PATH_MAX];
128 const char *context_name;
129 const char *stream_name;
130
131 pa_threaded_mainloop *loop;
132
133 pa_stream *stream;
134 pa_context *context;
135 } pulse_data;
136
137 static const ALCchar pulse_device[] = "PulseAudio Software";
138 static const ALCchar pulse_capture_device[] = "PulseAudio Capture";
139 static pa_context_flags_t pulse_ctx_flags;
140 static volatile ALuint load_count;
141
142
143 void *pulse_load(void) //{{{
144 {
145 if(load_count == 0)
146 {
147 #ifdef _WIN32
148 pa_handle = LoadLibrary("libpulse-0.dll");
149 #define LOAD_FUNC(x) do { \
150 p##x = GetProcAddress(pa_handle, #x); \
151 if(!(p##x)) { \
152 AL_PRINT("Could not load %s from libpulse-0.dll\n", #x); \
153 FreeLibrary(pa_handle); \
154 pa_handle = NULL; \
155 return NULL; \
156 } \
157 } while(0)
158 #define LOAD_OPTIONAL_FUNC(x) do { \
159 p##x = GetProcAddress(pa_handle, #x); \
160 } while(0)
161
162 #elif defined (HAVE_DLFCN_H)
163
164 const char *err;
165 #if defined(__APPLE__) && defined(__MACH__)
166 pa_handle = dlopen("libpulse.0.dylib", RTLD_NOW);
167 #else
168 pa_handle = dlopen("libpulse.so.0", RTLD_NOW);
169 #endif
170 dlerror();
171
172 #define LOAD_FUNC(x) do { \
173 p##x = dlsym(pa_handle, #x); \
174 if((err=dlerror()) != NULL) { \
175 AL_PRINT("Could not load %s from libpulse: %s\n", #x, err); \
176 dlclose(pa_handle); \
177 pa_handle = NULL; \
178 return NULL; \
179 } \
180 } while(0)
181 #define LOAD_OPTIONAL_FUNC(x) do { \
182 p##x = dlsym(pa_handle, #x); \
183 if((err=dlerror()) != NULL) { \
184 p##x = NULL; \
185 } \
186 } while(0)
187
188 #else
189
190 pa_handle = (void*)0xDEADBEEF;
191 #define LOAD_FUNC(x) p##x = (x)
192 #define LOAD_OPTIONAL_FUNC(x) p##x = (x)
193
194 #endif
195 if(!pa_handle)
196 return NULL;
197
198 LOAD_FUNC(pa_context_unref);
199 LOAD_FUNC(pa_sample_spec_valid);
200 LOAD_FUNC(pa_stream_drop);
201 LOAD_FUNC(pa_strerror);
202 LOAD_FUNC(pa_context_get_state);
203 LOAD_FUNC(pa_stream_get_state);
204 LOAD_FUNC(pa_threaded_mainloop_signal);
205 LOAD_FUNC(pa_stream_peek);
206 LOAD_FUNC(pa_threaded_mainloop_wait);
207 LOAD_FUNC(pa_threaded_mainloop_unlock);
208 LOAD_FUNC(pa_threaded_mainloop_in_thread);
209 LOAD_FUNC(pa_context_new);
210 LOAD_FUNC(pa_threaded_mainloop_stop);
211 LOAD_FUNC(pa_context_disconnect);
212 LOAD_FUNC(pa_threaded_mainloop_start);
213 LOAD_FUNC(pa_threaded_mainloop_get_api);
214 LOAD_FUNC(pa_context_set_state_callback);
215 LOAD_FUNC(pa_stream_write);
216 LOAD_FUNC(pa_xfree);
217 LOAD_FUNC(pa_stream_connect_record);
218 LOAD_FUNC(pa_stream_connect_playback);
219 LOAD_FUNC(pa_stream_readable_size);
220 LOAD_FUNC(pa_stream_cork);
221 LOAD_FUNC(pa_path_get_filename);
222 LOAD_FUNC(pa_get_binary_name);
223 LOAD_FUNC(pa_threaded_mainloop_free);
224 LOAD_FUNC(pa_context_errno);
225 LOAD_FUNC(pa_xmalloc);
226 LOAD_FUNC(pa_stream_unref);
227 LOAD_FUNC(pa_threaded_mainloop_accept);
228 LOAD_FUNC(pa_stream_set_write_callback);
229 LOAD_FUNC(pa_threaded_mainloop_new);
230 LOAD_FUNC(pa_context_connect);
231 LOAD_FUNC(pa_stream_set_buffer_attr);
232 LOAD_FUNC(pa_stream_get_buffer_attr);
233 LOAD_FUNC(pa_stream_get_sample_spec);
234 LOAD_FUNC(pa_stream_set_read_callback);
235 LOAD_FUNC(pa_stream_set_state_callback);
236 LOAD_FUNC(pa_stream_new);
237 LOAD_FUNC(pa_stream_disconnect);
238 LOAD_FUNC(pa_threaded_mainloop_lock);
239 LOAD_FUNC(pa_channel_map_init_auto);
240 LOAD_FUNC(pa_channel_map_parse);
241 LOAD_FUNC(pa_channel_map_snprint);
242 LOAD_FUNC(pa_channel_map_equal);
243 LOAD_FUNC(pa_context_get_server_info);
244 LOAD_FUNC(pa_context_get_sink_info_by_name);
245 LOAD_FUNC(pa_operation_get_state);
246 LOAD_FUNC(pa_operation_unref);
247 #if PA_CHECK_VERSION(0,9,15)
248 LOAD_OPTIONAL_FUNC(pa_channel_map_superset);
249 LOAD_OPTIONAL_FUNC(pa_stream_set_buffer_attr_callback);
250 #endif
251 #if PA_CHECK_VERSION(0,9,16)
252 LOAD_OPTIONAL_FUNC(pa_stream_begin_write);
253 #endif
254
255 #undef LOAD_OPTIONAL_FUNC
256 #undef LOAD_FUNC
257 }
258 ++load_count;
259
260 return pa_handle;
261 } //}}}
262
263 void pulse_unload(void) //{{{
264 {
265 if(load_count == 0 || --load_count > 0)
266 return;
267
268 #ifdef _WIN32
269 FreeLibrary(pa_handle);
270 #elif defined (HAVE_DLFCN_H)
271 dlclose(pa_handle);
272 #endif
273 pa_handle = NULL;
274 } //}}}
275
276
277 // PulseAudio Event Callbacks //{{{
278 static void context_state_callback(pa_context *context, void *pdata) //{{{
279 {
280 ALCdevice *Device = pdata;
281 pulse_data *data = Device->ExtraData;
282 pa_context_state_t state;
283
284 state = ppa_context_get_state(context);
285 if(state == PA_CONTEXT_READY || !PA_CONTEXT_IS_GOOD(state))
286 ppa_threaded_mainloop_signal(data->loop, 0);
287 }//}}}
288
289 static void stream_state_callback(pa_stream *stream, void *pdata) //{{{
290 {
291 ALCdevice *Device = pdata;
292 pulse_data *data = Device->ExtraData;
293 pa_stream_state_t state;
294
295 state = ppa_stream_get_state(stream);
296 if(state == PA_STREAM_READY || !PA_STREAM_IS_GOOD(state))
297 ppa_threaded_mainloop_signal(data->loop, 0);
298 }//}}}
299
300 static void stream_buffer_attr_callback(pa_stream *stream, void *pdata) //{{{
301 {
302 ALCdevice *Device = pdata;
303 pulse_data *data = Device->ExtraData;
304
305 SuspendContext(NULL);
306
307 data->attr = *(ppa_stream_get_buffer_attr(stream));
308 Device->UpdateSize = data->attr.tlength/data->frame_size;
309 Device->NumUpdates = 1;
310
311 ProcessContext(NULL);
312 }//}}}
313
314 static void context_state_callback2(pa_context *context, void *pdata) //{{{
315 {
316 ALCdevice *Device = pdata;
317 pulse_data *data = Device->ExtraData;
318
319 if(ppa_context_get_state(context) == PA_CONTEXT_FAILED)
320 {
321 AL_PRINT("Received context failure!\n");
322 aluHandleDisconnect(Device);
323 }
324 ppa_threaded_mainloop_signal(data->loop, 0);
325 }//}}}
326
327 static void stream_state_callback2(pa_stream *stream, void *pdata) //{{{
328 {
329 ALCdevice *Device = pdata;
330 pulse_data *data = Device->ExtraData;
331
332 if(ppa_stream_get_state(stream) == PA_STREAM_FAILED)
333 {
334 AL_PRINT("Received stream failure!\n");
335 aluHandleDisconnect(Device);
336 }
337 ppa_threaded_mainloop_signal(data->loop, 0);
338 }//}}}
339
340 static void stream_success_callback(pa_stream *stream, int success, void *pdata) //{{{
341 {
342 ALCdevice *Device = pdata;
343 pulse_data *data = Device->ExtraData;
344 (void)stream;
345 (void)success;
346
347 ppa_threaded_mainloop_signal(data->loop, 0);
348 }//}}}
349
350 static void server_info_callback(pa_context *context, const pa_server_info *info, void *pdata) //{{{
351 {
352 struct {
353 pa_threaded_mainloop *loop;
354 char *name;
355 } *data = pdata;
356 (void)context;
357
358 data->name = strdup(info->default_sink_name);
359 ppa_threaded_mainloop_signal(data->loop, 0);
360 }//}}}
361
362 static void sink_info_callback(pa_context *context, const pa_sink_info *info, int eol, void *pdata) //{{{
363 {
364 ALCdevice *device = pdata;
365 pulse_data *data = device->ExtraData;
366 char chanmap_str[256] = "";
367 const struct {
368 const char *str;
369 ALenum format;
370 } chanmaps[] = {
371 { "front-left,front-right,front-center,lfe,rear-left,rear-right,side-left,side-right",
372 AL_FORMAT_71CHN32 },
373 { "front-left,front-right,front-center,lfe,rear-center,side-left,side-right",
374 AL_FORMAT_61CHN32 },
375 { "front-left,front-right,front-center,lfe,rear-left,rear-right",
376 AL_FORMAT_51CHN32 },
377 { "front-left,front-right,rear-left,rear-right", AL_FORMAT_QUAD32 },
378 { "front-left,front-right", AL_FORMAT_STEREO_FLOAT32 },
379 { "mono", AL_FORMAT_MONO_FLOAT32 },
380 { NULL, 0 }
381 };
382 int i;
383 (void)context;
384
385 if(eol)
386 {
387 ppa_threaded_mainloop_signal(data->loop, 0);
388 return;
389 }
390
391 for(i = 0;chanmaps[i].str;i++)
392 {
393 pa_channel_map map;
394 if(!ppa_channel_map_parse(&map, chanmaps[i].str))
395 continue;
396
397 if(ppa_channel_map_equal(&info->channel_map, &map)
398 #if PA_CHECK_VERSION(0,9,15)
399 || (ppa_channel_map_superset &&
400 ppa_channel_map_superset(&info->channel_map, &map))
401 #endif
402 )
403 {
404 device->Format = chanmaps[i].format;
405 return;
406 }
407 }
408
409 ppa_channel_map_snprint(chanmap_str, sizeof(chanmap_str), &info->channel_map);
410 AL_PRINT("Failed to find format for channel map:\n %s\n", chanmap_str);
411 }//}}}
412 //}}}
413
414 // PulseAudio I/O Callbacks //{{{
415 static void stream_write_callback(pa_stream *stream, size_t len, void *pdata) //{{{
416 {
417 ALCdevice *Device = pdata;
418 pulse_data *data = Device->ExtraData;
419
420 while(len > 0)
421 {
422 size_t newlen = len;
423 void *buf;
424 pa_free_cb_t free_func = NULL;
425
426 #if PA_CHECK_VERSION(0,9,16)
427 if(!ppa_stream_begin_write ||
428 ppa_stream_begin_write(stream, &buf, &newlen) < 0)
429 #endif
430 {
431 buf = ppa_xmalloc(newlen);
432 free_func = ppa_xfree;
433 }
434
435 aluMixData(Device, buf, newlen/data->frame_size);
436 ppa_stream_write(stream, buf, newlen, free_func, 0, PA_SEEK_RELATIVE);
437 len -= newlen;
438 }
439 } //}}}
440 //}}}
441
442 static ALCboolean pulse_open(ALCdevice *device, const ALCchar *device_name) //{{{
443 {
444 pulse_data *data = ppa_xmalloc(sizeof(pulse_data));
445 pa_context_state_t state;
446
447 memset(data, 0, sizeof(*data));
448
449 if(ppa_get_binary_name(data->path_name, sizeof(data->path_name)))
450 data->context_name = ppa_path_get_filename(data->path_name);
451 else
452 data->context_name = "OpenAL Soft";
453
454 if(!(data->loop = ppa_threaded_mainloop_new()))
455 {
456 AL_PRINT("pa_threaded_mainloop_new() failed!\n");
457 goto out;
458 }
459
460 if(ppa_threaded_mainloop_start(data->loop) < 0)
461 {
462 AL_PRINT("pa_threaded_mainloop_start() failed\n");
463 goto out;
464 }
465
466 ppa_threaded_mainloop_lock(data->loop);
467 device->ExtraData = data;
468
469 data->context = ppa_context_new(ppa_threaded_mainloop_get_api(data->loop), data->context_name);
470 if(!data->context)
471 {
472 AL_PRINT("pa_context_new() failed\n");
473
474 ppa_threaded_mainloop_unlock(data->loop);
475 goto out;
476 }
477
478 ppa_context_set_state_callback(data->context, context_state_callback, device);
479
480 if(ppa_context_connect(data->context, NULL, pulse_ctx_flags, NULL) < 0)
481 {
482 AL_PRINT("Context did not connect: %s\n",
483 ppa_strerror(ppa_context_errno(data->context)));
484
485 ppa_context_unref(data->context);
486 data->context = NULL;
487
488 ppa_threaded_mainloop_unlock(data->loop);
489 goto out;
490 }
491
492 while((state=ppa_context_get_state(data->context)) != PA_CONTEXT_READY)
493 {
494 if(!PA_CONTEXT_IS_GOOD(state))
495 {
496 int err = ppa_context_errno(data->context);
497 if(err != PA_ERR_CONNECTIONREFUSED)
498 AL_PRINT("Context did not get ready: %s\n", ppa_strerror(err));
499
500 ppa_context_unref(data->context);
501 data->context = NULL;
502
503 ppa_threaded_mainloop_unlock(data->loop);
504 goto out;
505 }
506
507 ppa_threaded_mainloop_wait(data->loop);
508 }
509 ppa_context_set_state_callback(data->context, context_state_callback2, device);
510
511 device->szDeviceName = strdup(device_name);
512
513 ppa_threaded_mainloop_unlock(data->loop);
514 return ALC_TRUE;
515
516 out:
517 if(data->loop)
518 {
519 ppa_threaded_mainloop_stop(data->loop);
520 ppa_threaded_mainloop_free(data->loop);
521 }
522
523 device->ExtraData = NULL;
524 ppa_xfree(data);
525 return ALC_FALSE;
526 } //}}}
527
528 static void pulse_close(ALCdevice *device) //{{{
529 {
530 pulse_data *data = device->ExtraData;
531
532 ppa_threaded_mainloop_lock(data->loop);
533
534 if(data->stream)
535 {
536 ppa_stream_disconnect(data->stream);
537 ppa_stream_unref(data->stream);
538 }
539
540 ppa_context_disconnect(data->context);
541 ppa_context_unref(data->context);
542
543 ppa_threaded_mainloop_unlock(data->loop);
544
545 ppa_threaded_mainloop_stop(data->loop);
546 ppa_threaded_mainloop_free(data->loop);
547
548 DestroyRingBuffer(data->ring);
549
550 device->ExtraData = NULL;
551 ppa_xfree(data);
552 } //}}}
553 //}}}
554
555 // OpenAL {{{
556 static ALCboolean pulse_open_playback(ALCdevice *device, const ALCchar *device_name) //{{{
557 {
558 if(!device_name)
559 device_name = pulse_device;
560 else if(strcmp(device_name, pulse_device) != 0)
561 return ALC_FALSE;
562
563 if(!pulse_load())
564 return ALC_FALSE;
565
566 if(pulse_open(device, device_name) != ALC_FALSE)
567 return ALC_TRUE;
568
569 pulse_unload();
570 return ALC_FALSE;
571 } //}}}
572
573 static void pulse_close_playback(ALCdevice *device) //{{{
574 {
575 pulse_close(device);
576 pulse_unload();
577 } //}}}
578
579 static ALCboolean pulse_reset_playback(ALCdevice *device) //{{{
580 {
581 pulse_data *data = device->ExtraData;
582 pa_stream_flags_t flags = 0;
583 pa_stream_state_t state;
584 pa_channel_map chanmap;
585
586 ppa_threaded_mainloop_lock(data->loop);
587
588 if(!ConfigValueExists(NULL, "format"))
589 {
590 pa_operation *o;
591 struct {
592 pa_threaded_mainloop *loop;
593 char *name;
594 } server_data;
595 server_data.loop = data->loop;
596 server_data.name = NULL;
597
598 o = ppa_context_get_server_info(data->context, server_info_callback, &server_data);
599 while(ppa_operation_get_state(o) == PA_OPERATION_RUNNING)
600 ppa_threaded_mainloop_wait(data->loop);
601 ppa_operation_unref(o);
602 if(server_data.name)
603 {
604 o = ppa_context_get_sink_info_by_name(data->context, server_data.name, sink_info_callback, device);
605 while(ppa_operation_get_state(o) == PA_OPERATION_RUNNING)
606 ppa_threaded_mainloop_wait(data->loop);
607 ppa_operation_unref(o);
608 free(server_data.name);
609 }
610 }
611 if(!ConfigValueExists(NULL, "frequency"))
612 flags |= PA_STREAM_FIX_RATE;
613
614 data->frame_size = aluBytesFromFormat(device->Format) *
615 aluChannelsFromFormat(device->Format);
616 data->stream_name = "Playback Stream";
617 data->attr.minreq = -1;
618 data->attr.prebuf = -1;
619 data->attr.maxlength = -1;
620 data->attr.fragsize = -1;
621 data->attr.tlength = GetConfigValueInt("pulse", "buffer-length", 2048);
622 if(data->attr.tlength == 0)
623 data->attr.tlength = device->UpdateSize * device->NumUpdates;
624 data->attr.tlength *= data->frame_size;
625
626 switch(aluBytesFromFormat(device->Format))
627 {
628 case 1:
629 data->spec.format = PA_SAMPLE_U8;
630 break;
631 case 2:
632 data->spec.format = PA_SAMPLE_S16NE;
633 break;
634 case 4:
635 data->spec.format = PA_SAMPLE_FLOAT32NE;
636 break;
637 default:
638 AL_PRINT("Unknown format: 0x%x\n", device->Format);
639 ppa_threaded_mainloop_unlock(data->loop);
640 return ALC_FALSE;
641 }
642 data->spec.rate = device->Frequency;
643 data->spec.channels = aluChannelsFromFormat(device->Format);
644
645 if(ppa_sample_spec_valid(&data->spec) == 0)
646 {
647 AL_PRINT("Invalid sample format\n");
648 ppa_threaded_mainloop_unlock(data->loop);
649 return ALC_FALSE;
650 }
651
652 if(!ppa_channel_map_init_auto(&chanmap, data->spec.channels, PA_CHANNEL_MAP_WAVEEX))
653 {
654 AL_PRINT("Couldn't build map for channel count (%d)!\n", data->spec.channels);
655 ppa_threaded_mainloop_unlock(data->loop);
656 return ALC_FALSE;
657 }
658 SetDefaultWFXChannelOrder(device);
659
660 data->stream = ppa_stream_new(data->context, data->stream_name, &data->spec, &chanmap);
661 if(!data->stream)
662 {
663 AL_PRINT("pa_stream_new() failed: %s\n",
664 ppa_strerror(ppa_context_errno(data->context)));
665
666 ppa_threaded_mainloop_unlock(data->loop);
667 return ALC_FALSE;
668 }
669
670 ppa_stream_set_state_callback(data->stream, stream_state_callback, device);
671
672 if(ppa_stream_connect_playback(data->stream, NULL, &data->attr, flags, NULL, NULL) < 0)
673 {
674 AL_PRINT("Stream did not connect: %s\n",
675 ppa_strerror(ppa_context_errno(data->context)));
676
677 ppa_stream_unref(data->stream);
678 data->stream = NULL;
679
680 ppa_threaded_mainloop_unlock(data->loop);
681 return ALC_FALSE;
682 }
683
684 while((state=ppa_stream_get_state(data->stream)) != PA_STREAM_READY)
685 {
686 if(!PA_STREAM_IS_GOOD(state))
687 {
688 AL_PRINT("Stream did not get ready: %s\n",
689 ppa_strerror(ppa_context_errno(data->context)));
690
691 ppa_stream_unref(data->stream);
692 data->stream = NULL;
693
694 ppa_threaded_mainloop_unlock(data->loop);
695 return ALC_FALSE;
696 }
697
698 ppa_threaded_mainloop_wait(data->loop);
699 }
700 ppa_stream_set_state_callback(data->stream, stream_state_callback2, device);
701
702 data->spec = *(ppa_stream_get_sample_spec(data->stream));
703 if(device->Frequency != data->spec.rate)
704 {
705 pa_operation *o;
706
707 /* Server updated our playback rate, so modify the buffer attribs
708 * accordingly. */
709 data->attr.tlength = (ALuint64)(data->attr.tlength/data->frame_size) *
710 data->spec.rate / device->Frequency * data->frame_size;
711
712 o = ppa_stream_set_buffer_attr(data->stream, &data->attr,
713 stream_success_callback, device);
714 while(ppa_operation_get_state(o) == PA_OPERATION_RUNNING)
715 ppa_threaded_mainloop_wait(data->loop);
716 ppa_operation_unref(o);
717
718 device->Frequency = data->spec.rate;
719 }
720
721 stream_buffer_attr_callback(data->stream, device);
722 #if PA_CHECK_VERSION(0,9,15)
723 if(ppa_stream_set_buffer_attr_callback)
724 ppa_stream_set_buffer_attr_callback(data->stream, stream_buffer_attr_callback, device);
725 #endif
726
727 stream_write_callback(data->stream, data->attr.tlength, device);
728 ppa_stream_set_write_callback(data->stream, stream_write_callback, device);
729
730 ppa_threaded_mainloop_unlock(data->loop);
731 return ALC_TRUE;
732 } //}}}
733
734 static void pulse_stop_playback(ALCdevice *device) //{{{
735 {
736 pulse_data *data = device->ExtraData;
737
738 if(!data->stream)
739 return;
740
741 ppa_threaded_mainloop_lock(data->loop);
742
743 ppa_stream_disconnect(data->stream);
744 ppa_stream_unref(data->stream);
745 data->stream = NULL;
746
747 ppa_threaded_mainloop_unlock(data->loop);
748 } //}}}
749
750
751 static ALCboolean pulse_open_capture(ALCdevice *device, const ALCchar *device_name) //{{{
752 {
753 pulse_data *data;
754 pa_stream_flags_t flags = 0;
755 pa_stream_state_t state;
756 pa_channel_map chanmap;
757
758 if(!device_name)
759 device_name = pulse_capture_device;
760 else if(strcmp(device_name, pulse_capture_device) != 0)
761 return ALC_FALSE;
762
763 if(!pulse_load())
764 return ALC_FALSE;
765
766 if(pulse_open(device, device_name) == ALC_FALSE)
767 {
768 pulse_unload();
769 return ALC_FALSE;
770 }
771
772 data = device->ExtraData;
773 ppa_threaded_mainloop_lock(data->loop);
774
775 data->samples = device->UpdateSize * device->NumUpdates;
776 data->frame_size = aluBytesFromFormat(device->Format) *
777 aluChannelsFromFormat(device->Format);
778
779 if(!(data->ring = CreateRingBuffer(data->frame_size, data->samples)))
780 {
781 ppa_threaded_mainloop_unlock(data->loop);
782 goto fail;
783 }
784
785 data->attr.minreq = -1;
786 data->attr.prebuf = -1;
787 data->attr.maxlength = data->frame_size * data->samples;
788 data->attr.tlength = -1;
789 data->attr.fragsize = min(data->frame_size * data->samples,
790 10 * device->Frequency / 1000);
791 data->stream_name = "Capture Stream";
792
793 data->spec.rate = device->Frequency;
794 data->spec.channels = aluChannelsFromFormat(device->Format);
795
796 switch(aluBytesFromFormat(device->Format))
797 {
798 case 1:
799 data->spec.format = PA_SAMPLE_U8;
800 break;
801 case 2:
802 data->spec.format = PA_SAMPLE_S16NE;
803 break;
804 case 4:
805 data->spec.format = PA_SAMPLE_FLOAT32NE;
806 break;
807 default:
808 AL_PRINT("Unknown format: 0x%x\n", device->Format);
809 ppa_threaded_mainloop_unlock(data->loop);
810 goto fail;
811 }
812
813 if(ppa_sample_spec_valid(&data->spec) == 0)
814 {
815 AL_PRINT("Invalid sample format\n");
816 ppa_threaded_mainloop_unlock(data->loop);
817 goto fail;
818 }
819
820 if(!ppa_channel_map_init_auto(&chanmap, data->spec.channels, PA_CHANNEL_MAP_WAVEEX))
821 {
822 AL_PRINT("Couldn't build map for channel count (%d)!\n", data->spec.channels);
823 ppa_threaded_mainloop_unlock(data->loop);
824 goto fail;
825 }
826
827 data->stream = ppa_stream_new(data->context, data->stream_name, &data->spec, &chanmap);
828 if(!data->stream)
829 {
830 AL_PRINT("pa_stream_new() failed: %s\n",
831 ppa_strerror(ppa_context_errno(data->context)));
832
833 ppa_threaded_mainloop_unlock(data->loop);
834 goto fail;
835 }
836
837 ppa_stream_set_state_callback(data->stream, stream_state_callback, device);
838
839 flags |= PA_STREAM_START_CORKED|PA_STREAM_ADJUST_LATENCY;
840 if(ppa_stream_connect_record(data->stream, NULL, &data->attr, flags) < 0)
841 {
842 AL_PRINT("Stream did not connect: %s\n",
843 ppa_strerror(ppa_context_errno(data->context)));
844
845 ppa_stream_unref(data->stream);
846 data->stream = NULL;
847
848 ppa_threaded_mainloop_unlock(data->loop);
849 goto fail;
850 }
851
852 while((state=ppa_stream_get_state(data->stream)) != PA_STREAM_READY)
853 {
854 if(!PA_STREAM_IS_GOOD(state))
855 {
856 AL_PRINT("Stream did not get ready: %s\n",
857 ppa_strerror(ppa_context_errno(data->context)));
858
859 ppa_stream_unref(data->stream);
860 data->stream = NULL;
861
862 ppa_threaded_mainloop_unlock(data->loop);
863 goto fail;
864 }
865
866 ppa_threaded_mainloop_wait(data->loop);
867 }
868 ppa_stream_set_state_callback(data->stream, stream_state_callback2, device);
869
870 ppa_threaded_mainloop_unlock(data->loop);
871 return ALC_TRUE;
872
873 fail:
874 pulse_close(device);
875 pulse_unload();
876 return ALC_FALSE;
877 } //}}}
878
879 static void pulse_close_capture(ALCdevice *device) //{{{
880 {
881 pulse_close(device);
882 pulse_unload();
883 } //}}}
884
885 static void pulse_start_capture(ALCdevice *device) //{{{
886 {
887 pulse_data *data = device->ExtraData;
888 pa_operation *o;
889
890 ppa_threaded_mainloop_lock(data->loop);
891 o = ppa_stream_cork(data->stream, 0, stream_success_callback, device);
892 while(ppa_operation_get_state(o) == PA_OPERATION_RUNNING)
893 ppa_threaded_mainloop_wait(data->loop);
894 ppa_operation_unref(o);
895 ppa_threaded_mainloop_unlock(data->loop);
896 } //}}}
897
898 static void pulse_stop_capture(ALCdevice *device) //{{{
899 {
900 pulse_data *data = device->ExtraData;
901 pa_operation *o;
902
903 ppa_threaded_mainloop_lock(data->loop);
904 o = ppa_stream_cork(data->stream, 1, stream_success_callback, device);
905 while(ppa_operation_get_state(o) == PA_OPERATION_RUNNING)
906 ppa_threaded_mainloop_wait(data->loop);
907 ppa_operation_unref(o);
908 ppa_threaded_mainloop_unlock(data->loop);
909 } //}}}
910
911 static void pulse_capture_samples(ALCdevice *device, ALCvoid *buffer, ALCuint samples) //{{{
912 {
913 pulse_data *data = device->ExtraData;
914 ALCuint available = RingBufferSize(data->ring);
915 const void *buf;
916 size_t length;
917
918 available *= data->frame_size;
919 samples *= data->frame_size;
920
921 ppa_threaded_mainloop_lock(data->loop);
922 if(available+ppa_stream_readable_size(data->stream) < samples)
923 {
924 ppa_threaded_mainloop_unlock(data->loop);
925 alcSetError(device, ALC_INVALID_VALUE);
926 return;
927 }
928
929 available = min(available, samples);
930 if(available > 0)
931 {
932 ReadRingBuffer(data->ring, buffer, available/data->frame_size);
933 buffer = (ALubyte*)buffer + available;
934 samples -= available;
935 }
936
937 /* Capture is done in fragment-sized chunks, so we loop until we get all
938 * that's requested */
939 while(samples > 0)
940 {
941 if(ppa_stream_peek(data->stream, &buf, &length) < 0)
942 {
943 AL_PRINT("pa_stream_peek() failed: %s\n",
944 ppa_strerror(ppa_context_errno(data->context)));
945 break;
946 }
947 available = min(length, samples);
948
949 memcpy(buffer, buf, available);
950 buffer = (ALubyte*)buffer + available;
951 buf = (const ALubyte*)buf + available;
952 samples -= available;
953 length -= available;
954
955 /* Any unread data in the fragment will be lost, so save it */
956 length /= data->frame_size;
957 if(length > 0)
958 {
959 if(length > data->samples)
960 length = data->samples;
961 WriteRingBuffer(data->ring, buf, length);
962 }
963
964 ppa_stream_drop(data->stream);
965 }
966 ppa_threaded_mainloop_unlock(data->loop);
967 } //}}}
968
969 static ALCuint pulse_available_samples(ALCdevice *device) //{{{
970 {
971 pulse_data *data = device->ExtraData;
972 ALCuint ret;
973
974 ppa_threaded_mainloop_lock(data->loop);
975 ret = RingBufferSize(data->ring);
976 ret += ppa_stream_readable_size(data->stream)/data->frame_size;
977 ppa_threaded_mainloop_unlock(data->loop);
978
979 return ret;
980 } //}}}
981
982 BackendFuncs pulse_funcs = { //{{{
983 pulse_open_playback,
984 pulse_close_playback,
985 pulse_reset_playback,
986 pulse_stop_playback,
987 pulse_open_capture,
988 pulse_close_capture,
989 pulse_start_capture,
990 pulse_stop_capture,
991 pulse_capture_samples,
992 pulse_available_samples
993 }; //}}}
994
995 void alc_pulse_init(BackendFuncs *func_list) //{{{
996 {
997 *func_list = pulse_funcs;
998
999 pulse_ctx_flags = 0;
1000 if(!GetConfigValueBool("pulse", "spawn-server", 0))
1001 pulse_ctx_flags |= PA_CONTEXT_NOAUTOSPAWN;
1002 } //}}}
1003
1004 void alc_pulse_deinit(void) //{{{
1005 {
1006 } //}}}
1007
1008 void alc_pulse_probe(int type) //{{{
1009 {
1010 if(!pulse_load()) return;
1011
1012 if(type == DEVICE_PROBE)
1013 AppendDeviceList(pulse_device);
1014 else if(type == ALL_DEVICE_PROBE)
1015 AppendAllDeviceList(pulse_device);
1016 else if(type == CAPTURE_DEVICE_PROBE)
1017 AppendCaptureDeviceList(pulse_capture_device);
1018
1019 pulse_unload();
1020 } //}}}
1021 //}}}
Software OpenAL implementation