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