Alc/pulseaudio.c

   1 /**
   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.
   9  *
  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.
  14  *
  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
  20  */
  21
  22 #include "config.h"
  23
  24 #include "alMain.h"
  25 #ifdef HAVE_DLFCN_H
  26 #include <dlfcn.h>
  27 #endif
  28
  29 #include <pulse/pulseaudio.h>
  30
  31 #if PA_API_VERSION == 11
  32 #define PA_STREAM_ADJUST_LATENCY 0x2000U
  33 static __inline int PA_STREAM_IS_GOOD(pa_stream_state_t x)
  34 {
  35     return (x == PA_STREAM_CREATING || x == PA_STREAM_READY);
  36 }
  37 static __inline int PA_CONTEXT_IS_GOOD(pa_context_state_t x)
  38 {
  39     return (x == PA_CONTEXT_CONNECTING || x == PA_CONTEXT_AUTHORIZING ||
  40             x == PA_CONTEXT_SETTING_NAME || x == PA_CONTEXT_READY);
  41 }
  42 #define PA_STREAM_IS_GOOD PA_STREAM_IS_GOOD
  43 #define PA_CONTEXT_IS_GOOD PA_CONTEXT_IS_GOOD
  44 #elif PA_API_VERSION != 12
  45 #error Invalid PulseAudio API version
  46 #endif
  47
  48 #ifndef PA_CHECK_VERSION
  49 #define PA_CHECK_VERSION(major,minor,micro)                             \
  50     ((PA_MAJOR > (major)) ||                                            \
  51      (PA_MAJOR == (major) && PA_MINOR > (minor)) ||                     \
  52      (PA_MAJOR == (major) && PA_MINOR == (minor) && PA_MICRO >= (micro)))
  53 #endif
  54
  55 static void *pa_handle;
  56 #define MAKE_FUNC(x) static typeof(x) * p##x
  57 MAKE_FUNC(pa_context_unref);
  58 MAKE_FUNC(pa_sample_spec_valid);
  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);
  75 MAKE_FUNC(pa_xfree);
  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_list);
 112 MAKE_FUNC(pa_operation_get_state);
 113 MAKE_FUNC(pa_operation_unref);
 114 #if PA_CHECK_VERSION(0,9,15)
 115 MAKE_FUNC(pa_channel_map_superset);
 116 MAKE_FUNC(pa_stream_set_buffer_attr_callback);
 117 #endif
 118 #if PA_CHECK_VERSION(0,9,16)
 119 MAKE_FUNC(pa_stream_begin_write);
 120 #endif
 121 #undef MAKE_FUNC
 122
 123 #ifndef PATH_MAX
 124 #define PATH_MAX 4096
 125 #endif
 126
 127 typedef struct {
 128     char *device_name;
 129
 130     ALCuint samples;
 131     ALCuint frame_size;
 132
 133     RingBuffer *ring;
 134
 135     pa_buffer_attr attr;
 136     pa_sample_spec spec;
 137
 138     pa_threaded_mainloop *loop;
 139
 140     ALvoid *thread;
 141     volatile ALboolean killNow;
 142
 143     pa_stream *stream;
 144     pa_context *context;
 145 } pulse_data;
 146
 147 typedef struct {
 148     char *name;
 149     char *device_name;
 150 } DevMap;
 151
 152
 153 static const ALCchar pulse_device[] = "PulseAudio Default";
 154 static DevMap *allDevNameMap;
 155 static ALuint numDevNames;
 156 static DevMap *allCaptureDevNameMap;
 157 static ALuint numCaptureDevNames;
 158 static pa_context_flags_t pulse_ctx_flags;
 159
 160
 161 void *pulse_load(void) //{{{
 162 {
 163     if(!pa_handle)
 164     {
 165 #ifdef _WIN32
 166         pa_handle = LoadLibrary("libpulse-0.dll");
 167 #define LOAD_FUNC(x) do { \
 168     p##x = (typeof(p##x))GetProcAddress(pa_handle, #x); \
 169     if(!(p##x)) { \
 170         AL_PRINT("Could not load %s from libpulse-0.dll\n", #x); \
 171         FreeLibrary(pa_handle); \
 172         pa_handle = NULL; \
 173         return NULL; \
 174     } \
 175 } while(0)
 176 #define LOAD_OPTIONAL_FUNC(x) do { \
 177     p##x = (typeof(p##x))GetProcAddress(pa_handle, #x); \
 178 } while(0)
 179
 180 #elif defined (HAVE_DLFCN_H)
 181
 182         const char *err;
 183 #if defined(__APPLE__) && defined(__MACH__)
 184         pa_handle = dlopen("libpulse.0.dylib", RTLD_NOW);
 185 #else
 186         pa_handle = dlopen("libpulse.so.0", RTLD_NOW);
 187 #endif
 188         dlerror();
 189
 190 #define LOAD_FUNC(x) do { \
 191     p##x = dlsym(pa_handle, #x); \
 192     if((err=dlerror()) != NULL) { \
 193         AL_PRINT("Could not load %s from libpulse: %s\n", #x, err); \
 194         dlclose(pa_handle); \
 195         pa_handle = NULL; \
 196         return NULL; \
 197     } \
 198 } while(0)
 199 #define LOAD_OPTIONAL_FUNC(x) do { \
 200     p##x = dlsym(pa_handle, #x); \
 201     if((err=dlerror()) != NULL) { \
 202         p##x = NULL; \
 203     } \
 204 } while(0)
 205
 206 #else
 207
 208         pa_handle = (void*)0xDEADBEEF;
 209 #define LOAD_FUNC(x) p##x = (x)
 210 #define LOAD_OPTIONAL_FUNC(x) p##x = (x)
 211
 212 #endif
 213         if(!pa_handle)
 214             return NULL;
 215
 216 LOAD_FUNC(pa_context_unref);
 217 LOAD_FUNC(pa_sample_spec_valid);
 218 LOAD_FUNC(pa_stream_drop);
 219 LOAD_FUNC(pa_strerror);
 220 LOAD_FUNC(pa_context_get_state);
 221 LOAD_FUNC(pa_stream_get_state);
 222 LOAD_FUNC(pa_threaded_mainloop_signal);
 223 LOAD_FUNC(pa_stream_peek);
 224 LOAD_FUNC(pa_threaded_mainloop_wait);
 225 LOAD_FUNC(pa_threaded_mainloop_unlock);
 226 LOAD_FUNC(pa_threaded_mainloop_in_thread);
 227 LOAD_FUNC(pa_context_new);
 228 LOAD_FUNC(pa_threaded_mainloop_stop);
 229 LOAD_FUNC(pa_context_disconnect);
 230 LOAD_FUNC(pa_threaded_mainloop_start);
 231 LOAD_FUNC(pa_threaded_mainloop_get_api);
 232 LOAD_FUNC(pa_context_set_state_callback);
 233 LOAD_FUNC(pa_stream_write);
 234 LOAD_FUNC(pa_xfree);
 235 LOAD_FUNC(pa_stream_connect_record);
 236 LOAD_FUNC(pa_stream_connect_playback);
 237 LOAD_FUNC(pa_stream_readable_size);
 238 LOAD_FUNC(pa_stream_writable_size);
 239 LOAD_FUNC(pa_stream_cork);
 240 LOAD_FUNC(pa_stream_is_suspended);
 241 LOAD_FUNC(pa_stream_get_device_name);
 242 LOAD_FUNC(pa_path_get_filename);
 243 LOAD_FUNC(pa_get_binary_name);
 244 LOAD_FUNC(pa_threaded_mainloop_free);
 245 LOAD_FUNC(pa_context_errno);
 246 LOAD_FUNC(pa_xmalloc);
 247 LOAD_FUNC(pa_stream_unref);
 248 LOAD_FUNC(pa_threaded_mainloop_accept);
 249 LOAD_FUNC(pa_stream_set_write_callback);
 250 LOAD_FUNC(pa_threaded_mainloop_new);
 251 LOAD_FUNC(pa_context_connect);
 252 LOAD_FUNC(pa_stream_set_buffer_attr);
 253 LOAD_FUNC(pa_stream_get_buffer_attr);
 254 LOAD_FUNC(pa_stream_get_sample_spec);
 255 LOAD_FUNC(pa_stream_get_time);
 256 LOAD_FUNC(pa_stream_set_read_callback);
 257 LOAD_FUNC(pa_stream_set_state_callback);
 258 LOAD_FUNC(pa_stream_set_moved_callback);
 259 LOAD_FUNC(pa_stream_set_underflow_callback);
 260 LOAD_FUNC(pa_stream_new);
 261 LOAD_FUNC(pa_stream_disconnect);
 262 LOAD_FUNC(pa_threaded_mainloop_lock);
 263 LOAD_FUNC(pa_channel_map_init_auto);
 264 LOAD_FUNC(pa_channel_map_parse);
 265 LOAD_FUNC(pa_channel_map_snprint);
 266 LOAD_FUNC(pa_channel_map_equal);
 267 LOAD_FUNC(pa_context_get_server_info);
 268 LOAD_FUNC(pa_context_get_sink_info_by_name);
 269 LOAD_FUNC(pa_context_get_sink_info_list);
 270 LOAD_FUNC(pa_context_get_source_info_list);
 271 LOAD_FUNC(pa_operation_get_state);
 272 LOAD_FUNC(pa_operation_unref);
 273 #if PA_CHECK_VERSION(0,9,15)
 274 LOAD_OPTIONAL_FUNC(pa_channel_map_superset);
 275 LOAD_OPTIONAL_FUNC(pa_stream_set_buffer_attr_callback);
 276 #endif
 277 #if PA_CHECK_VERSION(0,9,16)
 278 LOAD_OPTIONAL_FUNC(pa_stream_begin_write);
 279 #endif
 280
 281 #undef LOAD_OPTIONAL_FUNC
 282 #undef LOAD_FUNC
 283     }
 284     return pa_handle;
 285 } //}}}
 286
 287 // PulseAudio Event Callbacks //{{{
 288 static void context_state_callback(pa_context *context, void *pdata) //{{{
 289 {
 290     pa_threaded_mainloop *loop = pdata;
 291     pa_context_state_t state;
 292
 293     state = ppa_context_get_state(context);
 294     if(state == PA_CONTEXT_READY || !PA_CONTEXT_IS_GOOD(state))
 295         ppa_threaded_mainloop_signal(loop, 0);
 296 }//}}}
 297
 298 static void stream_state_callback(pa_stream *stream, void *pdata) //{{{
 299 {
 300     pa_threaded_mainloop *loop = pdata;
 301     pa_stream_state_t state;
 302
 303     state = ppa_stream_get_state(stream);
 304     if(state == PA_STREAM_READY || !PA_STREAM_IS_GOOD(state))
 305         ppa_threaded_mainloop_signal(loop, 0);
 306 }//}}}
 307
 308 static void stream_signal_callback(pa_stream *stream, void *pdata) //{{{
 309 {
 310     ALCdevice *Device = pdata;
 311     pulse_data *data = Device->ExtraData;
 312     (void)stream;
 313
 314     ppa_threaded_mainloop_signal(data->loop, 0);
 315 }//}}}
 316
 317 static void stream_buffer_attr_callback(pa_stream *stream, void *pdata) //{{{
 318 {
 319     ALCdevice *Device = pdata;
 320     pulse_data *data = Device->ExtraData;
 321
 322     SuspendContext(NULL);
 323
 324     data->attr = *(ppa_stream_get_buffer_attr(stream));
 325     Device->UpdateSize = data->attr.minreq / data->frame_size;
 326     Device->NumUpdates = (data->attr.tlength/data->frame_size) / Device->UpdateSize;
 327     if(Device->NumUpdates <= 1)
 328     {
 329         Device->NumUpdates = 1;
 330         AL_PRINT("PulseAudio returned minreq > tlength/2; expect break up\n");
 331     }
 332
 333     ProcessContext(NULL);
 334 }//}}}
 335
 336 static void stream_device_callback(pa_stream *stream, void *pdata) //{{{
 337 {
 338     ALCdevice *Device = pdata;
 339     pulse_data *data = Device->ExtraData;
 340
 341     free(data->device_name);
 342     data->device_name = strdup(ppa_stream_get_device_name(stream));
 343 }//}}}
 344
 345 static void context_state_callback2(pa_context *context, void *pdata) //{{{
 346 {
 347     ALCdevice *Device = pdata;
 348     pulse_data *data = Device->ExtraData;
 349
 350     if(ppa_context_get_state(context) == PA_CONTEXT_FAILED)
 351     {
 352         AL_PRINT("Received context failure!\n");
 353         aluHandleDisconnect(Device);
 354     }
 355     ppa_threaded_mainloop_signal(data->loop, 0);
 356 }//}}}
 357
 358 static void stream_state_callback2(pa_stream *stream, void *pdata) //{{{
 359 {
 360     ALCdevice *Device = pdata;
 361     pulse_data *data = Device->ExtraData;
 362
 363     if(ppa_stream_get_state(stream) == PA_STREAM_FAILED)
 364     {
 365         AL_PRINT("Received stream failure!\n");
 366         aluHandleDisconnect(Device);
 367     }
 368     ppa_threaded_mainloop_signal(data->loop, 0);
 369 }//}}}
 370
 371 static void stream_success_callback(pa_stream *stream, int success, void *pdata) //{{{
 372 {
 373     ALCdevice *Device = pdata;
 374     pulse_data *data = Device->ExtraData;
 375     (void)stream;
 376     (void)success;
 377
 378     ppa_threaded_mainloop_signal(data->loop, 0);
 379 }//}}}
 380
 381 static void sink_info_callback(pa_context *context, const pa_sink_info *info, int eol, void *pdata) //{{{
 382 {
 383     ALCdevice *device = pdata;
 384     pulse_data *data = device->ExtraData;
 385     char chanmap_str[256] = "";
 386     const struct {
 387         const char *str;
 388         enum DevFmtChannels chans;
 389     } chanmaps[] = {
 390         { "front-left,front-right,front-center,lfe,rear-left,rear-right,side-left,side-right",
 391           DevFmtX71 },
 392         { "front-left,front-right,front-center,lfe,rear-center,side-left,side-right",
 393           DevFmtX61 },
 394         { "front-left,front-right,front-center,lfe,rear-left,rear-right",
 395           DevFmtX51 },
 396         { "front-left,front-right,rear-left,rear-right", DevFmtQuad },
 397         { "front-left,front-right", DevFmtStereo },
 398         { "mono", DevFmtMono },
 399         { NULL, 0 }
 400     };
 401     int i;
 402     (void)context;
 403
 404     if(eol)
 405     {
 406         ppa_threaded_mainloop_signal(data->loop, 0);
 407         return;
 408     }
 409
 410     for(i = 0;chanmaps[i].str;i++)
 411     {
 412         pa_channel_map map;
 413         if(!ppa_channel_map_parse(&map, chanmaps[i].str))
 414             continue;
 415
 416         if(ppa_channel_map_equal(&info->channel_map, &map)
 417 #if PA_CHECK_VERSION(0,9,15)
 418            || (ppa_channel_map_superset &&
 419                ppa_channel_map_superset(&info->channel_map, &map))
 420 #endif
 421             )
 422         {
 423             device->FmtChans = chanmaps[i].chans;
 424             return;
 425         }
 426     }
 427
 428     ppa_channel_map_snprint(chanmap_str, sizeof(chanmap_str), &info->channel_map);
 429     AL_PRINT("Failed to find format for channel map:\n    %s\n", chanmap_str);
 430 }//}}}
 431
 432 static void sink_device_callback(pa_context *context, const pa_sink_info *info, int eol, void *pdata) //{{{
 433 {
 434     pa_threaded_mainloop *loop = pdata;
 435     char str[1024];
 436     void *temp;
 437     int count;
 438     ALuint i;
 439
 440     (void)context;
 441
 442     if(eol)
 443     {
 444         ppa_threaded_mainloop_signal(loop, 0);
 445         return;
 446     }
 447
 448     count = 0;
 449     do {
 450         if(count == 0)
 451             snprintf(str, sizeof(str), "%s via PulseAudio", info->description);
 452         else
 453             snprintf(str, sizeof(str), "%s #%d via PulseAudio", info->description, count+1);
 454         count++;
 455
 456         for(i = 0;i < numDevNames;i++)
 457         {
 458             if(strcmp(str, allDevNameMap[i].name) == 0)
 459                 break;
 460         }
 461     } while(i != numDevNames);
 462
 463     temp = realloc(allDevNameMap, (numDevNames+1) * sizeof(*allDevNameMap));
 464     if(temp)
 465     {
 466         allDevNameMap = temp;
 467         allDevNameMap[numDevNames].name = strdup(str);
 468         allDevNameMap[numDevNames].device_name = strdup(info->name);
 469         numDevNames++;
 470     }
 471 }//}}}
 472
 473 static void source_device_callback(pa_context *context, const pa_source_info *info, int eol, void *pdata) //{{{
 474 {
 475     pa_threaded_mainloop *loop = pdata;
 476     char str[1024];
 477     void *temp;
 478     int count;
 479     ALuint i;
 480
 481     (void)context;
 482
 483     if(eol)
 484     {
 485         ppa_threaded_mainloop_signal(loop, 0);
 486         return;
 487     }
 488
 489     count = 0;
 490     do {
 491         if(count == 0)
 492             snprintf(str, sizeof(str), "%s via PulseAudio", info->description);
 493         else
 494             snprintf(str, sizeof(str), "%s #%d via PulseAudio", info->description, count+1);
 495         count++;
 496
 497         for(i = 0;i < numCaptureDevNames;i++)
 498         {
 499             if(strcmp(str, allCaptureDevNameMap[i].name) == 0)
 500                 break;
 501         }
 502     } while(i != numCaptureDevNames);
 503
 504     temp = realloc(allCaptureDevNameMap, (numCaptureDevNames+1) * sizeof(*allCaptureDevNameMap));
 505     if(temp)
 506     {
 507         allCaptureDevNameMap = temp;
 508         allCaptureDevNameMap[numCaptureDevNames].name = strdup(str);
 509         allCaptureDevNameMap[numCaptureDevNames].device_name = strdup(info->name);
 510         numCaptureDevNames++;
 511     }
 512 }//}}}
 513 //}}}
 514
 515 // PulseAudio I/O Callbacks //{{{
 516 static void stream_write_callback(pa_stream *stream, size_t len, void *pdata) //{{{
 517 {
 518     ALCdevice *Device = pdata;
 519     pulse_data *data = Device->ExtraData;
 520     (void)stream;
 521     (void)len;
 522
 523     ppa_threaded_mainloop_signal(data->loop, 0);
 524 } //}}}
 525 //}}}
 526
 527 static ALuint PulseProc(ALvoid *param)
 528 {
 529     ALCdevice *Device = param;
 530     pulse_data *data = Device->ExtraData;
 531     ssize_t len;
 532
 533     SetRTPriority();
 534
 535     ppa_threaded_mainloop_lock(data->loop);
 536     do {
 537         len = (Device->Connected ? ppa_stream_writable_size(data->stream) : 0);
 538         len -= len%(Device->UpdateSize*data->frame_size);
 539         if(len == 0)
 540         {
 541             ppa_threaded_mainloop_wait(data->loop);
 542             continue;
 543         }
 544
 545         while(len > 0)
 546         {
 547             size_t newlen = len;
 548             void *buf;
 549             pa_free_cb_t free_func = NULL;
 550
 551 #if PA_CHECK_VERSION(0,9,16)
 552             if(!ppa_stream_begin_write ||
 553                ppa_stream_begin_write(data->stream, &buf, &newlen) < 0)
 554 #endif
 555             {
 556                 buf = ppa_xmalloc(newlen);
 557                 free_func = ppa_xfree;
 558             }
 559             ppa_threaded_mainloop_unlock(data->loop);
 560
 561             aluMixData(Device, buf, newlen/data->frame_size);
 562
 563             ppa_threaded_mainloop_lock(data->loop);
 564             ppa_stream_write(data->stream, buf, newlen, free_func, 0, PA_SEEK_RELATIVE);
 565             len -= newlen;
 566         }
 567     } while(Device->Connected && !data->killNow);
 568     ppa_threaded_mainloop_unlock(data->loop);
 569
 570     return 0;
 571 }
 572
 573 static pa_context *connect_context(pa_threaded_mainloop *loop)
 574 {
 575     const char *name = "OpenAL Soft";
 576     char path_name[PATH_MAX];
 577     pa_context_state_t state;
 578     pa_context *context;
 579     int err;
 580
 581     if(ppa_get_binary_name(path_name, sizeof(path_name)))
 582         name = ppa_path_get_filename(path_name);
 583
 584     context = ppa_context_new(ppa_threaded_mainloop_get_api(loop), name);
 585     if(!context)
 586     {
 587         AL_PRINT("pa_context_new() failed\n");
 588         return NULL;
 589     }
 590
 591     ppa_context_set_state_callback(context, context_state_callback, loop);
 592
 593     if((err=ppa_context_connect(context, NULL, pulse_ctx_flags, NULL)) >= 0)
 594     {
 595         while((state=ppa_context_get_state(context)) != PA_CONTEXT_READY)
 596         {
 597             if(!PA_CONTEXT_IS_GOOD(state))
 598             {
 599                 err = ppa_context_errno(context);
 600                 if(err > 0)  err = -err;
 601                 break;
 602             }
 603
 604             ppa_threaded_mainloop_wait(loop);
 605         }
 606     }
 607     ppa_context_set_state_callback(context, NULL, NULL);
 608
 609     if(err < 0)
 610     {
 611         AL_PRINT("Context did not connect: %s\n", ppa_strerror(err));
 612         ppa_context_unref(context);
 613         return NULL;
 614     }
 615
 616     return context;
 617 }
 618
 619 static pa_stream *connect_playback_stream(ALCdevice *device,
 620     pa_stream_flags_t flags, pa_buffer_attr *attr, pa_sample_spec *spec,
 621     pa_channel_map *chanmap)
 622 {
 623     pulse_data *data = device->ExtraData;
 624     pa_stream_state_t state;
 625     pa_stream *stream;
 626
 627     stream = ppa_stream_new(data->context, "Playback Stream", spec, chanmap);
 628     if(!stream)
 629     {
 630         AL_PRINT("pa_stream_new() failed: %s\n",
 631                  ppa_strerror(ppa_context_errno(data->context)));
 632         return NULL;
 633     }
 634
 635     ppa_stream_set_state_callback(stream, stream_state_callback, data->loop);
 636
 637     if(ppa_stream_connect_playback(stream, data->device_name, attr, flags, NULL, NULL) < 0)
 638     {
 639         AL_PRINT("Stream did not connect: %s\n",
 640                  ppa_strerror(ppa_context_errno(data->context)));
 641         ppa_stream_unref(stream);
 642         return NULL;
 643     }
 644
 645     while((state=ppa_stream_get_state(stream)) != PA_STREAM_READY)
 646     {
 647         if(!PA_STREAM_IS_GOOD(state))
 648         {
 649             AL_PRINT("Stream did not get ready: %s\n",
 650                      ppa_strerror(ppa_context_errno(data->context)));
 651             ppa_stream_unref(stream);
 652             return NULL;
 653         }
 654
 655         ppa_threaded_mainloop_wait(data->loop);
 656     }
 657     ppa_stream_set_state_callback(stream, NULL, NULL);
 658
 659     return stream;
 660 }
 661
 662 static void probe_devices(ALboolean capture)
 663 {
 664     pa_threaded_mainloop *loop;
 665
 666     if(capture == AL_FALSE)
 667         allDevNameMap = malloc(sizeof(DevMap) * 1);
 668     else
 669         allCaptureDevNameMap = malloc(sizeof(DevMap) * 1);
 670
 671     if((loop=ppa_threaded_mainloop_new()) &&
 672        ppa_threaded_mainloop_start(loop) >= 0)
 673     {
 674         pa_context *context;
 675
 676         ppa_threaded_mainloop_lock(loop);
 677         context = connect_context(loop);
 678         if(context)
 679         {
 680             pa_operation *o;
 681
 682             if(capture == AL_FALSE)
 683             {
 684                 allDevNameMap[0].name = strdup(pulse_device);
 685                 allDevNameMap[0].device_name = NULL;
 686                 numDevNames = 1;
 687
 688                 o = ppa_context_get_sink_info_list(context, sink_device_callback, loop);
 689             }
 690             else
 691             {
 692                 allCaptureDevNameMap[0].name = strdup(pulse_device);
 693                 allCaptureDevNameMap[0].device_name = NULL;
 694                 numCaptureDevNames = 1;
 695
 696                 o = ppa_context_get_source_info_list(context, source_device_callback, loop);
 697             }
 698             while(ppa_operation_get_state(o) == PA_OPERATION_RUNNING)
 699                 ppa_threaded_mainloop_wait(loop);
 700             ppa_operation_unref(o);
 701
 702             ppa_context_disconnect(context);
 703             ppa_context_unref(context);
 704         }
 705         ppa_threaded_mainloop_unlock(loop);
 706         ppa_threaded_mainloop_stop(loop);
 707     }
 708     if(loop)
 709         ppa_threaded_mainloop_free(loop);
 710 }
 711
 712
 713 static ALCboolean pulse_open(ALCdevice *device, const ALCchar *device_name) //{{{
 714 {
 715     pulse_data *data = ppa_xmalloc(sizeof(pulse_data));
 716     memset(data, 0, sizeof(*data));
 717
 718     if(!(data->loop = ppa_threaded_mainloop_new()))
 719     {
 720         AL_PRINT("pa_threaded_mainloop_new() failed!\n");
 721         goto out;
 722     }
 723     if(ppa_threaded_mainloop_start(data->loop) < 0)
 724     {
 725         AL_PRINT("pa_threaded_mainloop_start() failed\n");
 726         goto out;
 727     }
 728
 729     ppa_threaded_mainloop_lock(data->loop);
 730     device->ExtraData = data;
 731
 732     data->context = connect_context(data->loop);
 733     if(!data->context)
 734     {
 735         ppa_threaded_mainloop_unlock(data->loop);
 736         goto out;
 737     }
 738     ppa_context_set_state_callback(data->context, context_state_callback2, device);
 739
 740     device->szDeviceName = strdup(device_name);
 741
 742     ppa_threaded_mainloop_unlock(data->loop);
 743     return ALC_TRUE;
 744
 745 out:
 746     if(data->loop)
 747     {
 748         ppa_threaded_mainloop_stop(data->loop);
 749         ppa_threaded_mainloop_free(data->loop);
 750     }
 751
 752     device->ExtraData = NULL;
 753     ppa_xfree(data);
 754     return ALC_FALSE;
 755 } //}}}
 756
 757 static void pulse_close(ALCdevice *device) //{{{
 758 {
 759     pulse_data *data = device->ExtraData;
 760
 761     ppa_threaded_mainloop_lock(data->loop);
 762
 763     if(data->stream)
 764     {
 765         ppa_stream_disconnect(data->stream);
 766         ppa_stream_unref(data->stream);
 767     }
 768
 769     ppa_context_disconnect(data->context);
 770     ppa_context_unref(data->context);
 771
 772     ppa_threaded_mainloop_unlock(data->loop);
 773
 774     ppa_threaded_mainloop_stop(data->loop);
 775     ppa_threaded_mainloop_free(data->loop);
 776
 777     DestroyRingBuffer(data->ring);
 778     free(data->device_name);
 779
 780     device->ExtraData = NULL;
 781     ppa_xfree(data);
 782 } //}}}
 783 //}}}
 784
 785 // OpenAL {{{
 786 static ALCboolean pulse_open_playback(ALCdevice *device, const ALCchar *device_name) //{{{
 787 {
 788     char *pulse_name = NULL;
 789     pa_sample_spec spec;
 790     pulse_data *data;
 791
 792     if(!pulse_load())
 793         return ALC_FALSE;
 794
 795     if(!allDevNameMap)
 796         probe_devices(AL_FALSE);
 797
 798     if(!device_name && numDevNames > 0)
 799         device_name = allDevNameMap[0].name;
 800     else
 801     {
 802         ALuint i;
 803
 804         for(i = 0;i < numDevNames;i++)
 805         {
 806             if(strcmp(device_name, allDevNameMap[i].name) == 0)
 807             {
 808                 pulse_name = allDevNameMap[i].device_name;
 809                 break;
 810             }
 811         }
 812         if(i == numDevNames)
 813             return ALC_FALSE;
 814     }
 815
 816     if(pulse_open(device, device_name) == ALC_FALSE)
 817         return ALC_FALSE;
 818
 819     data = device->ExtraData;
 820
 821     ppa_threaded_mainloop_lock(data->loop);
 822
 823     spec.format = PA_SAMPLE_S16NE;
 824     spec.rate = 44100;
 825     spec.channels = 2;
 826
 827     data->device_name = pulse_name;
 828     pa_stream *stream = connect_playback_stream(device, 0, NULL, &spec, NULL);
 829     if(!stream)
 830     {
 831         ppa_threaded_mainloop_unlock(data->loop);
 832         goto fail;
 833     }
 834
 835     if(ppa_stream_is_suspended(stream))
 836     {
 837         AL_PRINT("Device is suspended\n");
 838         ppa_stream_disconnect(stream);
 839         ppa_stream_unref(stream);
 840         ppa_threaded_mainloop_unlock(data->loop);
 841         goto fail;
 842     }
 843     data->device_name = strdup(ppa_stream_get_device_name(stream));
 844
 845     ppa_stream_disconnect(stream);
 846     ppa_stream_unref(stream);
 847
 848     ppa_threaded_mainloop_unlock(data->loop);
 849
 850     return ALC_TRUE;
 851
 852 fail:
 853     pulse_close(device);
 854     return ALC_FALSE;
 855 } //}}}
 856
 857 static void pulse_close_playback(ALCdevice *device) //{{{
 858 {
 859     pulse_close(device);
 860 } //}}}
 861
 862 static ALCboolean pulse_reset_playback(ALCdevice *device) //{{{
 863 {
 864     pulse_data *data = device->ExtraData;
 865     pa_stream_flags_t flags = 0;
 866     pa_channel_map chanmap;
 867
 868     ppa_threaded_mainloop_lock(data->loop);
 869
 870     if(!ConfigValueExists(NULL, "format"))
 871     {
 872         pa_operation *o;
 873         o = ppa_context_get_sink_info_by_name(data->context, data->device_name, sink_info_callback, device);
 874         while(ppa_operation_get_state(o) == PA_OPERATION_RUNNING)
 875             ppa_threaded_mainloop_wait(data->loop);
 876         ppa_operation_unref(o);
 877     }
 878     if(!ConfigValueExists(NULL, "frequency"))
 879         flags |= PA_STREAM_FIX_RATE;
 880
 881     data->frame_size = FrameSizeFromDevFmt(device->FmtChans, device->FmtType);
 882     data->attr.prebuf = -1;
 883     data->attr.fragsize = -1;
 884     data->attr.minreq = device->UpdateSize * data->frame_size;
 885     data->attr.tlength = data->attr.minreq * device->NumUpdates;
 886     if(data->attr.tlength < data->attr.minreq*2)
 887         data->attr.tlength = data->attr.minreq*2;
 888     data->attr.maxlength = data->attr.tlength;
 889     flags |= PA_STREAM_EARLY_REQUESTS;
 890     flags |= PA_STREAM_INTERPOLATE_TIMING | PA_STREAM_AUTO_TIMING_UPDATE;
 891
 892     switch(device->FmtType)
 893     {
 894         case DevFmtByte:
 895             device->FmtType = DevFmtUByte;
 896             /* fall-through */
 897         case DevFmtUByte:
 898             data->spec.format = PA_SAMPLE_U8;
 899             break;
 900         case DevFmtUShort:
 901             device->FmtType = DevFmtShort;
 902             /* fall-through */
 903         case DevFmtShort:
 904             data->spec.format = PA_SAMPLE_S16NE;
 905             break;
 906         case DevFmtFloat:
 907             data->spec.format = PA_SAMPLE_FLOAT32NE;
 908             break;
 909     }
 910     data->spec.rate = device->Frequency;
 911     data->spec.channels = ChannelsFromDevFmt(device->FmtChans);
 912
 913     if(ppa_sample_spec_valid(&data->spec) == 0)
 914     {
 915         AL_PRINT("Invalid sample format\n");
 916         ppa_threaded_mainloop_unlock(data->loop);
 917         return ALC_FALSE;
 918     }
 919
 920     if(!ppa_channel_map_init_auto(&chanmap, data->spec.channels, PA_CHANNEL_MAP_WAVEEX))
 921     {
 922         AL_PRINT("Couldn't build map for channel count (%d)!\n", data->spec.channels);
 923         ppa_threaded_mainloop_unlock(data->loop);
 924         return ALC_FALSE;
 925     }
 926     SetDefaultWFXChannelOrder(device);
 927
 928     data->stream = connect_playback_stream(device, flags, &data->attr, &data->spec, &chanmap);
 929     if(!data->stream)
 930     {
 931         ppa_threaded_mainloop_unlock(data->loop);
 932         return ALC_FALSE;
 933     }
 934
 935     ppa_stream_set_state_callback(data->stream, stream_state_callback2, device);
 936
 937     data->spec = *(ppa_stream_get_sample_spec(data->stream));
 938     if(device->Frequency != data->spec.rate)
 939     {
 940         pa_operation *o;
 941
 942         /* Server updated our playback rate, so modify the buffer attribs
 943          * accordingly. */
 944         data->attr.minreq = (ALuint64)(data->attr.minreq/data->frame_size) *
 945                             data->spec.rate / device->Frequency * data->frame_size;
 946         data->attr.tlength = data->attr.minreq * device->NumUpdates;
 947         data->attr.maxlength = data->attr.tlength;
 948
 949         o = ppa_stream_set_buffer_attr(data->stream, &data->attr,
 950                                        stream_success_callback, device);
 951         while(ppa_operation_get_state(o) == PA_OPERATION_RUNNING)
 952             ppa_threaded_mainloop_wait(data->loop);
 953         ppa_operation_unref(o);
 954
 955         device->Frequency = data->spec.rate;
 956     }
 957
 958     stream_buffer_attr_callback(data->stream, device);
 959 #if PA_CHECK_VERSION(0,9,15)
 960     if(ppa_stream_set_buffer_attr_callback)
 961         ppa_stream_set_buffer_attr_callback(data->stream, stream_buffer_attr_callback, device);
 962 #endif
 963     ppa_stream_set_moved_callback(data->stream, stream_device_callback, device);
 964     ppa_stream_set_write_callback(data->stream, stream_write_callback, device);
 965     ppa_stream_set_underflow_callback(data->stream, stream_signal_callback, device);
 966
 967     data->thread = StartThread(PulseProc, device);
 968     if(!data->thread)
 969     {
 970 #if PA_CHECK_VERSION(0,9,15)
 971         if(ppa_stream_set_buffer_attr_callback)
 972             ppa_stream_set_buffer_attr_callback(data->stream, NULL, NULL);
 973 #endif
 974         ppa_stream_set_moved_callback(data->stream, NULL, NULL);
 975         ppa_stream_set_write_callback(data->stream, NULL, NULL);
 976         ppa_stream_set_underflow_callback(data->stream, NULL, NULL);
 977         ppa_stream_disconnect(data->stream);
 978         ppa_stream_unref(data->stream);
 979         data->stream = NULL;
 980
 981         ppa_threaded_mainloop_unlock(data->loop);
 982         return ALC_FALSE;
 983     }
 984
 985     ppa_threaded_mainloop_unlock(data->loop);
 986     return ALC_TRUE;
 987 } //}}}
 988
 989 static void pulse_stop_playback(ALCdevice *device) //{{{
 990 {
 991     pulse_data *data = device->ExtraData;
 992
 993     if(!data->stream)
 994         return;
 995
 996     data->killNow = AL_TRUE;
 997     if(data->thread)
 998     {
 999         ppa_threaded_mainloop_signal(data->loop, 0);
1000         StopThread(data->thread);
1001         data->thread = NULL;
1002     }
1003     data->killNow = AL_FALSE;
1004
1005     ppa_threaded_mainloop_lock(data->loop);
1006
1007 #if PA_CHECK_VERSION(0,9,15)
1008     if(ppa_stream_set_buffer_attr_callback)
1009         ppa_stream_set_buffer_attr_callback(data->stream, NULL, NULL);
1010 #endif
1011     ppa_stream_set_moved_callback(data->stream, NULL, NULL);
1012     ppa_stream_set_write_callback(data->stream, NULL, NULL);
1013     ppa_stream_set_underflow_callback(data->stream, NULL, NULL);
1014     ppa_stream_disconnect(data->stream);
1015     ppa_stream_unref(data->stream);
1016     data->stream = NULL;
1017
1018     ppa_threaded_mainloop_unlock(data->loop);
1019 } //}}}
1020
1021
1022 static ALCboolean pulse_open_capture(ALCdevice *device, const ALCchar *device_name) //{{{
1023 {
1024     char *pulse_name = NULL;
1025     pulse_data *data;
1026     pa_stream_flags_t flags = 0;
1027     pa_stream_state_t state;
1028     pa_channel_map chanmap;
1029
1030     if(!pulse_load())
1031         return ALC_FALSE;
1032
1033     if(!allCaptureDevNameMap)
1034         probe_devices(AL_TRUE);
1035
1036     if(!device_name && numCaptureDevNames > 0)
1037         device_name = allCaptureDevNameMap[0].name;
1038     else
1039     {
1040         ALuint i;
1041
1042         for(i = 0;i < numCaptureDevNames;i++)
1043         {
1044             if(strcmp(device_name, allCaptureDevNameMap[i].name) == 0)
1045             {
1046                 pulse_name = allCaptureDevNameMap[i].device_name;
1047                 break;
1048             }
1049         }
1050         if(i == numCaptureDevNames)
1051             return ALC_FALSE;
1052     }
1053
1054     if(pulse_open(device, device_name) == ALC_FALSE)
1055         return ALC_FALSE;
1056
1057     data = device->ExtraData;
1058     ppa_threaded_mainloop_lock(data->loop);
1059
1060     data->samples = device->UpdateSize * device->NumUpdates;
1061     data->frame_size = FrameSizeFromDevFmt(device->FmtChans, device->FmtType);
1062     if(data->samples < 100 * device->Frequency / 1000)
1063         data->samples = 100 * device->Frequency / 1000;
1064
1065     if(!(data->ring = CreateRingBuffer(data->frame_size, data->samples)))
1066     {
1067         ppa_threaded_mainloop_unlock(data->loop);
1068         goto fail;
1069     }
1070
1071     data->attr.minreq = -1;
1072     data->attr.prebuf = -1;
1073     data->attr.maxlength = data->samples * data->frame_size;
1074     data->attr.tlength = -1;
1075     data->attr.fragsize = min(data->samples, 50 * device->Frequency / 1000) *
1076                           data->frame_size;
1077
1078     data->spec.rate = device->Frequency;
1079     data->spec.channels = ChannelsFromDevFmt(device->FmtChans);
1080
1081     switch(device->FmtType)
1082     {
1083         case DevFmtUByte:
1084             data->spec.format = PA_SAMPLE_U8;
1085             break;
1086         case DevFmtShort:
1087             data->spec.format = PA_SAMPLE_S16NE;
1088             break;
1089         case DevFmtFloat:
1090             data->spec.format = PA_SAMPLE_FLOAT32NE;
1091             break;
1092         case DevFmtByte:
1093         case DevFmtUShort:
1094             AL_PRINT("Capture format type %#x capture not supported on PulseAudio\n", device->FmtType);
1095             ppa_threaded_mainloop_unlock(data->loop);
1096             goto fail;
1097     }
1098
1099     if(ppa_sample_spec_valid(&data->spec) == 0)
1100     {
1101         AL_PRINT("Invalid sample format\n");
1102         ppa_threaded_mainloop_unlock(data->loop);
1103         goto fail;
1104     }
1105
1106     if(!ppa_channel_map_init_auto(&chanmap, data->spec.channels, PA_CHANNEL_MAP_WAVEEX))
1107     {
1108         AL_PRINT("Couldn't build map for channel count (%d)!\n", data->spec.channels);
1109         ppa_threaded_mainloop_unlock(data->loop);
1110         goto fail;
1111     }
1112
1113     data->stream = ppa_stream_new(data->context, "Capture Stream", &data->spec, &chanmap);
1114     if(!data->stream)
1115     {
1116         AL_PRINT("pa_stream_new() failed: %s\n",
1117                  ppa_strerror(ppa_context_errno(data->context)));
1118
1119         ppa_threaded_mainloop_unlock(data->loop);
1120         goto fail;
1121     }
1122
1123     ppa_stream_set_state_callback(data->stream, stream_state_callback, data->loop);
1124
1125     flags |= PA_STREAM_START_CORKED|PA_STREAM_ADJUST_LATENCY;
1126     if(ppa_stream_connect_record(data->stream, pulse_name, &data->attr, flags) < 0)
1127     {
1128         AL_PRINT("Stream did not connect: %s\n",
1129                  ppa_strerror(ppa_context_errno(data->context)));
1130
1131         ppa_stream_unref(data->stream);
1132         data->stream = NULL;
1133
1134         ppa_threaded_mainloop_unlock(data->loop);
1135         goto fail;
1136     }
1137
1138     while((state=ppa_stream_get_state(data->stream)) != PA_STREAM_READY)
1139     {
1140         if(!PA_STREAM_IS_GOOD(state))
1141         {
1142             AL_PRINT("Stream did not get ready: %s\n",
1143                      ppa_strerror(ppa_context_errno(data->context)));
1144
1145             ppa_stream_unref(data->stream);
1146             data->stream = NULL;
1147
1148             ppa_threaded_mainloop_unlock(data->loop);
1149             goto fail;
1150         }
1151
1152         ppa_threaded_mainloop_wait(data->loop);
1153     }
1154     ppa_stream_set_state_callback(data->stream, stream_state_callback2, device);
1155
1156     ppa_threaded_mainloop_unlock(data->loop);
1157     return ALC_TRUE;
1158
1159 fail:
1160     pulse_close(device);
1161     return ALC_FALSE;
1162 } //}}}
1163
1164 static void pulse_close_capture(ALCdevice *device) //{{{
1165 {
1166     pulse_close(device);
1167 } //}}}
1168
1169 static void pulse_start_capture(ALCdevice *device) //{{{
1170 {
1171     pulse_data *data = device->ExtraData;
1172     pa_operation *o;
1173
1174     ppa_threaded_mainloop_lock(data->loop);
1175     o = ppa_stream_cork(data->stream, 0, stream_success_callback, device);
1176     while(ppa_operation_get_state(o) == PA_OPERATION_RUNNING)
1177         ppa_threaded_mainloop_wait(data->loop);
1178     ppa_operation_unref(o);
1179     ppa_threaded_mainloop_unlock(data->loop);
1180 } //}}}
1181
1182 static void pulse_stop_capture(ALCdevice *device) //{{{
1183 {
1184     pulse_data *data = device->ExtraData;
1185     pa_operation *o;
1186
1187     ppa_threaded_mainloop_lock(data->loop);
1188     o = ppa_stream_cork(data->stream, 1, stream_success_callback, device);
1189     while(ppa_operation_get_state(o) == PA_OPERATION_RUNNING)
1190         ppa_threaded_mainloop_wait(data->loop);
1191     ppa_operation_unref(o);
1192     ppa_threaded_mainloop_unlock(data->loop);
1193 } //}}}
1194
1195 static ALCuint pulse_available_samples(ALCdevice *device) //{{{
1196 {
1197     pulse_data *data = device->ExtraData;
1198     size_t samples;
1199
1200     ppa_threaded_mainloop_lock(data->loop);
1201     /* Capture is done in fragment-sized chunks, so we loop until we get all
1202      * that's available */
1203     samples = (device->Connected ? ppa_stream_readable_size(data->stream) : 0);
1204     while(samples > 0)
1205     {
1206         const void *buf;
1207         size_t length;
1208
1209         if(ppa_stream_peek(data->stream, &buf, &length) < 0)
1210         {
1211             AL_PRINT("pa_stream_peek() failed: %s\n",
1212                      ppa_strerror(ppa_context_errno(data->context)));
1213             break;
1214         }
1215
1216         WriteRingBuffer(data->ring, buf, length/data->frame_size);
1217         samples -= length;
1218
1219         ppa_stream_drop(data->stream);
1220     }
1221     ppa_threaded_mainloop_unlock(data->loop);
1222
1223     return RingBufferSize(data->ring);
1224 } //}}}
1225
1226 static void pulse_capture_samples(ALCdevice *device, ALCvoid *buffer, ALCuint samples) //{{{
1227 {
1228     pulse_data *data = device->ExtraData;
1229
1230     if(pulse_available_samples(device) >= samples)
1231         ReadRingBuffer(data->ring, buffer, samples);
1232     else
1233         alcSetError(device, ALC_INVALID_VALUE);
1234 } //}}}
1235
1236
1237 BackendFuncs pulse_funcs = { //{{{
1238     pulse_open_playback,
1239     pulse_close_playback,
1240     pulse_reset_playback,
1241     pulse_stop_playback,
1242     pulse_open_capture,
1243     pulse_close_capture,
1244     pulse_start_capture,
1245     pulse_stop_capture,
1246     pulse_capture_samples,
1247     pulse_available_samples
1248 }; //}}}
1249
1250 void alc_pulse_init(BackendFuncs *func_list) //{{{
1251 {
1252     *func_list = pulse_funcs;
1253
1254     pulse_ctx_flags = 0;
1255     if(!GetConfigValueBool("pulse", "spawn-server", 0))
1256         pulse_ctx_flags |= PA_CONTEXT_NOAUTOSPAWN;
1257 } //}}}
1258
1259 void alc_pulse_deinit(void) //{{{
1260 {
1261     ALuint i;
1262
1263     for(i = 0;i < numDevNames;++i)
1264     {
1265         free(allDevNameMap[i].name);
1266         free(allDevNameMap[i].device_name);
1267     }
1268     free(allDevNameMap);
1269     allDevNameMap = NULL;
1270     numDevNames = 0;
1271
1272     for(i = 0;i < numCaptureDevNames;++i)
1273     {
1274         free(allCaptureDevNameMap[i].name);
1275         free(allCaptureDevNameMap[i].device_name);
1276     }
1277     free(allCaptureDevNameMap);
1278     allCaptureDevNameMap = NULL;
1279     numCaptureDevNames = 0;
1280
1281     if(pa_handle)
1282     {
1283 #ifdef _WIN32
1284         FreeLibrary(pa_handle);
1285 #elif defined (HAVE_DLFCN_H)
1286         dlclose(pa_handle);
1287 #endif
1288         pa_handle = NULL;
1289     }
1290 } //}}}
1291
1292 void alc_pulse_probe(int type) //{{{
1293 {
1294     if(!pulse_load()) return;
1295
1296     if(type == DEVICE_PROBE)
1297     {
1298         pa_threaded_mainloop *loop;
1299
1300         if((loop=ppa_threaded_mainloop_new()) &&
1301            ppa_threaded_mainloop_start(loop) >= 0)
1302         {
1303             pa_context *context;
1304
1305             ppa_threaded_mainloop_lock(loop);
1306             context = connect_context(loop);
1307             if(context)
1308             {
1309                 AppendDeviceList(pulse_device);
1310
1311                 ppa_context_disconnect(context);
1312                 ppa_context_unref(context);
1313             }
1314             ppa_threaded_mainloop_unlock(loop);
1315             ppa_threaded_mainloop_stop(loop);
1316         }
1317         if(loop)
1318             ppa_threaded_mainloop_free(loop);
1319     }
1320     else if(type == ALL_DEVICE_PROBE)
1321     {
1322         ALuint i;
1323
1324         for(i = 0;i < numDevNames;++i)
1325         {
1326             free(allDevNameMap[i].name);
1327             free(allDevNameMap[i].device_name);
1328         }
1329         free(allDevNameMap);
1330         allDevNameMap = NULL;
1331         numDevNames = 0;
1332
1333         probe_devices(AL_FALSE);
1334
1335         for(i = 0;i < numDevNames;i++)
1336             AppendAllDeviceList(allDevNameMap[i].name);
1337     }
1338     else if(type == CAPTURE_DEVICE_PROBE)
1339     {
1340         ALuint i;
1341
1342         for(i = 0;i < numCaptureDevNames;++i)
1343         {
1344             free(allCaptureDevNameMap[i].name);
1345             free(allCaptureDevNameMap[i].device_name);
1346         }
1347         free(allCaptureDevNameMap);
1348         allCaptureDevNameMap = NULL;
1349         numCaptureDevNames = 0;
1350
1351         probe_devices(AL_TRUE);
1352
1353         for(i = 0;i < numCaptureDevNames;i++)
1354             AppendCaptureDeviceList(allCaptureDevNameMap[i].name);
1355     }
1356 } //}}}
1357 //}}}