Alc/pulseaudio.c

   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 static void *pa_handle;
  48 #define MAKE_FUNC(x) static typeof(x) * p##x
  49 MAKE_FUNC(pa_context_unref);
  50 MAKE_FUNC(pa_sample_spec_valid);
  51 MAKE_FUNC(pa_stream_drop);
  52 MAKE_FUNC(pa_strerror);
  53 MAKE_FUNC(pa_context_get_state);
  54 MAKE_FUNC(pa_stream_get_state);
  55 MAKE_FUNC(pa_threaded_mainloop_signal);
  56 MAKE_FUNC(pa_stream_peek);
  57 MAKE_FUNC(pa_threaded_mainloop_wait);
  58 MAKE_FUNC(pa_threaded_mainloop_unlock);
  59 MAKE_FUNC(pa_context_new);
  60 MAKE_FUNC(pa_threaded_mainloop_stop);
  61 MAKE_FUNC(pa_context_disconnect);
  62 MAKE_FUNC(pa_threaded_mainloop_start);
  63 MAKE_FUNC(pa_threaded_mainloop_get_api);
  64 MAKE_FUNC(pa_context_set_state_callback);
  65 MAKE_FUNC(pa_stream_write);
  66 MAKE_FUNC(pa_xfree);
  67 MAKE_FUNC(pa_stream_connect_record);
  68 MAKE_FUNC(pa_stream_connect_playback);
  69 MAKE_FUNC(pa_path_get_filename);
  70 MAKE_FUNC(pa_get_binary_name);
  71 MAKE_FUNC(pa_threaded_mainloop_free);
  72 MAKE_FUNC(pa_context_errno);
  73 MAKE_FUNC(pa_xmalloc0);
  74 MAKE_FUNC(pa_stream_unref);
  75 MAKE_FUNC(pa_threaded_mainloop_accept);
  76 MAKE_FUNC(pa_stream_set_write_callback);
  77 MAKE_FUNC(pa_threaded_mainloop_new);
  78 MAKE_FUNC(pa_context_connect);
  79 MAKE_FUNC(pa_stream_set_read_callback);
  80 MAKE_FUNC(pa_stream_set_state_callback);
  81 MAKE_FUNC(pa_stream_new);
  82 MAKE_FUNC(pa_stream_disconnect);
  83 MAKE_FUNC(pa_threaded_mainloop_lock);
  84 #undef MAKE_FUNC
  85
  86 #ifndef PATH_MAX
  87 #define PATH_MAX 4096
  88 #endif
  89
  90 typedef struct {
  91     ALCdevice *device;
  92
  93     ALCuint samples;
  94     ALCuint frame_size;
  95
  96     RingBuffer *ring;
  97
  98     pa_buffer_attr attr;
  99     pa_sample_spec spec;
 100
 101     char path_name[PATH_MAX];
 102     const char *context_name;
 103     const char *stream_name;
 104
 105     pa_threaded_mainloop *loop;
 106
 107     pa_stream *stream;
 108     pa_context *context;
 109 } pulse_data;
 110
 111 static const ALCchar pulse_device[] = "PulseAudio Software";
 112 static const ALCchar pulse_capture_device[] = "PulseAudio Capture";
 113
 114 // PulseAudio Event Callbacks {{{
 115 static void stream_state_callback(pa_stream *stream, void *pdata) //{{{
 116 {
 117     pulse_data *data = pdata;
 118
 119     switch(ppa_stream_get_state(stream))
 120         {
 121                 case PA_STREAM_READY:
 122             AL_PRINT("%s: %s ready!\n", data->context_name, data->stream_name);
 123                         break;
 124
 125                 case PA_STREAM_FAILED:
 126             AL_PRINT("%s: %s: Connection failed: %s\n", data->context_name,
 127                      data->stream_name, ppa_strerror(ppa_context_errno(data->context)));
 128                         break;
 129
 130                 case PA_STREAM_TERMINATED:
 131             AL_PRINT("%s: %s terminated!\n", data->context_name, data->stream_name);
 132                         break;
 133
 134                 default:
 135                         break;
 136         }
 137
 138     ppa_threaded_mainloop_signal(data->loop, 1);
 139 } //}}}
 140
 141 static void context_state_callback(pa_context *context, void *pdata) //{{{
 142 {
 143     pulse_data *data = pdata;
 144
 145     switch(ppa_context_get_state(context))
 146         {
 147                 case PA_CONTEXT_READY:
 148             AL_PRINT("%s ready!\n", data->context_name);
 149                         break;
 150
 151                 case PA_CONTEXT_FAILED:
 152             AL_PRINT("%s: Connection failed: %s\n", data->context_name,
 153                      ppa_strerror(ppa_context_errno(context)));
 154             break;
 155
 156                 case PA_CONTEXT_TERMINATED:
 157             AL_PRINT("%s terminated!\n", data->context_name);
 158                         break;
 159
 160                 default:
 161                         break;
 162         }
 163
 164     ppa_threaded_mainloop_signal(data->loop, 1);
 165 } //}}}
 166 //}}}
 167
 168 // PulseAudio I/O Callbacks //{{{
 169 static void stream_write_callback(pa_stream *stream, size_t len, void *pdata) //{{{
 170 {
 171     ALCdevice *Device = pdata;
 172     void *buf = ppa_xmalloc0(len);
 173
 174     SuspendContext(NULL);
 175     aluMixData(Device->Context, buf, len, Device->Format);
 176     ProcessContext(NULL);
 177
 178     ppa_stream_write(stream, buf, len, ppa_xfree, 0, PA_SEEK_RELATIVE);
 179 } //}}}
 180
 181 static void stream_read_callback(pa_stream *stream, size_t length, void *pdata) //{{{
 182 {
 183     ALCdevice *Device = pdata;
 184     pulse_data *data = Device->ExtraData;
 185     const void *buf;
 186
 187     if(ppa_stream_peek(stream, &buf, &length) < 0)
 188     {
 189         AL_PRINT("pa_stream_peek() failed: %s\n",
 190                  ppa_strerror(ppa_context_errno(data->context)));
 191         return;
 192     }
 193
 194     assert(buf);
 195     assert(length);
 196
 197     length /= data->frame_size;
 198
 199     if(data->samples < length)
 200         AL_PRINT("stream_read_callback: buffer overflow!\n");
 201
 202     WriteRingBuffer(data->ring, buf, (length<data->samples) ? length : data->samples);
 203
 204     ppa_stream_drop(stream);
 205 } //}}}
 206 //}}}
 207
 208 static ALCboolean pulse_open(ALCdevice *device, const ALCchar *device_name) //{{{
 209 {
 210     pulse_data *data = ppa_xmalloc0(sizeof(pulse_data));
 211
 212     data->device = device;
 213
 214     if(ppa_get_binary_name(data->path_name, sizeof(data->path_name)))
 215         data->context_name = ppa_path_get_filename(data->path_name);
 216     else
 217         data->context_name = "OpenAL Soft";
 218
 219     if(!(data->loop = ppa_threaded_mainloop_new()))
 220     {
 221         AL_PRINT("pa_threaded_mainloop_new() failed!\n");
 222         goto out;
 223     }
 224
 225     if(ppa_threaded_mainloop_start(data->loop) < 0)
 226     {
 227         AL_PRINT("pa_threaded_mainloop_start() failed\n");
 228         goto out;
 229     }
 230
 231     ppa_threaded_mainloop_lock(data->loop);
 232
 233     data->context = ppa_context_new(ppa_threaded_mainloop_get_api(data->loop), data->context_name);
 234     if(!data->context)
 235     {
 236         AL_PRINT("pa_context_new() failed: %s\n",
 237                  ppa_strerror(ppa_context_errno(data->context)));
 238
 239         ppa_threaded_mainloop_unlock(data->loop);
 240         goto out;
 241     }
 242
 243     ppa_context_set_state_callback(data->context, context_state_callback, data);
 244
 245     if(ppa_context_connect(data->context, NULL, PA_CONTEXT_NOAUTOSPAWN, NULL) < 0)
 246     {
 247         AL_PRINT("Context did not connect: %s\n",
 248                  ppa_strerror(ppa_context_errno(data->context)));
 249
 250         ppa_context_unref(data->context);
 251         data->context = NULL;
 252
 253         ppa_threaded_mainloop_unlock(data->loop);
 254         goto out;
 255     }
 256
 257     while(ppa_context_get_state(data->context) != PA_CONTEXT_READY)
 258     {
 259         if(!PA_CONTEXT_IS_GOOD(ppa_context_get_state(data->context)))
 260         {
 261             AL_PRINT("Context did not get ready: %s\n",
 262                      ppa_strerror(ppa_context_errno(data->context)));
 263
 264             ppa_context_unref(data->context);
 265             data->context = NULL;
 266
 267             ppa_threaded_mainloop_unlock(data->loop);
 268             goto out;
 269         }
 270
 271         ppa_threaded_mainloop_wait(data->loop);
 272         ppa_threaded_mainloop_accept(data->loop);
 273     }
 274
 275     device->szDeviceName = strdup(device_name);
 276     device->ExtraData = data;
 277
 278     ppa_threaded_mainloop_unlock(data->loop);
 279     return ALC_TRUE;
 280
 281 out:
 282     if(data->loop)
 283     {
 284         ppa_threaded_mainloop_stop(data->loop);
 285         ppa_threaded_mainloop_free(data->loop);
 286     }
 287     device->ExtraData = NULL;
 288     device->szDeviceName = NULL;
 289
 290     ppa_xfree(data);
 291     return ALC_FALSE;
 292 } //}}}
 293
 294 static void pulse_close(ALCdevice *device) //{{{
 295 {
 296     pulse_data *data = device->ExtraData;
 297
 298     ppa_threaded_mainloop_lock(data->loop);
 299
 300     if(data->stream)
 301     {
 302         ppa_stream_disconnect(data->stream);
 303         ppa_stream_unref(data->stream);
 304     }
 305
 306     ppa_context_disconnect(data->context);
 307     ppa_context_unref(data->context);
 308
 309     ppa_threaded_mainloop_unlock(data->loop);
 310
 311     ppa_threaded_mainloop_stop(data->loop);
 312     ppa_threaded_mainloop_free(data->loop);
 313
 314     device->ExtraData = NULL;
 315     device->szDeviceName = NULL;
 316     DestroyRingBuffer(data->ring);
 317
 318     ppa_xfree(data);
 319 } //}}}
 320 //}}}
 321
 322 // OpenAL {{{
 323 static ALCboolean pulse_open_playback(ALCdevice *device, const ALCchar *device_name) //{{{
 324 {
 325     if(!pa_handle)
 326         return ALC_FALSE;
 327
 328     if(!device_name)
 329         device_name = pulse_device;
 330     else if(strcmp(device_name, pulse_device) != 0)
 331         return ALC_FALSE;
 332
 333     return pulse_open(device, device_name);
 334 } //}}}
 335
 336 static void pulse_close_playback(ALCdevice *device) //{{{
 337 {
 338     pulse_close(device);
 339 } //}}}
 340
 341 static ALCboolean pulse_start_context(ALCdevice *device, ALCcontext *context) //{{{
 342 {
 343     pulse_data *data = device->ExtraData;
 344     (void)context;
 345
 346     ppa_threaded_mainloop_lock(data->loop);
 347
 348     data->samples = device->BufferSize;
 349     data->frame_size = aluBytesFromFormat(device->Format) *
 350                        aluChannelsFromFormat(device->Format);
 351
 352     device->UpdateSize = device->BufferSize / 4;
 353
 354     data->attr.minreq = -1;
 355     data->attr.prebuf = -1;
 356     data->attr.maxlength = -1;
 357     data->attr.fragsize = data->frame_size * device->UpdateSize;
 358     data->attr.tlength = data->attr.fragsize * 4;
 359     data->stream_name = "Playback Stream";
 360
 361     data->spec.rate = device->Frequency;
 362     data->spec.channels = aluChannelsFromFormat(device->Format);
 363
 364     switch(aluBytesFromFormat(device->Format))
 365     {
 366         case 1:
 367             data->spec.format = PA_SAMPLE_U8;
 368             break;
 369         case 2:
 370             data->spec.format = PA_SAMPLE_S16NE;
 371             break;
 372         case 4:
 373             data->spec.format = PA_SAMPLE_FLOAT32NE;
 374             break;
 375         default:
 376             AL_PRINT("Unknown format: %x\n", device->Format);
 377             ppa_threaded_mainloop_unlock(data->loop);
 378             return ALC_FALSE;
 379     }
 380
 381     if(ppa_sample_spec_valid(&data->spec) == 0)
 382     {
 383         AL_PRINT("Invalid sample format\n");
 384         ppa_threaded_mainloop_unlock(data->loop);
 385         return ALC_FALSE;
 386     }
 387
 388     data->stream = ppa_stream_new(data->context, data->stream_name, &data->spec, NULL);
 389     if(!data->stream)
 390     {
 391         AL_PRINT("pa_stream_new() failed: %s\n",
 392                  ppa_strerror(ppa_context_errno(data->context)));
 393
 394         ppa_threaded_mainloop_unlock(data->loop);
 395         return ALC_FALSE;
 396     }
 397
 398     ppa_stream_set_state_callback(data->stream, stream_state_callback, data);
 399     ppa_stream_set_write_callback(data->stream, stream_write_callback, device);
 400
 401     if(ppa_stream_connect_playback(data->stream, NULL, &data->attr, PA_STREAM_ADJUST_LATENCY, NULL, NULL) < 0)
 402     {
 403         AL_PRINT("Stream did not connect: %s\n",
 404                  ppa_strerror(ppa_context_errno(data->context)));
 405
 406         ppa_stream_unref(data->stream);
 407         data->stream = NULL;
 408
 409         ppa_threaded_mainloop_unlock(data->loop);
 410         return ALC_FALSE;
 411     }
 412
 413     while(ppa_stream_get_state(data->stream) != PA_STREAM_READY)
 414     {
 415         if(!PA_STREAM_IS_GOOD(ppa_stream_get_state(data->stream)))
 416         {
 417             AL_PRINT("Stream did not get ready: %s\n",
 418                      ppa_strerror(ppa_context_errno(data->context)));
 419
 420             ppa_stream_unref(data->stream);
 421             data->stream = NULL;
 422
 423             ppa_threaded_mainloop_unlock(data->loop);
 424             return ALC_FALSE;
 425         }
 426
 427         ppa_threaded_mainloop_wait(data->loop);
 428         ppa_threaded_mainloop_accept(data->loop);
 429     }
 430
 431     ppa_threaded_mainloop_unlock(data->loop);
 432     return ALC_TRUE;
 433 } //}}}
 434
 435 static void pulse_stop_context(ALCdevice *device, ALCcontext *context) //{{{
 436 {
 437     pulse_data *data = device->ExtraData;
 438     (void)context;
 439
 440     if(!data->stream)
 441         return;
 442
 443     ppa_threaded_mainloop_lock(data->loop);
 444
 445     ppa_stream_disconnect(data->stream);
 446     ppa_stream_unref(data->stream);
 447     data->stream = NULL;
 448
 449     ppa_threaded_mainloop_unlock(data->loop);
 450 } //}}}
 451
 452
 453 static ALCboolean pulse_open_capture(ALCdevice *device, const ALCchar *device_name) //{{{
 454 {
 455     pulse_data *data;
 456
 457     if(!pa_handle)
 458         return ALC_FALSE;
 459
 460     if(!device_name)
 461         device_name = pulse_capture_device;
 462     else if(strcmp(device_name, pulse_capture_device) != 0)
 463         return ALC_FALSE;
 464
 465     if(pulse_open(device, device_name) == ALC_FALSE)
 466         return ALC_FALSE;
 467
 468     data = device->ExtraData;
 469     ppa_threaded_mainloop_lock(data->loop);
 470
 471     data->samples = device->BufferSize;
 472     data->frame_size = aluBytesFromFormat(device->Format) *
 473                        aluChannelsFromFormat(device->Format);
 474
 475     if(!(data->ring = CreateRingBuffer(data->frame_size, data->samples)))
 476     {
 477         ppa_threaded_mainloop_unlock(data->loop);
 478         pulse_close(device);
 479         free(device->szDeviceName);
 480         device->szDeviceName = NULL;
 481         return ALC_FALSE;
 482     }
 483
 484     data->attr.minreq = -1;
 485     data->attr.prebuf = -1;
 486     data->attr.maxlength = -1;
 487     data->attr.tlength = -1;
 488     data->attr.fragsize = data->frame_size * data->samples / 2;
 489     data->stream_name = "Capture Stream";
 490
 491     data->spec.rate = device->Frequency;
 492     data->spec.channels = aluChannelsFromFormat(device->Format);
 493
 494     switch(aluBytesFromFormat(device->Format))
 495     {
 496         case 1:
 497             data->spec.format = PA_SAMPLE_U8;
 498             break;
 499         case 2:
 500             data->spec.format = PA_SAMPLE_S16NE;
 501             break;
 502         default:
 503             AL_PRINT("Unknown format: %x\n", device->Format);
 504             ppa_threaded_mainloop_unlock(data->loop);
 505             pulse_close(device);
 506             free(device->szDeviceName);
 507             device->szDeviceName = NULL;
 508             return ALC_FALSE;
 509     }
 510
 511     if(ppa_sample_spec_valid(&data->spec) == 0)
 512     {
 513         AL_PRINT("Invalid sample format\n");
 514         ppa_threaded_mainloop_unlock(data->loop);
 515         pulse_close(device);
 516         free(device->szDeviceName);
 517         device->szDeviceName = NULL;
 518         return ALC_FALSE;
 519     }
 520
 521     data->stream = ppa_stream_new(data->context, data->stream_name, &data->spec, NULL);
 522     if(!data->stream)
 523     {
 524         AL_PRINT("pa_stream_new() failed: %s\n",
 525                  ppa_strerror(ppa_context_errno(data->context)));
 526
 527         ppa_threaded_mainloop_unlock(data->loop);
 528         pulse_close(device);
 529         free(device->szDeviceName);
 530         device->szDeviceName = NULL;
 531         return ALC_FALSE;
 532     }
 533
 534     ppa_stream_set_state_callback(data->stream, stream_state_callback, data);
 535
 536     if(ppa_stream_connect_record(data->stream, NULL, &data->attr, PA_STREAM_ADJUST_LATENCY) < 0)
 537     {
 538         AL_PRINT("Stream did not connect: %s\n",
 539                  ppa_strerror(ppa_context_errno(data->context)));
 540
 541         ppa_stream_unref(data->stream);
 542         ppa_threaded_mainloop_unlock(data->loop);
 543
 544         data->stream = NULL;
 545         pulse_close(device);
 546         free(device->szDeviceName);
 547         device->szDeviceName = NULL;
 548         return ALC_FALSE;
 549     }
 550
 551     while(ppa_stream_get_state(data->stream) != PA_STREAM_READY)
 552     {
 553         if(!PA_STREAM_IS_GOOD(ppa_stream_get_state(data->stream)))
 554         {
 555             AL_PRINT("Stream did not get ready: %s\n",
 556                      ppa_strerror(ppa_context_errno(data->context)));
 557
 558             ppa_stream_unref(data->stream);
 559             ppa_threaded_mainloop_unlock(data->loop);
 560
 561             data->stream = NULL;
 562             pulse_close(device);
 563             free(device->szDeviceName);
 564             device->szDeviceName = NULL;
 565             return ALC_FALSE;
 566         }
 567
 568         ppa_threaded_mainloop_wait(data->loop);
 569         ppa_threaded_mainloop_accept(data->loop);
 570     }
 571
 572     ppa_threaded_mainloop_unlock(data->loop);
 573     return ALC_TRUE;
 574 } //}}}
 575
 576 static void pulse_close_capture(ALCdevice *device) //{{{
 577 {
 578     pulse_close(device);
 579 } //}}}
 580
 581 static void pulse_start_capture(ALCdevice *device) //{{{
 582 {
 583     pulse_data *data = device->ExtraData;
 584
 585     ppa_threaded_mainloop_lock(data->loop);
 586     ppa_stream_set_read_callback(data->stream, stream_read_callback, device);
 587     ppa_threaded_mainloop_unlock(data->loop);
 588 } //}}}
 589
 590 static void pulse_stop_capture(ALCdevice *device) //{{{
 591 {
 592     pulse_data *data = device->ExtraData;
 593
 594     ppa_threaded_mainloop_lock(data->loop);
 595     ppa_stream_set_read_callback(data->stream, NULL, NULL);
 596     ppa_threaded_mainloop_unlock(data->loop);
 597 } //}}}
 598
 599 static void pulse_capture_samples(ALCdevice *device, ALCvoid *buffer, ALCuint samples) //{{{
 600 {
 601     pulse_data *data = device->ExtraData;
 602     ALCuint available = RingBufferSize(data->ring);
 603
 604     if(available < samples)
 605         SetALCError(ALC_INVALID_VALUE);
 606     else
 607         ReadRingBuffer(data->ring, buffer, samples);
 608 } //}}}
 609
 610 static ALCuint pulse_available_samples(ALCdevice *device) //{{{
 611 {
 612     pulse_data *data = device->ExtraData;
 613     return RingBufferSize(data->ring);
 614 } //}}}
 615
 616 BackendFuncs pulse_funcs = { //{{{
 617     pulse_open_playback,
 618     pulse_close_playback,
 619     pulse_start_context,
 620     pulse_stop_context,
 621     pulse_open_capture,
 622     pulse_close_capture,
 623     pulse_start_capture,
 624     pulse_stop_capture,
 625     pulse_capture_samples,
 626     pulse_available_samples
 627 }; //}}}
 628
 629 void alc_pulse_init(BackendFuncs *func_list) //{{{
 630 {
 631     *func_list = pulse_funcs;
 632
 633 #ifdef _WIN32
 634     pa_handle = LoadLibrary("libpulse-0.dll");
 635 #define LOAD_FUNC(x) do { \
 636     p##x = GetProcAddress(pa_handle, #x); \
 637     if(!(p##x)) { \
 638         AL_PRINT("Could not load %s from libpulse-0.dll\n", #x); \
 639         FreeLibrary(pa_handle); \
 640         pa_handle = NULL; \
 641         return; \
 642     } \
 643 } while(0)
 644
 645 #elif defined (HAVE_DLFCN_H)
 646
 647 #if defined(__APPLE__) && defined(__MACH__)
 648     pa_handle = dlopen("libpulse.0.dylib", RTLD_NOW);
 649 #else
 650     pa_handle = dlopen("libpulse.so.0", RTLD_NOW);
 651 #endif
 652 #define LOAD_FUNC(x) do { \
 653     p##x = dlsym(pa_handle, #x); \
 654     if(!(p##x)) { \
 655         AL_PRINT("Could not load %s from libpulse\n", #x); \
 656         dlclose(pa_handle); \
 657         pa_handle = NULL; \
 658         return; \
 659     } \
 660 } while(0)
 661
 662 #else
 663
 664     pa_handle = (void*)0xDEADBEEF;
 665 #define LOAD_FUNC(x) p##x = (x)
 666
 667 #endif
 668     if(!pa_handle)
 669         return;
 670
 671 LOAD_FUNC(pa_context_unref);
 672 LOAD_FUNC(pa_sample_spec_valid);
 673 LOAD_FUNC(pa_stream_drop);
 674 LOAD_FUNC(pa_strerror);
 675 LOAD_FUNC(pa_context_get_state);
 676 LOAD_FUNC(pa_stream_get_state);
 677 LOAD_FUNC(pa_threaded_mainloop_signal);
 678 LOAD_FUNC(pa_stream_peek);
 679 LOAD_FUNC(pa_threaded_mainloop_wait);
 680 LOAD_FUNC(pa_threaded_mainloop_unlock);
 681 LOAD_FUNC(pa_context_new);
 682 LOAD_FUNC(pa_threaded_mainloop_stop);
 683 LOAD_FUNC(pa_context_disconnect);
 684 LOAD_FUNC(pa_threaded_mainloop_start);
 685 LOAD_FUNC(pa_threaded_mainloop_get_api);
 686 LOAD_FUNC(pa_context_set_state_callback);
 687 LOAD_FUNC(pa_stream_write);
 688 LOAD_FUNC(pa_xfree);
 689 LOAD_FUNC(pa_stream_connect_record);
 690 LOAD_FUNC(pa_stream_connect_playback);
 691 LOAD_FUNC(pa_path_get_filename);
 692 LOAD_FUNC(pa_get_binary_name);
 693 LOAD_FUNC(pa_threaded_mainloop_free);
 694 LOAD_FUNC(pa_context_errno);
 695 LOAD_FUNC(pa_xmalloc0);
 696 LOAD_FUNC(pa_stream_unref);
 697 LOAD_FUNC(pa_threaded_mainloop_accept);
 698 LOAD_FUNC(pa_stream_set_write_callback);
 699 LOAD_FUNC(pa_threaded_mainloop_new);
 700 LOAD_FUNC(pa_context_connect);
 701 LOAD_FUNC(pa_stream_set_read_callback);
 702 LOAD_FUNC(pa_stream_set_state_callback);
 703 LOAD_FUNC(pa_stream_new);
 704 LOAD_FUNC(pa_stream_disconnect);
 705 LOAD_FUNC(pa_threaded_mainloop_lock);
 706
 707 #undef LOAD_FUNC
 708 } //}}}
 709
 710 void alc_pulse_deinit(void) //{{{
 711 {
 712     if(pa_handle)
 713     {
 714 #ifdef _WIN32
 715         FreeLibrary(pa_handle);
 716 #elif defined (HAVE_DLFCN_H)
 717         dlclose(pa_handle);
 718 #endif
 719     }
 720     pa_handle = NULL;
 721 } //}}}
 722
 723 void alc_pulse_probe(int type) //{{{
 724 {
 725     if(!pa_handle)
 726         return;
 727
 728     if(type == DEVICE_PROBE)
 729         AppendDeviceList(pulse_device);
 730     else if(type == ALL_DEVICE_PROBE)
 731         AppendAllDeviceList(pulse_device);
 732     else if(type == CAPTURE_DEVICE_PROBE)
 733         AppendCaptureDeviceList(pulse_capture_device);
 734 } //}}}
 735 //}}}