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