git.sesse.net Git - vlc/blob - modules/audio_output/pulse.c

   1 /*****************************************************************************
   2  * pulse.c : Pulseaudio output plugin for vlc
   3  *****************************************************************************
   4  * Copyright (C) 2008 the VideoLAN team
   5  *
   6  * Authors: Martin Hamrle <hamrle @ post . cz>
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  21  *****************************************************************************/
  22
  23 /*****************************************************************************
  24  * Preamble
  25  *****************************************************************************/
  26 #ifdef HAVE_CONFIG_H
  27 # include "config.h"
  28 #endif
  29
  30 #include <vlc_common.h>
  31 #include <vlc_plugin.h>
  32
  33 #include <vlc_aout.h>
  34
  35 #include <pulse/pulseaudio.h>
  36
  37 #include <assert.h>
  38
  39 /*****************************************************************************
  40  * aout_sys_t: Pulseaudio output method descriptor
  41  *****************************************************************************
  42  * This structure is part of the audio output thread descriptor.
  43  * It describes the specific properties of an audio device.
  44  *****************************************************************************/
  45 struct aout_sys_t
  46 {
  47     /** PulseAudio playback stream object */
  48     struct pa_stream *stream;
  49
  50     /** PulseAudio connection context */
  51     struct pa_context *context;
  52
  53     /** Main event loop object */
  54     struct pa_threaded_mainloop *mainloop;
  55
  56     int started;
  57     size_t buffer_size;
  58     mtime_t start_date;
  59 };
  60
  61 #define    PULSE_CLIENT_NAME N_("VLC media player")
  62
  63 #if 0
  64 #define PULSE_DEBUG( ...) \
  65     msg_Dbg( p_aout, __VA_ARGS__ )
  66 #else
  67 #define PULSE_DEBUG( ...) \
  68     (void) 0
  69 #endif
  70
  71
  72 #define CHECK_DEAD_GOTO(label) do { \
  73 if (!p_sys->context || pa_context_get_state(p_sys->context) != PA_CONTEXT_READY || \
  74     !p_sys->stream || pa_stream_get_state(p_sys->stream) != PA_STREAM_READY) { \
  75         msg_Err(p_aout, "Connection died: %s", p_sys->context ? pa_strerror(pa_context_errno(p_sys->context)) : "NULL"); \
  76         goto label; \
  77     }  \
  78 } while(0);
  79
  80 /*****************************************************************************
  81  * Local prototypes
  82  *****************************************************************************/
  83 static int  Open        ( vlc_object_t * );
  84 static void Close       ( vlc_object_t * );
  85 static void Play        ( aout_instance_t * );
  86
  87 static void context_state_cb(pa_context *c, void *userdata);
  88 static void stream_state_cb(pa_stream *s, void * userdata);
  89 static void stream_request_cb(pa_stream *s, size_t length, void *userdata);
  90 static void stream_latency_update_cb(pa_stream *s, void *userdata);
  91 static void success_cb(pa_stream *s, int sucess, void *userdata);
  92 static void uninit(aout_instance_t *p_aout);
  93
  94 /*****************************************************************************
  95  * Module descriptor
  96  *****************************************************************************/
  97 vlc_module_begin ()
  98     set_shortname( "Pulse Audio" )
  99     set_description( N_("Pulseaudio audio output") )
 100     set_capability( "audio output", 40 )
 101     set_category( CAT_AUDIO )
 102     set_subcategory( SUBCAT_AUDIO_AOUT )
 103     add_shortcut( "pulseaudio" )
 104     add_shortcut( "pa" )
 105     set_callbacks( Open, Close )
 106     linked_with_a_crap_library_which_uses_atexit()
 107 vlc_module_end ()
 108
 109 /*****************************************************************************
 110  * Open: open the audio device
 111  *****************************************************************************/
 112 static int Open ( vlc_object_t *p_this )
 113 {
 114     aout_instance_t *p_aout = (aout_instance_t *)p_this;
 115     struct aout_sys_t * p_sys;
 116     struct pa_sample_spec ss;
 117     const struct pa_buffer_attr *buffer_attr;
 118     struct pa_buffer_attr a;
 119     struct pa_channel_map map;
 120
 121     /* Allocate structures */
 122     p_aout->output.p_sys = p_sys = calloc( 1, sizeof( aout_sys_t ) );
 123     if( p_sys == NULL )
 124         return VLC_ENOMEM;
 125
 126     PULSE_DEBUG( "Pulse start initialization");
 127
 128     ss.channels = aout_FormatNbChannels( &p_aout->output.output ); /* Get the input stream channel count */
 129
 130     /* Setup the pulse audio stream based on the input stream count */
 131     switch(ss.channels)
 132     {
 133         case 8:
 134             p_aout->output.output.i_physical_channels
 135                 = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER
 136                 | AOUT_CHAN_MIDDLELEFT | AOUT_CHAN_MIDDLERIGHT
 137                 | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT
 138                 | AOUT_CHAN_LFE;
 139             break;
 140         case 6:
 141             p_aout->output.output.i_physical_channels
 142                 = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER
 143                 | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT
 144                 | AOUT_CHAN_LFE;
 145             break;
 146
 147         case 4:
 148             p_aout->output.output.i_physical_channels
 149                 = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT
 150                 | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT;
 151             break;
 152
 153         case 2:
 154             p_aout->output.output.i_physical_channels
 155                 = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT;
 156             break;
 157
 158         case 1:
 159             p_aout->output.output.i_physical_channels = AOUT_CHAN_CENTER;
 160             break;
 161
 162         default:
 163             msg_Err(p_aout,"Invalid number of channels");
 164         goto fail;
 165     }
 166
 167     /* Add a quick command line info message */
 168     msg_Info(p_aout, "No. of Audio Channels: %d", ss.channels);
 169
 170     ss.rate = p_aout->output.output.i_rate;
 171     ss.format = PA_SAMPLE_FLOAT32NE;
 172     p_aout->output.output.i_format = VLC_FOURCC('f','l','3','2');
 173
 174     if (!pa_sample_spec_valid(&ss)) {
 175         msg_Err(p_aout,"Invalid sample spec");
 176         goto fail;
 177     }
 178
 179     a.maxlength = pa_bytes_per_second(&ss)/4/pa_frame_size(&ss);
 180     a.tlength = a.maxlength*9/10;
 181     a.prebuf = a.tlength/2;
 182     a.minreq = a.tlength/10;
 183
 184     a.maxlength *= pa_frame_size(&ss);
 185     a.tlength *= pa_frame_size(&ss);
 186     a.prebuf *= pa_frame_size(&ss);
 187     a.minreq *= pa_frame_size(&ss);
 188
 189     p_sys->buffer_size = a.minreq;
 190
 191     /* Initialise the speaker map setup above */
 192     pa_channel_map_init_auto(&map, ss.channels, PA_CHANNEL_MAP_ALSA);
 193
 194     if (!(p_sys->mainloop = pa_threaded_mainloop_new())) {
 195         msg_Err(p_aout, "Failed to allocate main loop");
 196         goto fail;
 197     }
 198
 199     if (!(p_sys->context = pa_context_new(pa_threaded_mainloop_get_api(p_sys->mainloop), _( PULSE_CLIENT_NAME )))) {
 200         msg_Err(p_aout, "Failed to allocate context");
 201         goto fail;
 202     }
 203
 204     pa_context_set_state_callback(p_sys->context, context_state_cb, p_aout);
 205
 206     PULSE_DEBUG( "Pulse before context connect");
 207
 208     if (pa_context_connect(p_sys->context, NULL, 0, NULL) < 0) {
 209         msg_Err(p_aout, "Failed to connect to server: %s", pa_strerror(pa_context_errno(p_sys->context)));
 210         goto fail;
 211     }
 212
 213     PULSE_DEBUG( "Pulse after context connect");
 214
 215     pa_threaded_mainloop_lock(p_sys->mainloop);
 216
 217     if (pa_threaded_mainloop_start(p_sys->mainloop) < 0) {
 218         msg_Err(p_aout, "Failed to start main loop");
 219         goto unlock_and_fail;
 220     }
 221
 222     msg_Dbg(p_aout, "Pulse mainloop started");
 223
 224     /* Wait until the context is ready */
 225     pa_threaded_mainloop_wait(p_sys->mainloop);
 226
 227     if (pa_context_get_state(p_sys->context) != PA_CONTEXT_READY) {
 228         msg_Err(p_aout, "Failed to connect to server: %s", pa_strerror(pa_context_errno(p_sys->context)));
 229         goto unlock_and_fail;
 230     }
 231
 232     if (!(p_sys->stream = pa_stream_new(p_sys->context, "audio stream", &ss, &map))) {
 233         msg_Err(p_aout, "Failed to create stream: %s", pa_strerror(pa_context_errno(p_sys->context)));
 234         goto unlock_and_fail;
 235     }
 236
 237     PULSE_DEBUG( "Pulse after new stream");
 238
 239     pa_stream_set_state_callback(p_sys->stream, stream_state_cb, p_aout);
 240     pa_stream_set_write_callback(p_sys->stream, stream_request_cb, p_aout);
 241     pa_stream_set_latency_update_callback(p_sys->stream, stream_latency_update_cb, p_aout);
 242
 243     if (pa_stream_connect_playback(p_sys->stream, NULL, &a, PA_STREAM_INTERPOLATE_TIMING|PA_STREAM_AUTO_TIMING_UPDATE, NULL, NULL) < 0) {
 244         msg_Err(p_aout, "Failed to connect stream: %s", pa_strerror(pa_context_errno(p_sys->context)));
 245         goto unlock_and_fail;
 246     }
 247
 248      PULSE_DEBUG("Pulse stream connect");
 249
 250     /* Wait until the stream is ready */
 251     pa_threaded_mainloop_wait(p_sys->mainloop);
 252
 253     msg_Dbg(p_aout,"Pulse stream connected");
 254
 255     if (pa_stream_get_state(p_sys->stream) != PA_STREAM_READY) {
 256         msg_Err(p_aout, "Failed to connect to server: %s", pa_strerror(pa_context_errno(p_sys->context)));
 257         goto unlock_and_fail;
 258     }
 259
 260
 261     PULSE_DEBUG("Pulse after stream get status");
 262
 263     pa_threaded_mainloop_unlock(p_sys->mainloop);
 264
 265     buffer_attr = pa_stream_get_buffer_attr(p_sys->stream);
 266     p_aout->output.i_nb_samples = buffer_attr->minreq / pa_frame_size(&ss);
 267     p_aout->output.pf_play = Play;
 268     aout_VolumeSoftInit(p_aout);
 269     msg_Dbg(p_aout, "Pulse initialized successfully");
 270     {
 271         char cmt[PA_CHANNEL_MAP_SNPRINT_MAX], sst[PA_SAMPLE_SPEC_SNPRINT_MAX];
 272
 273         msg_Dbg(p_aout, "Buffer metrics: maxlength=%u, tlength=%u, prebuf=%u, minreq=%u", buffer_attr->maxlength, buffer_attr->tlength, buffer_attr->prebuf, buffer_attr->minreq);
 274         msg_Dbg(p_aout, "Using sample spec '%s', channel map '%s'.",
 275                 pa_sample_spec_snprint(sst, sizeof(sst), pa_stream_get_sample_spec(p_sys->stream)),
 276                 pa_channel_map_snprint(cmt, sizeof(cmt), pa_stream_get_channel_map(p_sys->stream)));
 277
 278             msg_Dbg(p_aout, "Connected to device %s (%u, %ssuspended).",
 279                         pa_stream_get_device_name(p_sys->stream),
 280                         pa_stream_get_device_index(p_sys->stream),
 281                         pa_stream_is_suspended(p_sys->stream) ? "" : "not ");
 282     }
 283
 284     return VLC_SUCCESS;
 285
 286 unlock_and_fail:
 287     msg_Dbg(p_aout, "Pulse initialization unlock and fail");
 288
 289     if (p_sys->mainloop)
 290         pa_threaded_mainloop_unlock(p_sys->mainloop);
 291 fail:
 292     msg_Err(p_aout, "Pulse initialization failed");
 293     uninit(p_aout);
 294     return VLC_EGENERIC;
 295 }
 296
 297 /*****************************************************************************
 298  * Play: play a sound samples buffer
 299  *****************************************************************************/
 300 static void Play( aout_instance_t * p_aout )
 301 {
 302     struct aout_sys_t * p_sys = (struct aout_sys_t *) p_aout->output.p_sys;
 303
 304     pa_operation *o;
 305
 306     if(!p_sys->started){
 307         msg_Dbg(p_aout, "Pulse stream started");
 308         p_sys->start_date =
 309             aout_FifoFirstDate( p_aout, &p_aout->output.fifo );
 310         p_sys->started = 1;
 311
 312         pa_threaded_mainloop_lock(p_sys->mainloop);
 313         if((o = pa_stream_flush(p_sys->stream, success_cb, p_aout))){
 314             pa_operation_unref(o);
 315         }
 316         pa_threaded_mainloop_unlock(p_sys->mainloop);
 317
 318         pa_threaded_mainloop_signal(p_sys->mainloop, 0);
 319     }
 320 }
 321
 322 /*****************************************************************************
 323  * Close: close the audio device
 324  *****************************************************************************/
 325 static void Close ( vlc_object_t *p_this )
 326 {
 327     aout_instance_t *p_aout = (aout_instance_t *)p_this;
 328     struct aout_sys_t * p_sys = p_aout->output.p_sys;
 329
 330     msg_Dbg(p_aout, "Pulse Close");
 331
 332     if(p_sys->stream){
 333         pa_operation *o;
 334         pa_threaded_mainloop_lock(p_sys->mainloop);
 335         pa_stream_set_write_callback(p_sys->stream, NULL, NULL);
 336
 337         if((o = pa_stream_drain(p_sys->stream, success_cb, p_aout))){
 338             while (pa_operation_get_state(o) != PA_OPERATION_DONE) {
 339                 CHECK_DEAD_GOTO(fail);
 340                 pa_threaded_mainloop_wait(p_sys->mainloop);
 341             }
 342
 343         fail:
 344
 345             pa_operation_unref(o);
 346         }
 347
 348         pa_threaded_mainloop_unlock(p_sys->mainloop);
 349     }
 350     uninit(p_aout);
 351 }
 352
 353 static void uninit(aout_instance_t *p_aout){
 354     struct aout_sys_t * p_sys = p_aout->output.p_sys;
 355
 356     if (p_sys->mainloop)
 357         pa_threaded_mainloop_stop(p_sys->mainloop);
 358
 359     if (p_sys->stream) {
 360         pa_stream_disconnect(p_sys->stream);
 361         pa_stream_unref(p_sys->stream);
 362         p_sys->stream = NULL;
 363     }
 364
 365     if (p_sys->context) {
 366         pa_context_disconnect(p_sys->context);
 367         pa_context_unref(p_sys->context);
 368         p_sys->context = NULL;
 369     }
 370
 371     if (p_sys->mainloop) {
 372         pa_threaded_mainloop_free(p_sys->mainloop);
 373         p_sys->mainloop = NULL;
 374     }
 375
 376     free(p_sys);
 377     p_aout->output.p_sys = NULL;
 378 }
 379
 380 static void context_state_cb(pa_context *c, void *userdata) {
 381     aout_instance_t *p_aout = (aout_instance_t *)userdata;
 382     struct aout_sys_t * p_sys = (struct aout_sys_t *) p_aout->output.p_sys;
 383
 384     assert(c);
 385
 386     PULSE_DEBUG( "Pulse context state changed");
 387
 388     switch (pa_context_get_state(c)) {
 389         case PA_CONTEXT_READY:
 390         case PA_CONTEXT_TERMINATED:
 391         case PA_CONTEXT_FAILED:
 392         PULSE_DEBUG( "Pulse context state changed signal");
 393             pa_threaded_mainloop_signal(p_sys->mainloop, 0);
 394             break;
 395
 396         case PA_CONTEXT_UNCONNECTED:
 397         case PA_CONTEXT_CONNECTING:
 398         case PA_CONTEXT_AUTHORIZING:
 399         case PA_CONTEXT_SETTING_NAME:
 400         PULSE_DEBUG( "Pulse context state changed no signal");
 401             break;
 402     }
 403 }
 404
 405 static void stream_state_cb(pa_stream *s, void * userdata) {
 406     aout_instance_t *p_aout = (aout_instance_t *)userdata;
 407     struct aout_sys_t * p_sys = (struct aout_sys_t *) p_aout->output.p_sys;
 408
 409     assert(s);
 410
 411     PULSE_DEBUG( "Pulse stream state changed");
 412
 413     switch (pa_stream_get_state(s)) {
 414
 415         case PA_STREAM_READY:
 416         case PA_STREAM_FAILED:
 417         case PA_STREAM_TERMINATED:
 418             pa_threaded_mainloop_signal(p_sys->mainloop, 0);
 419             break;
 420
 421         case PA_STREAM_UNCONNECTED:
 422         case PA_STREAM_CREATING:
 423             break;
 424     }
 425 }
 426
 427 static void stream_request_cb(pa_stream *s, size_t length, void *userdata) {
 428     aout_instance_t *p_aout = (aout_instance_t *)userdata;
 429     struct aout_sys_t * p_sys = (struct aout_sys_t *) p_aout->output.p_sys;
 430     mtime_t next_date;
 431
 432     assert(s);
 433     assert(p_sys);
 434
 435     size_t buffer_size = p_sys->buffer_size;
 436
 437     PULSE_DEBUG( "Pulse stream request %d", length);
 438
 439     do{
 440         aout_buffer_t *   p_buffer = NULL;
 441         if(p_sys->started){
 442             pa_usec_t latency;
 443             int negative;
 444             if(pa_stream_get_latency(p_sys->stream, &latency, &negative)<0){
 445                 if (pa_context_errno(p_sys->context) != PA_ERR_NODATA) {
 446                     msg_Err(p_aout, "pa_stream_get_latency() failed: %s", pa_strerror(pa_context_errno(p_sys->context)));
 447                 }
 448                 latency = 0;
 449
 450             }
 451             PULSE_DEBUG( "Pulse stream request latency=%"PRId64"", latency);
 452             next_date = mdate() + latency;
 453
 454
 455             if(p_sys->start_date < next_date + AOUT_PTS_TOLERANCE ){
 456     /*
 457                   vlc_mutex_lock( &p_aout->output_fifo_lock );
 458                 p_buffer = aout_FifoPop( p_aout, &p_aout->output.fifo );
 459                 vlc_mutex_unlock( &p_aout->output_fifo_lock );
 460     */
 461                 p_buffer = aout_OutputNextBuffer( p_aout, next_date, 0);
 462             }
 463         }
 464
 465         if ( p_buffer != NULL )
 466         {
 467             PULSE_DEBUG( "Pulse stream request write buffer %d", p_buffer->i_nb_bytes);
 468             pa_stream_write(p_sys->stream, p_buffer->p_buffer, p_buffer->i_nb_bytes, NULL, 0, PA_SEEK_RELATIVE);
 469             length -= p_buffer->i_nb_bytes;
 470             aout_BufferFree( p_buffer );
 471         }
 472         else
 473         {
 474             PULSE_DEBUG( "Pulse stream request write zeroes");
 475             void *data = pa_xmalloc(buffer_size);
 476             bzero(data, buffer_size);
 477             pa_stream_write(p_sys->stream, data, buffer_size, pa_xfree, 0, PA_SEEK_RELATIVE);
 478             length -= buffer_size;
 479         }
 480     }while(length > buffer_size);
 481
 482     pa_threaded_mainloop_signal(p_sys->mainloop, 0);
 483 }
 484
 485 static void stream_latency_update_cb(pa_stream *s, void *userdata) {
 486     aout_instance_t *p_aout = (aout_instance_t *)userdata;
 487     struct aout_sys_t * p_sys = (struct aout_sys_t *) p_aout->output.p_sys;
 488
 489     assert(s);
 490
 491     PULSE_DEBUG( "Pulse stream latency update");
 492
 493     pa_threaded_mainloop_signal(p_sys->mainloop, 0);
 494 }
 495
 496 static void success_cb(pa_stream *s, int sucess, void *userdata)
 497 {
 498     aout_instance_t *p_aout = (aout_instance_t *)userdata;
 499     struct aout_sys_t * p_sys = (struct aout_sys_t *) p_aout->output.p_sys;
 500
 501     VLC_UNUSED(sucess);
 502
 503     assert(s);
 504
 505     pa_threaded_mainloop_signal(p_sys->mainloop, 0);
 506 }
 507
 508 #undef PULSE_DEBUG