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
  25 #include <pulse/pulseaudio.h>
  26
  27 #if PA_API_VERSION == 11
  28 #define PA_STREAM_ADJUST_LATENCY 0x2000U
  29 static inline int PA_STREAM_IS_GOOD(pa_stream_state_t x)
  30 {
  31     return (x == PA_STREAM_CREATING || x == PA_STREAM_READY);
  32 }
  33 static inline int PA_CONTEXT_IS_GOOD(pa_context_state_t x)
  34 {
  35     return (x == PA_CONTEXT_CONNECTING || x == PA_CONTEXT_AUTHORIZING ||
  36             x == PA_CONTEXT_SETTING_NAME || x == PA_CONTEXT_READY);
  37 }
  38 #define PA_STREAM_IS_GOOD PA_STREAM_IS_GOOD
  39 #define PA_CONTEXT_IS_GOOD PA_CONTEXT_IS_GOOD
  40 #elif PA_API_VERSION != 12
  41 #error Invalid PulseAudio API version
  42 #endif
  43
  44 typedef struct {
  45     ALCdevice *device;
  46
  47     ALCenum format;
  48     ALCuint samples;
  49     ALCuint frequency;
  50     ALCuint frame_size;
  51
  52     RingBuffer *ring;
  53
  54     pa_buffer_attr attr;
  55     pa_sample_spec spec;
  56
  57     char path_name[PATH_MAX];
  58     const char *context_name;
  59     const char *stream_name;
  60
  61     pa_threaded_mainloop *loop;
  62
  63     pa_stream *stream;
  64     pa_context *context;
  65 } pulse_data;
  66
  67 static char *pulse_device;
  68 static char *pulse_capture_device;
  69
  70 // PulseAudio Event Callbacks {{{
  71 static void stream_state_callback(pa_stream *stream, void *pdata) //{{{
  72 {
  73     pulse_data *data = pdata;
  74
  75     switch(pa_stream_get_state(stream))
  76         {
  77                 case PA_STREAM_READY:
  78             AL_PRINT("%s: %s ready!\n", data->context_name, data->stream_name);
  79                         break;
  80
  81                 case PA_STREAM_FAILED:
  82             AL_PRINT("%s: %s: Connection failed: %s\n", data->context_name,
  83                      data->stream_name, pa_strerror(pa_context_errno(data->context)));
  84                         break;
  85
  86                 case PA_STREAM_TERMINATED:
  87             AL_PRINT("%s: %s terminated!\n", data->context_name, data->stream_name);
  88                         break;
  89
  90                 default:
  91                         break;
  92         }
  93
  94     pa_threaded_mainloop_signal(data->loop, 1);
  95 } //}}}
  96
  97 static void context_state_callback(pa_context *context, void *pdata) //{{{
  98 {
  99     pulse_data *data = pdata;
 100
 101     switch(pa_context_get_state(context))
 102         {
 103                 case PA_CONTEXT_READY:
 104             AL_PRINT("%s ready!\n", data->context_name);
 105                         break;
 106
 107                 case PA_CONTEXT_FAILED:
 108             AL_PRINT("%s: Connection failed: %s\n", data->context_name,
 109                      pa_strerror(pa_context_errno(context)));
 110             break;
 111
 112                 case PA_CONTEXT_TERMINATED:
 113             AL_PRINT("%s terminated!\n", data->context_name);
 114                         break;
 115
 116                 default:
 117                         break;
 118         }
 119
 120     pa_threaded_mainloop_signal(data->loop, 1);
 121 } //}}}
 122 //}}}
 123
 124 // PulseAudio I/O Callbacks //{{{
 125 static void stream_write_callback(pa_stream *stream, size_t len, void *pdata) //{{{
 126 {
 127     ALCdevice *Device = pdata;
 128     void *buf = pa_xmalloc0(len);
 129
 130     SuspendContext(NULL);
 131     aluMixData(Device->Context, buf, len, Device->Format);
 132     ProcessContext(NULL);
 133
 134     pa_stream_write(stream, buf, len, pa_xfree, 0, PA_SEEK_RELATIVE);
 135 } //}}}
 136
 137 static void stream_read_callback(pa_stream *stream, size_t length, void *pdata) //{{{
 138 {
 139     ALCdevice *Device = pdata;
 140     pulse_data *data = Device->ExtraData;
 141     const void *buf;
 142
 143     if(pa_stream_peek(stream, &buf, &length) < 0)
 144     {
 145         AL_PRINT("pa_stream_peek() failed: %s\n",
 146                  pa_strerror(pa_context_errno(data->context)));
 147         return;
 148     }
 149
 150     assert(buf);
 151     assert(length);
 152
 153     length /= data->frame_size;
 154
 155     if(data->samples < length)
 156         AL_PRINT("stream_read_callback: buffer overflow!\n");
 157
 158     WriteRingBuffer(data->ring, buf, (length<data->samples) ? length : data->samples);
 159
 160     pa_stream_drop(stream);
 161 } //}}}
 162 //}}}
 163
 164 static ALCboolean pulse_open(ALCdevice *device, ALCchar *device_name, ALCenum format, ALCuint samples, ALCuint frequency) //{{{
 165 {
 166     pulse_data *data = pa_xmalloc0(sizeof(pulse_data));
 167
 168     data->device = device;
 169     data->format = format;
 170     data->samples = samples;
 171     data->frequency = frequency;
 172     data->frame_size = aluBytesFromFormat(format) * aluChannelsFromFormat(format);
 173
 174     if(pa_get_binary_name(data->path_name, sizeof(data->path_name)))
 175         data->context_name = pa_path_get_filename(data->path_name);
 176     else
 177         data->context_name = "OpenAL Soft";
 178
 179     if(!(data->ring = CreateRingBuffer(data->frame_size, data->samples)))
 180     {
 181         pa_xfree(data);
 182         return ALC_FALSE;
 183     }
 184
 185     device->ExtraData = data;
 186     device->szDeviceName = device_name;
 187
 188     data->attr.minreq = -1;
 189     data->attr.prebuf = -1;
 190     data->attr.maxlength = -1;
 191
 192     if(device->IsCaptureDevice)
 193     {
 194         data->attr.tlength = -1;
 195         data->attr.fragsize = data->frame_size * data->samples / 2;
 196         data->stream_name = "Capture Stream";
 197     }
 198     else
 199     {
 200         data->attr.tlength = data->frame_size * (device->UpdateSize&~3);
 201         data->attr.fragsize = -1;
 202         data->stream_name = "Playback Stream";
 203     }
 204
 205     data->spec.rate = data->frequency;
 206     data->spec.channels = aluChannelsFromFormat(data->format);
 207
 208     switch(aluBytesFromFormat(data->format))
 209     {
 210         case 1:
 211             data->spec.format = PA_SAMPLE_U8;
 212             break;
 213         case 2:
 214             data->spec.format = PA_SAMPLE_S16NE;
 215             break;
 216         default:
 217             AL_PRINT("Unknown format: %x\n", data->format);
 218                         goto out2;
 219     }
 220
 221     if(pa_sample_spec_valid(&data->spec) == 0)
 222     {
 223         AL_PRINT("Invalid sample format\n");
 224                 goto out2;
 225     }
 226
 227     if(!(data->loop = pa_threaded_mainloop_new()))
 228     {
 229         AL_PRINT("pa_threaded_mainloop_new() failed!\n");
 230                 goto out2;
 231     }
 232
 233     if(pa_threaded_mainloop_start(data->loop) < 0)
 234     {
 235         AL_PRINT("pa_threaded_mainloop_start() failed\n");
 236                 goto out3;
 237     }
 238
 239     pa_threaded_mainloop_lock(data->loop);
 240
 241     data->context = pa_context_new(pa_threaded_mainloop_get_api(data->loop), data->context_name);
 242     if(!data->context)
 243     {
 244         AL_PRINT("pa_context_new() failed: %s\n",
 245                  pa_strerror(pa_context_errno(data->context)));
 246
 247         pa_threaded_mainloop_unlock(data->loop);
 248                 goto out3;
 249     }
 250
 251     pa_context_set_state_callback(data->context, context_state_callback, data);
 252
 253     if(pa_context_connect(data->context, NULL, PA_CONTEXT_NOAUTOSPAWN, NULL) < 0)
 254     {
 255         AL_PRINT("Context did not connect: %s\n",
 256                  pa_strerror(pa_context_errno(data->context)));
 257
 258         pa_context_unref(data->context);
 259         pa_threaded_mainloop_unlock(data->loop);
 260
 261         data->context = NULL;
 262                 goto out3;
 263     }
 264
 265     while(pa_context_get_state(data->context) != PA_CONTEXT_READY)
 266     {
 267         if(!PA_CONTEXT_IS_GOOD(pa_context_get_state(data->context)))
 268         {
 269             pa_context_unref(data->context);
 270             pa_threaded_mainloop_unlock(data->loop);
 271
 272             data->context = NULL;
 273                         goto out3;
 274         }
 275
 276         pa_threaded_mainloop_wait(data->loop);
 277         pa_threaded_mainloop_accept(data->loop);
 278     }
 279
 280     data->stream = pa_stream_new(data->context, data->stream_name, &data->spec, NULL);
 281     if(!data->stream)
 282     {
 283         AL_PRINT("pa_stream_new() failed: %s\n",
 284                  pa_strerror(pa_context_errno(data->context)));
 285
 286         pa_threaded_mainloop_unlock(data->loop);
 287                 goto out4;
 288     }
 289
 290     pa_stream_set_state_callback(data->stream, stream_state_callback, data);
 291
 292     if(device->IsCaptureDevice)
 293     {
 294         if(pa_stream_connect_record(data->stream, NULL, &data->attr, PA_STREAM_ADJUST_LATENCY) < 0)
 295         {
 296             AL_PRINT("Stream did not connect: %s\n",
 297                      pa_strerror(pa_context_errno(data->context)));
 298
 299             pa_stream_unref(data->stream);
 300             pa_threaded_mainloop_unlock(data->loop);
 301
 302             data->stream = NULL;
 303                         goto out4;
 304         }
 305     }
 306     else
 307     {
 308         pa_stream_set_write_callback(data->stream, stream_write_callback, device);
 309
 310         if(pa_stream_connect_playback(data->stream, NULL, &data->attr, PA_STREAM_ADJUST_LATENCY, NULL, NULL) < 0)
 311         {
 312             AL_PRINT("Stream did not connect: %s\n",
 313                      pa_strerror(pa_context_errno(data->context)));
 314
 315             pa_stream_unref(data->stream);
 316             pa_threaded_mainloop_unlock(data->loop);
 317
 318             data->stream = NULL;
 319                         goto out4;
 320         }
 321     }
 322
 323     while(pa_stream_get_state(data->stream) != PA_STREAM_READY)
 324     {
 325         if(!PA_STREAM_IS_GOOD(pa_stream_get_state(data->stream)))
 326         {
 327             pa_stream_unref(data->stream);
 328             pa_threaded_mainloop_unlock(data->loop);
 329
 330             data->stream = NULL;
 331                         goto out4;
 332         }
 333
 334         pa_threaded_mainloop_wait(data->loop);
 335         pa_threaded_mainloop_accept(data->loop);
 336     }
 337
 338     device->UpdateSize /= 4;
 339     pa_threaded_mainloop_unlock(data->loop);
 340
 341     return ALC_TRUE;
 342
 343 out4:
 344     pa_threaded_mainloop_lock(data->loop);
 345
 346     pa_context_disconnect(data->context);
 347     pa_context_unref(data->context);
 348
 349     pa_threaded_mainloop_unlock(data->loop);
 350 out3:
 351     pa_threaded_mainloop_stop(data->loop);
 352     pa_threaded_mainloop_free(data->loop);
 353 out2:
 354     device->ExtraData = NULL;
 355     device->szDeviceName = NULL;
 356     DestroyRingBuffer(data->ring);
 357
 358     pa_xfree(data);
 359     return ALC_FALSE;
 360 } //}}}
 361
 362 static void pulse_close(ALCdevice *device) //{{{
 363 {
 364     pulse_data *data = device->ExtraData;
 365
 366     pa_threaded_mainloop_lock(data->loop);
 367
 368     pa_stream_disconnect(data->stream);
 369     pa_stream_unref(data->stream);
 370
 371     pa_context_disconnect(data->context);
 372     pa_context_unref(data->context);
 373
 374     pa_threaded_mainloop_unlock(data->loop);
 375
 376     pa_threaded_mainloop_stop(data->loop);
 377     pa_threaded_mainloop_free(data->loop);
 378
 379     device->ExtraData = NULL;
 380     device->szDeviceName = NULL;
 381     DestroyRingBuffer(data->ring);
 382
 383     pa_xfree(data);
 384 } //}}}
 385 //}}}
 386
 387 // OpenAL {{{
 388 static ALCboolean pulse_open_playback(ALCdevice *device, const ALCchar *device_name) //{{{
 389 {
 390     if(device_name)
 391     {
 392         if(strcmp(device_name, pulse_device) != 0)
 393             return ALC_FALSE;
 394     }
 395
 396     return pulse_open(device, pulse_device, device->Format, 0, device->Frequency);
 397 } //}}}
 398
 399 static void pulse_close_playback(ALCdevice *device) //{{{
 400 {
 401     pulse_close(device);
 402 } //}}}
 403
 404 static ALCboolean pulse_open_capture(ALCdevice *device, const ALCchar *device_name, ALCuint frequency, ALCenum format, ALCsizei samples) //{{{
 405 {
 406     if(device_name)
 407     {
 408         if(strcmp(device_name, pulse_capture_device) != 0)
 409             return ALC_FALSE;
 410     }
 411
 412     return pulse_open(device, pulse_capture_device, format, samples, frequency);
 413 } //}}}
 414
 415 static void pulse_close_capture(ALCdevice *device) //{{{
 416 {
 417     pulse_close(device);
 418 } //}}}
 419
 420 static void pulse_start_capture(ALCdevice *device) //{{{
 421 {
 422     pulse_data *data = device->ExtraData;
 423
 424     pa_threaded_mainloop_lock(data->loop);
 425     pa_stream_set_read_callback(data->stream, stream_read_callback, device);
 426     pa_threaded_mainloop_unlock(data->loop);
 427 } //}}}
 428
 429 static void pulse_stop_capture(ALCdevice *device) //{{{
 430 {
 431     pulse_data *data = device->ExtraData;
 432
 433     pa_threaded_mainloop_lock(data->loop);
 434     pa_stream_set_read_callback(data->stream, NULL, NULL);
 435     pa_threaded_mainloop_unlock(data->loop);
 436 } //}}}
 437
 438 static void pulse_capture_samples(ALCdevice *device, ALCvoid *buffer, ALCuint samples) //{{{
 439 {
 440     pulse_data *data = device->ExtraData;
 441     ALCuint available = RingBufferSize(data->ring);
 442
 443     if(available < samples)
 444         SetALCError(ALC_INVALID_VALUE);
 445     else
 446         ReadRingBuffer(data->ring, buffer, samples);
 447 } //}}}
 448
 449 static ALCuint pulse_available_samples(ALCdevice *device) //{{{
 450 {
 451     pulse_data *data = device->ExtraData;
 452     return RingBufferSize(data->ring);
 453 } //}}}
 454
 455 BackendFuncs pulse_funcs = { //{{{
 456     pulse_open_playback,
 457     pulse_close_playback,
 458     pulse_open_capture,
 459     pulse_close_capture,
 460     pulse_start_capture,
 461     pulse_stop_capture,
 462     pulse_capture_samples,
 463     pulse_available_samples
 464 }; //}}}
 465
 466 void alc_pulse_init(BackendFuncs *func_list) //{{{
 467 {
 468     *func_list = pulse_funcs;
 469
 470     pulse_device = AppendDeviceList("PulseAudio Software");
 471     AppendAllDeviceList(pulse_device);
 472
 473     pulse_capture_device = AppendCaptureDeviceList("PulseAudio Capture");
 474 } //}}}
 475 //}}}