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