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 #ifndef PA_CHECK_VERSION
  48 #define PA_CHECK_VERSION(major,minor,micro)                             \
  49     ((PA_MAJOR > (major)) ||                                            \
  50      (PA_MAJOR == (major) && PA_MINOR > (minor)) ||                     \
  51      (PA_MAJOR == (major) && PA_MINOR == (minor) && PA_MICRO >= (micro)))
  52 #endif
  53
  54 static void *pa_handle;
  55 #define MAKE_FUNC(x) static typeof(x) * p##x
  56 MAKE_FUNC(pa_context_unref);
  57 MAKE_FUNC(pa_sample_spec_valid);
  58 MAKE_FUNC(pa_stream_drop);
  59 MAKE_FUNC(pa_strerror);
  60 MAKE_FUNC(pa_context_get_state);
  61 MAKE_FUNC(pa_stream_get_state);
  62 MAKE_FUNC(pa_threaded_mainloop_signal);
  63 MAKE_FUNC(pa_stream_peek);
  64 MAKE_FUNC(pa_threaded_mainloop_wait);
  65 MAKE_FUNC(pa_threaded_mainloop_unlock);
  66 MAKE_FUNC(pa_threaded_mainloop_in_thread);
  67 MAKE_FUNC(pa_context_new);
  68 MAKE_FUNC(pa_threaded_mainloop_stop);
  69 MAKE_FUNC(pa_context_disconnect);
  70 MAKE_FUNC(pa_threaded_mainloop_start);
  71 MAKE_FUNC(pa_threaded_mainloop_get_api);
  72 MAKE_FUNC(pa_context_set_state_callback);
  73 MAKE_FUNC(pa_stream_write);
  74 MAKE_FUNC(pa_xfree);
  75 MAKE_FUNC(pa_stream_connect_record);
  76 MAKE_FUNC(pa_stream_connect_playback);
  77 MAKE_FUNC(pa_stream_readable_size);
  78 MAKE_FUNC(pa_stream_cork);
  79 MAKE_FUNC(pa_stream_is_suspended);
  80 MAKE_FUNC(pa_stream_get_device_name);
  81 MAKE_FUNC(pa_path_get_filename);
  82 MAKE_FUNC(pa_get_binary_name);
  83 MAKE_FUNC(pa_threaded_mainloop_free);
  84 MAKE_FUNC(pa_context_errno);
  85 MAKE_FUNC(pa_xmalloc);
  86 MAKE_FUNC(pa_stream_unref);
  87 MAKE_FUNC(pa_threaded_mainloop_accept);
  88 MAKE_FUNC(pa_stream_set_write_callback);
  89 MAKE_FUNC(pa_threaded_mainloop_new);
  90 MAKE_FUNC(pa_context_connect);
  91 MAKE_FUNC(pa_stream_set_buffer_attr);
  92 MAKE_FUNC(pa_stream_get_buffer_attr);
  93 MAKE_FUNC(pa_stream_get_sample_spec);
  94 MAKE_FUNC(pa_stream_set_read_callback);
  95 MAKE_FUNC(pa_stream_set_state_callback);
  96 MAKE_FUNC(pa_stream_set_moved_callback);
  97 MAKE_FUNC(pa_stream_new);
  98 MAKE_FUNC(pa_stream_disconnect);
  99 MAKE_FUNC(pa_threaded_mainloop_lock);
 100 MAKE_FUNC(pa_channel_map_init_auto);
 101 MAKE_FUNC(pa_channel_map_parse);
 102 MAKE_FUNC(pa_channel_map_snprint);
 103 MAKE_FUNC(pa_channel_map_equal);
 104 MAKE_FUNC(pa_context_get_server_info);
 105 MAKE_FUNC(pa_context_get_sink_info_by_name);
 106 MAKE_FUNC(pa_operation_get_state);
 107 MAKE_FUNC(pa_operation_unref);
 108 #if PA_CHECK_VERSION(0,9,15)
 109 MAKE_FUNC(pa_channel_map_superset);
 110 MAKE_FUNC(pa_stream_set_buffer_attr_callback);
 111 #endif
 112 #if PA_CHECK_VERSION(0,9,16)
 113 MAKE_FUNC(pa_stream_begin_write);
 114 #endif
 115 #undef MAKE_FUNC
 116
 117 #ifndef PATH_MAX
 118 #define PATH_MAX 4096
 119 #endif
 120
 121 typedef struct {
 122     ALCuint samples;
 123     ALCuint frame_size;
 124
 125     RingBuffer *ring;
 126
 127     pa_buffer_attr attr;
 128     pa_sample_spec spec;
 129
 130     char *device_name;
 131     char path_name[PATH_MAX];
 132     const char *context_name;
 133     const char *stream_name;
 134
 135     pa_threaded_mainloop *loop;
 136
 137     pa_stream *stream;
 138     pa_context *context;
 139 } pulse_data;
 140
 141 static const ALCchar pulse_device[] = "PulseAudio Software";
 142 static const ALCchar pulse_capture_device[] = "PulseAudio Capture";
 143 static pa_context_flags_t pulse_ctx_flags;
 144
 145
 146 void *pulse_load(void) //{{{
 147 {
 148     if(!pa_handle)
 149     {
 150 #ifdef _WIN32
 151         pa_handle = LoadLibrary("libpulse-0.dll");
 152 #define LOAD_FUNC(x) do { \
 153     p##x = (typeof(p##x))GetProcAddress(pa_handle, #x); \
 154     if(!(p##x)) { \
 155         AL_PRINT("Could not load %s from libpulse-0.dll\n", #x); \
 156         FreeLibrary(pa_handle); \
 157         pa_handle = NULL; \
 158         return NULL; \
 159     } \
 160 } while(0)
 161 #define LOAD_OPTIONAL_FUNC(x) do { \
 162     p##x = (typeof(p##x))GetProcAddress(pa_handle, #x); \
 163 } while(0)
 164
 165 #elif defined (HAVE_DLFCN_H)
 166
 167         const char *err;
 168 #if defined(__APPLE__) && defined(__MACH__)
 169         pa_handle = dlopen("libpulse.0.dylib", RTLD_NOW);
 170 #else
 171         pa_handle = dlopen("libpulse.so.0", RTLD_NOW);
 172 #endif
 173         dlerror();
 174
 175 #define LOAD_FUNC(x) do { \
 176     p##x = dlsym(pa_handle, #x); \
 177     if((err=dlerror()) != NULL) { \
 178         AL_PRINT("Could not load %s from libpulse: %s\n", #x, err); \
 179         dlclose(pa_handle); \
 180         pa_handle = NULL; \
 181         return NULL; \
 182     } \
 183 } while(0)
 184 #define LOAD_OPTIONAL_FUNC(x) do { \
 185     p##x = dlsym(pa_handle, #x); \
 186     if((err=dlerror()) != NULL) { \
 187         p##x = NULL; \
 188     } \
 189 } while(0)
 190
 191 #else
 192
 193         pa_handle = (void*)0xDEADBEEF;
 194 #define LOAD_FUNC(x) p##x = (x)
 195 #define LOAD_OPTIONAL_FUNC(x) p##x = (x)
 196
 197 #endif
 198         if(!pa_handle)
 199             return NULL;
 200
 201 LOAD_FUNC(pa_context_unref);
 202 LOAD_FUNC(pa_sample_spec_valid);
 203 LOAD_FUNC(pa_stream_drop);
 204 LOAD_FUNC(pa_strerror);
 205 LOAD_FUNC(pa_context_get_state);
 206 LOAD_FUNC(pa_stream_get_state);
 207 LOAD_FUNC(pa_threaded_mainloop_signal);
 208 LOAD_FUNC(pa_stream_peek);
 209 LOAD_FUNC(pa_threaded_mainloop_wait);
 210 LOAD_FUNC(pa_threaded_mainloop_unlock);
 211 LOAD_FUNC(pa_threaded_mainloop_in_thread);
 212 LOAD_FUNC(pa_context_new);
 213 LOAD_FUNC(pa_threaded_mainloop_stop);
 214 LOAD_FUNC(pa_context_disconnect);
 215 LOAD_FUNC(pa_threaded_mainloop_start);
 216 LOAD_FUNC(pa_threaded_mainloop_get_api);
 217 LOAD_FUNC(pa_context_set_state_callback);
 218 LOAD_FUNC(pa_stream_write);
 219 LOAD_FUNC(pa_xfree);
 220 LOAD_FUNC(pa_stream_connect_record);
 221 LOAD_FUNC(pa_stream_connect_playback);
 222 LOAD_FUNC(pa_stream_readable_size);
 223 LOAD_FUNC(pa_stream_cork);
 224 LOAD_FUNC(pa_stream_is_suspended);
 225 LOAD_FUNC(pa_stream_get_device_name);
 226 LOAD_FUNC(pa_path_get_filename);
 227 LOAD_FUNC(pa_get_binary_name);
 228 LOAD_FUNC(pa_threaded_mainloop_free);
 229 LOAD_FUNC(pa_context_errno);
 230 LOAD_FUNC(pa_xmalloc);
 231 LOAD_FUNC(pa_stream_unref);
 232 LOAD_FUNC(pa_threaded_mainloop_accept);
 233 LOAD_FUNC(pa_stream_set_write_callback);
 234 LOAD_FUNC(pa_threaded_mainloop_new);
 235 LOAD_FUNC(pa_context_connect);
 236 LOAD_FUNC(pa_stream_set_buffer_attr);
 237 LOAD_FUNC(pa_stream_get_buffer_attr);
 238 LOAD_FUNC(pa_stream_get_sample_spec);
 239 LOAD_FUNC(pa_stream_set_read_callback);
 240 LOAD_FUNC(pa_stream_set_state_callback);
 241 LOAD_FUNC(pa_stream_set_moved_callback);
 242 LOAD_FUNC(pa_stream_new);
 243 LOAD_FUNC(pa_stream_disconnect);
 244 LOAD_FUNC(pa_threaded_mainloop_lock);
 245 LOAD_FUNC(pa_channel_map_init_auto);
 246 LOAD_FUNC(pa_channel_map_parse);
 247 LOAD_FUNC(pa_channel_map_snprint);
 248 LOAD_FUNC(pa_channel_map_equal);
 249 LOAD_FUNC(pa_context_get_server_info);
 250 LOAD_FUNC(pa_context_get_sink_info_by_name);
 251 LOAD_FUNC(pa_operation_get_state);
 252 LOAD_FUNC(pa_operation_unref);
 253 #if PA_CHECK_VERSION(0,9,15)
 254 LOAD_OPTIONAL_FUNC(pa_channel_map_superset);
 255 LOAD_OPTIONAL_FUNC(pa_stream_set_buffer_attr_callback);
 256 #endif
 257 #if PA_CHECK_VERSION(0,9,16)
 258 LOAD_OPTIONAL_FUNC(pa_stream_begin_write);
 259 #endif
 260
 261 #undef LOAD_OPTIONAL_FUNC
 262 #undef LOAD_FUNC
 263     }
 264     return pa_handle;
 265 } //}}}
 266
 267
 268 // PulseAudio Event Callbacks //{{{
 269 static void context_state_callback(pa_context *context, void *pdata) //{{{
 270 {
 271     pa_threaded_mainloop *loop = pdata;
 272     pa_context_state_t state;
 273
 274     state = ppa_context_get_state(context);
 275     if(state == PA_CONTEXT_READY || !PA_CONTEXT_IS_GOOD(state))
 276         ppa_threaded_mainloop_signal(loop, 0);
 277 }//}}}
 278
 279 static void stream_state_callback(pa_stream *stream, void *pdata) //{{{
 280 {
 281     pa_threaded_mainloop *loop = pdata;
 282     pa_stream_state_t state;
 283
 284     state = ppa_stream_get_state(stream);
 285     if(state == PA_STREAM_READY || !PA_STREAM_IS_GOOD(state))
 286         ppa_threaded_mainloop_signal(loop, 0);
 287 }//}}}
 288
 289 static void stream_buffer_attr_callback(pa_stream *stream, void *pdata) //{{{
 290 {
 291     ALCdevice *Device = pdata;
 292     pulse_data *data = Device->ExtraData;
 293
 294     SuspendContext(NULL);
 295
 296     data->attr = *(ppa_stream_get_buffer_attr(stream));
 297     Device->UpdateSize = 20 * Device->Frequency / 1000;
 298     Device->NumUpdates = data->attr.tlength/data->frame_size / Device->UpdateSize;
 299     if(Device->NumUpdates == 0)
 300         Device->NumUpdates = 1;
 301
 302     ProcessContext(NULL);
 303 }//}}}
 304
 305 static void stream_device_callback(pa_stream *stream, void *pdata) //{{{
 306 {
 307     ALCdevice *Device = pdata;
 308     pulse_data *data = Device->ExtraData;
 309
 310     free(data->device_name);
 311     data->device_name = strdup(ppa_stream_get_device_name(stream));
 312 }//}}}
 313
 314 static void context_state_callback2(pa_context *context, void *pdata) //{{{
 315 {
 316     ALCdevice *Device = pdata;
 317     pulse_data *data = Device->ExtraData;
 318
 319     if(ppa_context_get_state(context) == PA_CONTEXT_FAILED)
 320     {
 321         AL_PRINT("Received context failure!\n");
 322         aluHandleDisconnect(Device);
 323     }
 324     ppa_threaded_mainloop_signal(data->loop, 0);
 325 }//}}}
 326
 327 static void stream_state_callback2(pa_stream *stream, void *pdata) //{{{
 328 {
 329     ALCdevice *Device = pdata;
 330     pulse_data *data = Device->ExtraData;
 331
 332     if(ppa_stream_get_state(stream) == PA_STREAM_FAILED)
 333     {
 334         AL_PRINT("Received stream failure!\n");
 335         aluHandleDisconnect(Device);
 336     }
 337     ppa_threaded_mainloop_signal(data->loop, 0);
 338 }//}}}
 339
 340 static void stream_success_callback(pa_stream *stream, int success, void *pdata) //{{{
 341 {
 342     ALCdevice *Device = pdata;
 343     pulse_data *data = Device->ExtraData;
 344     (void)stream;
 345     (void)success;
 346
 347     ppa_threaded_mainloop_signal(data->loop, 0);
 348 }//}}}
 349
 350 static void sink_info_callback(pa_context *context, const pa_sink_info *info, int eol, void *pdata) //{{{
 351 {
 352     ALCdevice *device = pdata;
 353     pulse_data *data = device->ExtraData;
 354     char chanmap_str[256] = "";
 355     const struct {
 356         const char *str;
 357         ALenum format;
 358     } chanmaps[] = {
 359         { "front-left,front-right,front-center,lfe,rear-left,rear-right,side-left,side-right",
 360           AL_FORMAT_71CHN32 },
 361         { "front-left,front-right,front-center,lfe,rear-center,side-left,side-right",
 362           AL_FORMAT_61CHN32 },
 363         { "front-left,front-right,front-center,lfe,rear-left,rear-right",
 364           AL_FORMAT_51CHN32 },
 365         { "front-left,front-right,rear-left,rear-right", AL_FORMAT_QUAD32 },
 366         { "front-left,front-right", AL_FORMAT_STEREO_FLOAT32 },
 367         { "mono", AL_FORMAT_MONO_FLOAT32 },
 368         { NULL, 0 }
 369     };
 370     int i;
 371     (void)context;
 372
 373     if(eol)
 374     {
 375         ppa_threaded_mainloop_signal(data->loop, 0);
 376         return;
 377     }
 378
 379     for(i = 0;chanmaps[i].str;i++)
 380     {
 381         pa_channel_map map;
 382         if(!ppa_channel_map_parse(&map, chanmaps[i].str))
 383             continue;
 384
 385         if(ppa_channel_map_equal(&info->channel_map, &map)
 386 #if PA_CHECK_VERSION(0,9,15)
 387            || (ppa_channel_map_superset &&
 388                ppa_channel_map_superset(&info->channel_map, &map))
 389 #endif
 390             )
 391         {
 392             device->Format = chanmaps[i].format;
 393             return;
 394         }
 395     }
 396
 397     ppa_channel_map_snprint(chanmap_str, sizeof(chanmap_str), &info->channel_map);
 398     AL_PRINT("Failed to find format for channel map:\n    %s\n", chanmap_str);
 399 }//}}}
 400 //}}}
 401
 402 // PulseAudio I/O Callbacks //{{{
 403 static void stream_write_callback(pa_stream *stream, size_t len, void *pdata) //{{{
 404 {
 405     ALCdevice *Device = pdata;
 406     pulse_data *data = Device->ExtraData;
 407
 408     while(len > 0)
 409     {
 410         size_t newlen = len;
 411         void *buf;
 412         pa_free_cb_t free_func = NULL;
 413
 414 #if PA_CHECK_VERSION(0,9,16)
 415         if(!ppa_stream_begin_write ||
 416            ppa_stream_begin_write(stream, &buf, &newlen) < 0)
 417 #endif
 418         {
 419             buf = ppa_xmalloc(newlen);
 420             free_func = ppa_xfree;
 421         }
 422
 423         aluMixData(Device, buf, newlen/data->frame_size);
 424         ppa_stream_write(stream, buf, newlen, free_func, 0, PA_SEEK_RELATIVE);
 425         len -= newlen;
 426     }
 427 } //}}}
 428 //}}}
 429
 430 static pa_context *connect_context(pa_threaded_mainloop *loop, const char *name)
 431 {
 432     pa_context_state_t state;
 433     pa_context *context;
 434     int err;
 435
 436     context = ppa_context_new(ppa_threaded_mainloop_get_api(loop), name);
 437     if(!context)
 438     {
 439         AL_PRINT("pa_context_new() failed\n");
 440         return NULL;
 441     }
 442
 443     ppa_context_set_state_callback(context, context_state_callback, loop);
 444
 445     if((err=ppa_context_connect(context, NULL, pulse_ctx_flags, NULL)) >= 0)
 446     {
 447         while((state=ppa_context_get_state(context)) != PA_CONTEXT_READY)
 448         {
 449             if(!PA_CONTEXT_IS_GOOD(state))
 450             {
 451                 err = ppa_context_errno(context);
 452                 break;
 453             }
 454
 455             ppa_threaded_mainloop_wait(loop);
 456         }
 457     }
 458     ppa_context_set_state_callback(context, NULL, NULL);
 459
 460     if(err < 0)
 461     {
 462         AL_PRINT("Context did not connect: %s\n", ppa_strerror(err));
 463         ppa_context_unref(context);
 464         return NULL;
 465     }
 466
 467     return context;
 468 }
 469
 470 static pa_stream *connect_playback_stream(ALCdevice *device,
 471     pa_stream_flags_t flags, pa_buffer_attr *attr, pa_sample_spec *spec,
 472     pa_channel_map *chanmap)
 473 {
 474     pulse_data *data = device->ExtraData;
 475     pa_stream_state_t state;
 476     pa_stream *stream;
 477
 478     stream = ppa_stream_new(data->context, data->stream_name, spec, chanmap);
 479     if(!stream)
 480     {
 481         AL_PRINT("pa_stream_new() failed: %s\n",
 482                  ppa_strerror(ppa_context_errno(data->context)));
 483         return NULL;
 484     }
 485
 486     ppa_stream_set_state_callback(stream, stream_state_callback, data->loop);
 487
 488     if(ppa_stream_connect_playback(stream, data->device_name, attr, flags, NULL, NULL) < 0)
 489     {
 490         AL_PRINT("Stream did not connect: %s\n",
 491                  ppa_strerror(ppa_context_errno(data->context)));
 492         ppa_stream_unref(stream);
 493         return NULL;
 494     }
 495
 496     while((state=ppa_stream_get_state(stream)) != PA_STREAM_READY)
 497     {
 498         if(!PA_STREAM_IS_GOOD(state))
 499         {
 500             AL_PRINT("Stream did not get ready: %s\n",
 501                      ppa_strerror(ppa_context_errno(data->context)));
 502             ppa_stream_unref(stream);
 503             return NULL;
 504         }
 505
 506         ppa_threaded_mainloop_wait(data->loop);
 507     }
 508     ppa_stream_set_state_callback(stream, NULL, NULL);
 509
 510     return stream;
 511 }
 512
 513 static ALCboolean pulse_open(ALCdevice *device, const ALCchar *device_name) //{{{
 514 {
 515     pulse_data *data = ppa_xmalloc(sizeof(pulse_data));
 516
 517     memset(data, 0, sizeof(*data));
 518
 519     if(ppa_get_binary_name(data->path_name, sizeof(data->path_name)))
 520         data->context_name = ppa_path_get_filename(data->path_name);
 521     else
 522         data->context_name = "OpenAL Soft";
 523
 524     if(!(data->loop = ppa_threaded_mainloop_new()))
 525     {
 526         AL_PRINT("pa_threaded_mainloop_new() failed!\n");
 527         goto out;
 528     }
 529     if(ppa_threaded_mainloop_start(data->loop) < 0)
 530     {
 531         AL_PRINT("pa_threaded_mainloop_start() failed\n");
 532         goto out;
 533     }
 534
 535     ppa_threaded_mainloop_lock(data->loop);
 536     device->ExtraData = data;
 537
 538     data->context = connect_context(data->loop, data->context_name);
 539     if(!data->context)
 540     {
 541         ppa_threaded_mainloop_unlock(data->loop);
 542         goto out;
 543     }
 544     ppa_context_set_state_callback(data->context, context_state_callback2, device);
 545
 546     device->szDeviceName = strdup(device_name);
 547
 548     ppa_threaded_mainloop_unlock(data->loop);
 549     return ALC_TRUE;
 550
 551 out:
 552     if(data->loop)
 553     {
 554         ppa_threaded_mainloop_stop(data->loop);
 555         ppa_threaded_mainloop_free(data->loop);
 556     }
 557
 558     device->ExtraData = NULL;
 559     ppa_xfree(data);
 560     return ALC_FALSE;
 561 } //}}}
 562
 563 static void pulse_close(ALCdevice *device) //{{{
 564 {
 565     pulse_data *data = device->ExtraData;
 566
 567     ppa_threaded_mainloop_lock(data->loop);
 568
 569     if(data->stream)
 570     {
 571         ppa_stream_disconnect(data->stream);
 572         ppa_stream_unref(data->stream);
 573     }
 574
 575     ppa_context_disconnect(data->context);
 576     ppa_context_unref(data->context);
 577
 578     ppa_threaded_mainloop_unlock(data->loop);
 579
 580     ppa_threaded_mainloop_stop(data->loop);
 581     ppa_threaded_mainloop_free(data->loop);
 582
 583     DestroyRingBuffer(data->ring);
 584     free(data->device_name);
 585
 586     device->ExtraData = NULL;
 587     ppa_xfree(data);
 588 } //}}}
 589 //}}}
 590
 591 // OpenAL {{{
 592 static ALCboolean pulse_open_playback(ALCdevice *device, const ALCchar *device_name) //{{{
 593 {
 594     pa_sample_spec spec;
 595     pulse_data *data;
 596     ALuint len;
 597
 598     if(!device_name)
 599         device_name = pulse_device;
 600     else if(strcmp(device_name, pulse_device) != 0)
 601         return ALC_FALSE;
 602
 603     if(!pulse_load())
 604         return ALC_FALSE;
 605
 606     if(pulse_open(device, device_name) == ALC_FALSE)
 607         return ALC_FALSE;
 608
 609     data = device->ExtraData;
 610
 611     ppa_threaded_mainloop_lock(data->loop);
 612
 613     data->stream_name = "Playback Stream";
 614     spec.format = PA_SAMPLE_S16NE;
 615     spec.rate = 44100;
 616     spec.channels = 2;
 617
 618     pa_stream *stream = connect_playback_stream(device, 0, NULL, &spec, NULL);
 619     if(!stream)
 620     {
 621         ppa_threaded_mainloop_unlock(data->loop);
 622         goto fail;
 623     }
 624
 625     if(ppa_stream_is_suspended(stream))
 626     {
 627         ppa_stream_disconnect(stream);
 628         ppa_stream_unref(stream);
 629         ppa_threaded_mainloop_unlock(data->loop);
 630         goto fail;
 631     }
 632     data->device_name = strdup(ppa_stream_get_device_name(stream));
 633
 634     ppa_stream_disconnect(stream);
 635     ppa_stream_unref(stream);
 636
 637     ppa_threaded_mainloop_unlock(data->loop);
 638
 639     len = GetConfigValueInt("pulse", "buffer-length", 2048);
 640     if(len != 0)
 641     {
 642         device->UpdateSize = len;
 643         device->NumUpdates = 1;
 644     }
 645     return ALC_TRUE;
 646
 647 fail:
 648     pulse_close(device);
 649     return ALC_FALSE;
 650 } //}}}
 651
 652 static void pulse_close_playback(ALCdevice *device) //{{{
 653 {
 654     pulse_close(device);
 655 } //}}}
 656
 657 static ALCboolean pulse_reset_playback(ALCdevice *device) //{{{
 658 {
 659     pulse_data *data = device->ExtraData;
 660     pa_stream_flags_t flags = 0;
 661     pa_channel_map chanmap;
 662
 663     ppa_threaded_mainloop_lock(data->loop);
 664
 665     if(!ConfigValueExists(NULL, "format"))
 666     {
 667         pa_operation *o;
 668         o = ppa_context_get_sink_info_by_name(data->context, data->device_name, sink_info_callback, device);
 669         while(ppa_operation_get_state(o) == PA_OPERATION_RUNNING)
 670             ppa_threaded_mainloop_wait(data->loop);
 671         ppa_operation_unref(o);
 672     }
 673     if(!ConfigValueExists(NULL, "frequency"))
 674         flags |= PA_STREAM_FIX_RATE;
 675
 676     data->frame_size = aluFrameSizeFromFormat(device->Format);
 677     data->stream_name = "Playback Stream";
 678     data->attr.minreq = -1;
 679     data->attr.prebuf = -1;
 680     data->attr.fragsize = -1;
 681     data->attr.tlength = device->UpdateSize * device->NumUpdates *
 682                          data->frame_size;
 683     data->attr.maxlength = data->attr.tlength;
 684
 685     switch(aluBytesFromFormat(device->Format))
 686     {
 687         case 1:
 688             data->spec.format = PA_SAMPLE_U8;
 689             break;
 690         case 2:
 691             data->spec.format = PA_SAMPLE_S16NE;
 692             break;
 693         case 4:
 694             data->spec.format = PA_SAMPLE_FLOAT32NE;
 695             break;
 696         default:
 697             AL_PRINT("Unknown format: 0x%x\n", device->Format);
 698             ppa_threaded_mainloop_unlock(data->loop);
 699             return ALC_FALSE;
 700     }
 701     data->spec.rate = device->Frequency;
 702     data->spec.channels = aluChannelsFromFormat(device->Format);
 703
 704     if(ppa_sample_spec_valid(&data->spec) == 0)
 705     {
 706         AL_PRINT("Invalid sample format\n");
 707         ppa_threaded_mainloop_unlock(data->loop);
 708         return ALC_FALSE;
 709     }
 710
 711     if(!ppa_channel_map_init_auto(&chanmap, data->spec.channels, PA_CHANNEL_MAP_WAVEEX))
 712     {
 713         AL_PRINT("Couldn't build map for channel count (%d)!\n", data->spec.channels);
 714         ppa_threaded_mainloop_unlock(data->loop);
 715         return ALC_FALSE;
 716     }
 717     SetDefaultWFXChannelOrder(device);
 718
 719     data->stream = connect_playback_stream(device, flags, &data->attr, &data->spec, &chanmap);
 720     if(!data->stream)
 721     {
 722         ppa_threaded_mainloop_unlock(data->loop);
 723         return ALC_FALSE;
 724     }
 725
 726     ppa_stream_set_state_callback(data->stream, stream_state_callback2, device);
 727
 728     data->spec = *(ppa_stream_get_sample_spec(data->stream));
 729     if(device->Frequency != data->spec.rate)
 730     {
 731         pa_operation *o;
 732
 733         /* Server updated our playback rate, so modify the buffer attribs
 734          * accordingly. */
 735         data->attr.tlength = (ALuint64)(data->attr.tlength/data->frame_size) *
 736                              data->spec.rate / device->Frequency * data->frame_size;
 737         data->attr.maxlength = data->attr.tlength;
 738
 739         o = ppa_stream_set_buffer_attr(data->stream, &data->attr,
 740                                        stream_success_callback, device);
 741         while(ppa_operation_get_state(o) == PA_OPERATION_RUNNING)
 742             ppa_threaded_mainloop_wait(data->loop);
 743         ppa_operation_unref(o);
 744
 745         device->Frequency = data->spec.rate;
 746     }
 747
 748     stream_buffer_attr_callback(data->stream, device);
 749 #if PA_CHECK_VERSION(0,9,15)
 750     if(ppa_stream_set_buffer_attr_callback)
 751         ppa_stream_set_buffer_attr_callback(data->stream, stream_buffer_attr_callback, device);
 752 #endif
 753     ppa_stream_set_moved_callback(data->stream, stream_device_callback, device);
 754
 755     stream_write_callback(data->stream, data->attr.tlength, device);
 756     ppa_stream_set_write_callback(data->stream, stream_write_callback, device);
 757
 758     ppa_threaded_mainloop_unlock(data->loop);
 759     return ALC_TRUE;
 760 } //}}}
 761
 762 static void pulse_stop_playback(ALCdevice *device) //{{{
 763 {
 764     pulse_data *data = device->ExtraData;
 765
 766     if(!data->stream)
 767         return;
 768
 769     ppa_threaded_mainloop_lock(data->loop);
 770
 771 #if PA_CHECK_VERSION(0,9,15)
 772     if(ppa_stream_set_buffer_attr_callback)
 773         ppa_stream_set_buffer_attr_callback(data->stream, NULL, NULL);
 774 #endif
 775     ppa_stream_set_moved_callback(data->stream, NULL, NULL);
 776     ppa_stream_set_write_callback(data->stream, NULL, NULL);
 777     ppa_stream_disconnect(data->stream);
 778     ppa_stream_unref(data->stream);
 779     data->stream = NULL;
 780
 781     ppa_threaded_mainloop_unlock(data->loop);
 782 } //}}}
 783
 784
 785 static ALCboolean pulse_open_capture(ALCdevice *device, const ALCchar *device_name) //{{{
 786 {
 787     pulse_data *data;
 788     pa_stream_flags_t flags = 0;
 789     pa_stream_state_t state;
 790     pa_channel_map chanmap;
 791
 792     if(!device_name)
 793         device_name = pulse_capture_device;
 794     else if(strcmp(device_name, pulse_capture_device) != 0)
 795         return ALC_FALSE;
 796
 797     if(!pulse_load())
 798         return ALC_FALSE;
 799
 800     if(pulse_open(device, device_name) == ALC_FALSE)
 801         return ALC_FALSE;
 802
 803     data = device->ExtraData;
 804     ppa_threaded_mainloop_lock(data->loop);
 805
 806     data->samples = device->UpdateSize * device->NumUpdates;
 807     data->frame_size = aluFrameSizeFromFormat(device->Format);
 808
 809     if(!(data->ring = CreateRingBuffer(data->frame_size, data->samples)))
 810     {
 811         ppa_threaded_mainloop_unlock(data->loop);
 812         goto fail;
 813     }
 814
 815     data->attr.minreq = -1;
 816     data->attr.prebuf = -1;
 817     data->attr.maxlength = data->frame_size * data->samples;
 818     data->attr.tlength = -1;
 819     data->attr.fragsize = min(data->frame_size * data->samples,
 820                               10 * device->Frequency / 1000);
 821     data->stream_name = "Capture Stream";
 822
 823     data->spec.rate = device->Frequency;
 824     data->spec.channels = aluChannelsFromFormat(device->Format);
 825
 826     switch(aluBytesFromFormat(device->Format))
 827     {
 828         case 1:
 829             data->spec.format = PA_SAMPLE_U8;
 830             break;
 831         case 2:
 832             data->spec.format = PA_SAMPLE_S16NE;
 833             break;
 834         case 4:
 835             data->spec.format = PA_SAMPLE_FLOAT32NE;
 836             break;
 837         default:
 838             AL_PRINT("Unknown format: 0x%x\n", device->Format);
 839             ppa_threaded_mainloop_unlock(data->loop);
 840             goto fail;
 841     }
 842
 843     if(ppa_sample_spec_valid(&data->spec) == 0)
 844     {
 845         AL_PRINT("Invalid sample format\n");
 846         ppa_threaded_mainloop_unlock(data->loop);
 847         goto fail;
 848     }
 849
 850     if(!ppa_channel_map_init_auto(&chanmap, data->spec.channels, PA_CHANNEL_MAP_WAVEEX))
 851     {
 852         AL_PRINT("Couldn't build map for channel count (%d)!\n", data->spec.channels);
 853         ppa_threaded_mainloop_unlock(data->loop);
 854         goto fail;
 855     }
 856
 857     data->stream = ppa_stream_new(data->context, data->stream_name, &data->spec, &chanmap);
 858     if(!data->stream)
 859     {
 860         AL_PRINT("pa_stream_new() failed: %s\n",
 861                  ppa_strerror(ppa_context_errno(data->context)));
 862
 863         ppa_threaded_mainloop_unlock(data->loop);
 864         goto fail;
 865     }
 866
 867     ppa_stream_set_state_callback(data->stream, stream_state_callback, data->loop);
 868
 869     flags |= PA_STREAM_START_CORKED|PA_STREAM_ADJUST_LATENCY;
 870     if(ppa_stream_connect_record(data->stream, NULL, &data->attr, flags) < 0)
 871     {
 872         AL_PRINT("Stream did not connect: %s\n",
 873                  ppa_strerror(ppa_context_errno(data->context)));
 874
 875         ppa_stream_unref(data->stream);
 876         data->stream = NULL;
 877
 878         ppa_threaded_mainloop_unlock(data->loop);
 879         goto fail;
 880     }
 881
 882     while((state=ppa_stream_get_state(data->stream)) != PA_STREAM_READY)
 883     {
 884         if(!PA_STREAM_IS_GOOD(state))
 885         {
 886             AL_PRINT("Stream did not get ready: %s\n",
 887                      ppa_strerror(ppa_context_errno(data->context)));
 888
 889             ppa_stream_unref(data->stream);
 890             data->stream = NULL;
 891
 892             ppa_threaded_mainloop_unlock(data->loop);
 893             goto fail;
 894         }
 895
 896         ppa_threaded_mainloop_wait(data->loop);
 897     }
 898     ppa_stream_set_state_callback(data->stream, stream_state_callback2, device);
 899
 900     ppa_threaded_mainloop_unlock(data->loop);
 901     return ALC_TRUE;
 902
 903 fail:
 904     pulse_close(device);
 905     return ALC_FALSE;
 906 } //}}}
 907
 908 static void pulse_close_capture(ALCdevice *device) //{{{
 909 {
 910     pulse_close(device);
 911 } //}}}
 912
 913 static void pulse_start_capture(ALCdevice *device) //{{{
 914 {
 915     pulse_data *data = device->ExtraData;
 916     pa_operation *o;
 917
 918     ppa_threaded_mainloop_lock(data->loop);
 919     o = ppa_stream_cork(data->stream, 0, stream_success_callback, device);
 920     while(ppa_operation_get_state(o) == PA_OPERATION_RUNNING)
 921         ppa_threaded_mainloop_wait(data->loop);
 922     ppa_operation_unref(o);
 923     ppa_threaded_mainloop_unlock(data->loop);
 924 } //}}}
 925
 926 static void pulse_stop_capture(ALCdevice *device) //{{{
 927 {
 928     pulse_data *data = device->ExtraData;
 929     pa_operation *o;
 930
 931     ppa_threaded_mainloop_lock(data->loop);
 932     o = ppa_stream_cork(data->stream, 1, stream_success_callback, device);
 933     while(ppa_operation_get_state(o) == PA_OPERATION_RUNNING)
 934         ppa_threaded_mainloop_wait(data->loop);
 935     ppa_operation_unref(o);
 936     ppa_threaded_mainloop_unlock(data->loop);
 937 } //}}}
 938
 939 static void pulse_capture_samples(ALCdevice *device, ALCvoid *buffer, ALCuint samples) //{{{
 940 {
 941     pulse_data *data = device->ExtraData;
 942     ALCuint available = RingBufferSize(data->ring);
 943     const void *buf;
 944     size_t length;
 945
 946     available *= data->frame_size;
 947     samples *= data->frame_size;
 948
 949     ppa_threaded_mainloop_lock(data->loop);
 950     if(available+ppa_stream_readable_size(data->stream) < samples)
 951     {
 952         ppa_threaded_mainloop_unlock(data->loop);
 953         alcSetError(device, ALC_INVALID_VALUE);
 954         return;
 955     }
 956
 957     available = min(available, samples);
 958     if(available > 0)
 959     {
 960         ReadRingBuffer(data->ring, buffer, available/data->frame_size);
 961         buffer = (ALubyte*)buffer + available;
 962         samples -= available;
 963     }
 964
 965     /* Capture is done in fragment-sized chunks, so we loop until we get all
 966      * that's requested */
 967     while(samples > 0)
 968     {
 969         if(ppa_stream_peek(data->stream, &buf, &length) < 0)
 970         {
 971             AL_PRINT("pa_stream_peek() failed: %s\n",
 972                      ppa_strerror(ppa_context_errno(data->context)));
 973             break;
 974         }
 975         available = min(length, samples);
 976
 977         memcpy(buffer, buf, available);
 978         buffer = (ALubyte*)buffer + available;
 979         buf = (const ALubyte*)buf + available;
 980         samples -= available;
 981         length -= available;
 982
 983         /* Any unread data in the fragment will be lost, so save it */
 984         length /= data->frame_size;
 985         if(length > 0)
 986         {
 987             if(length > data->samples)
 988                 length = data->samples;
 989             WriteRingBuffer(data->ring, buf, length);
 990         }
 991
 992         ppa_stream_drop(data->stream);
 993     }
 994     ppa_threaded_mainloop_unlock(data->loop);
 995 } //}}}
 996
 997 static ALCuint pulse_available_samples(ALCdevice *device) //{{{
 998 {
 999     pulse_data *data = device->ExtraData;
1000     ALCuint ret;
1001
1002     ppa_threaded_mainloop_lock(data->loop);
1003     ret  = RingBufferSize(data->ring);
1004     ret += ppa_stream_readable_size(data->stream)/data->frame_size;
1005     ppa_threaded_mainloop_unlock(data->loop);
1006
1007     return ret;
1008 } //}}}
1009
1010 BackendFuncs pulse_funcs = { //{{{
1011     pulse_open_playback,
1012     pulse_close_playback,
1013     pulse_reset_playback,
1014     pulse_stop_playback,
1015     pulse_open_capture,
1016     pulse_close_capture,
1017     pulse_start_capture,
1018     pulse_stop_capture,
1019     pulse_capture_samples,
1020     pulse_available_samples
1021 }; //}}}
1022
1023 void alc_pulse_init(BackendFuncs *func_list) //{{{
1024 {
1025     *func_list = pulse_funcs;
1026
1027     pulse_ctx_flags = 0;
1028     if(!GetConfigValueBool("pulse", "spawn-server", 0))
1029         pulse_ctx_flags |= PA_CONTEXT_NOAUTOSPAWN;
1030 } //}}}
1031
1032 void alc_pulse_deinit(void) //{{{
1033 {
1034     if(pa_handle)
1035     {
1036 #ifdef _WIN32
1037         FreeLibrary(pa_handle);
1038 #elif defined (HAVE_DLFCN_H)
1039         dlclose(pa_handle);
1040 #endif
1041         pa_handle = NULL;
1042     }
1043 } //}}}
1044
1045 void alc_pulse_probe(int type) //{{{
1046 {
1047     if(!pulse_load()) return;
1048
1049     if(type == DEVICE_PROBE)
1050         AppendDeviceList(pulse_device);
1051     else if(type == ALL_DEVICE_PROBE)
1052         AppendAllDeviceList(pulse_device);
1053     else if(type == CAPTURE_DEVICE_PROBE)
1054         AppendCaptureDeviceList(pulse_capture_device);
1055 } //}}}
1056 //}}}