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