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